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>
   
6. 
   
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);
    
17. 
    
18.     printf("ptr:%p size:%zu\n", bd->ptr, bd->size);
    
19. 
    
20.     /* copy internal buffer data to buf */
    
21.     memcpy(buf, bd->ptr, buf_size);
    
22.     bd->ptr += buf_size;
    
23.     bd->size -= buf_size;
    
24. 
    
25.     return buf_size;
    
26. }
    
27. 
    
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 };
    
39. 
    
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];
    
47. 
    
48.     /* register codecs and formats and other lavf/lavc components*/
    
49.     av_register_all();
    
50. 
    
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;
    
56. 
    
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.     }
    
67. 
    
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);
    
99. 
    
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);
     
110. 
     
111.     if (ret < 0) {
     
112. // fprintf(stderr, "Error occurred: %s\n", av_err2str(ret));
     
113.         return 1;
     
114.     }
     
115. 
     
116.     return 0;
     
117. }

运行结果

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

点击(此处)折叠或打开

1. //metadata.c
2. #include <stdio.h>
   
3. 
   
4. #include <libavformat/avformat.h>
   
5. #include <libavutil/dict.h>
   
6. 
   
7. int main (int argc, char **argv)
   
8. {
   
9.     AVFormatContext *fmt_ctx = NULL;
   
10.     //“字典入口”，用来保存AVDictionary变量里面的每一个“字”
    
11.     AVDictionaryEntry *tag = NULL;
    
12.     int ret;
    
13. 
    
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.     }
    
20. 
    
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);
    
27. 
    
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>
   
6. 
   
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;
    
21. 
    
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.     }
    
29. 
    
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. }
    
35. 
    
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;
    
44. 
    
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. }
    
54. 
    
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;
    
78. 
    
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];
    
88. 
    
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.     }
    
94. 
    
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.     }
     
103. 
     
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);
     
113. 
     
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.     }
     
120. 
     
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.     }
     
131. 
     
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);
     
138. 
     
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.     }
     
147. 
     
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);
     
152. 
     
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.         }
     
166. 
     
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);
     
185. 
     
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);
     
193. 
     
194. end:
     
195.     fclose(dst_file);
     
196. 
     
197.     if (src_data)
     
198.         av_freep(&src_data[0]);
     
199.     av_freep(&src_data);
     
200. 
     
201.     if (dst_data)
     
202.         av_freep(&dst_data[0]);
     
203.     av_freep(&dst_data);
     
204. 
     
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.  */
    
18. 
    
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.  */
    
27. 
    
28. #include <stdio.h>
    
29. 
    
30. #include "libavformat/avformat.h"
    
31. #include "libavformat/avio.h"
    
32. 
    
33. #include "libavcodec/avcodec.h"
    
34. 
    
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"
    
40. 
    
41. #include "libswresample/swresample.h"
    
42. 
    
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
    
47. 
    
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. }
    
59. 
    
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;
    
67. 
    
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.     }
    
77. 
    
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.     }
    
96. 
    
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.     }
     
104. 
     
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.     }
     
114. 
     
115.     /** Save the decoder context for easier access later. */
     
116.     *input_codec_context = (*input_format_context)->streams[0]->codec;
     
117. 
     
118.     return 0;
     
119. }
     
120. 
     
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;
     
135. 
     
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.     }
     
150. 
     
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.     }
     
157. 
     
158.     /** Associate the output file (pointer) with the container format context. */
     
159.     //指定格式上下文的io上下文
     
160.     (*output_format_context)->pb = output_io_context;
     
161. 
     
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.     }
     
170. 
     
171.     av_strlcpy((*output_format_context)->filename, filename,
     
172.                sizeof((*output_format_context)->filename));
     
173. 
     
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.     }
     
180. 
     
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.     }
     
188. 
     
189.     /** Save the encoder context for easier access later. */
     
190.     *output_codec_context = stream->codec;
     
191. 
     
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;//码率
     
202. 
     
203.     /** Allow the use of the experimental AAC encoder */
     
204.     (*output_codec_context)->strict_std_compliance = FF_COMPLIANCE_EXPERIMENTAL;
     
205. 
     
206.     /** Set the sample rate for the container. */
     
207.     stream->time_base.den = input_codec_context->sample_rate;
     
208.     stream->time_base.num = 1;
     
209. 
     
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;
     
216. 
     
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.     }
     
224. 
     
225.     return 0;
     
226. 
     
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. }
     
233. 
     
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. }
     
242. 
     
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. }
     
252. 
     
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;
     
263. 
     
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);
     
291. 
     
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. }
     
300. 
     
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. }
     
312. 
     
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. }
     
325. 
     
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);
     
336. 
     
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.     }
     
348. 
     
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.     }
     
362. 
     
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. }
     
372. 
     
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;
     
383. 
     
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.     }
     
394. 
     
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. }
     
412. 
     
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;
     
423. 
     
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.     }
     
432. 
     
433.     return 0;
     
434. }
     
435. 
     
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;
     
442. 
     
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.     }
     
451. 
     
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. }
     
460. 
     
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;
     
478. 
     
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;
     
503. 
     
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;
     
511. 
     
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;
     
519. 
     
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);
     
526. 
     
527.     return ret;
     
528. }
     
529. 
     
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;
     
539. 
     
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.     }
     
545. 
     
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;
     
557. 
     
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.     }
     
568. 
     
569.     return 0;
     
570. }
     
571. 
     
572. /** Global timestamp for the audio frames */
     
573. static int64_t pts = 0;
     
574. 
     
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);
     
585. 
     
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.     }
     
591. 
     
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.     }
     
603. 
     
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.         }
     
612. 
     
613.         av_free_packet(&output_packet);
     
614.     }
     
615. 
     
616.     return 0;
     
617. }
     
618. 
     
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;
     
637. 
     
638.     /** Initialize temporary storage for one output frame. */
     
639.     if (init_output_frame(&output_frame, output_codec_context, frame_size))
     
640.         return AVERROR_EXIT;
     
641. 
     
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.     }
     
651. 
     
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. }
     
661. 
     
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. }
     
673. 
     
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;
     
686. 
     
687.     if (argc < 3) {
     
688.         fprintf(stderr, "Usage: %s  \n", argv[0]);
     
689.         exit(1);
     
690.     }
     
691. 
     
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;
     
717. 
     
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;
     
726. 
     
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;
     
745. 
     
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;
     
770. 
     
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.     }
     
787. 
     
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;
     
793. 
     
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);
     
808. 
     
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既然实现了，自己写也一样，没啥必要