/**

• @file
• Simple audio converter
• @example transcode_aac.c
• Convert an input audio file to AAC in an MP4 container using FFmpeg.
• Formats other than MP4 are supported based on the output file extension.
• @author Andreas Unterweger (dustsigns@gmail.com)
  */

include <stdio.h>

include "libavformat/avformat.h"

include "libavformat/avio.h"

include "libavcodec/avcodec.h"

include "libavutil/audio_fifo.h"

include "libavutil/avassert.h"

include "libavutil/avstring.h"

include "libavutil/frame.h"

include "libavutil/opt.h"

include "libswresample/swresample.h"

/* The output bit rate in bit/s */

define OUTPUT_BIT_RATE 96000

/* The number of output channels */

define OUTPUT_CHANNELS 2

/**

• Open an input file and the required decoder.

• @param filename File to be opened

• @param[out] input_format_context Format context of opened file

• @param[out] input_codec_context Codec context of opened file

• @return Error code (0 if successful)
  */
  static int open_input_file(const char *filename,
  AVFormatContext **input_format_context,
  AVCodecContext **input_codec_context) {
  AVCodecContext *avctx;
  AVCodec input_codec;
  int error;
  //初始化输入格式上下文
  / Open the input file to read from it. */
  if ((error = avformat_open_input(input_format_context, filename, NULL,
  NULL)) < 0) {
  fprintf(stderr, "Could not open input file '%s' (error '%s')\n",
  filename, av_err2str(error));
  input_format_context = NULL;
  return error;
  }
  //找到流信息
  / Get information on the input file (number of streams etc.). /
  if ((error = avformat_find_stream_info(input_format_context, NULL)) < 0) {
  fprintf(stderr, "Could not open find stream info (error '%s')\n",
  av_err2str(error));
  avformat_close_input(input_format_context);
  return error;
  }

  /* Make sure that there is only one stream in the input file. /
  if ((input_format_context)->nb_streams != 1) {
  fprintf(stderr, "Expected one audio input stream, but found %d\n",
  (input_format_context)->nb_streams);
  avformat_close_input(input_format_context);
  return AVERROR_EXIT;
  }
  //找到输入流的解码器,根据解码参数
  / Find a decoder for the audio stream. /
  if (!(input_codec = avcodec_find_decoder(
  (input_format_context)->streams[0]->codecpar->codec_id))) {
  fprintf(stderr, "Could not find input codec\n");
  avformat_close_input(input_format_context);
  return AVERROR_EXIT;
  }
  //分配解码器上下文
  /* Allocate a new decoding context. /
  avctx = avcodec_alloc_context3(input_codec);
  if (!avctx) {
  fprintf(stderr, "Could not allocate a decoding context\n");
  avformat_close_input(input_format_context);
  return AVERROR(ENOMEM);
  }
  //拷贝输入格式中的参数到解码器上下文中
  / Initialize the stream parameters with demuxer information. /
  error = avcodec_parameters_to_context(avctx, (input_format_context)->streams[0]->codecpar);
  if (error < 0) {
  avformat_close_input(input_format_context);
  avcodec_free_context(&avctx);
  return error;
  }
  //打开解码器上下文
  /* Open the decoder for the audio stream to use it later. */
  if ((error = avcodec_open2(avctx, input_codec, NULL)) < 0) {
  fprintf(stderr, "Could not open input codec (error '%s')\n",
  av_err2str(error));
  avcodec_free_context(&avctx);
  avformat_close_input(input_format_context);
  return error;
  }

  /* Save the decoder context for easier access later. */
  *input_codec_context = avctx;

  return 0;
  }

