FFmpeg
transcode_aac.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2013-2018 Andreas Unterweger
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 /**
22  * @file
23  * Simple audio converter
24  *
25  * @example transcode_aac.c
26  * Convert an input audio file to AAC in an MP4 container using FFmpeg.
27  * Formats other than MP4 are supported based on the output file extension.
28  * @author Andreas Unterweger (dustsigns@gmail.com)
29  */
30 
31 #include <stdio.h>
32 
33 #include "libavformat/avformat.h"
34 #include "libavformat/avio.h"
35 
36 #include "libavcodec/avcodec.h"
37 
38 #include "libavutil/audio_fifo.h"
39 #include "libavutil/avassert.h"
40 #include "libavutil/avstring.h"
41 #include "libavutil/frame.h"
42 #include "libavutil/opt.h"
43 
45 
46 /* The output bit rate in bit/s */
47 #define OUTPUT_BIT_RATE 96000
48 /* The number of output channels */
49 #define OUTPUT_CHANNELS 2
50 
51 /**
52  * Open an input file and the required decoder.
53  * @param filename File to be opened
54  * @param[out] input_format_context Format context of opened file
55  * @param[out] input_codec_context Codec context of opened file
56  * @return Error code (0 if successful)
57  */
58 static int open_input_file(const char *filename,
59  AVFormatContext **input_format_context,
60  AVCodecContext **input_codec_context)
61 {
62  AVCodecContext *avctx;
63  AVCodec *input_codec;
64  int error;
65 
66  /* Open the input file to read from it. */
67  if ((error = avformat_open_input(input_format_context, filename, NULL,
68  NULL)) < 0) {
69  fprintf(stderr, "Could not open input file '%s' (error '%s')\n",
70  filename, av_err2str(error));
71  *input_format_context = NULL;
72  return error;
73  }
74 
75  /* Get information on the input file (number of streams etc.). */
76  if ((error = avformat_find_stream_info(*input_format_context, NULL)) < 0) {
77  fprintf(stderr, "Could not open find stream info (error '%s')\n",
78  av_err2str(error));
79  avformat_close_input(input_format_context);
80  return error;
81  }
82 
83  /* Make sure that there is only one stream in the input file. */
84  if ((*input_format_context)->nb_streams != 1) {
85  fprintf(stderr, "Expected one audio input stream, but found %d\n",
86  (*input_format_context)->nb_streams);
87  avformat_close_input(input_format_context);
88  return AVERROR_EXIT;
89  }
90 
91  /* Find a decoder for the audio stream. */
92  if (!(input_codec = avcodec_find_decoder((*input_format_context)->streams[0]->codecpar->codec_id))) {
93  fprintf(stderr, "Could not find input codec\n");
94  avformat_close_input(input_format_context);
95  return AVERROR_EXIT;
96  }
97 
98  /* Allocate a new decoding context. */
99  avctx = avcodec_alloc_context3(input_codec);
100  if (!avctx) {
101  fprintf(stderr, "Could not allocate a decoding context\n");
102  avformat_close_input(input_format_context);
103  return AVERROR(ENOMEM);
104  }
105 
106  /* Initialize the stream parameters with demuxer information. */
107  error = avcodec_parameters_to_context(avctx, (*input_format_context)->streams[0]->codecpar);
108  if (error < 0) {
109  avformat_close_input(input_format_context);
110  avcodec_free_context(&avctx);
111  return error;
112  }
113 
114  /* Open the decoder for the audio stream to use it later. */
115  if ((error = avcodec_open2(avctx, input_codec, NULL)) < 0) {
116  fprintf(stderr, "Could not open input codec (error '%s')\n",
117  av_err2str(error));
118  avcodec_free_context(&avctx);
119  avformat_close_input(input_format_context);
120  return error;
121  }
122 
123  /* Save the decoder context for easier access later. */
124  *input_codec_context = avctx;
125 
126  return 0;
127 }
128 
129 /**
130  * Open an output file and the required encoder.
131  * Also set some basic encoder parameters.
132  * Some of these parameters are based on the input file's parameters.
133  * @param filename File to be opened
134  * @param input_codec_context Codec context of input file
135  * @param[out] output_format_context Format context of output file
136  * @param[out] output_codec_context Codec context of output file
137  * @return Error code (0 if successful)
138  */
139 static int open_output_file(const char *filename,
140  AVCodecContext *input_codec_context,
141  AVFormatContext **output_format_context,
142  AVCodecContext **output_codec_context)
143 {
144  AVCodecContext *avctx = NULL;
145  AVIOContext *output_io_context = NULL;
146  AVStream *stream = NULL;
147  AVCodec *output_codec = NULL;
148  int error;
149 
150  /* Open the output file to write to it. */
151  if ((error = avio_open(&output_io_context, filename,
152  AVIO_FLAG_WRITE)) < 0) {
153  fprintf(stderr, "Could not open output file '%s' (error '%s')\n",
154  filename, av_err2str(error));
155  return error;
156  }
157 
158  /* Create a new format context for the output container format. */
159  if (!(*output_format_context = avformat_alloc_context())) {
160  fprintf(stderr, "Could not allocate output format context\n");
161  return AVERROR(ENOMEM);
162  }
163 
164  /* Associate the output file (pointer) with the container format context. */
165  (*output_format_context)->pb = output_io_context;
166 
167  /* Guess the desired container format based on the file extension. */
168  if (!((*output_format_context)->oformat = av_guess_format(NULL, filename,
169  NULL))) {
170  fprintf(stderr, "Could not find output file format\n");
171  goto cleanup;
172  }
173 
174  if (!((*output_format_context)->url = av_strdup(filename))) {
175  fprintf(stderr, "Could not allocate url.\n");
176  error = AVERROR(ENOMEM);
177  goto cleanup;
178  }
179 
180  /* Find the encoder to be used by its name. */
181  if (!(output_codec = avcodec_find_encoder(AV_CODEC_ID_AAC))) {
182  fprintf(stderr, "Could not find an AAC encoder.\n");
183  goto cleanup;
184  }
185 
186  /* Create a new audio stream in the output file container. */
187  if (!(stream = avformat_new_stream(*output_format_context, NULL))) {
188  fprintf(stderr, "Could not create new stream\n");
189  error = AVERROR(ENOMEM);
190  goto cleanup;
191  }
192 
193  avctx = avcodec_alloc_context3(output_codec);
194  if (!avctx) {
195  fprintf(stderr, "Could not allocate an encoding context\n");
196  error = AVERROR(ENOMEM);
197  goto cleanup;
198  }
199 
200  /* Set the basic encoder parameters.
201  * The input file's sample rate is used to avoid a sample rate conversion. */
202  avctx->channels = OUTPUT_CHANNELS;
204  avctx->sample_rate = input_codec_context->sample_rate;
205  avctx->sample_fmt = output_codec->sample_fmts[0];
206  avctx->bit_rate = OUTPUT_BIT_RATE;
207 
208  /* Allow the use of the experimental AAC encoder. */
210 
211  /* Set the sample rate for the container. */
212  stream->time_base.den = input_codec_context->sample_rate;
213  stream->time_base.num = 1;
214 
215  /* Some container formats (like MP4) require global headers to be present.
216  * Mark the encoder so that it behaves accordingly. */
217  if ((*output_format_context)->oformat->flags & AVFMT_GLOBALHEADER)
219 
220  /* Open the encoder for the audio stream to use it later. */
221  if ((error = avcodec_open2(avctx, output_codec, NULL)) < 0) {
222  fprintf(stderr, "Could not open output codec (error '%s')\n",
223  av_err2str(error));
224  goto cleanup;
225  }
226 
228  if (error < 0) {
229  fprintf(stderr, "Could not initialize stream parameters\n");
230  goto cleanup;
231  }
232 
233  /* Save the encoder context for easier access later. */
234  *output_codec_context = avctx;
235 
236  return 0;
237 
238 cleanup:
239  avcodec_free_context(&avctx);
240  avio_closep(&(*output_format_context)->pb);
241  avformat_free_context(*output_format_context);
242  *output_format_context = NULL;
243  return error < 0 ? error : AVERROR_EXIT;
244 }
245 
246 /**
247  * Initialize one data packet for reading or writing.
248  * @param[out] packet Packet to be initialized
249  * @return Error code (0 if successful)
250  */
251 static int init_packet(AVPacket **packet)
252 {
253  if (!(*packet = av_packet_alloc())) {
254  fprintf(stderr, "Could not allocate packet\n");
255  return AVERROR(ENOMEM);
256  }
257  return 0;
258 }
259 
260 /**
261  * Initialize one audio frame for reading from the input file.
262  * @param[out] frame Frame to be initialized
263  * @return Error code (0 if successful)
264  */
266 {
267  if (!(*frame = av_frame_alloc())) {
268  fprintf(stderr, "Could not allocate input frame\n");
269  return AVERROR(ENOMEM);
270  }
271  return 0;
272 }
273 
274 /**
275  * Initialize the audio resampler based on the input and output codec settings.
276  * If the input and output sample formats differ, a conversion is required
277  * libswresample takes care of this, but requires initialization.
278  * @param input_codec_context Codec context of the input file
279  * @param output_codec_context Codec context of the output file
280  * @param[out] resample_context Resample context for the required conversion
281  * @return Error code (0 if successful)
282  */
283 static int init_resampler(AVCodecContext *input_codec_context,
284  AVCodecContext *output_codec_context,
285  SwrContext **resample_context)
286 {
287  int error;
288 
289  /*
290  * Create a resampler context for the conversion.
291  * Set the conversion parameters.
292  * Default channel layouts based on the number of channels
293  * are assumed for simplicity (they are sometimes not detected
294  * properly by the demuxer and/or decoder).
295  */
296  *resample_context = swr_alloc_set_opts(NULL,
297  av_get_default_channel_layout(output_codec_context->channels),
298  output_codec_context->sample_fmt,
299  output_codec_context->sample_rate,
300  av_get_default_channel_layout(input_codec_context->channels),
301  input_codec_context->sample_fmt,
302  input_codec_context->sample_rate,
303  0, NULL);
304  if (!*resample_context) {
305  fprintf(stderr, "Could not allocate resample context\n");
306  return AVERROR(ENOMEM);
307  }
308  /*
309  * Perform a sanity check so that the number of converted samples is
310  * not greater than the number of samples to be converted.
311  * If the sample rates differ, this case has to be handled differently
312  */
313  av_assert0(output_codec_context->sample_rate == input_codec_context->sample_rate);
314 
315  /* Open the resampler with the specified parameters. */
316  if ((error = swr_init(*resample_context)) < 0) {
317  fprintf(stderr, "Could not open resample context\n");
318  swr_free(resample_context);
319  return error;
320  }
321  return 0;
322 }
323 
324 /**
325  * Initialize a FIFO buffer for the audio samples to be encoded.
326  * @param[out] fifo Sample buffer
327  * @param output_codec_context Codec context of the output file
328  * @return Error code (0 if successful)
329  */
330 static int init_fifo(AVAudioFifo **fifo, AVCodecContext *output_codec_context)
331 {
332  /* Create the FIFO buffer based on the specified output sample format. */
333  if (!(*fifo = av_audio_fifo_alloc(output_codec_context->sample_fmt,
334  output_codec_context->channels, 1))) {
335  fprintf(stderr, "Could not allocate FIFO\n");
336  return AVERROR(ENOMEM);
337  }
338  return 0;
339 }
340 
341 /**
342  * Write the header of the output file container.
343  * @param output_format_context Format context of the output file
344  * @return Error code (0 if successful)
345  */
346 static int write_output_file_header(AVFormatContext *output_format_context)
347 {
348  int error;
349  if ((error = avformat_write_header(output_format_context, NULL)) < 0) {
350  fprintf(stderr, "Could not write output file header (error '%s')\n",
351  av_err2str(error));
352  return error;
353  }
354  return 0;
355 }
356 
357 /**
358  * Decode one audio frame from the input file.
359  * @param frame Audio frame to be decoded
360  * @param input_format_context Format context of the input file
361  * @param input_codec_context Codec context of the input file
362  * @param[out] data_present Indicates whether data has been decoded
363  * @param[out] finished Indicates whether the end of file has
364  * been reached and all data has been
365  * decoded. If this flag is false, there
366  * is more data to be decoded, i.e., this
367  * function has to be called again.
368  * @return Error code (0 if successful)
369  */
371  AVFormatContext *input_format_context,
372  AVCodecContext *input_codec_context,
373  int *data_present, int *finished)
374 {
375  /* Packet used for temporary storage. */
376  AVPacket *input_packet;
377  int error;
378 
379  error = init_packet(&input_packet);
380  if (error < 0)
381  return error;
382 
383  /* Read one audio frame from the input file into a temporary packet. */
384  if ((error = av_read_frame(input_format_context, input_packet)) < 0) {
385  /* If we are at the end of the file, flush the decoder below. */
386  if (error == AVERROR_EOF)
387  *finished = 1;
388  else {
389  fprintf(stderr, "Could not read frame (error '%s')\n",
390  av_err2str(error));
391  goto cleanup;
392  }
393  }
394 
395  /* Send the audio frame stored in the temporary packet to the decoder.
396  * The input audio stream decoder is used to do this. */
397  if ((error = avcodec_send_packet(input_codec_context, input_packet)) < 0) {
398  fprintf(stderr, "Could not send packet for decoding (error '%s')\n",
399  av_err2str(error));
400  goto cleanup;
401  }
402 
403  /* Receive one frame from the decoder. */
404  error = avcodec_receive_frame(input_codec_context, frame);
405  /* If the decoder asks for more data to be able to decode a frame,
406  * return indicating that no data is present. */
407  if (error == AVERROR(EAGAIN)) {
408  error = 0;
409  goto cleanup;
410  /* If the end of the input file is reached, stop decoding. */
411  } else if (error == AVERROR_EOF) {
412  *finished = 1;
413  error = 0;
414  goto cleanup;
415  } else if (error < 0) {
416  fprintf(stderr, "Could not decode frame (error '%s')\n",
417  av_err2str(error));
418  goto cleanup;
419  /* Default case: Return decoded data. */
420  } else {
421  *data_present = 1;
422  goto cleanup;
423  }
424 
425 cleanup:
426  av_packet_free(&input_packet);
427  return error;
428 }
429 
430 /**
431  * Initialize a temporary storage for the specified number of audio samples.
432  * The conversion requires temporary storage due to the different format.
433  * The number of audio samples to be allocated is specified in frame_size.
434  * @param[out] converted_input_samples Array of converted samples. The
435  * dimensions are reference, channel
436  * (for multi-channel audio), sample.
437  * @param output_codec_context Codec context of the output file
438  * @param frame_size Number of samples to be converted in
439  * each round
440  * @return Error code (0 if successful)
441  */
442 static int init_converted_samples(uint8_t ***converted_input_samples,
443  AVCodecContext *output_codec_context,
444  int frame_size)
445 {
446  int error;
447 
448  /* Allocate as many pointers as there are audio channels.
449  * Each pointer will later point to the audio samples of the corresponding
450  * channels (although it may be NULL for interleaved formats).
451  */
452  if (!(*converted_input_samples = calloc(output_codec_context->channels,
453  sizeof(**converted_input_samples)))) {
454  fprintf(stderr, "Could not allocate converted input sample pointers\n");
455  return AVERROR(ENOMEM);
456  }
457 
458  /* Allocate memory for the samples of all channels in one consecutive
459  * block for convenience. */
460  if ((error = av_samples_alloc(*converted_input_samples, NULL,
461  output_codec_context->channels,
462  frame_size,
463  output_codec_context->sample_fmt, 0)) < 0) {
464  fprintf(stderr,
465  "Could not allocate converted input samples (error '%s')\n",
466  av_err2str(error));
467  av_freep(&(*converted_input_samples)[0]);
468  free(*converted_input_samples);
469  return error;
470  }
471  return 0;
472 }
473 
474 /**
475  * Convert the input audio samples into the output sample format.
476  * The conversion happens on a per-frame basis, the size of which is
477  * specified by frame_size.
478  * @param input_data Samples to be decoded. The dimensions are
479  * channel (for multi-channel audio), sample.
480  * @param[out] converted_data Converted samples. The dimensions are channel
481  * (for multi-channel audio), sample.
482  * @param frame_size Number of samples to be converted
483  * @param resample_context Resample context for the conversion
484  * @return Error code (0 if successful)
485  */
486 static int convert_samples(const uint8_t **input_data,
487  uint8_t **converted_data, const int frame_size,
488  SwrContext *resample_context)
489 {
490  int error;
491 
492  /* Convert the samples using the resampler. */
493  if ((error = swr_convert(resample_context,
494  converted_data, frame_size,
495  input_data , frame_size)) < 0) {
496  fprintf(stderr, "Could not convert input samples (error '%s')\n",
497  av_err2str(error));
498  return error;
499  }
500 
501  return 0;
502 }
503 
504 /**
505  * Add converted input audio samples to the FIFO buffer for later processing.
506  * @param fifo Buffer to add the samples to
507  * @param converted_input_samples Samples to be added. The dimensions are channel
508  * (for multi-channel audio), sample.
509  * @param frame_size Number of samples to be converted
510  * @return Error code (0 if successful)
511  */
513  uint8_t **converted_input_samples,
514  const int frame_size)
515 {
516  int error;
517 
518  /* Make the FIFO as large as it needs to be to hold both,
519  * the old and the new samples. */
520  if ((error = av_audio_fifo_realloc(fifo, av_audio_fifo_size(fifo) + frame_size)) < 0) {
521  fprintf(stderr, "Could not reallocate FIFO\n");
522  return error;
523  }
524 
525  /* Store the new samples in the FIFO buffer. */
526  if (av_audio_fifo_write(fifo, (void **)converted_input_samples,
527  frame_size) < frame_size) {
528  fprintf(stderr, "Could not write data to FIFO\n");
529  return AVERROR_EXIT;
530  }
531  return 0;
532 }
533 
534 /**
535  * Read one audio frame from the input file, decode, convert and store
536  * it in the FIFO buffer.
537  * @param fifo Buffer used for temporary storage
538  * @param input_format_context Format context of the input file
539  * @param input_codec_context Codec context of the input file
540  * @param output_codec_context Codec context of the output file
541  * @param resampler_context Resample context for the conversion
542  * @param[out] finished Indicates whether the end of file has
543  * been reached and all data has been
544  * decoded. If this flag is false,
545  * there is more data to be decoded,
546  * i.e., this function has to be called
547  * again.
548  * @return Error code (0 if successful)
549  */
551  AVFormatContext *input_format_context,
552  AVCodecContext *input_codec_context,
553  AVCodecContext *output_codec_context,
554  SwrContext *resampler_context,
555  int *finished)
556 {
557  /* Temporary storage of the input samples of the frame read from the file. */
558  AVFrame *input_frame = NULL;
559  /* Temporary storage for the converted input samples. */
560  uint8_t **converted_input_samples = NULL;
561  int data_present = 0;
562  int ret = AVERROR_EXIT;
563 
564  /* Initialize temporary storage for one input frame. */
565  if (init_input_frame(&input_frame))
566  goto cleanup;
567  /* Decode one frame worth of audio samples. */
568  if (decode_audio_frame(input_frame, input_format_context,
569  input_codec_context, &data_present, finished))
570  goto cleanup;
571  /* If we are at the end of the file and there are no more samples
572  * in the decoder which are delayed, we are actually finished.
573  * This must not be treated as an error. */
574  if (*finished) {
575  ret = 0;
576  goto cleanup;
577  }
578  /* If there is decoded data, convert and store it. */
579  if (data_present) {
580  /* Initialize the temporary storage for the converted input samples. */
581  if (init_converted_samples(&converted_input_samples, output_codec_context,
582  input_frame->nb_samples))
583  goto cleanup;
584 
585  /* Convert the input samples to the desired output sample format.
586  * This requires a temporary storage provided by converted_input_samples. */
587  if (convert_samples((const uint8_t**)input_frame->extended_data, converted_input_samples,
588  input_frame->nb_samples, resampler_context))
589  goto cleanup;
590 
591  /* Add the converted input samples to the FIFO buffer for later processing. */
592  if (add_samples_to_fifo(fifo, converted_input_samples,
593  input_frame->nb_samples))
594  goto cleanup;
595  ret = 0;
596  }
597  ret = 0;
598 
599 cleanup:
600  if (converted_input_samples) {
601  av_freep(&converted_input_samples[0]);
602  free(converted_input_samples);
603  }
604  av_frame_free(&input_frame);
605 
606  return ret;
607 }
608 
609 /**
610  * Initialize one input frame for writing to the output file.
611  * The frame will be exactly frame_size samples large.
612  * @param[out] frame Frame to be initialized
613  * @param output_codec_context Codec context of the output file
614  * @param frame_size Size of the frame
615  * @return Error code (0 if successful)
616  */
618  AVCodecContext *output_codec_context,
619  int frame_size)
620 {
621  int error;
622 
623  /* Create a new frame to store the audio samples. */
624  if (!(*frame = av_frame_alloc())) {
625  fprintf(stderr, "Could not allocate output frame\n");
626  return AVERROR_EXIT;
627  }
628 
629  /* Set the frame's parameters, especially its size and format.
630  * av_frame_get_buffer needs this to allocate memory for the
631  * audio samples of the frame.
632  * Default channel layouts based on the number of channels
633  * are assumed for simplicity. */
634  (*frame)->nb_samples = frame_size;
635  (*frame)->channel_layout = output_codec_context->channel_layout;
636  (*frame)->format = output_codec_context->sample_fmt;
637  (*frame)->sample_rate = output_codec_context->sample_rate;
638 
639  /* Allocate the samples of the created frame. This call will make
640  * sure that the audio frame can hold as many samples as specified. */
641  if ((error = av_frame_get_buffer(*frame, 0)) < 0) {
642  fprintf(stderr, "Could not allocate output frame samples (error '%s')\n",
643  av_err2str(error));
645  return error;
646  }
647 
648  return 0;
649 }
650 
651 /* Global timestamp for the audio frames. */
652 static int64_t pts = 0;
653 
654 /**
655  * Encode one frame worth of audio to the output file.
656  * @param frame Samples to be encoded
657  * @param output_format_context Format context of the output file
658  * @param output_codec_context Codec context of the output file
659  * @param[out] data_present Indicates whether data has been
660  * encoded
661  * @return Error code (0 if successful)
662  */
664  AVFormatContext *output_format_context,
665  AVCodecContext *output_codec_context,
666  int *data_present)
667 {
668  /* Packet used for temporary storage. */
670  int error;
671 
673  if (error < 0)
674  return error;
675 
676  /* Set a timestamp based on the sample rate for the container. */
677  if (frame) {
678  frame->pts = pts;
679  pts += frame->nb_samples;
680  }
681 
682  /* Send the audio frame stored in the temporary packet to the encoder.
683  * The output audio stream encoder is used to do this. */
684  error = avcodec_send_frame(output_codec_context, frame);
685  /* The encoder signals that it has nothing more to encode. */
686  if (error == AVERROR_EOF) {
687  error = 0;
688  goto cleanup;
689  } else if (error < 0) {
690  fprintf(stderr, "Could not send packet for encoding (error '%s')\n",
691  av_err2str(error));
692  goto cleanup;
693  }
694 
695  /* Receive one encoded frame from the encoder. */
696  error = avcodec_receive_packet(output_codec_context, output_packet);
697  /* If the encoder asks for more data to be able to provide an
698  * encoded frame, return indicating that no data is present. */
699  if (error == AVERROR(EAGAIN)) {
700  error = 0;
701  goto cleanup;
702  /* If the last frame has been encoded, stop encoding. */
703  } else if (error == AVERROR_EOF) {
704  error = 0;
705  goto cleanup;
706  } else if (error < 0) {
707  fprintf(stderr, "Could not encode frame (error '%s')\n",
708  av_err2str(error));
709  goto cleanup;
710  /* Default case: Return encoded data. */
711  } else {
712  *data_present = 1;
713  }
714 
715  /* Write one audio frame from the temporary packet to the output file. */
716  if (*data_present &&
717  (error = av_write_frame(output_format_context, output_packet)) < 0) {
718  fprintf(stderr, "Could not write frame (error '%s')\n",
719  av_err2str(error));
720  goto cleanup;
721  }
722 
723 cleanup:
725  return error;
726 }
727 
728 /**
729  * Load one audio frame from the FIFO buffer, encode and write it to the
730  * output file.
731  * @param fifo Buffer used for temporary storage
732  * @param output_format_context Format context of the output file
733  * @param output_codec_context Codec context of the output file
734  * @return Error code (0 if successful)
735  */
737  AVFormatContext *output_format_context,
738  AVCodecContext *output_codec_context)
739 {
740  /* Temporary storage of the output samples of the frame written to the file. */
742  /* Use the maximum number of possible samples per frame.
743  * If there is less than the maximum possible frame size in the FIFO
744  * buffer use this number. Otherwise, use the maximum possible frame size. */
745  const int frame_size = FFMIN(av_audio_fifo_size(fifo),
746  output_codec_context->frame_size);
747  int data_written;
748 
749  /* Initialize temporary storage for one output frame. */
750  if (init_output_frame(&output_frame, output_codec_context, frame_size))
751  return AVERROR_EXIT;
752 
753  /* Read as many samples from the FIFO buffer as required to fill the frame.
754  * The samples are stored in the frame temporarily. */
755  if (av_audio_fifo_read(fifo, (void **)output_frame->data, frame_size) < frame_size) {
756  fprintf(stderr, "Could not read data from FIFO\n");
758  return AVERROR_EXIT;
759  }
760 
761  /* Encode one frame worth of audio samples. */
762  if (encode_audio_frame(output_frame, output_format_context,
763  output_codec_context, &data_written)) {
765  return AVERROR_EXIT;
766  }
768  return 0;
769 }
770 
771 /**
772  * Write the trailer of the output file container.
773  * @param output_format_context Format context of the output file
774  * @return Error code (0 if successful)
775  */
776 static int write_output_file_trailer(AVFormatContext *output_format_context)
777 {
778  int error;
779  if ((error = av_write_trailer(output_format_context)) < 0) {
780  fprintf(stderr, "Could not write output file trailer (error '%s')\n",
781  av_err2str(error));
782  return error;
783  }
784  return 0;
785 }
786 
787 int main(int argc, char **argv)
788 {
789  AVFormatContext *input_format_context = NULL, *output_format_context = NULL;
790  AVCodecContext *input_codec_context = NULL, *output_codec_context = NULL;
791  SwrContext *resample_context = NULL;
792  AVAudioFifo *fifo = NULL;
793  int ret = AVERROR_EXIT;
794 
795  if (argc != 3) {
796  fprintf(stderr, "Usage: %s <input file> <output file>\n", argv[0]);
797  exit(1);
798  }
799 
800  /* Open the input file for reading. */
801  if (open_input_file(argv[1], &input_format_context,
802  &input_codec_context))
803  goto cleanup;
804  /* Open the output file for writing. */
805  if (open_output_file(argv[2], input_codec_context,
806  &output_format_context, &output_codec_context))
807  goto cleanup;
808  /* Initialize the resampler to be able to convert audio sample formats. */
809  if (init_resampler(input_codec_context, output_codec_context,
810  &resample_context))
811  goto cleanup;
812  /* Initialize the FIFO buffer to store audio samples to be encoded. */
813  if (init_fifo(&fifo, output_codec_context))
814  goto cleanup;
815  /* Write the header of the output file container. */
816  if (write_output_file_header(output_format_context))
817  goto cleanup;
818 
819  /* Loop as long as we have input samples to read or output samples
820  * to write; abort as soon as we have neither. */
821  while (1) {
822  /* Use the encoder's desired frame size for processing. */
823  const int output_frame_size = output_codec_context->frame_size;
824  int finished = 0;
825 
826  /* Make sure that there is one frame worth of samples in the FIFO
827  * buffer so that the encoder can do its work.
828  * Since the decoder's and the encoder's frame size may differ, we
829  * need to FIFO buffer to store as many frames worth of input samples
830  * that they make up at least one frame worth of output samples. */
831  while (av_audio_fifo_size(fifo) < output_frame_size) {
832  /* Decode one frame worth of audio samples, convert it to the
833  * output sample format and put it into the FIFO buffer. */
834  if (read_decode_convert_and_store(fifo, input_format_context,
835  input_codec_context,
836  output_codec_context,
837  resample_context, &finished))
838  goto cleanup;
839 
840  /* If we are at the end of the input file, we continue
841  * encoding the remaining audio samples to the output file. */
842  if (finished)
843  break;
844  }
845 
846  /* If we have enough samples for the encoder, we encode them.
847  * At the end of the file, we pass the remaining samples to
848  * the encoder. */
849  while (av_audio_fifo_size(fifo) >= output_frame_size ||
850  (finished && av_audio_fifo_size(fifo) > 0))
851  /* Take one frame worth of audio samples from the FIFO buffer,
852  * encode it and write it to the output file. */
853  if (load_encode_and_write(fifo, output_format_context,
854  output_codec_context))
855  goto cleanup;
856 
857  /* If we are at the end of the input file and have encoded
858  * all remaining samples, we can exit this loop and finish. */
859  if (finished) {
860  int data_written;
861  /* Flush the encoder as it may have delayed frames. */
862  do {
863  data_written = 0;
864  if (encode_audio_frame(NULL, output_format_context,
865  output_codec_context, &data_written))
866  goto cleanup;
867  } while (data_written);
868  break;
869  }
870  }
871 
872  /* Write the trailer of the output file container. */
873  if (write_output_file_trailer(output_format_context))
874  goto cleanup;
875  ret = 0;
876 
877 cleanup:
878  if (fifo)
879  av_audio_fifo_free(fifo);
880  swr_free(&resample_context);
881  if (output_codec_context)
882  avcodec_free_context(&output_codec_context);
883  if (output_format_context) {
884  avio_closep(&output_format_context->pb);
885  avformat_free_context(output_format_context);
886  }
887  if (input_codec_context)
888  avcodec_free_context(&input_codec_context);
889  if (input_format_context)
890  avformat_close_input(&input_format_context);
891 
892  return ret;
893 }
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:30
av_audio_fifo_free
void av_audio_fifo_free(AVAudioFifo *af)
Free an AVAudioFifo.
Definition: audio_fifo.c:45
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1216
AVCodec
AVCodec.
Definition: codec.h:197
load_encode_and_write
static int load_encode_and_write(AVAudioFifo *fifo, AVFormatContext *output_format_context, AVCodecContext *output_codec_context)
Load one audio frame from the FIFO buffer, encode and write it to the output file.
Definition: transcode_aac.c:736
avcodec_receive_packet
int avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)
Read encoded data from the encoder.
Definition: encode.c:395
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4547
open_input_file
static int open_input_file(const char *filename, AVFormatContext **input_format_context, AVCodecContext **input_codec_context)
Open an input file and the required decoder.
Definition: transcode_aac.c:58
AVCodecContext::channel_layout
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1247
av_frame_get_buffer
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
Definition: frame.c:338
FF_COMPLIANCE_EXPERIMENTAL
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:1606
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1196
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:55
avcodec_parameters_from_context
int avcodec_parameters_from_context(AVCodecParameters *par, const AVCodecContext *codec)
Fill the parameters struct based on the values from the supplied codec context.
Definition: codec_par.c:90
av_audio_fifo_realloc
int av_audio_fifo_realloc(AVAudioFifo *af, int nb_samples)
Reallocate an AVAudioFifo.
Definition: audio_fifo.c:96
init_fifo
static int init_fifo(AVAudioFifo **fifo, AVCodecContext *output_codec_context)
Initialize a FIFO buffer for the audio samples to be encoded.
Definition: transcode_aac.c:330
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:204
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:324
cleanup
static av_cold void cleanup(FlashSV2Context *s)
Definition: flashsv2enc.c:127
write_output_file_header
static int write_output_file_header(AVFormatContext *output_format_context)
Write the header of the output file container.
Definition: transcode_aac.c:346
open_output_file
static int open_output_file(const char *filename, AVCodecContext *input_codec_context, AVFormatContext **output_format_context, AVCodecContext **output_codec_context)
Open an output file and the required encoder.
Definition: transcode_aac.c:139
av_read_frame
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
Definition: utils.c:1772
av_packet_free
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.c:75
AV_CODEC_FLAG_GLOBAL_HEADER
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:329
avformat_close_input
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: utils.c:4519
av_guess_format
ff_const59 AVOutputFormat * av_guess_format(const char *short_name, const char *filename, const char *mime_type)
Return the output format in the list of registered output formats which best matches the provided par...
Definition: format.c:51
AVAudioFifo
Context for an Audio FIFO Buffer.
Definition: audio_fifo.c:34
AVCodec::sample_fmts
enum AVSampleFormat * sample_fmts
array of supported sample formats, or NULL if unknown, array is terminated by -1
Definition: codec.h:220
av_samples_alloc
int av_samples_alloc(uint8_t **audio_data, int *linesize, int nb_channels, int nb_samples, enum AVSampleFormat sample_fmt, int align)
Allocate a samples buffer for nb_samples samples, and fill data pointers and linesize accordingly.
Definition: samplefmt.c:173
avcodec_find_encoder
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: allcodecs.c:941
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:616
pts
static int64_t pts
Definition: transcode_aac.c:652
AVRational::num
int num
Numerator.
Definition: rational.h:59
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:191
avassert.h
swr_init
av_cold int swr_init(struct SwrContext *s)
Initialize context after user parameters have been set.
Definition: swresample.c:152
avcodec_alloc_context3
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:170
av_audio_fifo_write
int av_audio_fifo_write(AVAudioFifo *af, void **data, int nb_samples)
Write data to an AVAudioFifo.
Definition: audio_fifo.c:112
add_samples_to_fifo
static int add_samples_to_fifo(AVAudioFifo *fifo, uint8_t **converted_input_samples, const int frame_size)
Add converted input audio samples to the FIFO buffer for later processing.
Definition: transcode_aac.c:512
frame_size
int frame_size
Definition: mxfenc.c:2206
decode_audio_frame
static int decode_audio_frame(AVFrame *frame, AVFormatContext *input_format_context, AVCodecContext *input_codec_context, int *data_present, int *finished)
Decode one audio frame from the input file.
Definition: transcode_aac.c:370
avcodec_receive_frame
int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder.
Definition: decode.c:643
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AVIO_FLAG_WRITE
#define AVIO_FLAG_WRITE
write-only
Definition: avio.h:675
swr_convert
int attribute_align_arg swr_convert(struct SwrContext *s, uint8_t *out_arg[SWR_CH_MAX], int out_count, const uint8_t *in_arg[SWR_CH_MAX], int in_count)
Definition: swresample.c:714
SwrContext
The libswresample context.
Definition: swresample_internal.h:95
swr_alloc_set_opts
struct SwrContext * swr_alloc_set_opts(struct SwrContext *s, int64_t out_ch_layout, enum AVSampleFormat out_sample_fmt, int out_sample_rate, int64_t in_ch_layout, enum AVSampleFormat in_sample_fmt, int in_sample_rate, int log_offset, void *log_ctx)
Allocate SwrContext if needed and set/reset common parameters.
Definition: swresample.c:59
avformat_write_header
av_warn_unused_result int avformat_write_header(AVFormatContext *s, AVDictionary **options)
Allocate the stream private data and write the stream header to an output media file.
Definition: mux.c:506
AVFormatContext
Format I/O context.
Definition: avformat.h:1231
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1038
AVStream::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avformat.h:902
NULL
#define NULL
Definition: coverity.c:32
avcodec_free_context
void avcodec_free_context(AVCodecContext **avctx)
Free the codec context and everything associated with it and write NULL to the provided pointer.
Definition: options.c:185
av_audio_fifo_alloc
AVAudioFifo * av_audio_fifo_alloc(enum AVSampleFormat sample_fmt, int channels, int nb_samples)
Allocate an AVAudioFifo.
Definition: audio_fifo.c:59
read_decode_convert_and_store
static int read_decode_convert_and_store(AVAudioFifo *fifo, AVFormatContext *input_format_context, AVCodecContext *input_codec_context, AVCodecContext *output_codec_context, SwrContext *resampler_context, int *finished)
Read one audio frame from the input file, decode, convert and store it in the FIFO buffer.
Definition: transcode_aac.c:550
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:586
OUTPUT_BIT_RATE
#define OUTPUT_BIT_RATE
Definition: transcode_aac.c:47
avcodec_open2
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: avcodec.c:142
av_write_frame
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
Write a packet to an output media file.
Definition: mux.c:1212
init_output_frame
static int init_output_frame(AVFrame **frame, AVCodecContext *output_codec_context, int frame_size)
Initialize one input frame for writing to the output file.
Definition: transcode_aac.c:617
swresample.h
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:426
init_input_frame
static int init_input_frame(AVFrame **frame)
Initialize one audio frame for reading from the input file.
Definition: transcode_aac.c:265
avformat_find_stream_info
int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
Read packets of a media file to get stream information.
Definition: utils.c:3650
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
avformat_alloc_context
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:211
av_err2str
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:119
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1204
encode_audio_frame
static int encode_audio_frame(AVFrame *frame, AVFormatContext *output_format_context, AVCodecContext *output_codec_context, int *data_present)
Encode one frame worth of audio to the output file.
Definition: transcode_aac.c:663
main
int main(int argc, char **argv)
Definition: transcode_aac.c:787
avio.h
swr_free
av_cold void swr_free(SwrContext **ss)
Free the given SwrContext and set the pointer to NULL.
Definition: swresample.c:137
init_packet
static int init_packet(AVPacket **packet)
Initialize one data packet for reading or writing.
Definition: transcode_aac.c:251
frame.h
OUTPUT_CHANNELS
#define OUTPUT_CHANNELS
Definition: transcode_aac.c:49
FFMIN
#define FFMIN(a, b)
Definition: common.h:105
output_frame
static int output_frame(H264Context *h, AVFrame *dst, H264Picture *srcp)
Definition: h264dec.c:824
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:64
av_audio_fifo_size
int av_audio_fifo_size(AVAudioFifo *af)
Get the current number of samples in the AVAudioFifo available for reading.
Definition: audio_fifo.c:228
init_resampler
static int init_resampler(AVCodecContext *input_codec_context, AVCodecContext *output_codec_context, SwrContext **resample_context)
Initialize the audio resampler based on the input and output codec settings.
Definition: transcode_aac.c:283
input_data
static void input_data(MLPEncodeContext *ctx, void *samples)
Wrapper function for inputting data in two different bit-depths.
Definition: mlpenc.c:1276
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:1197
avcodec_send_packet
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
Definition: decode.c:580
avio_closep
int avio_closep(AVIOContext **s)
Close the resource accessed by the AVIOContext *s, free it and set the pointer pointing to it to NULL...
Definition: aviobuf.c:1192
av_audio_fifo_read
int av_audio_fifo_read(AVAudioFifo *af, void **data, int nb_samples)
Read data from an AVAudioFifo.
Definition: audio_fifo.c:181
av_write_trailer
int av_write_trailer(AVFormatContext *s)
Write the stream trailer to an output media file and free the file private data.
Definition: mux.c:1274
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:390
AVFMT_GLOBALHEADER
#define AVFMT_GLOBALHEADER
Format wants global header.
Definition: avformat.h:461
avformat_open_input
int avformat_open_input(AVFormatContext **ps, const char *url, ff_const59 AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
Definition: utils.c:547
convert_samples
static int convert_samples(const uint8_t **input_data, uint8_t **converted_data, const int frame_size, SwrContext *resample_context)
Convert the input audio samples into the output sample format.
Definition: transcode_aac.c:486
avcodec_parameters_to_context
int avcodec_parameters_to_context(AVCodecContext *codec, const AVCodecParameters *par)
Fill the codec context based on the values from the supplied codec parameters.
Definition: codec_par.c:147
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:371
uint8_t
uint8_t
Definition: audio_convert.c:194
init_converted_samples
static int init_converted_samples(uint8_t ***converted_input_samples, AVCodecContext *output_codec_context, int frame_size)
Initialize a temporary storage for the specified number of audio samples.
Definition: transcode_aac.c:442
audio_fifo.h
avcodec_send_frame
int avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame)
Supply a raw video or audio frame to the encoder.
Definition: encode.c:364
avcodec.h
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:873
output_packet
static void output_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int eof)
Definition: ffmpeg.c:897
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
avcodec_find_decoder
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:946
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1601
avformat.h
AVCodecContext
main external API structure.
Definition: avcodec.h:536
AVRational::den
int den
Denominator.
Definition: rational.h:60
avformat_free_context
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: utils.c:4474
avio_open
int avio_open(AVIOContext **s, const char *url, int flags)
Create and initialize a AVIOContext for accessing the resource indicated by url.
Definition: aviobuf.c:1137
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:253
av_get_default_channel_layout
int64_t av_get_default_channel_layout(int nb_channels)
Return default channel layout for a given number of channels.
Definition: channel_layout.c:231
AVPacket
This structure stores compressed data.
Definition: packet.h:346
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVERROR_EXIT
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
Definition: error.h:56
avstring.h
write_output_file_trailer
static int write_output_file_trailer(AVFormatContext *output_format_context)
Write the trailer of the output file container.
Definition: transcode_aac.c:776