mirror of https://github.com/sipwise/rtpengine.git
Add a codec module for Codec 2, using libcodec2 for decoding and encoding. There is no RFC payload format for Codec 2, so this follows the convention Asterisk uses: encoding name "codec2" at 8000 Hz, mono, with one or more complete frames per RTP packet, each padded to whole bytes. The mode is selected with the format parameter "mode=" (3200, 2400, 1600, 1400, 1300, 1200 or 700C) and defaults to 2400, the only mode Asterisk supports. With the transcode option it can also be given as the bit rate, e.g. "codec2/8000/1/3200". Different modes are different bit streams, so payload types only match when they use the same mode. Modes 1600 and below use 40 ms frames, so their ptime is rounded up to a multiple of 40 ms. Modes not known to rtpengine (e.g. 450) are passed through unchanged when both sides agree, but can't be transcoded. libcodec2 is optional. It is detected with pkg-config (or from /usr/include/codec2) by utils/gen-codec2-flags. Without it, Codec 2 is still recognised for SDP handling and passthrough. In a Debian build the dependency can be dropped with the pkg.ngcp-rtpengine.nocodec2 build profile. test-transcode gains Codec 2 tests for both directions in modes 2400, 3200 and 1300, plus passthrough. check_encoder() is no longer limited to the extended AMR tests, as these use it too. Closes #2226 Change-Id: I2cad021f48e2043f36c30f5e6290cb7d6eba8c1f Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>pull/2206/head
parent
04f9031780
commit
9eb1cf9bd1
@ -0,0 +1,405 @@
|
||||
#include "codecmod.h"
|
||||
#include "loglib.h"
|
||||
|
||||
// Codec 2 (https://www.rowetel.com/?page_id=452) through libcodec2.
|
||||
//
|
||||
// There is no RFC payload format for Codec 2. This follows what Asterisk does: encoding
|
||||
// name "codec2" with an 8 kHz clock, and the payload of each RTP packet is one or more
|
||||
// complete Codec 2 frames back to back, each padded to whole bytes as produced by
|
||||
// libcodec2. The bit rate (Codec 2 "mode") is selected through the optional format
|
||||
// parameter "mode=" (3200, 2400, 1600, 1400, 1300, 1200 or 700C). Without it, mode 2400
|
||||
// is assumed, which is the only mode Asterisk supports.
|
||||
|
||||
#define CODEC2_DEFAULT_MODE 2400
|
||||
|
||||
|
||||
// modes are identified by their bit rate (700 for 700C); returns -1 if there is no such mode
|
||||
static int codec2_mode_from_int(int br) {
|
||||
switch (br) {
|
||||
case 3200:
|
||||
case 2400:
|
||||
case 1600:
|
||||
case 1400:
|
||||
case 1300:
|
||||
case 1200:
|
||||
case 700:
|
||||
return br;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
// returns the mode for a "mode=" value, or -1 if unknown
|
||||
static int codec2_mode_from_str(const str *s) {
|
||||
if (!str_cmp(s, "700C") || !str_cmp(s, "700c"))
|
||||
return 700;
|
||||
return codec2_mode_from_int(str_to_i(s, -1));
|
||||
}
|
||||
|
||||
static const char *codec2_mode_name(int mode) {
|
||||
switch (mode) {
|
||||
case 3200:
|
||||
return "3200";
|
||||
case 2400:
|
||||
return "2400";
|
||||
case 1600:
|
||||
return "1600";
|
||||
case 1400:
|
||||
return "1400";
|
||||
case 1300:
|
||||
return "1300";
|
||||
case 1200:
|
||||
return "1200";
|
||||
case 700:
|
||||
return "700C";
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static const char *codec2_mode_fmtp(int mode) {
|
||||
switch (mode) {
|
||||
case 3200:
|
||||
return "mode=3200";
|
||||
case 2400:
|
||||
return "mode=2400";
|
||||
case 1600:
|
||||
return "mode=1600";
|
||||
case 1400:
|
||||
return "mode=1400";
|
||||
case 1300:
|
||||
return "mode=1300";
|
||||
case 1200:
|
||||
return "mode=1200";
|
||||
case 700:
|
||||
return "mode=700C";
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void codec2_parse_format_cb(str *key, str *token, void *data) {
|
||||
union codec_format_options *opts = data;
|
||||
|
||||
if (str_cmp(key, "mode"))
|
||||
return;
|
||||
|
||||
int mode = codec2_mode_from_str(token);
|
||||
if (mode < 0) {
|
||||
ilog(LOG_WARN | LOG_FLAG_LIMIT, "Unsupported Codec 2 mode '" STR_FORMAT "'",
|
||||
STR_FMT(token));
|
||||
opts->codec2.mode = -1;
|
||||
return;
|
||||
}
|
||||
opts->codec2.mode = mode;
|
||||
}
|
||||
|
||||
static bool codec2_format_parse(struct rtp_codec_format *f, const str *fmtp) {
|
||||
codeclib_key_value_parse(fmtp, codec2_parse_format_cb, &f->parsed);
|
||||
return true;
|
||||
}
|
||||
|
||||
// absent "mode=" means the default mode
|
||||
static int codec2_effective_mode(const struct rtp_payload_type *p) {
|
||||
if (!p->format.fmtp_parsed)
|
||||
return CODEC2_DEFAULT_MODE;
|
||||
return p->format.parsed.codec2.mode ?: CODEC2_DEFAULT_MODE;
|
||||
}
|
||||
|
||||
static int codec2_format_cmp(const struct rtp_payload_type *A, const struct rtp_payload_type *B) {
|
||||
// different modes are different bit streams
|
||||
int a = codec2_effective_mode(A);
|
||||
int b = codec2_effective_mode(B);
|
||||
if (a < 0 || b < 0) {
|
||||
// a mode we don't know (e.g. 450): can still be passed through if both
|
||||
// sides use the very same format parameters
|
||||
if (a != b || str_cmp_str(&A->format_parameters, &B->format_parameters))
|
||||
return -1;
|
||||
return 0;
|
||||
}
|
||||
if (a != b)
|
||||
return -1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static GString *codec2_format_print(const struct rtp_payload_type *p) {
|
||||
if (!p->format.fmtp_parsed)
|
||||
return NULL;
|
||||
if (p->format.parsed.codec2.mode < 0)
|
||||
return NULL; // unknown mode: pass the original fmtp through
|
||||
|
||||
GString *s = g_string_new("");
|
||||
const char *fmtp = codec2_mode_fmtp(p->format.parsed.codec2.mode);
|
||||
if (fmtp)
|
||||
g_string_append(s, fmtp);
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
|
||||
static void codec2_init(struct rtp_payload_type *pt) {
|
||||
if (pt->clock_rate != 8000) {
|
||||
ilog(LOG_WARN, "Codec 2 is only supported with a clock rate of 8000 Hz");
|
||||
pt->clock_rate = 8000;
|
||||
}
|
||||
|
||||
// a bit rate given in the codec string (e.g. "codec2/8000/1/3200") selects the mode,
|
||||
// so that it's also signalled in the SDP
|
||||
if (pt->format.fmtp_parsed && !pt->format.parsed.codec2.mode && pt->bitrate
|
||||
&& pt->bitrate != CODEC2_DEFAULT_MODE)
|
||||
{
|
||||
int mode = codec2_mode_from_int(pt->bitrate);
|
||||
if (mode > 0) {
|
||||
pt->format.parsed.codec2.mode = mode;
|
||||
// also keep the plain fmtp string in line. A static string is fine here
|
||||
// because the caller copies it right after this
|
||||
if (!pt->format_parameters.len)
|
||||
pt->format_parameters = STR(codec2_mode_fmtp(mode));
|
||||
}
|
||||
else
|
||||
ilog(LOG_WARN, "Codec 2 has no mode for a bit rate of %i bit/s", pt->bitrate);
|
||||
}
|
||||
|
||||
int mode = codec2_effective_mode(pt);
|
||||
if (mode > 0)
|
||||
pt->bitrate = mode;
|
||||
|
||||
// modes 1600 and below use 40 ms frames
|
||||
if (mode > 0 && mode <= 1600 && pt->ptime > 0 && pt->ptime % 40) {
|
||||
int np = (pt->ptime + 39) / 40 * 40;
|
||||
ilog(LOG_DEBUG, "Codec 2 mode %s uses 40 ms frames, using ptime %i ms instead of %i ms",
|
||||
codec2_mode_name(mode), np, pt->ptime);
|
||||
pt->ptime = np;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#ifdef HAVE_CODEC2
|
||||
|
||||
#include "fix_frame_channel_layout.compat"
|
||||
|
||||
|
||||
static int codec2_lib_mode(int mode) {
|
||||
switch (mode) {
|
||||
case 3200:
|
||||
return CODEC2_MODE_3200;
|
||||
case 2400:
|
||||
return CODEC2_MODE_2400;
|
||||
case 1600:
|
||||
return CODEC2_MODE_1600;
|
||||
case 1400:
|
||||
return CODEC2_MODE_1400;
|
||||
case 1300:
|
||||
return CODEC2_MODE_1300;
|
||||
case 1200:
|
||||
return CODEC2_MODE_1200;
|
||||
case 700:
|
||||
return CODEC2_MODE_700C;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
// the mode comes from fmtp only, so that both sides agree on it
|
||||
static int codec2_select_mode(const union codec_format_options *fmtp) {
|
||||
if (fmtp && fmtp->codec2.mode)
|
||||
return fmtp->codec2.mode;
|
||||
return CODEC2_DEFAULT_MODE;
|
||||
}
|
||||
|
||||
|
||||
static void codec2_def_init(struct codec_def_s *def) {
|
||||
struct CODEC2 *c2 = codec2_create(CODEC2_MODE_2400);
|
||||
if (!c2)
|
||||
return;
|
||||
codec2_destroy(c2);
|
||||
def->support_encoding = 1;
|
||||
def->support_decoding = 1;
|
||||
}
|
||||
|
||||
|
||||
static const char *codec2_decoder_init(decoder_t *dec, const str *extra_opts) {
|
||||
if (dec->in_format.clockrate != 8000)
|
||||
return "Codec 2 requires a clock rate of 8000 Hz";
|
||||
if (dec->in_format.channels != 1)
|
||||
return "Codec 2 supports mono only";
|
||||
|
||||
int mode = codec2_select_mode(&dec->format_options);
|
||||
int lib_mode = codec2_lib_mode(mode);
|
||||
if (lib_mode < 0)
|
||||
return "unsupported Codec 2 mode";
|
||||
|
||||
dec->codec2 = codec2_create(lib_mode);
|
||||
if (!dec->codec2)
|
||||
return "failed to create Codec 2 decoder";
|
||||
|
||||
ilog(LOG_DEBUG, "Created Codec 2 decoder in mode %s (%i samples and %i bytes per frame)",
|
||||
codec2_mode_name(mode), codec2_samples_per_frame(dec->codec2),
|
||||
codec2_bytes_per_frame(dec->codec2));
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int codec2_decoder_input(decoder_t *dec, const str *data, frame_q *out, bool mark) {
|
||||
struct CODEC2 *c2 = dec->codec2;
|
||||
const int bytes_per_frame = codec2_bytes_per_frame(c2);
|
||||
const int samples_per_frame = codec2_samples_per_frame(c2);
|
||||
|
||||
size_t num_frames = data->len / bytes_per_frame;
|
||||
if (num_frames == 0 || data->len % bytes_per_frame) {
|
||||
ilog(LOG_WARN | LOG_FLAG_LIMIT, "Codec 2 payload of %zu bytes is not a multiple of the "
|
||||
"frame size (%i bytes)", data->len, bytes_per_frame);
|
||||
if (num_frames == 0)
|
||||
return -1;
|
||||
}
|
||||
|
||||
AVFrame *frame = av_frame_alloc();
|
||||
frame->nb_samples = num_frames * samples_per_frame;
|
||||
frame->format = AV_SAMPLE_FMT_S16;
|
||||
frame->sample_rate = dec->in_format.clockrate;
|
||||
DEF_CH_LAYOUT(&frame->CH_LAYOUT, 1);
|
||||
frame->pts = dec->pts;
|
||||
if (av_frame_get_buffer(frame, 0) < 0)
|
||||
abort();
|
||||
|
||||
const unsigned char *in = (const unsigned char *) data->s;
|
||||
short *pcm = (short *) frame->extended_data[0];
|
||||
for (size_t i = 0; i < num_frames; i++) {
|
||||
codec2_decode(c2, pcm, in);
|
||||
in += bytes_per_frame;
|
||||
pcm += samples_per_frame;
|
||||
}
|
||||
|
||||
t_queue_push_tail(out, frame);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void codec2_decoder_close(decoder_t *dec) {
|
||||
if (dec->codec2)
|
||||
codec2_destroy(dec->codec2);
|
||||
dec->codec2 = NULL;
|
||||
}
|
||||
|
||||
|
||||
static const char *codec2_encoder_init(encoder_t *enc, const str *extra_opts) {
|
||||
if (enc->requested_format.channels != 1)
|
||||
ilog(LOG_WARN, "Codec 2 supports mono only, ignoring %i requested channels",
|
||||
enc->requested_format.channels);
|
||||
|
||||
int mode = codec2_select_mode(&enc->format_options);
|
||||
int lib_mode = codec2_lib_mode(mode);
|
||||
if (lib_mode < 0)
|
||||
return "unsupported Codec 2 mode";
|
||||
|
||||
enc->codec2 = codec2_create(lib_mode);
|
||||
if (!enc->codec2)
|
||||
return "failed to create Codec 2 encoder";
|
||||
|
||||
if (enc->requested_format.clockrate != 8000)
|
||||
ilog(LOG_WARN, "Codec 2 requires a clock rate of 8000 Hz, ignoring requested %i Hz",
|
||||
enc->requested_format.clockrate);
|
||||
|
||||
enc->actual_format = enc->requested_format;
|
||||
enc->actual_format.format = AV_SAMPLE_FMT_S16;
|
||||
enc->actual_format.channels = 1;
|
||||
enc->actual_format.clockrate = 8000;
|
||||
enc->actual_format.time_base = 8000;
|
||||
|
||||
// put as many whole frames into each packet as fit the ptime, but at least one
|
||||
// (the 1600 and lower modes use 40 ms frames)
|
||||
int samples_per_frame = codec2_samples_per_frame(enc->codec2);
|
||||
int frame_ms = samples_per_frame * 1000 / enc->actual_format.clockrate;
|
||||
int frames = enc->ptime / frame_ms;
|
||||
if (frames < 1)
|
||||
frames = 1;
|
||||
if (frames * frame_ms != enc->ptime)
|
||||
ilog(LOG_INFO, "Codec 2 mode %s uses %i ms frames, sending %i ms per packet instead of "
|
||||
"ptime %i ms", codec2_mode_name(mode), frame_ms, frames * frame_ms, enc->ptime);
|
||||
|
||||
enc->samples_per_frame = frames * samples_per_frame;
|
||||
enc->samples_per_packet = enc->samples_per_frame;
|
||||
enc->bitrate = mode;
|
||||
|
||||
ilog(LOG_DEBUG, "Created Codec 2 encoder in mode %s (%i frames of %i bytes per packet)",
|
||||
codec2_mode_name(mode), frames, codec2_bytes_per_frame(enc->codec2));
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int codec2_encoder_input(encoder_t *enc, AVFrame **frame) {
|
||||
if (!*frame)
|
||||
return 0;
|
||||
|
||||
struct CODEC2 *c2 = enc->codec2;
|
||||
const int samples_per_frame = codec2_samples_per_frame(c2);
|
||||
const int bytes_per_frame = codec2_bytes_per_frame(c2);
|
||||
|
||||
if ((*frame)->nb_samples != enc->samples_per_frame) {
|
||||
ilog(LOG_ERR | LOG_FLAG_LIMIT, "Codec 2: input %i samples instead of %i",
|
||||
(*frame)->nb_samples, enc->samples_per_frame);
|
||||
return -1;
|
||||
}
|
||||
|
||||
int num_frames = (*frame)->nb_samples / samples_per_frame;
|
||||
av_new_packet(enc->avpkt, num_frames * bytes_per_frame);
|
||||
|
||||
short *pcm = (short *) (*frame)->extended_data[0];
|
||||
unsigned char *out = enc->avpkt->data;
|
||||
for (int i = 0; i < num_frames; i++) {
|
||||
codec2_encode(c2, out, pcm);
|
||||
pcm += samples_per_frame;
|
||||
out += bytes_per_frame;
|
||||
}
|
||||
|
||||
enc->avpkt->pts = (*frame)->pts;
|
||||
enc->avpkt->duration = (*frame)->nb_samples;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void codec2_encoder_close(encoder_t *enc) {
|
||||
if (enc->codec2)
|
||||
codec2_destroy(enc->codec2);
|
||||
enc->codec2 = NULL;
|
||||
}
|
||||
|
||||
|
||||
static const codec_type_t codec_type_codec2 = {
|
||||
.def_init = codec2_def_init,
|
||||
.decoder_init = codec2_decoder_init,
|
||||
.decoder_input = codec2_decoder_input,
|
||||
.decoder_close = codec2_decoder_close,
|
||||
.encoder_init = codec2_encoder_init,
|
||||
.encoder_input = codec2_encoder_input,
|
||||
.encoder_close = codec2_encoder_close,
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
static const codec_def_t codec2 = {
|
||||
.rtpname = "codec2",
|
||||
.avcodec_id = -1,
|
||||
.default_clockrate = 8000,
|
||||
.default_channels = 1,
|
||||
.default_bitrate = CODEC2_DEFAULT_MODE,
|
||||
.default_ptime = 20,
|
||||
.minimum_ptime = 20,
|
||||
.init = codec2_init,
|
||||
.format_parse = codec2_format_parse,
|
||||
.format_cmp = codec2_format_cmp,
|
||||
.format_print = codec2_format_print,
|
||||
.packetizer = &packetizer_passthrough,
|
||||
.bits_per_sample = 1, // at most 3200 bit/s at 8000 samples/s
|
||||
.media_type = MT_AUDIO,
|
||||
#ifdef HAVE_CODEC2
|
||||
.codec_type = &codec_type_codec2,
|
||||
#endif
|
||||
.dtx_methods = {
|
||||
[DTX_SILENCE] = &dtx_method_silence,
|
||||
[DTX_CN] = &dtx_method_cn,
|
||||
},
|
||||
.fixed_sizes = 1,
|
||||
};
|
||||
|
||||
|
||||
__attribute__((constructor))
|
||||
static void init(void) {
|
||||
codeclib_register_codec(&codec2);
|
||||
}
|
||||
@ -0,0 +1,13 @@
|
||||
#!/bin/bash
|
||||
|
||||
# Codec 2 support is optional: only enabled if libcodec2 is found
|
||||
|
||||
if pkg-config --exists codec2; then
|
||||
echo "CFLAGS_CODEC2 := -DHAVE_CODEC2"
|
||||
echo "CFLAGS_CODEC2 += $(pkg-config --cflags codec2)"
|
||||
echo "LDLIBS_CODEC2 := $(pkg-config --libs codec2)"
|
||||
elif [ -e /usr/include/codec2/codec2.h ]; then
|
||||
echo "CFLAGS_CODEC2 := -DHAVE_CODEC2"
|
||||
echo "CFLAGS_CODEC2 += -I/usr/include/codec2"
|
||||
echo "LDLIBS_CODEC2 := -lcodec2"
|
||||
fi
|
||||
Loading…
Reference in new issue