/**

• 打开输出文件,初始化编码器上下文

• Open an output file and the required encoder.

• Also set some basic encoder parameters.

• Some of these parameters are based on the input file's parameters.

• @param filename File to be opened

• @param input_codec_context Codec context of input file

• @param[out] output_format_context Format context of output file

• @param[out] output_codec_context Codec context of output file

• @return Error code (0 if successful)
  */
  static int open_output_file(const char *filename,
  AVCodecContext *input_codec_context,
  AVFormatContext **output_format_context,
  AVCodecContext output_codec_context) {
  AVCodecContext avctx = NULL;
  AVIOContext output_io_context = NULL;
  AVStream stream = NULL;
  AVCodec output_codec = NULL;
  int error;
  //打开输出文件.创建io上下文
  / Open the output file to write to it. /
  if ((error = avio_open(&output_io_context, filename,
  AVIO_FLAG_WRITE)) < 0) {
  fprintf(stderr, "Could not open output file '%s' (error '%s')\n",
  filename, av_err2str(error));
  return error;
  }
  //输出格式上下文,分配控件
  / Create a new format context for the output container format. /
  if (!(output_format_context = avformat_alloc_context())) {
  fprintf(stderr, "Could not allocate output format context\n");
  return AVERROR(ENOMEM);
  }
  //保存输出io上下文
  / Associate the output file (pointer) with the container format context. /
  (output_format_context)->pb = output_io_context;
  //根据文件名猜猜输出格式
  / Guess the desired container format based on the file extension. /
  if (!((output_format_context)->oformat = av_guess_format(NULL, filename,
  NULL))) {
  fprintf(stderr, "Could not find output file format\n");
  goto cleanup;
  }
  //保存文件名
  if (!((output_format_context)->url = av_strdup(filename))) {
  fprintf(stderr, "Could not allocate url.\n");
  error = AVERROR(ENOMEM);
  goto cleanup;
  }
  //找到指定编码器
  / Find the encoder to be used by its name. /
  if (!(output_codec = avcodec_find_encoder(AV_CODEC_ID_AAC))) {
  fprintf(stderr, "Could not find an AAC encoder.\n");
  goto cleanup;
  }
  //从输出格式中创建 输出流
  / Create a new audio stream in the output file container. /
  if (!(stream = avformat_new_stream(output_format_context, NULL))) {
  fprintf(stderr, "Could not create new stream\n");
  error = AVERROR(ENOMEM);
  goto cleanup;
  }
  //用编码器初始化输出编码器上下文
  avctx = avcodec_alloc_context3(output_codec);
  if (!avctx) {
  fprintf(stderr, "Could not allocate an encoding context\n");
  error = AVERROR(ENOMEM);
  goto cleanup;
  }
  //填充输出上下文的参数,这里看到,输出的编码器上下文参数是自己指定的,而输入的解码器的参数则来自文件的流中的参数
  / Set the basic encoder parameters.

  • The input file's sample rate is used to avoid a sample rate conversion. */
    avctx->channels = OUTPUT_CHANNELS;
    avctx->channel_layout = av_get_default_channel_layout(OUTPUT_CHANNELS);
    avctx->sample_rate = input_codec_context->sample_rate;
    avctx->sample_fmt = output_codec->sample_fmts[0];
    avctx->bit_rate = OUTPUT_BIT_RATE;

  /* Allow the use of the experimental AAC encoder. */
  avctx->strict_std_compliance = FF_COMPLIANCE_EXPERIMENTAL;

  /* Set the sample rate for the container. */
  stream->time_base.den = input_codec_context->sample_rate;
  stream->time_base.num = 1;

  /* Some container formats (like MP4) require global headers to be present.

  • Mark the encoder so that it behaves accordingly. /
    if ((output_format_context)->oformat->flags & AVFMT_GLOBALHEADER)
    avctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;

  /* Open the encoder for the audio stream to use it later. */
  //在用输出的编码器打开输出编码器上下文的参数
  if ((error = avcodec_open2(avctx, output_codec, NULL)) < 0) {
  fprintf(stderr, "Could not open output codec (error '%s')\n",
  av_err2str(error));
  goto cleanup;
  }
  // 用编码器上下文的参数填充输出流参数
  error = avcodec_parameters_from_context(stream->codecpar, avctx);
  if (error < 0) {
  fprintf(stderr, "Could not initialize stream parameters\n");
  goto cleanup;
  }

  /* Save the encoder context for easier access later. */
  *output_codec_context = avctx;

  return 0;

  cleanup:
  avcodec_free_context(&avctx);
  avio_closep(&(output_format_context)->pb);
  avformat_free_context(output_format_context);
  *output_format_context = NULL;
  return error < 0 ? error : AVERROR_EXIT;
  }

