胡斌 / srs

转到一个项目
Toggle navigation Toggle navigation pinning
winlin
e0219bd7 1 parent 66ffcad6

refine code, merge json encode to amf0.

内嵌 并排对比
正在显示 3 个修改的文件 包含 456 行增加 和 467 行删除
@@ -78,13 +78,12 @@ int srs_api_response_jsonp(ISrsHttpResponseWriter* w, string callback, string da @@ -78,13 +78,12 @@ int srs_api_response_jsonp(ISrsHttpResponseWriter* w, string callback, string da
78 78
79 int srs_api_response_jsonp_code(ISrsHttpResponseWriter* w, string callback, int code) 79 int srs_api_response_jsonp_code(ISrsHttpResponseWriter* w, string callback, int code)
80 { 80 {
81 - std::stringstream ss; 81 + SrsAmf0Object* obj = SrsAmf0Any::object();
  82 + SrsAutoFree(SrsAmf0Object, obj);
82 83
83 - ss << SRS_JOBJECT_START  
84 - << SRS_JFIELD_ERROR(code)  
85 - << SRS_JOBJECT_END; 84 + obj->set("code", SrsAmf0Any::number(code));
86 85
87 - return srs_api_response_jsonp(w, callback, ss.str()); 86 + return srs_api_response_jsonp(w, callback, obj->to_json());
88 } 87 }
89 88
90 int srs_api_response_json(ISrsHttpResponseWriter* w, string data) 89 int srs_api_response_json(ISrsHttpResponseWriter* w, string data)
@@ -99,13 +98,12 @@ int srs_api_response_json(ISrsHttpResponseWriter* w, string data) @@ -99,13 +98,12 @@ int srs_api_response_json(ISrsHttpResponseWriter* w, string data)
99 98
100 int srs_api_response_json_code(ISrsHttpResponseWriter* w, int code) 99 int srs_api_response_json_code(ISrsHttpResponseWriter* w, int code)
101 { 100 {
102 - std::stringstream ss; 101 + SrsAmf0Object* obj = SrsAmf0Any::object();
  102 + SrsAutoFree(SrsAmf0Object, obj);
103 103
104 - ss << SRS_JOBJECT_START  
105 - << SRS_JFIELD_ERROR(code)  
106 - << SRS_JOBJECT_END; 104 + obj->set("code", SrsAmf0Any::number(code));
107 105
108 - return srs_api_response_json(w, ss.str()); 106 + return srs_api_response_json(w, obj->to_json());
109 } 107 }
110 108
111 int srs_api_response(ISrsHttpResponseWriter* w, ISrsHttpMessage* r, std::string json) 109 int srs_api_response(ISrsHttpResponseWriter* w, ISrsHttpMessage* r, std::string json)
@@ -143,17 +141,19 @@ SrsGoApiRoot::~SrsGoApiRoot() @@ -143,17 +141,19 @@ SrsGoApiRoot::~SrsGoApiRoot()
143 int SrsGoApiRoot::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r) 141 int SrsGoApiRoot::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
144 { 142 {
145 SrsStatistic* stat = SrsStatistic::instance(); 143 SrsStatistic* stat = SrsStatistic::instance();
146 - std::stringstream ss;  
147 144
148 - ss << SRS_JOBJECT_START  
149 - << SRS_JFIELD_ERROR(ERROR_SUCCESS) << SRS_JFIELD_CONT  
150 - << SRS_JFIELD_ORG("server", stat->server_id()) << SRS_JFIELD_CONT  
151 - << SRS_JFIELD_ORG("urls", SRS_JOBJECT_START)  
152 - << SRS_JFIELD_STR("api", "the api root")  
153 - << SRS_JOBJECT_END  
154 - << SRS_JOBJECT_END; 145 + SrsAmf0Object* obj = SrsAmf0Any::object();
  146 + SrsAutoFree(SrsAmf0Object, obj);
  147 +
  148 + obj->set("code", SrsAmf0Any::number(ERROR_SUCCESS));
  149 + obj->set("server", SrsAmf0Any::number(stat->server_id()));
  150 +
  151 + SrsAmf0Object* urls = SrsAmf0Any::object();
  152 + obj->set("urls", urls);
  153 +
  154 + urls->set("api", SrsAmf0Any::str("the api root"));
155 155
156 - return srs_api_response(w, r, ss.str()); 156 + return srs_api_response(w, r, obj->to_json());
157 } 157 }
158 158
159 SrsGoApiApi::SrsGoApiApi() 159 SrsGoApiApi::SrsGoApiApi()
@@ -167,17 +167,19 @@ SrsGoApiApi::~SrsGoApiApi() @@ -167,17 +167,19 @@ SrsGoApiApi::~SrsGoApiApi()
167 int SrsGoApiApi::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r) 167 int SrsGoApiApi::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
168 { 168 {
169 SrsStatistic* stat = SrsStatistic::instance(); 169 SrsStatistic* stat = SrsStatistic::instance();
170 - std::stringstream ss;  
171 170
172 - ss << SRS_JOBJECT_START  
173 - << SRS_JFIELD_ERROR(ERROR_SUCCESS) << SRS_JFIELD_CONT  
174 - << SRS_JFIELD_ORG("server", stat->server_id()) << SRS_JFIELD_CONT  
175 - << SRS_JFIELD_ORG("urls", SRS_JOBJECT_START)  
176 - << SRS_JFIELD_STR("v1", "the api version 1.0")  
177 - << SRS_JOBJECT_END  
178 - << SRS_JOBJECT_END;  
179 -  
180 - return srs_api_response(w, r, ss.str()); 171 + SrsAmf0Object* obj = SrsAmf0Any::object();
  172 + SrsAutoFree(SrsAmf0Object, obj);
  173 +
  174 + obj->set("code", SrsAmf0Any::number(ERROR_SUCCESS));
  175 + obj->set("server", SrsAmf0Any::number(stat->server_id()));
  176 +
  177 + SrsAmf0Object* urls = SrsAmf0Any::object();
  178 + obj->set("urls", urls);
  179 +
  180 + urls->set("v1", SrsAmf0Any::str("the api version 1.0"));
  181 +
  182 + return srs_api_response(w, r, obj->to_json());
181 } 183 }
182 184
183 SrsGoApiV1::SrsGoApiV1() 185 SrsGoApiV1::SrsGoApiV1()
@@ -191,35 +193,39 @@ SrsGoApiV1::~SrsGoApiV1() @@ -191,35 +193,39 @@ SrsGoApiV1::~SrsGoApiV1()
191 int SrsGoApiV1::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r) 193 int SrsGoApiV1::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
192 { 194 {
193 SrsStatistic* stat = SrsStatistic::instance(); 195 SrsStatistic* stat = SrsStatistic::instance();
194 - std::stringstream ss;  
195 196
196 - ss << SRS_JOBJECT_START  
197 - << SRS_JFIELD_ERROR(ERROR_SUCCESS) << SRS_JFIELD_CONT  
198 - << SRS_JFIELD_ORG("server", stat->server_id()) << SRS_JFIELD_CONT  
199 - << SRS_JFIELD_ORG("urls", SRS_JOBJECT_START)  
200 - << SRS_JFIELD_STR("versions", "the version of SRS") << SRS_JFIELD_CONT  
201 - << SRS_JFIELD_STR("summaries", "the summary(pid, argv, pwd, cpu, mem) of SRS") << SRS_JFIELD_CONT  
202 - << SRS_JFIELD_STR("rusages", "the rusage of SRS") << SRS_JFIELD_CONT  
203 - << SRS_JFIELD_STR("self_proc_stats", "the self process stats") << SRS_JFIELD_CONT  
204 - << SRS_JFIELD_STR("system_proc_stats", "the system process stats") << SRS_JFIELD_CONT  
205 - << SRS_JFIELD_STR("meminfos", "the meminfo of system") << SRS_JFIELD_CONT  
206 - << SRS_JFIELD_STR("authors", "the license, copyright, authors and contributors") << SRS_JFIELD_CONT  
207 - << SRS_JFIELD_STR("features", "the supported features of SRS") << SRS_JFIELD_CONT  
208 - << SRS_JFIELD_STR("requests", "the request itself, for http debug") << SRS_JFIELD_CONT  
209 - << SRS_JFIELD_STR("vhosts", "manage all vhosts or specified vhost") << SRS_JFIELD_CONT  
210 - << SRS_JFIELD_STR("streams", "manage all streams or specified stream") << SRS_JFIELD_CONT  
211 - << SRS_JFIELD_STR("clients", "manage all clients or specified client, default query top 10 clients") << SRS_JFIELD_CONT  
212 - << SRS_JFIELD_STR("raw", "raw api for srs, support CUID srs for instance the config") << SRS_JFIELD_CONT  
213 - << SRS_JFIELD_ORG("tests", SRS_JOBJECT_START)  
214 - << SRS_JFIELD_STR("requests", "show the request info") << SRS_JFIELD_CONT  
215 - << SRS_JFIELD_STR("errors", "always return an error 100") << SRS_JFIELD_CONT  
216 - << SRS_JFIELD_STR("redirects", "always redirect to /api/v1/test/errors") << SRS_JFIELD_CONT  
217 - << SRS_JFIELD_STR("[vhost]", "http vhost for http://error.srs.com:1985/api/v1/tests/errors")  
218 - << SRS_JOBJECT_END  
219 - << SRS_JOBJECT_END  
220 - << SRS_JOBJECT_END; 197 + SrsAmf0Object* obj = SrsAmf0Any::object();
  198 + SrsAutoFree(SrsAmf0Object, obj);
  199 +
  200 + obj->set("code", SrsAmf0Any::number(ERROR_SUCCESS));
  201 + obj->set("server", SrsAmf0Any::number(stat->server_id()));
221 202
222 - return srs_api_response(w, r, ss.str()); 203 + SrsAmf0Object* urls = SrsAmf0Any::object();
  204 + obj->set("urls", urls);
  205 +
  206 + urls->set("versions", SrsAmf0Any::str("the version of SRS"));
  207 + urls->set("summaries", SrsAmf0Any::str("the summary(pid, argv, pwd, cpu, mem) of SRS"));
  208 + urls->set("rusages", SrsAmf0Any::str("the rusage of SRS"));
  209 + urls->set("self_proc_stats", SrsAmf0Any::str("the self process stats"));
  210 + urls->set("system_proc_stats", SrsAmf0Any::str("the system process stats"));
  211 + urls->set("meminfos", SrsAmf0Any::str("the meminfo of system"));
  212 + urls->set("authors", SrsAmf0Any::str("the license, copyright, authors and contributors"));
  213 + urls->set("features", SrsAmf0Any::str("the supported features of SRS"));
  214 + urls->set("requests", SrsAmf0Any::str("the request itself, for http debug"));
  215 + urls->set("vhosts", SrsAmf0Any::str("manage all vhosts or specified vhost"));
  216 + urls->set("streams", SrsAmf0Any::str("manage all streams or specified stream"));
  217 + urls->set("clients", SrsAmf0Any::str("manage all clients or specified client, default query top 10 clients"));
  218 + urls->set("raw", SrsAmf0Any::str("raw api for srs, support CUID srs for instance the config"));
  219 +
  220 + SrsAmf0Object* tests = SrsAmf0Any::object();
  221 + obj->set("tests", tests);
  222 +
  223 + tests->set("requests", SrsAmf0Any::str("show the request info"));
  224 + tests->set("errors", SrsAmf0Any::str("always return an error 100"));
  225 + tests->set("redirects", SrsAmf0Any::str("always redirect to /api/v1/test/errors"));
  226 + tests->set("[vhost]", SrsAmf0Any::str("http vhost for http://error.srs.com:1985/api/v1/tests/errors"));
  227 +
  228 + return srs_api_response(w, r, obj->to_json());
223 } 229 }
224 230
225 SrsGoApiVersion::SrsGoApiVersion() 231 SrsGoApiVersion::SrsGoApiVersion()
@@ -233,20 +239,22 @@ SrsGoApiVersion::~SrsGoApiVersion() @@ -233,20 +239,22 @@ SrsGoApiVersion::~SrsGoApiVersion()
233 int SrsGoApiVersion::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r) 239 int SrsGoApiVersion::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
234 { 240 {
235 SrsStatistic* stat = SrsStatistic::instance(); 241 SrsStatistic* stat = SrsStatistic::instance();
236 - std::stringstream ss;  
237 242
238 - ss << SRS_JOBJECT_START  
239 - << SRS_JFIELD_ERROR(ERROR_SUCCESS) << SRS_JFIELD_CONT  
240 - << SRS_JFIELD_ORG("server", stat->server_id()) << SRS_JFIELD_CONT  
241 - << SRS_JFIELD_ORG("data", SRS_JOBJECT_START)  
242 - << SRS_JFIELD_ORG("major", VERSION_MAJOR) << SRS_JFIELD_CONT  
243 - << SRS_JFIELD_ORG("minor", VERSION_MINOR) << SRS_JFIELD_CONT  
244 - << SRS_JFIELD_ORG("revision", VERSION_REVISION) << SRS_JFIELD_CONT  
245 - << SRS_JFIELD_STR("version", RTMP_SIG_SRS_VERSION)  
246 - << SRS_JOBJECT_END  
247 - << SRS_JOBJECT_END; 243 + SrsAmf0Object* obj = SrsAmf0Any::object();
  244 + SrsAutoFree(SrsAmf0Object, obj);
  245 +
  246 + obj->set("code", SrsAmf0Any::number(ERROR_SUCCESS));
  247 + obj->set("server", SrsAmf0Any::number(stat->server_id()));
248 248
249 - return srs_api_response(w, r, ss.str()); 249 + SrsAmf0Object* data = SrsAmf0Any::object();
  250 + obj->set("data", data);
  251 +
  252 + data->set("major", SrsAmf0Any::number(VERSION_MAJOR));
  253 + data->set("minor", SrsAmf0Any::number(VERSION_MINOR));
  254 + data->set("revision", SrsAmf0Any::number(VERSION_REVISION));
  255 + data->set("version", SrsAmf0Any::str(RTMP_SIG_SRS_VERSION));
  256 +
  257 + return srs_api_response(w, r, obj->to_json());
250 } 258 }
251 259
252 SrsGoApiSummaries::SrsGoApiSummaries() 260 SrsGoApiSummaries::SrsGoApiSummaries()
@@ -275,36 +283,38 @@ SrsGoApiRusages::~SrsGoApiRusages() @@ -275,36 +283,38 @@ SrsGoApiRusages::~SrsGoApiRusages()
275 int SrsGoApiRusages::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r) 283 int SrsGoApiRusages::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
276 { 284 {
277 SrsStatistic* stat = SrsStatistic::instance(); 285 SrsStatistic* stat = SrsStatistic::instance();
278 - std::stringstream ss;  
279 286
280 - SrsRusage* ru = srs_get_system_rusage(); 287 + SrsAmf0Object* obj = SrsAmf0Any::object();
  288 + SrsAutoFree(SrsAmf0Object, obj);
281 289
282 - ss << SRS_JOBJECT_START  
283 - << SRS_JFIELD_ERROR(ERROR_SUCCESS) << SRS_JFIELD_CONT  
284 - << SRS_JFIELD_ORG("server", stat->server_id()) << SRS_JFIELD_CONT  
285 - << SRS_JFIELD_ORG("data", SRS_JOBJECT_START)  
286 - << SRS_JFIELD_ORG("ok", (ru->ok? "true":"false")) << SRS_JFIELD_CONT  
287 - << SRS_JFIELD_ORG("sample_time", ru->sample_time) << SRS_JFIELD_CONT  
288 - << SRS_JFIELD_ORG("ru_utime", ru->r.ru_utime.tv_sec) << SRS_JFIELD_CONT  
289 - << SRS_JFIELD_ORG("ru_stime", ru->r.ru_stime.tv_sec) << SRS_JFIELD_CONT  
290 - << SRS_JFIELD_ORG("ru_maxrss", ru->r.ru_maxrss) << SRS_JFIELD_CONT  
291 - << SRS_JFIELD_ORG("ru_ixrss", ru->r.ru_ixrss) << SRS_JFIELD_CONT  
292 - << SRS_JFIELD_ORG("ru_idrss", ru->r.ru_idrss) << SRS_JFIELD_CONT  
293 - << SRS_JFIELD_ORG("ru_isrss", ru->r.ru_isrss) << SRS_JFIELD_CONT  
294 - << SRS_JFIELD_ORG("ru_minflt", ru->r.ru_minflt) << SRS_JFIELD_CONT  
295 - << SRS_JFIELD_ORG("ru_majflt", ru->r.ru_majflt) << SRS_JFIELD_CONT  
296 - << SRS_JFIELD_ORG("ru_nswap", ru->r.ru_nswap) << SRS_JFIELD_CONT  
297 - << SRS_JFIELD_ORG("ru_inblock", ru->r.ru_inblock) << SRS_JFIELD_CONT  
298 - << SRS_JFIELD_ORG("ru_oublock", ru->r.ru_oublock) << SRS_JFIELD_CONT  
299 - << SRS_JFIELD_ORG("ru_msgsnd", ru->r.ru_msgsnd) << SRS_JFIELD_CONT  
300 - << SRS_JFIELD_ORG("ru_msgrcv", ru->r.ru_msgrcv) << SRS_JFIELD_CONT  
301 - << SRS_JFIELD_ORG("ru_nsignals", ru->r.ru_nsignals) << SRS_JFIELD_CONT  
302 - << SRS_JFIELD_ORG("ru_nvcsw", ru->r.ru_nvcsw) << SRS_JFIELD_CONT  
303 - << SRS_JFIELD_ORG("ru_nivcsw", ru->r.ru_nivcsw)  
304 - << SRS_JOBJECT_END  
305 - << SRS_JOBJECT_END; 290 + obj->set("code", SrsAmf0Any::number(ERROR_SUCCESS));
  291 + obj->set("server", SrsAmf0Any::number(stat->server_id()));
306 292
307 - return srs_api_response(w, r, ss.str()); 293 + SrsAmf0Object* data = SrsAmf0Any::object();
  294 + obj->set("data", data);
  295 +
  296 + SrsRusage* ru = srs_get_system_rusage();
  297 +
  298 + data->set("ok", SrsAmf0Any::boolean(ru->ok? "true":"false"));
  299 + data->set("sample_time", SrsAmf0Any::number(ru->sample_time));
  300 + data->set("ru_utime", SrsAmf0Any::number(ru->r.ru_utime.tv_sec));
  301 + data->set("ru_stime", SrsAmf0Any::number(ru->r.ru_stime.tv_sec));
  302 + data->set("ru_maxrss", SrsAmf0Any::number(ru->r.ru_maxrss));
  303 + data->set("ru_ixrss", SrsAmf0Any::number(ru->r.ru_ixrss));
  304 + data->set("ru_idrss", SrsAmf0Any::number(ru->r.ru_idrss));
  305 + data->set("ru_isrss", SrsAmf0Any::number(ru->r.ru_isrss));
  306 + data->set("ru_minflt", SrsAmf0Any::number(ru->r.ru_minflt));
  307 + data->set("ru_majflt", SrsAmf0Any::number(ru->r.ru_majflt));
  308 + data->set("ru_nswap", SrsAmf0Any::number(ru->r.ru_nswap));
  309 + data->set("ru_inblock", SrsAmf0Any::number(ru->r.ru_inblock));
  310 + data->set("ru_oublock", SrsAmf0Any::number(ru->r.ru_oublock));
  311 + data->set("ru_msgsnd", SrsAmf0Any::number(ru->r.ru_msgsnd));
  312 + data->set("ru_msgrcv", SrsAmf0Any::number(ru->r.ru_msgrcv));
  313 + data->set("ru_nsignals", SrsAmf0Any::number(ru->r.ru_nsignals));
  314 + data->set("ru_nvcsw", SrsAmf0Any::number(ru->r.ru_nvcsw));
  315 + data->set("ru_nivcsw", SrsAmf0Any::number(ru->r.ru_nivcsw));
  316 +
  317 + return srs_api_response(w, r, obj->to_json());
308 } 318 }
309 319
310 SrsGoApiSelfProcStats::SrsGoApiSelfProcStats() 320 SrsGoApiSelfProcStats::SrsGoApiSelfProcStats()
@@ -318,65 +328,70 @@ SrsGoApiSelfProcStats::~SrsGoApiSelfProcStats() @@ -318,65 +328,70 @@ SrsGoApiSelfProcStats::~SrsGoApiSelfProcStats()
318 int SrsGoApiSelfProcStats::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r) 328 int SrsGoApiSelfProcStats::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
319 { 329 {
320 SrsStatistic* stat = SrsStatistic::instance(); 330 SrsStatistic* stat = SrsStatistic::instance();
321 - std::stringstream ss;  
322 331
323 - SrsProcSelfStat* u = srs_get_self_proc_stat(); 332 + SrsAmf0Object* obj = SrsAmf0Any::object();
  333 + SrsAutoFree(SrsAmf0Object, obj);
  334 +
  335 + obj->set("code", SrsAmf0Any::number(ERROR_SUCCESS));
  336 + obj->set("server", SrsAmf0Any::number(stat->server_id()));
324 337
325 - ss << SRS_JOBJECT_START  
326 - << SRS_JFIELD_ERROR(ERROR_SUCCESS) << SRS_JFIELD_CONT  
327 - << SRS_JFIELD_ORG("server", stat->server_id()) << SRS_JFIELD_CONT  
328 - << SRS_JFIELD_ORG("data", SRS_JOBJECT_START)  
329 - << SRS_JFIELD_ORG("ok", (u->ok? "true":"false")) << SRS_JFIELD_CONT  
330 - << SRS_JFIELD_ORG("sample_time", u->sample_time) << SRS_JFIELD_CONT  
331 - << SRS_JFIELD_ORG("percent", u->percent) << SRS_JFIELD_CONT  
332 - << SRS_JFIELD_ORG("pid", u->pid) << SRS_JFIELD_CONT  
333 - << SRS_JFIELD_STR("comm", u->comm) << SRS_JFIELD_CONT  
334 - << SRS_JFIELD_STR("state", u->state) << SRS_JFIELD_CONT  
335 - << SRS_JFIELD_ORG("ppid", u->ppid) << SRS_JFIELD_CONT  
336 - << SRS_JFIELD_ORG("pgrp", u->pgrp) << SRS_JFIELD_CONT  
337 - << SRS_JFIELD_ORG("session", u->session) << SRS_JFIELD_CONT  
338 - << SRS_JFIELD_ORG("tty_nr", u->tty_nr) << SRS_JFIELD_CONT  
339 - << SRS_JFIELD_ORG("tpgid", u->tpgid) << SRS_JFIELD_CONT  
340 - << SRS_JFIELD_ORG("flags", u->flags) << SRS_JFIELD_CONT  
341 - << SRS_JFIELD_ORG("minflt", u->minflt) << SRS_JFIELD_CONT  
342 - << SRS_JFIELD_ORG("cminflt", u->cminflt) << SRS_JFIELD_CONT  
343 - << SRS_JFIELD_ORG("majflt", u->majflt) << SRS_JFIELD_CONT  
344 - << SRS_JFIELD_ORG("cmajflt", u->cmajflt) << SRS_JFIELD_CONT  
345 - << SRS_JFIELD_ORG("utime", u->utime) << SRS_JFIELD_CONT  
346 - << SRS_JFIELD_ORG("stime", u->stime) << SRS_JFIELD_CONT  
347 - << SRS_JFIELD_ORG("cutime", u->cutime) << SRS_JFIELD_CONT  
348 - << SRS_JFIELD_ORG("cstime", u->cstime) << SRS_JFIELD_CONT  
349 - << SRS_JFIELD_ORG("priority", u->priority) << SRS_JFIELD_CONT  
350 - << SRS_JFIELD_ORG("nice", u->nice) << SRS_JFIELD_CONT  
351 - << SRS_JFIELD_ORG("num_threads", u->num_threads) << SRS_JFIELD_CONT  
352 - << SRS_JFIELD_ORG("itrealvalue", u->itrealvalue) << SRS_JFIELD_CONT  
353 - << SRS_JFIELD_ORG("starttime", u->starttime) << SRS_JFIELD_CONT  
354 - << SRS_JFIELD_ORG("vsize", u->vsize) << SRS_JFIELD_CONT  
355 - << SRS_JFIELD_ORG("rss", u->rss) << SRS_JFIELD_CONT  
356 - << SRS_JFIELD_ORG("rsslim", u->rsslim) << SRS_JFIELD_CONT  
357 - << SRS_JFIELD_ORG("startcode", u->startcode) << SRS_JFIELD_CONT  
358 - << SRS_JFIELD_ORG("endcode", u->endcode) << SRS_JFIELD_CONT  
359 - << SRS_JFIELD_ORG("startstack", u->startstack) << SRS_JFIELD_CONT  
360 - << SRS_JFIELD_ORG("kstkesp", u->kstkesp) << SRS_JFIELD_CONT  
361 - << SRS_JFIELD_ORG("kstkeip", u->kstkeip) << SRS_JFIELD_CONT  
362 - << SRS_JFIELD_ORG("signal", u->signal) << SRS_JFIELD_CONT  
363 - << SRS_JFIELD_ORG("blocked", u->blocked) << SRS_JFIELD_CONT  
364 - << SRS_JFIELD_ORG("sigignore", u->sigignore) << SRS_JFIELD_CONT  
365 - << SRS_JFIELD_ORG("sigcatch", u->sigcatch) << SRS_JFIELD_CONT  
366 - << SRS_JFIELD_ORG("wchan", u->wchan) << SRS_JFIELD_CONT  
367 - << SRS_JFIELD_ORG("nswap", u->nswap) << SRS_JFIELD_CONT  
368 - << SRS_JFIELD_ORG("cnswap", u->cnswap) << SRS_JFIELD_CONT  
369 - << SRS_JFIELD_ORG("exit_signal", u->exit_signal) << SRS_JFIELD_CONT  
370 - << SRS_JFIELD_ORG("processor", u->processor) << SRS_JFIELD_CONT  
371 - << SRS_JFIELD_ORG("rt_priority", u->rt_priority) << SRS_JFIELD_CONT  
372 - << SRS_JFIELD_ORG("policy", u->policy) << SRS_JFIELD_CONT  
373 - << SRS_JFIELD_ORG("delayacct_blkio_ticks", u->delayacct_blkio_ticks) << SRS_JFIELD_CONT  
374 - << SRS_JFIELD_ORG("guest_time", u->guest_time) << SRS_JFIELD_CONT  
375 - << SRS_JFIELD_ORG("cguest_time", u->cguest_time)  
376 - << SRS_JOBJECT_END  
377 - << SRS_JOBJECT_END; 338 + SrsAmf0Object* data = SrsAmf0Any::object();
  339 + obj->set("data", data);
378 340
379 - return srs_api_response(w, r, ss.str()); 341 + SrsProcSelfStat* u = srs_get_self_proc_stat();
  342 +
  343 + string state;
  344 + state += (char)u->state;
  345 +
  346 + data->set("ok", SrsAmf0Any::boolean(u->ok? "true":"false"));
  347 + data->set("sample_time", SrsAmf0Any::number(u->sample_time));
  348 + data->set("percent", SrsAmf0Any::number(u->percent));
  349 + data->set("pid", SrsAmf0Any::number(u->pid));
  350 + data->set("comm", SrsAmf0Any::str(u->comm));
  351 + data->set("state", SrsAmf0Any::str(state.c_str()));
  352 + data->set("ppid", SrsAmf0Any::number(u->ppid));
  353 + data->set("pgrp", SrsAmf0Any::number(u->pgrp));
  354 + data->set("session", SrsAmf0Any::number(u->session));
  355 + data->set("tty_nr", SrsAmf0Any::number(u->tty_nr));
  356 + data->set("tpgid", SrsAmf0Any::number(u->tpgid));
  357 + data->set("flags", SrsAmf0Any::number(u->flags));
  358 + data->set("minflt", SrsAmf0Any::number(u->minflt));
  359 + data->set("cminflt", SrsAmf0Any::number(u->cminflt));
  360 + data->set("majflt", SrsAmf0Any::number(u->majflt));
  361 + data->set("cmajflt", SrsAmf0Any::number(u->cmajflt));
  362 + data->set("utime", SrsAmf0Any::number(u->utime));
  363 + data->set("stime", SrsAmf0Any::number(u->stime));
  364 + data->set("cutime", SrsAmf0Any::number(u->cutime));
  365 + data->set("cstime", SrsAmf0Any::number(u->cstime));
  366 + data->set("priority", SrsAmf0Any::number(u->priority));
  367 + data->set("nice", SrsAmf0Any::number(u->nice));
  368 + data->set("num_threads", SrsAmf0Any::number(u->num_threads));
  369 + data->set("itrealvalue", SrsAmf0Any::number(u->itrealvalue));
  370 + data->set("starttime", SrsAmf0Any::number(u->starttime));
  371 + data->set("vsize", SrsAmf0Any::number(u->vsize));
  372 + data->set("rss", SrsAmf0Any::number(u->rss));
  373 + data->set("rsslim", SrsAmf0Any::number(u->rsslim));
  374 + data->set("startcode", SrsAmf0Any::number(u->startcode));
  375 + data->set("endcode", SrsAmf0Any::number(u->endcode));
  376 + data->set("startstack", SrsAmf0Any::number(u->startstack));
  377 + data->set("kstkesp", SrsAmf0Any::number(u->kstkesp));
  378 + data->set("kstkeip", SrsAmf0Any::number(u->kstkeip));
  379 + data->set("signal", SrsAmf0Any::number(u->signal));
  380 + data->set("blocked", SrsAmf0Any::number(u->blocked));
  381 + data->set("sigignore", SrsAmf0Any::number(u->sigignore));
  382 + data->set("sigcatch", SrsAmf0Any::number(u->sigcatch));
  383 + data->set("wchan", SrsAmf0Any::number(u->wchan));
  384 + data->set("nswap", SrsAmf0Any::number(u->nswap));
  385 + data->set("cnswap", SrsAmf0Any::number(u->cnswap));
  386 + data->set("exit_signal", SrsAmf0Any::number(u->exit_signal));
  387 + data->set("processor", SrsAmf0Any::number(u->processor));
  388 + data->set("rt_priority", SrsAmf0Any::number(u->rt_priority));
  389 + data->set("policy", SrsAmf0Any::number(u->policy));
  390 + data->set("delayacct_blkio_ticks", SrsAmf0Any::number(u->delayacct_blkio_ticks));
  391 + data->set("guest_time", SrsAmf0Any::number(u->guest_time));
  392 + data->set("cguest_time", SrsAmf0Any::number(u->cguest_time));
  393 +
  394 + return srs_api_response(w, r, obj->to_json());
380 } 395 }
381 396
382 SrsGoApiSystemProcStats::SrsGoApiSystemProcStats() 397 SrsGoApiSystemProcStats::SrsGoApiSystemProcStats()
@@ -390,30 +405,32 @@ SrsGoApiSystemProcStats::~SrsGoApiSystemProcStats() @@ -390,30 +405,32 @@ SrsGoApiSystemProcStats::~SrsGoApiSystemProcStats()
390 int SrsGoApiSystemProcStats::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r) 405 int SrsGoApiSystemProcStats::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
391 { 406 {
392 SrsStatistic* stat = SrsStatistic::instance(); 407 SrsStatistic* stat = SrsStatistic::instance();
393 - std::stringstream ss; 408 +
  409 + SrsAmf0Object* obj = SrsAmf0Any::object();
  410 + SrsAutoFree(SrsAmf0Object, obj);
  411 +
  412 + obj->set("code", SrsAmf0Any::number(ERROR_SUCCESS));
  413 + obj->set("server", SrsAmf0Any::number(stat->server_id()));
  414 +
  415 + SrsAmf0Object* data = SrsAmf0Any::object();
  416 + obj->set("data", data);
394 417
395 SrsProcSystemStat* s = srs_get_system_proc_stat(); 418 SrsProcSystemStat* s = srs_get_system_proc_stat();
396 419
397 - ss << SRS_JOBJECT_START  
398 - << SRS_JFIELD_ERROR(ERROR_SUCCESS) << SRS_JFIELD_CONT  
399 - << SRS_JFIELD_ORG("server", stat->server_id()) << SRS_JFIELD_CONT  
400 - << SRS_JFIELD_ORG("data", SRS_JOBJECT_START)  
401 - << SRS_JFIELD_ORG("ok", (s->ok? "true":"false")) << SRS_JFIELD_CONT  
402 - << SRS_JFIELD_ORG("sample_time", s->sample_time) << SRS_JFIELD_CONT  
403 - << SRS_JFIELD_ORG("percent", s->percent) << SRS_JFIELD_CONT  
404 - << SRS_JFIELD_ORG("user", s->user) << SRS_JFIELD_CONT  
405 - << SRS_JFIELD_ORG("nice", s->nice) << SRS_JFIELD_CONT  
406 - << SRS_JFIELD_ORG("sys", s->sys) << SRS_JFIELD_CONT  
407 - << SRS_JFIELD_ORG("idle", s->idle) << SRS_JFIELD_CONT  
408 - << SRS_JFIELD_ORG("iowait", s->iowait) << SRS_JFIELD_CONT  
409 - << SRS_JFIELD_ORG("irq", s->irq) << SRS_JFIELD_CONT  
410 - << SRS_JFIELD_ORG("softirq", s->softirq) << SRS_JFIELD_CONT  
411 - << SRS_JFIELD_ORG("steal", s->steal) << SRS_JFIELD_CONT  
412 - << SRS_JFIELD_ORG("guest", s->guest)  
413 - << SRS_JOBJECT_END  
414 - << SRS_JOBJECT_END; 420 + data->set("ok", SrsAmf0Any::boolean(s->ok? "true":"false"));
  421 + data->set("sample_time", SrsAmf0Any::number(s->sample_time));
  422 + data->set("percent", SrsAmf0Any::number(s->percent));
  423 + data->set("user", SrsAmf0Any::number(s->user));
  424 + data->set("nice", SrsAmf0Any::number(s->nice));
  425 + data->set("sys", SrsAmf0Any::number(s->sys));
  426 + data->set("idle", SrsAmf0Any::number(s->idle));
  427 + data->set("iowait", SrsAmf0Any::number(s->iowait));
  428 + data->set("irq", SrsAmf0Any::number(s->irq));
  429 + data->set("softirq", SrsAmf0Any::number(s->softirq));
  430 + data->set("steal", SrsAmf0Any::number(s->steal));
  431 + data->set("guest", SrsAmf0Any::number(s->guest));
415 432
416 - return srs_api_response(w, r, ss.str()); 433 + return srs_api_response(w, r, obj->to_json());
417 } 434 }
418 435
419 SrsGoApiMemInfos::SrsGoApiMemInfos() 436 SrsGoApiMemInfos::SrsGoApiMemInfos()
@@ -427,31 +444,33 @@ SrsGoApiMemInfos::~SrsGoApiMemInfos() @@ -427,31 +444,33 @@ SrsGoApiMemInfos::~SrsGoApiMemInfos()
427 int SrsGoApiMemInfos::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r) 444 int SrsGoApiMemInfos::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
428 { 445 {
429 SrsStatistic* stat = SrsStatistic::instance(); 446 SrsStatistic* stat = SrsStatistic::instance();
430 - std::stringstream ss; 447 +
  448 + SrsAmf0Object* obj = SrsAmf0Any::object();
  449 + SrsAutoFree(SrsAmf0Object, obj);
  450 +
  451 + obj->set("code", SrsAmf0Any::number(ERROR_SUCCESS));
  452 + obj->set("server", SrsAmf0Any::number(stat->server_id()));
  453 +
  454 + SrsAmf0Object* data = SrsAmf0Any::object();
  455 + obj->set("data", data);
431 456
432 SrsMemInfo* m = srs_get_meminfo(); 457 SrsMemInfo* m = srs_get_meminfo();
433 458
434 - ss << SRS_JOBJECT_START  
435 - << SRS_JFIELD_ERROR(ERROR_SUCCESS) << SRS_JFIELD_CONT  
436 - << SRS_JFIELD_ORG("server", stat->server_id()) << SRS_JFIELD_CONT  
437 - << SRS_JFIELD_ORG("data", SRS_JOBJECT_START)  
438 - << SRS_JFIELD_ORG("ok", (m->ok? "true":"false")) << SRS_JFIELD_CONT  
439 - << SRS_JFIELD_ORG("sample_time", m->sample_time) << SRS_JFIELD_CONT  
440 - << SRS_JFIELD_ORG("percent_ram", m->percent_ram) << SRS_JFIELD_CONT  
441 - << SRS_JFIELD_ORG("percent_swap", m->percent_swap) << SRS_JFIELD_CONT  
442 - << SRS_JFIELD_ORG("MemActive", m->MemActive) << SRS_JFIELD_CONT  
443 - << SRS_JFIELD_ORG("RealInUse", m->RealInUse) << SRS_JFIELD_CONT  
444 - << SRS_JFIELD_ORG("NotInUse", m->NotInUse) << SRS_JFIELD_CONT  
445 - << SRS_JFIELD_ORG("MemTotal", m->MemTotal) << SRS_JFIELD_CONT  
446 - << SRS_JFIELD_ORG("MemFree", m->MemFree) << SRS_JFIELD_CONT  
447 - << SRS_JFIELD_ORG("Buffers", m->Buffers) << SRS_JFIELD_CONT  
448 - << SRS_JFIELD_ORG("Cached", m->Cached) << SRS_JFIELD_CONT  
449 - << SRS_JFIELD_ORG("SwapTotal", m->SwapTotal) << SRS_JFIELD_CONT  
450 - << SRS_JFIELD_ORG("SwapFree", m->SwapFree)  
451 - << SRS_JOBJECT_END  
452 - << SRS_JOBJECT_END; 459 + data->set("ok", SrsAmf0Any::boolean(m->ok? "true":"false"));
  460 + data->set("sample_time", SrsAmf0Any::number(m->sample_time));
  461 + data->set("percent_ram", SrsAmf0Any::number(m->percent_ram));
  462 + data->set("percent_swap", SrsAmf0Any::number(m->percent_swap));
  463 + data->set("MemActive", SrsAmf0Any::number(m->MemActive));
  464 + data->set("RealInUse", SrsAmf0Any::number(m->RealInUse));
  465 + data->set("NotInUse", SrsAmf0Any::number(m->NotInUse));
  466 + data->set("MemTotal", SrsAmf0Any::number(m->MemTotal));
  467 + data->set("MemFree", SrsAmf0Any::number(m->MemFree));
  468 + data->set("Buffers", SrsAmf0Any::number(m->Buffers));
  469 + data->set("Cached", SrsAmf0Any::number(m->Cached));
  470 + data->set("SwapTotal", SrsAmf0Any::number(m->SwapTotal));
  471 + data->set("SwapFree", SrsAmf0Any::number(m->SwapFree));
453 472
454 - return srs_api_response(w, r, ss.str()); 473 + return srs_api_response(w, r, obj->to_json());
455 } 474 }
456 475
457 SrsGoApiAuthors::SrsGoApiAuthors() 476 SrsGoApiAuthors::SrsGoApiAuthors()
@@ -465,22 +484,24 @@ SrsGoApiAuthors::~SrsGoApiAuthors() @@ -465,22 +484,24 @@ SrsGoApiAuthors::~SrsGoApiAuthors()
465 int SrsGoApiAuthors::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r) 484 int SrsGoApiAuthors::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
466 { 485 {
467 SrsStatistic* stat = SrsStatistic::instance(); 486 SrsStatistic* stat = SrsStatistic::instance();
468 - std::stringstream ss;  
469 487
470 - ss << SRS_JOBJECT_START  
471 - << SRS_JFIELD_ERROR(ERROR_SUCCESS) << SRS_JFIELD_CONT  
472 - << SRS_JFIELD_ORG("server", stat->server_id()) << SRS_JFIELD_CONT  
473 - << SRS_JFIELD_ORG("data", SRS_JOBJECT_START)  
474 - << SRS_JFIELD_STR("primary", RTMP_SIG_SRS_PRIMARY) << SRS_JFIELD_CONT  
475 - << SRS_JFIELD_STR("license", RTMP_SIG_SRS_LICENSE) << SRS_JFIELD_CONT  
476 - << SRS_JFIELD_STR("copyright", RTMP_SIG_SRS_COPYRIGHT) << SRS_JFIELD_CONT  
477 - << SRS_JFIELD_STR("authors", RTMP_SIG_SRS_AUTHROS) << SRS_JFIELD_CONT  
478 - << SRS_JFIELD_STR("contributors_link", RTMP_SIG_SRS_CONTRIBUTORS_URL) << SRS_JFIELD_CONT  
479 - << SRS_JFIELD_STR("contributors", SRS_AUTO_CONSTRIBUTORS)  
480 - << SRS_JOBJECT_END  
481 - << SRS_JOBJECT_END; 488 + SrsAmf0Object* obj = SrsAmf0Any::object();
  489 + SrsAutoFree(SrsAmf0Object, obj);
482 490
483 - return srs_api_response(w, r, ss.str()); 491 + obj->set("code", SrsAmf0Any::number(ERROR_SUCCESS));
  492 + obj->set("server", SrsAmf0Any::number(stat->server_id()));
  493 +
  494 + SrsAmf0Object* data = SrsAmf0Any::object();
  495 + obj->set("data", data);
  496 +
  497 + data->set("primary", SrsAmf0Any::str(RTMP_SIG_SRS_PRIMARY));
  498 + data->set("license", SrsAmf0Any::str(RTMP_SIG_SRS_LICENSE));
  499 + data->set("copyright", SrsAmf0Any::str(RTMP_SIG_SRS_COPYRIGHT));
  500 + data->set("authors", SrsAmf0Any::str(RTMP_SIG_SRS_AUTHROS));
  501 + data->set("contributors_link", SrsAmf0Any::str(RTMP_SIG_SRS_CONTRIBUTORS_URL));
  502 + data->set("contributors", SrsAmf0Any::str(SRS_AUTO_CONSTRIBUTORS));
  503 +
  504 + return srs_api_response(w, r, obj->to_json());
484 } 505 }
485 506
486 SrsGoApiFeatures::SrsGoApiFeatures() 507 SrsGoApiFeatures::SrsGoApiFeatures()
@@ -494,119 +515,111 @@ SrsGoApiFeatures::~SrsGoApiFeatures() @@ -494,119 +515,111 @@ SrsGoApiFeatures::~SrsGoApiFeatures()
494 int SrsGoApiFeatures::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r) 515 int SrsGoApiFeatures::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
495 { 516 {
496 SrsStatistic* stat = SrsStatistic::instance(); 517 SrsStatistic* stat = SrsStatistic::instance();
497 - std::stringstream ss; 518 +
  519 + SrsAmf0Object* obj = SrsAmf0Any::object();
  520 + SrsAutoFree(SrsAmf0Object, obj);
  521 +
  522 + obj->set("code", SrsAmf0Any::number(ERROR_SUCCESS));
  523 + obj->set("server", SrsAmf0Any::number(stat->server_id()));
  524 +
  525 + SrsAmf0Object* data = SrsAmf0Any::object();
  526 + obj->set("data", data);
  527 +
  528 + data->set("options", SrsAmf0Any::str(SRS_AUTO_USER_CONFIGURE));
  529 + data->set("options2", SrsAmf0Any::str(SRS_AUTO_CONFIGURE));
  530 + data->set("build", SrsAmf0Any::str(SRS_AUTO_BUILD_DATE));
  531 + data->set("build2", SrsAmf0Any::str(SRS_AUTO_BUILD_TS));
  532 +
  533 + SrsAmf0Object* features = SrsAmf0Any::object();
  534 + data->set("features", features);
498 535
499 #ifdef SRS_AUTO_SSL 536 #ifdef SRS_AUTO_SSL
500 - bool ssl = true; 537 + features->set("ssl", SrsAmf0Any::boolean(true));
501 #else 538 #else
502 - bool ssl = false; 539 + features->set("ssl", SrsAmf0Any::boolean(false));
503 #endif 540 #endif
504 #ifdef SRS_AUTO_HLS 541 #ifdef SRS_AUTO_HLS
505 - bool hls = true; 542 + features->set("hls", SrsAmf0Any::boolean(true));
506 #else 543 #else
507 - bool hls = false; 544 + features->set("hls", SrsAmf0Any::boolean(false));
508 #endif 545 #endif
509 #ifdef SRS_AUTO_HDS 546 #ifdef SRS_AUTO_HDS
510 - bool hds = true; 547 + features->set("hds", SrsAmf0Any::boolean(true));
511 #else 548 #else
512 - bool hds = false; 549 + features->set("hds", SrsAmf0Any::boolean(false));
513 #endif 550 #endif
514 #ifdef SRS_AUTO_HTTP_CALLBACK 551 #ifdef SRS_AUTO_HTTP_CALLBACK
515 - bool callback = true; 552 + features->set("callback", SrsAmf0Any::boolean(true));
516 #else 553 #else
517 - bool callback = false; 554 + features->set("callback", SrsAmf0Any::boolean(false));
518 #endif 555 #endif
519 #ifdef SRS_AUTO_HTTP_API 556 #ifdef SRS_AUTO_HTTP_API
520 - bool api = true; 557 + features->set("api", SrsAmf0Any::boolean(true));
521 #else 558 #else
522 - bool api = false; 559 + features->set("api", SrsAmf0Any::boolean(false));
523 #endif 560 #endif
524 #ifdef SRS_AUTO_HTTP_SERVER 561 #ifdef SRS_AUTO_HTTP_SERVER
525 - bool httpd = true; 562 + features->set("httpd", SrsAmf0Any::boolean(true));
526 #else 563 #else
527 - bool httpd = false; 564 + features->set("httpd", SrsAmf0Any::boolean(false));
528 #endif 565 #endif
529 #ifdef SRS_AUTO_DVR 566 #ifdef SRS_AUTO_DVR
530 - bool dvr = true; 567 + features->set("dvr", SrsAmf0Any::boolean(true));
531 #else 568 #else
532 - bool dvr = false; 569 + features->set("dvr", SrsAmf0Any::boolean(false));
533 #endif 570 #endif
534 #ifdef SRS_AUTO_TRANSCODE 571 #ifdef SRS_AUTO_TRANSCODE
535 - bool transcode = true; 572 + features->set("transcode", SrsAmf0Any::boolean(true));
536 #else 573 #else
537 - bool transcode = false; 574 + features->set("transcode", SrsAmf0Any::boolean(false));
538 #endif 575 #endif
539 #ifdef SRS_AUTO_INGEST 576 #ifdef SRS_AUTO_INGEST
540 - bool ingest = true; 577 + features->set("ingest", SrsAmf0Any::boolean(true));
541 #else 578 #else
542 - bool ingest = false; 579 + features->set("ingest", SrsAmf0Any::boolean(false));
543 #endif 580 #endif
544 #ifdef SRS_AUTO_STAT 581 #ifdef SRS_AUTO_STAT
545 - bool _stat = true; 582 + features->set("stat", SrsAmf0Any::boolean(true));
546 #else 583 #else
547 - bool _stat = false; 584 + features->set("stat", SrsAmf0Any::boolean(false));
548 #endif 585 #endif
549 #ifdef SRS_AUTO_NGINX 586 #ifdef SRS_AUTO_NGINX
550 - bool nginx = true; 587 + features->set("nginx", SrsAmf0Any::boolean(true));
551 #else 588 #else
552 - bool nginx = false; 589 + features->set("nginx", SrsAmf0Any::boolean(false));
553 #endif 590 #endif
554 #ifdef SRS_AUTO_FFMPEG_TOOL 591 #ifdef SRS_AUTO_FFMPEG_TOOL
555 - bool ffmpeg = true; 592 + features->set("ffmpeg", SrsAmf0Any::boolean(true));
556 #else 593 #else
557 - bool ffmpeg = false; 594 + features->set("ffmpeg", SrsAmf0Any::boolean(false));
558 #endif 595 #endif
559 #ifdef SRS_AUTO_STREAM_CASTER 596 #ifdef SRS_AUTO_STREAM_CASTER
560 - bool caster = true; 597 + features->set("caster", SrsAmf0Any::boolean(true));
561 #else 598 #else
562 - bool caster = false; 599 + features->set("caster", SrsAmf0Any::boolean(false));
563 #endif 600 #endif
564 #ifdef SRS_PERF_COMPLEX_SEND 601 #ifdef SRS_PERF_COMPLEX_SEND
565 - bool complex_send = true; 602 + features->set("complex_send", SrsAmf0Any::boolean(true));
566 #else 603 #else
567 - bool complex_send = false; 604 + features->set("complex_send", SrsAmf0Any::boolean(false));
568 #endif 605 #endif
569 #ifdef SRS_PERF_TCP_NODELAY 606 #ifdef SRS_PERF_TCP_NODELAY
570 - bool tcp_nodelay = true; 607 + features->set("tcp_nodelay", SrsAmf0Any::boolean(true));
571 #else 608 #else
572 - bool tcp_nodelay = false; 609 + features->set("tcp_nodelay", SrsAmf0Any::boolean(false));
573 #endif 610 #endif
574 #ifdef SRS_PERF_SO_SNDBUF_SIZE 611 #ifdef SRS_PERF_SO_SNDBUF_SIZE
575 - bool so_sendbuf = true; 612 + features->set("so_sendbuf", SrsAmf0Any::boolean(true));
576 #else 613 #else
577 - bool so_sendbuf = false; 614 + features->set("so_sendbuf", SrsAmf0Any::boolean(false));
578 #endif 615 #endif
579 #ifdef SRS_PERF_MERGED_READ 616 #ifdef SRS_PERF_MERGED_READ
580 - bool mr = true; 617 + features->set("mr", SrsAmf0Any::boolean(true));
581 #else 618 #else
582 - bool mr = false; 619 + features->set("mr", SrsAmf0Any::boolean(false));
583 #endif 620 #endif
584 621
585 - ss << SRS_JOBJECT_START  
586 - << SRS_JFIELD_ERROR(ERROR_SUCCESS) << SRS_JFIELD_CONT  
587 - << SRS_JFIELD_ORG("server", stat->server_id()) << SRS_JFIELD_CONT  
588 - << SRS_JFIELD_ORG("data", SRS_JOBJECT_START)  
589 - << SRS_JFIELD_BOOL("ssl", ssl) << SRS_JFIELD_CONT  
590 - << SRS_JFIELD_BOOL("hls", hls) << SRS_JFIELD_CONT  
591 - << SRS_JFIELD_BOOL("hds", hds) << SRS_JFIELD_CONT  
592 - << SRS_JFIELD_BOOL("callback", callback) << SRS_JFIELD_CONT  
593 - << SRS_JFIELD_BOOL("api", api) << SRS_JFIELD_CONT  
594 - << SRS_JFIELD_BOOL("httpd", httpd) << SRS_JFIELD_CONT  
595 - << SRS_JFIELD_BOOL("dvr", dvr) << SRS_JFIELD_CONT  
596 - << SRS_JFIELD_BOOL("transcode", transcode) << SRS_JFIELD_CONT  
597 - << SRS_JFIELD_BOOL("ingest", ingest) << SRS_JFIELD_CONT  
598 - << SRS_JFIELD_BOOL("stat", _stat) << SRS_JFIELD_CONT  
599 - << SRS_JFIELD_BOOL("nginx", nginx) << SRS_JFIELD_CONT  
600 - << SRS_JFIELD_BOOL("ffmpeg", ffmpeg) << SRS_JFIELD_CONT  
601 - << SRS_JFIELD_BOOL("stream_caster", caster) << SRS_JFIELD_CONT  
602 - << SRS_JFIELD_BOOL("complex_send", complex_send) << SRS_JFIELD_CONT  
603 - << SRS_JFIELD_BOOL("tcp_nodelay", tcp_nodelay) << SRS_JFIELD_CONT  
604 - << SRS_JFIELD_BOOL("so_sendbuf", so_sendbuf) << SRS_JFIELD_CONT  
605 - << SRS_JFIELD_BOOL("mr", mr)  
606 - << SRS_JOBJECT_END  
607 - << SRS_JOBJECT_END;  
608 -  
609 - return srs_api_response(w, r, ss.str()); 622 + return srs_api_response(w, r, obj->to_json());
610 } 623 }
611 624
612 SrsGoApiRequests::SrsGoApiRequests() 625 SrsGoApiRequests::SrsGoApiRequests()
@@ -619,57 +632,44 @@ SrsGoApiRequests::~SrsGoApiRequests() @@ -619,57 +632,44 @@ SrsGoApiRequests::~SrsGoApiRequests()
619 632
620 int SrsGoApiRequests::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r) 633 int SrsGoApiRequests::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
621 { 634 {
622 - ISrsHttpMessage* req = r;  
623 -  
624 SrsStatistic* stat = SrsStatistic::instance(); 635 SrsStatistic* stat = SrsStatistic::instance();
625 - std::stringstream ss;  
626 636
627 - ss << SRS_JOBJECT_START  
628 - << SRS_JFIELD_ERROR(ERROR_SUCCESS) << SRS_JFIELD_CONT  
629 - << SRS_JFIELD_ORG("server", stat->server_id()) << SRS_JFIELD_CONT  
630 - << SRS_JFIELD_ORG("data", SRS_JOBJECT_START)  
631 - << SRS_JFIELD_STR("uri", req->uri()) << SRS_JFIELD_CONT  
632 - << SRS_JFIELD_STR("path", req->path()) << SRS_JFIELD_CONT; 637 + SrsAmf0Object* obj = SrsAmf0Any::object();
  638 + SrsAutoFree(SrsAmf0Object, obj);
  639 +
  640 + obj->set("code", SrsAmf0Any::number(ERROR_SUCCESS));
  641 + obj->set("server", SrsAmf0Any::number(stat->server_id()));
  642 +
  643 + SrsAmf0Object* data = SrsAmf0Any::object();
  644 + obj->set("data", data);
  645 +
  646 + data->set("uri", SrsAmf0Any::str(r->uri().c_str()));
  647 + data->set("path", SrsAmf0Any::str(r->path().c_str()));
633 648
634 // method 649 // method
635 - if (req->is_http_get()) {  
636 - ss << SRS_JFIELD_STR("METHOD", "GET");  
637 - } else if (req->is_http_post()) {  
638 - ss << SRS_JFIELD_STR("METHOD", "POST");  
639 - } else if (req->is_http_put()) {  
640 - ss << SRS_JFIELD_STR("METHOD", "PUT");  
641 - } else if (req->is_http_delete()) {  
642 - ss << SRS_JFIELD_STR("METHOD", "DELETE");  
643 - } else {  
644 - ss << SRS_JFIELD_ORG("METHOD", req->method());  
645 - }  
646 - ss << SRS_JFIELD_CONT; 650 + data->set("METHOD", SrsAmf0Any::str(r->method_str().c_str()));
647 651
648 // request headers 652 // request headers
649 - ss << SRS_JFIELD_NAME("headers") << SRS_JOBJECT_START;  
650 - for (int i = 0; i < req->request_header_count(); i++) {  
651 - std::string key = req->request_header_key_at(i);  
652 - std::string value = req->request_header_value_at(i);  
653 - if ( i < req->request_header_count() - 1) {  
654 - ss << SRS_JFIELD_STR(key, value) << SRS_JFIELD_CONT;  
655 - } else {  
656 - ss << SRS_JFIELD_STR(key, value);  
657 - } 653 + SrsAmf0Object* headers = SrsAmf0Any::object();
  654 + data->set("headers", headers);
  655 +
  656 + for (int i = 0; i < r->request_header_count(); i++) {
  657 + std::string key = r->request_header_key_at(i);
  658 + std::string value = r->request_header_value_at(i);
  659 + headers->set(key, SrsAmf0Any::str(value.c_str()));
658 } 660 }
659 - ss << SRS_JOBJECT_END << SRS_JFIELD_CONT;  
660 661
661 // server informations 662 // server informations
662 - ss << SRS_JFIELD_NAME("server") << SRS_JOBJECT_START  
663 - << SRS_JFIELD_STR("sigature", RTMP_SIG_SRS_KEY) << SRS_JFIELD_CONT  
664 - << SRS_JFIELD_STR("name", RTMP_SIG_SRS_NAME) << SRS_JFIELD_CONT  
665 - << SRS_JFIELD_STR("version", RTMP_SIG_SRS_VERSION) << SRS_JFIELD_CONT  
666 - << SRS_JFIELD_STR("link", RTMP_SIG_SRS_URL) << SRS_JFIELD_CONT  
667 - << SRS_JFIELD_ORG("time", srs_get_system_time_ms())  
668 - << SRS_JOBJECT_END  
669 - << SRS_JOBJECT_END  
670 - << SRS_JOBJECT_END; 663 + SrsAmf0Object* server = SrsAmf0Any::object();
  664 + data->set("headers", server);
671 665
672 - return srs_api_response(w, r, ss.str()); 666 + server->set("sigature", SrsAmf0Any::str(RTMP_SIG_SRS_KEY));
  667 + server->set("name", SrsAmf0Any::str(RTMP_SIG_SRS_NAME));
  668 + server->set("version", SrsAmf0Any::str(RTMP_SIG_SRS_VERSION));
  669 + server->set("link", SrsAmf0Any::str(RTMP_SIG_SRS_URL));
  670 + server->set("time", SrsAmf0Any::number(srs_get_system_time_ms()));
  671 +
  672 + return srs_api_response(w, r, obj->to_json());
673 } 673 }
674 674
675 SrsGoApiVhosts::SrsGoApiVhosts() 675 SrsGoApiVhosts::SrsGoApiVhosts()
@@ -685,7 +685,6 @@ int SrsGoApiVhosts::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r) @@ -685,7 +685,6 @@ int SrsGoApiVhosts::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
685 int ret = ERROR_SUCCESS; 685 int ret = ERROR_SUCCESS;
686 686
687 SrsStatistic* stat = SrsStatistic::instance(); 687 SrsStatistic* stat = SrsStatistic::instance();
688 - std::stringstream ss;  
689 688
690 // path: {pattern}{vhost_id} 689 // path: {pattern}{vhost_id}
691 // e.g. /api/v1/vhosts/100 pattern= /api/v1/vhosts/, vhost_id=100 690 // e.g. /api/v1/vhosts/100 pattern= /api/v1/vhosts/, vhost_id=100
@@ -698,31 +697,33 @@ int SrsGoApiVhosts::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r) @@ -698,31 +697,33 @@ int SrsGoApiVhosts::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
698 return srs_api_response_code(w, r, ret); 697 return srs_api_response_code(w, r, ret);
699 } 698 }
700 699
  700 + SrsAmf0Object* obj = SrsAmf0Any::object();
  701 + SrsAutoFree(SrsAmf0Object, obj);
  702 +
  703 + obj->set("code", SrsAmf0Any::number(ERROR_SUCCESS));
  704 + obj->set("server", SrsAmf0Any::number(stat->server_id()));
  705 +
