ffmpeg的复习、学习、总结

最新推荐文章于 2024-05-06 08:43:08 发布
转载 最新推荐文章于 2024-05-06 08:43:08 发布 · 1k 阅读 · 1

本文通过FFmpeg的示例代码介绍了如何实现自定义缓冲区读取、元信息处理、音频重采样及编码等功能，为读者提供了一个深入理解FFmpeg工作原理的机会。
本文从ffmpeg的例程入手，记录下ffmpeg能做什么


点击(此处)折叠或打开

  1. //avio_reading.c
  2. #include <libavcodec/avcodec.h>
  3. #include <libavformat/avformat.h>
  4. #include <libavformat/avio.h>
  5. #include <libavutil/file.h>

  7. struct buffer_data {
  8.     uint8_t *ptr;
  9.     size_t size; ///< size left in the buffer
  10. };
  11. //读回调函数opaque=调用者传递的参数，buf=目的地址（要把数据保存到哪里）
  12. //buf_size=目的地址的长度，返回值表示读取多少字节的数据到目的地址
  13. static int read_packet(void *opaque, uint8_t *buf, int buf_size)
  14. {
  15.     struct buffer_data *bd = (struct buffer_data *)opaque;
  16.     buf_size = FFMIN(buf_size, bd->size);

  18.     printf("ptr:%p size:%zu\n", bd->ptr, bd->size);

  20.     /* copy internal buffer data to buf */
  21.     memcpy(buf, bd->ptr, buf_size);
  22.     bd->ptr += buf_size;
  23.     bd->size -= buf_size;

  25.     return buf_size;
  26. }

  28. int main(int argc, char *argv[])
  29. {
  30.     //格式上下文
  31.     AVFormatContext *fmt_ctx = NULL;
  32.     //io上下文
  33.     AVIOContext *avio_ctx = NULL;
  34.     uint8_t *buffer = NULL, *avio_ctx_buffer = NULL;
  35.     size_t buffer_size, avio_ctx_buffer_size = 4096;
  36.     char *input_filename = NULL;
  37.     int ret = 0;
  38.     struct buffer_data bd = { 0 };

  40.     if (argc != 2) {
  41.         fprintf(stderr, "usage: %s input_file\n"
  42.                 "API example program to show how to read from a custom buffer "
  43.                 "accessed through AVIOContext.\n", argv[0]);
  44.         return 1;
  45.     }
  46.     input_filename = argv[1];

  48.     /* register codecs and formats and other lavf/lavc components*/
  49.     av_register_all();

  51.     /* slurp file content into buffer */
  52.     //映射文件到内存中,不常用的函数
  53.     ret = av_file_map(input_filename, &buffer, &buffer_size, 0, NULL);
  54.     if (ret < 0)
  55.         goto end;

  57.     /* fill opaque structure used by the AVIOContext read callback */
  58.     bd.ptr = buffer;
  59.     bd.size = buffer_size;
  60.     
  61.     //申请格式上下文，如果没有申请，那么avformat_open_input会帮助申请（此时第二个参数不能为NULL）
  62.     //自己申请格式上下文还有个好处，就是可以指定这个格式上下文的io上下文（意味着我们可以使用自己的方式对文件进行读写，否则使用ffmpeg提供的方法）
  63.     if (!(fmt_ctx = avformat_alloc_context())) {
  64.         ret = AVERROR(ENOMEM);
  65.         goto end;
  66.     }

  68.     avio_ctx_buffer = av_malloc(avio_ctx_buffer_size);
  69.     if (!avio_ctx_buffer) {
  70.         ret = AVERROR(ENOMEM);
  71.         goto end;
  72.     }
  73.     //申请io上下文，avio_ctx_buffer=文件内容的内存首地址，avio_ctx_buffer_size=文件内容的长度
  74.     //0=写标志（1表示可写） bd=传给回调函数的参数 read_packet=读回调函数 NULL=写回调函数 NULL=跳到一个文件的特殊位置的函数
  75.     avio_ctx = avio_alloc_context(avio_ctx_buffer, avio_ctx_buffer_size,
  76.                                   0, &bd, &read_packet, NULL, NULL);
  77.     if (!avio_ctx) {
  78.         ret = AVERROR(ENOMEM);
  79.         goto end;
  80.     }
  81.     //格式上下文的pd变量指向io上下文（如果没有指定的话在avformat_open_input函数会指定默认的）
  82.     fmt_ctx->pb = avio_ctx;
  83.     //打开输入文件，填充格式上下文，&fmt_ctx=格式上下文的地址，NULL=文件名（如果文件名是空的话，必须自己指定格式上下文的io上下文）
  84.     //NULL=指定以某种方式打开文件（AVInputFormat *），NULL=参数（可以传递一些自己的参数进去，我没用过）（AVDictionary**）
  85.     ret = avformat_open_input(&fmt_ctx, NULL, NULL, NULL);
  86.     if (ret < 0) {
  87.         fprintf(stderr, "Could not open input\n");
  88.         goto end;
  89.     }
  90.     //查找流的信息fmt_ctx=格式上下文，NULL=参数（AVDictionary**）
  91.     ret = avformat_find_stream_info(fmt_ctx, NULL);
  92.     if (ret < 0) {
  93.         fprintf(stderr, "Could not find stream information\n");
  94.         goto end;
  95.     }
  96.     //dump文件信息 fmt_ctx=格式上下文 0=流的序号（填0就行），input_filename=文件名，也可以是一个连接
  97.     //0=Select whether the specified context is an input(0) or output(1)
  98.     av_dump_format(fmt_ctx, 0, input_filename, 0);

  100. end:
  101.     //关闭格式上下文，必须要关闭，不关闭可能会内存泄露&fmt_ctx = 格式上下文的地址
  102.     avformat_close_input(&fmt_ctx);
  103.     /* note: the internal buffer could have changed, and be != avio_ctx_buffer */
  104.     if (avio_ctx) {
  105.         av_freep(&avio_ctx->buffer);
  106.         av_freep(&avio_ctx);
  107.     }
  108.     //解除文件映射
  109.     av_file_unmap(buffer, buffer_size);

  111.     if (ret < 0) {
  112. // fprintf(stderr, "Error occurred: %s\n", av_err2str(ret));
  113.         return 1;
  114.     }

  116.     return 0;
  117. }
运行结果

这个例程像我们展示如何获取一个媒体文件的元信息，值得多看一眼的地方是，我们可以指定io上下文，这意味着我们可以从内存中把数据传给ffmpeg，不论数据时从网络，摄像头，或者是本地文件


点击(此处)折叠或打开

  1. //metadata.c
  2. #include <stdio.h>

  4. #include <libavformat/avformat.h>
  5. #include <libavutil/dict.h>

  7. int main (int argc, char **argv)
  8. {
  9.     AVFormatContext *fmt_ctx = NULL;
  10.     //“字典入口”，用来保存AVDictionary变量里面的每一个“字”
  11.     AVDictionaryEntry *tag = NULL;
  12.     int ret;

  14.     if (argc != 2) {
  15.         printf("usage: %s \n"
  16.                "example program to demonstrate the use of the libavformat metadata API.\n"
  17.                "\n", argv[0]);
  18.         return 1;
  19.     }

  21.     av_register_all();
  22.     if ((ret = avformat_open_input(&fmt_ctx, argv[1], NULL, NULL)))
  23.         return ret;
  24.     //遍历“字典”中的每一个“字”，每一个字有一个键值对
  25.     while ((tag = av_dict_get(fmt_ctx->metadata, "", tag, AV_DICT_IGNORE_SUFFIX)))
  26.         printf("%s=%s\n", tag->key, tag->value);

  28.     avformat_close_input(&fmt_ctx);
  29.     return 0;
  30. }