/**

• Initialize one data packet for reading or writing.
• @param packet Packet to be initialized
  */
  static void init_packet(AVPacket packet) {
  av_init_packet(packet);
  / Set the packet data and size so that it is recognized as being empty. */
  packet->data = NULL;
  packet->size = 0;
  }

/**

• 初始化一个帧
• Initialize one audio frame for reading from the input file.
• @param[out] frame Frame to be initialized
• @return Error code (0 if successful)
  */
  static int init_input_frame(AVFrame *frame) {
  if (!(frame = av_frame_alloc())) {
  fprintf(stderr, "Could not allocate input frame\n");
  return AVERROR(ENOMEM);
  }
  return 0;
  }

/**

• 用输入输出的编解码上下文来生产转换上下文

• Initialize the audio resampler based on the input and output codec settings.

• If the input and output sample formats differ, a conversion is required

• libswresample takes care of this, but requires initialization.

• @param input_codec_context Codec context of the input file

• @param output_codec_context Codec context of the output file

• @param[out] resample_context Resample context for the required conversion

• @return Error code (0 if successful)
  */
  static int init_resampler(AVCodecContext *input_codec_context,
  AVCodecContext *output_codec_context,
  SwrContext **resample_context) {
  int error;

  /*

  • Create a resampler context for the conversion.
  • Set the conversion parameters.
  • Default channel layouts based on the number of channels
  • are assumed for simplicity (they are sometimes not detected
  • properly by the demuxer and/or decoder).
    /
    //根据输出输入的编解码器来分配 转换上下文的参数
    resample_context = swr_alloc_set_opts(NULL,
    av_get_default_channel_layout(
    output_codec_context->channels),
    output_codec_context->sample_fmt,
    output_codec_context->sample_rate,
    av_get_default_channel_layout(
    input_codec_context->channels),
    input_codec_context->sample_fmt,
    input_codec_context->sample_rate,
    0, NULL);
    if (!resample_context) {
    fprintf(stderr, "Could not allocate resample context\n");
    return AVERROR(ENOMEM);
    }
    /
  • Perform a sanity check so that the number of converted samples is
  • not greater than the number of samples to be converted.
  • If the sample rates differ, this case has to be handled differently
    */
    av_assert0(output_codec_context->sample_rate == input_codec_context->sample_rate);

  /* Open the resampler with the specified parameters. /
  //参数设置完成了. 然后初始化上下文
  if ((error = swr_init(resample_context)) < 0) {
  fprintf(stderr, "Could not open resample context\n");
  swr_free(resample_context);
  return error;
  }
  return 0;
  }

/**

• 初始化一个先进先出的缓冲区,针对输出格式的大小
• Initialize a FIFO buffer for the audio samples to be encoded.
• @param[out] fifo Sample buffer
• @param output_codec_context Codec context of the output file
• @return Error code (0 if successful)
  */
  static int init_fifo(AVAudioFifo **fifo, AVCodecContext output_codec_context) {
  / Create the FIFO buffer based on the specified output sample format. /
  //根据输出参数返回创建一个先进先出的缓存
  if (!(fifo = av_audio_fifo_alloc(output_codec_context->sample_fmt,
  output_codec_context->channels, 1))) {
  fprintf(stderr, "Could not allocate FIFO\n");
  return AVERROR(ENOMEM);
  }
  return 0;
  }

/**

• 写出输出文件的头信息
• Write the header of the output file container.
• @param output_format_context Format context of the output file
• @return Error code (0 if successful)
  */
  static int write_output_file_header(AVFormatContext *output_format_context) {
  int error;
  if ((error = avformat_write_header(output_format_context, NULL)) < 0) {
  fprintf(stderr, "Could not write output file header (error '%s')\n",
  av_err2str(error));
  return error;
  }
  return 0;
  }

/**

• Decode one audio frame from the input file.

• @param frame Audio frame to be decoded

• @param input_format_context Format context of the input file

• @param input_codec_context Codec context of the input file

• @param[out] data_present Indicates whether data has been decoded

• @param[out] finished Indicates whether the end of file has

•                              been reached and all data has been
  

•                              decoded. If this flag is false, there
  

•                              is more data to be decoded, i.e., this
  

•                              function has to be called again.
  

• @return Error code (0 if successful)

• 从输入文件中解码音频真
  */
  static int decode_audio_frame(AVFrame *frame,
  AVFormatContext *input_format_context,
  AVCodecContext *input_codec_context,
  int *data_present, int finished) {
  / Packet used for temporary storage. /
  AVPacket input_packet;
  int error;
  init_packet(&input_packet);
  //读取数据到packet中
  / Read one audio frame from the input file into a temporary packet. /
  if ((error = av_read_frame(input_format_context, &input_packet)) < 0) {
  / If we are at the end of the file, flush the decoder below. */
  if (error == AVERROR_EOF)
  finished = 1;
  else {
  fprintf(stderr, "Could not read frame (error '%s')\n",
  av_err2str(error));
  return error;
  }
  }
  //packet数据送入解码器
  / Send the audio frame stored in the temporary packet to the decoder.

  • The input audio stream decoder is used to do this. /
    if ((error = avcodec_send_packet(input_codec_context, &input_packet)) < 0) {
    fprintf(stderr, "Could not send packet for decoding (error '%s')\n",
    av_err2str(error));
    return error;
    }
    //获取解码后的frame
    / Receive one frame from the decoder. /
    error = avcodec_receive_frame(input_codec_context, frame);
    / If the decoder asks for more data to be able to decode a frame,
  • return indicating that no data is present. /
    if (error == AVERROR(EAGAIN)) {
    error = 0;
    goto cleanup;
    / If the end of the input file is reached, stop decoding. */
    } else if (error == AVERROR_EOF) {
    finished = 1;
    error = 0;
    goto cleanup;
    } else if (error < 0) {
    fprintf(stderr, "Could not decode frame (error '%s')\n",
    av_err2str(error));
    goto cleanup;
    / Default case: Return decoded data. */
    } else {
    *data_present = 1;
    goto cleanup;
    }

  cleanup:
  av_packet_unref(&input_packet);
  return error;
  }

/**

• 分配个临时用的存储区域,

• Initialize a temporary storage for the specified number of audio samples.

• The conversion requires temporary storage due to the different format.

• The number of audio samples to be allocated is specified in frame_size.

• @param[out] converted_input_samples Array of converted samples. The

•                                 dimensions are reference, channel
  

•                                 (for multi-channel audio), sample.
  

• @param output_codec_context Codec context of the output file

• @param frame_size Number of samples to be converted in

•                                 each round
  

• @return Error code (0 if successful)
  */
  static int init_converted_samples(uint8_t ***converted_input_samples,
  AVCodecContext *output_codec_context,
  int frame_size) {
  int error;

  /* Allocate as many pointers as there are audio channels.

  • Each pointer will later point to the audio samples of the corresponding
  • channels (although it may be NULL for interleaved formats).
    /
    if (!(converted_input_samples = calloc(output_codec_context->channels,
    sizeof(**converted_input_samples)))) {
    fprintf(stderr, "Could not allocate converted input sample pointers\n");
    return AVERROR(ENOMEM);
    }

  /* Allocate memory for the samples of all channels in one consecutive

  • block for convenience. /
    //给数组分配空间缓冲
    if ((error = av_samples_alloc(converted_input_samples, NULL,
    output_codec_context->channels,
    frame_size,
    output_codec_context->sample_fmt, 0)) < 0) {
    fprintf(stderr,
    "Could not allocate converted input samples (error '%s')\n",
    av_err2str(error));
    av_freep(&(converted_input_samples)[0]);
    free(converted_input_samples);
    return error;
    }
    return 0;
    }

/**

• 转换输入数据到输出数据,根据frame_size转换

• 数据从input_data 到 convert_data

• Convert the input audio samples into the output sample format.

• The conversion happens on a per-frame basis, the size of which is

• specified by frame_size.

• @param input_data Samples to be decoded. The dimensions are

•                          channel (for multi-channel audio), sample.
  

• @param[out] converted_data Converted samples. The dimensions are channel

•                          (for multi-channel audio), sample.
  

• @param frame_size Number of samples to be converted

• @param resample_context Resample context for the conversion

• @return Error code (0 if successful)
  */
  static int convert_samples(const uint8_t **input_data,
  uint8_t **converted_data, const int frame_size,
  SwrContext *resample_context) {
  int error;

  /* Convert the samples using the resampler. */
  if ((error = swr_convert(resample_context,
  converted_data, frame_size,
  input_data, frame_size)) < 0) {
  fprintf(stderr, "Could not convert input samples (error '%s')\n",
  av_err2str(error));
  return error;
  }

  return 0;
  }

/**

• 把转换后的数据写入到fifo 的缓冲区中

• Add converted input audio samples to the FIFO buffer for later processing.

• @param fifo Buffer to add the samples to

• @param converted_input_samples Samples to be added. The dimensions are channel

•                            (for multi-channel audio), sample.
  

• @param frame_size Number of samples to be converted

• @return Error code (0 if successful)
  */
  static int add_samples_to_fifo(AVAudioFifo *fifo,
  uint8_t **converted_input_samples,
  const int frame_size) {
  int error;

  /* Make the FIFO as large as it needs to be to hold both,

  • the old and the new samples. */
    //扩充fifo.保证数据能放下.
    if ((error = av_audio_fifo_realloc(fifo, av_audio_fifo_size(fifo) + frame_size)) < 0) {
    fprintf(stderr, "Could not reallocate FIFO\n");
    return error;
    }

  /* Store the new samples in the FIFO buffer. */
  //把输入存入 fifo中
  if (av_audio_fifo_write(fifo, (void **) converted_input_samples,
  frame_size) < frame_size) {
  fprintf(stderr, "Could not write data to FIFO\n");
  return AVERROR_EXIT;
  }
  return 0;
  }

/**

• Read one audio frame from the input file, decode, convert and store

• it in the FIFO buffer.

• @param fifo Buffer used for temporary storage

• @param input_format_context Format context of the input file

• @param input_codec_context Codec context of the input file

• @param output_codec_context Codec context of the output file

• @param resampler_context Resample context for the conversion

• @param[out] finished Indicates whether the end of file has

•                              been reached and all data has been
  

•                              decoded. If this flag is false,
  

•                              there is more data to be decoded,
  

•                              i.e., this function has to be called
  

•                              again.
  

• @return Error code (0 if successful)
  */
  //这里做了什么. 分配临时存储转换数据的空间,然后几码输入数据.获取帧,在把帧进行转换,转换完写入fifo缓冲区
  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) {
  / Temporary storage of the input samples of the frame read from the file. */
  AVFrame input_frame = NULL;
  / Temporary storage for the converted input samples. */
  uint8_t **converted_input_samples = NULL;
  int data_present = 0;
  int ret = AVERROR_EXIT;

  /* Initialize temporary storage for one input frame. /
  if (init_input_frame(&input_frame))//用来存放解码后的输入数据
  goto cleanup;
  / Decode one frame worth of audio samples. /
  //解码输入数据,获得输入帧.
  if (decode_audio_frame(input_frame, input_format_context,
  input_codec_context, &data_present, finished))
  goto cleanup;
  / If we are at the end of the file and there are no more samples

  • in the decoder which are delayed, we are actually finished.

  • This must not be treated as an error. /
    if (finished) {
    ret = 0;
    goto cleanup;
    }
    /* If there is decoded data, convert and store it. /
    if (data_present) {//这里表示已经有了解码后的帧数据,下边进行专门
    / Initialize the temporary storage for the converted input samples. */
    //根据输出参数获取用于接收转码数据的数组 ,为数组分配空间
    if (init_converted_samples(&converted_input_samples, output_codec_context,
    input_frame->nb_samples))
    goto cleanup;

    /* Convert the input samples to the desired output sample format.

    • This requires a temporary storage provided by converted_input_samples. */
      //转码音频数据inputFrame的数据.输出到 converted_input_samples中
      if (convert_samples((const uint8_t **) input_frame->extended_data, converted_input_samples,
      input_frame->nb_samples, resampler_context))
      goto cleanup;

    /* Add the converted input samples to the FIFO buffer for later processing. */
    //把转换后的数据写入到fifo 缓冲区中
    if (add_samples_to_fifo(fifo, converted_input_samples,
    input_frame->nb_samples))
    goto cleanup;
    ret = 0;
    }
    ret = 0;

  cleanup:
  if (converted_input_samples) {
  av_freep(&converted_input_samples[0]);
  free(converted_input_samples);
  }
  av_frame_free(&input_frame);

  return ret;
  }