701 if (r->is_http_get()) { 706 if (r->is_http_get()) {
702 - std::stringstream data;  
703 -  
704 if (!vhost) { 707 if (!vhost) {
705 - ret = stat->dumps_vhosts(data); 708 + SrsAmf0StrictArray* data = SrsAmf0Any::strict_array();
  709 + obj->set("vhosts", data);
706 710
707 - ss << SRS_JOBJECT_START  
708 - << SRS_JFIELD_ERROR(ret) << SRS_JFIELD_CONT  
709 - << SRS_JFIELD_ORG("server", stat->server_id()) << SRS_JFIELD_CONT  
710 - << SRS_JFIELD_ORG("vhosts", data.str())  
711 - << SRS_JOBJECT_END; 711 + if ((ret = stat->dumps_vhosts(data)) != ERROR_SUCCESS) {
  712 + return srs_api_response_code(w, r, ret);
  713 + }
712 } else { 714 } else {
713 - ret = vhost->dumps(data); 715 + SrsAmf0Object* data = SrsAmf0Any::object();
  716 + obj->set("vhost", data);;
714 717
715 - ss << SRS_JOBJECT_START  
716 - << SRS_JFIELD_ERROR(ret) << SRS_JFIELD_CONT  
717 - << SRS_JFIELD_ORG("server", stat->server_id()) << SRS_JFIELD_CONT  
718 - << SRS_JFIELD_ORG("vhost", data.str())  
719 - << SRS_JOBJECT_END; 718 + if ((ret = vhost->dumps(data)) != ERROR_SUCCESS) {
  719 + return srs_api_response_code(w, r, ret);
  720 + }
720 } 721 }
721 -  
722 - return srs_api_response(w, r, ss.str()); 722 + } else {
  723 + return srs_go_http_error(w, SRS_CONSTS_HTTP_MethodNotAllowed);
723 } 724 }
724 725
725 - return srs_api_response(w, r, ss.str()); 726 + return srs_api_response(w, r, obj->to_json());
726 } 727 }
727 728
728 SrsGoApiStreams::SrsGoApiStreams() 729 SrsGoApiStreams::SrsGoApiStreams()
@@ -738,7 +739,6 @@ int SrsGoApiStreams::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r) @@ -738,7 +739,6 @@ int SrsGoApiStreams::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
738 int ret = ERROR_SUCCESS; 739 int ret = ERROR_SUCCESS;
739 740
740 SrsStatistic* stat = SrsStatistic::instance(); 741 SrsStatistic* stat = SrsStatistic::instance();
741 - std::stringstream ss;  
742 742
743 // path: {pattern}{stream_id} 743 // path: {pattern}{stream_id}
744 // e.g. /api/v1/streams/100 pattern= /api/v1/streams/, stream_id=100 744 // e.g. /api/v1/streams/100 pattern= /api/v1/streams/, stream_id=100
@@ -751,31 +751,33 @@ int SrsGoApiStreams::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r) @@ -751,31 +751,33 @@ int SrsGoApiStreams::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
751 return srs_api_response_code(w, r, ret); 751 return srs_api_response_code(w, r, ret);
752 } 752 }
753 753
  754 + SrsAmf0Object* obj = SrsAmf0Any::object();
  755 + SrsAutoFree(SrsAmf0Object, obj);
  756 +
  757 + obj->set("code", SrsAmf0Any::number(ERROR_SUCCESS));
  758 + obj->set("server", SrsAmf0Any::number(stat->server_id()));
  759 +
