cellular-infrastructure
/
osmo-msc
mirror of https://gerrit.osmocom.org/osmo-msc
9
0
Fork 0
Code Issues Releases Wiki Activity

Merge branch 'zecke/mgcp-transcoder'

This commit is contained in:
Holger Hans Peter Freyther 2010-11-02 19:41:42 +01:00
parent 43eb1a3db0 8b19dee437
commit 79dcd719e0
4 changed files with 163 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
openbsc/include/openbsc/mgcp_internal.h
View File

@ -98,7 +98,15 @@ struct mgcp_endpoint {
/* port status for bts/net */ /* port status for bts/net */
struct mgcp_rtp_end bts_end; struct mgcp_rtp_end bts_end;
struct mgcp_rtp_end net_end; struct mgcp_rtp_end net_end;
struct mgcp_rtp_end transcoder_end;
/*
* For transcoding we will send from the local_port
* of trans_bts and it will arrive at trans_net from
* where we will forward it to the network.
*/
struct mgcp_rtp_end trans_bts;
struct mgcp_rtp_end trans_net;
int is_transcoded;
/* sequence bits */ /* sequence bits */
struct mgcp_rtp_state net_state; struct mgcp_rtp_state net_state;
@ -124,7 +132,15 @@ int mgcp_analyze_header(struct mgcp_config *cfg, struct msgb *msg,
int mgcp_send_dummy(struct mgcp_endpoint *endp); int mgcp_send_dummy(struct mgcp_endpoint *endp);
int mgcp_bind_bts_rtp_port(struct mgcp_endpoint *endp, int rtp_port); int mgcp_bind_bts_rtp_port(struct mgcp_endpoint *endp, int rtp_port);
int mgcp_bind_net_rtp_port(struct mgcp_endpoint *endp, int rtp_port); int mgcp_bind_net_rtp_port(struct mgcp_endpoint *endp, int rtp_port);
int mgcp_bind_transcoder_rtp_port(struct mgcp_endpoint *enp, int rtp_port); int mgcp_bind_trans_bts_rtp_port(struct mgcp_endpoint *enp, int rtp_port);
int mgcp_bind_trans_net_rtp_port(struct mgcp_endpoint *enp, int rtp_port);
int mgcp_free_rtp_port(struct mgcp_rtp_end *end); int mgcp_free_rtp_port(struct mgcp_rtp_end *end);
/* For transcoding we need to manage an in and an output that are connected */
static inline int endp_back_channel(int endpoint)
{
return endpoint + 60;
}
#endif #endif

139
openbsc/src/mgcp/mgcp_network.c
View File

@ -168,31 +168,22 @@ static int forward_data(int fd, struct mgcp_rtp_tap *tap, const char *buf, int l
(struct sockaddr *)&tap->forward, sizeof(tap->forward)); (struct sockaddr *)&tap->forward, sizeof(tap->forward));
} }
static int send_transcoder(struct mgcp_endpoint *endp, int is_rtp, static int send_transcoder(struct mgcp_rtp_end *end, struct mgcp_config *cfg,
const char *buf, int len) int is_rtp, const char *buf, int len)
{ {
int rc; int rc;
int port; int port;
struct mgcp_config *cfg = endp->cfg;
struct sockaddr_in addr; struct sockaddr_in addr;
if (endp->transcoder_end.rtp_port == 0) { port = is_rtp ? end->rtp_port : end->rtcp_port;
LOGP(DMGCP, LOGL_ERROR, "Transcoder port not known on 0x%x\n",
ENDPOINT_NUMBER(endp));
return -1;
}
port = rtp_calculate_port(ENDPOINT_NUMBER(endp), cfg->transcoder_remote_base);
if (!is_rtp)
port += 1;
addr.sin_family = AF_INET; addr.sin_family = AF_INET;
addr.sin_addr = cfg->transcoder_in; addr.sin_addr = cfg->transcoder_in;
addr.sin_port = htons(port); addr.sin_port = port;
rc = sendto(is_rtp ? rc = sendto(is_rtp ?
endp->bts_end.rtp.fd : end->rtp.fd :
endp->bts_end.rtcp.fd, buf, len, 0, end->rtcp.fd, buf, len, 0,
(struct sockaddr *) &addr, sizeof(addr)); (struct sockaddr *) &addr, sizeof(addr));
if (rc != len) if (rc != len)
@ -306,6 +297,9 @@ static int rtp_data_net(struct bsc_fd *fd, unsigned int what)
endp->net_end.packets += 1; endp->net_end.packets += 1;
forward_data(fd->fd, &endp->taps[MGCP_TAP_NET_IN], buf, rc); forward_data(fd->fd, &endp->taps[MGCP_TAP_NET_IN], buf, rc);
if (endp->is_transcoded)
return send_transcoder(&endp->trans_net, endp->cfg, proto == PROTO_RTP, &buf[0], rc);
else
return send_to(endp, DEST_BTS, proto == PROTO_RTP, &addr, &buf[0], rc); return send_to(endp, DEST_BTS, proto == PROTO_RTP, &addr, &buf[0], rc);
} }
@ -383,53 +377,67 @@ static int rtp_data_bts(struct bsc_fd *fd, unsigned int what)
endp->bts_end.packets += 1; endp->bts_end.packets += 1;
forward_data(fd->fd, &endp->taps[MGCP_TAP_BTS_IN], buf, rc); forward_data(fd->fd, &endp->taps[MGCP_TAP_BTS_IN], buf, rc);
if (cfg->transcoder_ip) if (endp->is_transcoded)
return send_transcoder(endp, proto == PROTO_RTP, &buf[0], rc); return send_transcoder(&endp->trans_bts, endp->cfg, proto == PROTO_RTP, &buf[0], rc);
else else
return send_to(endp, DEST_NETWORK, proto == PROTO_RTP, &addr, &buf[0], rc); return send_to(endp, DEST_NETWORK, proto == PROTO_RTP, &addr, &buf[0], rc);
} }
static int rtp_data_transcoder(struct bsc_fd *fd, unsigned int what) static int rtp_data_transcoder(struct mgcp_rtp_end *end, struct mgcp_endpoint *_endp,
int dest, struct bsc_fd *fd)
{ {
char buf[4096]; char buf[4096];
struct sockaddr_in addr; struct sockaddr_in addr;
struct mgcp_endpoint *endp;
struct mgcp_config *cfg; struct mgcp_config *cfg;
int rc, proto; int rc, proto;
endp = (struct mgcp_endpoint *) fd->data; cfg = _endp->cfg;
cfg = endp->cfg; rc = recevice_from(_endp, fd->fd, &addr, buf, sizeof(buf));
rc = recevice_from(endp, fd->fd, &addr, buf, sizeof(buf));
if (rc <= 0) if (rc <= 0)
return -1; return -1;
proto = fd == &endp->transcoder_end.rtp ? PROTO_RTP : PROTO_RTCP; proto = fd == &end->rtp ? PROTO_RTP : PROTO_RTCP;
if (memcmp(&addr.sin_addr, &cfg->transcoder_in, sizeof(addr.sin_addr)) != 0) { if (memcmp(&addr.sin_addr, &cfg->transcoder_in, sizeof(addr.sin_addr)) != 0) {
LOGP(DMGCP, LOGL_ERROR, LOGP(DMGCP, LOGL_ERROR,
"Data not coming from transcoder: %s on 0x%x\n", "Data not coming from transcoder dest: %d %s on 0x%x\n",
inet_ntoa(addr.sin_addr), ENDPOINT_NUMBER(endp)); dest, inet_ntoa(addr.sin_addr), ENDPOINT_NUMBER(_endp));
return -1; return -1;
} }
if (endp->transcoder_end.rtp_port != addr.sin_port && if (end->rtp_port != addr.sin_port &&
endp->transcoder_end.rtcp_port != addr.sin_port) { end->rtcp_port != addr.sin_port) {
LOGP(DMGCP, LOGL_ERROR, LOGP(DMGCP, LOGL_ERROR,
"Data from wrong transcoder source port %d on 0x%x\n", "Data from wrong transcoder dest %d source port %d on 0x%x\n",
ntohs(addr.sin_port), ENDPOINT_NUMBER(endp)); dest, ntohs(addr.sin_port), ENDPOINT_NUMBER(_endp));
return -1; return -1;
} }
/* throw away the dummy message */ /* throw away the dummy message */
if (rc == 1 && buf[0] == DUMMY_LOAD) { if (rc == 1 && buf[0] == DUMMY_LOAD) {
LOGP(DMGCP, LOGL_NOTICE, "Filtered dummy from transcoder on 0x%x\n", LOGP(DMGCP, LOGL_NOTICE, "Filtered dummy from transcoder dest %d on 0x%x\n",
ENDPOINT_NUMBER(endp)); dest, ENDPOINT_NUMBER(_endp));
return 0; return 0;
} }
endp->transcoder_end.packets += 1; end->packets += 1;
return send_to(endp, DEST_NETWORK, proto == PROTO_RTP, &addr, &buf[0], rc); return send_to(_endp, dest, proto == PROTO_RTP, &addr, &buf[0], rc);
}
static int rtp_data_trans_net(struct bsc_fd *fd, unsigned int what)
{
struct mgcp_endpoint *endp;
endp = (struct mgcp_endpoint *) fd->data;
return rtp_data_transcoder(&endp->trans_net, endp, DEST_NETWORK, fd);
}
static int rtp_data_trans_bts(struct bsc_fd *fd, unsigned int what)
{
struct mgcp_endpoint *endp;
endp = (struct mgcp_endpoint *) fd->data;
return rtp_data_transcoder(&endp->trans_bts, endp, DEST_BTS, fd);
} }
static int create_bind(const char *source_addr, struct bsc_fd *fd, int port) static int create_bind(const char *source_addr, struct bsc_fd *fd, int port)
@ -511,52 +519,47 @@ cleanup0:
return -1; return -1;
} }
int mgcp_bind_bts_rtp_port(struct mgcp_endpoint *endp, int rtp_port) static int int_bind(const char *port,
struct mgcp_rtp_end *end, int (*cb)(struct bsc_fd *, unsigned),
struct mgcp_endpoint *_endp, int rtp_port)
{ {
if (endp->bts_end.rtp.fd != -1 || endp->bts_end.rtcp.fd != -1) { if (end->rtp.fd != -1 || end->rtcp.fd != -1) {
LOGP(DMGCP, LOGL_ERROR, "Previous bts-port was still bound on %d\n", LOGP(DMGCP, LOGL_ERROR, "Previous %s was still bound on %d\n",
ENDPOINT_NUMBER(endp)); port, ENDPOINT_NUMBER(_endp));
mgcp_free_rtp_port(&endp->bts_end); mgcp_free_rtp_port(end);
} }
endp->bts_end.local_port = rtp_port; end->local_port = rtp_port;
endp->bts_end.rtp.cb = rtp_data_bts; end->rtp.cb = cb;
endp->bts_end.rtp.data = endp; end->rtp.data = _endp;
endp->bts_end.rtcp.data = endp; end->rtcp.data = _endp;
endp->bts_end.rtcp.cb = rtp_data_bts; end->rtcp.cb = cb;
return bind_rtp(endp->cfg, &endp->bts_end, ENDPOINT_NUMBER(endp)); return bind_rtp(_endp->cfg, end, ENDPOINT_NUMBER(_endp));
}
int mgcp_bind_bts_rtp_port(struct mgcp_endpoint *endp, int rtp_port)
{
return int_bind("bts-port", &endp->bts_end,
rtp_data_bts, endp, rtp_port);
} }
int mgcp_bind_net_rtp_port(struct mgcp_endpoint *endp, int rtp_port) int mgcp_bind_net_rtp_port(struct mgcp_endpoint *endp, int rtp_port)
{ {
if (endp->net_end.rtp.fd != -1 || endp->net_end.rtcp.fd != -1) { return int_bind("net-port", &endp->net_end,
LOGP(DMGCP, LOGL_ERROR, "Previous net-port was still bound on %d\n", rtp_data_net, endp, rtp_port);
ENDPOINT_NUMBER(endp));
mgcp_free_rtp_port(&endp->net_end);
} }
endp->net_end.local_port = rtp_port; int mgcp_bind_trans_net_rtp_port(struct mgcp_endpoint *endp, int rtp_port)
endp->net_end.rtp.cb = rtp_data_net;
endp->net_end.rtp.data = endp;
endp->net_end.rtcp.data = endp;
endp->net_end.rtcp.cb = rtp_data_net;
return bind_rtp(endp->cfg, &endp->net_end, ENDPOINT_NUMBER(endp));
}
int mgcp_bind_transcoder_rtp_port(struct mgcp_endpoint *endp, int rtp_port)
{ {
if (endp->transcoder_end.rtp.fd != -1 || endp->transcoder_end.rtcp.fd != -1) { return int_bind("trans-net", &endp->trans_net,
LOGP(DMGCP, LOGL_ERROR, "Previous net-port was still bound on %d\n", rtp_data_trans_net, endp, rtp_port);
ENDPOINT_NUMBER(endp));
mgcp_free_rtp_port(&endp->transcoder_end);
} }
endp->transcoder_end.local_port = rtp_port; int mgcp_bind_trans_bts_rtp_port(struct mgcp_endpoint *endp, int rtp_port)
endp->transcoder_end.rtp.cb = rtp_data_transcoder; {
endp->transcoder_end.rtp.data = endp; return int_bind("trans-bts", &endp->trans_bts,
endp->transcoder_end.rtcp.data = endp; rtp_data_trans_bts, endp, rtp_port);
endp->transcoder_end.rtcp.cb = rtp_data_transcoder;
return bind_rtp(endp->cfg, &endp->transcoder_end, ENDPOINT_NUMBER(endp));
} }
int mgcp_free_rtp_port(struct mgcp_rtp_end *end) int mgcp_free_rtp_port(struct mgcp_rtp_end *end)

