{ MNCC_STOP_DTMF_REQ, "MNCC_STOP_DTMF_REQ" },
{ MNCC_HOLD_REQ, "MNCC_HOLD_REQ " },
{ MNCC_RETRIEVE_REQ, "MNCC_RETRIEVE_REQ" },
+
{ MNCC_LCHAN_MODIFY, "MNCC_LCHAN_MODIFY" },
+
+ { MNCC_BRIDGE, "MNCC_BRIDGE" },
+ { MNCC_FRAME_RECV, "MNCC_FRAME_RECV" },
+ { MNCC_FRAME_DROP, "MNCC_FRAME_DROP" },
+ { MNCC_RTP_CREATE, "MNCC_RTP_CREATE" },
+ { MNCC_RTP_CONNECT, "MNCC_RTP_CONNECT" },
+ { MNCC_RTP_FREE, "MNCC_RTP_FREE" },
+
{ 0, NULL }
};
const char *mncc_name(int value)
{
int i = 0;
+ static char ukn[32];
while (mncc_names[i].name) {
if (mncc_names[i].msg_type == value)
return mncc_names[i].name;
i++;
}
- return "unknown";
+ SPRINT(ukn, "unknown(0x%x)", value);
+ return ukn;
}
static int mncc_send(struct lcr_gsm *lcr_gsm, int msg_type, void *data);
*/
Pgsm::Pgsm(int type, char *portname, struct port_settings *settings, struct interface *interface) : Port(type, portname, settings, interface)
{
+#ifdef WITH_GSMHR
+ signed short homing[160];
+ int i;
+#endif
+
p_g_tones = 0;
if (interface->is_tones == IS_YES)
p_g_tones = 1;
p_g_hr_encoder = NULL;
p_g_amr_decoder = NULL;
p_g_amr_encoder = NULL;
+ p_g_amr_cmr = 0;
+ p_g_amr_cmr_valid = 0;
#ifdef WITH_GSMFR
p_g_fr_decoder = gsm_fr_create();
p_g_fr_encoder = gsm_fr_create();
trigger_work(&p_g_delete);
}
#endif
+#ifdef WITH_GSMHR
+ p_g_hr_decoder = gsm_hr_create();
+ p_g_hr_encoder = gsm_hr_create();
+ if (!p_g_hr_encoder || !p_g_hr_decoder) {
+ PERROR("Failed to create GSM HR codec instance\n");
+ trigger_work(&p_g_delete);
+ }
+ /* Homing */
+ for (i = 0; i < 160; i++)
+ homing[i] = 0x0008;
+ gsm_hr_encode(p_g_hr_encoder, homing, NULL);
+#endif
+#ifdef WITH_GSMAMR
+ p_g_amr_decoder = gsm_amr_create();
+ p_g_amr_encoder = gsm_amr_create();
+ if (!p_g_amr_encoder || !p_g_amr_decoder) {
+ PERROR("Failed to create GSM AMR codec instance\n");
+ trigger_work(&p_g_delete);
+ }
+#endif
p_g_rxpos = 0;
p_g_tch_connected = 0;
p_g_media_type = 0;
if (p_g_fr_decoder)
gsm_fr_destroy(p_g_fr_decoder);
//#endif
+#ifdef WITH_GSMHR
+ if (p_g_hr_encoder)
+ gsm_hr_destroy(p_g_hr_encoder);
+ if (p_g_hr_decoder)
+ gsm_hr_destroy(p_g_hr_decoder);
+#endif
+#ifdef WITH_GSMAMR
+ /* close codec */
+ if (p_g_amr_encoder)
+ gsm_amr_destroy(p_g_amr_encoder);
+ if (p_g_amr_decoder)
+ gsm_amr_destroy(p_g_amr_decoder);
+#endif
}
{
struct gsm_data_frame *frame = (struct gsm_data_frame *)arg;
unsigned char data[160];
- int i;
+ int i, cmr;
if (!p_g_fr_decoder)
return;
switch (frame->msg_type) {
+ case ANALOG_8000HZ:
+ if (p_g_media_type != MEDIA_TYPE_ANALOG) {
+ PERROR("'Analog' frame, but current media type mismatches.\n");
+ return;
+ }
+ for (i = 0; i < 160; i++) {
+ data[i] = audio_s16_to_law[((int16_t *)frame->data)[i] & 0xffff];
+ }
+ break;
case GSM_TCHF_FRAME:
+ if (p_g_media_type != MEDIA_TYPE_GSM) {
+ PERROR("FR frame, but current media type mismatches.\n");
+ return;
+ }
+ if (!p_g_fr_decoder) {
+ PERROR("FR frame, but decoder not created.\n");
+ return;
+ }
if ((frame->data[0]>>4) != 0xd) {
PDEBUG(DEBUG_GSM, "received GSM frame with wrong magig 0x%x\n", frame->data[0]>>4);
goto bfi;
}
#endif
break;
+ case GSM_TCHH_FRAME:
+ if (p_g_media_type != MEDIA_TYPE_GSM_HR) {
+ PERROR("HR frame, but current media type mismatches.\n");
+ return;
+ }
+ if (!p_g_hr_decoder) {
+ PERROR("HR frame, but decoder not created.\n");
+ return;
+ }
+ if ((frame->data[0]>>4) != 0x0)
+ goto bfi;
+#ifdef WITH_GSMHR
+ /* decode */
+ if (gsm_hr_decode(p_g_hr_decoder, frame->data, p_g_samples))
+ goto bfi;
+ for (i = 0; i < 160; i++) {
+ data[i] = audio_s16_to_law[p_g_samples[i] & 0xffff];
+ }
+#endif
+ break;
+ case GSM_TCHF_FRAME_EFR:
+ if (p_g_media_type != MEDIA_TYPE_GSM_EFR) {
+ PERROR("EFR frame, but current media type mismatches.\n");
+ return;
+ }
+ if (!p_g_amr_decoder) {
+ PERROR("EFR frame, but decoder not created.\n");
+ return;
+ }
+ if ((frame->data[0]>>4) != 0xc)
+ goto bfi;
+#ifdef WITH_GSMAMR
+ /* decode */
+ gsm_efr_decode(p_g_amr_decoder, frame->data, p_g_samples);
+ for (i = 0; i < 160; i++) {
+ data[i] = audio_s16_to_law[p_g_samples[i] & 0xffff];
+ }
+#endif
+ break;
+ case GSM_TCH_FRAME_AMR:
+ if (p_g_media_type != MEDIA_TYPE_AMR) {
+ PERROR("AMR frame, but current media type mismatches.\n");
+ return;
+ }
+ if (!p_g_amr_decoder) {
+ PERROR("AMR frame, but decoder not created.\n");
+ return;
+ }
+ cmr = (frame->data[1] >> 4);
+ if (cmr <= 7) {
+ p_g_amr_cmr = cmr;
+ p_g_amr_cmr_valid = 1;
+ }
+ if (!(frame->data[2] & 0x04))
+ goto bfi;
+#ifdef WITH_GSMAMR
+ /* decode (skip length byte in front) */
+ gsm_amr_decode(p_g_amr_decoder, frame->data + 1, p_g_samples);
+ for (i = 0; i < 160; i++) {
+ data[i] = audio_s16_to_law[p_g_samples[i] & 0xffff];
+ }
+#endif
+ break;
case GSM_BAD_FRAME:
default:
bfi:
/* send traffic to gsm */
int Pgsm::bridge_rx(unsigned char *data, int len)
{
+ int ret;
+
+ if ((ret = Port::bridge_rx(data, len)))
+ return ret;
+
if (p_tone_name[0])
return -EINVAL;
int Pgsm::audio_send(unsigned char *data, int len)
{
unsigned char frame[33];
+ int ret;
/* record data */
if (p_record)
/* write to rx buffer */
while(len--) {
p_g_rxdata[p_g_rxpos++] = audio_law_to_s32[*data++];
- if (p_g_rxpos == 160) {
- p_g_rxpos = 0;
+ if (p_g_rxpos != 160)
+ continue;
+ p_g_rxpos = 0;
+ switch (p_g_media_type) {
+ case MEDIA_TYPE_ANALOG:
+ frame_send(p_g_rxdata, 320, ANALOG_8000HZ);
+ break;
+ case MEDIA_TYPE_GSM:
+ if (!p_g_fr_encoder) {
+ PERROR("FR frame, but encoder not created.\n");
+ break;
+ }
#ifdef WITH_GSMFR
/* encode data */
gsm_fr_encode(p_g_fr_encoder, p_g_rxdata, frame);
- frame_send(frame);
+ frame_send(frame, 33, GSM_TCHF_FRAME);
+#endif
+ break;
+ case MEDIA_TYPE_GSM_HR:
+ if (!p_g_hr_encoder) {
+ PERROR("HR frame, but encoder not created.\n");
+ break;
+ }
+#ifdef WITH_GSMHR
+ /* encode data */
+ gsm_hr_encode(p_g_hr_encoder, p_g_rxdata, frame);
+ frame_send(frame, 15, GSM_TCHH_FRAME);
+#endif
+ break;
+ case MEDIA_TYPE_GSM_EFR:
+ if (!p_g_amr_encoder) {
+ PERROR("EFR frame, but encoder not created.\n");
+ break;
+ }
+#ifdef WITH_GSMAMR
+ /* encode data */
+ gsm_efr_encode(p_g_amr_encoder, p_g_rxdata, frame);
+ frame_send(frame, 31, GSM_TCHF_FRAME_EFR);
+#endif
+ break;
+ case MEDIA_TYPE_AMR:
+ if (!p_g_amr_encoder) {
+ PERROR("AMR frame, but encoder not created.\n");
+ break;
+ }
+ if (!p_g_amr_cmr_valid) {
+ PDEBUG(DEBUG_GSM, "no valid CMR yet.\n");
+ break;
+ }
+#ifdef WITH_GSMAMR
+ /* encode data (prefix a length byte) */
+ ret = gsm_amr_encode(p_g_amr_encoder, p_g_rxdata, frame + 1, p_g_amr_cmr);
+ frame[0] = ret;
+ frame_send(frame, ret + 1, GSM_TCH_FRAME_AMR);
#endif
+ break;
}
}
return 0;
}
-void Pgsm::frame_send(void *_frame)
+void Pgsm::frame_send(void *_frame, int len, int msg_type)
{
- unsigned char buffer[sizeof(struct gsm_data_frame) + 33];
+ unsigned char buffer[sizeof(struct gsm_data_frame) + len];
struct gsm_data_frame *frame = (struct gsm_data_frame *)buffer;
- frame->msg_type = GSM_TCHF_FRAME;
+ frame->msg_type = msg_type;
frame->callref = p_g_callref;
- memcpy(frame->data, _frame, 33);
+ memcpy(frame->data, _frame, len);
if (p_g_lcr_gsm) {
mncc_send(p_g_lcr_gsm, frame->msg_type, frame);
{
struct gsm_mncc *mode;
- /* already modified to that payload type */
+ /* already modified to that media type */
if (p_g_media_type == media_type)
return;
send_and_free_mncc(p_g_lcr_gsm, frame->msg_type, frame);
p_g_tch_connected = 1;
}
+
+ /* modify to GSM FR (this is GSM user side only, so there is FR supported only) */
+ modify_lchan(MEDIA_TYPE_GSM);
}
/* ALERTING INDICATION */
send_and_free_mncc(p_g_lcr_gsm, frame->msg_type, frame);
p_g_tch_connected = 1;
}
+
+ /* modify to GSM FR, if not already */
+ if (!p_g_media_type) {
+ modify_lchan(MEDIA_TYPE_GSM);
+ }
}
/* CONNECT INDICATION */
message->param.connectinfo.rtpinfo.media_types[0] = p_g_media_type;
message->param.connectinfo.rtpinfo.payload_types[0] = p_g_payload_type;
message->param.connectinfo.rtpinfo.payloads = 1;
+ } else {
+ /* modify to GSM FR, if not already
+ * for network side, this should have been already happened */
+ if (!p_g_media_type)
+ modify_lchan(MEDIA_TYPE_GSM);
}
+
if (p_g_rtp_bridge) {
struct gsm_mncc_rtp *rtp;
send_and_free_mncc(p_g_lcr_gsm, frame->msg_type, frame);
p_g_tch_connected = 1;
}
+
+ /* modify to GSM FR, if not already */
+ if (!p_g_media_type) {
+ modify_lchan(MEDIA_TYPE_GSM);
+ }
}
/* DISCONNECT INDICATION */
send_and_free_mncc(p_g_lcr_gsm, mncc->msg_type, mncc);
p_g_tch_connected = 1;
}
+
+ /* modify to GSM FR, if not already */
+ if (!p_g_media_type) {
+ modify_lchan(MEDIA_TYPE_GSM);
+ }
}
/* MESSAGE_CONNECT */
/* FIXME: the caller should provide this */
switch (msg_type) {
+ case ANALOG_8000HZ:
+ len = sizeof(struct gsm_data_frame) + 320;
+ break;
case GSM_TCHF_FRAME:
len = sizeof(struct gsm_data_frame) + 33;
break;
/* free all the calls that were running through the MNCC interface */
port = port_first;
while(port) {
- if ((port->p_type & PORT_CLASS_mISDN_MASK) == PORT_CLASS_GSM) {
+ if ((port->p_type & PORT_CLASS_MASK) == PORT_CLASS_GSM) {
pgsm = (class Pgsm *)port;
if (pgsm->p_g_lcr_gsm == lcr_gsm) {
message = message_create(pgsm->p_serial, ACTIVE_EPOINT(pgsm->p_epointlist), PORT_TO_EPOINT, MESSAGE_RELEASE);
- message->param.disconnectinfo.cause = 27; // temp. unavail.
+ message->param.disconnectinfo.cause = 41; // temp. fail.
message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
message_put(message);
pgsm->new_state(PORT_STATE_RELEASE);
int rc;
static char buf[sizeof(struct gsm_mncc)+1024];
struct gsm_mncc *mncc_prim = (struct gsm_mncc *) buf;
+ struct gsm_mncc_hello *hello = (struct gsm_mncc_hello *) buf;
memset(buf, 0, sizeof(buf));
rc = recv(lfd->fd, buf, sizeof(buf), 0);
if (rc < 0)
return rc;
+ /* TODO: size check? */
+ switch (mncc_prim->msg_type) {
+ case MNCC_SOCKET_HELLO:
+ if (hello->version != MNCC_SOCK_VERSION) {
+ PERROR("MNCC version different. BSC version is %u\n", hello->version);
+ mncc_fd_close(lcr_gsm, lfd);
+ return 0;
+ }
+ if (hello->mncc_size != sizeof(struct gsm_mncc)) {
+ PERROR("MNCC gsm_mncc size differs: %u %u\n",
+ hello->mncc_size, sizeof(struct gsm_mncc));
+ mncc_fd_close(lcr_gsm, lfd);
+ return 0;
+ }
+ if (hello->data_frame_size != sizeof(struct gsm_data_frame)) {
+ PERROR("MNCC gsm_mncc size differs: %u %u\n",
+ hello->data_frame_size, sizeof(struct gsm_data_frame));
+ mncc_fd_close(lcr_gsm, lfd);
+ return 0;
+ }
+
+#define CHECK_OFFSET(hello, field, lcr_gsm, lfd) \
+ if (hello->field ##_offset != __builtin_offsetof(struct gsm_mncc, field)) { \
+ PERROR("MNCC gsm_mncc offset of %s is %u %u\n", \
+ #field, hello->field ##_offset, \
+ __builtin_offsetof(struct gsm_mncc, field)); \
+ mncc_fd_close(lcr_gsm, lfd); \
+ return 0; \
+ }
+
+ CHECK_OFFSET(hello, called, lcr_gsm, lfd);
+ CHECK_OFFSET(hello, signal, lcr_gsm, lfd);
+ CHECK_OFFSET(hello, emergency, lcr_gsm, lfd);
+ CHECK_OFFSET(hello, lchan_type, lcr_gsm, lfd);
+#undef CHECK_OFFSET
+
+ break;
+ }
+
/* Hand the MNCC message into LCR */
switch (lcr_gsm->type) {
#ifdef WITH_GSM_BS
projects / lcr.git / blobdiff