cellular-infrastructure
/
osmo-mgw
mirror of https://gerrit.osmocom.org/osmo-mgw
10
0
Fork 0
Code Issues Releases Wiki Activity
osmo-mgw/tests/legacy_mgcp/mgcp_transcoding_test.c

663 lines
20 KiB
C
Raw Blame History

#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <err.h>
#include <stdint.h>
#include <errno.h>
#include <osmocom/core/talloc.h>
#include <osmocom/core/application.h>
#include <osmocom/netif/rtp.h>
#include <osmocom/legacy_mgcp/mgcp.h>
#include <osmocom/legacy_mgcp/mgcp_internal.h>
#include "bscconfig.h"
#ifndef BUILD_MGCP_TRANSCODING
#error "Requires MGCP transcoding enabled (see --enable-mgcp-transcoding)"
#endif
#include <osmocom/legacy_mgcp/mgcp_transcode.h>
uint8_t *audio_frame_l16[] = {
};
struct rtp_packets {
float t;
int len;
char *data;
};
struct rtp_packets audio_packets_l16[] = {
/* RTP: SeqNo=1, TS=160 */
{0.020000, 332,
"\x80\x0B\x00\x01\x00\x00\x00\xA0\x11\x22\x33\x44"
"\x00\x00\x40\x13\x5A\x9E\x40\x13\x00\x00\xBF\xED\xA5\x62\xBF\xED"
"\x00\x00\x40\x13\x5A\x9E\x40\x13\x00\x00\xBF\xED\xA5\x62\xBF\xED"
"\x00\x00\x40\x13\x5A\x9E\x40\x13\x00\x00\xBF\xED\xA5\x62\xBF\xED"
"\x00\x00\x40\x13\x5A\x9E\x40\x13\x00\x00\xBF\xED\xA5\x62\xBF\xED"
"\x00\x00\x40\x13\x5A\x9E\x40\x13\x00\x00\xBF\xED\xA5\x62\xBF\xED"
"\x00\x00\x40\x13\x5A\x9E\x40\x13\x00\x00\xBF\xED\xA5\x62\xBF\xED"
"\x00\x00\x40\x13\x5A\x9E\x40\x13\x00\x00\xBF\xED\xA5\x62\xBF\xED"
"\x00\x00\x40\x13\x5A\x9E\x40\x13\x00\x00\xBF\xED\xA5\x62\xBF\xED"
"\x00\x00\x40\x13\x5A\x9E\x40\x13\x00\x00\xBF\xED\xA5\x62\xBF\xED"
"\x00\x00\x40\x13\x5A\x9E\x40\x13\x00\x00\xBF\xED\xA5\x62\xBF\xED"
"\x00\x00\x40\x13\x5A\x9E\x40\x13\x00\x00\xBF\xED\xA5\x62\xBF\xED"
"\x00\x00\x40\x13\x5A\x9E\x40\x13\x00\x00\xBF\xED\xA5\x62\xBF\xED"
"\x00\x00\x40\x13\x5A\x9E\x40\x13\x00\x00\xBF\xED\xA5\x62\xBF\xED"
"\x00\x00\x40\x13\x5A\x9E\x40\x13\x00\x00\xBF\xED\xA5\x62\xBF\xED"
"\x00\x00\x40\x13\x5A\x9E\x40\x13\x00\x00\xBF\xED\xA5\x62\xBF\xED"
"\x00\x00\x40\x13\x5A\x9E\x40\x13\x00\x00\xBF\xED\xA5\x62\xBF\xED"
"\x00\x00\x40\x13\x5A\x9E\x40\x13\x00\x00\xBF\xED\xA5\x62\xBF\xED"
"\x00\x00\x40\x13\x5A\x9E\x40\x13\x00\x00\xBF\xED\xA5\x62\xBF\xED"
"\x00\x00\x40\x13\x5A\x9E\x40\x13\x00\x00\xBF\xED\xA5\x62\xBF\xED"
"\x00\x00\x40\x13\x5A\x9E\x40\x13\x00\x00\xBF\xED\xA5\x62\xBF\xED"
},
};
struct rtp_packets audio_packets_gsm[] = {
/* RTP: SeqNo=1, TS=160 */
{0.020000, 45,
"\x80\x03\x00\x01\x00\x00\x00\xA0\x11\x22\x33\x44"
"\xD4\x7C\xE3\xE9\x62\x50\x39\xF0\xF8\xB4\x68\xEA\x6C\x0E\x81\x1B"
"\x56\x2A\xD5\xBC\x69\x9C\xD1\xF0\x66\x7A\xEC\x49\x7A\x33\x3D\x0A"
"\xDE"
},
};
struct rtp_packets audio_packets_gsm_invalid_size[] = {
/* RTP: SeqNo=1, TS=160 */
{0.020000, 41,
"\x80\x03\x00\x01\x00\x00\x00\xA0\x11\x22\x33\x44"
"\xD4\x7C\xE3\xE9\x62\x50\x39\xF0\xF8\xB4\x68\xEA\x6C\x0E\x81\x1B"
"\x56\x2A\xD5\xBC\x69\x9C\xD1\xF0\x66\x7A\xEC\x49\x7A\x33\x3D\x0A"
"\xDE"
},
};
struct rtp_packets audio_packets_gsm_invalid_data[] = {
/* RTP: SeqNo=1, TS=160 */
{0.020000, 45,
"\x80\x03\x00\x01\x00\x00\x00\xA0\x11\x22\x33\x44"
"\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE"
"\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE\xEE"
"\xEE"
},
};
struct rtp_packets audio_packets_gsm_invalid_ptype[] = {
/* RTP: SeqNo=1, TS=160 */
{0.020000, 45,
"\x80\x08\x00\x01\x00\x00\x00\xA0\x11\x22\x33\x44"
"\xD4\x7C\xE3\xE9\x62\x50\x39\xF0\xF8\xB4\x68\xEA\x6C\x0E\x81\x1B"
"\x56\x2A\xD5\xBC\x69\x9C\xD1\xF0\x66\x7A\xEC\x49\x7A\x33\x3D\x0A"
"\xDE"
},
};
struct rtp_packets audio_packets_g729[] = {
/* RTP: SeqNo=1, TS=160 */
{0.020000, 32,
"\x80\x12\x00\x01\x00\x00\x00\xA0\x11\x22\x33\x44"
"\xAF\xC2\x81\x40\x00\xFA\xCE\xA4\x21\x7C\xC5\xC3\x4F\xA5\x98\xF5"
"\xB2\x95\xC4\xAD"
},
};
struct rtp_packets audio_packets_pcma[] = {
/* RTP: SeqNo=1, TS=160 */
{0.020000, 172,
"\x80\x08\x00\x01\x00\x00\x00\xA0\x11\x22\x33\x44"
"\xD5\xA5\xA3\xA5\xD5\x25\x23\x25\xD5\xA5\xA3\xA5\xD5\x25\x23\x25"
"\xD5\xA5\xA3\xA5\xD5\x25\x23\x25\xD5\xA5\xA3\xA5\xD5\x25\x23\x25"
"\xD5\xA5\xA3\xA5\xD5\x25\x23\x25\xD5\xA5\xA3\xA5\xD5\x25\x23\x25"
"\xD5\xA5\xA3\xA5\xD5\x25\x23\x25\xD5\xA5\xA3\xA5\xD5\x25\x23\x25"
"\xD5\xA5\xA3\xA5\xD5\x25\x23\x25\xD5\xA5\xA3\xA5\xD5\x25\x23\x25"
"\xD5\xA5\xA3\xA5\xD5\x25\x23\x25\xD5\xA5\xA3\xA5\xD5\x25\x23\x25"
"\xD5\xA5\xA3\xA5\xD5\x25\x23\x25\xD5\xA5\xA3\xA5\xD5\x25\x23\x25"
"\xD5\xA5\xA3\xA5\xD5\x25\x23\x25\xD5\xA5\xA3\xA5\xD5\x25\x23\x25"
"\xD5\xA5\xA3\xA5\xD5\x25\x23\x25\xD5\xA5\xA3\xA5\xD5\x25\x23\x25"
"\xD5\xA5\xA3\xA5\xD5\x25\x23\x25\xD5\xA5\xA3\xA5\xD5\x25\x23\x25"
},
/* RTP: SeqNo=26527, TS=232640 */
{0.020000, 92,
"\x80\x08\x67\x9f\x00\x03\x8c\xc0\x04\xaa\x67\x9f\xd5\xd5\xd5\xd5"
"\xd5\xd5\xd5\xd5\xd5\xd5\xd5\xd5\xd5\xd5\xd5\xd5\xd5\xd5\xd5\xd5"
"\xd5\xd5\xd5\xd5\xd5\xd5\xd5\xd5\xd5\xd5\xd5\xd5\xd5\xd5\xd5\xd5"
"\xd5\xd5\xd5\xd5\xd5\xd5\xd5\xd5\xd5\xd5\xd5\xd5\xd5\xd5\xd5\xd5"
"\xd5\xd5\xd5\xd5\xd5\xd5\x55\x55\xd5\xd5\x55\x55\xd5\xd5\x55\x55"
"\xd5\xd5\xd5\x55\x55\xd5\xd5\xd5\x55\x55\xd5\xd5"
},
/* RTP: SeqNo=26528, TS=232720 */
{0.020000, 92,
"\x80\x08\x67\xa0\x00\x03\x8d\x10\x04\xaa\x67\x9f\x55\xd5\xd5\x55"
"\xd5\x55\xd5\xd5\xd5\x55\xd5\x55\xd5\xd5\x55\xd5\x55\xd5\x55\xd5"
"\x55\x55\xd5\x55\xd5\xd5\x55\x55\x55\x55\x55\xd5\xd5\x55\xd5\xd5"
"\xd5\x55\xd5\xd5\xd5\x55\x54\x55\xd5\xd5\x55\xd5\xd5\xd5\xd5\x55"
"\x54\x55\xd5\x55\xd5\x55\x55\x55\x55\x55\xd5\xd5\xd5\xd5\xd5\xd4"
"\xd5\x54\x55\xd5\xd4\xd5\x54\xd5\x55\xd5\xd5\xd5"
},
};
static int audio_name_to_type(const char *name)
{
if (!strcasecmp(name, "gsm"))
return 3;
#ifdef HAVE_BCG729
else if (!strcasecmp(name, "g729"))
return 18;
#endif
else if (!strcasecmp(name, "pcma"))
return 8;
else if (!strcasecmp(name, "l16"))
return 11;
return -1;
}
int mgcp_get_trans_frame_size(void *state_, int nsamples, int dst);
static int given_configured_endpoint(int in_samples, int out_samples,
const char *srcfmt, const char *dstfmt,
void **out_ctx, struct mgcp_endpoint **out_endp)
{
int rc;
struct mgcp_rtp_end *dst_end;
struct mgcp_rtp_end *src_end;
struct mgcp_config *cfg;
struct mgcp_trunk_config *tcfg;
struct mgcp_endpoint *endp;
cfg = mgcp_config_alloc();
tcfg = talloc_zero(cfg, struct mgcp_trunk_config);
endp = talloc_zero(tcfg, struct mgcp_endpoint);
cfg->setup_rtp_processing_cb = mgcp_transcoding_setup;
cfg->rtp_processing_cb = mgcp_transcoding_process_rtp;
cfg->get_net_downlink_format_cb = mgcp_transcoding_net_downlink_format;
tcfg->endpoints = endp;
tcfg->number_endpoints = 1;
tcfg->cfg = cfg;
endp->tcfg = tcfg;
endp->cfg = cfg;
mgcp_initialize_endp(endp);
dst_end = &endp->bts_end;
dst_end->codec.payload_type = audio_name_to_type(dstfmt);
src_end = &endp->net_end;
src_end->codec.payload_type = audio_name_to_type(srcfmt);
if (out_samples) {
dst_end->codec.frame_duration_den = dst_end->codec.rate;
dst_end->codec.frame_duration_num = out_samples;
dst_end->frames_per_packet = 1;
dst_end->force_output_ptime = 1;
}
rc = mgcp_transcoding_setup(endp, dst_end, src_end);
if (rc < 0) {
printf("setup failed: %s", strerror(-rc));
abort();
}
*out_ctx = cfg;
*out_endp = endp;
return 0;
}
static int transcode_test(const char *srcfmt, const char *dstfmt,
uint8_t *src_pkts, size_t src_pkt_size)
{
char buf[4096] = {0x80, 0};
void *ctx;
struct mgcp_rtp_end *dst_end;
struct mgcp_process_rtp_state *state;
struct mgcp_endpoint *endp;
int in_size;
const int in_samples = 160;
int len, cont;
printf("== Transcoding test ==\n");
printf("converting %s -> %s\n", srcfmt, dstfmt);
given_configured_endpoint(in_samples, 0, srcfmt, dstfmt, &ctx, &endp);
dst_end = &endp->bts_end;
state = dst_end->rtp_process_data;
OSMO_ASSERT(state != NULL);
in_size = mgcp_transcoding_get_frame_size(state, in_samples, 0);
OSMO_ASSERT(sizeof(buf) >= in_size + 12);
memcpy(buf, src_pkts, src_pkt_size);
len = src_pkt_size;
cont = mgcp_transcoding_process_rtp(endp, dst_end,
buf, &len, sizeof(buf));
if (cont < 0) {
printf("Nothing encoded due: %s\n", strerror(-cont));
talloc_free(ctx);
return -1;
}
if (len < 24) {
printf("encoded: %s\n", osmo_hexdump((unsigned char *)buf, len));
} else {
const char *str = osmo_hexdump((unsigned char *)buf, len);
int i = 0;
const int prefix = 4;
const int cutlen = 48;
int nchars = 0;
printf("encoded:\n");
do {
nchars = printf("%*s%-.*s", prefix, "", cutlen, str + i);
i += nchars - prefix;
printf("\n");
} while (nchars - prefix >= cutlen);
}
printf("counted: %d\n", cont);
talloc_free(ctx);
return 0;
}
static void test_rtp_seq_state(void)
{
char buf[4096];
int len;
int cont;
void *ctx;
struct mgcp_endpoint *endp;
struct mgcp_process_rtp_state *state;
struct rtp_hdr *hdr;
uint32_t ts_no;
uint16_t seq_no;
given_configured_endpoint(160, 0, "pcma", "l16", &ctx, &endp);
state = endp->bts_end.rtp_process_data;
OSMO_ASSERT(!state->is_running);
OSMO_ASSERT(state->next_seq == 0);
OSMO_ASSERT(state->next_time == 0);
/* initialize packet */
len = audio_packets_pcma[0].len;
memcpy(buf, audio_packets_pcma[0].data, len);
cont = mgcp_transcoding_process_rtp(endp, &endp->bts_end, buf, &len, len);
OSMO_ASSERT(cont >= 0);
OSMO_ASSERT(state->is_running);
OSMO_ASSERT(state->next_seq == 2);
OSMO_ASSERT(state->next_time == 240);
/* verify that the right timestamp was written */
OSMO_ASSERT(len == audio_packets_pcma[0].len);
hdr = (struct rtp_hdr *) &buf[0];
memcpy(&ts_no, &hdr->timestamp, sizeof(ts_no));
OSMO_ASSERT(htonl(ts_no) == 160);
memcpy(&seq_no, &hdr->sequence, sizeof(seq_no));
OSMO_ASSERT(htons(seq_no) == 1);
/* Check the right sequence number is written */
state->next_seq = 1234;
len = audio_packets_pcma[0].len;
memcpy(buf, audio_packets_pcma[0].data, len);
cont = mgcp_transcoding_process_rtp(endp, &endp->bts_end, buf, &len, len);
OSMO_ASSERT(cont >= 0);
OSMO_ASSERT(len == audio_packets_pcma[0].len);
hdr = (struct rtp_hdr *) &buf[0];
memcpy(&seq_no, &hdr->sequence, sizeof(seq_no));
OSMO_ASSERT(htons(seq_no) == 1234);
talloc_free(ctx);
}
static void test_transcode_result(void)
{
char buf[4096];
int len, res;
void *ctx;
struct mgcp_endpoint *endp;
struct mgcp_process_rtp_state *state;
{
/* from GSM to PCMA and same ptime */
given_configured_endpoint(160, 0, "gsm", "pcma", &ctx, &endp);
state = endp->bts_end.rtp_process_data;
/* result */
len = audio_packets_gsm[0].len;
memcpy(buf, audio_packets_gsm[0].data, len);
res = mgcp_transcoding_process_rtp(endp, &endp->bts_end, buf, &len, ARRAY_SIZE(buf));
OSMO_ASSERT(res == sizeof(struct rtp_hdr));
OSMO_ASSERT(state->sample_cnt == 0);
len = res;
res = mgcp_transcoding_process_rtp(endp, &endp->bts_end, buf, &len, ARRAY_SIZE(buf));
OSMO_ASSERT(res == -ENOMSG);
talloc_free(ctx);
}
{
/* from GSM to PCMA and same ptime */
given_configured_endpoint(160, 160, "gsm", "pcma", &ctx, &endp);
state = endp->bts_end.rtp_process_data;
/* result */
len = audio_packets_gsm[0].len;
memcpy(buf, audio_packets_gsm[0].data, len);
res = mgcp_transcoding_process_rtp(endp, &endp->bts_end, buf, &len, ARRAY_SIZE(buf));
OSMO_ASSERT(res == sizeof(struct rtp_hdr));
OSMO_ASSERT(state->sample_cnt == 0);
len = res;
res = mgcp_transcoding_process_rtp(endp, &endp->bts_end, buf, &len, ARRAY_SIZE(buf));
OSMO_ASSERT(res == -EAGAIN);
talloc_free(ctx);
}
{
/* from PCMA to GSM and wrong different ptime */
given_configured_endpoint(80, 160, "pcma", "gsm", &ctx, &endp);
state = endp->bts_end.rtp_process_data;
/* Add the first sample */
len = audio_packets_pcma[1].len;
memcpy(buf, audio_packets_pcma[1].data, len);
res = mgcp_transcoding_process_rtp(endp, &endp->bts_end, buf, &len, ARRAY_SIZE(buf));
OSMO_ASSERT(state->sample_cnt == 80);
OSMO_ASSERT(state->next_time == 232640);
OSMO_ASSERT(res < 0);
/* Add the second sample and it should be consumable */
len = audio_packets_pcma[2].len;
memcpy(buf, audio_packets_pcma[2].data, len);
res = mgcp_transcoding_process_rtp(endp, &endp->bts_end, buf, &len, ARRAY_SIZE(buf));
OSMO_ASSERT(state->sample_cnt == 0);
OSMO_ASSERT(state->next_time == 232640 + 80 + 160);
OSMO_ASSERT(res == sizeof(struct rtp_hdr));
talloc_free(ctx);
}
{
/* from PCMA to GSM with a big time jump */
struct rtp_hdr *hdr;
uint32_t ts;
given_configured_endpoint(80, 160, "pcma", "gsm", &ctx, &endp);
state = endp->bts_end.rtp_process_data;
/* Add the first sample */
len = audio_packets_pcma[1].len;
memcpy(buf, audio_packets_pcma[1].data, len);
res = mgcp_transcoding_process_rtp(endp, &endp->bts_end, buf, &len, ARRAY_SIZE(buf));
OSMO_ASSERT(state->sample_cnt == 80);
OSMO_ASSERT(state->next_time == 232640);
OSMO_ASSERT(state->next_seq == 26527);
OSMO_ASSERT(res < 0);
/* Add a skip to the packet to force a 'resync' */
len = audio_packets_pcma[2].len;
memcpy(buf, audio_packets_pcma[2].data, len);
hdr = (struct rtp_hdr *) &buf[0];
/* jump the time and add alignment error */
ts = ntohl(hdr->timestamp) + 123 * 80 + 2;
hdr->timestamp = htonl(ts);
res = mgcp_transcoding_process_rtp(endp, &endp->bts_end, buf, &len, ARRAY_SIZE(buf));
OSMO_ASSERT(res < 0);
OSMO_ASSERT(state->sample_cnt == 80);
OSMO_ASSERT(state->next_time == ts);
OSMO_ASSERT(state->next_seq == 26527);
/* TODO: this can create alignment errors */
/* Now attempt to consume 160 samples */
len = audio_packets_pcma[2].len;
memcpy(buf, audio_packets_pcma[2].data, len);
hdr = (struct rtp_hdr *) &buf[0];
ts += 80;
hdr->timestamp = htonl(ts);
res = mgcp_transcoding_process_rtp(endp, &endp->bts_end, buf, &len, ARRAY_SIZE(buf));
OSMO_ASSERT(res == 12);
OSMO_ASSERT(state->sample_cnt == 0);
OSMO_ASSERT(state->next_time == ts + 160);
OSMO_ASSERT(state->next_seq == 26528);
talloc_free(ctx);
}
}
static void test_transcode_change(void)
{
char buf[4096] = {0x80, 0};
void *ctx;
struct mgcp_endpoint *endp;
struct mgcp_process_rtp_state *state;
struct rtp_hdr *hdr;
int len, res;
{
/* from GSM to PCMA and same ptime */
printf("Testing Initial L16->GSM, PCMA->GSM\n");
given_configured_endpoint(160, 0, "l16", "gsm", &ctx, &endp);
endp->net_end.alt_codec = endp->net_end.codec;
endp->net_end.alt_codec.payload_type = audio_name_to_type("pcma");
state = endp->bts_end.rtp_process_data;
/* initial transcoding work */
OSMO_ASSERT(state->src_fmt == AF_L16);
OSMO_ASSERT(state->dst_fmt == AF_GSM);
OSMO_ASSERT(endp->net_end.alt_codec.payload_type == 8);
OSMO_ASSERT(endp->net_end.codec.payload_type == 11);
/* result */
len = audio_packets_pcma[0].len;
memcpy(buf, audio_packets_pcma[0].data, len);
res = mgcp_transcoding_process_rtp(endp, &endp->bts_end, buf, &len, ARRAY_SIZE(buf));
state = endp->bts_end.rtp_process_data;
OSMO_ASSERT(res == sizeof(struct rtp_hdr));
OSMO_ASSERT(state->sample_cnt == 0);
OSMO_ASSERT(state->src_fmt == AF_PCMA);
OSMO_ASSERT(state->dst_fmt == AF_GSM);
OSMO_ASSERT(endp->net_end.alt_codec.payload_type == 11);
OSMO_ASSERT(endp->net_end.codec.payload_type == 8);
len = res;
res = mgcp_transcoding_process_rtp(endp, &endp->bts_end, buf, &len, ARRAY_SIZE(buf));
OSMO_ASSERT(res == -ENOMSG);
OSMO_ASSERT(state == endp->bts_end.rtp_process_data);
/* now check that comfort noise doesn't change anything */
len = audio_packets_pcma[1].len;
memcpy(buf, audio_packets_pcma[1].data, len);
hdr = (struct rtp_hdr *) buf;
hdr->payload_type = 12;
res = mgcp_transcoding_process_rtp(endp, &endp->bts_end, buf, &len, ARRAY_SIZE(buf));
OSMO_ASSERT(state == endp->bts_end.rtp_process_data);
OSMO_ASSERT(state->sample_cnt == 80);
OSMO_ASSERT(state->src_fmt == AF_PCMA);
OSMO_ASSERT(state->dst_fmt == AF_GSM);
OSMO_ASSERT(endp->net_end.alt_codec.payload_type == 11);
OSMO_ASSERT(endp->net_end.codec.payload_type == 8);
talloc_free(ctx);
}
}
static int test_repacking(int in_samples, int out_samples, int no_transcode)
{
char buf[4096] = {0x80, 0};
int cc;
struct mgcp_endpoint *endp;
void *ctx;
struct mgcp_process_rtp_state *state;
int in_cnt;
int out_size;
int in_size;
uint32_t ts = 0;
uint16_t seq = 0;
const char *srcfmt = "pcma";
const char *dstfmt = no_transcode ? "pcma" : "l16";
printf("== Transcoding test ==\n");
printf("converting %s -> %s\n", srcfmt, dstfmt);
given_configured_endpoint(in_samples, out_samples, srcfmt, dstfmt, &ctx, &endp);
state = endp->bts_end.rtp_process_data;
OSMO_ASSERT(state != NULL);
in_size = mgcp_transcoding_get_frame_size(state, in_samples, 0);
OSMO_ASSERT(sizeof(buf) >= in_size + 12);
out_size = mgcp_transcoding_get_frame_size(state, -1, 1);
OSMO_ASSERT(sizeof(buf) >= out_size + 12);
buf[1] = endp->net_end.codec.payload_type;
*(uint16_t*)(buf+2) = htons(1);
*(uint32_t*)(buf+4) = htonl(0);
*(uint32_t*)(buf+8) = htonl(0xaabbccdd);
for (in_cnt = 0; in_cnt < 16; in_cnt++) {
int cont;
int len;
/* fake PCMA data */
printf("generating %d %s input samples\n", in_samples, srcfmt);
for (cc = 0; cc < in_samples; cc++)
buf[12+cc] = cc;
*(uint16_t*)(buf+2) = htonl(seq);
*(uint32_t*)(buf+4) = htonl(ts);
seq += 1;
ts += in_samples;
cc += 12; /* include RTP header */
len = cc;
do {
cont = mgcp_transcoding_process_rtp(endp, &endp->bts_end,
buf, &len, sizeof(buf));
if (cont == -EAGAIN) {
fprintf(stderr, "Got EAGAIN\n");
break;
}
if (cont < 0) {
printf("processing failed: %s", strerror(-cont));
abort();
}
len -= 12; /* ignore RTP header */
printf("got %d %s output frames (%d octets) count=%d\n",
len / out_size, dstfmt, len, cont);
len = cont;
} while (len > 0);
}
talloc_free(ctx);
return 0;
}
static const struct log_info_cat log_categories[] = {
};
const struct log_info log_info = {
.cat = log_categories,
.num_cat = ARRAY_SIZE(log_categories),
};
int main(int argc, char **argv)
{
int rc;
void *ctx = talloc_named_const(NULL, 0, "mgcp_transcoding_test");
osmo_init_logging2(ctx, &log_info);
printf("=== Transcoding Good Cases ===\n");
transcode_test("l16", "l16",
(uint8_t *)audio_packets_l16[0].data,
audio_packets_l16[0].len);
transcode_test("l16", "gsm",
(uint8_t *)audio_packets_l16[0].data,
audio_packets_l16[0].len);
transcode_test("l16", "pcma",
(uint8_t *)audio_packets_l16[0].data,
audio_packets_l16[0].len);
transcode_test("gsm", "l16",
(uint8_t *)audio_packets_gsm[0].data,
audio_packets_gsm[0].len);
transcode_test("gsm", "gsm",
(uint8_t *)audio_packets_gsm[0].data,
audio_packets_gsm[0].len);
transcode_test("gsm", "pcma",
(uint8_t *)audio_packets_gsm[0].data,
audio_packets_gsm[0].len);
transcode_test("pcma", "l16",
(uint8_t *)audio_packets_pcma[0].data,
audio_packets_pcma[0].len);
transcode_test("pcma", "gsm",
(uint8_t *)audio_packets_pcma[0].data,
audio_packets_pcma[0].len);
transcode_test("pcma", "pcma",
(uint8_t *)audio_packets_pcma[0].data,
audio_packets_pcma[0].len);
printf("=== Transcoding Bad Cases ===\n");
printf("Invalid size:\n");
rc = transcode_test("gsm", "pcma",
(uint8_t *)audio_packets_gsm_invalid_size[0].data,
audio_packets_gsm_invalid_size[0].len);
OSMO_ASSERT(rc < 0);
printf("Invalid data:\n");
rc = transcode_test("gsm", "pcma",
(uint8_t *)audio_packets_gsm_invalid_data[0].data,
audio_packets_gsm_invalid_data[0].len);
OSMO_ASSERT(rc < 0);
printf("Invalid payload type:\n");
rc = transcode_test("gsm", "pcma",
(uint8_t *)audio_packets_gsm_invalid_ptype[0].data,
audio_packets_gsm_invalid_ptype[0].len);
OSMO_ASSERT(rc == 0);
printf("=== Repacking ===\n");
test_repacking(160, 160, 0);
test_repacking(160, 160, 1);
test_repacking(160, 80, 0);
test_repacking(160, 80, 1);
test_repacking(160, 320, 0);
test_repacking(160, 320, 1);
test_repacking(160, 240, 0);
test_repacking(160, 240, 1);
test_repacking(160, 100, 0);
test_repacking(160, 100, 1);
test_rtp_seq_state();
test_transcode_result();
test_transcode_change();
return 0;
}
View Git Blame Copy Permalink