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); }