64
openbsc/src/mgcp/mgcp_protocol.c
View File

@ -382,7 +382,6 @@ static int allocate_port(struct mgcp_endpoint *endp, struct mgcp_rtp_end *end,
int i; int i;
if (range->mode == PORT_ALLOC_STATIC) { if (range->mode == PORT_ALLOC_STATIC) {
end->local_port = rtp_calculate_port(ENDPOINT_NUMBER(endp), range->base_port);
end->local_alloc = PORT_ALLOC_STATIC; end->local_alloc = PORT_ALLOC_STATIC;
return 0; return 0;
} }
@ -421,14 +420,28 @@ static int allocate_ports(struct mgcp_endpoint *endp)
return -1; return -1;
} }
if (endp->cfg->transcoder_ip && if (endp->cfg->transcoder_ip) {
allocate_port(endp, &endp->transcoder_end, &endp->cfg->transcoder_ports, if (allocate_port(endp, &endp->trans_net,
mgcp_bind_transcoder_rtp_port) != 0) { &endp->cfg->transcoder_ports,
mgcp_bind_trans_net_rtp_port) != 0) {
mgcp_rtp_end_reset(&endp->net_end); mgcp_rtp_end_reset(&endp->net_end);
mgcp_rtp_end_reset(&endp->bts_end); mgcp_rtp_end_reset(&endp->bts_end);
return -1; return -1;
} }
if (allocate_port(endp, &endp->trans_bts,
&endp->cfg->transcoder_ports,
mgcp_bind_trans_bts_rtp_port) != 0) {
mgcp_rtp_end_reset(&endp->net_end);
mgcp_rtp_end_reset(&endp->bts_end);
mgcp_rtp_end_reset(&endp->trans_net);
return -1;
}
/* remember that we have set up transcoding */
endp->is_transcoded = 1;
}
return 0; return 0;
} }
@ -790,12 +803,14 @@ struct mgcp_config *mgcp_config_alloc(void)
static void mgcp_rtp_end_reset(struct mgcp_rtp_end *end) static void mgcp_rtp_end_reset(struct mgcp_rtp_end *end)
{ {
if (end->local_alloc == PORT_ALLOC_DYNAMIC) if (end->local_alloc == PORT_ALLOC_DYNAMIC) {
mgcp_free_rtp_port(end); mgcp_free_rtp_port(end);
end->local_port = 0;
}
end->packets = 0; end->packets = 0;
memset(&end->addr, 0, sizeof(end->addr)); memset(&end->addr, 0, sizeof(end->addr));
end->rtp_port = end->rtcp_port = end->local_port = 0; end->rtp_port = end->rtcp_port = 0;
end->payload_type = -1; end->payload_type = -1;
end->local_alloc = -1; end->local_alloc = -1;
} }
@ -823,7 +838,8 @@ int mgcp_endpoints_allocate(struct mgcp_config *cfg)
cfg->endpoints[i].cfg = cfg; cfg->endpoints[i].cfg = cfg;
mgcp_rtp_end_init(&cfg->endpoints[i].net_end); mgcp_rtp_end_init(&cfg->endpoints[i].net_end);
mgcp_rtp_end_init(&cfg->endpoints[i].bts_end); mgcp_rtp_end_init(&cfg->endpoints[i].bts_end);
mgcp_rtp_end_init(&cfg->endpoints[i].transcoder_end); mgcp_rtp_end_init(&cfg->endpoints[i].trans_net);
mgcp_rtp_end_init(&cfg->endpoints[i].trans_bts);
} }
return 0; return 0;
@ -847,7 +863,9 @@ void mgcp_free_endp(struct mgcp_endpoint *endp)
mgcp_rtp_end_reset(&endp->bts_end); mgcp_rtp_end_reset(&endp->bts_end);
mgcp_rtp_end_reset(&endp->net_end); mgcp_rtp_end_reset(&endp->net_end);
mgcp_rtp_end_reset(&endp->transcoder_end); mgcp_rtp_end_reset(&endp->trans_net);
mgcp_rtp_end_reset(&endp->trans_bts);
endp->is_transcoded = 0;
memset(&endp->net_state, 0, sizeof(endp->net_state)); memset(&endp->net_state, 0, sizeof(endp->net_state));
memset(&endp->bts_state, 0, sizeof(endp->bts_state)); memset(&endp->bts_state, 0, sizeof(endp->bts_state));
@ -858,12 +876,6 @@ void mgcp_free_endp(struct mgcp_endpoint *endp)
memset(&endp->taps, 0, sizeof(endp->taps)); memset(&endp->taps, 0, sizeof(endp->taps));
} }
/* For transcoding we need to manage an in and an output that are connected */
static int back_channel(int endpoint)
{
return endpoint + 60;
}
static int send_trans(struct mgcp_config *cfg, const char *buf, int len) static int send_trans(struct mgcp_config *cfg, const char *buf, int len)
{ {
struct sockaddr_in addr; struct sockaddr_in addr;
@ -925,27 +937,31 @@ static void create_transcoder(struct mgcp_endpoint *endp)
{ {
int port; int port;
int in_endp = ENDPOINT_NUMBER(endp); int in_endp = ENDPOINT_NUMBER(endp);
int out_endp = back_channel(in_endp); int out_endp = endp_back_channel(in_endp);
if (!endp->cfg->transcoder_ip) if (!endp->is_transcoded)
return; return;
send_msg(endp, in_endp, endp->bts_end.local_port, "CRCX", "recvonly"); send_msg(endp, in_endp, endp->trans_bts.local_port, "CRCX", "sendrecv");
send_msg(endp, in_endp, endp->bts_end.local_port, "MDCX", "recvonly"); send_msg(endp, in_endp, endp->trans_bts.local_port, "MDCX", "sendrecv");
send_msg(endp, out_endp, endp->transcoder_end.local_port, "CRCX", "sendrecv"); send_msg(endp, out_endp, endp->trans_net.local_port, "CRCX", "sendrecv");
send_msg(endp, out_endp, endp->transcoder_end.local_port, "MDCX", "sendrecv"); send_msg(endp, out_endp, endp->trans_net.local_port, "MDCX", "sendrecv");
port = rtp_calculate_port(in_endp, endp->cfg->transcoder_remote_base);
endp->trans_bts.rtp_port = htons(port);
endp->trans_bts.rtcp_port = htons(port + 1);
port = rtp_calculate_port(out_endp, endp->cfg->transcoder_remote_base); port = rtp_calculate_port(out_endp, endp->cfg->transcoder_remote_base);
endp->transcoder_end.rtp_port = htons(port); endp->trans_net.rtp_port = htons(port);
endp->transcoder_end.rtcp_port = htons(port + 1); endp->trans_net.rtcp_port = htons(port + 1);
} }
static void delete_transcoder(struct mgcp_endpoint *endp) static void delete_transcoder(struct mgcp_endpoint *endp)
{ {
int in_endp = ENDPOINT_NUMBER(endp); int in_endp = ENDPOINT_NUMBER(endp);
int out_endp = back_channel(in_endp); int out_endp = endp_back_channel(in_endp);
if (!endp->cfg->transcoder_ip) if (!endp->is_transcoded)
return; return;
send_dlcx(endp, in_endp); send_dlcx(endp, in_endp);

33
openbsc/src/mgcp/mgcp_vty.c
View File

@ -99,14 +99,14 @@ DEFUN(show_mcgp, show_mgcp_cmd, "show mgcp",
vty_out(vty, "MGCP is up and running with %u endpoints:%s", g_cfg->number_endpoints - 1, VTY_NEWLINE); vty_out(vty, "MGCP is up and running with %u endpoints:%s", g_cfg->number_endpoints - 1, VTY_NEWLINE);
for (i = 1; i < g_cfg->number_endpoints; ++i) { for (i = 1; i < g_cfg->number_endpoints; ++i) {
struct mgcp_endpoint *endp = &g_cfg->endpoints[i]; struct mgcp_endpoint *endp = &g_cfg->endpoints[i];
vty_out(vty, " Endpoint 0x%.2x: CI: %d net: %u/%u bts: %u/%u on %s traffic received bts: %u/%u remote: %u/%u transcoder: %u%s", vty_out(vty, " Endpoint 0x%.2x: CI: %d net: %u/%u bts: %u/%u on %s traffic received bts: %u/%u remote: %u/%u transcoder: %u/%u%s",
i, endp->ci, i, endp->ci,
ntohs(endp->net_end.rtp_port), ntohs(endp->net_end.rtcp_port), ntohs(endp->net_end.rtp_port), ntohs(endp->net_end.rtcp_port),
ntohs(endp->bts_end.rtp_port), ntohs(endp->bts_end.rtcp_port), ntohs(endp->bts_end.rtp_port), ntohs(endp->bts_end.rtcp_port),
inet_ntoa(endp->bts_end.addr), inet_ntoa(endp->bts_end.addr),
endp->bts_end.packets, endp->bts_state.lost_no, endp->bts_end.packets, endp->bts_state.lost_no,
endp->net_end.packets, endp->net_state.lost_no, endp->net_end.packets, endp->net_state.lost_no,
endp->transcoder_end.packets, endp->trans_net.packets, endp->trans_bts.packets,
VTY_NEWLINE); VTY_NEWLINE);
} }
@ -319,6 +319,20 @@ DEFUN(cfg_mgcp_transcoder,
return CMD_SUCCESS; return CMD_SUCCESS;
} }
DEFUN(cfg_mgcp_no_transcoder,
cfg_mgcp_no_transcoder_cmd,
NO_STR "transcoder-mgw",
"Disable the transcoding\n")
{
if (g_cfg->transcoder_ip) {
LOGP(DMGCP, LOGL_NOTICE, "Disabling transcoding on future calls.\n");
talloc_free(g_cfg->transcoder_ip);
g_cfg->transcoder_ip = NULL;
}
return CMD_SUCCESS;
}
DEFUN(cfg_mgcp_transcoder_remote_base, DEFUN(cfg_mgcp_transcoder_remote_base,
cfg_mgcp_transcoder_remote_base_cmd, cfg_mgcp_transcoder_remote_base_cmd,
"transcoder-remote-base <0-65534>", "transcoder-remote-base <0-65534>",
@ -453,6 +467,7 @@ int mgcp_vty_init(void)
install_element(MGCP_NODE, &cfg_mgcp_number_endp_cmd); install_element(MGCP_NODE, &cfg_mgcp_number_endp_cmd);
install_element(MGCP_NODE, &cfg_mgcp_agent_addr_cmd); install_element(MGCP_NODE, &cfg_mgcp_agent_addr_cmd);
install_element(MGCP_NODE, &cfg_mgcp_transcoder_cmd); install_element(MGCP_NODE, &cfg_mgcp_transcoder_cmd);
install_element(MGCP_NODE, &cfg_mgcp_no_transcoder_cmd);
install_element(MGCP_NODE, &cfg_mgcp_transcoder_remote_base_cmd); install_element(MGCP_NODE, &cfg_mgcp_transcoder_remote_base_cmd);
return 0; return 0;
} }
@ -508,13 +523,23 @@ int mgcp_parse_config(const char *config_file, struct mgcp_config *cfg)
} }
if (g_cfg->transcoder_ip && g_cfg->transcoder_ports.mode == PORT_ALLOC_STATIC) { if (g_cfg->transcoder_ip && g_cfg->transcoder_ports.mode == PORT_ALLOC_STATIC) {
/* network side */
rtp_port = rtp_calculate_port(ENDPOINT_NUMBER(endp), rtp_port = rtp_calculate_port(ENDPOINT_NUMBER(endp),
g_cfg->transcoder_ports.base_port); g_cfg->transcoder_ports.base_port);
if (mgcp_bind_transcoder_rtp_port(endp, rtp_port) != 0) { if (mgcp_bind_trans_net_rtp_port(endp, rtp_port) != 0) {
LOGP(DMGCP, LOGL_FATAL, "Failed to bind: %d\n", rtp_port); LOGP(DMGCP, LOGL_FATAL, "Failed to bind: %d\n", rtp_port);
return -1; return -1;
} }
endp->transcoder_end.local_alloc = PORT_ALLOC_STATIC; endp->trans_net.local_alloc = PORT_ALLOC_STATIC;
/* bts side */
rtp_port = rtp_calculate_port(endp_back_channel(ENDPOINT_NUMBER(endp)),
g_cfg->transcoder_ports.base_port);
if (mgcp_bind_trans_bts_rtp_port(endp, rtp_port) != 0) {
LOGP(DMGCP, LOGL_FATAL, "Failed to bind: %d\n", rtp_port);
return -1;
}
endp->trans_bts.local_alloc = PORT_ALLOC_STATIC;
} }
} }