/**

• 用输出文件的编解码器上下文初始化输出帧,分配内存

• Initialize one input frame for writing to the output file.

• The frame will be exactly frame_size samples large.

• @param[out] frame Frame to be initialized

• @param output_codec_context Codec context of the output file

• @param frame_size Size of the frame

• @return Error code (0 if successful)
  */
  static int init_output_frame(AVFrame **frame,
  AVCodecContext *output_codec_context,
  int frame_size) {
  int error;

  /* Create a new frame to store the audio samples. /
  if (!(frame = av_frame_alloc())) {
  fprintf(stderr, "Could not allocate output frame\n");
  return AVERROR_EXIT;
  }

  /* Set the frame's parameters, especially its size and format.

  • av_frame_get_buffer needs this to allocate memory for the
  • audio samples of the frame.
  • Default channel layouts based on the number of channels
  • are assumed for simplicity. /
    (frame)->nb_samples = frame_size;
    (frame)->channel_layout = output_codec_context->channel_layout;
    (frame)->format = output_codec_context->sample_fmt;
    (*frame)->sample_rate = output_codec_context->sample_rate;

  /* Allocate the samples of the created frame. This call will make

  • sure that the audio frame can hold as many samples as specified. /
    if ((error = av_frame_get_buffer(frame, 0)) < 0) {
    fprintf(stderr, "Could not allocate output frame samples (error '%s')\n",
    av_err2str(error));
    av_frame_free(frame);
    return error;
    }

  return 0;
  }

/* Global timestamp for the audio frames. */
static int64_t pts = 0;

/**

• 编码音频真,使用输出编码器,编码完后的数据,写出到输出格式上下文中

• Encode one frame worth of audio to the output file.

• @param frame Samples to be encoded

• @param output_format_context Format context of the output file

• @param output_codec_context Codec context of the output file

• @param[out] data_present Indicates whether data has been

•                               encoded
  

• @return Error code (0 if successful)
  */
  static int encode_audio_frame(AVFrame *frame,
  AVFormatContext *output_format_context,
  AVCodecContext *output_codec_context,
  int data_present) {
  / Packet used for temporary storage. */
  AVPacket output_packet;
  int error;
  //初始packet
  init_packet(&output_packet);

  /* Set a timestamp based on the sample rate for the container. */
  if (frame) {
  frame->pts = pts;
  pts += frame->nb_samples;
  }

  /* Send the audio frame stored in the temporary packet to the encoder.

  • The output audio stream encoder is used to do this. /
    //frame 送入编码器.
    error = avcodec_send_frame(output_codec_context, frame);
    / The encoder signals that it has nothing more to encode. /
    if (error == AVERROR_EOF) {
    error = 0;
    goto cleanup;
    } else if (error < 0) {
    fprintf(stderr, "Could not send packet for encoding (error '%s')\n",
    av_err2str(error));
    return error;
    }
    //取出编码后的数据
    / Receive one encoded frame from the encoder. /
    error = avcodec_receive_packet(output_codec_context, &output_packet);
    / If the encoder asks for more data to be able to provide an
  • encoded frame, return indicating that no data is present. /
    if (error == AVERROR(EAGAIN)) {
    error = 0;
    goto cleanup;
    / If the last frame has been encoded, stop encoding. /
    } else if (error == AVERROR_EOF) {
    error = 0;
    goto cleanup;
    } else if (error < 0) {
    fprintf(stderr, "Could not encode frame (error '%s')\n",
    av_err2str(error));
    goto cleanup;
    / Default case: Return encoded data. */
    } else {
    data_present = 1;
    }
    //把编码后的数据写出到输出文件中
    / Write one audio frame from the temporary packet to the output file. /
    if (data_present &&
    (error = av_write_frame(output_format_context, &output_packet)) < 0) {
    fprintf(stderr, "Could not write frame (error '%s')\n",
    av_err2str(error));
    goto cleanup;
    }

  cleanup:
  av_packet_unref(&output_packet);
  return error;
  }

