static int config_output(AVFilterLink *outlink)
{
int ret;
AVFilterContext *ctx = outlink->src;
AVFilterLink *inlink = ctx->inputs[0];
AConvertContext *aconvert = ctx->priv;
char buf1[64], buf2[64];
/* if not specified in args, use the format and layout of the output */
if (aconvert->out_sample_fmt == AV_SAMPLE_FMT_NONE)
aconvert->out_sample_fmt = outlink->format;
if (aconvert->out_chlayout == 0)
aconvert->out_chlayout = outlink->channel_layout;
aconvert->swr = swr_alloc_set_opts(aconvert->swr,
aconvert->out_chlayout, aconvert->out_sample_fmt, inlink->sample_rate,
inlink->channel_layout, inlink->format, inlink->sample_rate,
0, ctx);
if (!aconvert->swr)
return AVERROR(ENOMEM);
ret = swr_init(aconvert->swr);
if (ret < 0)
return ret;
av_get_channel_layout_string(buf1, sizeof(buf1),
-1, inlink ->channel_layout);
av_get_channel_layout_string(buf2, sizeof(buf2),
-1, outlink->channel_layout);
av_log(ctx, AV_LOG_VERBOSE,
"fmt:%s cl:%s -> fmt:%s cl:%s\n",
av_get_sample_fmt_name(inlink ->format), buf1,
av_get_sample_fmt_name(outlink->format), buf2);
return 0;
}
static int config_output(AVFilterLink *outlink)
{
AVFilterContext *ctx = outlink->src;
AVFilterLink *inlink = ctx->inputs[0];
ResampleContext *s = ctx->priv;
char buf1[64], buf2[64];
int ret;
if (s->avr) {
avresample_close(s->avr);
avresample_free(&s->avr);
}
if (inlink->channel_layout == outlink->channel_layout &&
inlink->sample_rate == outlink->sample_rate &&
(inlink->format == outlink->format ||
(av_get_channel_layout_nb_channels(inlink->channel_layout) == 1 &&
av_get_channel_layout_nb_channels(outlink->channel_layout) == 1 &&
av_get_planar_sample_fmt(inlink->format) ==
av_get_planar_sample_fmt(outlink->format))))
return 0;
if (!(s->avr = avresample_alloc_context()))
return AVERROR(ENOMEM);
if (s->options) {
AVDictionaryEntry *e = NULL;
while ((e = av_dict_get(s->options, "", e, AV_DICT_IGNORE_SUFFIX)))
av_log(ctx, AV_LOG_VERBOSE, "lavr option: %s=%s\n", e->key, e->value);
av_opt_set_dict(s->avr, &s->options);
}
av_opt_set_int(s->avr, "in_channel_layout", inlink ->channel_layout, 0);
av_opt_set_int(s->avr, "out_channel_layout", outlink->channel_layout, 0);
av_opt_set_int(s->avr, "in_sample_fmt", inlink ->format, 0);
av_opt_set_int(s->avr, "out_sample_fmt", outlink->format, 0);
av_opt_set_int(s->avr, "in_sample_rate", inlink ->sample_rate, 0);
av_opt_set_int(s->avr, "out_sample_rate", outlink->sample_rate, 0);
if ((ret = avresample_open(s->avr)) < 0)
return ret;
outlink->time_base = (AVRational){ 1, outlink->sample_rate };
s->next_pts = AV_NOPTS_VALUE;
s->next_in_pts = AV_NOPTS_VALUE;
av_get_channel_layout_string(buf1, sizeof(buf1),
-1, inlink ->channel_layout);
av_get_channel_layout_string(buf2, sizeof(buf2),
-1, outlink->channel_layout);
av_log(ctx, AV_LOG_VERBOSE,
"fmt:%s srate:%d cl:%s -> fmt:%s srate:%d cl:%s\n",
av_get_sample_fmt_name(inlink ->format), inlink ->sample_rate, buf1,
av_get_sample_fmt_name(outlink->format), outlink->sample_rate, buf2);
return 0;
}
static int config_output(AVFilterLink *outlink)
{
AVFilterLink *inlink = outlink->src->inputs[0];
AConvertContext *aconvert = outlink->src->priv;
char buf1[64], buf2[64];
aconvert->in_sample_fmt = inlink->format;
aconvert->in_packing_fmt = inlink->planar;
if (aconvert->out_packing_fmt == -1)
aconvert->out_packing_fmt = outlink->planar;
aconvert->in_chlayout = inlink->channel_layout;
aconvert->in_nb_channels =
av_get_channel_layout_nb_channels(inlink->channel_layout);
/* if not specified in args, use the format and layout of the output */
if (aconvert->out_sample_fmt == AV_SAMPLE_FMT_NONE)
aconvert->out_sample_fmt = outlink->format;
if (aconvert->out_chlayout == 0)
aconvert->out_chlayout = outlink->channel_layout;
aconvert->out_nb_channels =
av_get_channel_layout_nb_channels(outlink->channel_layout);
av_get_channel_layout_string(buf1, sizeof(buf1),
-1, inlink ->channel_layout);
av_get_channel_layout_string(buf2, sizeof(buf2),
-1, outlink->channel_layout);
av_log(outlink->src, AV_LOG_INFO,
"fmt:%s cl:%s planar:%i -> fmt:%s cl:%s planar:%i\n",
av_get_sample_fmt_name(inlink ->format), buf1, inlink ->planar,
av_get_sample_fmt_name(outlink->format), buf2, outlink->planar);
/* compute which channel layout conversion to use */
if (inlink->channel_layout != outlink->channel_layout) {
int i;
for (i = 0; i < sizeof(rematrix_funcs); i++) {
const struct RematrixFunctionInfo *f = &rematrix_funcs[i];
if ((f->in_chlayout == 0 || f->in_chlayout == inlink ->channel_layout) &&
(f->out_chlayout == 0 || f->out_chlayout == outlink->channel_layout) &&
(f->planar == -1 || f->planar == inlink->planar) &&
(f->sfmt == -1 || f->sfmt == inlink->format)
) {
aconvert->convert_chlayout = f->func;
break;
}
}
if (!aconvert->convert_chlayout) {
av_log(outlink->src, AV_LOG_ERROR,
"Unsupported channel layout conversion '%s -> %s' requested!\n",
buf1, buf2);
return AVERROR(EINVAL);
}
}
return 0;
}
static int config_output(AVFilterLink *outlink)
{
AVFilterContext *ctx = outlink->src;
AVFilterLink *inlink = ctx->inputs[0];
ResampleContext *s = ctx->priv;
char buf1[64], buf2[64];
int ret;
if (s->avr) {
avresample_close(s->avr);
avresample_free(&s->avr);
}
if (inlink->channel_layout == outlink->channel_layout &&
inlink->sample_rate == outlink->sample_rate &&
inlink->format == outlink->format)
return 0;
if (!(s->avr = avresample_alloc_context()))
return AVERROR(ENOMEM);
av_opt_set_int(s->avr, "in_channel_layout", inlink ->channel_layout, 0);
av_opt_set_int(s->avr, "out_channel_layout", outlink->channel_layout, 0);
av_opt_set_int(s->avr, "in_sample_fmt", inlink ->format, 0);
av_opt_set_int(s->avr, "out_sample_fmt", outlink->format, 0);
av_opt_set_int(s->avr, "in_sample_rate", inlink ->sample_rate, 0);
av_opt_set_int(s->avr, "out_sample_rate", outlink->sample_rate, 0);
/* if both the input and output formats are s16 or u8, use s16 as
the internal sample format */
if (av_get_bytes_per_sample(inlink->format) <= 2 &&
av_get_bytes_per_sample(outlink->format) <= 2)
av_opt_set_int(s->avr, "internal_sample_fmt", AV_SAMPLE_FMT_S16P, 0);
if ((ret = avresample_open(s->avr)) < 0)
return ret;
outlink->time_base = (AVRational){ 1, outlink->sample_rate };
s->next_pts = AV_NOPTS_VALUE;
av_get_channel_layout_string(buf1, sizeof(buf1),
-1, inlink ->channel_layout);
av_get_channel_layout_string(buf2, sizeof(buf2),
-1, outlink->channel_layout);
av_log(ctx, AV_LOG_VERBOSE,
"fmt:%s srate: %d cl:%s -> fmt:%s srate: %d cl:%s\n",
av_get_sample_fmt_name(inlink ->format), inlink ->sample_rate, buf1,
av_get_sample_fmt_name(outlink->format), outlink->sample_rate, buf2);
return 0;
}
static inline void log_input_change(void *ctx, AVFilterLink *link, AVFilterBufferRef *ref)
{
char old_layout_str[16], new_layout_str[16];
av_get_channel_layout_string(old_layout_str, sizeof(old_layout_str),
-1, link->channel_layout);
av_get_channel_layout_string(new_layout_str, sizeof(new_layout_str),
-1, ref->audio->channel_layout);
av_log(ctx, AV_LOG_INFO,
"Audio input format changed: "
"%s:%s:%d -> %s:%s:%d, normalizing\n",
av_get_sample_fmt_name(link->format),
old_layout_str, (int)link->sample_rate,
av_get_sample_fmt_name(ref->format),
new_layout_str, ref->audio->sample_rate);
}
static int init_encoder(AVCodec *enc, AVCodecContext **enc_ctx,
int64_t ch_layout, int sample_rate)
{
AVCodecContext *ctx;
int result;
char name_buff[NAME_BUFF_SIZE];
av_get_channel_layout_string(name_buff, NAME_BUFF_SIZE, 0, ch_layout);
av_log(NULL, AV_LOG_INFO, "channel layout: %s, sample rate: %i\n", name_buff, sample_rate);
ctx = avcodec_alloc_context3(enc);
if (!ctx) {
av_log(NULL, AV_LOG_ERROR, "Can't allocate encoder context\n");
return AVERROR(ENOMEM);
}
ctx->sample_fmt = AV_SAMPLE_FMT_S16;
ctx->sample_rate = sample_rate;
ctx->channel_layout = ch_layout;
result = avcodec_open2(ctx, enc, NULL);
if (result < 0) {
av_log(ctx, AV_LOG_ERROR, "Can't open encoder\n");
return result;
}
*enc_ctx = ctx;
return 0;
}
QDebug operator<<(QDebug dbg, QtAV::AudioFormat::ChannelLayout channelLayout)
{
char cl[128];
av_get_channel_layout_string(cl, sizeof(cl), -1, AudioFormat::channelLayoutToFFmpeg(channelLayout)); //TODO: ff version
dbg.nospace() << cl;
return dbg.space();
}
static int print_link_prop(AVBPrint *buf, AVFilterLink *link)
{
char *format;
char layout[64];
if (!buf)
buf = &(AVBPrint){ 0 }; /* dummy buffer */
switch (link->type) {
case AVMEDIA_TYPE_VIDEO:
format = av_x_if_null(av_get_pix_fmt_name(link->format), "?");
av_bprintf(buf, "[%dx%d %d:%d %s]", link->w, link->h,
link->sample_aspect_ratio.num,
link->sample_aspect_ratio.den,
format);
break;
case AVMEDIA_TYPE_AUDIO:
av_get_channel_layout_string(layout, sizeof(layout),
-1, link->channel_layout);
format = av_x_if_null(av_get_sample_fmt_name(link->format), "?");
av_bprintf(buf, "[%dHz %s:%s:%s]",
(int)link->sample_rate, format, layout,
link->planar ? "planar" : "packed");
break;
default:
av_bprintf(buf, "?");
break;
}
return buf->len;
}
static htsmsg_t *
tvh_codec_audio_get_list_channel_layouts(TVHAudioCodec *self)
{
htsmsg_t *list = NULL, *map = NULL;
const uint64_t *channel_layouts = self->channel_layouts;
uint64_t l = 0;
char l_buf[16];
int i;
if (channel_layouts && (list = htsmsg_create_list())) {
if (!(map = htsmsg_create_map())) {
htsmsg_destroy(list);
list = NULL;
}
else {
ADD_ENTRY(list, map, s64, l, str, AUTO_STR);
for (i = 0; (l = channel_layouts[i]); i++) {
if (l < INT64_MAX) {
if (!(map = htsmsg_create_map())) {
htsmsg_destroy(list);
list = NULL;
break;
}
l_buf[0] = '\0';
av_get_channel_layout_string(l_buf, sizeof(l_buf), 0, l);
ADD_ENTRY(list, map, s64, l, str, l_buf);
}
}
}
}
return list;
}
static void log_audio_fmt(const struct GrooveAudioFormat *fmt) {
char buf[128];
av_get_channel_layout_string(buf, sizeof(buf), 0, fmt->channel_layout);
av_log(NULL, AV_LOG_INFO, "encoder: using audio format: %s, %d Hz, %s\n",
av_get_sample_fmt_name((enum AVSampleFormat)fmt->sample_fmt),
fmt->sample_rate, buf);
}
static int clean_layout(void *s, int64_t layout){
if(layout && layout != AV_CH_FRONT_CENTER && !(layout&(layout-1))) {
char buf[128];
av_get_channel_layout_string(buf, sizeof(buf), -1, layout);
av_log(s, AV_LOG_VERBOSE, "Treating %s as mono\n", buf);
return AV_CH_FRONT_CENTER;
}
return layout;
}
void
metadata_from_libav(char *dst, size_t dstlen,
const AVCodec *codec, const AVCodecContext *avctx)
{
char *n;
int off = snprintf(dst, dstlen, "%s", codec->name);
n = dst;
while(*n) {
*n = toupper((int)*n);
n++;
}
if(codec->id == AV_CODEC_ID_H264) {
const char *p;
switch(avctx->profile) {
case FF_PROFILE_H264_BASELINE: p = "Baseline"; break;
case FF_PROFILE_H264_MAIN: p = "Main"; break;
case FF_PROFILE_H264_EXTENDED: p = "Extended"; break;
case FF_PROFILE_H264_HIGH: p = "High"; break;
case FF_PROFILE_H264_HIGH_10: p = "High 10"; break;
case FF_PROFILE_H264_HIGH_422: p = "High 422"; break;
case FF_PROFILE_H264_HIGH_444: p = "High 444"; break;
case FF_PROFILE_H264_CAVLC_444: p = "CAVLC 444"; break;
default: p = NULL; break;
}
if(p != NULL && avctx->level != FF_LEVEL_UNKNOWN)
off += snprintf(dst + off, dstlen - off,
", %s (Level %d.%d)",
p, avctx->level / 10, avctx->level % 10);
}
if(avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
char buf[64];
av_get_channel_layout_string(buf, sizeof(buf), avctx->channels,
avctx->channel_layout);
off += snprintf(dst + off, dstlen - off, ", %d Hz, %s",
avctx->sample_rate, buf);
}
if(avctx->width)
off += snprintf(dst + off, dstlen - off,
", %dx%d", avctx->width, avctx->height);
if(avctx->codec_type == AVMEDIA_TYPE_AUDIO && avctx->bit_rate)
off += snprintf(dst + off, dstlen - off,
", %d kb/s", avctx->bit_rate / 1000);
if(avctx->hwaccel != NULL)
off += snprintf(dst + off, dstlen - off, " (%s)",
avctx->hwaccel->name);
}
static void print_digraph(FILE *outfile, AVFilterGraph *graph)
{
int i, j;
fprintf(outfile, "digraph G {\n");
fprintf(outfile, "node [shape=box]\n");
fprintf(outfile, "rankdir=LR\n");
for (i = 0; i < graph->nb_filters; i++) {
char filter_ctx_label[128];
const AVFilterContext *filter_ctx = graph->filters[i];
snprintf(filter_ctx_label, sizeof(filter_ctx_label), "%s\\n(%s)",
filter_ctx->name,
filter_ctx->filter->name);
for (j = 0; j < filter_ctx->nb_outputs; j++) {
AVFilterLink *link = filter_ctx->outputs[j];
if (link) {
char dst_filter_ctx_label[128];
const AVFilterContext *dst_filter_ctx = link->dst;
snprintf(dst_filter_ctx_label, sizeof(dst_filter_ctx_label),
"%s\\n(%s)",
dst_filter_ctx->name,
dst_filter_ctx->filter->name);
fprintf(outfile, "\"%s\" -> \"%s\" [ label= \"inpad:%s -> outpad:%s\\n",
filter_ctx_label, dst_filter_ctx_label,
avfilter_pad_get_name(link->srcpad, 0),
avfilter_pad_get_name(link->dstpad, 0));
if (link->type == AVMEDIA_TYPE_VIDEO) {
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(link->format);
fprintf(outfile,
"fmt:%s w:%d h:%d tb:%d/%d",
desc->name,
link->w, link->h,
link->time_base.num, link->time_base.den);
} else if (link->type == AVMEDIA_TYPE_AUDIO) {
char buf[255];
av_get_channel_layout_string(buf, sizeof(buf), -1,
link->channel_layout);
fprintf(outfile,
"fmt:%s sr:%d cl:%s tb:%d/%d",
av_get_sample_fmt_name(link->format),
link->sample_rate, buf,
link->time_base.num, link->time_base.den);
}
fprintf(outfile, "\" ];\n");
}
}
}
fprintf(outfile, "}\n");
}
wchar_t * __stdcall MakeMediaInfoString(MediaInfo* info, wchar_t *buffer)
{
buffer[0] = 0;
if (info->m_bVideoStream)
{
StringCchPrintf(buffer + wcslen(buffer), 128, L"Video:%dx%d; ", info->m_Width, info->m_Height);
}
else
{
StringCchCat(buffer + wcslen(buffer), 128, L"Video:None; ");
};
if (info->m_bAudioStream)
{
StringCchCat(buffer + wcslen(buffer), 128, L"Audio:");
switch (info->m_SampleRate)
{
case 8000:
StringCchCat(buffer + wcslen(buffer), 128, L"Phone Quality,");
break;
case 22050:
StringCchCat(buffer + wcslen(buffer), 128, L"Low Quality,");
break;
case 44100:
StringCchCat(buffer + wcslen(buffer), 128, L"CD Quality,");
break;
case 48000:
StringCchCat(buffer + wcslen(buffer), 128, L"DVD Quality,");
break;
default:
StringCchPrintf(buffer + wcslen(buffer), 128, L"%dHz,", info->m_SampleRate);
break;
};
char buf[1024] = {};
av_get_channel_layout_string(buf, 1024, info->m_nChannel, info->m_channel_layout);
StringCchPrintf(buffer + wcslen(buffer), 128, L"%hs", buf);
}
else
{
StringCchCat(buffer + wcslen(buffer), 128, L"Audio:None");
};
{
int32_t t = (int32_t)(info->m_Duration / AV_TIME_BASE_LL);
int32_t h = t / 3600;
t %= 3600;
int32_t m = t / 60;
int32_t s = t % 60;
StringCchPrintf(buffer + wcslen(buffer), 128, L"; Duration:%d:%02d:%02d", h, m ,s);
}
return buffer;
};
string AudioSamples::channelsLayoutString() const
{
if (!m_raw)
return "";
char buf[128] = {0};
av_get_channel_layout_string(buf,
sizeof(buf),
av::frame::get_channels(m_raw),
av::frame::get_channel_layout(m_raw));
return string(buf);
}
int main(void)
{
const int64_t *cl;
char buf[512];
for (cl = avfilter_all_channel_layouts; *cl != -1; cl++) {
av_get_channel_layout_string(buf, sizeof(buf), -1, *cl);
printf("%s\n", buf);
}
return 0;
}
static int config_output(AVFilterLink *outlink)
{
AVFilterContext *ctx = outlink->src;
MixContext *s = ctx->priv;
int i;
char buf[64];
s->planar = av_sample_fmt_is_planar(outlink->format);
s->sample_rate = outlink->sample_rate;
#ifdef IDE_COMPILE
outlink->time_base.num = 1;
outlink->time_base.den = outlink->sample_rate;
#else
outlink->time_base = (AVRational){ 1, outlink->sample_rate };
#endif
s->next_pts = AV_NOPTS_VALUE;
s->frame_list = av_mallocz(sizeof(*s->frame_list));
if (!s->frame_list)
return AVERROR(ENOMEM);
s->fifos = av_mallocz(s->nb_inputs * sizeof(*s->fifos));
if (!s->fifos)
return AVERROR(ENOMEM);
s->nb_channels = av_get_channel_layout_nb_channels(outlink->channel_layout);
for (i = 0; i < s->nb_inputs; i++) {
s->fifos[i] = av_audio_fifo_alloc(outlink->format, s->nb_channels, 1024);
if (!s->fifos[i])
return AVERROR(ENOMEM);
}
s->input_state = av_malloc(s->nb_inputs);
if (!s->input_state)
return AVERROR(ENOMEM);
memset(s->input_state, INPUT_ON, s->nb_inputs);
s->active_inputs = s->nb_inputs;
s->input_scale = av_mallocz_array(s->nb_inputs, sizeof(*s->input_scale));
if (!s->input_scale)
return AVERROR(ENOMEM);
s->scale_norm = s->active_inputs;
calculate_scales(s, 0);
av_get_channel_layout_string(buf, sizeof(buf), -1, outlink->channel_layout);
av_log(ctx, AV_LOG_VERBOSE,
"inputs:%d fmt:%s srate:%d cl:%s\n", s->nb_inputs,
av_get_sample_fmt_name(outlink->format), outlink->sample_rate, buf);
return 0;
}
static int clean_layout(SwrContext *s, int64_t layout){
if((layout & AV_CH_LAYOUT_STEREO_DOWNMIX) == AV_CH_LAYOUT_STEREO_DOWNMIX)
return AV_CH_LAYOUT_STEREO;
if(layout && layout != AV_CH_FRONT_CENTER && !(layout&(layout-1))) {
char buf[128];
av_get_channel_layout_string(buf, sizeof(buf), -1, layout);
av_log(s, AV_LOG_VERBOSE, "Treating %s as mono\n", buf);
return AV_CH_FRONT_CENTER;
}
return layout;
}
avtranscoder::AudioProperties audioStreamInfo( const AVFormatContext* formatContext, const size_t index )
{
AudioProperties ap;
AVCodecContext* codec_context = formatContext->streams[index]->codec;
ap.codecId = codec_context->codec_id;
ap.sampleRate = codec_context->sample_rate;
ap.channels = codec_context->channels;
ap.bit_rate = codec_context->bit_rate;
ap.streamId = index;
AVCodec* codec = avcodec_find_decoder( codec_context->codec_id );
if( codec != NULL )
{
ap.codecName = codec->name;
ap.codecLongName = codec->long_name;
}
char buf1[1024];
av_get_channel_layout_string( buf1, sizeof( buf1 ), -1, codec_context->channel_layout );
ap.channelLayout = std::string( buf1 );
const char* channelName = av_get_channel_name( codec_context->channel_layout );
if( channelName )
ap.channelName = std::string( channelName );
#ifdef FF_RESAMPLE_LIBRARY
const char* channelDescription = av_get_channel_description( codec_context->channel_layout );
if( channelDescription )
ap.channelDescription = std::string( channelDescription );
#endif
std::string sampleFormat = "";
switch( codec_context->sample_fmt )
{
case AV_SAMPLE_FMT_NONE : ap.sampleFormat = "none"; break;
case AV_SAMPLE_FMT_U8 : ap.sampleFormat = "unsigned 8 bits"; break;
case AV_SAMPLE_FMT_S16 : ap.sampleFormat = "signed 16 bits"; break;
case AV_SAMPLE_FMT_S32 : ap.sampleFormat = "signed 32 bits"; break;
case AV_SAMPLE_FMT_FLT : ap.sampleFormat = "float"; break;
case AV_SAMPLE_FMT_DBL : ap.sampleFormat = "double"; break;
case AV_SAMPLE_FMT_U8P : ap.sampleFormat = "unsigned 8 bits, planar"; break;
case AV_SAMPLE_FMT_S16P : ap.sampleFormat = "signed 16 bits, planar"; break;
case AV_SAMPLE_FMT_S32P : ap.sampleFormat = "signed 32 bits, planar"; break;
case AV_SAMPLE_FMT_FLTP : ap.sampleFormat = "float, planar"; break;
case AV_SAMPLE_FMT_DBLP : ap.sampleFormat = "double, planar"; break;
case AV_SAMPLE_FMT_NB : ap.sampleFormat = "Number of sample formats."; break;
}
return ap;
}
void FFmpeg_Decoder::getInfo(int *samplerate, ChannelConfig *chans, SampleType *type)
{
if(!mStream)
fail("No audio stream info");
if((*mStream)->codec->sample_fmt == AV_SAMPLE_FMT_U8)
*type = SampleType_UInt8;
else if((*mStream)->codec->sample_fmt == AV_SAMPLE_FMT_S16)
*type = SampleType_Int16;
else if((*mStream)->codec->sample_fmt == AV_SAMPLE_FMT_FLT)
*type = SampleType_Float32;
else
fail(std::string("Unsupported sample format: ")+
av_get_sample_fmt_name((*mStream)->codec->sample_fmt));
if((*mStream)->codec->channel_layout == AV_CH_LAYOUT_MONO)
*chans = ChannelConfig_Mono;
else if((*mStream)->codec->channel_layout == AV_CH_LAYOUT_STEREO)
*chans = ChannelConfig_Stereo;
else if((*mStream)->codec->channel_layout == AV_CH_LAYOUT_QUAD)
*chans = ChannelConfig_Quad;
else if((*mStream)->codec->channel_layout == AV_CH_LAYOUT_5POINT1)
*chans = ChannelConfig_5point1;
else if((*mStream)->codec->channel_layout == AV_CH_LAYOUT_7POINT1)
*chans = ChannelConfig_7point1;
else if((*mStream)->codec->channel_layout == 0)
{
/* Unknown channel layout. Try to guess. */
if((*mStream)->codec->channels == 1)
*chans = ChannelConfig_Mono;
else if((*mStream)->codec->channels == 2)
*chans = ChannelConfig_Stereo;
else
{
std::stringstream sstr("Unsupported raw channel count: ");
sstr << (*mStream)->codec->channels;
fail(sstr.str());
}
}
else
{
char str[1024];
av_get_channel_layout_string(str, sizeof(str), (*mStream)->codec->channels,
(*mStream)->codec->channel_layout);
fail(std::string("Unsupported channel layout: ")+str);
}
*samplerate = (*mStream)->codec->sample_rate;
}
static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
{
AVFilterContext *ctx = inlink->dst;
AShowInfoContext *s = ctx->priv;
char chlayout_str[128];
uint32_t checksum = 0;
int channels = av_get_channel_layout_nb_channels(buf->channel_layout);
int planar = av_sample_fmt_is_planar(buf->format);
int block_align = av_get_bytes_per_sample(buf->format) * (planar ? 1 : channels);
int data_size = buf->nb_samples * block_align;
int planes = planar ? channels : 1;
int i;
void *tmp_ptr = av_realloc(s->plane_checksums, channels * sizeof(*s->plane_checksums));
if (!tmp_ptr)
return AVERROR(ENOMEM);
s->plane_checksums = tmp_ptr;
for (i = 0; i < planes; i++) {
uint8_t *data = buf->extended_data[i];
s->plane_checksums[i] = av_adler32_update(0, data, data_size);
checksum = i ? av_adler32_update(checksum, data, data_size) :
s->plane_checksums[0];
}
av_get_channel_layout_string(chlayout_str, sizeof(chlayout_str), -1,
buf->channel_layout);
av_log(ctx, AV_LOG_INFO,
"n:%"PRId64" pts:%s pts_time:%s pos:%"PRId64" "
"fmt:%s channels:%d chlayout:%s rate:%d nb_samples:%d "
"checksum:%08X ",
inlink->frame_count,
av_ts2str(buf->pts), av_ts2timestr(buf->pts, &inlink->time_base),
av_frame_get_pkt_pos(buf),
av_get_sample_fmt_name(buf->format), av_frame_get_channels(buf), chlayout_str,
buf->sample_rate, buf->nb_samples,
checksum);
av_log(ctx, AV_LOG_INFO, "plane_checksums: [ ");
for (i = 0; i < planes; i++)
av_log(ctx, AV_LOG_INFO, "%08X ", s->plane_checksums[i]);
av_log(ctx, AV_LOG_INFO, "]\n");
return ff_filter_frame(inlink->dst->outputs[0], buf);
}
static int config_props(AVFilterLink *outlink)
{
ANullContext *priv = outlink->src->priv;
char buf[128];
int chans_nb;
outlink->sample_rate = priv->sample_rate;
outlink->channel_layout = priv->channel_layout;
chans_nb = av_get_channel_layout_nb_channels(priv->channel_layout);
av_get_channel_layout_string(buf, sizeof(buf), chans_nb, priv->channel_layout);
av_log(outlink->src, AV_LOG_INFO,
"sample_rate:%"PRId64 " channel_layout:%"PRId64 " channel_layout_description:'%s'\n",
priv->sample_rate, priv->channel_layout, buf);
return 0;
}
static av_cold int init(AVFilterContext *ctx, const char *args0, void *opaque)
{
ABufferSourceContext *abuffer = ctx->priv;
char *arg = NULL, *ptr, chlayout_str[16];
char *args = av_strdup(args0);
int ret;
arg = av_strtok(args, ":", &ptr);
#define ADD_FORMAT(fmt_name) \
if (!arg) \
goto arg_fail; \
if ((ret = ff_parse_##fmt_name(&abuffer->fmt_name, arg, ctx)) < 0) { \
av_freep(&args); \
return ret; \
} \
if (*args) \
arg = av_strtok(NULL, ":", &ptr)
ADD_FORMAT(sample_rate);
ADD_FORMAT(sample_format);
ADD_FORMAT(channel_layout);
ADD_FORMAT(packing_format);
abuffer->fifo = av_fifo_alloc(FIFO_SIZE*sizeof(AVFilterBufferRef*));
if (!abuffer->fifo) {
av_log(ctx, AV_LOG_ERROR, "Failed to allocate fifo, filter init failed.\n");
return AVERROR(ENOMEM);
}
av_get_channel_layout_string(chlayout_str, sizeof(chlayout_str),
-1, abuffer->channel_layout);
av_log(ctx, AV_LOG_INFO, "format:%s layout:%s rate:%d\n",
av_get_sample_fmt_name(abuffer->sample_format), chlayout_str,
abuffer->sample_rate);
av_freep(&args);
return 0;
arg_fail:
av_log(ctx, AV_LOG_ERROR, "Invalid arguments, must be of the form "
"sample_rate:sample_fmt:channel_layout:packing\n");
av_freep(&args);
return AVERROR(EINVAL);
}
static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *samplesref)
{
AVFilterContext *ctx = inlink->dst;
ShowInfoContext *showinfo = ctx->priv;
uint32_t plane_checksum[8] = {0}, checksum = 0;
char chlayout_str[128];
int plane;
int linesize =
samplesref->audio->nb_samples *
av_get_bytes_per_sample(samplesref->format);
if (!av_sample_fmt_is_planar(samplesref->format))
linesize *= av_get_channel_layout_nb_channels(samplesref->audio->channel_layout);
for (plane = 0; samplesref->data[plane] && plane < 8; plane++) {
uint8_t *data = samplesref->data[plane];
plane_checksum[plane] = av_adler32_update(plane_checksum[plane],
data, linesize);
checksum = av_adler32_update(checksum, data, linesize);
}
av_get_channel_layout_string(chlayout_str, sizeof(chlayout_str), -1,
samplesref->audio->channel_layout);
av_log(ctx, AV_LOG_INFO,
"n:%d pts:%s pts_time:%s pos:%"PRId64" "
"fmt:%s chlayout:%s nb_samples:%d rate:%d "
"checksum:%08X plane_checksum[%08X",
showinfo->frame,
av_ts2str(samplesref->pts), av_ts2timestr(samplesref->pts, &inlink->time_base),
samplesref->pos,
av_get_sample_fmt_name(samplesref->format),
chlayout_str,
samplesref->audio->nb_samples,
samplesref->audio->sample_rate,
checksum,
plane_checksum[0]);
for (plane = 1; samplesref->data[plane] && plane < 8; plane++)
av_log(ctx, AV_LOG_INFO, " %08X", plane_checksum[plane]);
av_log(ctx, AV_LOG_INFO, "]\n");
showinfo->frame++;
ff_filter_samples(inlink->dst->outputs[0], samplesref);
}
void FFmpeg_Decoder::getInfo(int *samplerate, ChannelConfig *chans, SampleType *type)
{
if(mStreams.empty())
fail("No audio stream info");
MyStream *stream = mStreams[0];
if(stream->mCodecCtx->sample_fmt == AV_SAMPLE_FMT_U8)
*type = SampleType_UInt8;
else if(stream->mCodecCtx->sample_fmt == AV_SAMPLE_FMT_S16)
*type = SampleType_Int16;
else
fail(std::string("Unsupported sample format: ")+
av_get_sample_fmt_name(stream->mCodecCtx->sample_fmt));
if(stream->mCodecCtx->channel_layout == AV_CH_LAYOUT_MONO)
*chans = ChannelConfig_Mono;
else if(stream->mCodecCtx->channel_layout == AV_CH_LAYOUT_STEREO)
*chans = ChannelConfig_Stereo;
else if(stream->mCodecCtx->channel_layout == 0)
{
/* Unknown channel layout. Try to guess. */
if(stream->mCodecCtx->channels == 1)
*chans = ChannelConfig_Mono;
else if(stream->mCodecCtx->channels == 2)
*chans = ChannelConfig_Stereo;
else
{
std::stringstream sstr("Unsupported raw channel count: ");
sstr << stream->mCodecCtx->channels;
fail(sstr.str());
}
}
else
{
char str[1024];
av_get_channel_layout_string(str, sizeof(str), stream->mCodecCtx->channels,
stream->mCodecCtx->channel_layout);
fail(std::string("Unsupported channel layout: ")+str);
}
*samplerate = stream->mCodecCtx->sample_rate;
}
static int filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)
{
AVFilterContext *ctx = inlink->dst;
AShowInfoContext *s = ctx->priv;
char chlayout_str[128];
uint32_t checksum = 0;
int channels = av_get_channel_layout_nb_channels(buf->audio->channel_layout);
int planar = av_sample_fmt_is_planar(buf->format);
int block_align = av_get_bytes_per_sample(buf->format) * (planar ? 1 : channels);
int data_size = buf->audio->nb_samples * block_align;
int planes = planar ? channels : 1;
int i;
for (i = 0; i < planes; i++) {
uint8_t *data = buf->extended_data[i];
s->plane_checksums[i] = av_adler32_update(0, data, data_size);
checksum = i ? av_adler32_update(checksum, data, data_size) :
s->plane_checksums[0];
}
av_get_channel_layout_string(chlayout_str, sizeof(chlayout_str), -1,
buf->audio->channel_layout);
av_log(ctx, AV_LOG_INFO,
"n:%"PRIu64" pts:%"PRId64" pts_time:%f "
"fmt:%s chlayout:%s rate:%d nb_samples:%d "
"checksum:%08X ",
s->frame, buf->pts, buf->pts * av_q2d(inlink->time_base),
av_get_sample_fmt_name(buf->format), chlayout_str,
buf->audio->sample_rate, buf->audio->nb_samples,
checksum);
av_log(ctx, AV_LOG_INFO, "plane_checksums: [ ");
for (i = 0; i < planes; i++)
av_log(ctx, AV_LOG_INFO, "%08X ", s->plane_checksums[i]);
av_log(ctx, AV_LOG_INFO, "]\n");
s->frame++;
return ff_filter_samples(inlink->dst->outputs[0], buf);
}
int main(void)
{
const int64_t *cl;
char buf[512];
int i;
const char *teststrings[] ={
"blah",
"1",
"2",
"-1",
"60",
"65",
"1c",
"2c",
"-1c",
"60c",
"65c",
"5.1",
"stereo",
"1+1+1+1",
"1c+1c+1c+1c",
"2c+1c",
"0x3",
};
for (cl = avfilter_all_channel_layouts; *cl != -1; cl++) {
av_get_channel_layout_string(buf, sizeof(buf), -1, *cl);
printf("%s\n", buf);
}
for ( i = 0; i<FF_ARRAY_ELEMS(teststrings); i++) {
int64_t layout = -1;
int count = -1;
int ret;
ret = ff_parse_channel_layout(&layout, &count, teststrings[i], NULL);
printf ("%d = ff_parse_channel_layout(%016"PRIX64", %2d, %s);\n", ret ? -1 : 0, layout, count, teststrings[i]);
}
return 0;
}
void ff_dlog_link(void *ctx, AVFilterLink *link, int end)
{
if (link->type == AVMEDIA_TYPE_VIDEO) {
av_dlog(ctx,
"link[%p s:%dx%d fmt:%-16s %-16s->%-16s]%s",
link, link->w, link->h,
av_pix_fmt_descriptors[link->format].name,
link->src ? link->src->filter->name : "",
link->dst ? link->dst->filter->name : "",
end ? "\n" : "");
} else {
char buf[128];
av_get_channel_layout_string(buf, sizeof(buf), -1, link->channel_layout);
av_dlog(ctx,
"link[%p r:%"PRId64" cl:%s fmt:%-16s %-16s->%-16s]%s",
link, link->sample_rate, buf,
av_get_sample_fmt_name(link->format),
link->src ? link->src->filter->name : "",
link->dst ? link->dst->filter->name : "",
end ? "\n" : "");
}
}
void ff_tlog_link(void *ctx, AVFilterLink *link, int end)
{
if (link->type == AVMEDIA_TYPE_VIDEO) {
ff_tlog(ctx,
"link[%p s:%dx%d fmt:%s %s->%s]%s",
link, link->w, link->h,
av_get_pix_fmt_name(link->format),
link->src ? link->src->filter->name : "",
link->dst ? link->dst->filter->name : "",
end ? "\n" : "");
} else {
char buf[128];
av_get_channel_layout_string(buf, sizeof(buf), -1, link->channel_layout);
ff_tlog(ctx,
"link[%p r:%d cl:%s fmt:%s %s->%s]%s",
link, (int)link->sample_rate, buf,
av_get_sample_fmt_name(link->format),
link->src ? link->src->filter->name : "",
link->dst ? link->dst->filter->name : "",
end ? "\n" : "");
}
}
static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
{
AVFilterContext *ctx = inlink->dst;
AShowInfoContext *s = ctx->priv;
char chlayout_str[128];
uint32_t checksum = 0;
int channels = inlink->channels;
int planar = av_sample_fmt_is_planar(buf->format);
int block_align = av_get_bytes_per_sample(buf->format) * (planar ? 1 : channels);
int data_size = buf->nb_samples * block_align;
int planes = planar ? channels : 1;
int i;
void *tmp_ptr = av_realloc_array(s->plane_checksums, channels, sizeof(*s->plane_checksums));
if (!tmp_ptr)
return AVERROR(ENOMEM);
s->plane_checksums = tmp_ptr;
for (i = 0; i < planes; i++) {
uint8_t *data = buf->extended_data[i];
s->plane_checksums[i] = av_adler32_update(0, data, data_size);
checksum = i ? av_adler32_update(checksum, data, data_size) :
s->plane_checksums[0];
}
av_get_channel_layout_string(chlayout_str, sizeof(chlayout_str), -1,
buf->channel_layout);
av_log(ctx, AV_LOG_INFO,
"n:%"PRId64" pts:%s pts_time:%s pos:%"PRId64" "
"fmt:%s channels:%d chlayout:%s rate:%d nb_samples:%d "
"checksum:%08"PRIX32" ",
inlink->frame_count_out,
av_ts2str(buf->pts), av_ts2timestr(buf->pts, &inlink->time_base),
av_frame_get_pkt_pos(buf),
av_get_sample_fmt_name(buf->format), av_frame_get_channels(buf), chlayout_str,
buf->sample_rate, buf->nb_samples,
checksum);
av_log(ctx, AV_LOG_INFO, "plane_checksums: [ ");
for (i = 0; i < planes; i++)
av_log(ctx, AV_LOG_INFO, "%08"PRIX32" ", s->plane_checksums[i]);
av_log(ctx, AV_LOG_INFO, "]\n");
for (i = 0; i < buf->nb_side_data; i++) {
AVFrameSideData *sd = buf->side_data[i];
av_log(ctx, AV_LOG_INFO, " side data - ");
switch (sd->type) {
case AV_FRAME_DATA_MATRIXENCODING: dump_matrixenc (ctx, sd); break;
case AV_FRAME_DATA_DOWNMIX_INFO: dump_downmix (ctx, sd); break;
case AV_FRAME_DATA_REPLAYGAIN: dump_replaygain(ctx, sd); break;
case AV_FRAME_DATA_AUDIO_SERVICE_TYPE: dump_audio_service_type(ctx, sd); break;
default: dump_unknown (ctx, sd); break;
}
av_log(ctx, AV_LOG_INFO, "\n");
}
return ff_filter_frame(inlink->dst->outputs[0], buf);
}
