highperfocused/ffmpeg
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

doc/examples: convert to new channel layout-API

Browse Source 
Signed-off-by: James Almer <jamrial@gmail.com>
This commit is contained in:
James Almer
2022-01-20 17:47:51 -03:00
parent 50e9e11316
commit f5ef91e020
9 changed files with 73 additions and 81 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
doc/examples/decode_audio.c
View File

@@ -97,7 +97,7 @@ static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame,
exit(1); exit(1);
} }
for (i = 0; i < frame->nb_samples; i++) for (i = 0; i < frame->nb_samples; i++)
for (ch = 0; ch < dec_ctx->channels; ch++) for (ch = 0; ch < dec_ctx->ch_layout.nb_channels; ch++)
fwrite(frame->data[ch] + data_size*i, 1, data_size, outfile); fwrite(frame->data[ch] + data_size*i, 1, data_size, outfile);
} }
} }
@@ -215,7 +215,7 @@ int main(int argc, char **argv)
sfmt = av_get_packed_sample_fmt(sfmt); sfmt = av_get_packed_sample_fmt(sfmt);
} }
n_channels = c->channels; n_channels = c->ch_layout.nb_channels;
if ((ret = get_format_from_sample_fmt(&fmt, sfmt)) < 0) if ((ret = get_format_from_sample_fmt(&fmt, sfmt)) < 0)
goto end; goto end;

2
doc/examples/demuxing_decoding.c
View File