/**

• Load one audio frame from the FIFO buffer, encode and write it to the

• output file.

• @param fifo Buffer used for temporary storage

• @param output_format_context Format context of the output file

• @param output_codec_context Codec context of the output file

• @return Error code (0 if successful)
  */
  //编码数据然后写出到文件中
  static int load_encode_and_write(AVAudioFifo *fifo,
  AVFormatContext *output_format_context,
  AVCodecContext output_codec_context) {
  / Temporary storage of the output samples of the frame written to the file. */
  AVFrame output_frame;
  / Use the maximum number of possible samples per frame.

  • If there is less than the maximum possible frame size in the FIFO
  • buffer use this number. Otherwise, use the maximum possible frame size. */
    const int frame_size = FFMIN(av_audio_fifo_size(fifo),
    output_codec_context->frame_size);
    int data_written;

  //初始化临时存储视频帧的结构
  /* Initialize temporary storage for one output frame. */
  if (init_output_frame(&output_frame, output_codec_context, frame_size))
  return AVERROR_EXIT;

  /* Read as many samples from the FIFO buffer as required to fill the frame.

  • The samples are stored in the frame temporarily. */
    //把数据从fifo 中读入output_frame中
    if (av_audio_fifo_read(fifo, (void **) output_frame->data, frame_size) < frame_size) {
    fprintf(stderr, "Could not read data from FIFO\n");
    av_frame_free(&output_frame);
    return AVERROR_EXIT;
    }

  /* Encode one frame worth of audio samples. */
  //数据编码器编码,然后把编码后的packet数据写出到文件中
  if (encode_audio_frame(output_frame, output_format_context,
  output_codec_context, &data_written)) {
  av_frame_free(&output_frame);
  return AVERROR_EXIT;
  }
  av_frame_free(&output_frame);
  return 0;
  }

