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 packet Packet to be initialized
249  */
250 static void init_packet(AVPacket *packet)
251 {
252  av_init_packet(packet);
253  /* Set the packet data and size so that it is recognized as being empty. */
254  packet->data = NULL;
255  packet->size = 0;
256 }
257 
258 /**
259  * Initialize one audio frame for reading from the input file.
260  * @param[out] frame Frame to be initialized
261  * @return Error code (0 if successful)
262  */
264 {
265  if (!(*frame = av_frame_alloc())) {
266  fprintf(stderr, "Could not allocate input frame\n");
267  return AVERROR(ENOMEM);
268  }
269  return 0;
270 }
271 
272 /**
273  * Initialize the audio resampler based on the input and output codec settings.
274  * If the input and output sample formats differ, a conversion is required
275  * libswresample takes care of this, but requires initialization.
276  * @param input_codec_context Codec context of the input file
277  * @param output_codec_context Codec context of the output file
278  * @param[out] resample_context Resample context for the required conversion
279  * @return Error code (0 if successful)
280  */
281 static int init_resampler(AVCodecContext *input_codec_context,
282  AVCodecContext *output_codec_context,
283  SwrContext **resample_context)
284 {
285  int error;
286 
287  /*
288  * Create a resampler context for the conversion.
289  * Set the conversion parameters.
290  * Default channel layouts based on the number of channels
291  * are assumed for simplicity (they are sometimes not detected
292  * properly by the demuxer and/or decoder).
293  */
294  *resample_context = swr_alloc_set_opts(NULL,
295  av_get_default_channel_layout(output_codec_context->channels),
296  output_codec_context->sample_fmt,
297  output_codec_context->sample_rate,
298  av_get_default_channel_layout(input_codec_context->channels),
299  input_codec_context->sample_fmt,
300  input_codec_context->sample_rate,
301  0, NULL);
302  if (!*resample_context) {
303  fprintf(stderr, "Could not allocate resample context\n");
304  return AVERROR(ENOMEM);
305  }
306  /*
307  * Perform a sanity check so that the number of converted samples is
308  * not greater than the number of samples to be converted.
309  * If the sample rates differ, this case has to be handled differently
310  */
311  av_assert0(output_codec_context->sample_rate == input_codec_context->sample_rate);
312 
313  /* Open the resampler with the specified parameters. */
314  if ((error = swr_init(*resample_context)) < 0) {
315  fprintf(stderr, "Could not open resample context\n");
316  swr_free(resample_context);
317  return error;
318  }
319  return 0;
320 }
321 
322 /**
323  * Initialize a FIFO buffer for the audio samples to be encoded.
324  * @param[out] fifo Sample buffer
325  * @param output_codec_context Codec context of the output file
326  * @return Error code (0 if successful)
327  */
328 static int init_fifo(AVAudioFifo **fifo, AVCodecContext *output_codec_context)
329 {
330  /* Create the FIFO buffer based on the specified output sample format. */
331  if (!(*fifo = av_audio_fifo_alloc(output_codec_context->sample_fmt,
332  output_codec_context->channels, 1))) {
333  fprintf(stderr, "Could not allocate FIFO\n");
334  return AVERROR(ENOMEM);
335  }
336  return 0;
337 }
338 
339 /**
340  * Write the header of the output file container.
341  * @param output_format_context Format context of the output file
342  * @return Error code (0 if successful)
343  */
344 static int write_output_file_header(AVFormatContext *output_format_context)
345 {
346  int error;
347  if ((error = avformat_write_header(output_format_context, NULL)) < 0) {
348  fprintf(stderr, "Could not write output file header (error '%s')\n",
349  av_err2str(error));
350  return error;
351  }
352  return 0;
353 }
354 
355 /**
356  * Decode one audio frame from the input file.
357  * @param frame Audio frame to be decoded
358  * @param input_format_context Format context of the input file
359  * @param input_codec_context Codec context of the input file
360  * @param[out] data_present Indicates whether data has been decoded
361  * @param[out] finished Indicates whether the end of file has
362  * been reached and all data has been
363  * decoded. If this flag is false, there
364  * is more data to be decoded, i.e., this
365  * function has to be called again.
366  * @return Error code (0 if successful)
367  */
369  AVFormatContext *input_format_context,
370  AVCodecContext *input_codec_context,
371  int *data_present, int *finished)
372 {
373  /* Packet used for temporary storage. */
374  AVPacket input_packet;
375  int error;
376  init_packet(&input_packet);
377 
378  /* Read one audio frame from the input file into a temporary packet. */
379  if ((error = av_read_frame(input_format_context, &input_packet)) < 0) {
380  /* If we are at the end of the file, flush the decoder below. */
381  if (error == AVERROR_EOF)
382  *finished = 1;
383  else {
384  fprintf(stderr, "Could not read frame (error '%s')\n",
385  av_err2str(error));
386  return error;
387  }
388  }
389 
390  /* Send the audio frame stored in the temporary packet to the decoder.
391  * The input audio stream decoder is used to do this. */
392  if ((error = avcodec_send_packet(input_codec_context, &input_packet)) < 0) {
393  fprintf(stderr, "Could not send packet for decoding (error '%s')\n",
394  av_err2str(error));
395  return error;
396  }
397 
398  /* Receive one frame from the decoder. */
399  error = avcodec_receive_frame(input_codec_context, frame);
400  /* If the decoder asks for more data to be able to decode a frame,
401  * return indicating that no data is present. */
402  if (error == AVERROR(EAGAIN)) {
403  error = 0;
404  goto cleanup;
405  /* If the end of the input file is reached, stop decoding. */
406  } else if (error == AVERROR_EOF) {
407  *finished = 1;
408  error = 0;
409  goto cleanup;
410  } else if (error < 0) {
411  fprintf(stderr, "Could not decode frame (error '%s')\n",
412  av_err2str(error));
413  goto cleanup;
414  /* Default case: Return decoded data. */
415  } else {
416  *data_present = 1;
417  goto cleanup;
418  }
419 
420 cleanup:
421  av_packet_unref(&input_packet);
422  return error;
423 }
424 
425 /**
426  * Initialize a temporary storage for the specified number of audio samples.
427  * The conversion requires temporary storage due to the different format.
428  * The number of audio samples to be allocated is specified in frame_size.
429  * @param[out] converted_input_samples Array of converted samples. The
430  * dimensions are reference, channel
431  * (for multi-channel audio), sample.
432  * @param output_codec_context Codec context of the output file
433  * @param frame_size Number of samples to be converted in
434  * each round
435  * @return Error code (0 if successful)
436  */
437 static int init_converted_samples(uint8_t ***converted_input_samples,
438  AVCodecContext *output_codec_context,
439  int frame_size)
440 {
441  int error;
442 
443  /* Allocate as many pointers as there are audio channels.
444  * Each pointer will later point to the audio samples of the corresponding
445  * channels (although it may be NULL for interleaved formats).
446  */
447  if (!(*converted_input_samples = calloc(output_codec_context->channels,
448  sizeof(**converted_input_samples)))) {
449  fprintf(stderr, "Could not allocate converted input sample pointers\n");
450  return AVERROR(ENOMEM);
451  }
452 
453  /* Allocate memory for the samples of all channels in one consecutive
454  * block for convenience. */
455  if ((error = av_samples_alloc(*converted_input_samples, NULL,
456  output_codec_context->channels,
457  frame_size,
458  output_codec_context->sample_fmt, 0)) < 0) {
459  fprintf(stderr,
460  "Could not allocate converted input samples (error '%s')\n",
461  av_err2str(error));
462  av_freep(&(*converted_input_samples)[0]);
463  free(*converted_input_samples);
464  return error;
465  }
466  return 0;
467 }
468 
469 /**
470  * Convert the input audio samples into the output sample format.
471  * The conversion happens on a per-frame basis, the size of which is
472  * specified by frame_size.
473  * @param input_data Samples to be decoded. The dimensions are
474  * channel (for multi-channel audio), sample.
475  * @param[out] converted_data Converted samples. The dimensions are channel
476  * (for multi-channel audio), sample.
477  * @param frame_size Number of samples to be converted
478  * @param resample_context Resample context for the conversion
479  * @return Error code (0 if successful)
480  */
481 static int convert_samples(const uint8_t **input_data,
482  uint8_t **converted_data, const int frame_size,
483  SwrContext *resample_context)
484 {
485  int error;
486 
487  /* Convert the samples using the resampler. */
488  if ((error = swr_convert(resample_context,
489  converted_data, frame_size,
490  input_data , frame_size)) < 0) {
491  fprintf(stderr, "Could not convert input samples (error '%s')\n",
492  av_err2str(error));
493  return error;
494  }
495 
496  return 0;
497 }
498 
499 /**
500  * Add converted input audio samples to the FIFO buffer for later processing.
501  * @param fifo Buffer to add the samples to
502  * @param converted_input_samples Samples to be added. The dimensions are channel
503  * (for multi-channel audio), sample.
504  * @param frame_size Number of samples to be converted
505  * @return Error code (0 if successful)
506  */
508  uint8_t **converted_input_samples,
509  const int frame_size)
510 {
511  int error;
512 
513  /* Make the FIFO as large as it needs to be to hold both,
514  * the old and the new samples. */
515  if ((error = av_audio_fifo_realloc(fifo, av_audio_fifo_size(fifo) + frame_size)) < 0) {
516  fprintf(stderr, "Could not reallocate FIFO\n");
517  return error;
518  }
519 
520  /* Store the new samples in the FIFO buffer. */
521  if (av_audio_fifo_write(fifo, (void **)converted_input_samples,
522  frame_size) < frame_size) {
523  fprintf(stderr, "Could not write data to FIFO\n");
524  return AVERROR_EXIT;
525  }
526  return 0;
527 }
528 
529 /**
530  * Read one audio frame from the input file, decode, convert and store
531  * it in the FIFO buffer.
532  * @param fifo Buffer used for temporary storage
533  * @param input_format_context Format context of the input file
534  * @param input_codec_context Codec context of the input file
535  * @param output_codec_context Codec context of the output file
536  * @param resampler_context Resample context for the conversion
537  * @param[out] finished Indicates whether the end of file has
538  * been reached and all data has been
539  * decoded. If this flag is false,
540  * there is more data to be decoded,
541  * i.e., this function has to be called
542  * again.
543  * @return Error code (0 if successful)
544  */
546  AVFormatContext *input_format_context,
547  AVCodecContext *input_codec_context,
548  AVCodecContext *output_codec_context,
549  SwrContext *resampler_context,
550  int *finished)
551 {
552  /* Temporary storage of the input samples of the frame read from the file. */
553  AVFrame *input_frame = NULL;
554  /* Temporary storage for the converted input samples. */
555  uint8_t **converted_input_samples = NULL;
556  int data_present = 0;
557  int ret = AVERROR_EXIT;
558 
559  /* Initialize temporary storage for one input frame. */
560  if (init_input_frame(&input_frame))
561  goto cleanup;
562  /* Decode one frame worth of audio samples. */
563  if (decode_audio_frame(input_frame, input_format_context,
564  input_codec_context, &data_present, finished))
565  goto cleanup;
566  /* If we are at the end of the file and there are no more samples
567  * in the decoder which are delayed, we are actually finished.
568  * This must not be treated as an error. */
569  if (*finished) {
570  ret = 0;
571  goto cleanup;
572  }
573  /* If there is decoded data, convert and store it. */
574  if (data_present) {
575  /* Initialize the temporary storage for the converted input samples. */
576  if (init_converted_samples(&converted_input_samples, output_codec_context,
577  input_frame->nb_samples))
578  goto cleanup;
579 
580  /* Convert the input samples to the desired output sample format.
581  * This requires a temporary storage provided by converted_input_samples. */
582  if (convert_samples((const uint8_t**)input_frame->extended_data, converted_input_samples,
583  input_frame->nb_samples, resampler_context))
584  goto cleanup;
585 
586  /* Add the converted input samples to the FIFO buffer for later processing. */
587  if (add_samples_to_fifo(fifo, converted_input_samples,
588  input_frame->nb_samples))
589  goto cleanup;
590  ret = 0;
591  }
592  ret = 0;
593 
594 cleanup:
595  if (converted_input_samples) {
596  av_freep(&converted_input_samples[0]);
597  free(converted_input_samples);
598  }
599  av_frame_free(&input_frame);
600 
601  return ret;
602 }
603 
604 /**
605  * Initialize one input frame for writing to the output file.
606  * The frame will be exactly frame_size samples large.
607  * @param[out] frame Frame to be initialized
608  * @param output_codec_context Codec context of the output file
609  * @param frame_size Size of the frame
610  * @return Error code (0 if successful)
611  */
613  AVCodecContext *output_codec_context,
614  int frame_size)
615 {
616  int error;
617 
618  /* Create a new frame to store the audio samples. */
619  if (!(*frame = av_frame_alloc())) {
620  fprintf(stderr, "Could not allocate output frame\n");
621  return AVERROR_EXIT;
622  }
623 
624  /* Set the frame's parameters, especially its size and format.
625  * av_frame_get_buffer needs this to allocate memory for the
626  * audio samples of the frame.
627  * Default channel layouts based on the number of channels
628  * are assumed for simplicity. */
629  (*frame)->nb_samples = frame_size;
630  (*frame)->channel_layout = output_codec_context->channel_layout;
631  (*frame)->format = output_codec_context->sample_fmt;
632  (*frame)->sample_rate = output_codec_context->sample_rate;
633 
634  /* Allocate the samples of the created frame. This call will make
635  * sure that the audio frame can hold as many samples as specified. */
636  if ((error = av_frame_get_buffer(*frame, 0)) < 0) {
637  fprintf(stderr, "Could not allocate output frame samples (error '%s')\n",
638  av_err2str(error));
640  return error;
641  }
642 
643  return 0;
644 }
645 
646 /* Global timestamp for the audio frames. */
647 static int64_t pts = 0;
648 
649 /**
650  * Encode one frame worth of audio to the output file.
651  * @param frame Samples to be encoded
652  * @param output_format_context Format context of the output file
653  * @param output_codec_context Codec context of the output file
654  * @param[out] data_present Indicates whether data has been
655  * encoded
656  * @return Error code (0 if successful)
657  */
659  AVFormatContext *output_format_context,
660  AVCodecContext *output_codec_context,
661  int *data_present)
662 {
663  /* Packet used for temporary storage. */
665  int error;
667 
668  /* Set a timestamp based on the sample rate for the container. */
669  if (frame) {
670  frame->pts = pts;
671  pts += frame->nb_samples;
672  }
673 
674  /* Send the audio frame stored in the temporary packet to the encoder.
675  * The output audio stream encoder is used to do this. */
676  error = avcodec_send_frame(output_codec_context, frame);
677  /* The encoder signals that it has nothing more to encode. */
678  if (error == AVERROR_EOF) {
679  error = 0;
680  goto cleanup;
681  } else if (error < 0) {
682  fprintf(stderr, "Could not send packet for encoding (error '%s')\n",
683  av_err2str(error));
684  return error;
685  }
686 
687  /* Receive one encoded frame from the encoder. */
688  error = avcodec_receive_packet(output_codec_context, &output_packet);
689  /* If the encoder asks for more data to be able to provide an
690  * encoded frame, return indicating that no data is present. */
691  if (error == AVERROR(EAGAIN)) {
692  error = 0;
693  goto cleanup;
694  /* If the last frame has been encoded, stop encoding. */
695  } else if (error == AVERROR_EOF) {
696  error = 0;
697  goto cleanup;
698  } else if (error < 0) {
699  fprintf(stderr, "Could not encode frame (error '%s')\n",
700  av_err2str(error));
701  goto cleanup;
702  /* Default case: Return encoded data. */
703  } else {
704  *data_present = 1;
705  }
706 
707  /* Write one audio frame from the temporary packet to the output file. */
708  if (*data_present &&
709  (error = av_write_frame(output_format_context, &output_packet)) < 0) {
710  fprintf(stderr, "Could not write frame (error '%s')\n",
711  av_err2str(error));
712  goto cleanup;
713  }
714 
715 cleanup:
717  return error;
718 }
719 
720 /**
721  * Load one audio frame from the FIFO buffer, encode and write it to the
722  * output file.
723  * @param fifo Buffer used for temporary storage
724  * @param output_format_context Format context of the output file
725  * @param output_codec_context Codec context of the output file
726  * @return Error code (0 if successful)
727  */
729  AVFormatContext *output_format_context,
730  AVCodecContext *output_codec_context)
731 {
732  /* Temporary storage of the output samples of the frame written to the file. */
734  /* Use the maximum number of possible samples per frame.
735  * If there is less than the maximum possible frame size in the FIFO
736  * buffer use this number. Otherwise, use the maximum possible frame size. */
737  const int frame_size = FFMIN(av_audio_fifo_size(fifo),
738  output_codec_context->frame_size);
739  int data_written;
740 
741  /* Initialize temporary storage for one output frame. */
742  if (init_output_frame(&output_frame, output_codec_context, frame_size))
743  return AVERROR_EXIT;
744 
745  /* Read as many samples from the FIFO buffer as required to fill the frame.
746  * The samples are stored in the frame temporarily. */
747  if (av_audio_fifo_read(fifo, (void **)output_frame->data, frame_size) < frame_size) {
748  fprintf(stderr, "Could not read data from FIFO\n");
750  return AVERROR_EXIT;
751  }
752 
753  /* Encode one frame worth of audio samples. */
754  if (encode_audio_frame(output_frame, output_format_context,
755  output_codec_context, &data_written)) {
757  return AVERROR_EXIT;
758  }
760  return 0;
761 }
762 
763 /**
764  * Write the trailer of the output file container.
765  * @param output_format_context Format context of the output file
766  * @return Error code (0 if successful)
767  */
768 static int write_output_file_trailer(AVFormatContext *output_format_context)
769 {
770  int error;
771  if ((error = av_write_trailer(output_format_context)) < 0) {
772  fprintf(stderr, "Could not write output file trailer (error '%s')\n",
773  av_err2str(error));
774  return error;
775  }
776  return 0;
777 }
778 
779 int main(int argc, char **argv)
780 {
781  AVFormatContext *input_format_context = NULL, *output_format_context = NULL;
782  AVCodecContext *input_codec_context = NULL, *output_codec_context = NULL;
783  SwrContext *resample_context = NULL;
784  AVAudioFifo *fifo = NULL;
785  int ret = AVERROR_EXIT;
786 
787  if (argc != 3) {
788  fprintf(stderr, "Usage: %s <input file> <output file>\n", argv[0]);
789  exit(1);
790  }
791 
792  /* Open the input file for reading. */
793  if (open_input_file(argv[1], &input_format_context,
794  &input_codec_context))
795  goto cleanup;
796  /* Open the output file for writing. */
797  if (open_output_file(argv[2], input_codec_context,
798  &output_format_context, &output_codec_context))
799  goto cleanup;
800  /* Initialize the resampler to be able to convert audio sample formats. */
801  if (init_resampler(input_codec_context, output_codec_context,
802  &resample_context))
803  goto cleanup;
804  /* Initialize the FIFO buffer to store audio samples to be encoded. */
805  if (init_fifo(&fifo, output_codec_context))
806  goto cleanup;
807  /* Write the header of the output file container. */
808  if (write_output_file_header(output_format_context))
809  goto cleanup;
810 
811  /* Loop as long as we have input samples to read or output samples
812  * to write; abort as soon as we have neither. */
813  while (1) {
814  /* Use the encoder's desired frame size for processing. */
815  const int output_frame_size = output_codec_context->frame_size;
816  int finished = 0;
817 
818  /* Make sure that there is one frame worth of samples in the FIFO
819  * buffer so that the encoder can do its work.
820  * Since the decoder's and the encoder's frame size may differ, we
821  * need to FIFO buffer to store as many frames worth of input samples
822  * that they make up at least one frame worth of output samples. */
823  while (av_audio_fifo_size(fifo) < output_frame_size) {
824  /* Decode one frame worth of audio samples, convert it to the
825  * output sample format and put it into the FIFO buffer. */
826  if (read_decode_convert_and_store(fifo, input_format_context,
827  input_codec_context,
828  output_codec_context,
829  resample_context, &finished))
830  goto cleanup;
831 
832  /* If we are at the end of the input file, we continue
833  * encoding the remaining audio samples to the output file. */
834  if (finished)
835  break;
836  }
837 
838  /* If we have enough samples for the encoder, we encode them.
839  * At the end of the file, we pass the remaining samples to
840  * the encoder. */
841  while (av_audio_fifo_size(fifo) >= output_frame_size ||
842  (finished && av_audio_fifo_size(fifo) > 0))
843  /* Take one frame worth of audio samples from the FIFO buffer,
844  * encode it and write it to the output file. */
845  if (load_encode_and_write(fifo, output_format_context,
846  output_codec_context))
847  goto cleanup;
848 
849  /* If we are at the end of the input file and have encoded
850  * all remaining samples, we can exit this loop and finish. */
851  if (finished) {
852  int data_written;
853  /* Flush the encoder as it may have delayed frames. */
854  do {
855  data_written = 0;
856  if (encode_audio_frame(NULL, output_format_context,
857  output_codec_context, &data_written))
858  goto cleanup;
859  } while (data_written);
860  break;
861  }
862  }
863 
864  /* Write the trailer of the output file container. */
865  if (write_output_file_trailer(output_format_context))
866  goto cleanup;
867  ret = 0;
868 
869 cleanup:
870  if (fifo)
871  av_audio_fifo_free(fifo);
872  swr_free(&resample_context);
873  if (output_codec_context)
874  avcodec_free_context(&output_codec_context);
875  if (output_format_context) {
876  avio_closep(&output_format_context->pb);
877  avformat_free_context(output_format_context);
878  }
879  if (input_codec_context)
880  avcodec_free_context(&input_codec_context);
881  if (input_format_context)
882  avformat_close_input(&input_format_context);
883 
884  return ret;
885 }
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:2245
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:599
AVCodec
AVCodec.
Definition: avcodec.h:3481
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:728
avcodec_receive_packet
int avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)
Read encoded data from the encoder.
Definition: encode.c:417
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:4480
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:2276
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:324
FF_COMPLIANCE_EXPERIMENTAL
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:2633
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:2225
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: utils.c:2098
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:328
avcodec_find_encoder
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: allcodecs.c:885
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
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:344
AVPacket::data
uint8_t * data
Definition: avcodec.h:1477
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:1785
AV_CODEC_FLAG_GLOBAL_HEADER
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:904
avformat_close_input
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: utils.c:4452
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: avcodec.h:3504
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
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1645
pts
static int64_t pts
Definition: transcode_aac.c:647
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:189
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:156
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:507
frame_size
int frame_size
Definition: mxfenc.c:2215
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:368
avcodec_receive_frame
int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder.
Definition: decode.c:740
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:655
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:508
AVFormatContext
Format I/O context.
Definition: avformat.h:1342
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1017
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:899
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:171
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:545
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1615
OUTPUT_BIT_RATE
#define OUTPUT_BIT_RATE
Definition: transcode_aac.c:47
avcodec_open2
int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: utils.c:565
av_write_frame
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
Write a packet to an output media file.
Definition: mux.c:878
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:612
swresample.h
error
static void error(const char *err)
Definition: target_dec_fuzzer.c:61
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: avcodec.h:566
init_input_frame
static int init_input_frame(AVFrame **frame)
Initialize one audio frame for reading from the input file.
Definition: transcode_aac.c:263
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:3588
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
AVPacket::size
int size
Definition: avcodec.h:1478
avformat_alloc_context
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:144
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:2233
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:658
main
int main(int argc, char **argv)
Definition: transcode_aac.c:779
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
frame.h
avcodec_find_decoder
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:890
OUTPUT_CHANNELS
#define OUTPUT_CHANNELS
Definition: transcode_aac.c:49
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
output_frame
static int output_frame(H264Context *h, AVFrame *dst, H264Picture *srcp)
Definition: h264dec.c:837
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:281
input_data
static void input_data(MLPEncodeContext *ctx, void *samples)
Wrapper function for inputting data in two different bit-depths.
Definition: mlpenc.c:1275
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:2226
avcodec_send_packet
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
Definition: decode.c:677
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:1210
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:1254
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:361
AVFMT_GLOBALHEADER
#define AVFMT_GLOBALHEADER
Format wants global header.
Definition: avformat.h:466
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:540
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:481
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: utils.c:2155
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:342
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:437
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:387
avcodec.h
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:870
output_packet
static void output_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int eof)
Definition: ffmpeg.c:847
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
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:2628
avformat.h
AVCodecContext
main external API structure.
Definition: avcodec.h:1565
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:4414
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:1153
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:251
init_packet
static void init_packet(AVPacket *packet)
Initialize one data packet for reading or writing.
Definition: transcode_aac.c:250
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:225
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1454
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:768
av_init_packet
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:33