这个没什么好说的，只需要注意一下格式上下文的metadata中保存了媒体文件的元信息，保存的格式是“字典”（AVDictionary）类型


点击(此处)折叠或打开

  1. //resampling_audio.c
  2. #include <libavutil/opt.h>
  3. #include <libavutil/channel_layout.h>
  4. #include <libavutil/samplefmt.h>
  5. #include <libswresample/swresample.h>

  7. static int get_format_from_sample_fmt(const char **fmt,
  8.                                       enum AVSampleFormat sample_fmt)
  9. {
  10.     int i;
  11.     struct sample_fmt_entry {
  12.         enum AVSampleFormat sample_fmt; const char *fmt_be, *fmt_le;
  13.     } sample_fmt_entries[] = {
  14.         { AV_SAMPLE_FMT_U8, "u8", "u8" },
  15.         { AV_SAMPLE_FMT_S16, "s16be", "s16le" },
  16.         { AV_SAMPLE_FMT_S32, "s32be", "s32le" },
  17.         { AV_SAMPLE_FMT_FLT, "f32be", "f32le" },
  18.         { AV_SAMPLE_FMT_DBL, "f64be", "f64le" },
  19.     };
  20.     *fmt = NULL;

  22.     for (i = 0; i < FF_ARRAY_ELEMS(sample_fmt_entries); i++) {
  23.         struct sample_fmt_entry *entry = &sample_fmt_entries[i];
  24.         if (sample_fmt == entry->sample_fmt) {
  25.             *fmt = AV_NE(entry->fmt_be, entry->fmt_le);
  26.             return 0;
  27.         }
  28.     }

  30.     fprintf(stderr,
  31.             "Sample format %s not supported as output format\n",
  32.             av_get_sample_fmt_name(sample_fmt));
  33.     return AVERROR(EINVAL);
  34. }

  36. /**
  37.  * Fill dst buffer with nb_samples, generated starting from t.
  38.  */
  39. static void fill_samples(double *dst, int nb_samples, int nb_channels, int sample_rate, double *t)
  40. {
  41.     int i, j;
  42.     double tincr = 1.0 / sample_rate, *dstp = dst;
  43.     const double c = 2 * M_PI * 440.0;

  45.     /* generate sin tone with 440Hz frequency and duplicated channels */
  46.     for (i = 0; i < nb_samples; i++) {
  47.         *dstp = sin(c * *t);
  48.         for (j = 1; j < nb_channels; j++)
  49.             dstp[j] = dstp[0];
  50.         dstp += nb_channels;
  51.         *t += tincr;
  52.     }
  53. }

  55. int main(int argc, char **argv)
  56. {
  57.     //AV_CH_LAYOUT_STEREO=3 左右 AV_CH_LAYOUT_SURROUND=7 左右中 理解成声道的一种格式就行
  58.     int64_t src_ch_layout = AV_CH_LAYOUT_STEREO, dst_ch_layout = AV_CH_LAYOUT_SURROUND;
  59.     //采样率定义44100比较常用
  60.     int src_rate = 48000, dst_rate = 44100;
  61.     //
  62.     uint8_t **src_data = NULL, **dst_data = NULL;
  63.     //声道数
  64.     int src_nb_channels = 0, dst_nb_channels = 0;
  65.     int src_linesize, dst_linesize;
  66.     //这东西我叫他采样数，但是问别人好像不这么叫
  67.     int src_nb_samples = 1024, dst_nb_samples, max_dst_nb_samples;
  68.     //采样格式 double 和 signed 16bit，现在好像都流行平面的（声道的数据分开存放）
  69.     enum AVSampleFormat src_sample_fmt = AV_SAMPLE_FMT_DBL, dst_sample_fmt = AV_SAMPLE_FMT_S16;
  70.     const char *dst_filename = NULL;
  71.     FILE *dst_file;
  72.     int dst_bufsize;
  73.     const char *fmt;
  74.     //本段代码嘴主要的结构 重采样上下文
  75.     struct SwrContext *swr_ctx;
  76.     double t;
  77.     int ret;

  79.     if (argc != 2) {
  80.         fprintf(stderr, "Usage: %s output_file\n"
  81.                 "API example program to show how to resample an audio stream with libswresample.\n"
  82.                 "This program generates a series of audio frames, resamples them to a specified "
  83.                 "output format and rate and saves them to an output file named output_file.\n",
  84.             argv[0]);
  85.         exit(1);
  86.     }
  87.     dst_filename = argv[1];

  89.     dst_file = fopen(dst_filename, "wb");
  90.     if (!dst_file) {
  91.         fprintf(stderr, "Could not open destination file %s\n", dst_filename);
  92.         exit(1);
  93.     }

  95.     /* create resampler context */
  96.     //创建重采样上下文
  97.     swr_ctx = swr_alloc();
  98.     if (!swr_ctx) {
  99.         fprintf(stderr, "Could not allocate resampler context\n");
  100.         ret = AVERROR(ENOMEM);
  101.         goto end;
  102.     }

  104.     /* set options */
  105.     //设置重采样上下文的输入属性
  106.     av_opt_set_int(swr_ctx, "in_channel_layout", src_ch_layout, 0);
  107.     av_opt_set_int(swr_ctx, "in_sample_rate", src_rate, 0);
  108.     av_opt_set_sample_fmt(swr_ctx, "in_sample_fmt", src_sample_fmt, 0);
  109.     //设置重采样上下文的输出属性
  110.     av_opt_set_int(swr_ctx, "out_channel_layout", dst_ch_layout, 0);
  111.     av_opt_set_int(swr_ctx, "out_sample_rate", dst_rate, 0);
  112.     av_opt_set_sample_fmt(swr_ctx, "out_sample_fmt", dst_sample_fmt, 0);

  114.     /* initialize the resampling context */
  115.     //初始化重采样上下文
  116.     if ((ret = swr_init(swr_ctx)) < 0) {
  117.         fprintf(stderr, "Failed to initialize the resampling context\n");
  118.         goto end;
  119.     }

  121.     /* allocate source and destination samples buffers */
  122.     //通过声道格式获取声道数
  123.     src_nb_channels = av_get_channel_layout_nb_channels(src_ch_layout);
  124.     //计算并申请一块内存，用于保存源数据 src_linesize=采样数*采样格式的字节数（double类型=8字节）*声道数
  125.     ret = av_samples_alloc_array_and_samples(&src_data, &src_linesize, src_nb_channels,
  126.                                              src_nb_samples, src_sample_fmt, 0);
  127.     if (ret < 0) {
  128.         fprintf(stderr, "Could not allocate source samples\n");
  129.         goto end;
  130.     }

  132.     /* compute the number of converted samples: buffering is avoided
  133.      * ensuring that the output buffer will contain at least all the
  134.      * converted input samples */
  135.     //计算目标采样数，如果重新采样的话，采样率S肯定不等于采样率D，比如48000采样率单位时间采样数为1024的话，那么44100采样率在同等时间的采样数x=1024*44100    // /48000 需要理解 采样率和采样数之间的关系 这地方可能我说的不对，暂时我就这样理解，有人知道的话希望指点
  136.     max_dst_nb_samples = dst_nb_samples =
  137.         av_rescale_rnd(src_nb_samples, dst_rate, src_rate, AV_ROUND_UP);

  139.     /* buffer is going to be directly written to a rawaudio file, no alignment */
  140.     dst_nb_channels = av_get_channel_layout_nb_channels(dst_ch_layout);
  141.     ret = av_samples_alloc_array_and_samples(&dst_data, &dst_linesize, dst_nb_channels,
  142.                                              dst_nb_samples, dst_sample_fmt, 0);
  143.     if (ret < 0) {
  144.         fprintf(stderr, "Could not allocate destination samples\n");
  145.         goto end;
  146.     }

  148.     t = 0;
  149.     do {
  150.         /* generate synthetic audio */
  151.         fill_samples((double *)src_data[0], src_nb_samples, src_nb_channels, src_rate, &t);

  153.         /* compute destination number of samples */
  154.         //重新采样必须有这一步，如果是转格式采样率不变的话，可以不计算这一步
  155.         dst_nb_samples = av_rescale_rnd(swr_get_delay(swr_ctx, src_rate) +
  156.                                         src_nb_samples, dst_rate, src_rate, AV_ROUND_UP);
  157.         if (dst_nb_samples > max_dst_nb_samples) {
  158.             av_freep(&dst_data[0]);
  159.             //重新申请dst_data（不然装不下，越界）
  160.             ret = av_samples_alloc(dst_data, &dst_linesize, dst_nb_channels,
  161.                                    dst_nb_samples, dst_sample_fmt, 1);
  162.             if (ret < 0)
  163.                 break;
  164.             max_dst_nb_samples = dst_nb_samples;
  165.         }

  167.         /* convert to destination format */
  168.         //转换格式
  169.         ret = swr_convert(swr_ctx, dst_data, dst_nb_samples, (const uint8_t **)src_data, src_nb_samples);
  170.         if (ret < 0) {
  171.             fprintf(stderr, "Error while converting\n");
  172.             goto end;
  173.         }
  174.         //计算转换之后音频帧的长度
  175.         dst_bufsize = av_samples_get_buffer_size(&dst_linesize, dst_nb_channels,
  176.                                                  ret, dst_sample_fmt, 1);
  177.         if (dst_bufsize < 0) {
  178.             fprintf(stderr, "Could not get sample buffer size\n");
  179.             goto end;
  180.         }
  181.         printf("t:%f in:%d out:%d\n", t, src_nb_samples, ret);
  182.         //没有经过容器封装的原始音频数据
  183.         fwrite(dst_data[0], 1, dst_bufsize, dst_file);
  184.     } while (t < 10);

  186.     if ((ret = get_format_from_sample_fmt(&fmt, dst_sample_fmt)) < 0)
  187.         goto end;
  188. //PRId64 = 64
  189. //32位os中使用lld代替
  190.     fprintf(stderr, "Resampling succeeded. Play the output file with the command:\n"
  191.             "ffplay -f %s -channel_layout %lld -channels %d -ar %d %s\n",
  192.             fmt, dst_ch_layout, dst_nb_channels, dst_rate, dst_filename);

  194. end:
  195.     fclose(dst_file);

  197.     if (src_data)
  198.         av_freep(&src_data[0]);
  199.     av_freep(&src_data);

  201.     if (dst_data)
  202.         av_freep(&dst_data[0]);
  203.     av_freep(&dst_data);

  205.     swr_free(&swr_ctx);
  206.     return ret < 0;
  207. }