/**

• 写出尾部数据
• Write the trailer of the output file container.
• @param output_format_context Format context of the output file
• @return Error code (0 if successful)
  */
  static int write_output_file_trailer(AVFormatContext *output_format_context) {
  int error;
  if ((error = av_write_trailer(output_format_context)) < 0) {
  fprintf(stderr, "Could not write output file trailer (error '%s')\n",
  av_err2str(error));
  return error;
  }
  return 0;
  }

/**

• 转换音频数据

• @param argc

• @param argv

• @return
  */
  int transcode_aac_main(int argc, char **argv) {
  AVFormatContext *input_format_context = NULL, *output_format_context = NULL;
  AVCodecContext *input_codec_context = NULL, *output_codec_context = NULL;
  SwrContext *resample_context = NULL;
  AVAudioFifo *fifo = NULL;
  int ret = AVERROR_EXIT;

  if (argc != 3) {
  fprintf(stderr, "Usage: %s <input file> <output file>\n", argv[0]);
  exit(1);
  }

  /* Open the input file for reading. /
  //打开输入文件格式 并初始化输入格式上下文
  if (open_input_file(argv[1], &input_format_context,
  &input_codec_context))
  goto cleanup;
  / Open the output file for writing. /
  //打开输出文件并初始输出编码器上下文和输出格式上下文
  if (open_output_file(argv[2], input_codec_context,
  &output_format_context, &output_codec_context))
  goto cleanup;
  / Initialize the resampler to be able to convert audio sample formats. /
  //初始化转换上下文
  if (init_resampler(input_codec_context, output_codec_context,
  &resample_context))
  goto cleanup;
  / Initialize the FIFO buffer to store audio samples to be encoded. /
  //创建输出buffer
  if (init_fifo(&fifo, output_codec_context))
  goto cleanup;
  / Write the header of the output file container. */
  //写出头信息
  if (write_output_file_header(output_format_context))
  goto cleanup;

  /* Loop as long as we have input samples to read or output samples

  • to write; abort as soon as we have neither. /
    //只要有输入的采样或者输出的采样.就循环,
    while (1) {
    / Use the encoder's desired frame size for processing. */
    const int output_frame_size = output_codec_context->frame_size;//每个通道的采样数
    int finished = 0;

    /* Make sure that there is one frame worth of samples in the FIFO

    • buffer so that the encoder can do its work.

    • Since the decoder's and the encoder's frame size may differ, we

    • need to FIFO buffer to store as many frames worth of input samples

    • that they make up at least one frame worth of output samples. /
      //用输出的最大帧数做控制,把数据从输入中取出放入输出中
      while (av_audio_fifo_size(fifo) < output_frame_size) {
      / Decode one frame worth of audio samples, convert it to the

      • output sample format and put it into the FIFO buffer. */
        //解码输入数据.进行转换,然后放入输出数据中, 类似生产者消费者
        if (read_decode_convert_and_store(fifo, input_format_context,
        input_codec_context,
        output_codec_context,
        resample_context, &finished))
        goto cleanup;

      /* If we are at the end of the input file, we continue

      • encoding the remaining audio samples to the output file. */
        if (finished)
        break;
        }

    /* If we have enough samples for the encoder, we encode them.

    • At the end of the file, we pass the remaining samples to
    • the encoder. /
      //如果样本数已经足够了.就写到文件中
      while (av_audio_fifo_size(fifo) >= output_frame_size ||
      (finished && av_audio_fifo_size(fifo) > 0))
      / Take one frame worth of audio samples from the FIFO buffer,
      • encode it and write it to the output file. */
        //编码数据.写出到文件中
        if (load_encode_and_write(fifo, output_format_context,
        output_codec_context))
        goto cleanup;

    /* If we are at the end of the input file and have encoded

    • all remaining samples, we can exit this loop and finish. /
      if (finished) {
      int data_written;
      / Flush the encoder as it may have delayed frames. */
      do {
      data_written = 0;
      //刷新编码器中的数据
      if (encode_audio_frame(NULL, output_format_context,
      output_codec_context, &data_written))
      goto cleanup;
      } while (data_written);
      break;
      }
      }

  //写出数据尾部
  /* Write the trailer of the output file container. */
  if (write_output_file_trailer(output_format_context))
  goto cleanup;
  ret = 0;

  cleanup:
  if (fifo)
  av_audio_fifo_free(fifo);
  swr_free(&resample_context);
  if (output_codec_context)
  avcodec_free_context(&output_codec_context);
  if (output_format_context) {
  avio_closep(&output_format_context->pb);
  avformat_free_context(output_format_context);
  }
  if (input_codec_context)
  avcodec_free_context(&input_codec_context);
  if (input_format_context)
  avformat_close_input(&input_format_context);

  return ret;
  }