754 if (r->is_http_get()) { 760 if (r->is_http_get()) {
755 - std::stringstream data;  
756 -  
757 if (!stream) { 761 if (!stream) {
758 - ret = stat->dumps_streams(data); 762 + SrsAmf0StrictArray* data = SrsAmf0Any::strict_array();
  763 + obj->set("streams", data);
759 764
760 - ss << SRS_JOBJECT_START  
761 - << SRS_JFIELD_ERROR(ret) << SRS_JFIELD_CONT  
762 - << SRS_JFIELD_ORG("server", stat->server_id()) << SRS_JFIELD_CONT  
763 - << SRS_JFIELD_ORG("streams", data.str())  
764 - << SRS_JOBJECT_END; 765 + if ((ret = stat->dumps_streams(data)) != ERROR_SUCCESS) {
  766 + return srs_api_response_code(w, r, ret);
  767 + }
765 } else { 768 } else {
766 - ret = stream->dumps(data); 769 + SrsAmf0Object* data = SrsAmf0Any::object();
  770 + obj->set("stream", data);;
767 771
768 - ss << SRS_JOBJECT_START  
769 - << SRS_JFIELD_ERROR(ret) << SRS_JFIELD_CONT  
770 - << SRS_JFIELD_ORG("server", stat->server_id()) << SRS_JFIELD_CONT  
771 - << SRS_JFIELD_ORG("stream", data.str())  
772 - << SRS_JOBJECT_END; 772 + if ((ret = stream->dumps(data)) != ERROR_SUCCESS) {
  773 + return srs_api_response_code(w, r, ret);
  774 + }
773 } 775 }
774 -  
775 - return srs_api_response(w, r, ss.str()); 776 + } else {
  777 + return srs_go_http_error(w, SRS_CONSTS_HTTP_MethodNotAllowed);
776 } 778 }
777 779
778 - return ret; 780 + return srs_api_response(w, r, obj->to_json());
779 } 781 }
780 782
781 SrsGoApiClients::SrsGoApiClients() 783 SrsGoApiClients::SrsGoApiClients()
@@ -791,7 +793,6 @@ int SrsGoApiClients::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r) @@ -791,7 +793,6 @@ int SrsGoApiClients::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
791 int ret = ERROR_SUCCESS; 793 int ret = ERROR_SUCCESS;
792 794
793 SrsStatistic* stat = SrsStatistic::instance(); 795 SrsStatistic* stat = SrsStatistic::instance();
794 - std::stringstream ss;  
795 796
796 // path: {pattern}{client_id} 797 // path: {pattern}{client_id}
797 // e.g. /api/v1/clients/100 pattern= /api/v1/clients/, client_id=100 798 // e.g. /api/v1/clients/100 pattern= /api/v1/clients/, client_id=100
@@ -804,39 +805,33 @@ int SrsGoApiClients::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r) @@ -804,39 +805,33 @@ int SrsGoApiClients::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
804 return srs_api_response_code(w, r, ret); 805 return srs_api_response_code(w, r, ret);
805 } 806 }
806 807
807 - if (r->is_http_delete()) {  
808 - srs_assert(client);  
809 -  
810 - client->conn->expire();  
811 - srs_warn("delete client=%d ok", cid);  
812 - return srs_api_response_code(w, r, ret);  
813 - } else if (r->is_http_get()) {  
814 - std::stringstream data;  
815 - 808 + SrsAmf0Object* obj = SrsAmf0Any::object();
  809 + SrsAutoFree(SrsAmf0Object, obj);
  810 +
  811 + obj->set("code", SrsAmf0Any::number(ERROR_SUCCESS));
  812 + obj->set("server", SrsAmf0Any::number(stat->server_id()));
  813 +
  814 + if (r->is_http_get()) {
816 if (!client) { 815 if (!client) {
817 - ret = stat->dumps_clients(data, 0, 10); 816 + SrsAmf0StrictArray* data = SrsAmf0Any::strict_array();
  817 + obj->set("clients", data);
818 818
819 - ss << SRS_JOBJECT_START  
820 - << SRS_JFIELD_ERROR(ret) << SRS_JFIELD_CONT  
821 - << SRS_JFIELD_ORG("server", stat->server_id()) << SRS_JFIELD_CONT  
822 - << SRS_JFIELD_ORG("clients", data.str())  
823 - << SRS_JOBJECT_END; 819 + if ((ret = stat->dumps_clients(data, 0, 10)) != ERROR_SUCCESS) {
  820 + return srs_api_response_code(w, r, ret);
  821 + }
824 } else { 822 } else {
825 - ret = client->dumps(data); 823 + SrsAmf0Object* data = SrsAmf0Any::object();
  824 + obj->set("client", data);;
826 825
827 - ss << SRS_JOBJECT_START  
828 - << SRS_JFIELD_ERROR(ret) << SRS_JFIELD_CONT  
829 - << SRS_JFIELD_ORG("server", stat->server_id()) << SRS_JFIELD_CONT  
830 - << SRS_JFIELD_ORG("client", data.str())  
831 - << SRS_JOBJECT_END; 826 + if ((ret = client->dumps(data)) != ERROR_SUCCESS) {
  827 + return srs_api_response_code(w, r, ret);
  828 + }
832 } 829 }
833 -  
834 - return srs_api_response(w, r, ss.str());  
835 } else { 830 } else {
836 return srs_go_http_error(w, SRS_CONSTS_HTTP_MethodNotAllowed); 831 return srs_go_http_error(w, SRS_CONSTS_HTTP_MethodNotAllowed);
837 } 832 }
838 -  
839 - return ret; 833 +
  834 + return srs_api_response(w, r, obj->to_json());
