external/srs
1
0
Fork 0
mirror of https://github.com/ossrs/srs.git synced 2025-03-09 15:49:59 +00:00
Code Issues Releases Wiki Activity

json objects support dumps to string.

Browse source
This commit is contained in:
winlin 2015-09-19 12:27:31 +08:00
parent b78781707e
commit 3f7e69b617
14 changed files with 729 additions and 761 deletions
Download patch file Download diff file Expand all files Collapse all files

1
README.md
View file

@ -344,6 +344,7 @@ Remark:
## History
* v3.0, 2015-09-19, json objects support dumps to string.
* v3.0, 2015-09-14, fix [#459][bug #459], support dvr raw api. 3.0.4
* v3.0, 2015-09-14, fix [#459][bug #459], dvr support apply filter for ng-control dvr module.
* v3.0, 2015-09-14, fix [#319][bug #319], http raw api support update global and vhost. 3.0.3

218
trunk/src/app/srs_app_config.cpp
View file

@ -75,7 +75,7 @@ using namespace _srs_internal;
* @param dir the transcode or ingest config directive.
* @param engine the amf0 object to dumps to.
*/
int srs_config_dumps_engine(SrsConfDirective* dir, SrsAmf0Object* engine);
int srs_config_dumps_engine(SrsConfDirective* dir, SrsJsonObject* engine);
/**
* whether the two vector actual equals, for instance,
@ -511,21 +511,21 @@ int srs_config_transform_vhost(SrsConfDirective* root)
return ret;
}
int srs_config_dumps_engine(SrsConfDirective* dir, SrsAmf0Object* engine)
int srs_config_dumps_engine(SrsConfDirective* dir, SrsJsonObject* engine)
{
int ret = ERROR_SUCCESS;
SrsConfDirective* conf = NULL;
engine->set("id", dir->dumps_arg0_to_str());
engine->set("enabled", SrsAmf0Any::boolean(_srs_config->get_engine_enabled(dir)));
engine->set("enabled", SrsJsonAny::boolean(_srs_config->get_engine_enabled(dir)));
if ((conf = dir->get("iformat")) != NULL) {
engine->set("iformat", conf->dumps_arg0_to_str());
}
if ((conf = dir->get("vfilter")) != NULL) {
SrsAmf0Object* vfilter = SrsAmf0Any::object();
SrsJsonObject* vfilter = SrsJsonAny::object();
engine->set("vfilter", vfilter);
for (int i = 0; i < (int)conf->directives.size(); i++) {
@ -567,7 +567,7 @@ int srs_config_dumps_engine(SrsConfDirective* dir, SrsAmf0Object* engine)
}
if ((conf = dir->get("vparams")) != NULL) {
SrsAmf0Object* vparams = SrsAmf0Any::object();
SrsJsonObject* vparams = SrsJsonAny::object();
engine->set("vparams", vparams);
for (int i = 0; i < (int)conf->directives.size(); i++) {
@ -593,7 +593,7 @@ int srs_config_dumps_engine(SrsConfDirective* dir, SrsAmf0Object* engine)
}
if ((conf = dir->get("aparams")) != NULL) {
SrsAmf0Object* aparams = SrsAmf0Any::object();
SrsJsonObject* aparams = SrsJsonAny::object();
engine->set("aparams", aparams);
for (int i = 0; i < (int)conf->directives.size(); i++) {
@ -868,29 +868,29 @@ int SrsConfDirective::persistence(SrsFileWriter* writer, int level)
return ret;
}
SrsAmf0StrictArray* SrsConfDirective::dumps_args()
SrsJsonArray* SrsConfDirective::dumps_args()
{
SrsAmf0StrictArray* arr = SrsAmf0Any::strict_array();
SrsJsonArray* arr = SrsJsonAny::array();
for (int i = 0; i < (int)args.size(); i++) {
string arg = args.at(i);
arr->append(SrsAmf0Any::str(arg.c_str()));
arr->append(SrsJsonAny::str(arg.c_str()));
}
return arr;
}
SrsAmf0Any* SrsConfDirective::dumps_arg0_to_str()
SrsJsonAny* SrsConfDirective::dumps_arg0_to_str()
{
return SrsAmf0Any::str(arg0().c_str());
return SrsJsonAny::str(arg0().c_str());
}
SrsAmf0Any* SrsConfDirective::dumps_arg0_to_number()
SrsJsonAny* SrsConfDirective::dumps_arg0_to_number()
{
return SrsAmf0Any::number(::atof(arg0().c_str()));
return SrsJsonAny::number(::atof(arg0().c_str()));
}
SrsAmf0Any* SrsConfDirective::dumps_arg0_to_boolean()
SrsJsonAny* SrsConfDirective::dumps_arg0_to_boolean()
{
return SrsAmf0Any::boolean(arg0() == "on");
return SrsJsonAny::boolean(arg0() == "on");
}
// see: ngx_conf_parse
@ -1994,7 +1994,7 @@ int SrsConfig::persistence()
return ret;
}
int SrsConfig::minimal_to_json(SrsAmf0Object* obj)
int SrsConfig::minimal_to_json(SrsJsonObject* obj)
{
int ret = ERROR_SUCCESS;
@ -2012,7 +2012,7 @@ int SrsConfig::minimal_to_json(SrsAmf0Object* obj)
return ret;
}
int SrsConfig::global_to_json(SrsAmf0Object* obj)
int SrsConfig::global_to_json(SrsJsonObject* obj)
{
int ret = ERROR_SUCCESS;
@ -2045,7 +2045,7 @@ int SrsConfig::global_to_json(SrsAmf0Object* obj)
} else if (dir->name == "pithy_print_ms") {
obj->set(dir->name, dir->dumps_arg0_to_number());
} else if (dir->name == "heartbeat") {
SrsAmf0Object* sobj = SrsAmf0Any::object();
SrsJsonObject* sobj = SrsJsonAny::object();
for (int j = 0; j < (int)dir->directives.size(); j++) {
SrsConfDirective* sdir = dir->directives.at(j);
if (sdir->name == "enabled") {
@ -2062,7 +2062,7 @@ int SrsConfig::global_to_json(SrsAmf0Object* obj)
}
obj->set(dir->name, sobj);
} else if (dir->name == "stats") {
SrsAmf0Object* sobj = SrsAmf0Any::object();
SrsJsonObject* sobj = SrsJsonAny::object();
for (int j = 0; j < (int)dir->directives.size(); j++) {
SrsConfDirective* sdir = dir->directives.at(j);
if (sdir->name == "network") {
@ -2073,7 +2073,7 @@ int SrsConfig::global_to_json(SrsAmf0Object* obj)
}
obj->set(dir->name, sobj);
} else if (dir->name == "http_api") {
SrsAmf0Object* sobj = SrsAmf0Any::object();
SrsJsonObject* sobj = SrsJsonAny::object();
for (int j = 0; j < (int)dir->directives.size(); j++) {
SrsConfDirective* sdir = dir->directives.at(j);
if (sdir->name == "enabled") {
@ -2083,7 +2083,7 @@ int SrsConfig::global_to_json(SrsAmf0Object* obj)
} else if (sdir->name == "crossdomain") {
sobj->set(sdir->name, sdir->dumps_arg0_to_boolean());
} else if (sdir->name == "raw_api") {
SrsAmf0Object* ssobj = SrsAmf0Any::object();
SrsJsonObject* ssobj = SrsJsonAny::object();
sobj->set(sdir->name, ssobj);
for (int j = 0; j < (int)sdir->directives.size(); j++) {
@ -2102,7 +2102,7 @@ int SrsConfig::global_to_json(SrsAmf0Object* obj)
}
obj->set(dir->name, sobj);
} else if (dir->name == "http_server") {
SrsAmf0Object* sobj = SrsAmf0Any::object();
SrsJsonObject* sobj = SrsJsonAny::object();
for (int j = 0; j < (int)dir->directives.size(); j++) {
SrsConfDirective* sdir = dir->directives.at(j);
if (sdir->name == "enabled") {
@ -2115,7 +2115,7 @@ int SrsConfig::global_to_json(SrsAmf0Object* obj)
}
obj->set(dir->name, sobj);
} else if (dir->name == "stream_caster") {
SrsAmf0Object* sobj = SrsAmf0Any::object();
SrsJsonObject* sobj = SrsJsonAny::object();
for (int j = 0; j < (int)dir->directives.size(); j++) {
SrsConfDirective* sdir = dir->directives.at(j);
if (sdir->name == "enabled") {
@ -2138,7 +2138,7 @@ int SrsConfig::global_to_json(SrsAmf0Object* obj)
}
}
SrsAmf0Object* sobjs = SrsAmf0Any::object();
SrsJsonObject* sobjs = SrsJsonAny::object();
int nb_vhosts = 0;
SrsStatistic* stat = SrsStatistic::instance();
@ -2149,73 +2149,73 @@ int SrsConfig::global_to_json(SrsAmf0Object* obj)
}
nb_vhosts++;
SrsAmf0Object* sobj = SrsAmf0Any::object();
SrsJsonObject* sobj = SrsJsonAny::object();
sobjs->set(dir->arg0(), sobj);
SrsStatisticVhost* svhost = stat->find_vhost(dir->arg0());
sobj->set("id", SrsAmf0Any::number(svhost? (double)svhost->id : 0));
sobj->set("id", SrsJsonAny::number(svhost? (double)svhost->id : 0));
sobj->set("name", dir->dumps_arg0_to_str());
sobj->set("enabled", SrsAmf0Any::boolean(get_vhost_enabled(dir->arg0())));
sobj->set("enabled", SrsJsonAny::boolean(get_vhost_enabled(dir->arg0())));
if (get_dvr_enabled(dir->arg0())) {
sobj->set("dvr", SrsAmf0Any::boolean(true));
sobj->set("dvr", SrsJsonAny::boolean(true));
}
if (get_vhost_http_enabled(dir->arg0())) {
sobj->set("http_static", SrsAmf0Any::boolean(true));
sobj->set("http_static", SrsJsonAny::boolean(true));
}
if (get_vhost_http_remux_enabled(dir->arg0())) {
sobj->set("http_remux", SrsAmf0Any::boolean(true));
sobj->set("http_remux", SrsJsonAny::boolean(true));
}
if (get_hls_enabled(dir->arg0())) {
sobj->set("hls", SrsAmf0Any::boolean(true));
sobj->set("hls", SrsJsonAny::boolean(true));
}
if (get_hds_enabled(dir->arg0())) {
sobj->set("hds", SrsAmf0Any::boolean(true));
sobj->set("hds", SrsJsonAny::boolean(true));
}
if (get_vhost_http_hooks(dir->arg0())) {
sobj->set("http_hooks", SrsAmf0Any::boolean(true));
sobj->set("http_hooks", SrsJsonAny::boolean(true));
}
if (get_exec_enabled(dir->arg0())) {
sobj->set("exec", SrsAmf0Any::boolean(true));
sobj->set("exec", SrsJsonAny::boolean(true));
}
if (get_bw_check_enabled(dir->arg0())) {
sobj->set("bandcheck", SrsAmf0Any::boolean(true));
sobj->set("bandcheck", SrsJsonAny::boolean(true));
}
if (!get_vhost_is_edge(dir->arg0())) {
sobj->set("origin", SrsAmf0Any::boolean(true));
sobj->set("origin", SrsJsonAny::boolean(true));
}
if (get_forward_enabled(dir->arg0())) {
sobj->set("forward", SrsAmf0Any::boolean(true));
sobj->set("forward", SrsJsonAny::boolean(true));
}
if (get_security_enabled(dir->arg0())) {
sobj->set("security", SrsAmf0Any::boolean(true));
sobj->set("security", SrsJsonAny::boolean(true));
}
if (get_refer_enabled(dir->arg0())) {
sobj->set("refer", SrsAmf0Any::boolean(true));
sobj->set("refer", SrsJsonAny::boolean(true));
}
if (get_mr_enabled(dir->arg0())) {
sobj->set("mr", SrsAmf0Any::boolean(true));
sobj->set("mr", SrsJsonAny::boolean(true));
}
if (get_realtime_enabled(dir->arg0())) {
sobj->set("min_latency", SrsAmf0Any::boolean(true));
sobj->set("min_latency", SrsJsonAny::boolean(true));
}
if (get_gop_cache(dir->arg0())) {
sobj->set("gop_cache", SrsAmf0Any::boolean(true));
sobj->set("gop_cache", SrsJsonAny::boolean(true));
}
if (get_tcp_nodelay(dir->arg0())) {
sobj->set("tcp_nodelay", SrsAmf0Any::boolean(true));
sobj->set("tcp_nodelay", SrsJsonAny::boolean(true));
}
if (get_mix_correct(dir->arg0())) {
sobj->set("mix_correct", SrsAmf0Any::boolean(true));
sobj->set("mix_correct", SrsJsonAny::boolean(true));
}
if (get_time_jitter(dir->arg0()) != SrsRtmpJitterAlgorithmOFF) {
sobj->set("time_jitter", SrsAmf0Any::boolean(true));
sobj->set("time_jitter", SrsJsonAny::boolean(true));
}
if (get_atc(dir->arg0())) {
sobj->set("atc", SrsAmf0Any::boolean(true));
sobj->set("atc", SrsJsonAny::boolean(true));
}
bool has_transcode = false;
@ -2242,7 +2242,7 @@ int SrsConfig::global_to_json(SrsAmf0Object* obj)
}
}
if (has_transcode) {
sobj->set("transcode", SrsAmf0Any::boolean(has_transcode));
sobj->set("transcode", SrsJsonAny::boolean(has_transcode));
}
bool has_ingest = false;
@ -2258,17 +2258,17 @@ int SrsConfig::global_to_json(SrsAmf0Object* obj)
}
}
if (has_ingest) {
sobj->set("ingest", SrsAmf0Any::boolean(has_ingest));
sobj->set("ingest", SrsJsonAny::boolean(has_ingest));
}
}
obj->set("nb_vhosts", SrsAmf0Any::number(nb_vhosts));
obj->set("nb_vhosts", SrsJsonAny::number(nb_vhosts));
obj->set("vhosts", sobjs);
return ret;
}
int SrsConfig::vhost_to_json(SrsConfDirective* vhost, SrsAmf0Object* obj)
int SrsConfig::vhost_to_json(SrsConfDirective* vhost, SrsJsonObject* obj)
{
int ret = ERROR_SUCCESS;
@ -2278,10 +2278,10 @@ int SrsConfig::vhost_to_json(SrsConfDirective* vhost, SrsAmf0Object* obj)
SrsStatistic* stat = SrsStatistic::instance();
SrsStatisticVhost* svhost = stat->find_vhost(vhost->arg0());
obj->set("id", SrsAmf0Any::number(svhost? (double)svhost->id : 0));
obj->set("id", SrsJsonAny::number(svhost? (double)svhost->id : 0));
obj->set("name", vhost->dumps_arg0_to_str());
obj->set("enabled", SrsAmf0Any::boolean(get_vhost_enabled(vhost)));
obj->set("enabled", SrsJsonAny::boolean(get_vhost_enabled(vhost)));
// vhost scope configs.
if ((dir = vhost->get("chunk_size")) != NULL) {
@ -2296,7 +2296,7 @@ int SrsConfig::vhost_to_json(SrsConfDirective* vhost, SrsAmf0Object* obj)
// cluster.
if ((dir = vhost->get("cluster")) != NULL) {
SrsAmf0Object* cluster = SrsAmf0Any::object();
SrsJsonObject* cluster = SrsJsonAny::object();
obj->set("cluster", cluster);
for (int i = 0; i < (int)dir->directives.size(); i++) {
@ -2318,10 +2318,10 @@ int SrsConfig::vhost_to_json(SrsConfDirective* vhost, SrsAmf0Object* obj)
// forward
if ((dir = vhost->get("forward")) != NULL) {
SrsAmf0Object* forward = SrsAmf0Any::object();
SrsJsonObject* forward = SrsJsonAny::object();
obj->set("forward", forward);
forward->set("enabled", SrsAmf0Any::boolean(get_forward_enabled(vhost->name)));
forward->set("enabled", SrsJsonAny::boolean(get_forward_enabled(vhost->name)));
for (int i = 0; i < (int)dir->directives.size(); i++) {
SrsConfDirective* sdir = dir->directives.at(i);
@ -2334,7 +2334,7 @@ int SrsConfig::vhost_to_json(SrsConfDirective* vhost, SrsAmf0Object* obj)
// play
if ((dir = vhost->get("play")) != NULL) {
SrsAmf0Object* play = SrsAmf0Any::object();
SrsJsonObject* play = SrsJsonAny::object();
obj->set("play", play);
for (int i = 0; i < (int)dir->directives.size(); i++) {
@ -2364,7 +2364,7 @@ int SrsConfig::vhost_to_json(SrsConfDirective* vhost, SrsAmf0Object* obj)
// publish
if ((dir = vhost->get("publish")) != NULL) {
SrsAmf0Object* publish = SrsAmf0Any::object();
SrsJsonObject* publish = SrsJsonAny::object();
obj->set("publish", publish);
for (int i = 0; i < (int)dir->directives.size(); i++) {
@ -2384,10 +2384,10 @@ int SrsConfig::vhost_to_json(SrsConfDirective* vhost, SrsAmf0Object* obj)
// refer
if ((dir = vhost->get("refer")) != NULL) {
SrsAmf0Object* refer = SrsAmf0Any::object();
SrsJsonObject* refer = SrsJsonAny::object();
obj->set("refer", refer);
refer->set("enabled", SrsAmf0Any::boolean(get_refer_enabled(vhost->name)));
refer->set("enabled", SrsJsonAny::boolean(get_refer_enabled(vhost->name)));
for (int i = 0; i < (int)dir->directives.size(); i++) {
SrsConfDirective* sdir = dir->directives.at(i);
@ -2404,10 +2404,10 @@ int SrsConfig::vhost_to_json(SrsConfDirective* vhost, SrsAmf0Object* obj)
// bandcheck
if ((dir = vhost->get("bandcheck")) != NULL) {
SrsAmf0Object* bandcheck = SrsAmf0Any::object();
SrsJsonObject* bandcheck = SrsJsonAny::object();
obj->set("bandcheck", bandcheck);
bandcheck->set("enabled", SrsAmf0Any::boolean(get_bw_check_enabled(vhost->name)));
bandcheck->set("enabled", SrsJsonAny::boolean(get_bw_check_enabled(vhost->name)));
for (int i = 0; i < (int)dir->directives.size(); i++) {
SrsConfDirective* sdir = dir->directives.at(i);
@ -2424,31 +2424,31 @@ int SrsConfig::vhost_to_json(SrsConfDirective* vhost, SrsAmf0Object* obj)
// security
if ((dir = vhost->get("security")) != NULL) {
SrsAmf0Object* security = SrsAmf0Any::object();
SrsJsonObject* security = SrsJsonAny::object();
obj->set("security", security);
security->set("enabled", SrsAmf0Any::boolean(get_security_enabled(vhost->name)));
security->set("enabled", SrsJsonAny::boolean(get_security_enabled(vhost->name)));
SrsAmf0StrictArray* allows = SrsAmf0Any::strict_array();
SrsJsonArray* allows = SrsJsonAny::array();
security->set("allows", allows);
SrsAmf0StrictArray* denies = SrsAmf0Any::strict_array();
SrsJsonArray* denies = SrsJsonAny::array();
security->set("denies", denies);
for (int i = 0; i < (int)dir->directives.size(); i++) {
SrsConfDirective* sdir = dir->directives.at(i);
if (sdir->name == "allow") {
SrsAmf0Object* allow = SrsAmf0Any::object();
allow->set("action", SrsAmf0Any::str(sdir->name.c_str()));
allow->set("method", SrsAmf0Any::str(sdir->arg0().c_str()));
allow->set("entry", SrsAmf0Any::str(sdir->arg1().c_str()));
SrsJsonObject* allow = SrsJsonAny::object();
allow->set("action", SrsJsonAny::str(sdir->name.c_str()));
allow->set("method", SrsJsonAny::str(sdir->arg0().c_str()));
allow->set("entry", SrsJsonAny::str(sdir->arg1().c_str()));
allows->append(allow);
} else if (sdir->name == "deny") {
SrsAmf0Object* deny = SrsAmf0Any::object();
deny->set("action", SrsAmf0Any::str(sdir->name.c_str()));
deny->set("method", SrsAmf0Any::str(sdir->arg0().c_str()));
deny->set("entry", SrsAmf0Any::str(sdir->arg1().c_str()));
SrsJsonObject* deny = SrsJsonAny::object();
deny->set("action", SrsJsonAny::str(sdir->name.c_str()));
deny->set("method", SrsJsonAny::str(sdir->arg0().c_str()));
deny->set("entry", SrsJsonAny::str(sdir->arg1().c_str()));
denies->append(deny);
}
}
@ -2456,10 +2456,10 @@ int SrsConfig::vhost_to_json(SrsConfDirective* vhost, SrsAmf0Object* obj)
// http_static
if ((dir = vhost->get("http_static")) != NULL) {
SrsAmf0Object* http_static = SrsAmf0Any::object();
SrsJsonObject* http_static = SrsJsonAny::object();
obj->set("http_static", http_static);
http_static->set("enabled", SrsAmf0Any::boolean(get_vhost_http_enabled(vhost->name)));
http_static->set("enabled", SrsJsonAny::boolean(get_vhost_http_enabled(vhost->name)));
for (int i = 0; i < (int)dir->directives.size(); i++) {
SrsConfDirective* sdir = dir->directives.at(i);
@ -2474,10 +2474,10 @@ int SrsConfig::vhost_to_json(SrsConfDirective* vhost, SrsAmf0Object* obj)
// http_remux
if ((dir = vhost->get("http_remux")) != NULL) {
SrsAmf0Object* http_remux = SrsAmf0Any::object();
SrsJsonObject* http_remux = SrsJsonAny::object();
obj->set("http_remux", http_remux);
http_remux->set("enabled", SrsAmf0Any::boolean(get_vhost_http_remux_enabled(vhost->name)));
http_remux->set("enabled", SrsJsonAny::boolean(get_vhost_http_remux_enabled(vhost->name)));
for (int i = 0; i < (int)dir->directives.size(); i++) {
SrsConfDirective* sdir = dir->directives.at(i);
@ -2494,10 +2494,10 @@ int SrsConfig::vhost_to_json(SrsConfDirective* vhost, SrsAmf0Object* obj)
// http_hooks
if ((dir = vhost->get("http_hooks")) != NULL) {
SrsAmf0Object* http_hooks = SrsAmf0Any::object();
SrsJsonObject* http_hooks = SrsJsonAny::object();
obj->set("http_hooks", http_hooks);
http_hooks->set("enabled", SrsAmf0Any::boolean(get_vhost_http_hooks_enabled(vhost->name)));
http_hooks->set("enabled", SrsJsonAny::boolean(get_vhost_http_hooks_enabled(vhost->name)));
for (int i = 0; i < (int)dir->directives.size(); i++) {
SrsConfDirective* sdir = dir->directives.at(i);
@ -2526,10 +2526,10 @@ int SrsConfig::vhost_to_json(SrsConfDirective* vhost, SrsAmf0Object* obj)
// hls
if ((dir = vhost->get("hls")) != NULL) {
SrsAmf0Object* hls = SrsAmf0Any::object();
SrsJsonObject* hls = SrsJsonAny::object();
obj->set("hls", hls);
hls->set("enabled", SrsAmf0Any::boolean(get_hls_enabled(vhost->name)));
hls->set("enabled", SrsJsonAny::boolean(get_hls_enabled(vhost->name)));
for (int i = 0; i < (int)dir->directives.size(); i++) {
SrsConfDirective* sdir = dir->directives.at(i);
@ -2576,10 +2576,10 @@ int SrsConfig::vhost_to_json(SrsConfDirective* vhost, SrsAmf0Object* obj)
// hds
if ((dir = vhost->get("hds")) != NULL) {
SrsAmf0Object* hds = SrsAmf0Any::object();
SrsJsonObject* hds = SrsJsonAny::object();
obj->set("hds", hds);
hds->set("enabled", SrsAmf0Any::boolean(get_hds_enabled(vhost->name)));
hds->set("enabled", SrsJsonAny::boolean(get_hds_enabled(vhost->name)));
for (int i = 0; i < (int)dir->directives.size(); i++) {
SrsConfDirective* sdir = dir->directives.at(i);
@ -2596,10 +2596,10 @@ int SrsConfig::vhost_to_json(SrsConfDirective* vhost, SrsAmf0Object* obj)
// dvr
if ((dir = vhost->get("dvr")) != NULL) {
SrsAmf0Object* dvr = SrsAmf0Any::object();
SrsJsonObject* dvr = SrsJsonAny::object();
obj->set("dvr", dvr);
dvr->set("enabled", SrsAmf0Any::boolean(get_dvr_enabled(vhost->name)));
dvr->set("enabled", SrsJsonAny::boolean(get_dvr_enabled(vhost->name)));
for (int i = 0; i < (int)dir->directives.size(); i++) {
SrsConfDirective* sdir = dir->directives.at(i);
@ -2622,10 +2622,10 @@ int SrsConfig::vhost_to_json(SrsConfDirective* vhost, SrsAmf0Object* obj)
// exec
if ((dir = vhost->get("exec")) != NULL) {
SrsAmf0Object* ng_exec = SrsAmf0Any::object();
SrsJsonObject* ng_exec = SrsJsonAny::object();
obj->set("exec", ng_exec);
ng_exec->set("enabled", SrsAmf0Any::boolean(get_exec_enabled(vhost->name)));
ng_exec->set("enabled", SrsJsonAny::boolean(get_exec_enabled(vhost->name)));
for (int i = 0; i < (int)dir->directives.size(); i++) {
SrsConfDirective* sdir = dir->directives.at(i);
@ -2637,7 +2637,7 @@ int SrsConfig::vhost_to_json(SrsConfDirective* vhost, SrsAmf0Object* obj)
}
// ingest
SrsAmf0StrictArray* ingests = NULL;
SrsJsonArray* ingests = NULL;
for (int i = 0; i < (int)vhost->directives.size(); i++) {
dir = vhost->directives.at(i);
if (dir->name != "ingest") {
@ -2645,20 +2645,20 @@ int SrsConfig::vhost_to_json(SrsConfDirective* vhost, SrsAmf0Object* obj)
}
if (!ingests) {
ingests = SrsAmf0Any::strict_array();
ingests = SrsJsonAny::array();
obj->set("ingests", ingests);
}
SrsAmf0Object* ingest = SrsAmf0Any::object();
SrsJsonObject* ingest = SrsJsonAny::object();
ingest->set("id", dir->dumps_arg0_to_str());
ingest->set("enabled", SrsAmf0Any::boolean(get_ingest_enabled(dir)));
ingest->set("enabled", SrsJsonAny::boolean(get_ingest_enabled(dir)));
ingests->append(ingest);
for (int j = 0; j < (int)dir->directives.size(); j++) {
SrsConfDirective* sdir = dir->directives.at(j);
if (sdir->name == "input") {
SrsAmf0Object* input = SrsAmf0Any::object();
SrsJsonObject* input = SrsJsonAny::object();
ingest->set("input", input);
SrsConfDirective* type = sdir->get("type");
@ -2673,7 +2673,7 @@ int SrsConfig::vhost_to_json(SrsConfDirective* vhost, SrsAmf0Object* obj)
} else if (sdir->name == "ffmpeg") {
ingest->set("ffmpeg", sdir->dumps_arg0_to_str());
} else if (sdir->name == "engine") {
SrsAmf0Object* engine = SrsAmf0Any::object();
SrsJsonObject* engine = SrsJsonAny::object();
ingest->set("engine", engine);
if ((ret = srs_config_dumps_engine(sdir, engine)) != ERROR_SUCCESS) {
@ -2684,7 +2684,7 @@ int SrsConfig::vhost_to_json(SrsConfDirective* vhost, SrsAmf0Object* obj)
}
// transcode
SrsAmf0StrictArray* transcodes = NULL;
SrsJsonArray* transcodes = NULL;
for (int i = 0; i < (int)vhost->directives.size(); i++) {
dir = vhost->directives.at(i);
if (dir->name != "transcode") {
@ -2692,17 +2692,17 @@ int SrsConfig::vhost_to_json(SrsConfDirective* vhost, SrsAmf0Object* obj)
}
if (!transcodes) {
transcodes = SrsAmf0Any::strict_array();
transcodes = SrsJsonAny::array();
obj->set("transcodes", transcodes);
}
SrsAmf0Object* transcode = SrsAmf0Any::object();
SrsJsonObject* transcode = SrsJsonAny::object();
transcodes->append(transcode);
transcode->set("apply", dir->dumps_arg0_to_str());
transcode->set("enabled", SrsAmf0Any::boolean(get_transcode_enabled(dir)));
transcode->set("enabled", SrsJsonAny::boolean(get_transcode_enabled(dir)));
SrsAmf0StrictArray* engines = SrsAmf0Any::strict_array();
SrsJsonArray* engines = SrsJsonAny::array();
transcode->set("engines", engines);
for (int i = 0; i < (int)dir->directives.size(); i++) {
@ -2711,7 +2711,7 @@ int SrsConfig::vhost_to_json(SrsConfDirective* vhost, SrsAmf0Object* obj)
if (sdir->name == "ffmpeg") {
transcode->set("ffmpeg", sdir->dumps_arg0_to_str());
} else if (sdir->name == "engine") {
SrsAmf0Object* engine = SrsAmf0Any::object();
SrsJsonObject* engine = SrsJsonAny::object();
engines->append(engine);
if ((ret = srs_config_dumps_engine(sdir, engine)) != ERROR_SUCCESS) {
@ -2724,24 +2724,24 @@ int SrsConfig::vhost_to_json(SrsConfDirective* vhost, SrsAmf0Object* obj)
return ret;
}
int SrsConfig::raw_to_json(SrsAmf0Object* obj)
int SrsConfig::raw_to_json(SrsJsonObject* obj)
{
int ret = ERROR_SUCCESS;
SrsAmf0Object* sobj = SrsAmf0Any::object();
SrsJsonObject* sobj = SrsJsonAny::object();
obj->set("http_api", sobj);
sobj->set("enabled", SrsAmf0Any::boolean(get_http_api_enabled()));
sobj->set("listen", SrsAmf0Any::str(get_http_api_listen().c_str()));
sobj->set("crossdomain", SrsAmf0Any::boolean(get_http_api_crossdomain()));
sobj->set("enabled", SrsJsonAny::boolean(get_http_api_enabled()));
sobj->set("listen", SrsJsonAny::str(get_http_api_listen().c_str()));
sobj->set("crossdomain", SrsJsonAny::boolean(get_http_api_crossdomain()));
SrsAmf0Object* ssobj = SrsAmf0Any::object();
SrsJsonObject* ssobj = SrsJsonAny::object();
sobj->set("raw_api", ssobj);
ssobj->set("enabled", SrsAmf0Any::boolean(get_raw_api()));
ssobj->set("allow_reload", SrsAmf0Any::boolean(get_raw_api_allow_reload()));
ssobj->set("allow_query", SrsAmf0Any::boolean(get_raw_api_allow_query()));
ssobj->set("allow_update", SrsAmf0Any::boolean(get_raw_api_allow_update()));
ssobj->set("enabled", SrsJsonAny::boolean(get_raw_api()));
ssobj->set("allow_reload", SrsJsonAny::boolean(get_raw_api_allow_reload()));
ssobj->set("allow_query", SrsJsonAny::boolean(get_raw_api_allow_query()));
ssobj->set("allow_update", SrsJsonAny::boolean(get_raw_api_allow_update()));
return ret;
}

22
trunk/src/app/srs_app_config.hpp
View file

@ -40,9 +40,9 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
class SrsRequest;
class SrsFileWriter;
class SrsAmf0Object;
class SrsAmf0StrictArray;
class SrsAmf0Any;
class SrsJsonObject;
class SrsJsonArray;
class SrsJsonAny;
class SrsConfig;
class SrsRequest;
@ -250,13 +250,13 @@ public:
/**
* dumps the args[0-N] to array(string).
*/
virtual SrsAmf0StrictArray* dumps_args();
virtual SrsJsonArray* dumps_args();
/**
* dumps arg0 to str, number or boolean.
*/
virtual SrsAmf0Any* dumps_arg0_to_str();
virtual SrsAmf0Any* dumps_arg0_to_number();
virtual SrsAmf0Any* dumps_arg0_to_boolean();
virtual SrsJsonAny* dumps_arg0_to_str();
virtual SrsJsonAny* dumps_arg0_to_number();
virtual SrsJsonAny* dumps_arg0_to_boolean();
// private parse.
private:
/**
@ -416,19 +416,19 @@ public:
/**
* dumps the global sections to json.
*/
virtual int global_to_json(SrsAmf0Object* obj);
virtual int global_to_json(SrsJsonObject* obj);
/**
* dumps the minimal sections to json.
*/
virtual int minimal_to_json(SrsAmf0Object* obj);
virtual int minimal_to_json(SrsJsonObject* obj);
/**
* dumps the vhost section to json.
*/
virtual int vhost_to_json(SrsConfDirective* vhost, SrsAmf0Object* obj);
virtual int vhost_to_json(SrsConfDirective* vhost, SrsJsonObject* obj);
/**
* dumps the http_api sections to json for raw api info.
*/
virtual int raw_to_json(SrsAmf0Object* obj);
virtual int raw_to_json(SrsJsonObject* obj);
/**
* raw set the global listen.
*/

10
trunk/src/app/srs_app_heartbeat.cpp
View file

@ -66,14 +66,14 @@ void SrsHttpHeartbeat::heartbeat()
ip = ips[_srs_config->get_stats_network() % (int)ips.size()];
}
SrsAmf0Object* obj = SrsAmf0Any::object();
SrsAutoFree(SrsAmf0Object, obj);
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
obj->set("device_id", SrsAmf0Any::str(device_id.c_str()));
obj->set("ip", SrsAmf0Any::str(ip.c_str()));
obj->set("device_id", SrsJsonAny::str(device_id.c_str()));
obj->set("ip", SrsJsonAny::str(ip.c_str()));
if (_srs_config->get_heartbeat_summaries()) {
SrsAmf0Object* summaries = SrsAmf0Any::object();
SrsJsonObject* summaries = SrsJsonAny::object();
obj->set("summaries", summaries);
srs_api_dump_summaries(summaries);

514
trunk/src/app/srs_app_http_api.cpp
View file

@ -78,10 +78,10 @@ int srs_api_response_jsonp(ISrsHttpResponseWriter* w, string callback, string da
int srs_api_response_jsonp_code(ISrsHttpResponseWriter* w, string callback, int code)
{
SrsAmf0Object* obj = SrsAmf0Any::object();
SrsAutoFree(SrsAmf0Object, obj);
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
obj->set("code", SrsAmf0Any::number(code));
obj->set("code", SrsJsonAny::ingeter(code));
return srs_api_response_jsonp(w, callback, obj->to_json());
}
@ -98,10 +98,10 @@ int srs_api_response_json(ISrsHttpResponseWriter* w, string data)
int srs_api_response_json_code(ISrsHttpResponseWriter* w, int code)
{
SrsAmf0Object* obj = SrsAmf0Any::object();
SrsAutoFree(SrsAmf0Object, obj);
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
obj->set("code", SrsAmf0Any::number(code));
obj->set("code", SrsJsonAny::ingeter(code));
return srs_api_response_json(w, obj->to_json());
}
@ -142,16 +142,16 @@ int SrsGoApiRoot::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
{
SrsStatistic* stat = SrsStatistic::instance();
SrsAmf0Object* obj = SrsAmf0Any::object();
SrsAutoFree(SrsAmf0Object, obj);
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
obj->set("code", SrsAmf0Any::number(ERROR_SUCCESS));
obj->set("server", SrsAmf0Any::number(stat->server_id()));
obj->set("code", SrsJsonAny::number(ERROR_SUCCESS));
obj->set("server", SrsJsonAny::number(stat->server_id()));
SrsAmf0Object* urls = SrsAmf0Any::object();
SrsJsonObject* urls = SrsJsonAny::object();
obj->set("urls", urls);
urls->set("api", SrsAmf0Any::str("the api root"));
urls->set("api", SrsJsonAny::str("the api root"));
return srs_api_response(w, r, obj->to_json());
}
@ -168,16 +168,16 @@ int SrsGoApiApi::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
{
SrsStatistic* stat = SrsStatistic::instance();
SrsAmf0Object* obj = SrsAmf0Any::object();
SrsAutoFree(SrsAmf0Object, obj);
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
obj->set("code", SrsAmf0Any::number(ERROR_SUCCESS));
obj->set("server", SrsAmf0Any::number(stat->server_id()));
obj->set("code", SrsJsonAny::number(ERROR_SUCCESS));
obj->set("server", SrsJsonAny::number(stat->server_id()));
SrsAmf0Object* urls = SrsAmf0Any::object();
SrsJsonObject* urls = SrsJsonAny::object();
obj->set("urls", urls);
urls->set("v1", SrsAmf0Any::str("the api version 1.0"));
urls->set("v1", SrsJsonAny::str("the api version 1.0"));
return srs_api_response(w, r, obj->to_json());
}
@ -194,36 +194,36 @@ int SrsGoApiV1::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
{
SrsStatistic* stat = SrsStatistic::instance();
SrsAmf0Object* obj = SrsAmf0Any::object();
SrsAutoFree(SrsAmf0Object, obj);
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
obj->set("code", SrsAmf0Any::number(ERROR_SUCCESS));
obj->set("server", SrsAmf0Any::number(stat->server_id()));
obj->set("code", SrsJsonAny::number(ERROR_SUCCESS));
obj->set("server", SrsJsonAny::number(stat->server_id()));
SrsAmf0Object* urls = SrsAmf0Any::object();
SrsJsonObject* urls = SrsJsonAny::object();
obj->set("urls", urls);
urls->set("versions", SrsAmf0Any::str("the version of SRS"));
urls->set("summaries", SrsAmf0Any::str("the summary(pid, argv, pwd, cpu, mem) of SRS"));
urls->set("rusages", SrsAmf0Any::str("the rusage of SRS"));
urls->set("self_proc_stats", SrsAmf0Any::str("the self process stats"));
urls->set("system_proc_stats", SrsAmf0Any::str("the system process stats"));
urls->set("meminfos", SrsAmf0Any::str("the meminfo of system"));
urls->set("authors", SrsAmf0Any::str("the license, copyright, authors and contributors"));
urls->set("features", SrsAmf0Any::str("the supported features of SRS"));
urls->set("requests", SrsAmf0Any::str("the request itself, for http debug"));
urls->set("vhosts", SrsAmf0Any::str("manage all vhosts or specified vhost"));
urls->set("streams", SrsAmf0Any::str("manage all streams or specified stream"));
urls->set("clients", SrsAmf0Any::str("manage all clients or specified client, default query top 10 clients"));
urls->set("raw", SrsAmf0Any::str("raw api for srs, support CUID srs for instance the config"));
urls->set("versions", SrsJsonAny::str("the version of SRS"));
urls->set("summaries", SrsJsonAny::str("the summary(pid, argv, pwd, cpu, mem) of SRS"));
urls->set("rusages", SrsJsonAny::str("the rusage of SRS"));
urls->set("self_proc_stats", SrsJsonAny::str("the self process stats"));
urls->set("system_proc_stats", SrsJsonAny::str("the system process stats"));
urls->set("meminfos", SrsJsonAny::str("the meminfo of system"));
urls->set("authors", SrsJsonAny::str("the license, copyright, authors and contributors"));
urls->set("features", SrsJsonAny::str("the supported features of SRS"));
urls->set("requests", SrsJsonAny::str("the request itself, for http debug"));
urls->set("vhosts", SrsJsonAny::str("manage all vhosts or specified vhost"));
urls->set("streams", SrsJsonAny::str("manage all streams or specified stream"));
urls->set("clients", SrsJsonAny::str("manage all clients or specified client, default query top 10 clients"));
urls->set("raw", SrsJsonAny::str("raw api for srs, support CUID srs for instance the config"));
SrsAmf0Object* tests = SrsAmf0Any::object();
SrsJsonObject* tests = SrsJsonAny::object();
obj->set("tests", tests);
tests->set("requests", SrsAmf0Any::str("show the request info"));
tests->set("errors", SrsAmf0Any::str("always return an error 100"));
tests->set("redirects", SrsAmf0Any::str("always redirect to /api/v1/test/errors"));
tests->set("[vhost]", SrsAmf0Any::str("http vhost for http://error.srs.com:1985/api/v1/tests/errors"));
tests->set("requests", SrsJsonAny::str("show the request info"));
tests->set("errors", SrsJsonAny::str("always return an error 100"));
tests->set("redirects", SrsJsonAny::str("always redirect to /api/v1/test/errors"));
tests->set("[vhost]", SrsJsonAny::str("http vhost for http://error.srs.com:1985/api/v1/tests/errors"));
return srs_api_response(w, r, obj->to_json());
}
@ -240,19 +240,19 @@ int SrsGoApiVersion::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
{
SrsStatistic* stat = SrsStatistic::instance();
SrsAmf0Object* obj = SrsAmf0Any::object();
SrsAutoFree(SrsAmf0Object, obj);
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
obj->set("code", SrsAmf0Any::number(ERROR_SUCCESS));
obj->set("server", SrsAmf0Any::number(stat->server_id()));
obj->set("code", SrsJsonAny::number(ERROR_SUCCESS));
obj->set("server", SrsJsonAny::number(stat->server_id()));
SrsAmf0Object* data = SrsAmf0Any::object();
SrsJsonObject* data = SrsJsonAny::object();
obj->set("data", data);
data->set("major", SrsAmf0Any::number(VERSION_MAJOR));
data->set("minor", SrsAmf0Any::number(VERSION_MINOR));
data->set("revision", SrsAmf0Any::number(VERSION_REVISION));
data->set("version", SrsAmf0Any::str(RTMP_SIG_SRS_VERSION));
data->set("major", SrsJsonAny::number(VERSION_MAJOR));
data->set("minor", SrsJsonAny::number(VERSION_MINOR));
data->set("revision", SrsJsonAny::number(VERSION_REVISION));
data->set("version", SrsJsonAny::str(RTMP_SIG_SRS_VERSION));
return srs_api_response(w, r, obj->to_json());
}
@ -267,8 +267,8 @@ SrsGoApiSummaries::~SrsGoApiSummaries()
int SrsGoApiSummaries::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
{
SrsAmf0Object* obj = SrsAmf0Any::object();
SrsAutoFree(SrsAmf0Object, obj);
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
srs_api_dump_summaries(obj);
@ -287,35 +287,35 @@ int SrsGoApiRusages::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
{
SrsStatistic* stat = SrsStatistic::instance();
SrsAmf0Object* obj = SrsAmf0Any::object();
SrsAutoFree(SrsAmf0Object, obj);
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
obj->set("code", SrsAmf0Any::number(ERROR_SUCCESS));
obj->set("server", SrsAmf0Any::number(stat->server_id()));
obj->set("code", SrsJsonAny::number(ERROR_SUCCESS));
obj->set("server", SrsJsonAny::number(stat->server_id()));
SrsAmf0Object* data = SrsAmf0Any::object();
SrsJsonObject* data = SrsJsonAny::object();
obj->set("data", data);
SrsRusage* ru = srs_get_system_rusage();
data->set("ok", SrsAmf0Any::boolean(ru->ok));
data->set("sample_time", SrsAmf0Any::number(ru->sample_time));
data->set("ru_utime", SrsAmf0Any::number(ru->r.ru_utime.tv_sec));
data->set("ru_stime", SrsAmf0Any::number(ru->r.ru_stime.tv_sec));
data->set("ru_maxrss", SrsAmf0Any::number(ru->r.ru_maxrss));
data->set("ru_ixrss", SrsAmf0Any::number(ru->r.ru_ixrss));
data->set("ru_idrss", SrsAmf0Any::number(ru->r.ru_idrss));
data->set("ru_isrss", SrsAmf0Any::number(ru->r.ru_isrss));
data->set("ru_minflt", SrsAmf0Any::number(ru->r.ru_minflt));
data->set("ru_majflt", SrsAmf0Any::number(ru->r.ru_majflt));
data->set("ru_nswap", SrsAmf0Any::number(ru->r.ru_nswap));
data->set("ru_inblock", SrsAmf0Any::number(ru->r.ru_inblock));
data->set("ru_oublock", SrsAmf0Any::number(ru->r.ru_oublock));
data->set("ru_msgsnd", SrsAmf0Any::number(ru->r.ru_msgsnd));
data->set("ru_msgrcv", SrsAmf0Any::number(ru->r.ru_msgrcv));
data->set("ru_nsignals", SrsAmf0Any::number(ru->r.ru_nsignals));
data->set("ru_nvcsw", SrsAmf0Any::number(ru->r.ru_nvcsw));
data->set("ru_nivcsw", SrsAmf0Any::number(ru->r.ru_nivcsw));
data->set("ok", SrsJsonAny::boolean(ru->ok));
data->set("sample_time", SrsJsonAny::number(ru->sample_time));
data->set("ru_utime", SrsJsonAny::number(ru->r.ru_utime.tv_sec));
data->set("ru_stime", SrsJsonAny::number(ru->r.ru_stime.tv_sec));
data->set("ru_maxrss", SrsJsonAny::number(ru->r.ru_maxrss));
data->set("ru_ixrss", SrsJsonAny::number(ru->r.ru_ixrss));
data->set("ru_idrss", SrsJsonAny::number(ru->r.ru_idrss));
data->set("ru_isrss", SrsJsonAny::number(ru->r.ru_isrss));
data->set("ru_minflt", SrsJsonAny::number(ru->r.ru_minflt));
data->set("ru_majflt", SrsJsonAny::number(ru->r.ru_majflt));
data->set("ru_nswap", SrsJsonAny::number(ru->r.ru_nswap));
data->set("ru_inblock", SrsJsonAny::number(ru->r.ru_inblock));
data->set("ru_oublock", SrsJsonAny::number(ru->r.ru_oublock));
data->set("ru_msgsnd", SrsJsonAny::number(ru->r.ru_msgsnd));
data->set("ru_msgrcv", SrsJsonAny::number(ru->r.ru_msgrcv));
data->set("ru_nsignals", SrsJsonAny::number(ru->r.ru_nsignals));
data->set("ru_nvcsw", SrsJsonAny::number(ru->r.ru_nvcsw));
data->set("ru_nivcsw", SrsJsonAny::number(ru->r.ru_nivcsw));
return srs_api_response(w, r, obj->to_json());
}
@ -332,13 +332,13 @@ int SrsGoApiSelfProcStats::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage
{
SrsStatistic* stat = SrsStatistic::instance();
SrsAmf0Object* obj = SrsAmf0Any::object();
SrsAutoFree(SrsAmf0Object, obj);
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
obj->set("code", SrsAmf0Any::number(ERROR_SUCCESS));
obj->set("server", SrsAmf0Any::number(stat->server_id()));
obj->set("code", SrsJsonAny::number(ERROR_SUCCESS));
obj->set("server", SrsJsonAny::number(stat->server_id()));
SrsAmf0Object* data = SrsAmf0Any::object();
SrsJsonObject* data = SrsJsonAny::object();
obj->set("data", data);
SrsProcSelfStat* u = srs_get_self_proc_stat();
@ -346,53 +346,53 @@ int SrsGoApiSelfProcStats::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage
string state;
state += (char)u->state;
data->set("ok", SrsAmf0Any::boolean(u->ok));
data->set("sample_time", SrsAmf0Any::number(u->sample_time));
data->set("percent", SrsAmf0Any::number(u->percent));
data->set("pid", SrsAmf0Any::number(u->pid));
data->set("comm", SrsAmf0Any::str(u->comm));
data->set("state", SrsAmf0Any::str(state.c_str()));
data->set("ppid", SrsAmf0Any::number(u->ppid));
data->set("pgrp", SrsAmf0Any::number(u->pgrp));
data->set("session", SrsAmf0Any::number(u->session));
data->set("tty_nr", SrsAmf0Any::number(u->tty_nr));
data->set("tpgid", SrsAmf0Any::number(u->tpgid));
data->set("flags", SrsAmf0Any::number(u->flags));
data->set("minflt", SrsAmf0Any::number(u->minflt));
data->set("cminflt", SrsAmf0Any::number(u->cminflt));
data->set("majflt", SrsAmf0Any::number(u->majflt));
data->set("cmajflt", SrsAmf0Any::number(u->cmajflt));
data->set("utime", SrsAmf0Any::number(u->utime));
data->set("stime", SrsAmf0Any::number(u->stime));
data->set("cutime", SrsAmf0Any::number(u->cutime));
data->set("cstime", SrsAmf0Any::number(u->cstime));
data->set("priority", SrsAmf0Any::number(u->priority));
data->set("nice", SrsAmf0Any::number(u->nice));
data->set("num_threads", SrsAmf0Any::number(u->num_threads));
data->set("itrealvalue", SrsAmf0Any::number(u->itrealvalue));
data->set("starttime", SrsAmf0Any::number(u->starttime));
data->set("vsize", SrsAmf0Any::number(u->vsize));
data->set("rss", SrsAmf0Any::number(u->rss));
data->set("rsslim", SrsAmf0Any::number(u->rsslim));
data->set("startcode", SrsAmf0Any::number(u->startcode));
data->set("endcode", SrsAmf0Any::number(u->endcode));
data->set("startstack", SrsAmf0Any::number(u->startstack));
data->set("kstkesp", SrsAmf0Any::number(u->kstkesp));
data->set("kstkeip", SrsAmf0Any::number(u->kstkeip));
data->set("signal", SrsAmf0Any::number(u->signal));
data->set("blocked", SrsAmf0Any::number(u->blocked));
data->set("sigignore", SrsAmf0Any::number(u->sigignore));
data->set("sigcatch", SrsAmf0Any::number(u->sigcatch));
data->set("wchan", SrsAmf0Any::number(u->wchan));
data->set("nswap", SrsAmf0Any::number(u->nswap));
data->set("cnswap", SrsAmf0Any::number(u->cnswap));
data->set("exit_signal", SrsAmf0Any::number(u->exit_signal));
data->set("processor", SrsAmf0Any::number(u->processor));
data->set("rt_priority", SrsAmf0Any::number(u->rt_priority));
data->set("policy", SrsAmf0Any::number(u->policy));
data->set("delayacct_blkio_ticks", SrsAmf0Any::number(u->delayacct_blkio_ticks));
data->set("guest_time", SrsAmf0Any::number(u->guest_time));
data->set("cguest_time", SrsAmf0Any::number(u->cguest_time));
data->set("ok", SrsJsonAny::boolean(u->ok));
data->set("sample_time", SrsJsonAny::number(u->sample_time));
data->set("percent", SrsJsonAny::number(u->percent));
data->set("pid", SrsJsonAny::number(u->pid));
data->set("comm", SrsJsonAny::str(u->comm));
data->set("state", SrsJsonAny::str(state.c_str()));
data->set("ppid", SrsJsonAny::number(u->ppid));
data->set("pgrp", SrsJsonAny::number(u->pgrp));
data->set("session", SrsJsonAny::number(u->session));
data->set("tty_nr", SrsJsonAny::number(u->tty_nr));
data->set("tpgid", SrsJsonAny::number(u->tpgid));
data->set("flags", SrsJsonAny::number(u->flags));
data->set("minflt", SrsJsonAny::number(u->minflt));
data->set("cminflt", SrsJsonAny::number(u->cminflt));
data->set("majflt", SrsJsonAny::number(u->majflt));
data->set("cmajflt", SrsJsonAny::number(u->cmajflt));
data->set("utime", SrsJsonAny::number(u->utime));
data->set("stime", SrsJsonAny::number(u->stime));
data->set("cutime", SrsJsonAny::number(u->cutime));
data->set("cstime", SrsJsonAny::number(u->cstime));
data->set("priority", SrsJsonAny::number(u->priority));
data->set("nice", SrsJsonAny::number(u->nice));
data->set("num_threads", SrsJsonAny::number(u->num_threads));
data->set("itrealvalue", SrsJsonAny::number(u->itrealvalue));
data->set("starttime", SrsJsonAny::number(u->starttime));
data->set("vsize", SrsJsonAny::number(u->vsize));
data->set("rss", SrsJsonAny::number(u->rss));
data->set("rsslim", SrsJsonAny::number(u->rsslim));
data->set("startcode", SrsJsonAny::number(u->startcode));
data->set("endcode", SrsJsonAny::number(u->endcode));
data->set("startstack", SrsJsonAny::number(u->startstack));
data->set("kstkesp", SrsJsonAny::number(u->kstkesp));
data->set("kstkeip", SrsJsonAny::number(u->kstkeip));
data->set("signal", SrsJsonAny::number(u->signal));
data->set("blocked", SrsJsonAny::number(u->blocked));
data->set("sigignore", SrsJsonAny::number(u->sigignore));
data->set("sigcatch", SrsJsonAny::number(u->sigcatch));
data->set("wchan", SrsJsonAny::number(u->wchan));
data->set("nswap", SrsJsonAny::number(u->nswap));
data->set("cnswap", SrsJsonAny::number(u->cnswap));
data->set("exit_signal", SrsJsonAny::number(u->exit_signal));
data->set("processor", SrsJsonAny::number(u->processor));
data->set("rt_priority", SrsJsonAny::number(u->rt_priority));
data->set("policy", SrsJsonAny::number(u->policy));
data->set("delayacct_blkio_ticks", SrsJsonAny::number(u->delayacct_blkio_ticks));
data->set("guest_time", SrsJsonAny::number(u->guest_time));
data->set("cguest_time", SrsJsonAny::number(u->cguest_time));
return srs_api_response(w, r, obj->to_json());
}
@ -409,29 +409,29 @@ int SrsGoApiSystemProcStats::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessa
{
SrsStatistic* stat = SrsStatistic::instance();
SrsAmf0Object* obj = SrsAmf0Any::object();
SrsAutoFree(SrsAmf0Object, obj);
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
obj->set("code", SrsAmf0Any::number(ERROR_SUCCESS));
obj->set("server", SrsAmf0Any::number(stat->server_id()));
obj->set("code", SrsJsonAny::number(ERROR_SUCCESS));
obj->set("server", SrsJsonAny::number(stat->server_id()));
SrsAmf0Object* data = SrsAmf0Any::object();
SrsJsonObject* data = SrsJsonAny::object();
obj->set("data", data);
SrsProcSystemStat* s = srs_get_system_proc_stat();
data->set("ok", SrsAmf0Any::boolean(s->ok));
data->set("sample_time", SrsAmf0Any::number(s->sample_time));
data->set("percent", SrsAmf0Any::number(s->percent));
data->set("user", SrsAmf0Any::number(s->user));
data->set("nice", SrsAmf0Any::number(s->nice));
data->set("sys", SrsAmf0Any::number(s->sys));
data->set("idle", SrsAmf0Any::number(s->idle));
data->set("iowait", SrsAmf0Any::number(s->iowait));
data->set("irq", SrsAmf0Any::number(s->irq));
data->set("softirq", SrsAmf0Any::number(s->softirq));
data->set("steal", SrsAmf0Any::number(s->steal));
data->set("guest", SrsAmf0Any::number(s->guest));
data->set("ok", SrsJsonAny::boolean(s->ok));
data->set("sample_time", SrsJsonAny::number(s->sample_time));
data->set("percent", SrsJsonAny::number(s->percent));
data->set("user", SrsJsonAny::number(s->user));
data->set("nice", SrsJsonAny::number(s->nice));
data->set("sys", SrsJsonAny::number(s->sys));
data->set("idle", SrsJsonAny::number(s->idle));
data->set("iowait", SrsJsonAny::number(s->iowait));
data->set("irq", SrsJsonAny::number(s->irq));
data->set("softirq", SrsJsonAny::number(s->softirq));
data->set("steal", SrsJsonAny::number(s->steal));
data->set("guest", SrsJsonAny::number(s->guest));
return srs_api_response(w, r, obj->to_json());
}
@ -448,30 +448,30 @@ int SrsGoApiMemInfos::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
{
SrsStatistic* stat = SrsStatistic::instance();
SrsAmf0Object* obj = SrsAmf0Any::object();
SrsAutoFree(SrsAmf0Object, obj);
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
obj->set("code", SrsAmf0Any::number(ERROR_SUCCESS));
obj->set("server", SrsAmf0Any::number(stat->server_id()));
obj->set("code", SrsJsonAny::number(ERROR_SUCCESS));
obj->set("server", SrsJsonAny::number(stat->server_id()));
SrsAmf0Object* data = SrsAmf0Any::object();
SrsJsonObject* data = SrsJsonAny::object();
obj->set("data", data);
SrsMemInfo* m = srs_get_meminfo();
data->set("ok", SrsAmf0Any::boolean(m->ok));
data->set("sample_time", SrsAmf0Any::number(m->sample_time));
data->set("percent_ram", SrsAmf0Any::number(m->percent_ram));
data->set("percent_swap", SrsAmf0Any::number(m->percent_swap));
data->set("MemActive", SrsAmf0Any::number(m->MemActive));
data->set("RealInUse", SrsAmf0Any::number(m->RealInUse));
data->set("NotInUse", SrsAmf0Any::number(m->NotInUse));
data->set("MemTotal", SrsAmf0Any::number(m->MemTotal));
data->set("MemFree", SrsAmf0Any::number(m->MemFree));
data->set("Buffers", SrsAmf0Any::number(m->Buffers));
data->set("Cached", SrsAmf0Any::number(m->Cached));
data->set("SwapTotal", SrsAmf0Any::number(m->SwapTotal));
data->set("SwapFree", SrsAmf0Any::number(m->SwapFree));
data->set("ok", SrsJsonAny::boolean(m->ok));
data->set("sample_time", SrsJsonAny::number(m->sample_time));
data->set("percent_ram", SrsJsonAny::number(m->percent_ram));
data->set("percent_swap", SrsJsonAny::number(m->percent_swap));
data->set("MemActive", SrsJsonAny::number(m->MemActive));
data->set("RealInUse", SrsJsonAny::number(m->RealInUse));
data->set("NotInUse", SrsJsonAny::number(m->NotInUse));
data->set("MemTotal", SrsJsonAny::number(m->MemTotal));
data->set("MemFree", SrsJsonAny::number(m->MemFree));
data->set("Buffers", SrsJsonAny::number(m->Buffers));
data->set("Cached", SrsJsonAny::number(m->Cached));
data->set("SwapTotal", SrsJsonAny::number(m->SwapTotal));
data->set("SwapFree", SrsJsonAny::number(m->SwapFree));
return srs_api_response(w, r, obj->to_json());
}
@ -488,21 +488,21 @@ int SrsGoApiAuthors::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
{
SrsStatistic* stat = SrsStatistic::instance();
SrsAmf0Object* obj = SrsAmf0Any::object();
SrsAutoFree(SrsAmf0Object, obj);
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
obj->set("code", SrsAmf0Any::number(ERROR_SUCCESS));
obj->set("server", SrsAmf0Any::number(stat->server_id()));
obj->set("code", SrsJsonAny::number(ERROR_SUCCESS));
obj->set("server", SrsJsonAny::number(stat->server_id()));
SrsAmf0Object* data = SrsAmf0Any::object();
SrsJsonObject* data = SrsJsonAny::object();
obj->set("data", data);
data->set("primary", SrsAmf0Any::str(RTMP_SIG_SRS_PRIMARY));
data->set("license", SrsAmf0Any::str(RTMP_SIG_SRS_LICENSE));
data->set("copyright", SrsAmf0Any::str(RTMP_SIG_SRS_COPYRIGHT));
data->set("authors", SrsAmf0Any::str(RTMP_SIG_SRS_AUTHROS));
data->set("contributors_link", SrsAmf0Any::str(RTMP_SIG_SRS_CONTRIBUTORS_URL));
data->set("contributors", SrsAmf0Any::str(SRS_AUTO_CONSTRIBUTORS));
data->set("primary", SrsJsonAny::str(RTMP_SIG_SRS_PRIMARY));
data->set("license", SrsJsonAny::str(RTMP_SIG_SRS_LICENSE));
data->set("copyright", SrsJsonAny::str(RTMP_SIG_SRS_COPYRIGHT));
data->set("authors", SrsJsonAny::str(RTMP_SIG_SRS_AUTHROS));
data->set("contributors_link", SrsJsonAny::str(RTMP_SIG_SRS_CONTRIBUTORS_URL));
data->set("contributors", SrsJsonAny::str(SRS_AUTO_CONSTRIBUTORS));
return srs_api_response(w, r, obj->to_json());
}
@ -519,107 +519,107 @@ int SrsGoApiFeatures::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
{
SrsStatistic* stat = SrsStatistic::instance();
SrsAmf0Object* obj = SrsAmf0Any::object();
SrsAutoFree(SrsAmf0Object, obj);
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
obj->set("code", SrsAmf0Any::number(ERROR_SUCCESS));
obj->set("server", SrsAmf0Any::number(stat->server_id()));
obj->set("code", SrsJsonAny::number(ERROR_SUCCESS));
obj->set("server", SrsJsonAny::number(stat->server_id()));
SrsAmf0Object* data = SrsAmf0Any::object();
SrsJsonObject* data = SrsJsonAny::object();
obj->set("data", data);
data->set("options", SrsAmf0Any::str(SRS_AUTO_USER_CONFIGURE));
data->set("options2", SrsAmf0Any::str(SRS_AUTO_CONFIGURE));
data->set("build", SrsAmf0Any::str(SRS_AUTO_BUILD_DATE));
data->set("build2", SrsAmf0Any::str(SRS_AUTO_BUILD_TS));
data->set("options", SrsJsonAny::str(SRS_AUTO_USER_CONFIGURE));
data->set("options2", SrsJsonAny::str(SRS_AUTO_CONFIGURE));
data->set("build", SrsJsonAny::str(SRS_AUTO_BUILD_DATE));
data->set("build2", SrsJsonAny::str(SRS_AUTO_BUILD_TS));
SrsAmf0Object* features = SrsAmf0Any::object();
SrsJsonObject* features = SrsJsonAny::object();
data->set("features", features);
#ifdef SRS_AUTO_SSL
features->set("ssl", SrsAmf0Any::boolean(true));
features->set("ssl", SrsJsonAny::boolean(true));
#else
features->set("ssl", SrsAmf0Any::boolean(false));
features->set("ssl", SrsJsonAny::boolean(false));
#endif
#ifdef SRS_AUTO_HLS
features->set("hls", SrsAmf0Any::boolean(true));
features->set("hls", SrsJsonAny::boolean(true));
#else
features->set("hls", SrsAmf0Any::boolean(false));
features->set("hls", SrsJsonAny::boolean(false));
#endif
#ifdef SRS_AUTO_HDS
features->set("hds", SrsAmf0Any::boolean(true));
features->set("hds", SrsJsonAny::boolean(true));
#else
features->set("hds", SrsAmf0Any::boolean(false));
features->set("hds", SrsJsonAny::boolean(false));
#endif
#ifdef SRS_AUTO_HTTP_CALLBACK
features->set("callback", SrsAmf0Any::boolean(true));
features->set("callback", SrsJsonAny::boolean(true));
#else
features->set("callback", SrsAmf0Any::boolean(false));
features->set("callback", SrsJsonAny::boolean(false));
#endif
#ifdef SRS_AUTO_HTTP_API
features->set("api", SrsAmf0Any::boolean(true));
features->set("api", SrsJsonAny::boolean(true));
#else
features->set("api", SrsAmf0Any::boolean(false));
features->set("api", SrsJsonAny::boolean(false));
#endif
#ifdef SRS_AUTO_HTTP_SERVER
features->set("httpd", SrsAmf0Any::boolean(true));
features->set("httpd", SrsJsonAny::boolean(true));
#else
features->set("httpd", SrsAmf0Any::boolean(false));
features->set("httpd", SrsJsonAny::boolean(false));
#endif
#ifdef SRS_AUTO_DVR
features->set("dvr", SrsAmf0Any::boolean(true));
features->set("dvr", SrsJsonAny::boolean(true));
#else
features->set("dvr", SrsAmf0Any::boolean(false));
features->set("dvr", SrsJsonAny::boolean(false));
#endif
#ifdef SRS_AUTO_TRANSCODE
features->set("transcode", SrsAmf0Any::boolean(true));
features->set("transcode", SrsJsonAny::boolean(true));
#else
features->set("transcode", SrsAmf0Any::boolean(false));
features->set("transcode", SrsJsonAny::boolean(false));
#endif
#ifdef SRS_AUTO_INGEST
features->set("ingest", SrsAmf0Any::boolean(true));
features->set("ingest", SrsJsonAny::boolean(true));
#else
features->set("ingest", SrsAmf0Any::boolean(false));
features->set("ingest", SrsJsonAny::boolean(false));
#endif
#ifdef SRS_AUTO_STAT
features->set("stat", SrsAmf0Any::boolean(true));
features->set("stat", SrsJsonAny::boolean(true));
#else
features->set("stat", SrsAmf0Any::boolean(false));
features->set("stat", SrsJsonAny::boolean(false));
#endif
#ifdef SRS_AUTO_NGINX
features->set("nginx", SrsAmf0Any::boolean(true));
features->set("nginx", SrsJsonAny::boolean(true));
#else
features->set("nginx", SrsAmf0Any::boolean(false));
features->set("nginx", SrsJsonAny::boolean(false));
#endif
#ifdef SRS_AUTO_FFMPEG_TOOL
features->set("ffmpeg", SrsAmf0Any::boolean(true));
features->set("ffmpeg", SrsJsonAny::boolean(true));
#else
features->set("ffmpeg", SrsAmf0Any::boolean(false));
features->set("ffmpeg", SrsJsonAny::boolean(false));
#endif
#ifdef SRS_AUTO_STREAM_CASTER
features->set("caster", SrsAmf0Any::boolean(true));
features->set("caster", SrsJsonAny::boolean(true));
#else
features->set("caster", SrsAmf0Any::boolean(false));
features->set("caster", SrsJsonAny::boolean(false));
#endif
#ifdef SRS_PERF_COMPLEX_SEND
features->set("complex_send", SrsAmf0Any::boolean(true));
features->set("complex_send", SrsJsonAny::boolean(true));
#else
features->set("complex_send", SrsAmf0Any::boolean(false));
features->set("complex_send", SrsJsonAny::boolean(false));
#endif
#ifdef SRS_PERF_TCP_NODELAY
features->set("tcp_nodelay", SrsAmf0Any::boolean(true));
features->set("tcp_nodelay", SrsJsonAny::boolean(true));
#else
features->set("tcp_nodelay", SrsAmf0Any::boolean(false));
features->set("tcp_nodelay", SrsJsonAny::boolean(false));
#endif
#ifdef SRS_PERF_SO_SNDBUF_SIZE
features->set("so_sendbuf", SrsAmf0Any::boolean(true));
features->set("so_sendbuf", SrsJsonAny::boolean(true));
#else
features->set("so_sendbuf", SrsAmf0Any::boolean(false));
features->set("so_sendbuf", SrsJsonAny::boolean(false));
#endif
#ifdef SRS_PERF_MERGED_READ
features->set("mr", SrsAmf0Any::boolean(true));
features->set("mr", SrsJsonAny::boolean(true));
#else
features->set("mr", SrsAmf0Any::boolean(false));
features->set("mr", SrsJsonAny::boolean(false));
#endif
return srs_api_response(w, r, obj->to_json());
@ -637,40 +637,40 @@ int SrsGoApiRequests::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
{
SrsStatistic* stat = SrsStatistic::instance();
SrsAmf0Object* obj = SrsAmf0Any::object();
SrsAutoFree(SrsAmf0Object, obj);
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
obj->set("code", SrsAmf0Any::number(ERROR_SUCCESS));
obj->set("server", SrsAmf0Any::number(stat->server_id()));
obj->set("code", SrsJsonAny::number(ERROR_SUCCESS));
obj->set("server", SrsJsonAny::number(stat->server_id()));
SrsAmf0Object* data = SrsAmf0Any::object();
SrsJsonObject* data = SrsJsonAny::object();
obj->set("data", data);
data->set("uri", SrsAmf0Any::str(r->uri().c_str()));
data->set("path", SrsAmf0Any::str(r->path().c_str()));
data->set("uri", SrsJsonAny::str(r->uri().c_str()));
data->set("path", SrsJsonAny::str(r->path().c_str()));
// method
data->set("METHOD", SrsAmf0Any::str(r->method_str().c_str()));
data->set("METHOD", SrsJsonAny::str(r->method_str().c_str()));
// request headers
SrsAmf0Object* headers = SrsAmf0Any::object();
SrsJsonObject* headers = SrsJsonAny::object();
data->set("headers", headers);
for (int i = 0; i < r->request_header_count(); i++) {
std::string key = r->request_header_key_at(i);
std::string value = r->request_header_value_at(i);
headers->set(key, SrsAmf0Any::str(value.c_str()));
headers->set(key, SrsJsonAny::str(value.c_str()));
}
// server informations
SrsAmf0Object* server = SrsAmf0Any::object();
SrsJsonObject* server = SrsJsonAny::object();
data->set("headers", server);
server->set("sigature", SrsAmf0Any::str(RTMP_SIG_SRS_KEY));
server->set("name", SrsAmf0Any::str(RTMP_SIG_SRS_NAME));
server->set("version", SrsAmf0Any::str(RTMP_SIG_SRS_VERSION));
server->set("link", SrsAmf0Any::str(RTMP_SIG_SRS_URL));
server->set("time", SrsAmf0Any::number(srs_get_system_time_ms()));
server->set("sigature", SrsJsonAny::str(RTMP_SIG_SRS_KEY));
server->set("name", SrsJsonAny::str(RTMP_SIG_SRS_NAME));
server->set("version", SrsJsonAny::str(RTMP_SIG_SRS_VERSION));
server->set("link", SrsJsonAny::str(RTMP_SIG_SRS_URL));
server->set("time", SrsJsonAny::number(srs_get_system_time_ms()));
return srs_api_response(w, r, obj->to_json());
}
@ -700,22 +700,22 @@ int SrsGoApiVhosts::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
return srs_api_response_code(w, r, ret);
}
SrsAmf0Object* obj = SrsAmf0Any::object();
SrsAutoFree(SrsAmf0Object, obj);
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
obj->set("code", SrsAmf0Any::number(ERROR_SUCCESS));
obj->set("server", SrsAmf0Any::number(stat->server_id()));
obj->set("code", SrsJsonAny::number(ERROR_SUCCESS));
obj->set("server", SrsJsonAny::number(stat->server_id()));
if (r->is_http_get()) {
if (!vhost) {
SrsAmf0StrictArray* data = SrsAmf0Any::strict_array();
SrsJsonArray* data = SrsJsonAny::array();
obj->set("vhosts", data);
if ((ret = stat->dumps_vhosts(data)) != ERROR_SUCCESS) {
return srs_api_response_code(w, r, ret);
}
} else {
SrsAmf0Object* data = SrsAmf0Any::object();
SrsJsonObject* data = SrsJsonAny::object();
obj->set("vhost", data);;
if ((ret = vhost->dumps(data)) != ERROR_SUCCESS) {
@ -754,22 +754,22 @@ int SrsGoApiStreams::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
return srs_api_response_code(w, r, ret);
}
SrsAmf0Object* obj = SrsAmf0Any::object();
SrsAutoFree(SrsAmf0Object, obj);
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
obj->set("code", SrsAmf0Any::number(ERROR_SUCCESS));
obj->set("server", SrsAmf0Any::number(stat->server_id()));
obj->set("code", SrsJsonAny::number(ERROR_SUCCESS));
obj->set("server", SrsJsonAny::number(stat->server_id()));
if (r->is_http_get()) {
if (!stream) {
SrsAmf0StrictArray* data = SrsAmf0Any::strict_array();
SrsJsonArray* data = SrsJsonAny::array();
obj->set("streams", data);
if ((ret = stat->dumps_streams(data)) != ERROR_SUCCESS) {
return srs_api_response_code(w, r, ret);
}
} else {
SrsAmf0Object* data = SrsAmf0Any::object();
SrsJsonObject* data = SrsJsonAny::object();
obj->set("stream", data);;
if ((ret = stream->dumps(data)) != ERROR_SUCCESS) {
@ -808,22 +808,22 @@ int SrsGoApiClients::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
return srs_api_response_code(w, r, ret);
}
SrsAmf0Object* obj = SrsAmf0Any::object();
SrsAutoFree(SrsAmf0Object, obj);
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
obj->set("code", SrsAmf0Any::number(ERROR_SUCCESS));
obj->set("server", SrsAmf0Any::number(stat->server_id()));
obj->set("code", SrsJsonAny::number(ERROR_SUCCESS));
obj->set("server", SrsJsonAny::number(stat->server_id()));
if (r->is_http_get()) {
if (!client) {
SrsAmf0StrictArray* data = SrsAmf0Any::strict_array();
SrsJsonArray* data = SrsJsonAny::array();
obj->set("clients", data);
if ((ret = stat->dumps_clients(data, 0, 10)) != ERROR_SUCCESS) {
return srs_api_response_code(w, r, ret);
}
} else {
SrsAmf0Object* data = SrsAmf0Any::object();
SrsJsonObject* data = SrsJsonAny::object();
obj->set("client", data);;
if ((ret = client->dumps(data)) != ERROR_SUCCESS) {
@ -870,9 +870,9 @@ int SrsGoApiRaw::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
std::string rpc = r->query_get("rpc");
// the object to return for request.
SrsAmf0Object* obj = SrsAmf0Any::object();
SrsAutoFree(SrsAmf0Object, obj);
obj->set("code", SrsAmf0Any::number(ERROR_SUCCESS));
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
obj->set("code", SrsJsonAny::number(ERROR_SUCCESS));
// for rpc=raw, to query the raw api config for http api.
if (rpc == "raw") {
@ -952,14 +952,14 @@ int SrsGoApiRaw::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
return srs_api_response_code(w, r, ret);
}
SrsAmf0Object* data = SrsAmf0Any::object();
SrsJsonObject* data = SrsJsonAny::object();
obj->set("vhost", data);
if ((ret = _srs_config->vhost_to_json(conf, data)) != ERROR_SUCCESS) {
srs_error("raw api query vhost failed. ret=%d", ret);
return srs_api_response_code(w, r, ret);
}
} else if (scope == "minimal") {
SrsAmf0Object* data = SrsAmf0Any::object();
SrsJsonObject* data = SrsJsonAny::object();
obj->set("minimal", data);
// query minimal scope.
@ -968,7 +968,7 @@ int SrsGoApiRaw::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
return srs_api_response_code(w, r, ret);
}
} else {
SrsAmf0Object* data = SrsAmf0Any::object();
SrsJsonObject* data = SrsJsonAny::object();
obj->set("global", data);
// query global scope.

152
trunk/src/app/srs_app_http_hooks.cpp
View file

@ -63,16 +63,16 @@ int SrsHttpHooks::on_connect(string url, SrsRequest* req)
int client_id = _srs_context->get_id();
SrsAmf0Object* obj = SrsAmf0Any::object();
SrsAutoFree(SrsAmf0Object, obj);
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
obj->set("action", SrsAmf0Any::str("on_connect"));
obj->set("client_id", SrsAmf0Any::number(client_id));
obj->set("ip", SrsAmf0Any::str(req->ip.c_str()));
obj->set("vhost", SrsAmf0Any::str(req->vhost.c_str()));
obj->set("app", SrsAmf0Any::str(req->app.c_str()));
obj->set("tcUrl", SrsAmf0Any::str(req->tcUrl.c_str()));
obj->set("pageUrl", SrsAmf0Any::str(req->pageUrl.c_str()));
obj->set("action", SrsJsonAny::str("on_connect"));
obj->set("client_id", SrsJsonAny::number(client_id));
obj->set("ip", SrsJsonAny::str(req->ip.c_str()));
obj->set("vhost", SrsJsonAny::str(req->vhost.c_str()));
obj->set("app", SrsJsonAny::str(req->app.c_str()));
obj->set("tcUrl", SrsJsonAny::str(req->tcUrl.c_str()));
obj->set("pageUrl", SrsJsonAny::str(req->pageUrl.c_str()));
std::string data = obj->to_json();
std::string res;
@ -99,16 +99,16 @@ void SrsHttpHooks::on_close(string url, SrsRequest* req, int64_t send_bytes, int
int client_id = _srs_context->get_id();
SrsAmf0Object* obj = SrsAmf0Any::object();
SrsAutoFree(SrsAmf0Object, obj);
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
obj->set("action", SrsAmf0Any::str("on_close"));
obj->set("client_id", SrsAmf0Any::number(client_id));
obj->set("ip", SrsAmf0Any::str(req->ip.c_str()));
obj->set("vhost", SrsAmf0Any::str(req->vhost.c_str()));
obj->set("app", SrsAmf0Any::str(req->app.c_str()));
obj->set("send_bytes", SrsAmf0Any::number(send_bytes));
obj->set("recv_bytes", SrsAmf0Any::number(recv_bytes));
obj->set("action", SrsJsonAny::str("on_close"));
obj->set("client_id", SrsJsonAny::number(client_id));
obj->set("ip", SrsJsonAny::str(req->ip.c_str()));
obj->set("vhost", SrsJsonAny::str(req->vhost.c_str()));
obj->set("app", SrsJsonAny::str(req->app.c_str()));
obj->set("send_bytes", SrsJsonAny::number(send_bytes));
obj->set("recv_bytes", SrsJsonAny::number(recv_bytes));
std::string data = obj->to_json();
std::string res;
@ -135,15 +135,15 @@ int SrsHttpHooks::on_publish(string url, SrsRequest* req)
int client_id = _srs_context->get_id();
SrsAmf0Object* obj = SrsAmf0Any::object();
SrsAutoFree(SrsAmf0Object, obj);
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
obj->set("action", SrsAmf0Any::str("on_publish"));
obj->set("client_id", SrsAmf0Any::number(client_id));
obj->set("ip", SrsAmf0Any::str(req->ip.c_str()));
obj->set("vhost", SrsAmf0Any::str(req->vhost.c_str()));
obj->set("app", SrsAmf0Any::str(req->app.c_str()));
obj->set("stream", SrsAmf0Any::str(req->stream.c_str()));
obj->set("action", SrsJsonAny::str("on_publish"));
obj->set("client_id", SrsJsonAny::number(client_id));
obj->set("ip", SrsJsonAny::str(req->ip.c_str()));
obj->set("vhost", SrsJsonAny::str(req->vhost.c_str()));
obj->set("app", SrsJsonAny::str(req->app.c_str()));
obj->set("stream", SrsJsonAny::str(req->stream.c_str()));
std::string data = obj->to_json();
std::string res;
@ -170,15 +170,15 @@ void SrsHttpHooks::on_unpublish(string url, SrsRequest* req)
int client_id = _srs_context->get_id();
SrsAmf0Object* obj = SrsAmf0Any::object();
SrsAutoFree(SrsAmf0Object, obj);
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
obj->set("action", SrsAmf0Any::str("on_unpublish"));
obj->set("client_id", SrsAmf0Any::number(client_id));
obj->set("ip", SrsAmf0Any::str(req->ip.c_str()));
obj->set("vhost", SrsAmf0Any::str(req->vhost.c_str()));
obj->set("app", SrsAmf0Any::str(req->app.c_str()));
obj->set("stream", SrsAmf0Any::str(req->stream.c_str()));
obj->set("action", SrsJsonAny::str("on_unpublish"));
obj->set("client_id", SrsJsonAny::number(client_id));
obj->set("ip", SrsJsonAny::str(req->ip.c_str()));
obj->set("vhost", SrsJsonAny::str(req->vhost.c_str()));
obj->set("app", SrsJsonAny::str(req->app.c_str()));
obj->set("stream", SrsJsonAny::str(req->stream.c_str()));
std::string data = obj->to_json();
std::string res;
@ -205,16 +205,16 @@ int SrsHttpHooks::on_play(string url, SrsRequest* req)
int client_id = _srs_context->get_id();
SrsAmf0Object* obj = SrsAmf0Any::object();
SrsAutoFree(SrsAmf0Object, obj);
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
obj->set("action", SrsAmf0Any::str("on_play"));
obj->set("client_id", SrsAmf0Any::number(client_id));
obj->set("ip", SrsAmf0Any::str(req->ip.c_str()));
obj->set("vhost", SrsAmf0Any::str(req->vhost.c_str()));
obj->set("app", SrsAmf0Any::str(req->app.c_str()));
obj->set("stream", SrsAmf0Any::str(req->stream.c_str()));
obj->set("pageUrl", SrsAmf0Any::str(req->pageUrl.c_str()));
obj->set("action", SrsJsonAny::str("on_play"));
obj->set("client_id", SrsJsonAny::number(client_id));
obj->set("ip", SrsJsonAny::str(req->ip.c_str()));
obj->set("vhost", SrsJsonAny::str(req->vhost.c_str()));
obj->set("app", SrsJsonAny::str(req->app.c_str()));
obj->set("stream", SrsJsonAny::str(req->stream.c_str()));
obj->set("pageUrl", SrsJsonAny::str(req->pageUrl.c_str()));
std::string data = obj->to_json();
std::string res;
@ -241,15 +241,15 @@ void SrsHttpHooks::on_stop(string url, SrsRequest* req)
int client_id = _srs_context->get_id();
SrsAmf0Object* obj = SrsAmf0Any::object();
SrsAutoFree(SrsAmf0Object, obj);
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
obj->set("action", SrsAmf0Any::str("on_stop"));
obj->set("client_id", SrsAmf0Any::number(client_id));
obj->set("ip", SrsAmf0Any::str(req->ip.c_str()));
obj->set("vhost", SrsAmf0Any::str(req->vhost.c_str()));
obj->set("app", SrsAmf0Any::str(req->app.c_str()));
obj->set("stream", SrsAmf0Any::str(req->stream.c_str()));
obj->set("action", SrsJsonAny::str("on_stop"));
obj->set("client_id", SrsJsonAny::number(client_id));
obj->set("ip", SrsJsonAny::str(req->ip.c_str()));
obj->set("vhost", SrsJsonAny::str(req->vhost.c_str()));
obj->set("app", SrsJsonAny::str(req->app.c_str()));
obj->set("stream", SrsJsonAny::str(req->stream.c_str()));
std::string data = obj->to_json();
std::string res;
@ -277,17 +277,17 @@ int SrsHttpHooks::on_dvr(int cid, string url, SrsRequest* req, string file)
int client_id = cid;
std::string cwd = _srs_config->cwd();
SrsAmf0Object* obj = SrsAmf0Any::object();
SrsAutoFree(SrsAmf0Object, obj);
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
obj->set("action", SrsAmf0Any::str("on_dvr"));
obj->set("client_id", SrsAmf0Any::number(client_id));
obj->set("ip", SrsAmf0Any::str(req->ip.c_str()));
obj->set("vhost", SrsAmf0Any::str(req->vhost.c_str()));
obj->set("app", SrsAmf0Any::str(req->app.c_str()));
obj->set("stream", SrsAmf0Any::str(req->stream.c_str()));
obj->set("cwd", SrsAmf0Any::str(cwd.c_str()));
obj->set("file", SrsAmf0Any::str(file.c_str()));
obj->set("action", SrsJsonAny::str("on_dvr"));
obj->set("client_id", SrsJsonAny::number(client_id));
obj->set("ip", SrsJsonAny::str(req->ip.c_str()));
obj->set("vhost", SrsJsonAny::str(req->vhost.c_str()));
obj->set("app", SrsJsonAny::str(req->app.c_str()));
obj->set("stream", SrsJsonAny::str(req->stream.c_str()));
obj->set("cwd", SrsJsonAny::str(cwd.c_str()));
obj->set("file", SrsJsonAny::str(file.c_str()));
std::string data = obj->to_json();
std::string res;
@ -315,22 +315,22 @@ int SrsHttpHooks::on_hls(int cid, string url, SrsRequest* req, string file, stri
int client_id = cid;
std::string cwd = _srs_config->cwd();
SrsAmf0Object* obj = SrsAmf0Any::object();
SrsAutoFree(SrsAmf0Object, obj);
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
obj->set("action", SrsAmf0Any::str("on_hls"));
obj->set("client_id", SrsAmf0Any::number(client_id));
obj->set("ip", SrsAmf0Any::str(req->ip.c_str()));
obj->set("vhost", SrsAmf0Any::str(req->vhost.c_str()));
obj->set("app", SrsAmf0Any::str(req->app.c_str()));
obj->set("stream", SrsAmf0Any::str(req->stream.c_str()));
obj->set("duration", SrsAmf0Any::number(duration));
obj->set("cwd", SrsAmf0Any::str(cwd.c_str()));
obj->set("file", SrsAmf0Any::str(file.c_str()));
obj->set("url", SrsAmf0Any::str(url.c_str()));
obj->set("m3u8", SrsAmf0Any::str(m3u8.c_str()));
obj->set("m3u8_url", SrsAmf0Any::str(m3u8_url.c_str()));
obj->set("seq_no", SrsAmf0Any::number(sn));
obj->set("action", SrsJsonAny::str("on_hls"));
obj->set("client_id", SrsJsonAny::number(client_id));
obj->set("ip", SrsJsonAny::str(req->ip.c_str()));
obj->set("vhost", SrsJsonAny::str(req->vhost.c_str()));
obj->set("app", SrsJsonAny::str(req->app.c_str()));
obj->set("stream", SrsJsonAny::str(req->stream.c_str()));
obj->set("duration", SrsJsonAny::number(duration));
obj->set("cwd", SrsJsonAny::str(cwd.c_str()));
obj->set("file", SrsJsonAny::str(file.c_str()));
obj->set("url", SrsJsonAny::str(url.c_str()));
obj->set("m3u8", SrsJsonAny::str(m3u8.c_str()));
obj->set("m3u8_url", SrsJsonAny::str(m3u8_url.c_str()));
obj->set("seq_no", SrsJsonAny::number(sn));
std::string data = obj->to_json();
std::string res;

120
trunk/src/app/srs_app_statistic.cpp
View file

@ -58,7 +58,7 @@ SrsStatisticVhost::~SrsStatisticVhost()
srs_freep(kbps);
}
int SrsStatisticVhost::dumps(SrsAmf0Object* obj)
int SrsStatisticVhost::dumps(SrsJsonObject* obj)
{
int ret = ERROR_SUCCESS;
@ -66,26 +66,26 @@ int SrsStatisticVhost::dumps(SrsAmf0Object* obj)
bool hls_enabled = _srs_config->get_hls_enabled(vhost);
bool enabled = _srs_config->get_vhost_enabled(vhost);
obj->set("id", SrsAmf0Any::number(id));
obj->set("name", SrsAmf0Any::str(vhost.c_str()));
obj->set("enabled", SrsAmf0Any::boolean(enabled));
obj->set("clients", SrsAmf0Any::number(nb_clients));
obj->set("streams", SrsAmf0Any::number(nb_streams));
obj->set("send_bytes", SrsAmf0Any::number(kbps->get_send_bytes()));
obj->set("recv_bytes", SrsAmf0Any::number(kbps->get_recv_bytes()));
obj->set("id", SrsJsonAny::number(id));
obj->set("name", SrsJsonAny::str(vhost.c_str()));
obj->set("enabled", SrsJsonAny::boolean(enabled));
obj->set("clients", SrsJsonAny::number(nb_clients));
obj->set("streams", SrsJsonAny::number(nb_streams));
obj->set("send_bytes", SrsJsonAny::number(kbps->get_send_bytes()));
obj->set("recv_bytes", SrsJsonAny::number(kbps->get_recv_bytes()));
SrsAmf0Object* okbps = SrsAmf0Any::object();
SrsJsonObject* okbps = SrsJsonAny::object();
obj->set("kbps", okbps);
okbps->set("recv_30s", SrsAmf0Any::number(kbps->get_recv_kbps_30s()));
okbps->set("send_30s", SrsAmf0Any::number(kbps->get_send_kbps_30s()));
okbps->set("recv_30s", SrsJsonAny::number(kbps->get_recv_kbps_30s()));
okbps->set("send_30s", SrsJsonAny::number(kbps->get_send_kbps_30s()));
SrsAmf0Object* hls = SrsAmf0Any::object();
SrsJsonObject* hls = SrsJsonAny::object();
obj->set("hls", hls);
hls->set("enabled", SrsAmf0Any::boolean(hls_enabled));
hls->set("enabled", SrsJsonAny::boolean(hls_enabled));
if (hls_enabled) {
hls->set("fragment", SrsAmf0Any::number(_srs_config->get_hls_fragment(vhost)));
hls->set("fragment", SrsJsonAny::number(_srs_config->get_hls_fragment(vhost)));
}
return ret;
@ -122,54 +122,54 @@ SrsStatisticStream::~SrsStatisticStream()
srs_freep(kbps);
}
int SrsStatisticStream::dumps(SrsAmf0Object* obj)
int SrsStatisticStream::dumps(SrsJsonObject* obj)
{
int ret = ERROR_SUCCESS;
obj->set("id", SrsAmf0Any::number(id));
obj->set("name", SrsAmf0Any::str(stream.c_str()));
obj->set("vhost", SrsAmf0Any::number(vhost->id));
obj->set("app", SrsAmf0Any::str(app.c_str()));
obj->set("live_ms", SrsAmf0Any::number(srs_get_system_time_ms()));
obj->set("clients", SrsAmf0Any::number(nb_clients));
obj->set("send_bytes", SrsAmf0Any::number(kbps->get_send_bytes()));
obj->set("recv_bytes", SrsAmf0Any::number(kbps->get_recv_bytes()));
obj->set("id", SrsJsonAny::number(id));
obj->set("name", SrsJsonAny::str(stream.c_str()));
obj->set("vhost", SrsJsonAny::number(vhost->id));
obj->set("app", SrsJsonAny::str(app.c_str()));
obj->set("live_ms", SrsJsonAny::number(srs_get_system_time_ms()));
obj->set("clients", SrsJsonAny::number(nb_clients));
obj->set("send_bytes", SrsJsonAny::number(kbps->get_send_bytes()));
obj->set("recv_bytes", SrsJsonAny::number(kbps->get_recv_bytes()));
SrsAmf0Object* okbps = SrsAmf0Any::object();
SrsJsonObject* okbps = SrsJsonAny::object();
obj->set("kbps", okbps);
okbps->set("recv_30s", SrsAmf0Any::number(kbps->get_recv_kbps_30s()));
okbps->set("send_30s", SrsAmf0Any::number(kbps->get_send_kbps_30s()));
okbps->set("recv_30s", SrsJsonAny::number(kbps->get_recv_kbps_30s()));
okbps->set("send_30s", SrsJsonAny::number(kbps->get_send_kbps_30s()));
SrsAmf0Object* publish = SrsAmf0Any::object();
SrsJsonObject* publish = SrsJsonAny::object();
obj->set("publish", publish);
publish->set("active", SrsAmf0Any::boolean(active));
publish->set("cid", SrsAmf0Any::number(connection_cid));
publish->set("active", SrsJsonAny::boolean(active));
publish->set("cid", SrsJsonAny::number(connection_cid));
if (!has_video) {
obj->set("video", SrsAmf0Any::null());
obj->set("video", SrsJsonAny::null());
} else {
SrsAmf0Object* video = SrsAmf0Any::object();
SrsJsonObject* video = SrsJsonAny::object();
obj->set("video", video);
video->set("codec", SrsAmf0Any::str(srs_codec_video2str(vcodec).c_str()));
video->set("profile", SrsAmf0Any::str(srs_codec_avc_profile2str(avc_profile).c_str()));
video->set("level", SrsAmf0Any::str(srs_codec_avc_level2str(avc_level).c_str()));
video->set("width", SrsAmf0Any::number(width));
video->set("height", SrsAmf0Any::number(height));
video->set("codec", SrsJsonAny::str(srs_codec_video2str(vcodec).c_str()));
video->set("profile", SrsJsonAny::str(srs_codec_avc_profile2str(avc_profile).c_str()));
video->set("level", SrsJsonAny::str(srs_codec_avc_level2str(avc_level).c_str()));
video->set("width", SrsJsonAny::number(width));
video->set("height", SrsJsonAny::number(height));
}
if (!has_audio) {
obj->set("audio", SrsAmf0Any::null());
obj->set("audio", SrsJsonAny::null());
} else {
SrsAmf0Object* audio = SrsAmf0Any::object();
SrsJsonObject* audio = SrsJsonAny::object();
obj->set("audio", audio);
audio->set("codec", SrsAmf0Any::str(srs_codec_audio2str(acodec).c_str()));
audio->set("sample_rate", SrsAmf0Any::number(flv_sample_rates[asample_rate]));
audio->set("channel", SrsAmf0Any::number(asound_type + 1));
audio->set("profile", SrsAmf0Any::str(srs_codec_aac_object2str(aac_object).c_str()));
audio->set("codec", SrsJsonAny::str(srs_codec_audio2str(acodec).c_str()));
audio->set("sample_rate", SrsJsonAny::number(flv_sample_rates[asample_rate]));
audio->set("channel", SrsJsonAny::number(asound_type + 1));
audio->set("profile", SrsJsonAny::str(srs_codec_aac_object2str(aac_object).c_str()));
}
return ret;
@ -206,21 +206,21 @@ SrsStatisticClient::~SrsStatisticClient()
{
}
int SrsStatisticClient::dumps(SrsAmf0Object* obj)
int SrsStatisticClient::dumps(SrsJsonObject* obj)
{
int ret = ERROR_SUCCESS;
obj->set("id", SrsAmf0Any::number(id));
obj->set("vhost", SrsAmf0Any::number(stream->vhost->id));
obj->set("stream", SrsAmf0Any::number(stream->id));
obj->set("ip", SrsAmf0Any::str(req->ip.c_str()));
obj->set("pageUrl", SrsAmf0Any::str(req->pageUrl.c_str()));
obj->set("swfUrl", SrsAmf0Any::str(req->swfUrl.c_str()));
obj->set("tcUrl", SrsAmf0Any::str(req->tcUrl.c_str()));
obj->set("url", SrsAmf0Any::str(req->get_stream_url().c_str()));
obj->set("type", SrsAmf0Any::str(srs_client_type_string(type).c_str()));
obj->set("publish", SrsAmf0Any::boolean(srs_client_type_is_publish(type)));
obj->set("alive", SrsAmf0Any::number((srs_get_system_time_ms() - create) / 1000.0));
obj->set("id", SrsJsonAny::number(id));
obj->set("vhost", SrsJsonAny::number(stream->vhost->id));
obj->set("stream", SrsJsonAny::number(stream->id));
obj->set("ip", SrsJsonAny::str(req->ip.c_str()));
obj->set("pageUrl", SrsJsonAny::str(req->pageUrl.c_str()));
obj->set("swfUrl", SrsJsonAny::str(req->swfUrl.c_str()));
obj->set("tcUrl", SrsJsonAny::str(req->tcUrl.c_str()));
obj->set("url", SrsJsonAny::str(req->get_stream_url().c_str()));
obj->set("type", SrsJsonAny::str(srs_client_type_string(type).c_str()));
obj->set("publish", SrsJsonAny::boolean(srs_client_type_is_publish(type)));
obj->set("alive", SrsJsonAny::number((srs_get_system_time_ms() - create) / 1000.0));
return ret;
}
@ -456,7 +456,7 @@ int64_t SrsStatistic::server_id()
return _server_id;
}
int SrsStatistic::dumps_vhosts(SrsAmf0StrictArray* arr)
int SrsStatistic::dumps_vhosts(SrsJsonArray* arr)
{
int ret = ERROR_SUCCESS;
@ -464,7 +464,7 @@ int SrsStatistic::dumps_vhosts(SrsAmf0StrictArray* arr)
for (it = vhosts.begin(); it != vhosts.end(); it++) {
SrsStatisticVhost* vhost = it->second;
SrsAmf0Object* obj = SrsAmf0Any::object();
SrsJsonObject* obj = SrsJsonAny::object();
arr->append(obj);
if ((ret = vhost->dumps(obj)) != ERROR_SUCCESS) {
@ -475,7 +475,7 @@ int SrsStatistic::dumps_vhosts(SrsAmf0StrictArray* arr)
return ret;
}
int SrsStatistic::dumps_streams(SrsAmf0StrictArray* arr)
int SrsStatistic::dumps_streams(SrsJsonArray* arr)
{
int ret = ERROR_SUCCESS;
@ -483,7 +483,7 @@ int SrsStatistic::dumps_streams(SrsAmf0StrictArray* arr)
for (it = streams.begin(); it != streams.end(); it++) {
SrsStatisticStream* stream = it->second;
SrsAmf0Object* obj = SrsAmf0Any::object();
SrsJsonObject* obj = SrsJsonAny::object();
arr->append(obj);
if ((ret = stream->dumps(obj)) != ERROR_SUCCESS) {
@ -494,7 +494,7 @@ int SrsStatistic::dumps_streams(SrsAmf0StrictArray* arr)
return ret;
}
int SrsStatistic::dumps_clients(SrsAmf0StrictArray* arr, int start, int count)
int SrsStatistic::dumps_clients(SrsJsonArray* arr, int start, int count)
{
int ret = ERROR_SUCCESS;
@ -506,7 +506,7 @@ int SrsStatistic::dumps_clients(SrsAmf0StrictArray* arr, int start, int count)
SrsStatisticClient* client = it->second;
SrsAmf0Object* obj = SrsAmf0Any::object();
SrsJsonObject* obj = SrsJsonAny::object();
arr->append(obj);
if ((ret = client->dumps(obj)) != ERROR_SUCCESS) {

16
trunk/src/app/srs_app_statistic.hpp
View file

@ -40,8 +40,8 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
class SrsKbps;
class SrsRequest;
class SrsConnection;
class SrsAmf0Object;
class SrsAmf0StrictArray;
class SrsJsonObject;
class SrsJsonArray;
struct SrsStatisticVhost
{
@ -59,7 +59,7 @@ public:
SrsStatisticVhost();
virtual ~SrsStatisticVhost();
public:
virtual int dumps(SrsAmf0Object* obj);
virtual int dumps(SrsJsonObject* obj);
};
struct SrsStatisticStream
@ -104,7 +104,7 @@ public:
SrsStatisticStream();
virtual ~SrsStatisticStream();
public:
virtual int dumps(SrsAmf0Object* obj);
virtual int dumps(SrsJsonObject* obj);
public:
/**
* publish the stream.
@ -129,7 +129,7 @@ public:
SrsStatisticClient();
virtual ~SrsStatisticClient();
public:
virtual int dumps(SrsAmf0Object* obj);
virtual int dumps(SrsJsonObject* obj);
};
class SrsStatistic
@ -226,17 +226,17 @@ public:
/**
* dumps the vhosts to amf0 array.
*/
virtual int dumps_vhosts(SrsAmf0StrictArray* arr);
virtual int dumps_vhosts(SrsJsonArray* arr);
/**
* dumps the streams to amf0 array.
*/
virtual int dumps_streams(SrsAmf0StrictArray* arr);
virtual int dumps_streams(SrsJsonArray* arr);
/**
* dumps the clients to amf0 array
* @param start the start index, from 0.
* @param count the max count of clients to dump.
*/
virtual int dumps_clients(SrsAmf0StrictArray* arr, int start, int count);
virtual int dumps_clients(SrsJsonArray* arr, int start, int count);
private:
virtual SrsStatisticVhost* create_vhost(SrsRequest* req);
virtual SrsStatisticStream* create_stream(SrsStatisticVhost* vhost, SrsRequest* req);

86
trunk/src/app/srs_app_utility.cpp
View file

@ -1372,7 +1372,7 @@ bool srs_is_boolean(const string& str)
return str == "true" || str == "false";
}
void srs_api_dump_summaries(SrsAmf0Object* obj)
void srs_api_dump_summaries(SrsJsonObject* obj)
{
SrsRusage* r = srs_get_system_rusage();
SrsProcSelfStat* u = srs_get_self_proc_stat();
@ -1425,62 +1425,62 @@ void srs_api_dump_summaries(SrsAmf0Object* obj)
bool ok = (r->ok && u->ok && s->ok && c->ok
&& d->ok && m->ok && p->ok && nrs->ok);
SrsAmf0Object* data = SrsAmf0Any::object();
SrsJsonObject* data = SrsJsonAny::object();
obj->set("data", data);
data->set("ok", SrsAmf0Any::boolean(ok));
data->set("now_ms", SrsAmf0Any::number(now));
data->set("ok", SrsJsonAny::boolean(ok));
data->set("now_ms", SrsJsonAny::number(now));
// self
SrsAmf0Object* self = SrsAmf0Any::object();
SrsJsonObject* self = SrsJsonAny::object();
data->set("self", self);
self->set("version", SrsAmf0Any::str(RTMP_SIG_SRS_VERSION));
self->set("pid", SrsAmf0Any::number(getpid()));
self->set("ppid", SrsAmf0Any::number(u->ppid));
self->set("argv", SrsAmf0Any::str(_srs_config->argv().c_str()));
self->set("cwd", SrsAmf0Any::str(_srs_config->cwd().c_str()));
self->set("mem_kbyte", SrsAmf0Any::number(r->r.ru_maxrss));
self->set("mem_percent", SrsAmf0Any::number(self_mem_percent));
self->set("cpu_percent", SrsAmf0Any::number(u->percent));
self->set("srs_uptime", SrsAmf0Any::number(srs_uptime));
self->set("version", SrsJsonAny::str(RTMP_SIG_SRS_VERSION));
self->set("pid", SrsJsonAny::number(getpid()));
self->set("ppid", SrsJsonAny::number(u->ppid));
self->set("argv", SrsJsonAny::str(_srs_config->argv().c_str()));
self->set("cwd", SrsJsonAny::str(_srs_config->cwd().c_str()));
self->set("mem_kbyte", SrsJsonAny::number(r->r.ru_maxrss));
self->set("mem_percent", SrsJsonAny::number(self_mem_percent));
self->set("cpu_percent", SrsJsonAny::number(u->percent));
self->set("srs_uptime", SrsJsonAny::number(srs_uptime));
// system
SrsAmf0Object* sys = SrsAmf0Any::object();
SrsJsonObject* sys = SrsJsonAny::object();
data->set("system", sys);
sys->set("cpu_percent", SrsAmf0Any::number(s->percent));
sys->set("disk_read_KBps", SrsAmf0Any::number(d->in_KBps));
sys->set("disk_write_KBps", SrsAmf0Any::number(d->out_KBps));
sys->set("disk_busy_percent", SrsAmf0Any::number(d->busy));
sys->set("mem_ram_kbyte", SrsAmf0Any::number(m->MemTotal));
sys->set("mem_ram_percent", SrsAmf0Any::number(m->percent_ram));
sys->set("mem_swap_kbyte", SrsAmf0Any::number(m->SwapTotal));
sys->set("mem_swap_percent", SrsAmf0Any::number(m->percent_swap));
sys->set("cpus", SrsAmf0Any::number(c->nb_processors));
sys->set("cpus_online", SrsAmf0Any::number(c->nb_processors_online));
sys->set("uptime", SrsAmf0Any::number(p->os_uptime));
sys->set("ilde_time", SrsAmf0Any::number(p->os_ilde_time));
sys->set("load_1m", SrsAmf0Any::number(p->load_one_minutes));
sys->set("load_5m", SrsAmf0Any::number(p->load_five_minutes));
sys->set("load_15m", SrsAmf0Any::number(p->load_fifteen_minutes));
sys->set("cpu_percent", SrsJsonAny::number(s->percent));
sys->set("disk_read_KBps", SrsJsonAny::number(d->in_KBps));
sys->set("disk_write_KBps", SrsJsonAny::number(d->out_KBps));
sys->set("disk_busy_percent", SrsJsonAny::number(d->busy));
sys->set("mem_ram_kbyte", SrsJsonAny::number(m->MemTotal));
sys->set("mem_ram_percent", SrsJsonAny::number(m->percent_ram));
sys->set("mem_swap_kbyte", SrsJsonAny::number(m->SwapTotal));
sys->set("mem_swap_percent", SrsJsonAny::number(m->percent_swap));
sys->set("cpus", SrsJsonAny::number(c->nb_processors));
sys->set("cpus_online", SrsJsonAny::number(c->nb_processors_online));
sys->set("uptime", SrsJsonAny::number(p->os_uptime));
sys->set("ilde_time", SrsJsonAny::number(p->os_ilde_time));
sys->set("load_1m", SrsJsonAny::number(p->load_one_minutes));
sys->set("load_5m", SrsJsonAny::number(p->load_five_minutes));
sys->set("load_15m", SrsJsonAny::number(p->load_fifteen_minutes));
// system network bytes stat.
sys->set("net_sample_time", SrsAmf0Any::number(n_sample_time));
sys->set("net_sample_time", SrsJsonAny::number(n_sample_time));
// internet public address network device bytes.
sys->set("net_recv_bytes", SrsAmf0Any::number(nr_bytes));
sys->set("net_send_bytes", SrsAmf0Any::number(ns_bytes));
sys->set("net_recv_bytes", SrsJsonAny::number(nr_bytes));
sys->set("net_send_bytes", SrsJsonAny::number(ns_bytes));
// intranet private address network device bytes.
sys->set("net_recvi_bytes", SrsAmf0Any::number(nri_bytes));
sys->set("net_sendi_bytes", SrsAmf0Any::number(nsi_bytes));
sys->set("net_recvi_bytes", SrsJsonAny::number(nri_bytes));
sys->set("net_sendi_bytes", SrsJsonAny::number(nsi_bytes));
// srs network bytes stat.
sys->set("srs_sample_time", SrsAmf0Any::number(nrs->sample_time));
sys->set("srs_recv_bytes", SrsAmf0Any::number(nrs->rbytes));
sys->set("srs_send_bytes", SrsAmf0Any::number(nrs->sbytes));
sys->set("conn_sys", SrsAmf0Any::number(nrs->nb_conn_sys));
sys->set("conn_sys_et", SrsAmf0Any::number(nrs->nb_conn_sys_et));
sys->set("conn_sys_tw", SrsAmf0Any::number(nrs->nb_conn_sys_tw));
sys->set("conn_sys_udp", SrsAmf0Any::number(nrs->nb_conn_sys_udp));
sys->set("conn_srs", SrsAmf0Any::number(nrs->nb_conn_srs));
sys->set("srs_sample_time", SrsJsonAny::number(nrs->sample_time));
sys->set("srs_recv_bytes", SrsJsonAny::number(nrs->rbytes));
sys->set("srs_send_bytes", SrsJsonAny::number(nrs->sbytes));
sys->set("conn_sys", SrsJsonAny::number(nrs->nb_conn_sys));
sys->set("conn_sys_et", SrsJsonAny::number(nrs->nb_conn_sys_et));
sys->set("conn_sys_tw", SrsJsonAny::number(nrs->nb_conn_sys_tw));
sys->set("conn_sys_udp", SrsJsonAny::number(nrs->nb_conn_sys_udp));
sys->set("conn_srs", SrsJsonAny::number(nrs->nb_conn_srs));
}
string srs_join_vector_string(vector<string>& vs, string separator)

4
trunk/src/app/srs_app_utility.hpp
View file

@ -41,7 +41,7 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
class SrsKbps;
class SrsStream;
class SrsAmf0Object;
class SrsJsonObject;
// client open socket and connect to server.
extern int srs_socket_connect(std::string server, int port, int64_t timeout, st_netfd_t* pstfd);
@ -682,7 +682,7 @@ extern bool srs_is_digit_number(const std::string& str);
extern bool srs_is_boolean(const std::string& str);
// dump summaries for /api/v1/summaries.
extern void srs_api_dump_summaries(SrsAmf0Object* obj);
extern void srs_api_dump_summaries(SrsJsonObject* obj);
// join string in vector with indicated separator
extern std::string srs_join_vector_string(std::vector<std::string>& vs, std::string separator);

137
trunk/src/protocol/srs_protocol_json.cpp
View file

@ -23,10 +23,60 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#include <srs_protocol_json.hpp>
#include <sstream>
using namespace std;
#include <srs_kernel_log.hpp>
/* json encode
cout<< SRS_JOBJECT_START
<< SRS_JFIELD_STR("name", "srs") << SRS_JFIELD_CONT
<< SRS_JFIELD_ORG("version", 100) << SRS_JFIELD_CONT
<< SRS_JFIELD_NAME("features") << SRS_JOBJECT_START
<< SRS_JFIELD_STR("rtmp", "released") << SRS_JFIELD_CONT
<< SRS_JFIELD_STR("hls", "released") << SRS_JFIELD_CONT
<< SRS_JFIELD_STR("dash", "plan")
<< SRS_JOBJECT_END << SRS_JFIELD_CONT
<< SRS_JFIELD_STR("author", "srs team")
<< SRS_JOBJECT_END
it's:
cont<< "{"
<< "name:" << "srs" << ","
<< "version:" << 100 << ","
<< "features:" << "{"
<< "rtmp:" << "released" << ","
<< "hls:" << "released" << ","
<< "dash:" << "plan"
<< "}" << ","
<< "author:" << "srs team"
<< "}"
that is:
"""
{
"name": "srs",
"version": 100,
"features": {
"rtmp": "released",
"hls": "released",
"dash": "plan"
},
"author": "srs team"
}
"""
*/
#define SRS_JOBJECT_START "{"
#define SRS_JFIELD_NAME(k) "\"" << k << "\":"
#define SRS_JFIELD_OBJ(k) SRS_JFIELD_NAME(k) << SRS_JOBJECT_START
#define SRS_JFIELD_STR(k, v) SRS_JFIELD_NAME(k) << "\"" << v << "\""
#define SRS_JFIELD_ORG(k, v) SRS_JFIELD_NAME(k) << std::dec << v
#define SRS_JFIELD_BOOL(k, v) SRS_JFIELD_ORG(k, (v? "true":"false"))
#define SRS_JFIELD_NULL(k) SRS_JFIELD_NAME(k) << "null"
#define SRS_JFIELD_ERROR(ret) "\"" << "code" << "\":" << ret
#define SRS_JFIELD_CONT ","
#define SRS_JOBJECT_END "}"
#define SRS_JARRAY_START "["
#define SRS_JARRAY_END "]"
#ifdef SRS_JSON_USE_NXJSON
////////////////////////////////////////////////////////////////////////////////////////////////
@ -267,6 +317,46 @@ SrsJsonArray* SrsJsonAny::to_array()
return p;
}
string SrsJsonAny::to_json()
{
switch (marker) {
case SRS_JSON_String: {
return "\"" + to_str() + "\"";
}
case SRS_JSON_Boolean: {
return to_boolean()? "true":"false";
}
case SRS_JSON_Integer: {
// len(max int64_t) is 20, plus one "+-."
char tmp[22];
snprintf(tmp, 22, "%"PRId64, to_integer());
return tmp;
}
case SRS_JSON_Number: {
// len(max int64_t) is 20, plus one "+-."
char tmp[22];
snprintf(tmp, 22, "%.6f", to_number());
return tmp;
}
case SRS_JSON_Null: {
return "null";
}
case SRS_JSON_Object: {
SrsJsonObject* obj = to_object();
return obj->to_json();
}
case SRS_JSON_Array: {
SrsJsonArray* arr = to_array();
return arr->to_json();
}
default: {
break;
}
}
return "null";
}
SrsJsonAny* SrsJsonAny::str(const char* value)
{
return new SrsJsonString(value);
@ -402,6 +492,27 @@ SrsJsonAny* SrsJsonObject::value_at(int index)
return elem.second;
}
string SrsJsonObject::to_json()
{
stringstream ss;
ss << SRS_JOBJECT_START;
for (int i = 0; i < (int)properties.size(); i++) {
std::string name = this->key_at(i);
SrsJsonAny* any = this->value_at(i);
ss << SRS_JFIELD_NAME(name) << any->to_json();
if (i < (int)properties.size() - 1) {
ss << SRS_JFIELD_CONT;
}
}
ss << SRS_JOBJECT_END;
return ss.str();
}
void SrsJsonObject::set(string key, SrsJsonAny* value)
{
if (!value) {
@ -549,6 +660,32 @@ void SrsJsonArray::add(SrsJsonAny* value)
properties.push_back(value);
}
void SrsJsonArray::append(SrsJsonAny* value)
{
add(value);
}
string SrsJsonArray::to_json()
{
stringstream ss;
ss << SRS_JARRAY_START;
for (int i = 0; i < (int)properties.size(); i++) {
SrsJsonAny* any = properties[i];
ss << any->to_json();
if (i < (int)properties.size() - 1) {
ss << SRS_JFIELD_CONT;
}
}
ss << SRS_JARRAY_END;
return ss.str();
}
#ifdef SRS_JSON_USE_NXJSON
////////////////////////////////////////////////////////////////////////////////////////////////

20
trunk/src/protocol/srs_protocol_json.hpp
View file

@ -112,6 +112,12 @@ public:
* user must ensure the type is a ecma array, or assert failed.
*/
virtual SrsJsonArray* to_array();
// json
public:
/**
* convert the amf0 stuff to json.
*/
virtual std::string to_json();
public:
static SrsJsonAny* str(const char* value = NULL);
static SrsJsonAny* boolean(bool value = false);
@ -145,6 +151,12 @@ public:
virtual std::string key_at(int index);
// @remark: max index is count().
virtual SrsJsonAny* value_at(int index);
// json
public:
/**
* convert the amf0 object to json.
*/
virtual std::string to_json();
public:
virtual void set(std::string key, SrsJsonAny* value);
virtual SrsJsonAny* get_property(std::string name);
@ -171,6 +183,14 @@ public:
// @remark: max index is count().
virtual SrsJsonAny* at(int index);
virtual void add(SrsJsonAny* value);
// alias to add.
virtual void append(SrsJsonAny* value);
// json
public:
/**
* convert the amf0 ecma array to json.
*/
virtual std::string to_json();
};
////////////////////////////////////////////////////////////////////////

166
trunk/src/protocol/srs_rtmp_amf0.cpp
View file

@ -35,55 +35,6 @@ using namespace std;
using namespace _srs_internal;
/* json encode
cout<< SRS_JOBJECT_START
<< SRS_JFIELD_STR("name", "srs") << SRS_JFIELD_CONT
<< SRS_JFIELD_ORG("version", 100) << SRS_JFIELD_CONT
<< SRS_JFIELD_NAME("features") << SRS_JOBJECT_START
<< SRS_JFIELD_STR("rtmp", "released") << SRS_JFIELD_CONT
<< SRS_JFIELD_STR("hls", "released") << SRS_JFIELD_CONT
<< SRS_JFIELD_STR("dash", "plan")
<< SRS_JOBJECT_END << SRS_JFIELD_CONT
<< SRS_JFIELD_STR("author", "srs team")
<< SRS_JOBJECT_END
it's:
cont<< "{"
<< "name:" << "srs" << ","
<< "version:" << 100 << ","
<< "features:" << "{"
<< "rtmp:" << "released" << ","
<< "hls:" << "released" << ","
<< "dash:" << "plan"
<< "}" << ","
<< "author:" << "srs team"
<< "}"
that is:
"""
{
"name": "srs",
"version": 100,
"features": {
"rtmp": "released",
"hls": "released",
"dash": "plan"
},
"author": "srs team"
}
"""
*/
#define SRS_JOBJECT_START "{"
#define SRS_JFIELD_NAME(k) "\"" << k << "\":"
#define SRS_JFIELD_OBJ(k) SRS_JFIELD_NAME(k) << SRS_JOBJECT_START
#define SRS_JFIELD_STR(k, v) SRS_JFIELD_NAME(k) << "\"" << v << "\""
#define SRS_JFIELD_ORG(k, v) SRS_JFIELD_NAME(k) << std::dec << v
#define SRS_JFIELD_BOOL(k, v) SRS_JFIELD_ORG(k, (v? "true":"false"))
#define SRS_JFIELD_NULL(k) SRS_JFIELD_NAME(k) << "null"
#define SRS_JFIELD_ERROR(ret) "\"" << "code" << "\":" << ret
#define SRS_JFIELD_CONT ","
#define SRS_JOBJECT_END "}"
#define SRS_JARRAY_START "["
#define SRS_JARRAY_END "]"
// AMF0 marker
#define RTMP_AMF0_Number 0x00
#define RTMP_AMF0_Boolean 0x01
@ -331,60 +282,6 @@ char* SrsAmf0Any::human_print(char** pdata, int* psize)
return data;
}
string SrsAmf0Any::to_json()
{
switch (marker) {
case RTMP_AMF0_String: {
return "\"" + to_str() + "\"";
}
case RTMP_AMF0_Boolean: {
return to_boolean()? "true":"false";
}
case RTMP_AMF0_Number: {
double v = to_number();
int64_t iv = (int64_t)v;
// len(max int64_t) is 20, plus one "+-."
char tmp[22];
if (v == iv) {
snprintf(tmp, 22, "%"PRId64, iv);
} else {
snprintf(tmp, 22, "%.6f", to_number());
}
return tmp;
}
case RTMP_AMF0_Null: {
return "null";
}
case RTMP_AMF0_Undefined: {
return "null";
}
case RTMP_AMF0_Object: {
SrsAmf0Object* obj = to_object();
return obj->to_json();
}
case RTMP_AMF0_EcmaArray: {
SrsAmf0EcmaArray* arr = to_ecma_array();
return arr->to_json();
}
case RTMP_AMF0_StrictArray: {
SrsAmf0StrictArray* arr = to_strict_array();
return arr->to_json();
}
case RTMP_AMF0_Date: {
// TODO: FIXME: support amf0 data to json.
return "null";
}
case RTMP_AMF0_Invalid:
default: {
break;
}
}
return "null";
}
SrsAmf0Any* SrsAmf0Any::str(const char* value)
{
return new SrsAmf0String(value);
@ -846,27 +743,6 @@ SrsAmf0Any* SrsAmf0Object::copy()
return copy;
}
string SrsAmf0Object::to_json()
{
stringstream ss;
ss << SRS_JOBJECT_START;
for (int i = 0; i < properties->count(); i++) {
std::string name = this->key_at(i);
SrsAmf0Any* any = this->value_at(i);
ss << SRS_JFIELD_NAME(name) << any->to_json();
if (i < properties->count() - 1) {
ss << SRS_JFIELD_CONT;
}
}
ss << SRS_JOBJECT_END;
return ss.str();
}
void SrsAmf0Object::clear()
{
properties->clear();
@ -1068,27 +944,6 @@ SrsAmf0Any* SrsAmf0EcmaArray::copy()
return copy;
}
string SrsAmf0EcmaArray::to_json()
{
stringstream ss;
ss << SRS_JOBJECT_START;
for (int i = 0; i < properties->count(); i++) {
std::string name = this->key_at(i);
SrsAmf0Any* any = this->value_at(i);
ss << SRS_JFIELD_NAME(name) << any->to_json();
if (i < properties->count() - 1) {
ss << SRS_JFIELD_CONT;
}
}
ss << SRS_JOBJECT_END;
return ss.str();
}
void SrsAmf0EcmaArray::clear()
{
properties->clear();
@ -1264,27 +1119,6 @@ SrsAmf0Any* SrsAmf0StrictArray::copy()
return copy;
}
string SrsAmf0StrictArray::to_json()
{
stringstream ss;
ss << SRS_JARRAY_START;
for (int i = 0; i < (int)properties.size(); i++) {
SrsAmf0Any* any = properties[i];
ss << any->to_json();
if (i < (int)properties.size() - 1) {
ss << SRS_JFIELD_CONT;
}
}
ss << SRS_JARRAY_END;
return ss.str();
}
void SrsAmf0StrictArray::clear()
{
properties.clear();

24
trunk/src/protocol/srs_rtmp_amf0.hpp
View file

@ -272,12 +272,6 @@ public:
* @remark user must free the data returned or output by pdata.
*/
virtual char* human_print(char** pdata, int* psize);
// json
public:
/**
* convert the amf0 stuff to json.
*/
virtual std::string to_json();
// create AMF0 instance.
public:
/**
@ -357,12 +351,6 @@ public:
virtual int read(SrsStream* stream);
virtual int write(SrsStream* stream);
virtual SrsAmf0Any* copy();
// json
public:
/**
* convert the amf0 object to json.
*/
virtual std::string to_json();
// properties iteration
public:
/**
@ -446,12 +434,6 @@ public:
virtual int read(SrsStream* stream);
virtual int write(SrsStream* stream);
virtual SrsAmf0Any* copy();
// json
public:
/**
* convert the amf0 ecma array to json.
*/
virtual std::string to_json();
// properties iteration
public:
/**
@ -533,12 +515,6 @@ public:
virtual int read(SrsStream* stream);
virtual int write(SrsStream* stream);
virtual SrsAmf0Any* copy();
// json
public:
/**
* convert the amf0 strict array to json.
*/
virtual std::string to_json();
// properties iteration
public:
/**