You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
268 lines
6.3 KiB
268 lines
6.3 KiB
#include "codeclib.h"
|
|
#include <libavcodec/avcodec.h>
|
|
#include <libavformat/avformat.h>
|
|
#include <libavfilter/avfilter.h>
|
|
#include <glib.h>
|
|
#include "str.h"
|
|
#include "log.h"
|
|
#include "resample.h"
|
|
|
|
|
|
|
|
|
|
#ifndef dbg
|
|
#ifdef __DEBUG
|
|
#define dbg(x...) ilog(LOG_DEBUG, x)
|
|
#else
|
|
#define dbg(x...) ((void)0)
|
|
#endif
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#define CODEC_DEF_MULT_NAME(ref, id, mult, name) { \
|
|
.rtpname = #ref, \
|
|
.avcodec_id = AV_CODEC_ID_ ## id, \
|
|
.clockrate_mult = mult, \
|
|
.avcodec_name = #name, \
|
|
}
|
|
#define CODEC_DEF_MULT(ref, id, mult) CODEC_DEF_MULT_NAME(ref, id, mult, NULL)
|
|
#define CODEC_DEF_NAME(ref, id, name) CODEC_DEF_MULT_NAME(ref, id, 1, name)
|
|
#define CODEC_DEF(ref, id) CODEC_DEF_MULT(ref, id, 1)
|
|
|
|
static const struct codec_def_s codecs[] = {
|
|
CODEC_DEF(PCMA, PCM_ALAW),
|
|
CODEC_DEF(PCMU, PCM_MULAW),
|
|
CODEC_DEF(G723, G723_1),
|
|
CODEC_DEF_MULT(G722, ADPCM_G722, 2),
|
|
CODEC_DEF(QCELP, QCELP),
|
|
CODEC_DEF(G729, G729),
|
|
CODEC_DEF(speex, SPEEX),
|
|
CODEC_DEF(GSM, GSM),
|
|
CODEC_DEF(iLBC, ILBC),
|
|
CODEC_DEF_NAME(opus, OPUS, libopus),
|
|
CODEC_DEF_NAME(vorbis, VORBIS, libvorbis),
|
|
CODEC_DEF(ac3, AC3),
|
|
CODEC_DEF(eac3, EAC3),
|
|
CODEC_DEF(ATRAC3, ATRAC3),
|
|
CODEC_DEF(ATRAC-X, ATRAC3P),
|
|
#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(57, 0, 0)
|
|
CODEC_DEF(EVRC, EVRC),
|
|
CODEC_DEF(EVRC0, EVRC),
|
|
CODEC_DEF(EVRC1, EVRC),
|
|
#endif
|
|
CODEC_DEF(AMR, AMR_NB),
|
|
CODEC_DEF(AMR-WB, AMR_WB),
|
|
};
|
|
|
|
|
|
|
|
// XXX use hashtable for quicker lookup
|
|
const codec_def_t *codec_find(const str *name) {
|
|
for (int i = 0; i < G_N_ELEMENTS(codecs); i++) {
|
|
if (!str_cmp(name, codecs[i].rtpname))
|
|
return &codecs[i];
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
|
|
decoder_t *decoder_new_fmt(const codec_def_t *def, int clockrate, int channels, int resample) {
|
|
const char *err = NULL;
|
|
|
|
clockrate *= def->clockrate_mult;
|
|
|
|
decoder_t *ret = g_slice_alloc0(sizeof(*ret));
|
|
|
|
format_init(&ret->in_format);
|
|
ret->in_format.channels = channels;
|
|
ret->in_format.clockrate = clockrate;
|
|
// output defaults to same as input
|
|
ret->out_format = ret->in_format;
|
|
if (resample)
|
|
ret->out_format.clockrate = resample;
|
|
// sample format to be determined later when decoded frames arrive
|
|
|
|
AVCodec *codec = NULL;
|
|
if (def->avcodec_name)
|
|
codec = avcodec_find_decoder_by_name(def->avcodec_name);
|
|
if (!codec)
|
|
codec = avcodec_find_decoder(def->avcodec_id);
|
|
if (!codec) {
|
|
ilog(LOG_WARN, "Codec '%s' not supported", def->rtpname);
|
|
goto err;
|
|
}
|
|
|
|
ret->avcctx = avcodec_alloc_context3(codec);
|
|
err = "failed to alloc codec context";
|
|
if (!ret->avcctx)
|
|
goto err;
|
|
ret->avcctx->channels = channels;
|
|
ret->avcctx->sample_rate = clockrate;
|
|
err = "failed to open codec context";
|
|
int i = avcodec_open2(ret->avcctx, codec, NULL);
|
|
if (i)
|
|
goto err;
|
|
|
|
for (const enum AVSampleFormat *sfmt = codec->sample_fmts; sfmt && *sfmt != -1; sfmt++)
|
|
dbg("supported sample format for input codec %s: %s",
|
|
codec->name, av_get_sample_fmt_name(*sfmt));
|
|
|
|
av_init_packet(&ret->avpkt);
|
|
|
|
ret->pts = (uint64_t) -1LL;
|
|
ret->rtp_ts = (unsigned long) -1L;
|
|
ret->mixer_idx = (unsigned int) -1;
|
|
|
|
return ret;
|
|
|
|
err:
|
|
decoder_close(ret);
|
|
if (err)
|
|
ilog(LOG_ERR, "Error creating media decoder: %s", err);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void decoder_close(decoder_t *dec) {
|
|
if (!dec)
|
|
return;
|
|
/// XXX drain inputs and outputs
|
|
#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(56, 1, 0)
|
|
avcodec_free_context(&dec->avcctx);
|
|
#else
|
|
avcodec_close(dec->avcctx);
|
|
av_free(dec->avcctx);
|
|
#endif
|
|
resample_shutdown(&dec->mix_resample);
|
|
resample_shutdown(&dec->output_resample);
|
|
g_slice_free1(sizeof(*dec), dec);
|
|
}
|
|
|
|
int decoder_input_data(decoder_t *dec, const str *data, unsigned long ts,
|
|
int (*callback)(decoder_t *, AVFrame *, void *u1, void *u2), void *u1, void *u2)
|
|
{
|
|
const char *err;
|
|
|
|
if (G_UNLIKELY(!dec))
|
|
return -1;
|
|
|
|
dbg("%p dec pts %llu rtp_ts %llu incoming ts %lu", dec, (unsigned long long) dec->pts,
|
|
(unsigned long long) dec->rtp_ts, (unsigned long) ts);
|
|
|
|
if (G_UNLIKELY(dec->rtp_ts == (unsigned long) -1L)) {
|
|
// initialize pts
|
|
dec->pts = 0;
|
|
}
|
|
else {
|
|
// shift pts according to rtp ts shift
|
|
dec->pts += (ts - dec->rtp_ts);
|
|
// XXX handle lost packets here if timestamps don't line up?
|
|
}
|
|
dec->rtp_ts = ts;
|
|
|
|
dec->avpkt.data = (unsigned char *) data->s;
|
|
dec->avpkt.size = data->len;
|
|
dec->avpkt.pts = dec->pts;
|
|
|
|
AVFrame *frame = NULL;
|
|
|
|
// loop until all input is consumed and all available output has been processed
|
|
int keep_going;
|
|
do {
|
|
keep_going = 0;
|
|
int got_frame = 0;
|
|
err = "failed to alloc av frame";
|
|
frame = av_frame_alloc();
|
|
if (!frame)
|
|
goto err;
|
|
|
|
#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(57, 36, 0)
|
|
if (dec->avpkt.size) {
|
|
int ret = avcodec_send_packet(dec->avcctx, &dec->avpkt);
|
|
dbg("send packet ret %i", ret);
|
|
err = "failed to send packet to avcodec";
|
|
if (ret == 0) {
|
|
// consumed the packet
|
|
dec->avpkt.size = 0;
|
|
keep_going = 1;
|
|
}
|
|
else {
|
|
if (ret == AVERROR(EAGAIN))
|
|
; // try again after reading output
|
|
else
|
|
goto err;
|
|
}
|
|
}
|
|
|
|
int ret = avcodec_receive_frame(dec->avcctx, frame);
|
|
dbg("receive frame ret %i", ret);
|
|
err = "failed to receive frame from avcodec";
|
|
if (ret == 0) {
|
|
// got a frame
|
|
keep_going = 1;
|
|
got_frame = 1;
|
|
}
|
|
else {
|
|
if (ret == AVERROR(EAGAIN))
|
|
; // maybe needs more input now
|
|
else
|
|
goto err;
|
|
}
|
|
#else
|
|
// only do this if we have any input left
|
|
if (dec->avpkt.size == 0)
|
|
break;
|
|
|
|
int ret = avcodec_decode_audio4(dec->avcctx, frame, &got_frame, &dec->avpkt);
|
|
dbg("decode frame ret %i, got frame %i", ret, got_frame);
|
|
err = "failed to decode audio packet";
|
|
if (ret < 0)
|
|
goto err;
|
|
if (ret > 0) {
|
|
// consumed some input
|
|
err = "invalid return value";
|
|
if (ret > dec->avpkt.size)
|
|
goto err;
|
|
dec->avpkt.size -= ret;
|
|
dec->avpkt.data += ret;
|
|
keep_going = 1;
|
|
}
|
|
if (got_frame)
|
|
keep_going = 1;
|
|
#endif
|
|
|
|
if (got_frame) {
|
|
dbg("raw frame from decoder pts %llu samples %u", (unsigned long long) frame->pts, frame->nb_samples);
|
|
|
|
#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(57, 36, 0)
|
|
frame->pts = frame->pkt_pts;
|
|
#endif
|
|
if (G_UNLIKELY(frame->pts == AV_NOPTS_VALUE))
|
|
frame->pts = dec->avpkt.pts;
|
|
dec->avpkt.pts += frame->nb_samples;
|
|
|
|
if (callback(dec, frame, u1, u2))
|
|
return -1;
|
|
frame = NULL;
|
|
}
|
|
} while (keep_going);
|
|
|
|
av_frame_free(&frame);
|
|
return 0;
|
|
|
|
err:
|
|
ilog(LOG_ERR, "Error decoding media packet: %s", err);
|
|
av_frame_free(&frame);
|
|
return -1;
|
|
}
|
|
|
|
|
|
void codeclib_init() {
|
|
av_register_all();
|
|
avcodec_register_all();
|
|
avfilter_register_all();
|
|
avformat_network_init();
|
|
}
|