external/srs
1
0
Fork 0
mirror of https://github.com/ossrs/srs.git synced 2025-02-15 04:42:04 +00:00
Code Issues Releases Wiki Activity

fix gb28181 api error code

Browse source
This commit is contained in:
kyxlx550 2020-04-16 12:30:11 +08:00
parent 7950bc586e
commit 33b91cd6f2
5 changed files with 151 additions and 99 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

85
trunk/src/app/srs_app_gb28181.cpp
View file

@ -312,7 +312,12 @@ srs_error_t SrsGb28181PsRtpProcessor::on_udp_packet(const sockaddr* from, const
channel.set_channel_id(tmp_id);
channel.set_port_mode(RTP_PORT_MODE_FIXED);
channel.set_ssrc(pkt.ssrc);
_srs_gb28181->create_stream_channel(&channel);
srs_error_t err2 = srs_success;
if ((err2 = _srs_gb28181->create_stream_channel(&channel)) != srs_success){
srs_warn("gb28181: RtpProcessor create stream channel error %s", srs_error_desc(err2).c_str());
srs_error_reset(err2);
};
muxer = _srs_gb28181->fetch_rtmpmuxer(tmp_id);
}
@ -1547,8 +1552,9 @@ void SrsGb28181Manger::stop_rtp_listen(std::string id)
}
//api
uint32_t SrsGb28181Manger::create_stream_channel(SrsGb28181StreamChannel *channel)
srs_error_t SrsGb28181Manger::create_stream_channel(SrsGb28181StreamChannel *channel)
{
srs_error_t err = srs_success;
srs_assert(channel);
std::string id = channel->get_channel_id();
@ -1559,15 +1565,14 @@ uint32_t SrsGb28181Manger::create_stream_channel(SrsGb28181StreamChannel *channe
SrsGb28181StreamChannel s = muxer->get_channel();
channel->copy(&s);
//return ERROR_GB28181_SESSION_IS_EXIST;
return ERROR_SUCCESS;
return err;
}
//create on rtmp muxer, gb28181 stream to rtmp
srs_error_t err = srs_success;
if ((err = fetch_or_create_rtmpmuxer(id, &muxer)) != srs_success){
srs_warn("gb28181: create rtmp muxer error, %s", srs_error_desc(err).c_str());
srs_freep(err);
return ERROR_GB28181_CREATER_RTMPMUXER_FAILED;
return err;
}
//Start RTP listening port, receive gb28181 stream,
@ -1584,21 +1589,19 @@ uint32_t SrsGb28181Manger::create_stream_channel(SrsGb28181StreamChannel *channe
if (port_mode == RTP_PORT_MODE_RANDOM){
alloc_port(&rtp_port);
if (rtp_port <= 0){
return ERROR_GB28181_RTP_PORT_FULL;
return srs_error_new(ERROR_GB28181_RTP_PORT_FULL, "gb28181: rtp port full");
}
srs_error_t err = srs_success;
if ((err = start_ps_rtp_listen(id, rtp_port)) != srs_success){
srs_warn("gb28181: start ps rtp listen error, %s", srs_error_desc(err).c_str());
srs_freep(err);
free_port(rtp_port, rtp_port + 1);
return ERROR_GB28181_CREATER_RTMPMUXER_FAILED;
return err;
}
}
else if(port_mode == RTP_PORT_MODE_FIXED) {
rtp_port = config->rtp_mux_port;
}
else{
return ERROR_GB28181_PORT_MODE_INVALID;
return srs_error_new(ERROR_GB28181_PORT_MODE_INVALID, "gb28181: port mode invalid");
}
uint32_t ssrc = channel->get_ssrc();
@ -1673,11 +1676,13 @@ uint32_t SrsGb28181Manger::create_stream_channel(SrsGb28181StreamChannel *channe
muxer->copy_channel(channel);
return ERROR_SUCCESS;
return err;
}
uint32_t SrsGb28181Manger::delete_stream_channel(std::string id)
srs_error_t SrsGb28181Manger::delete_stream_channel(std::string id)
{
srs_error_t err = srs_success;
//notify the device to stop streaming
//if an internal sip service controlled channel
notify_sip_bye(id, id);
@ -1686,19 +1691,21 @@ uint32_t SrsGb28181Manger::delete_stream_channel(std::string id)
if (muxer){
stop_rtp_listen(id);
muxer->stop();
return ERROR_SUCCESS;
return err;
}else {
return ERROR_GB28181_SESSION_IS_NOTEXIST;
return srs_error_new(ERROR_GB28181_SESSION_IS_NOTEXIST, "stream channel is not exists");
}
}
uint32_t SrsGb28181Manger::query_stream_channel(std::string id, SrsJsonArray* arr)
srs_error_t SrsGb28181Manger::query_stream_channel(std::string id, SrsJsonArray* arr)
{
srs_error_t err = srs_success;
if (!id.empty()){
SrsGb28181RtmpMuxer *muxer = fetch_rtmpmuxer(id);
if (!muxer){
return ERROR_GB28181_SESSION_IS_NOTEXIST;
return srs_error_new(ERROR_GB28181_SESSION_IS_NOTEXIST, "stream channel not exists");
}
SrsJsonObject* obj = SrsJsonAny::object();
arr->append(obj);
@ -1713,13 +1720,15 @@ uint32_t SrsGb28181Manger::query_stream_channel(std::string id, SrsJsonArray* ar
}
}
return ERROR_SUCCESS;
return err;
}
uint32_t SrsGb28181Manger::notify_sip_invite(std::string id, std::string ip, int port, uint32_t ssrc, std::string chid)
srs_error_t SrsGb28181Manger::notify_sip_invite(std::string id, std::string ip, int port, uint32_t ssrc, std::string chid)
{
srs_error_t err = srs_success;
if (!sip_service){
return ERROR_GB28181_SIP_NOT_RUN;
return srs_error_new(ERROR_GB28181_SIP_NOT_RUN, "sip not run");
}
//if RTMP Muxer does not exist, you need to create
@ -1732,9 +1741,9 @@ uint32_t SrsGb28181Manger::notify_sip_invite(std::string id, std::string ip, int
//channel not exist
SrsGb28181StreamChannel channel;
channel.set_channel_id(key);
int code = create_stream_channel(&channel);
if (code != ERROR_SUCCESS){
return code;
err = create_stream_channel(&channel);
if (err != srs_success){
return err;
}
ip = channel.get_ip();
@ -1754,10 +1763,10 @@ uint32_t SrsGb28181Manger::notify_sip_invite(std::string id, std::string ip, int
return sip_service->send_invite(&req, ip, port, ssrc, chid);
}
uint32_t SrsGb28181Manger::notify_sip_bye(std::string id, std::string chid)
srs_error_t SrsGb28181Manger::notify_sip_bye(std::string id, std::string chid)
{
if (!sip_service){
return ERROR_GB28181_SIP_NOT_RUN;
return srs_error_new(ERROR_GB28181_SIP_NOT_RUN, "sip not run");
}
SrsSipRequest req;
@ -1765,10 +1774,10 @@ uint32_t SrsGb28181Manger::notify_sip_bye(std::string id, std::string chid)
return sip_service->send_bye(&req, chid);
}
uint32_t SrsGb28181Manger::notify_sip_raw_data(std::string id, std::string data)
srs_error_t SrsGb28181Manger::notify_sip_raw_data(std::string id, std::string data)
{
if (!sip_service){
return ERROR_GB28181_SIP_NOT_RUN;
return srs_error_new(ERROR_GB28181_SIP_NOT_RUN, "sip not run");
}
SrsSipRequest req;
@ -1777,21 +1786,19 @@ uint32_t SrsGb28181Manger::notify_sip_raw_data(std::string id, std::string data)
}
uint32_t SrsGb28181Manger::notify_sip_unregister(std::string id)
srs_error_t SrsGb28181Manger::notify_sip_unregister(std::string id)
{
if (!sip_service){
return ERROR_GB28181_SIP_NOT_RUN;
return srs_error_new(ERROR_GB28181_SIP_NOT_RUN, "sip not run");
}
delete_stream_channel(id);
sip_service->remove_session(id);
return ERROR_SUCCESS;
return delete_stream_channel(id);
}
uint32_t SrsGb28181Manger::notify_sip_query_catalog(std::string id)
srs_error_t SrsGb28181Manger::notify_sip_query_catalog(std::string id)
{
if (!sip_service){
return ERROR_GB28181_SIP_NOT_RUN;
if (!sip_service){
return srs_error_new(ERROR_GB28181_SIP_NOT_RUN, "sip not run");
}
SrsSipRequest req;
@ -1799,10 +1806,10 @@ uint32_t SrsGb28181Manger::notify_sip_query_catalog(std::string id)
return sip_service->send_query_catalog(&req);
}
uint32_t SrsGb28181Manger::query_sip_session(std::string id, SrsJsonArray* arr)
srs_error_t SrsGb28181Manger::query_sip_session(std::string id, SrsJsonArray* arr)
{
if (!sip_service){
return ERROR_GB28181_SIP_NOT_RUN;
if (!sip_service){
return srs_error_new(ERROR_GB28181_SIP_NOT_RUN, "sip not run");
}
return sip_service->query_sip_session(id, arr);

18
trunk/src/app/srs_app_gb28181.hpp
View file

@ -413,16 +413,16 @@ public:
public:
//stream channel api
uint32_t create_stream_channel(SrsGb28181StreamChannel *channel);
uint32_t delete_stream_channel(std::string id);
uint32_t query_stream_channel(std::string id, SrsJsonArray* arr);
srs_error_t create_stream_channel(SrsGb28181StreamChannel *channel);
srs_error_t delete_stream_channel(std::string id);
srs_error_t query_stream_channel(std::string id, SrsJsonArray* arr);
//sip api
uint32_t notify_sip_invite(std::string id, std::string ip, int port, uint32_t ssrc, std::string chid);
uint32_t notify_sip_bye(std::string id, std::string chid);
uint32_t notify_sip_raw_data(std::string id, std::string data);
uint32_t notify_sip_unregister(std::string id);
uint32_t notify_sip_query_catalog(std::string id);
uint32_t query_sip_session(std::string id, SrsJsonArray* arr);
srs_error_t notify_sip_invite(std::string id, std::string ip, int port, uint32_t ssrc, std::string chid);
srs_error_t notify_sip_bye(std::string id, std::string chid);
srs_error_t notify_sip_raw_data(std::string id, std::string data);
srs_error_t notify_sip_unregister(std::string id);
srs_error_t notify_sip_query_catalog(std::string id);
srs_error_t query_sip_session(std::string id, SrsJsonArray* arr);
private:
void destroy();

76
trunk/src/app/srs_app_gb28181_sip.cpp
View file

@ -201,20 +201,25 @@ srs_error_t SrsGb28181SipSession::do_cycle()
}
//create stream channel, ready for recv device av stream
int code = _srs_gb28181->create_stream_channel(&ch);
srs_error_t err = _srs_gb28181->create_stream_channel(&ch);
if (code == ERROR_SUCCESS){
if ((err = _srs_gb28181->create_stream_channel(&ch)) == srs_success){
SrsSipRequest req;
req.sip_auth_id = _session_id;
//send invite to device, req push av stream
code = servcie->send_invite(&req, ch.get_ip(),
ch.get_rtp_port(), ch.get_ssrc(), chid);
//the same device can't be sent too fast. the device can't handle it
srs_usleep(1*SRS_UTIME_SECONDS);
err = servcie->send_invite(&req, ch.get_ip(),
ch.get_rtp_port(), ch.get_ssrc(), chid);
}
int code = srs_error_code(err);
if (err != srs_success){
srs_error_reset(err);
}
//the same device can't be sent too fast. the device can't handle it
srs_usleep(1*SRS_UTIME_SECONDS);
srs_trace("gb28181: %s clients device=%s send invite code=%d",
_session_id.c_str(), chid.c_str(), code);
}//end for (it)
@ -238,9 +243,14 @@ srs_error_t SrsGb28181SipSession::do_cycle()
query_duration >= config->sip_query_catalog_interval) {
SrsSipRequest req;
req.sip_auth_id = _session_id;
servcie->send_query_catalog(&req);
_query_catalog_time = srs_get_system_time();
srs_error_t err = servcie->send_query_catalog(&req);
if (err != srs_success){
srs_trace("gb28181: sip query catalog error %s",srs_error_desc(err).c_str());
srs_error_reset(err);
}
//print device status
srs_trace("gb28181: sip session=%s peer(%s, %d) status(%s,%s) duration(%u,%u)",
_session_id.c_str(), _peer_ip.c_str(), _peer_port,
@ -621,26 +631,28 @@ int SrsGb28181SipService::send_status(SrsSipRequest *req, sockaddr *f, int l)
}
int SrsGb28181SipService::send_invite(SrsSipRequest *req, string ip, int port, uint32_t ssrc, std::string chid)
srs_error_t SrsGb28181SipService::send_invite(SrsSipRequest *req, string ip, int port, uint32_t ssrc, std::string chid)
{
srs_error_t err = srs_success;
srs_assert(req);
SrsGb28181SipSession *sip_session = fetch(req->sip_auth_id);
if (!sip_session){
return ERROR_GB28181_SESSION_IS_NOTEXIST;
return srs_error_new(ERROR_GB28181_SESSION_IS_NOTEXIST, "sip session not exist");
}
//if you are inviting or succeed in invite,
//you cannot invite again. you need to 'bye' and try again
SrsGb28181Device *device = sip_session->get_device_info(chid);
if (!device || device->device_status != "ON"){
return ERROR_GB28181_SIP_CH_OFFLINE;
return srs_error_new(ERROR_GB28181_SIP_CH_OFFLINE, "sip device channel offline");
}
if (device->invite_status == SrsGb28181SipSessionTrying ||
device->invite_status == SrsGb28181SipSessionInviteOk){
return ERROR_GB28181_SIP_IS_INVITING;
return srs_error_new(ERROR_GB28181_SIP_IS_INVITING, "sip device channel inviting");
}
req->host = config->host;
@ -656,7 +668,7 @@ int SrsGb28181SipService::send_invite(SrsSipRequest *req, string ip, int port,
if (send_message(&addr, sip_session->sockaddr_fromlen(), ss) <= 0)
{
return ERROR_GB28181_SIP_INVITE_FAILED;
return srs_error_new(ERROR_GB28181_SIP_INVITE_FAILED, "sip device invite failed");
}
//prame branch, from_tag, to_tag, call_id,
@ -668,27 +680,25 @@ int SrsGb28181SipService::send_invite(SrsSipRequest *req, string ip, int port,
//call_id map sip_session
sip_session_map_by_callid(sip_session, req->call_id);
return ERROR_SUCCESS;
return err;
}
int SrsGb28181SipService::send_bye(SrsSipRequest *req, std::string chid)
srs_error_t SrsGb28181SipService::send_bye(SrsSipRequest *req, std::string chid)
{
srs_error_t err = srs_success;
srs_assert(req);
SrsGb28181SipSession *sip_session = fetch(req->sip_auth_id);
if (!sip_session){
return ERROR_GB28181_SESSION_IS_NOTEXIST;
return srs_error_new(ERROR_GB28181_SESSION_IS_NOTEXIST, "sip session not exist");
}
SrsGb28181Device *device = sip_session->get_device_info(chid);
if (!device){
return ERROR_GB28181_SIP_CH_NOTEXIST;
return srs_error_new(ERROR_GB28181_SIP_CH_NOTEXIST, "sip device channel not exist");
}
// if (status == SrsGb28181SipSessionTrying ||
// status == SrsGb28181SipSessionInviteOk){
// return ERROR_GB28181_SIP_IS_INVITING;
// }
//prame branch, from_tag, to_tag, call_id,
//The parameter of 'bye' must be the same as 'invite'
@ -709,20 +719,22 @@ int SrsGb28181SipService::send_bye(SrsSipRequest *req, std::string chid)
sockaddr addr = sip_session->sockaddr_from();
if (send_message(&addr, sip_session->sockaddr_fromlen(), ss) <= 0)
{
return ERROR_GB28181_SIP_BYE_FAILED;
return srs_error_new(ERROR_GB28181_SIP_BYE_FAILED, "sip bye failed");
}
return ERROR_SUCCESS;
return err;
}
int SrsGb28181SipService::send_sip_raw_data(SrsSipRequest *req, std::string data)
srs_error_t SrsGb28181SipService::send_sip_raw_data(SrsSipRequest *req, std::string data)
{
srs_error_t err = srs_success;
srs_assert(req);
SrsGb28181SipSession *sip_session = fetch(req->sip_auth_id);
if (!sip_session){
return ERROR_GB28181_SESSION_IS_NOTEXIST;
return srs_error_new(ERROR_GB28181_SESSION_IS_NOTEXIST, "sip session no exist");
}
std::stringstream ss;
@ -731,13 +743,13 @@ int SrsGb28181SipService::send_sip_raw_data(SrsSipRequest *req, std::string dat
sockaddr addr = sip_session->sockaddr_from();
if (send_message(&addr, sip_session->sockaddr_fromlen(), ss) <= 0)
{
return ERROR_GB28181_SIP_RAW_DATA_FAILED;
return srs_error_new(ERROR_GB28181_SIP_RAW_DATA_FAILED, "sip raw data failed");
}
return ERROR_SUCCESS;
return err;
}
int SrsGb28181SipService::send_query_catalog(SrsSipRequest *req)
srs_error_t SrsGb28181SipService::send_query_catalog(SrsSipRequest *req)
{
req->host = config->host;
req->host_port = config->sip_port;
@ -752,12 +764,14 @@ int SrsGb28181SipService::send_query_catalog(SrsSipRequest *req)
return send_sip_raw_data(req, ss.str());
}
int SrsGb28181SipService::query_sip_session(std::string sid, SrsJsonArray* arr)
srs_error_t SrsGb28181SipService::query_sip_session(std::string sid, SrsJsonArray* arr)
{
srs_error_t err = srs_success;
if (!sid.empty()){
SrsGb28181SipSession* sess = fetch(sid);
if (!sess){
return ERROR_GB28181_SESSION_IS_NOTEXIST;
return srs_error_new(ERROR_GB28181_SESSION_IS_NOTEXIST, "sip session not exist");
}
SrsJsonObject* obj = SrsJsonAny::object();
arr->append(obj);
@ -772,7 +786,7 @@ int SrsGb28181SipService::query_sip_session(std::string sid, SrsJsonArray* arr)
}
}
return ERROR_SUCCESS;
return err;
}
srs_error_t SrsGb28181SipService::fetch_or_create_sip_session(SrsSipRequest *req, SrsGb28181SipSession** sip_session)

10
trunk/src/app/srs_app_gb28181_sip.hpp
View file

@ -172,9 +172,9 @@ public:
int send_ack(SrsSipRequest *req, sockaddr *f, int l);
int send_status(SrsSipRequest *req, sockaddr *f, int l);
int send_invite(SrsSipRequest *req, std::string ip, int port, uint32_t ssrc, std::string chid);
int send_bye(SrsSipRequest *req, std::string chid);
int send_query_catalog(SrsSipRequest *req);
srs_error_t send_invite(SrsSipRequest *req, std::string ip, int port, uint32_t ssrc, std::string chid);
srs_error_t send_bye(SrsSipRequest *req, std::string chid);
srs_error_t send_query_catalog(SrsSipRequest *req);
// The SIP command is transmitted through HTTP API,
// and the body content is transmitted to the device,
@ -190,8 +190,8 @@ public:
// Content-Length: 0
//
//
int send_sip_raw_data(SrsSipRequest *req, std::string data);
int query_sip_session(std::string sid, SrsJsonArray* arr);
srs_error_t send_sip_raw_data(SrsSipRequest *req, std::string data);
srs_error_t query_sip_session(std::string sid, SrsJsonArray* arr);
public:
srs_error_t fetch_or_create_sip_session(SrsSipRequest *req, SrsGb28181SipSession** sess);

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

@ -1670,6 +1670,8 @@ SrsGoApiGb28181::~SrsGoApiGb28181()
srs_error_t SrsGoApiGb28181::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
{
srs_error_t err = srs_success;
SrsJsonObject* obj = SrsJsonAny::object();
SrsAutoFree(SrsJsonObject, obj);
@ -1697,8 +1699,8 @@ srs_error_t SrsGoApiGb28181::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessa
channel.set_stream(stream);
channel.set_port_mode(port_mode);
uint32_t code = _srs_gb28181->create_stream_channel(&channel);
if (code != ERROR_SUCCESS) {
if ((err =_srs_gb28181->create_stream_channel(&channel)) != srs_success) {
int code = srs_error_code(err); srs_error_reset(err);
return srs_api_response_code(w, r, code);
}
@ -1718,15 +1720,20 @@ srs_error_t SrsGoApiGb28181::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessa
return srs_api_response_code(w, r, ERROR_GB28181_VALUE_EMPTY);
}
uint32_t code = _srs_gb28181->delete_stream_channel(id);
err =_srs_gb28181->delete_stream_channel(id);
int code = srs_error_code(err);
if (err != srs_success) {
srs_error_reset(err);
}
return srs_api_response_code(w, r, code);
}
else if(action == "query_channel") {
SrsJsonArray* arr = SrsJsonAny::array();
data->set("channels", arr);
uint32_t code = _srs_gb28181->query_stream_channel(id, arr);
if (code != ERROR_SUCCESS) {
if ((err = _srs_gb28181->query_stream_channel(id, arr)) != srs_success) {
int code = srs_error_code(err); srs_error_reset(err);
return srs_api_response_code(w, r, code);
}
@ -1745,9 +1752,12 @@ srs_error_t SrsGoApiGb28181::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessa
int _port = strtoul(rtp_port.c_str(), NULL, 10);
uint32_t _ssrc = (uint32_t)(strtoul(ssrc.c_str(), NULL, 10));
err = _srs_gb28181->notify_sip_invite(id, ip, _port, _ssrc, chid);
int code = srs_error_code(err);
if (err != srs_success) {
srs_error_reset(err);
}
int code = _srs_gb28181->notify_sip_invite(id, ip, _port, _ssrc, chid);
return srs_api_response_code(w, r, code);
}
else if(action == "sip_bye"){
@ -1756,7 +1766,12 @@ srs_error_t SrsGoApiGb28181::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessa
return srs_api_response_code(w, r, ERROR_GB28181_VALUE_EMPTY);
}
int code = _srs_gb28181->notify_sip_bye(id, chid);
err = _srs_gb28181->notify_sip_bye(id, chid);
int code = srs_error_code(err);
if (err != srs_success) {
srs_error_reset(err);
}
return srs_api_response_code(w, r, code);
}
else if(action == "sip_raw_data"){
@ -1766,7 +1781,13 @@ srs_error_t SrsGoApiGb28181::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessa
std::string body;
r->body_read_all(body);
int code = _srs_gb28181->notify_sip_raw_data(id, body);
err = _srs_gb28181->notify_sip_raw_data(id, body);
int code = srs_error_code(err);
if (err != srs_success) {
srs_error_reset(err);
}
return srs_api_response_code(w, r, code);
}
else if(action == "sip_unregister"){
@ -1774,7 +1795,12 @@ srs_error_t SrsGoApiGb28181::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessa
return srs_api_response_code(w, r, ERROR_GB28181_VALUE_EMPTY);
}
int code = _srs_gb28181->notify_sip_unregister(id);
err = _srs_gb28181->notify_sip_unregister(id);
int code = srs_error_code(err);
if (err != srs_success) {
srs_error_reset(err);
}
return srs_api_response_code(w, r, code);
}
else if(action == "sip_query_catalog"){
@ -1782,15 +1808,20 @@ srs_error_t SrsGoApiGb28181::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessa
return srs_api_response_code(w, r, ERROR_GB28181_VALUE_EMPTY);
}
int code = _srs_gb28181->notify_sip_query_catalog(id);
err = _srs_gb28181->notify_sip_query_catalog(id);
int code = srs_error_code(err);
if (err != srs_success) {
srs_error_reset(err);
}
return srs_api_response_code(w, r, code);
}
else if(action == "sip_query_session"){
SrsJsonArray* arr = SrsJsonAny::array();
data->set("sessions", arr);
uint32_t code = _srs_gb28181->query_sip_session(id, arr);
if (code != ERROR_SUCCESS) {
if ((err = _srs_gb28181->query_sip_session(id, arr)) != srs_success) {
int code = srs_error_code(err); srs_error_reset(err);
return srs_api_response_code(w, r, code);
}