重采样的例程比较简单，只要理解几个名词就行了
1、声道数
2、声道格式（可以用来计算声道数）
3、采样率 常用的22500 44100 48000...
4、采样格式 每个样本需要用多少位来表示，是否带符号，是否平面
5、采样数 这个一般都是1024，mp3格式的好像是1152
如果想做一个重新采样的程序的话，从哪获取上面这些信息呢

声道格式，采样率，采样格式都保存在codec_ctx（AVCodecContext*编解码器上下文）中
//frame是解码文件获取的一帧音频，data中音频数据（此处需要注意，如果是平面格式的话，是否data【0】data【1】呢？），nb_samples中保存采样数
src_data = frame->data;
src_nb_samples = frame->nb_samples;


点击(此处)折叠或打开

  1. /*
  2.  * This file is part of FFmpeg.
  3.  *
  4.  * FFmpeg is free software; you can redistribute it and/or
  5.  * modify it under the terms of the GNU Lesser General Public
  6.  * License as published by the Free Software Foundation; either
  7.  * version 2.1 of the License, or (at your option) any later version.
  8.  *
  9.  * FFmpeg is distributed in the hope that it will be useful,
  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  12.  * Lesser General Public License for more details.
  13.  *
  14.  * You should have received a copy of the GNU Lesser General Public
  15.  * License along with FFmpeg; if not, write to the Free Software
  16.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  17.  */

  19. /**
  20.  * @file
  21.  * simple audio converter
  22.  *
  23.  * @example transcode_aac.c
  24.  * Convert an input audio file to AAC in an MP4 container using FFmpeg.
  25.  * @author Andreas Unterweger (dustsigns@gmail.com)
  26.  */

  28. #include <stdio.h>

  30. #include "libavformat/avformat.h"
  31. #include "libavformat/avio.h"

  33. #include "libavcodec/avcodec.h"

  35. #include "libavutil/audio_fifo.h"
  36. #include "libavutil/avassert.h"
  37. #include "libavutil/avstring.h"
  38. #include "libavutil/frame.h"
  39. #include "libavutil/opt.h"

  41. #include "libswresample/swresample.h"

  43. /** The output bit rate in kbit/s */
  44. #define OUTPUT_BIT_RATE 96000
  45. /** The number of output channels */
  46. #define OUTPUT_CHANNELS 2

  48. /**
  49.  * Convert an error code into a text message.
  50.  * @param error Error code to be converted
  51.  * @return Corresponding error text (not thread-safe)
  52.  */
  53. static const char *get_error_text(const int error)
  54. {
  55.     static char error_buffer[255];
  56.     av_strerror(error, error_buffer, sizeof(error_buffer));
  57.     return error_buffer;
  58. }

  60. /** Open an input file and the required decoder. */
  61. static int open_input_file(const char *filename,
  62.                            AVFormatContext **input_format_context,
  63.                            AVCodecContext **input_codec_context)
  64. {
  65.     AVCodec *input_codec;
  66.     int error;

  68.     /** Open the input file to read from it. */
  69.     //打开输入文件
  70.     if ((error = avformat_open_input(input_format_context, filename, NULL,
  71.                                      NULL)) < 0) {
  72.         fprintf(stderr, "Could not open input file '%s' (error '%s')\n",
  73.                 filename, get_error_text(error));
  74.         *input_format_context = NULL;
  75.         return error;
  76.     }

  78.     /** Get information on the input file (number of streams etc.). */
  79.     //查找流信息
  80.     if ((error = avformat_find_stream_info(*input_format_context, NULL)) < 0) {
  81.         fprintf(stderr, "Could not open find stream info (error '%s')\n",
  82.                 get_error_text(error));
  83.         avformat_close_input(input_format_context);
  84.         return error;
  85.     }
  86.     //这个地方只检测了流的数量，而且并没有确定流的类型
  87.     //(*input_format_context)->streams[0]->codec->codec_type AVMEDIA_TYPE_AUDIO AVMEDIA_TYPE_VIDEO
  88.     //所以做测试的时候输入文件必须是一个纯的音频文件，没有的话可以使用ffmpeg转换一个
  89.     /** Make sure that there is only one stream in the input file. */
  90.     if ((*input_format_context)->nb_streams != 1) {
  91.         fprintf(stderr, "Expected one audio input stream, but found %d\n",
  92.                 (*input_format_context)->nb_streams);
  93.         avformat_close_input(input_format_context);
  94.         return AVERROR_EXIT;
  95.     }

  97.     /** Find a decoder for the audio stream. */
  98.     //查找解码器 参数是解码器ID 解码时解码器的ID保存在 格式上下文->流->编解码器上下文->codec->codec_id
  99.     if (!(input_codec = avcodec_find_decoder((*input_format_context)->streams[0]->codec->codec_id))) {
  100.         fprintf(stderr, "Could not find input codec\n");
  101.         avformat_close_input(input_format_context);
  102.         return AVERROR_EXIT;
  103.     }

  105.     /** Open the decoder for the audio stream to use it later. */
  106.     //打开解码器 参数是编解码器上下文，编解码器，NULL=参数
  107.     if ((error = avcodec_open2((*input_format_context)->streams[0]->codec,
  108.                                input_codec, NULL)) < 0) {
  109.         fprintf(stderr, "Could not open input codec (error '%s')\n",
  110.                 get_error_text(error));
  111.         avformat_close_input(input_format_context);
  112.         return error;
  113.     }

  115.     /** Save the decoder context for easier access later. */
  116.     *input_codec_context = (*input_format_context)->streams[0]->codec;

  118.     return 0;
  119. }

  121. /**
  122.  * Open an output file and the required encoder.
  123.  * Also set some basic encoder parameters.
  124.  * Some of these parameters are based on the input file's parameters.
  125.  */
  126. static int open_output_file(const char *filename,
  127.                             AVCodecContext *input_codec_context,
  128.                             AVFormatContext **output_format_context,
  129.                             AVCodecContext **output_codec_context)
  130. {
  131.     AVIOContext *output_io_context = NULL;
  132.     AVStream *stream = NULL;
  133.     AVCodec *output_codec = NULL;
  134.     int error;

  136.     /** Open the output file to write to it. */
  137.     //对比例1中的avio_alloc_context，本次是打开文件，并且填充io上下文，而在例1中是直接指定io上下文的读回调函数
  138.     //如果此时不想把通过ffmpeg的方式把数据写入到文件中的话，也可以使用avio_alloc_context去指定写回调函数，就可以随心所欲的处理音频数据了
  139.     //对于输出格式上下文，其成员 io上下文和 输出格式oformat都有写文件函数，他们有什么关系呢？
  140.     //当调用av_write_frame的时候，会先调用oformat里面的写函数，oformat里面的写函数在去调用io上下文的写函数，
  141.     //总结来看io上下文的写 是和文件url有关的（网络，或者本地文件）
  142.     //oformat则是和媒体容器相关的，比如是mp4，flv，或者aac，mp3
  143.     //此处是我自己的理解，不一定正确
  144.     if ((error = avio_open(&output_io_context, filename,
  145.                            AVIO_FLAG_WRITE)) < 0) {
  146.         fprintf(stderr, "Could not open output file '%s' (error '%s')\n",
  147.                 filename, get_error_text(error));
  148.         return error;
  149.     }

  151.     /** Create a new format context for the output container format. */
  152.     //创建输出格式上下文
  153.     if (!(*output_format_context = avformat_alloc_context())) {
  154.         fprintf(stderr, "Could not allocate output format context\n");
  155.         return AVERROR(ENOMEM);
  156.     }

  158.     /** Associate the output file (pointer) with the container format context. */
  159.     //指定格式上下文的io上下文
  160.     (*output_format_context)->pb = output_io_context;

  162.     /** Guess the desired container format based on the file extension. */
  163.     //猜测输出格式的上下文，作用，我猜测是在写入文件的时候，写入相应的文件格式的头或者类似的信息，
  164.     //比如mp4的话，就需要写一个个的box，flv则是tag，其他的容器也有自己的数据格式
  165.     if (!((*output_format_context)->oformat = av_guess_format(NULL, filename,
  166.                                                               NULL))) {
  167.         fprintf(stderr, "Could not find output file format\n");
  168.         goto cleanup;
  169.     }

  171.     av_strlcpy((*output_format_context)->filename, filename,
  172.                sizeof((*output_format_context)->filename));

  174.     /** Find the encoder to be used by its name. */
  175.     //查找编码器
  176.     if (!(output_codec = avcodec_find_encoder(AV_CODEC_ID_AAC))) {
  177.         fprintf(stderr, "Could not find an AAC encoder.\n");
  178.         goto cleanup;
  179.     }

  181.     /** Create a new audio stream in the output file container. */
  182.     //新建一个流
  183.     if (!(stream = avformat_new_stream(*output_format_context, output_codec))) {
  184.         fprintf(stderr, "Could not create new stream\n");
  185.         error = AVERROR(ENOMEM);
  186.         goto cleanup;
  187.     }

  189.     /** Save the encoder context for easier access later. */
  190.     *output_codec_context = stream->codec;

  192.     /**
  193.      * Set the basic encoder parameters.
  194.      * The input file's sample rate is used to avoid a sample rate conversion.
  195.      */
  196.     //编码器初始化
  197.     (*output_codec_context)->channels = OUTPUT_CHANNELS;//声道数
  198.     (*output_codec_context)->channel_layout = av_get_default_channel_layout(OUTPUT_CHANNELS);//声道格式
  199.     (*output_codec_context)->sample_rate = input_codec_context->sample_rate;//采样率
  200.     (*output_codec_context)->sample_fmt = output_codec->sample_fmts[0];//采样格式
  201.     (*output_codec_context)->bit_rate = OUTPUT_BIT_RATE;//码率

  203.     /** Allow the use of the experimental AAC encoder */
  204.     (*output_codec_context)->strict_std_compliance = FF_COMPLIANCE_EXPERIMENTAL;

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

  210.     /**
  211.      * Some container formats (like MP4) require global headers to be present
  212.      * Mark the encoder so that it behaves accordingly.
  213.      */
  214.     if ((*output_format_context)->oformat->flags & AVFMT_GLOBALHEADER)
  215.         (*output_codec_context)->flags |= CODEC_FLAG_GLOBAL_HEADER;

  217.     /** Open the encoder for the audio stream to use it later. */
  218.     //打开编码器
  219.     if ((error = avcodec_open2(*output_codec_context, output_codec, NULL)) < 0) {
  220.         fprintf(stderr, "Could not open output codec (error '%s')\n",
  221.                 get_error_text(error));
  222.         goto cleanup;
  223.     }

  225.     return 0;

  227. cleanup:
  228.     avio_closep(&(*output_format_context)->pb);
  229.     avformat_free_context(*output_format_context);
  230.     *output_format_context = NULL;
  231.     return error < 0 ? error : AVERROR_EXIT;
  232. }

  234. /** Initialize one data packet for reading or writing. */
  235. static void init_packet(AVPacket *packet)
  236. {
  237.     av_init_packet(packet);
  238.     /** Set the packet data and size so that it is recognized as being empty. */
  239.     packet->data = NULL;
  240.     packet->size = 0;
  241. }

  243. /** Initialize one audio frame for reading from the input file */
  244. static int init_input_frame(AVFrame **frame)
  245. {
  246.     if (!(*frame = av_frame_alloc())) {
  247.         fprintf(stderr, "Could not allocate input frame\n");
  248.         return AVERROR(ENOMEM);
  249.     }
  250.     return 0;
  251. }

  253. /**
  254.  * Initialize the audio resampler based on the input and output codec settings.
  255.  * If the input and output sample formats differ, a conversion is required
  256.  * libswresample takes care of this, but requires initialization.
  257.  */
  258. static int init_resampler(AVCodecContext *input_codec_context,
  259.                           AVCodecContext *output_codec_context,
  260.                           SwrContext **resample_context)
  261. {
  262.         int error;

  264.         /**
  265.          * Create a resampler context for the conversion.
  266.          * Set the conversion parameters.
  267.          * Default channel layouts based on the number of channels
  268.          * are assumed for simplicity (they are sometimes not detected
  269.          * properly by the demuxer and/or decoder).
  270.          */
  271.         //区别于例三，一个函数搞定重采样上下文的初始化
  272.         *resample_context = swr_alloc_set_opts(NULL,
  273.                                               av_get_default_channel_layout(output_codec_context->channels),
  274.                                               output_codec_context->sample_fmt,
  275.                                               output_codec_context->sample_rate,
  276.                                               av_get_default_channel_layout(input_codec_context->channels),
  277.                                               input_codec_context->sample_fmt,
  278.                                               input_codec_context->sample_rate,
  279.                                               0, NULL);
  280.         if (!*resample_context) {
  281.             fprintf(stderr, "Could not allocate resample context\n");
  282.             return AVERROR(ENOMEM);
  283.         }
  284.         /**
  285.         * Perform a sanity check so that the number of converted samples is
  286.         * not greater than the number of samples to be converted.
  287.         * If the sample rates differ, this case has to be handled differently
  288.         */
  289.         //确保输入输出采样率相等，猜测：如果采样率不相等的话，采样数就需要重新计算，但是此段代码中并没有重新计算采样数
  290.         av_assert0(output_codec_context->sample_rate == input_codec_context->sample_rate);

  292.         /** Open the resampler with the specified parameters. */
  293.         if ((error = swr_init(*resample_context)) < 0) {
  294.             fprintf(stderr, "Could not open resample context\n");
  295.             swr_free(resample_context);
  296.             return error;
  297.         }
  298.     return 0;
  299. }

  301. /** Initialize a FIFO buffer for the audio samples to be encoded. */
  302. static int init_fifo(AVAudioFifo **fifo, AVCodecContext *output_codec_context)
  303. {
  304.     /** Create the FIFO buffer based on the specified output sample format. */
  305.     if (!(*fifo = av_audio_fifo_alloc(output_codec_context->sample_fmt,
  306.                                       output_codec_context->channels, 1))) {
  307.         fprintf(stderr, "Could not allocate FIFO\n");
  308.         return AVERROR(ENOMEM);
  309.     }
  310.     return 0;
  311. }

  313. /** Write the header of the output file container. */
  314. static int write_output_file_header(AVFormatContext *output_format_context)
  315. {
  316.     int error;
  317.     //写文件头
  318.     if ((error = avformat_write_header(output_format_context, NULL)) < 0) {
  319.         fprintf(stderr, "Could not write output file header (error '%s')\n",
  320.                 get_error_text(error));
  321.         return error;
  322.     }
  323.     return 0;
  324. }

  326. /** Decode one audio frame from the input file. */
  327. static int decode_audio_frame(AVFrame *frame,
  328.                               AVFormatContext *input_format_context,
  329.                               AVCodecContext *input_codec_context,
  330.                               int *data_present, int *finished)
  331. {
  332.     /** Packet used for temporary storage. */
  333.     AVPacket input_packet;
  334.     int error;
  335.     init_packet(&input_packet);

  337.     /** Read one audio frame from the input file into a temporary packet. */
  338.     if ((error = av_read_frame(input_format_context, &input_packet)) < 0) {
  339.         /** If we are at the end of the file, flush the decoder below. */
  340.         if (error == AVERROR_EOF)
  341.             *finished = 1;
  342.         else {
  343.             fprintf(stderr, "Could not read frame (error '%s')\n",
  344.                     get_error_text(error));
  345.             return error;
  346.         }
  347.     }

  349.     /**
  350.      * Decode the audio frame stored in the temporary packet.
  351.      * The input audio stream decoder is used to do this.
  352.      * If we are at the end of the file, pass an empty packet to the decoder
  353.      * to flush it.
  354.      */
  355.     if ((error = avcodec_decode_audio4(input_codec_context, frame,
  356.                                        data_present, &input_packet)) < 0) {
  357.         fprintf(stderr, "Could not decode frame (error '%s')\n",
  358.                 get_error_text(error));
  359.         av_free_packet(&input_packet);
  360.         return error;
  361.     }

  363.     /**
  364.      * If the decoder has not been flushed completely, we are not finished,
  365.      * so that this function has to be called again.
  366.      */
  367.     if (*finished && *data_present)
  368.         *finished = 0;
  369.     av_free_packet(&input_packet);
  370.     return 0;
  371. }

  373. /**
  374.  * Initialize a temporary storage for the specified number of audio samples.
  375.  * The conversion requires temporary storage due to the different format.
  376.  * The number of audio samples to be allocated is specified in frame_size.
  377.  */
  378. static int init_converted_samples(uint8_t ***converted_input_samples,
  379.                                   AVCodecContext *output_codec_context,
  380.                                   int frame_size)
  381. {
  382.     int error;

  384.     /**
  385.      * Allocate as many pointers as there are audio channels.
  386.      * Each pointer will later point to the audio samples of the corresponding
  387.      * channels (although it may be NULL for interleaved formats).
  388.      */
  389.     if (!(*converted_input_samples = calloc(output_codec_context->channels,
  390.                                             sizeof(**converted_input_samples)))) {
  391.         fprintf(stderr, "Could not allocate converted input sample pointers\n");
  392.         return AVERROR(ENOMEM);
  393.     }

  395.     /**
  396.      * Allocate memory for the samples of all channels in one consecutive
  397.      * block for convenience.
  398.      */
  399.     if ((error = av_samples_alloc(*converted_input_samples, NULL,
  400.                                   output_codec_context->channels,
  401.                                   frame_size,
  402.                                   output_codec_context->sample_fmt, 0)) < 0) {
  403.         fprintf(stderr,
  404.                 "Could not allocate converted input samples (error '%s')\n",
  405.                 get_error_text(error));
  406.         av_freep(&(*converted_input_samples)[0]);
  407.         free(*converted_input_samples);
  408.         return error;
  409.     }
  410.     return 0;
  411. }

  413. /**
  414.  * Convert the input audio samples into the output sample format.
  415.  * The conversion happens on a per-frame basis, the size of which is specified
  416.  * by frame_size.
  417.  */
  418. static int convert_samples(const uint8_t **input_data,
  419.                            uint8_t **converted_data, const int frame_size,
  420.                            SwrContext *resample_context)
  421. {
  422.     int error;

  424.     /** Convert the samples using the resampler. */
  425.     if ((error = swr_convert(resample_context,
  426.                              converted_data, frame_size,
  427.                              input_data , frame_size)) < 0) {
  428.         fprintf(stderr, "Could not convert input samples (error '%s')\n",
  429.                 get_error_text(error));
  430.         return error;
  431.     }

  433.     return 0;
  434. }

  436. /** Add converted input audio samples to the FIFO buffer for later processing. */
  437. static int add_samples_to_fifo(AVAudioFifo *fifo,
  438.                                uint8_t **converted_input_samples,
  439.                                const int frame_size)
  440. {
  441.     int error;

  443.     /**
  444.      * Make the FIFO as large as it needs to be to hold both,
  445.      * the old and the new samples.
  446.      */
  447.     if ((error = av_audio_fifo_realloc(fifo, av_audio_fifo_size(fifo) + frame_size)) < 0) {
  448.         fprintf(stderr, "Could not reallocate FIFO\n");
  449.         return error;
  450.     }

  452.     /** Store the new samples in the FIFO buffer. */
  453.     if (av_audio_fifo_write(fifo, (void **)converted_input_samples,
  454.                             frame_size) < frame_size) {
  455.         fprintf(stderr, "Could not write data to FIFO\n");
  456.         return AVERROR_EXIT;
  457.     }
  458.     return 0;
  459. }

  461. /**
  462.  * Read one audio frame from the input file, decodes, converts and stores
  463.  * it in the FIFO buffer.
  464.  */
  465. static int read_decode_convert_and_store(AVAudioFifo *fifo,
  466.                                          AVFormatContext *input_format_context,
  467.                                          AVCodecContext *input_codec_context,
  468.                                          AVCodecContext *output_codec_context,
  469.                                          SwrContext *resampler_context,
  470.                                          int *finished)
  471. {
  472.     /** Temporary storage of the input samples of the frame read from the file. */
  473.     AVFrame *input_frame = NULL;
  474.     /** Temporary storage for the converted input samples. */
  475.     uint8_t **converted_input_samples = NULL;
  476.     int data_present;
  477.     int ret = AVERROR_EXIT;

  479.     /** Initialize temporary storage for one input frame. */
  480.     if (init_input_frame(&input_frame))
  481.         goto cleanup;
  482.     /** Decode one frame worth of audio samples. */
  483.     if (decode_audio_frame(input_frame, input_format_context,
  484.                            input_codec_context, &data_present, finished))
  485.         goto cleanup;
  486.     /**
  487.      * If we are at the end of the file and there are no more samples
  488.      * in the decoder which are delayed, we are actually finished.
  489.      * This must not be treated as an error.
  490.      */
  491.     if (*finished && !data_present) {
  492.         ret = 0;
  493.         goto cleanup;
  494.     }
  495.     /** If there is decoded data, convert and store it */
  496.     //input_frame->nb_samples表示当前帧内数据的长度 MP3一般是1152 aac=1024
  497.     //区别于编解码器上下文中的frame_size是帧最大长度
  498.     if (data_present) {
  499.         /** Initialize the temporary storage for the converted input samples. */
  500.         if (init_converted_samples(&converted_input_samples, output_codec_context,
  501.                                    input_frame->nb_samples))
  502.             goto cleanup;

  504.         /**
  505.          * Convert the input samples to the desired output sample format.
  506.          * This requires a temporary storage provided by converted_input_samples.
  507.          */
  508.         if (convert_samples((const uint8_t**)input_frame->extended_data, converted_input_samples,
  509.                             input_frame->nb_samples, resampler_context))
  510.             goto cleanup;

  512.         /** Add the converted input samples to the FIFO buffer for later processing. */
  513.         if (add_samples_to_fifo(fifo, converted_input_samples,
  514.                                 input_frame->nb_samples))
  515.             goto cleanup;
  516.         ret = 0;
  517.     }
  518.     ret = 0;

  520. cleanup:
  521.     if (converted_input_samples) {
  522.         av_freep(&converted_input_samples[0]);
  523.         free(converted_input_samples);
  524.     }
  525.     av_frame_free(&input_frame);

  527.     return ret;
  528. }

  530. /**
  531.  * Initialize one input frame for writing to the output file.
  532.  * The frame will be exactly frame_size samples large.
  533.  */
  534. static int init_output_frame(AVFrame **frame,
  535.                              AVCodecContext *output_codec_context,
  536.                              int frame_size)
  537. {
  538.     int error;

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

  546.     /**
  547.      * Set the frame's parameters, especially its size and format.
  548.      * av_frame_get_buffer needs this to allocate memory for the
  549.      * audio samples of the frame.
  550.      * Default channel layouts based on the number of channels
  551.      * are assumed for simplicity.
  552.      */
  553.     (*frame)->nb_samples = frame_size;
  554.     (*frame)->channel_layout = output_codec_context->channel_layout;
  555.     (*frame)->format = output_codec_context->sample_fmt;
  556.     (*frame)->sample_rate = output_codec_context->sample_rate;

  558.     /**
  559.      * Allocate the samples of the created frame. This call will make
  560.      * sure that the audio frame can hold as many samples as specified.
  561.      */
  562.     if ((error = av_frame_get_buffer(*frame, 0)) < 0) {
  563.         fprintf(stderr, "Could allocate output frame samples (error '%s')\n",
  564.                 get_error_text(error));
  565.         av_frame_free(frame);
  566.         return error;
  567.     }

  569.     return 0;
  570. }

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

  575. /** Encode one frame worth of audio to the output file. */
  576. static int encode_audio_frame(AVFrame *frame,
  577.                               AVFormatContext *output_format_context,
  578.                               AVCodecContext *output_codec_context,
  579.                               int *data_present)
  580. {
  581.     /** Packet used for temporary storage. */
  582.     AVPacket output_packet;
  583.     int error;
  584.     init_packet(&output_packet);

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

  592.     /**
  593.      * Encode the audio frame and store it in the temporary packet.
  594.      * The output audio stream encoder is used to do this.
  595.      */
  596.     if ((error = avcodec_encode_audio2(output_codec_context, &output_packet,
  597.                                        frame, data_present)) < 0) {
  598.         fprintf(stderr, "Could not encode frame (error '%s')\n",
  599.                 get_error_text(error));
  600.         av_free_packet(&output_packet);
  601.         return error;
  602.     }

  604.     /** Write one audio frame from the temporary packet to the output file. */
  605.     if (*data_present) {
  606.         if ((error = av_write_frame(output_format_context, &output_packet)) < 0) {
  607.             fprintf(stderr, "Could not write frame (error '%s')\n",
  608.                     get_error_text(error));
  609.             av_free_packet(&output_packet);
  610.             return error;
  611.         }

  613.         av_free_packet(&output_packet);
  614.     }

  616.     return 0;
  617. }

  619. /**
  620.  * Load one audio frame from the FIFO buffer, encode and write it to the
  621.  * output file.
  622.  */
  623. static int load_encode_and_write(AVAudioFifo *fifo,
  624.                                  AVFormatContext *output_format_context,
  625.                                  AVCodecContext *output_codec_context)
  626. {
  627.     /** Temporary storage of the output samples of the frame written to the file. */
  628.     AVFrame *output_frame;
  629.     /**
  630.      * Use the maximum number of possible samples per frame.
  631.      * If there is less than the maximum possible frame size in the FIFO
  632.      * buffer use this number. Otherwise, use the maximum possible frame size
  633.      */
  634.     const int frame_size = FFMIN(av_audio_fifo_size(fifo),
  635.                                  output_codec_context->frame_size);
  636.     int data_written;

  638.     /** Initialize temporary storage for one output frame. */
  639.     if (init_output_frame(&output_frame, output_codec_context, frame_size))
  640.         return AVERROR_EXIT;

  642.     /**
  643.      * Read as many samples from the FIFO buffer as required to fill the frame.
  644.      * The samples are stored in the frame temporarily.
  645.      */
  646.     if (av_audio_fifo_read(fifo, (void **)output_frame->data, frame_size) < frame_size) {
  647.         fprintf(stderr, "Could not read data from FIFO\n");
  648.         av_frame_free(&output_frame);
  649.         return AVERROR_EXIT;
  650.     }

  652.     /** Encode one frame worth of audio samples. */
  653.     if (encode_audio_frame(output_frame, output_format_context,
  654.                            output_codec_context, &data_written)) {
  655.         av_frame_free(&output_frame);
  656.         return AVERROR_EXIT;
  657.     }
  658.     av_frame_free(&output_frame);
  659.     return 0;
  660. }

  662. /** Write the trailer of the output file container. */
  663. static int write_output_file_trailer(AVFormatContext *output_format_context)
  664. {
  665.     int error;
  666.     if ((error = av_write_trailer(output_format_context)) < 0) {
  667.         fprintf(stderr, "Could not write output file trailer (error '%s')\n",
  668.                 get_error_text(error));
  669.         return error;
  670.     }
  671.     return 0;
  672. }

  674. /** Convert an audio file to an AAC file in an MP4 container. */
  675. int main(int argc, char **argv)
  676. {
  677.     //输入输出格式上下文
  678.     AVFormatContext *input_format_context = NULL, *output_format_context = NULL;
  679.     //解码器上下文、编码器上下文
  680.     AVCodecContext *input_codec_context = NULL, *output_codec_context = NULL;
  681.     //重采样上下文
  682.     SwrContext *resample_context = NULL;
  683.     //音频fifo
  684.     AVAudioFifo *fifo = NULL;
  685.     int ret = AVERROR_EXIT;

  687.     if (argc < 3) {
  688.         fprintf(stderr, "Usage: %s  \n", argv[0]);
  689.         exit(1);
  690.     }

  692.     /** Register all codecs and formats so that they can be used. */
  693.     av_register_all();
  694.     /** Open the input file for reading. */
  695.     //填充了输入格式上下文，并且打开了相对应的解码器
  696.     if (open_input_file(argv[1], &input_format_context,
  697.                         &input_codec_context))
  698.         goto cleanup;
  699.     /** Open the output file for writing. */
  700.     //填充输出格式上下文，打开io上下文，流的初始化，编码器的初始化
  701.     if (open_output_file(argv[2], input_codec_context,
  702.                          &output_format_context, &output_codec_context))
  703.         goto cleanup;
  704.     /** Initialize the resampler to be able to convert audio sample formats. */
  705.     //初始化重采样上下文
  706.     if (init_resampler(input_codec_context, output_codec_context,
  707.                        &resample_context))
  708.         goto cleanup;
  709.     /** Initialize the FIFO buffer to store audio samples to be encoded. */
  710.     //初始化音频fifo
  711.     if (init_fifo(&fifo, output_codec_context))
  712.         goto cleanup;
  713.     /** Write the header of the output file container. */
  714.     /
  715.     if (write_output_file_header(output_format_context))
  716.         goto cleanup;

  718.     /**
  719.      * Loop as long as we have input samples to read or output samples
  720.      * to write; abort as soon as we have neither.
  721.      */
  722.     while (1) {
  723.         /** Use the encoder's desired frame size for processing. */
  724.         const int output_frame_size = output_codec_context->frame_size;
  725.         int finished = 0;

  727.         /**
  728.          * Make sure that there is one frame worth of samples in the FIFO
  729.          * buffer so that the encoder can do its work.
  730.          * Since the decoder's and the encoder's frame size may differ, we
  731.          * need to FIFO buffer to store as many frames worth of input samples
  732.          * that they make up at least one frame worth of output samples.
  733.          */
  734.         //检查fifo里面的数据是否大于要输出的帧的大小，如果不大于，那么将解码转换的数据存放的fifo中
  735.         while (av_audio_fifo_size(fifo) < output_frame_size) {
  736.             /**
  737.              * Decode one frame worth of audio samples, convert it to the
  738.              * output sample format and put it into the FIFO buffer.
  739.              */
  740.             if (read_decode_convert_and_store(fifo, input_format_context,
  741.                                               input_codec_context,
  742.                                               output_codec_context,
  743.                                               resample_context, &finished))
  744.                 goto cleanup;

  746.             /**
  747.              * If we are at the end of the input file, we continue
  748.              * encoding the remaining audio samples to the output file.
  749.              */
  750.             if (finished)
  751.                 break;
  752.         }
  753.         
  754.         /**
  755.          * If we have enough samples for the encoder, we encode them.
  756.          * At the end of the file, we pass the remaining samples to
  757.          * the encoder.
  758.          */
  759.         //检查fifo数据是否大于输出帧的大小，或者（到文件末尾并且fifo数据长度大于0）
  760.         while (av_audio_fifo_size(fifo) >= output_frame_size ||
  761.                (finished && av_audio_fifo_size(fifo) > 0))
  762.             /**
  763.              * Take one frame worth of audio samples from the FIFO buffer,
  764.              * encode it and write it to the output file.
  765.              */
  766.             //读fifo，编码，写入文件
  767.             if (load_encode_and_write(fifo, output_format_context,
  768.                                       output_codec_context))
  769.                 goto cleanup;

  771.         /**
  772.          * If we are at the end of the input file and have encoded
  773.          * all remaining samples, we can exit this loop and finish.
  774.          */
  775.         if (finished) {
  776.             int data_written;
  777.             /** Flush the encoder as it may have delayed frames. */
  778.             //刷新编码器中可能存在的延时帧
  779.             do {
  780.                 if (encode_audio_frame(NULL, output_format_context,
  781.                                        output_codec_context, &data_written))
  782.                     goto cleanup;
  783.             } while (data_written);
  784.             break;
  785.         }
  786.     }

  788.     /** Write the trailer of the output file container. */
  789.     //写文件尾
  790.     if (write_output_file_trailer(output_format_context))
  791.         goto cleanup;
  792.     ret = 0;

  794. cleanup:
  795.     if (fifo)
  796.         av_audio_fifo_free(fifo);
  797.     swr_free(&resample_context);
  798.     if (output_codec_context)
  799.         avcodec_close(output_codec_context);
  800.     if (output_format_context) {
  801.         avio_closep(&output_format_context->pb);
  802.         avformat_free_context(output_format_context);
  803.     }
  804.     if (input_codec_context)
  805.         avcodec_close(input_codec_context);
  806.     if (input_format_context)
  807.         avformat_close_input(&input_format_context);

  809.     return ret;
  810. }