@@ -345,7 +345,7 @@ int main (int argc, char **argv)
if (audio_stream) { if (audio_stream) {
enum AVSampleFormat sfmt = audio_dec_ctx->sample_fmt; enum AVSampleFormat sfmt = audio_dec_ctx->sample_fmt;
int n_channels = audio_dec_ctx->channels; int n_channels = audio_dec_ctx->ch_layout.nb_channels;
const char *fmt; const char *fmt;
if (av_sample_fmt_is_planar(sfmt)) { if (av_sample_fmt_is_planar(sfmt)) {

30
doc/examples/encode_audio.c
View File

@@ -70,26 +70,25 @@ static int select_sample_rate(const AVCodec *codec)
} }
/* select layout with the highest channel count */ /* select layout with the highest channel count */
static int select_channel_layout(const AVCodec *codec) static int select_channel_layout(const AVCodec *codec, AVChannelLayout *dst)
{ {
const uint64_t *p; const AVChannelLayout *p, *best_ch_layout;
uint64_t best_ch_layout = 0;
int best_nb_channels = 0; int best_nb_channels = 0;
if (!codec->channel_layouts) if (!codec->ch_layouts)
return AV_CH_LAYOUT_STEREO; return av_channel_layout_copy(dst, &(AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO);
p = codec->channel_layouts; p = codec->ch_layouts;
while (*p) { while (p->nb_channels) {
int nb_channels = av_get_channel_layout_nb_channels(*p); int nb_channels = p->nb_channels;
if (nb_channels > best_nb_channels) { if (nb_channels > best_nb_channels) {
best_ch_layout = *p; best_ch_layout = p;
best_nb_channels = nb_channels; best_nb_channels = nb_channels;
} }
p++; p++;
} }
return best_ch_layout; return av_channel_layout_copy(dst, best_ch_layout);
} }
static void encode(AVCodecContext *ctx, AVFrame *frame, AVPacket *pkt, static void encode(AVCodecContext *ctx, AVFrame *frame, AVPacket *pkt,
@@ -164,8 +163,9 @@ int main(int argc, char **argv)
/* select other audio parameters supported by the encoder */ /* select other audio parameters supported by the encoder */
c->sample_rate = select_sample_rate(codec); c->sample_rate = select_sample_rate(codec);
c->channel_layout = select_channel_layout(codec); ret = select_channel_layout(codec, &c->ch_layout);
c->channels = av_get_channel_layout_nb_channels(c->channel_layout); if (ret < 0)
exit(1);
/* open it */ /* open it */
if (avcodec_open2(c, codec, NULL) < 0) { if (avcodec_open2(c, codec, NULL) < 0) {
@@ -195,7 +195,9 @@ int main(int argc, char **argv)
frame->nb_samples = c->frame_size; frame->nb_samples = c->frame_size;
frame->format = c->sample_fmt; frame->format = c->sample_fmt;
frame->channel_layout = c->channel_layout; ret = av_channel_layout_copy(&frame->ch_layout, &c->ch_layout);
if (ret < 0)
exit(1);
/* allocate the data buffers */ /* allocate the data buffers */
ret = av_frame_get_buffer(frame, 0); ret = av_frame_get_buffer(frame, 0);
@@ -218,7 +220,7 @@ int main(int argc, char **argv)
for (j = 0; j < c->frame_size; j++) { for (j = 0; j < c->frame_size; j++) {
samples[2*j] = (int)(sin(t) * 10000); samples[2*j] = (int)(sin(t) * 10000);
for (k = 1; k < c->channels; k++) for (k = 1; k < c->ch_layout.nb_channels; k++)
samples[2*j + k] = samples[2*j]; samples[2*j + k] = samples[2*j];
t += tincr; t += tincr;
} }

13
doc/examples/filter_audio.c
View File

@@ -55,7 +55,7 @@
#define INPUT_SAMPLERATE 48000 #define INPUT_SAMPLERATE 48000
#define INPUT_FORMAT AV_SAMPLE_FMT_FLTP #define INPUT_FORMAT AV_SAMPLE_FMT_FLTP
#define INPUT_CHANNEL_LAYOUT AV_CH_LAYOUT_5POINT0 #define INPUT_CHANNEL_LAYOUT (AVChannelLayout)AV_CHANNEL_LAYOUT_5POINT0
#define VOLUME_VAL 0.90 #define VOLUME_VAL 0.90
@@ -100,7 +100,7 @@ static int init_filter_graph(AVFilterGraph **graph, AVFilterContext **src,
} }
/* Set the filter options through the AVOptions API. */ /* Set the filter options through the AVOptions API. */
av_get_channel_layout_string(ch_layout, sizeof(ch_layout), 0, INPUT_CHANNEL_LAYOUT); av_channel_layout_describe(&INPUT_CHANNEL_LAYOUT, ch_layout, sizeof(ch_layout));
av_opt_set (abuffer_ctx, "channel_layout", ch_layout, AV_OPT_SEARCH_CHILDREN); av_opt_set (abuffer_ctx, "channel_layout", ch_layout, AV_OPT_SEARCH_CHILDREN);
av_opt_set (abuffer_ctx, "sample_fmt", av_get_sample_fmt_name(INPUT_FORMAT), AV_OPT_SEARCH_CHILDREN); av_opt_set (abuffer_ctx, "sample_fmt", av_get_sample_fmt_name(INPUT_FORMAT), AV_OPT_SEARCH_CHILDREN);
av_opt_set_q (abuffer_ctx, "time_base", (AVRational){ 1, INPUT_SAMPLERATE }, AV_OPT_SEARCH_CHILDREN); av_opt_set_q (abuffer_ctx, "time_base", (AVRational){ 1, INPUT_SAMPLERATE }, AV_OPT_SEARCH_CHILDREN);
@@ -154,9 +154,8 @@ static int init_filter_graph(AVFilterGraph **graph, AVFilterContext **src,
/* A third way of passing the options is in a string of the form /* A third way of passing the options is in a string of the form
* key1=value1:key2=value2.... */ * key1=value1:key2=value2.... */
snprintf(options_str, sizeof(options_str), snprintf(options_str, sizeof(options_str),
"sample_fmts=%s:sample_rates=%d:channel_layouts=0x%"PRIx64, "sample_fmts=%s:sample_rates=%d:channel_layouts=stereo",
av_get_sample_fmt_name(AV_SAMPLE_FMT_S16), 44100, av_get_sample_fmt_name(AV_SAMPLE_FMT_S16), 44100);
(uint64_t)AV_CH_LAYOUT_STEREO);
err = avfilter_init_str(aformat_ctx, options_str); err = avfilter_init_str(aformat_ctx, options_str);
if (err < 0) { if (err < 0) {
av_log(NULL, AV_LOG_ERROR, "Could not initialize the aformat filter.\n"); av_log(NULL, AV_LOG_ERROR, "Could not initialize the aformat filter.\n");
@@ -215,7 +214,7 @@ static int init_filter_graph(AVFilterGraph **graph, AVFilterContext **src,
static int process_output(struct AVMD5 *md5, AVFrame *frame) static int process_output(struct AVMD5 *md5, AVFrame *frame)
{ {
int planar = av_sample_fmt_is_planar(frame->format); int planar = av_sample_fmt_is_planar(frame->format);
int channels = av_get_channel_layout_nb_channels(frame->channel_layout); int channels = frame->ch_layout.nb_channels;
int planes = planar ? channels : 1; int planes = planar ? channels : 1;
int bps = av_get_bytes_per_sample(frame->format); int bps = av_get_bytes_per_sample(frame->format);
int plane_size = bps * frame->nb_samples * (planar ? 1 : channels); int plane_size = bps * frame->nb_samples * (planar ? 1 : channels);
@@ -248,7 +247,7 @@ static int get_input(AVFrame *frame, int frame_num)
/* Set up the frame properties and allocate the buffer for the data. */ /* Set up the frame properties and allocate the buffer for the data. */
frame->sample_rate = INPUT_SAMPLERATE; frame->sample_rate = INPUT_SAMPLERATE;
frame->format = INPUT_FORMAT; frame->format = INPUT_FORMAT;
frame->channel_layout = INPUT_CHANNEL_LAYOUT; av_channel_layout_copy(&frame->ch_layout, &INPUT_CHANNEL_LAYOUT);
frame->nb_samples = FRAME_SIZE; frame->nb_samples = FRAME_SIZE;
frame->pts = frame_num * FRAME_SIZE; frame->pts = frame_num * FRAME_SIZE;

18
doc/examples/filtering_audio.c
View File

@@ -94,7 +94,6 @@ static int init_filters(const char *filters_descr)
AVFilterInOut *outputs = avfilter_inout_alloc(); AVFilterInOut *outputs = avfilter_inout_alloc();
AVFilterInOut *inputs = avfilter_inout_alloc(); AVFilterInOut *inputs = avfilter_inout_alloc();
static const enum AVSampleFormat out_sample_fmts[] = { AV_SAMPLE_FMT_S16, -1 }; static const enum AVSampleFormat out_sample_fmts[] = { AV_SAMPLE_FMT_S16, -1 };
static const int64_t out_channel_layouts[] = { AV_CH_LAYOUT_MONO, -1 };
static const int out_sample_rates[] = { 8000, -1 }; static const int out_sample_rates[] = { 8000, -1 };
const AVFilterLink *outlink; const AVFilterLink *outlink;
AVRational time_base = fmt_ctx->streams[audio_stream_index]->time_base; AVRational time_base = fmt_ctx->streams[audio_stream_index]->time_base;
@@ -106,12 +105,13 @@ static int init_filters(const char *filters_descr)
} }
/* buffer audio source: the decoded frames from the decoder will be inserted here. */ /* buffer audio source: the decoded frames from the decoder will be inserted here. */
if (!dec_ctx->channel_layout) if (dec_ctx->ch_layout.order == AV_CHANNEL_ORDER_UNSPEC)
dec_ctx->channel_layout = av_get_default_channel_layout(dec_ctx->channels); av_channel_layout_default(&dec_ctx->ch_layout, dec_ctx->ch_layout.nb_channels);
snprintf(args, sizeof(args), ret = snprintf(args, sizeof(args),
"time_base=%d/%d:sample_rate=%d:sample_fmt=%s:channel_layout=0x%"PRIx64, "time_base=%d/%d:sample_rate=%d:sample_fmt=%s:channel_layout=",
time_base.num, time_base.den, dec_ctx->sample_rate, time_base.num, time_base.den, dec_ctx->sample_rate,
av_get_sample_fmt_name(dec_ctx->sample_fmt), dec_ctx->channel_layout); av_get_sample_fmt_name(dec_ctx->sample_fmt));
av_channel_layout_describe(&dec_ctx->ch_layout, args + ret, sizeof(args) - ret);
ret = avfilter_graph_create_filter(&buffersrc_ctx, abuffersrc, "in", ret = avfilter_graph_create_filter(&buffersrc_ctx, abuffersrc, "in",
args, NULL, filter_graph); args, NULL, filter_graph);
if (ret < 0) { if (ret < 0) {
@@ -134,7 +134,7 @@ static int init_filters(const char *filters_descr)
goto end; goto end;
} }
ret = av_opt_set_int_list(buffersink_ctx, "channel_layouts", out_channel_layouts, -1, ret = av_opt_set(buffersink_ctx, "ch_layouts", "mono",
AV_OPT_SEARCH_CHILDREN); AV_OPT_SEARCH_CHILDREN);
if (ret < 0) { if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot set output channel layout\n"); av_log(NULL, AV_LOG_ERROR, "Cannot set output channel layout\n");
@@ -185,7 +185,7 @@ static int init_filters(const char *filters_descr)
/* Print summary of the sink buffer /* Print summary of the sink buffer
* Note: args buffer is reused to store channel layout string */ * Note: args buffer is reused to store channel layout string */
outlink = buffersink_ctx->inputs[0]; outlink = buffersink_ctx->inputs[0];
av_get_channel_layout_string(args, sizeof(args), -1, outlink->channel_layout); av_channel_layout_describe(&outlink->ch_layout, args, sizeof(args));
av_log(NULL, AV_LOG_INFO, "Output: srate:%dHz fmt:%s chlayout:%s\n", av_log(NULL, AV_LOG_INFO, "Output: srate:%dHz fmt:%s chlayout:%s\n",
(int)outlink->sample_rate, (int)outlink->sample_rate,
(char *)av_x_if_null(av_get_sample_fmt_name(outlink->format), "?"), (char *)av_x_if_null(av_get_sample_fmt_name(outlink->format), "?"),
@@ -200,7 +200,7 @@ end:
static void print_frame(const AVFrame *frame) static void print_frame(const AVFrame *frame)
{ {
const int n = frame->nb_samples * av_get_channel_layout_nb_channels(frame->channel_layout); const int n = frame->nb_samples * frame->ch_layout.nb_channels;
const uint16_t *p = (uint16_t*)frame->data[0]; const uint16_t *p = (uint16_t*)frame->data[0];
const uint16_t *p_end = p + n; const uint16_t *p_end = p + n;

25
doc/examples/muxing.c
View File

@@ -170,16 +170,7 @@ static void add_stream(OutputStream *ost, AVFormatContext *oc,
c->sample_rate = 44100; c->sample_rate = 44100;
} }
} }
c->channels = av_get_channel_layout_nb_channels(c->channel_layout); av_channel_layout_copy(&c->ch_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO);
c->channel_layout = AV_CH_LAYOUT_STEREO;
if ((*codec)->channel_layouts) {
c->channel_layout = (*codec)->channel_layouts[0];
for (i = 0; (*codec)->channel_layouts[i]; i++) {
if ((*codec)->channel_layouts[i] == AV_CH_LAYOUT_STEREO)
c->channel_layout = AV_CH_LAYOUT_STEREO;
}
}
c->channels = av_get_channel_layout_nb_channels(c->channel_layout);
ost->st->time_base = (AVRational){ 1, c->sample_rate }; ost->st->time_base = (AVRational){ 1, c->sample_rate };
break; break;
@@ -224,7 +215,7 @@ static void add_stream(OutputStream *ost, AVFormatContext *oc,
/* audio output */ /* audio output */
static AVFrame *alloc_audio_frame(enum AVSampleFormat sample_fmt, static AVFrame *alloc_audio_frame(enum AVSampleFormat sample_fmt,
uint64_t channel_layout, const AVChannelLayout *channel_layout,
int sample_rate, int nb_samples) int sample_rate, int nb_samples)
{ {
AVFrame *frame = av_frame_alloc(); AVFrame *frame = av_frame_alloc();
@@ -236,7 +227,7 @@ static AVFrame *alloc_audio_frame(enum AVSampleFormat sample_fmt,
} }
frame->format = sample_fmt; frame->format = sample_fmt;
frame->channel_layout = channel_layout; av_channel_layout_copy(&frame->ch_layout, channel_layout);
frame->sample_rate = sample_rate; frame->sample_rate = sample_rate;
frame->nb_samples = nb_samples; frame->nb_samples = nb_samples;
@@ -281,9 +272,9 @@ static void open_audio(AVFormatContext *oc, const AVCodec *codec,
else else
nb_samples = c->frame_size; nb_samples = c->frame_size;
ost->frame = alloc_audio_frame(c->sample_fmt, c->channel_layout, ost->frame = alloc_audio_frame(c->sample_fmt, &c->ch_layout,
c->sample_rate, nb_samples); c->sample_rate, nb_samples);
ost->tmp_frame = alloc_audio_frame(AV_SAMPLE_FMT_S16, c->channel_layout, ost->tmp_frame = alloc_audio_frame(AV_SAMPLE_FMT_S16, &c->ch_layout,
c->sample_rate, nb_samples); c->sample_rate, nb_samples);
/* copy the stream parameters to the muxer */ /* copy the stream parameters to the muxer */
@@ -301,10 +292,10 @@ static void open_audio(AVFormatContext *oc, const AVCodec *codec,
} }
/* set options */ /* set options */
av_opt_set_int (ost->swr_ctx, "in_channel_count", c->channels, 0); av_opt_set_chlayout (ost->swr_ctx, "in_chlayout", &c->ch_layout, 0);
av_opt_set_int (ost->swr_ctx, "in_sample_rate", c->sample_rate, 0); av_opt_set_int (ost->swr_ctx, "in_sample_rate", c->sample_rate, 0);
av_opt_set_sample_fmt(ost->swr_ctx, "in_sample_fmt", AV_SAMPLE_FMT_S16, 0); av_opt_set_sample_fmt(ost->swr_ctx, "in_sample_fmt", AV_SAMPLE_FMT_S16, 0);
av_opt_set_int (ost->swr_ctx, "out_channel_count", c->channels, 0); av_opt_set_chlayout (ost->swr_ctx, "out_chlayout", &c->ch_layout, 0);
av_opt_set_int (ost->swr_ctx, "out_sample_rate", c->sample_rate, 0); av_opt_set_int (ost->swr_ctx, "out_sample_rate", c->sample_rate, 0);
av_opt_set_sample_fmt(ost->swr_ctx, "out_sample_fmt", c->sample_fmt, 0); av_opt_set_sample_fmt(ost->swr_ctx, "out_sample_fmt", c->sample_fmt, 0);
@@ -330,7 +321,7 @@ static AVFrame *get_audio_frame(OutputStream *ost)
for (j = 0; j <frame->nb_samples; j++) { for (j = 0; j <frame->nb_samples; j++) {
v = (int)(sin(ost->t) * 10000); v = (int)(sin(ost->t) * 10000);
for (i = 0; i < ost->enc->channels; i++) for (i = 0; i < ost->enc->ch_layout.nb_channels; i++)
*q++ = v; *q++ = v;
ost->t += ost->tincr; ost->t += ost->tincr;
ost->tincr += ost->tincr2; ost->tincr += ost->tincr2;

16
doc/examples/resampling_audio.c
View File

@@ -80,7 +80,7 @@ static void fill_samples(double *dst, int nb_samples, int nb_channels, int sampl
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
int64_t src_ch_layout = AV_CH_LAYOUT_STEREO, dst_ch_layout = AV_CH_LAYOUT_SURROUND; AVChannelLayout src_ch_layout = AV_CHANNEL_LAYOUT_STEREO, dst_ch_layout = AV_CHANNEL_LAYOUT_SURROUND;
int src_rate = 48000, dst_rate = 44100; int src_rate = 48000, dst_rate = 44100;
uint8_t **src_data = NULL, **dst_data = NULL; uint8_t **src_data = NULL, **dst_data = NULL;
int src_nb_channels = 0, dst_nb_channels = 0; int src_nb_channels = 0, dst_nb_channels = 0;
@@ -92,6 +92,7 @@ int main(int argc, char **argv)
int dst_bufsize; int dst_bufsize;
const char *fmt; const char *fmt;
struct SwrContext *swr_ctx; struct SwrContext *swr_ctx;
char buf[64];
double t; double t;
int ret; int ret;
@@ -120,11 +121,11 @@ int main(int argc, char **argv)
} }
/* set options */ /* set options */
av_opt_set_int(swr_ctx, "in_channel_layout", src_ch_layout, 0); av_opt_set_chlayout(swr_ctx, "in_chlayout", &src_ch_layout, 0);
av_opt_set_int(swr_ctx, "in_sample_rate", src_rate, 0); av_opt_set_int(swr_ctx, "in_sample_rate", src_rate, 0);
av_opt_set_sample_fmt(swr_ctx, "in_sample_fmt", src_sample_fmt, 0); av_opt_set_sample_fmt(swr_ctx, "in_sample_fmt", src_sample_fmt, 0);
av_opt_set_int(swr_ctx, "out_channel_layout", dst_ch_layout, 0); av_opt_set_chlayout(swr_ctx, "out_chlayout", &dst_ch_layout, 0);
av_opt_set_int(swr_ctx, "out_sample_rate", dst_rate, 0); av_opt_set_int(swr_ctx, "out_sample_rate", dst_rate, 0);
av_opt_set_sample_fmt(swr_ctx, "out_sample_fmt", dst_sample_fmt, 0); av_opt_set_sample_fmt(swr_ctx, "out_sample_fmt", dst_sample_fmt, 0);
@@ -136,7 +137,7 @@ int main(int argc, char **argv)
/* allocate source and destination samples buffers */ /* allocate source and destination samples buffers */
src_nb_channels = av_get_channel_layout_nb_channels(src_ch_layout); src_nb_channels = src_ch_layout.nb_channels;
ret = av_samples_alloc_array_and_samples(&src_data, &src_linesize, src_nb_channels, ret = av_samples_alloc_array_and_samples(&src_data, &src_linesize, src_nb_channels,
src_nb_samples, src_sample_fmt, 0); src_nb_samples, src_sample_fmt, 0);
if (ret < 0) { if (ret < 0) {
@@ -151,7 +152,7 @@ int main(int argc, char **argv)
av_rescale_rnd(src_nb_samples, dst_rate, src_rate, AV_ROUND_UP); av_rescale_rnd(src_nb_samples, dst_rate, src_rate, AV_ROUND_UP);
/* buffer is going to be directly written to a rawaudio file, no alignment */ /* buffer is going to be directly written to a rawaudio file, no alignment */
dst_nb_channels = av_get_channel_layout_nb_channels(dst_ch_layout); dst_nb_channels = dst_ch_layout.nb_channels;
ret = av_samples_alloc_array_and_samples(&dst_data, &dst_linesize, dst_nb_channels, ret = av_samples_alloc_array_and_samples(&dst_data, &dst_linesize, dst_nb_channels,
dst_nb_samples, dst_sample_fmt, 0); dst_nb_samples, dst_sample_fmt, 0);
if (ret < 0) { if (ret < 0) {
@@ -194,9 +195,10 @@ int main(int argc, char **argv)
if ((ret = get_format_from_sample_fmt(&fmt, dst_sample_fmt)) < 0) if ((ret = get_format_from_sample_fmt(&fmt, dst_sample_fmt)) < 0)
goto end; goto end;
av_channel_layout_describe(&dst_ch_layout, buf, sizeof(buf));
fprintf(stderr, "Resampling succeeded. Play the output file with the command:\n" fprintf(stderr, "Resampling succeeded. Play the output file with the command:\n"
"ffplay -f %s -channel_layout %"PRId64" -channels %d -ar %d %s\n", "ffplay -f %s -channel_layout %s -channels %d -ar %d %s\n",
fmt, dst_ch_layout, dst_nb_channels, dst_rate, dst_filename); fmt, buf, dst_nb_channels, dst_rate, dst_filename);
end: end:
fclose(dst_file); fclose(dst_file);

24
doc/examples/transcode_aac.c
View File

@@ -200,8 +200,7 @@ static int open_output_file(const char *filename,
/* Set the basic encoder parameters. /* Set the basic encoder parameters.
* The input file's sample rate is used to avoid a sample rate conversion. */ * The input file's sample rate is used to avoid a sample rate conversion. */
avctx->channels = OUTPUT_CHANNELS; av_channel_layout_default(&avctx->ch_layout, OUTPUT_CHANNELS);
avctx->channel_layout = av_get_default_channel_layout(OUTPUT_CHANNELS);
avctx->sample_rate = input_codec_context->sample_rate; avctx->sample_rate = input_codec_context->sample_rate;
avctx->sample_fmt = output_codec->sample_fmts[0]; avctx->sample_fmt = output_codec->sample_fmts[0];
avctx->bit_rate = OUTPUT_BIT_RATE; avctx->bit_rate = OUTPUT_BIT_RATE;
@@ -290,21 +289,18 @@ static int init_resampler(AVCodecContext *input_codec_context,
/* /*
* Create a resampler context for the conversion. * Create a resampler context for the conversion.
* Set the conversion parameters. * Set the conversion parameters.
* Default channel layouts based on the number of channels
* are assumed for simplicity (they are sometimes not detected
* properly by the demuxer and/or decoder).
*/ */
*resample_context = swr_alloc_set_opts(NULL, error = swr_alloc_set_opts2(resample_context,
av_get_default_channel_layout(output_codec_context->channels), &output_codec_context->ch_layout,
output_codec_context->sample_fmt, output_codec_context->sample_fmt,
output_codec_context->sample_rate, output_codec_context->sample_rate,
av_get_default_channel_layout(input_codec_context->channels), &input_codec_context->ch_layout,
input_codec_context->sample_fmt, input_codec_context->sample_fmt,
input_codec_context->sample_rate, input_codec_context->sample_rate,
0, NULL); 0, NULL);
if (!*resample_context) { if (error < 0) {
fprintf(stderr, "Could not allocate resample context\n"); fprintf(stderr, "Could not allocate resample context\n");
return AVERROR(ENOMEM); return error;
} }
/* /*
* Perform a sanity check so that the number of converted samples is * Perform a sanity check so that the number of converted samples is
@@ -332,7 +328,7 @@ static int init_fifo(AVAudioFifo **fifo, AVCodecContext *output_codec_context)
{ {
/* Create the FIFO buffer based on the specified output sample format. */ /* Create the FIFO buffer based on the specified output sample format. */
if (!(*fifo = av_audio_fifo_alloc(output_codec_context->sample_fmt, if (!(*fifo = av_audio_fifo_alloc(output_codec_context->sample_fmt,
output_codec_context->channels, 1))) { output_codec_context->ch_layout.nb_channels, 1))) {
fprintf(stderr, "Could not allocate FIFO\n"); fprintf(stderr, "Could not allocate FIFO\n");
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
@@ -450,7 +446,7 @@ static int init_converted_samples(uint8_t ***converted_input_samples,
* Each pointer will later point to the audio samples of the corresponding * Each pointer will later point to the audio samples of the corresponding
* channels (although it may be NULL for interleaved formats). * channels (although it may be NULL for interleaved formats).
*/ */
if (!(*converted_input_samples = calloc(output_codec_context->channels, if (!(*converted_input_samples = calloc(output_codec_context->ch_layout.nb_channels,
sizeof(**converted_input_samples)))) { sizeof(**converted_input_samples)))) {
fprintf(stderr, "Could not allocate converted input sample pointers\n"); fprintf(stderr, "Could not allocate converted input sample pointers\n");
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
@@ -459,7 +455,7 @@ static int init_converted_samples(uint8_t ***converted_input_samples,
/* Allocate memory for the samples of all channels in one consecutive /* Allocate memory for the samples of all channels in one consecutive
* block for convenience. */ * block for convenience. */
if ((error = av_samples_alloc(*converted_input_samples, NULL, if ((error = av_samples_alloc(*converted_input_samples, NULL,
output_codec_context->channels, output_codec_context->ch_layout.nb_channels,
frame_size, frame_size,
output_codec_context->sample_fmt, 0)) < 0) { output_codec_context->sample_fmt, 0)) < 0) {
fprintf(stderr, fprintf(stderr,
@@ -633,7 +629,7 @@ static int init_output_frame(AVFrame **frame,
* Default channel layouts based on the number of channels * Default channel layouts based on the number of channels
* are assumed for simplicity. */ * are assumed for simplicity. */
(*frame)->nb_samples = frame_size; (*frame)->nb_samples = frame_size;
(*frame)->channel_layout = output_codec_context->channel_layout; av_channel_layout_copy(&(*frame)->ch_layout, &output_codec_context->ch_layout);
(*frame)->format = output_codec_context->sample_fmt; (*frame)->format = output_codec_context->sample_fmt;
(*frame)->sample_rate = output_codec_context->sample_rate; (*frame)->sample_rate = output_codec_context->sample_rate;

22
doc/examples/transcoding.c
View File

@@ -175,8 +175,9 @@ static int open_output_file(const char *filename)
enc_ctx->time_base = av_inv_q(dec_ctx->framerate); enc_ctx->time_base = av_inv_q(dec_ctx->framerate);
} else { } else {
enc_ctx->sample_rate = dec_ctx->sample_rate; enc_ctx->sample_rate = dec_ctx->sample_rate;
enc_ctx->channel_layout = dec_ctx->channel_layout; ret = av_channel_layout_copy(&enc_ctx->ch_layout, &dec_ctx->ch_layout);
enc_ctx->channels = av_get_channel_layout_nb_channels(enc_ctx->channel_layout); if (ret < 0)
return ret;
/* take first format from list of supported formats */ /* take first format from list of supported formats */
enc_ctx->sample_fmt = encoder->sample_fmts[0]; enc_ctx->sample_fmt = encoder->sample_fmts[0];
enc_ctx->time_base = (AVRational){1, enc_ctx->sample_rate}; enc_ctx->time_base = (AVRational){1, enc_ctx->sample_rate};
@@ -289,6 +290,7 @@ static int init_filter(FilteringContext* fctx, AVCodecContext *dec_ctx,
goto end; goto end;
} }
} else if (dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) { } else if (dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
char buf[64];
buffersrc = avfilter_get_by_name("abuffer"); buffersrc = avfilter_get_by_name("abuffer");
buffersink = avfilter_get_by_name("abuffersink"); buffersink = avfilter_get_by_name("abuffersink");
if (!buffersrc || !buffersink) { if (!buffersrc || !buffersink) {
@@ -297,14 +299,14 @@ static int init_filter(FilteringContext* fctx, AVCodecContext *dec_ctx,
goto end; goto end;
} }
if (!dec_ctx->channel_layout) if (dec_ctx->ch_layout.order == AV_CHANNEL_ORDER_UNSPEC)
dec_ctx->channel_layout = av_channel_layout_default(&dec_ctx->ch_layout, dec_ctx->ch_layout.nb_channels);
av_get_default_channel_layout(dec_ctx->channels); av_channel_layout_describe(&dec_ctx->ch_layout, buf, sizeof(buf));
snprintf(args, sizeof(args), snprintf(args, sizeof(args),
"time_base=%d/%d:sample_rate=%d:sample_fmt=%s:channel_layout=0x%"PRIx64, "time_base=%d/%d:sample_rate=%d:sample_fmt=%s:channel_layout=%s",
dec_ctx->time_base.num, dec_ctx->time_base.den, dec_ctx->sample_rate, dec_ctx->time_base.num, dec_ctx->time_base.den, dec_ctx->sample_rate,
av_get_sample_fmt_name(dec_ctx->sample_fmt), av_get_sample_fmt_name(dec_ctx->sample_fmt),
dec_ctx->channel_layout); buf);
ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in", ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",
args, NULL, filter_graph); args, NULL, filter_graph);
if (ret < 0) { if (ret < 0) {
@@ -327,9 +329,9 @@ static int init_filter(FilteringContext* fctx, AVCodecContext *dec_ctx,
goto end; goto end;
} }
ret = av_opt_set_bin(buffersink_ctx, "channel_layouts", av_channel_layout_describe(&enc_ctx->ch_layout, buf, sizeof(buf));
(uint8_t*)&enc_ctx->channel_layout, ret = av_opt_set(buffersink_ctx, "ch_layouts",
sizeof(enc_ctx->channel_layout), AV_OPT_SEARCH_CHILDREN); buf, AV_OPT_SEARCH_CHILDREN);
if (ret < 0) { if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot set output channel layout\n"); av_log(NULL, AV_LOG_ERROR, "Cannot set output channel layout\n");
goto end; goto end;