840 } 835 }
841 836
842 SrsGoApiRaw::SrsGoApiRaw(SrsServer* svr) 837 SrsGoApiRaw::SrsGoApiRaw(SrsServer* svr)
@@ -33,6 +33,7 @@ using namespace std; @@ -33,6 +33,7 @@ using namespace std;
33 #include <srs_app_conn.hpp> 33 #include <srs_app_conn.hpp>
34 #include <srs_app_config.hpp> 34 #include <srs_app_config.hpp>
35 #include <srs_kernel_utility.hpp> 35 #include <srs_kernel_utility.hpp>
  36 +#include <srs_rtmp_amf0.hpp>
36 37
37 int64_t srs_gvid = getpid(); 38 int64_t srs_gvid = getpid();
38 39
@@ -57,7 +58,7 @@ SrsStatisticVhost::~SrsStatisticVhost() @@ -57,7 +58,7 @@ SrsStatisticVhost::~SrsStatisticVhost()
57 srs_freep(kbps); 58 srs_freep(kbps);
58 } 59 }
59 60
60 -int SrsStatisticVhost::dumps(stringstream& ss) 61 +int SrsStatisticVhost::dumps(SrsAmf0Object* obj)
61 { 62 {
62 int ret = ERROR_SUCCESS; 63 int ret = ERROR_SUCCESS;
63 64
@@ -65,26 +66,27 @@ int SrsStatisticVhost::dumps(stringstream& ss) @@ -65,26 +66,27 @@ int SrsStatisticVhost::dumps(stringstream& ss)
65 bool hls_enabled = _srs_config->get_hls_enabled(vhost); 66 bool hls_enabled = _srs_config->get_hls_enabled(vhost);
66 bool enabled = _srs_config->get_vhost_enabled(vhost); 67 bool enabled = _srs_config->get_vhost_enabled(vhost);
67 68
68 - ss << SRS_JOBJECT_START  
69 - << SRS_JFIELD_ORG("id", id) << SRS_JFIELD_CONT  
70 - << SRS_JFIELD_STR("name", vhost) << SRS_JFIELD_CONT  
71 - << SRS_JFIELD_BOOL("enabled", enabled) << SRS_JFIELD_CONT  
72 - << SRS_JFIELD_ORG("clients", nb_clients) << SRS_JFIELD_CONT  
73 - << SRS_JFIELD_ORG("streams", nb_streams) << SRS_JFIELD_CONT  
74 - << SRS_JFIELD_ORG("send_bytes", kbps->get_send_bytes()) << SRS_JFIELD_CONT  
75 - << SRS_JFIELD_ORG("recv_bytes", kbps->get_recv_bytes()) << SRS_JFIELD_CONT  
76 - << SRS_JFIELD_OBJ("kbps")  
77 - << SRS_JFIELD_ORG("recv_30s", kbps->get_recv_kbps_30s()) << SRS_JFIELD_CONT  
78 - << SRS_JFIELD_ORG("send_30s", kbps->get_send_kbps_30s())  
79 - << SRS_JOBJECT_END << SRS_JFIELD_CONT  
80 - << SRS_JFIELD_NAME("hls") << SRS_JOBJECT_START  
81 - << SRS_JFIELD_BOOL("enabled", hls_enabled); 69 + obj->set("id", SrsAmf0Any::number(id));
  70 + obj->set("name", SrsAmf0Any::str(vhost.c_str()));
  71 + obj->set("enabled", SrsAmf0Any::boolean(enabled));
  72 + obj->set("clients", SrsAmf0Any::number(nb_clients));
  73 + obj->set("streams", SrsAmf0Any::number(nb_streams));
  74 + obj->set("send_bytes", SrsAmf0Any::number(kbps->get_send_bytes()));
  75 + obj->set("recv_bytes", SrsAmf0Any::number(kbps->get_recv_bytes()));
  76 +
  77 + SrsAmf0Object* okbps = SrsAmf0Any::object();
  78 + obj->set("kbps", okbps);
  79 +
  80 + okbps->set("recv_30s", SrsAmf0Any::number(kbps->get_recv_kbps_30s()));
  81 + okbps->set("send_30s", SrsAmf0Any::number(kbps->get_send_kbps_30s()));
  82 +
  83 + SrsAmf0Object* hls = SrsAmf0Any::object();
  84 + obj->set("hls", hls);
  85 +
  86 + hls->set("enabled", SrsAmf0Any::boolean(hls_enabled));
82 if (hls_enabled) { 87 if (hls_enabled) {
83 - ss << SRS_JFIELD_CONT;  
84 - ss << SRS_JFIELD_ORG("fragment", _srs_config->get_hls_fragment(vhost)); 88 + hls->set("fragment", SrsAmf0Any::number(_srs_config->get_hls_fragment(vhost)));
85 } 89 }
86 - ss << SRS_JOBJECT_END  
87 - << SRS_JOBJECT_END;  
88 90
89 return ret; 91 return ret;
90 } 92 }
@@ -118,52 +120,54 @@ SrsStatisticStream::~SrsStatisticStream() @@ -118,52 +120,54 @@ SrsStatisticStream::~SrsStatisticStream()
118 srs_freep(kbps); 120 srs_freep(kbps);
119 } 121 }
120 122
121 -int SrsStatisticStream::dumps(stringstream& ss) 123 +int SrsStatisticStream::dumps(SrsAmf0Object* obj)
122 { 124 {
123 int ret = ERROR_SUCCESS; 125 int ret = ERROR_SUCCESS;
124 126
125 - ss << SRS_JOBJECT_START  
126 - << SRS_JFIELD_ORG("id", id) << SRS_JFIELD_CONT  
127 - << SRS_JFIELD_STR("name", stream) << SRS_JFIELD_CONT  
128 - << SRS_JFIELD_ORG("vhost", vhost->id) << SRS_JFIELD_CONT  
129 - << SRS_JFIELD_STR("app", app) << SRS_JFIELD_CONT  
130 - << SRS_JFIELD_ORG("live_ms", srs_get_system_time_ms()) << SRS_JFIELD_CONT  
131 - << SRS_JFIELD_ORG("clients", nb_clients) << SRS_JFIELD_CONT  
132 - << SRS_JFIELD_ORG("send_bytes", kbps->get_send_bytes()) << SRS_JFIELD_CONT  
133 - << SRS_JFIELD_ORG("recv_bytes", kbps->get_recv_bytes()) << SRS_JFIELD_CONT  
134 - << SRS_JFIELD_OBJ("kbps")  
135 - << SRS_JFIELD_ORG("recv_30s", kbps->get_recv_kbps_30s()) << SRS_JFIELD_CONT  
136 - << SRS_JFIELD_ORG("send_30s", kbps->get_send_kbps_30s())  
137 - << SRS_JOBJECT_END << SRS_JFIELD_CONT  
138 - << SRS_JFIELD_OBJ("publish")  
139 - << SRS_JFIELD_BOOL("active", active) << SRS_JFIELD_CONT  
140 - << SRS_JFIELD_ORG("cid", connection_cid)  
141 - << SRS_JOBJECT_END << SRS_JFIELD_CONT; 127 + obj->set("id", SrsAmf0Any::number(id));
  128 + obj->set("name", SrsAmf0Any::str(stream.c_str()));
  129 + obj->set("vhost", SrsAmf0Any::number(vhost->id));
  130 + obj->set("app", SrsAmf0Any::str(app.c_str()));
  131 + obj->set("live_ms", SrsAmf0Any::number(srs_get_system_time_ms()));
  132 + obj->set("clients", SrsAmf0Any::number(nb_clients));
  133 + obj->set("send_bytes", SrsAmf0Any::number(kbps->get_send_bytes()));
  134 + obj->set("recv_bytes", SrsAmf0Any::number(kbps->get_recv_bytes()));
  135 +
  136 + SrsAmf0Object* okbps = SrsAmf0Any::object();
  137 + obj->set("kbps", okbps);
  138 +
  139 + okbps->set("recv_30s", SrsAmf0Any::number(kbps->get_recv_kbps_30s()));
  140 + okbps->set("send_30s", SrsAmf0Any::number(kbps->get_send_kbps_30s()));
  141 +
  142 + SrsAmf0Object* publish = SrsAmf0Any::object();
  143 + obj->set("publish", publish);
  144 +
  145 + publish->set("active", SrsAmf0Any::boolean(active));
  146 + publish->set("cid", SrsAmf0Any::number(connection_cid));
142 147
143 if (!has_video) { 148 if (!has_video) {
144 - ss << SRS_JFIELD_NULL("video") << SRS_JFIELD_CONT; 149 + obj->set("video", SrsAmf0Any::null());
145 } else { 150 } else {
146 - ss << SRS_JFIELD_NAME("video") << SRS_JOBJECT_START  
147 - << SRS_JFIELD_STR("codec", srs_codec_video2str(vcodec)) << SRS_JFIELD_CONT  
148 - << SRS_JFIELD_STR("profile", srs_codec_avc_profile2str(avc_profile)) << SRS_JFIELD_CONT  
149 - << SRS_JFIELD_ORG("level", srs_codec_avc_level2str(avc_level))  
150 - << SRS_JOBJECT_END  
151 - << SRS_JFIELD_CONT; 151 + SrsAmf0Object* video = SrsAmf0Any::object();
  152 + obj->set("video", video);
  153 +
  154 + video->set("codec", SrsAmf0Any::str(srs_codec_video2str(vcodec).c_str()));
  155 + video->set("profile", SrsAmf0Any::str(srs_codec_avc_profile2str(avc_profile).c_str()));
  156 + video->set("level", SrsAmf0Any::str(srs_codec_avc_level2str(avc_level).c_str()));
152 } 157 }
153 158
154 if (!has_audio) { 159 if (!has_audio) {
155 - ss << SRS_JFIELD_NULL("audio"); 160 + obj->set("audio", SrsAmf0Any::null());
156 } else { 161 } else {
157 - ss << SRS_JFIELD_NAME("audio") << SRS_JOBJECT_START  
158 - << SRS_JFIELD_STR("codec", srs_codec_audio2str(acodec)) << SRS_JFIELD_CONT  
159 - << SRS_JFIELD_ORG("sample_rate", (int)flv_sample_rates[asample_rate]) << SRS_JFIELD_CONT  
160 - << SRS_JFIELD_ORG("channel", (int)asound_type + 1) << SRS_JFIELD_CONT  
161 - << SRS_JFIELD_STR("profile", srs_codec_aac_object2str(aac_object))  
162 - << SRS_JOBJECT_END; 162 + SrsAmf0Object* audio = SrsAmf0Any::object();
  163 + obj->set("audio", audio);
  164 +
  165 + audio->set("codec", SrsAmf0Any::str(srs_codec_audio2str(acodec).c_str()));
  166 + audio->set("sample_rate", SrsAmf0Any::number(flv_sample_rates[asample_rate]));
  167 + audio->set("channel", SrsAmf0Any::number(asound_type + 1));
  168 + audio->set("profile", SrsAmf0Any::str(srs_codec_aac_object2str(aac_object).c_str()));
163 } 169 }
164 170
165 - ss << SRS_JOBJECT_END;  
166 -  
167 return ret; 171 return ret;
168 } 172 }
169 173
@@ -198,23 +202,21 @@ SrsStatisticClient::~SrsStatisticClient() @@ -198,23 +202,21 @@ SrsStatisticClient::~SrsStatisticClient()
198 { 202 {
199 } 203 }
200 204
201 -int SrsStatisticClient::dumps(stringstream& ss) 205 +int SrsStatisticClient::dumps(SrsAmf0Object* obj)
202 { 206 {
203 int ret = ERROR_SUCCESS; 207 int ret = ERROR_SUCCESS;
204 208
205 - ss << SRS_JOBJECT_START  
206 - << SRS_JFIELD_ORG("id", id) << SRS_JFIELD_CONT  
207 - << SRS_JFIELD_ORG("vhost", stream->vhost->id) << SRS_JFIELD_CONT  
208 - << SRS_JFIELD_ORG("stream", stream->id) << SRS_JFIELD_CONT  
209 - << SRS_JFIELD_STR("ip", req->ip) << SRS_JFIELD_CONT  
210 - << SRS_JFIELD_STR("pageUrl", req->pageUrl) << SRS_JFIELD_CONT  
211 - << SRS_JFIELD_STR("swfUrl", req->swfUrl) << SRS_JFIELD_CONT  
212 - << SRS_JFIELD_STR("tcUrl", req->tcUrl) << SRS_JFIELD_CONT  
213 - << SRS_JFIELD_STR("url", req->get_stream_url()) << SRS_JFIELD_CONT  
214 - << SRS_JFIELD_STR("type", srs_client_type_string(type)) << SRS_JFIELD_CONT  
215 - << SRS_JFIELD_BOOL("publish", srs_client_type_is_publish(type)) << SRS_JFIELD_CONT  
216 - << SRS_JFIELD_ORG("alive", srs_get_system_time_ms() - create)  
217 - << SRS_JOBJECT_END; 209 + obj->set("id", SrsAmf0Any::number(id));
  210 + obj->set("vhost", SrsAmf0Any::number(stream->vhost->id));
  211 + obj->set("stream", SrsAmf0Any::number(stream->id));
  212 + obj->set("ip", SrsAmf0Any::str(req->ip.c_str()));
  213 + obj->set("pageUrl", SrsAmf0Any::str(req->pageUrl.c_str()));
  214 + obj->set("swfUrl", SrsAmf0Any::str(req->swfUrl.c_str()));
  215 + obj->set("tcUrl", SrsAmf0Any::str(req->tcUrl.c_str()));
  216 + obj->set("url", SrsAmf0Any::str(req->get_stream_url().c_str()));
  217 + obj->set("type", SrsAmf0Any::str(srs_client_type_string(type).c_str()));
  218 + obj->set("publish", SrsAmf0Any::boolean(srs_client_type_is_publish(type)));
  219 + obj->set("alive", SrsAmf0Any::number(srs_get_system_time_ms() - create));
218 220
219 return ret; 221 return ret;
220 } 222 }
@@ -446,55 +448,48 @@ int64_t SrsStatistic::server_id() @@ -446,55 +448,48 @@ int64_t SrsStatistic::server_id()
446 return _server_id; 448 return _server_id;
447 } 449 }
448 450
449 -int SrsStatistic::dumps_vhosts(stringstream& ss) 451 +int SrsStatistic::dumps_vhosts(SrsAmf0StrictArray* arr)
450 { 452 {
451 int ret = ERROR_SUCCESS; 453 int ret = ERROR_SUCCESS;
452 454
453 - ss << SRS_JARRAY_START;  
454 std::map<int64_t, SrsStatisticVhost*>::iterator it; 455 std::map<int64_t, SrsStatisticVhost*>::iterator it;
455 for (it = vhosts.begin(); it != vhosts.end(); it++) { 456 for (it = vhosts.begin(); it != vhosts.end(); it++) {
456 SrsStatisticVhost* vhost = it->second; 457 SrsStatisticVhost* vhost = it->second;
457 458
458 - if (it != vhosts.begin()) {  
459 - ss << SRS_JFIELD_CONT;  
460 - } 459 + SrsAmf0Object* obj = SrsAmf0Any::object();
  460 + arr->append(obj);
461 461
462 - if ((ret = vhost->dumps(ss)) != ERROR_SUCCESS) { 462 + if ((ret = vhost->dumps(obj)) != ERROR_SUCCESS) {
463 return ret; 463 return ret;
464 } 464 }
465 } 465 }
466 - ss << SRS_JARRAY_END;  
467 466
468 return ret; 467 return ret;
469 } 468 }
470 469
471 -int SrsStatistic::dumps_streams(stringstream& ss) 470 +int SrsStatistic::dumps_streams(SrsAmf0StrictArray* arr)
472 { 471 {
473 int ret = ERROR_SUCCESS; 472 int ret = ERROR_SUCCESS;
474 473
475 - ss << SRS_JARRAY_START;  
476 std::map<int64_t, SrsStatisticStream*>::iterator it; 474 std::map<int64_t, SrsStatisticStream*>::iterator it;
477 for (it = streams.begin(); it != streams.end(); it++) { 475 for (it = streams.begin(); it != streams.end(); it++) {
478 SrsStatisticStream* stream = it->second; 476 SrsStatisticStream* stream = it->second;
479 477
480 - if (it != streams.begin()) {  
481 - ss << SRS_JFIELD_CONT;  
482 - } 478 + SrsAmf0Object* obj = SrsAmf0Any::object();
  479 + arr->append(obj);
483 480
484 - if ((ret = stream->dumps(ss)) != ERROR_SUCCESS) { 481 + if ((ret = stream->dumps(obj)) != ERROR_SUCCESS) {
485 return ret; 482 return ret;
486 } 483 }
487 } 484 }
488 - ss << SRS_JARRAY_END;  
489 485
490 return ret; 486 return ret;
491 } 487 }
492 488
493 -int SrsStatistic::dumps_clients(stringstream& ss, int start, int count) 489 +int SrsStatistic::dumps_clients(SrsAmf0StrictArray* arr, int start, int count)
494 { 490 {
495 int ret = ERROR_SUCCESS; 491 int ret = ERROR_SUCCESS;
496 492
497 - ss << SRS_JARRAY_START;  
498 std::map<int, SrsStatisticClient*>::iterator it = clients.begin(); 493 std::map<int, SrsStatisticClient*>::iterator it = clients.begin();
499 for (int i = 0; i < start + count && it != clients.end(); it++, i++) { 494 for (int i = 0; i < start + count && it != clients.end(); it++, i++) {
500 if (i < start) { 495 if (i < start) {
@@ -503,16 +498,13 @@ int SrsStatistic::dumps_clients(stringstream& ss, int start, int count) @@ -503,16 +498,13 @@ int SrsStatistic::dumps_clients(stringstream& ss, int start, int count)
503 498
504 SrsStatisticClient* client = it->second; 499 SrsStatisticClient* client = it->second;
505 500
506 - if (i != start) {  
507 - ss << SRS_JFIELD_CONT;  
508 - } 501 + SrsAmf0Object* obj = SrsAmf0Any::object();
  502 + arr->append(obj);
509 503
510 - if ((ret = client->dumps(ss)) != ERROR_SUCCESS) { 504 + if ((ret = client->dumps(obj)) != ERROR_SUCCESS) {
511 return ret; 505 return ret;
512 } 506 }
513 } 507 }
514 - ss << SRS_JARRAY_END;  
515 -  
516 508
517 return ret; 509 return ret;
518 } 510 }
@@ -39,6 +39,8 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. @@ -39,6 +39,8 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
39 class SrsKbps; 39 class SrsKbps;
40 class SrsRequest; 40 class SrsRequest;
41 class SrsConnection; 41 class SrsConnection;
  42 +class SrsAmf0Object;
  43 +class SrsAmf0StrictArray;
42 44
43 struct SrsStatisticVhost 45 struct SrsStatisticVhost
44 { 46 {
@@ -56,7 +58,7 @@ public: @@ -56,7 +58,7 @@ public:
56 SrsStatisticVhost(); 58 SrsStatisticVhost();
57 virtual ~SrsStatisticVhost(); 59 virtual ~SrsStatisticVhost();
58 public: 60 public:
59 - virtual int dumps(std::stringstream& ss); 61 + virtual int dumps(SrsAmf0Object* obj);
60 }; 62 };
61 63
62 struct SrsStatisticStream 64 struct SrsStatisticStream
@@ -98,7 +100,7 @@ public: @@ -98,7 +100,7 @@ public:
98 SrsStatisticStream(); 100 SrsStatisticStream();
99 virtual ~SrsStatisticStream(); 101 virtual ~SrsStatisticStream();
100 public: 102 public:
101 - virtual int dumps(std::stringstream& ss); 103 + virtual int dumps(SrsAmf0Object* obj);
102 public: 104 public:
103 /** 105 /**
104 * publish the stream. 106 * publish the stream.
@@ -123,7 +125,7 @@ public: @@ -123,7 +125,7 @@ public:
123 SrsStatisticClient(); 125 SrsStatisticClient();
124 virtual ~SrsStatisticClient(); 126 virtual ~SrsStatisticClient();
125 public: 127 public:
126 - virtual int dumps(std::stringstream& ss); 128 + virtual int dumps(SrsAmf0Object* obj);
127 }; 129 };
128 130
129 class SrsStatistic 131 class SrsStatistic
@@ -217,19 +219,19 @@ public: @@ -217,19 +219,19 @@ public:
217 */ 219 */
218 virtual int64_t server_id(); 220 virtual int64_t server_id();
219 /** 221 /**
220 - * dumps the vhosts to sstream in json. 222 + * dumps the vhosts to amf0 array.
221 */ 223 */
222 - virtual int dumps_vhosts(std::stringstream& ss); 224 + virtual int dumps_vhosts(SrsAmf0StrictArray* arr);
223 /** 225 /**
224 - * dumps the streams to sstream in json. 226 + * dumps the streams to amf0 array.
225 */ 227 */
226 - virtual int dumps_streams(std::stringstream& ss); 228 + virtual int dumps_streams(SrsAmf0StrictArray* arr);
227 /** 229 /**
228 - * dumps the clients to sstream in json. 230 + * dumps the clients to amf0 array
229 * @param start the start index, from 0. 231 * @param start the start index, from 0.
230 * @param count the max count of clients to dump. 232 * @param count the max count of clients to dump.
231 */ 233 */
232 - virtual int dumps_clients(std::stringstream& ss, int start, int count); 234 + virtual int dumps_clients(SrsAmf0StrictArray* arr, int start, int count);
233 private: 235 private:
234 virtual SrsStatisticVhost* create_vhost(SrsRequest* req); 236 virtual SrsStatisticVhost* create_vhost(SrsRequest* req);
235 virtual SrsStatisticStream* create_stream(SrsStatisticVhost* vhost, SrsRequest* req); 237 virtual SrsStatisticStream* create_stream(SrsStatisticVhost* vhost, SrsRequest* req);