基本的流程：从输入文件中解码出一帧音频（音频数据保存在input_frame->extended_data），把音频数据进行格式转换并且保存到fifo中
从音频fifo中读音频数据（output_frame->data），进行编码，写入文件
1、从输入文件解码出一帧
avformat_open_input->avformat_find_stream_info->avcodec_find_decoder->avcodec_open2->av_frame_alloc->av_init_packet->av_read_frame->avcodec_decode_audio4(至此获得一帧音频数据)->av_free_packet->av_frame_free->avcodec_close->avformat_close_input
至此，已经获取了一帧数据
2、重采样
swr_alloc_set_opts->swr_init->av_samples_alloc->swr_convert->swr_free
3、音频fifo
av_audio_fifo_alloc->av_audio_fifo_realloc->av_audio_fifo_write->av_audio_fifo_read->av_audio_fifo_free
4、编码写入文件
avio_open->avformat_alloc_context->av_guess_format->avcodec_find_encoder->avformat_new_stream->avcodec_open2->avformat_write_header->av_frame_alloc->av_init_packet->avcodec_encode_audio2->av_write_frame->av_free_packet->av_frame_free->av_write_trailer

总结:音频fifo是比较重要的，fifo在处理音频的时候几乎是必须的，也可以自己实现一个fifo，不过ffmpeg既然实现了，自己写也一样，没啥必要
架构师视角：AI如何解决高等教育中的个性化学习难题？
AI天才研究院
08-02 1148
在“大规模标准化教育”与“个体差异化需求”的矛盾中，高等教育正面临着前所未有的“个性化危机”。作为一名深耕AI与教育领域的架构师，我曾参与过3所顶尖高校的个性化学习平台设计。——它能通过数据感知学生的差异，用算法匹配个性化的学习路径，最终让“因材施教”从理想走向现实。本文将从三个维度，拆解AI解决高等教育个性化学习难题的底层逻辑。无论你是教育行业的技术从业者，还是高校的IT管理者，都能从中找到可落地的思路。
FFmpeg4.2.2 交叉编译
夏的专栏
01-21 3072
这两天一直在编译FFmpeg库,实话真是踩坑不少,也知道了遇见问题该如何排错,所以还是打算记录下,也算是一个总结. 百度了解FFmpeg 环境和下载 1 .CentOs 8 2. android-ndk-r17c 3. ffmpeg-4.2.2 注意要下载linux版的ndk,在获取下载链接时候,通过wget下载到linux中 Configure帮助选项 查看帮助选项 ./configur...
FFMPEG学习记录及总结
廖阿明的博客
03-28 290
转载至： https://blog.youkuaiyun.com/li_wen01/article/details/60765749FFMPEG是一套非常强大的软件，他主要提供音视频格式转换，图像拉升，添加水印，视频截图等功能。关于FFMPEG的学习资料非常的多，以雷神为主的博客非常详细介绍了FFMPEG的使用和具体实现。但是雷神的博客多以Windows平台开发，对于我等初学者，能做的就是把他们应用到linu...
FFmpeg 学习：FFmpeg 学习整理总结
Linuxhus的博客
02-19 1334
一、FFmpeg 播放视频的基本流程整理 播放流程: video.avi(Container) -> 打开得到 Video_Stream -> 读取Packet -> 解析到 Frame -> 显示Frame。 Container：在音视频中的容器，一般指的是一种特定的文件格式(如 AVI/QT )，里面指明了所包含的音视频，字幕等相关信息。 Stream：媒体流，指时间轴上的一段连续数据，如一段声音、视频或字幕数据。 Packet：Stream中的Raw
ffmpeg: avio_reading.c 解读
hjjdebug的专栏
01-29 1188
avio_reading.c 解读 演示了avformat 是如何通过avio 来读取数据的,下面来看分析 1. ret = av_file_map(input_filename, &buffer, &buffer_size, 0, NULL); 将输入文件读入内存到buffer,并返回长度buffer_size, 把它放入结构bd中 2. fmt_ctx = avformat_alloc_context(); 分配一个format context, 只是一个头而已 ......
FFMPEG学习小结1
淡淡的宁静的博客
06-12 383
音视频处理包括 1.采集，编码，然后就是一个常见视频文件了。 2.将视频文件，进行解码，然后绘制，然后加上声音，就是视频播放了。 3.视频播放方案：使用VideoView（也是MediaPlayer+SurfaceView），接口较死，支持的格式少； 使用MediaPlayer+SurfaceView，自己封装； 使用FFMPEG+SurfaceView。 4.MediaPlayer使用的...
FFmpeg学习总结(一)
Dog9527的博客
03-28 565
FFmpeg 学习总结(一）前言FFmpeg基本概念 前言 学习了一段时间的ffmpeg，在此记录学习过程与走过的弯路，防止大家踩我走过的坑。 FFmpeg基本概念 FFmpeg是一套强大的视频处理开源计算机程序，包括播放、录制、转码、特效等，广泛应用于视频网站与商业领域。 1容器/文件 ...
FFmpeg之yuv格式转换(二十)
最新发布
2301_82242251的博客
05-06 1125
其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。当然我也为你们整理好了百度、阿里、腾讯、字节跳动等等互联网超级大厂的历年面试真题集锦。这也是我这些年来养成的习惯，一定要学会把好的东西，归纳整理，然后系统的消化吸收，这样才能极大的提高学习效率和成长进阶。碎片、零散化的东西，我觉得最没有价值的。就好比你给我一张扑克牌，我只会觉得它是一张废纸，但如果你给我一副扑克牌，它便有了它的价值。
多媒体基础复习资料总结
12-15
本复习资料旨在帮助理解和掌握多媒体技术的基础知识，为深入学习和应用提供扎实的理论基础。 一、多媒体概念 多媒体是指通过计算机对文字、图像、声音、视频等多种媒体信息进行数字化处理，并进行交互式操作的技术...
ffmpeg提取音频数据
qq_15255121的专栏
04-22 1208
学习就是要学习基础，学习原理。 所以大家想学习下面的内容，最好看下下面几篇我写的文章，然后再看下面的内容就会so easy. https://blog.youkuaiyun.com/qq_15255121/article/details/115168456 https://blog.youkuaiyun.com/qq_15255121/article/details/115301516 https://blog.youkuaiyun.com/qq_15255121/article/details/115348454 抽取音频数据
ffmpeg_avio_reading_demo.c例子
01-29
FFmpeg是领先的多媒体框架，能够解码，编码， 转码，复用，解复用，流，过滤和播放人类和机器创造的任何东西(ffmpeg avio reading demo.c)
FFMpeg学习总结
Sunny04的专栏
05-26 1025
参考：  http://blog.youkuaiyun.com/yang_xian521/article/details/7697324
学习ffmpeg心得
weixin_43360707的博客
01-14 324
刚接触ffmpeg感觉无从下手，看了一周资料，大致有点入门，下面说说如何学习： 1、首先官网 http://ffmpeg.org/doxygen/trunk/pages.html 这里有很多案例以及相关api接口的调用。 2、https://github.com/gongluck/FFmpeg4.0-study 这是个github 里面有音频冲采样以及推流等功能。 https://www.cnblogs.com/gongluck/category/1215138.html 这份资料非常好，有很多关于上述gi
ffmpeg学习心得
LANWENBING的专栏
07-27 218
1. 编译Mac ./configure --prefix=/usr/local/ffmpeg --enable-debug=3--enable-shared --disable-static make -j 4 make install mac 查看内核数量 macOS，查看CPU信息：sysctl machdep.cpu machdep.cpu.core_count: 2 核数为2 machdep.cpu.thread_count: 4 cpu数量为4个，使用了超线程技术：双核四线...
FFmpeg学习心得
狂奔的鱼の博客
02-12 289
单独编译FFmpeg某一模块的功能的时候，需要自行选取include和lib，往往会出现各种问题 首先是LINK2001或者LINK2019 ERRO，没有添加正确的DLL文件。 此时需要用到VS自带的一个工具Dumpbin.exe 进行dll依赖分析 C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Tools\...
ffmpeg编程的学习感受！
清闲老窝的专栏
06-28 3853
想用ffmpeg和arm编写一个摄像头远程监控的程序，开始使用了简单读取一帧数据，压缩一帧数据，然后传送一帧数据的模型，感觉太简单，就想使用一下真正的视频监控，于是考虑使用开源的库ffmpeg！开始信心十足，因为以前移植过jpeg库，使用过directshow库感觉都能够很快上手，但现在发现眼下的这个ffmpeg绝不是那么好对付的。究其原因：一、资料太少，版本兼容性太差，这似乎是所有开源软件的
ffmpeg心得体会
lin111000713的专栏
12-08 415
1.ffmpeg某个成员变量不知道为何引入？作用？google： 成员变量 FFmpeg-cvslog 就能搜索到引入这个成员变量的log
ffmpeg解码流程
q506616671的专栏
12-17 2779
FFMPEG解码流程: 1. 注册所有容器格式和CODEC:av_register_all() 2. 打开文件:av_open_input_file() 3. 从文件中提取流信息:av_find_stream_info() 4. 穷举所有的流，查找其中种类为CODEC_TYPE_VIDEO 5. 查找对应的解码器:avcodec_find_decoder() 6. 打开编解码器:a
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值