ffmpeg转码常用容器编码格式与解编码器的搭配总结，-c与-f参数的运用

Posted 2023-04-07 戴国进

转码

现今常用的一些编码格式以及它们所支持的容器格式如下：

特别提一点，mkv是个万能的容器格式，下面说的所有编码格式，mkv几乎都能“装”，就不再列出了。

视频编码格式：

h264（又称mpeg-4 avc、mpeg-4 part 10）：mp4、flv、avi、mov、wmv、m4v、f4v、3gp、ts

mpeg4（不只一种，这里指mpeg-4 part 2、divx、xvid）：mp4、avi、mov、wmv、m4v、3gp、ts

h265（又称hevc、mpeg-h part 2）：mp4、avi、mov、ts

vp8：avi、wmv、ts、webm

vp9：mp4、avi、wmv、ts、webm

音频编码格式：（【】左边是视频容器格式，【】右边是音频容器格式，*和^后面再说明）

aac：mp4、flv、avi、mov、wmv、3gp、m4v、f4v、ts【】aac、m4a、wma、ac3

mp3：mp4、avi、mov、wmv、f4v、ts【】mp3、wma、ac3

ac-3：mp4、avi*、mov、wmv、m4v、ts【】ac3、m4a、wma

flac：mp4*、avi*、wmv、ts【】flac、m4a、wma、ac3^

vorbis：mp4、avi*、mov、wmv、ts、webm【】ogg、wma、ac3^

opus：mp4*、ts、webm【】ogg、ac3^

（*的意思是需要进一步使用相应参数，小白不建议）

（^的意思是能转码成功，但很可能播放器不能播放）

（一般听感来说，上述中opus编码格式是有损编码里最好的，其次是vorbis，之后是aac、mp3之类）

（ffmpeg似乎不支持ape容器格式）

对新人来说看到这些庞杂的格式可能很懵，通俗说明一下：“一样容器能装不同菜，一样菜能盛在不同容器”的道理，我们只要找到菜和容器都互相能“接受”的组合就行了。只是视频是一个容器两道菜（画面和声音），音频就一个容器一道菜。

反之，上面列的这些，也可以理解为视音频容器格式所支持的编码格式。上期说一个视频有画面和声音，那么画和声就有它俩各自的编码格式，所以对一个现存的视频来说，它的容器格式要同时支持画和声的编码格式；音频就只有声音的编码格式，和它的容器格式互相支持就可以。

这里指出两点前提：以原文件的编码为参考，ffmpeg的支持。

虽然有着许多的格式，但目前大多数视频的编码格式是h264和aac，音频的编码格式是mp3或aac。因此，只要不同的容器格式之间能同时支持一样的编码格式，就能够进行“高效转码”。

例如同时支持h264和aac的有mp4、flv、avi、mov、wmv……满足这个前提后，这些容器两两之间都可以任意“高效转码”。可如果像上期说的，只知道容器格式mp4和flv，并不能直接认为它俩可以用“-c copy”“高效转码”。

对于需要转换编码格式的音视频，用ffmpeg的前提是ffmpeg要能支持我们想转的编码格式。ffmpeg就像一个批发中心，但它的货总归还是有限的。

不过对于无需转换编码格式的情况，即便是ffmpeg不支持的编码格式，也能用“-c copy”复制照抄（例如将原视频转码成mkv，可理解为原视频中的编码格式给ffmpeg提供了个“模板”），但是如果ffmpeg不支持最后输出文件的容器格式的话，就不能这样转码。

除了音视频，ffmpeg还可以转码字幕和图像文件：

（直接按“输入→输出”流程即可，例如ffmpeg -i .\\input.png output.jpg）

（srt转码ass要注意srt先以记事本打开，另存为将编码改成UTF-8或unicode）

字幕容器格式：srt、ass、ssa之间两两任意互转

图像容器格式：jpg、jpeg、png、bmp、gif、webp之间两两任意互转

-c与-f参数的运用

若要转换编码格式，我们将运用“-c”来使用ffmpeg支持的编解码器。

“-c”参数包括了音视频的全部编解码器，所以以前的“-c copy”是复制音视频编码的意思。当然我们也可以直接用“-c copy”转码音频，没有视频也没关系。

要只对视频里的画面或者声音进行操作的话，我们可以用“-c:v”来限定只处理视频画面，“-c:a”来限定只处理视频里的音频声音，“-c:s”来限定只处理字幕。

经常用的比如“-c:v libx264”，表示将编码格式转换成h264；“-c:a libmp3lame”，表示将编码格式转换成mp3。

这里的“libx264”、“libmp3lame”是编码器的名字（文末再说编码器名怎么得知）。简单形象地说，“容器格式、编码格式、编码器”的一个可行搭配是“avi、（h264、mp3）、（libx264、libmp3lame）”。

我们也可以用“-c:v h264”、“-c:a mp3”来进行上述操作，这样的话不用知道编码器名也可以。如下图：

ffmpeg里的“stream”可以理解为“流”、“轨道”、“通道”。红圈里的是编码格式转换的指示说明，从原来的什么转换成什么。例如上图是，视频编码格式从mpeg4转换成h264，视频里的音频编码格式从aac转换成mp3。

我们还可以通过“-f”参数来进行转码。“-f”，“format，格式”的意思，强制输出什么格式的文件，让ffmpeg自行挑选编解码器进行转码输出。但只是一般情况来说，就像前面说过ffmpeg的支持也是有限的，不支持的话当然也转码输出不了。

这个“-f”可以用来“查询”自己想转的容器格式是有什么编码格式或编码器可以支持。它的用法例如“-f webm”。如下图：

这说明vp9和opus是webm容器格式支持的编码格式。

（在一些时候，用“-f”参数转码完的视频质量会不好，这个以后再说）

转码思路流程

①先用命令行ffprobe .\\input.mp4

查看文件的编码格式，如下图：

红圈表示该视频的画面（video）编码格式是h264，声音（audio）编码格式是aac

另外，一般查看文件属性也可以知道其编码格式

②确定自己想转的容器或编码格式

③用“ffmpeg -formats”命令行

查询ffmpeg支持哪些容器格式。如下图

demuxing是“解封装”的意思，muxing是“封装”的意思，

就像容器格式又称封装格式

转码也可以看作是封装

解封装就可以看作是转码的相反操作

还有，用“ffmpeg -codecs”命令行

查询ffmpeg支持哪些编码格式及编解码器名。如下图

decoder指解码器名，encoder指编码器名，以此类推

④输入相应命令行进行转码

FFMPEG实现的转码程序

本例子是由FFEMPG的doc/example例子transcode.c修改而来，可以根据需求任意转换音视频的编码。

 

原来的例子的作用更类似于remux，并没有实现转码的功能，只是实现了格式转换，比如ts转avi等。并不能实现音视频编码格式的转换，比如将h264转为mpeg2。

 

FFMPEG转码的实现有多种方式：

一种方式是：流解复用->视频+音频流->解码->YUV/PCM等->视音频编码->重新生成的音视频流->复用->流

另一种方式依赖AVFilter，这一部分在另外的几篇文章中解释怎么用。虽然AVFilter学习起来可能比较困难，但是在实际的编程应用中，依靠AVFilter做转码效率比第一种方式高，并且解码的CPU和时间消耗也少的多。所以，还是建议好好学习这部分的，毕竟我一直觉得FFMPEG的强项就是解码和转码。

 

 

本例子是视频mpeg2转h264，音频mpegaudio转g711。

 

[cpp] view plain copy

 

 print?

1. <span style="font-family:SimHei;font-size:18px;">/* 
2. * based on FFMPEG transcode.c 
3. * modified by tongli 
4. */  
5. #include <stdio.h>  
6. #include "snprintf.h"  
7. extern "C"  
8. {  
9. #include <libavcodec/avcodec.h>  
10. #include <libavformat/avformat.h>  
11. #include <libavfilter/avfiltergraph.h>  
12. #include <libavfilter/avcodec.h>  
13. #include <libavfilter/buffersink.h>  
14. #include <libavfilter/buffersrc.h>  
15. #include <libavutil/opt.h>  
16. #include <libavutil/pixdesc.h>  
17. }  
18. static AVFormatContext *ifmt_ctx;  
19. static AVFormatContext *ofmt_ctx;  
20. typedef struct FilteringContext {  
21.     AVFilterContext *buffersink_ctx;  
22.     AVFilterContext *buffersrc_ctx;  
23.     AVFilterGraph *filter_graph;  
24. } FilteringContext;  
25. static FilteringContext *filter_ctx;  
26.   
27. static int open_input_file(const char *filename)  
28. {  
29.     int ret;  
30.     unsigned int i;  
31.   
32.     ifmt_ctx = NULL;  
33.     if ((ret = avformat_open_input(&ifmt_ctx, filename, NULL, NULL)) < 0) {  
34.         av_log(NULL, AV_LOG_ERROR, "Cannot open input file\n");  
35.         return ret;  
36.     }  
37.   
38.     if ((ret = avformat_find_stream_info(ifmt_ctx, NULL)) < 0) {  
39.         av_log(NULL, AV_LOG_ERROR, "Cannot find stream information\n");  
40.         return ret;  
41.     }  
42.   
43.     for (i = 0; i < ifmt_ctx->nb_streams; i++) {  
44.         AVStream *stream;  
45.         AVCodecContext *codec_ctx;  
46.         stream = ifmt_ctx->streams[i];  
47.         codec_ctx = stream->codec;  
48.         /* Reencode video & audio and remux subtitles etc. */  
49.         if (codec_ctx->codec_type == AVMEDIA_TYPE_VIDEO  
50.             || codec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {  
51.             /* Open decoder */  
52.             ret = avcodec_open2(codec_ctx,  
53.                 avcodec_find_decoder(codec_ctx->codec_id), NULL);  
54.             if (ret < 0) {  
55.                 av_log(NULL, AV_LOG_ERROR, "Failed to open decoder for stream #%u\n", i);  
56.                 return ret;  
57.             }  
58.         }  
59.     }  
60.   
61.     av_dump_format(ifmt_ctx, 0, filename, 0);  
62.     return 0;  
63. }  
64.   
65. static int open_output_file(const char *filename)  
66. {  
67.     AVStream *out_stream;  
68.     AVStream *in_stream;  
69.     AVCodecContext *dec_ctx, *enc_ctx;  
70.     AVCodec *encoder;  
71.     int ret;  
72.     unsigned int i;  
73.   
74.     ofmt_ctx = NULL;  
75.     avformat_alloc_output_context2(&ofmt_ctx, NULL, NULL, filename);  
76.     if (!ofmt_ctx) {  
77.         av_log(NULL, AV_LOG_ERROR, "Could not create output context\n");  
78.         return AVERROR_UNKNOWN;  
79.     }  
80.   
81.     for (i = 0; i < ifmt_ctx->nb_streams; i++) {  
82.         out_stream = avformat_new_stream(ofmt_ctx, NULL);  
83.         if (!out_stream) {  
84.             av_log(NULL, AV_LOG_ERROR, "Failed allocating output stream\n");  
85.             return AVERROR_UNKNOWN;  
86.         }  
87.   
88.         in_stream = ifmt_ctx->streams[i];  
89.         dec_ctx = in_stream->codec;  
90.         enc_ctx = out_stream->codec;  
91.   
92.         if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO)   
93.         {  
94.             encoder = avcodec_find_encoder(AV_CODEC_ID_H264);  
95.             if (!encoder) {  
96.                 av_log(NULL, AV_LOG_FATAL, "Neccessary encoder not found\n");  
97.                 return AVERROR_INVALIDDATA;  
98.             }  
99.   
100.             enc_ctx->height = dec_ctx->height;  
101.             enc_ctx->width = dec_ctx->width;  
102.             enc_ctx->sample_aspect_ratio = dec_ctx->sample_aspect_ratio;  
103.                   
104.             enc_ctx->pix_fmt = encoder->pix_fmts[0];  
105.                   
106.             enc_ctx->time_base = dec_ctx->time_base;  
107.   
108.             enc_ctx->me_range = 16;  
109.             enc_ctx->max_qdiff = 4;  
110.             enc_ctx->qmin = 10;  
111.             enc_ctx->qmax = 51;  
112.             enc_ctx->qcompress = 0.6;  
113.             enc_ctx->refs = 3;  
114.             enc_ctx->bit_rate = 500000;  
115.               
116.             ret = avcodec_open2(enc_ctx, encoder, NULL);  
117.             if (ret < 0) {  
118.                 av_log(NULL, AV_LOG_ERROR, "Cannot open video encoder for stream #%u\n", i);  
119.                 return ret;  
120.             }  
121.         }  
122.         else if (dec_ctx->codec_type == AVMEDIA_TYPE_UNKNOWN) {  
123.             av_log(NULL, AV_LOG_FATAL, "Elementary stream #%d is of unknown type, cannot proceed\n", i);  
124.             return AVERROR_INVALIDDATA;  
125.         }  
126.         else if (dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO)  
127.         {  
128.             encoder = avcodec_find_encoder(AV_CODEC_ID_PCM_ALAW);  
129.             enc_ctx->sample_rate = dec_ctx->sample_rate;  
130.             enc_ctx->channel_layout = dec_ctx->channel_layout;  
131.             enc_ctx->channels = av_get_channel_layout_nb_channels(enc_ctx->channel_layout);  
132.             enc_ctx->sample_fmt = encoder->sample_fmts[0];  
133.             AVRational ar = { 1, enc_ctx->sample_rate };  
134.             enc_ctx->time_base = ar;  
135.   
136.             ret = avcodec_open2(enc_ctx, encoder, NULL);  
137.             if (ret < 0) {  
138.                 av_log(NULL, AV_LOG_ERROR, "Cannot open video encoder for stream #%u\n", i);  
139.                 return ret;  
140.             }  
141.         }  
142.         else {  
143.             ret = avcodec_copy_context(ofmt_ctx->streams[i]->codec,  
144.                 ifmt_ctx->streams[i]->codec);  
145.             if (ret < 0) {  
146.                 av_log(NULL, AV_LOG_ERROR, "Copying stream context failed\n");  
147.                 return ret;  
148.             }  
149.         }  
150.   
151.         if (ofmt_ctx->oformat->flags & AVFMT_GLOBALHEADER)  
152.             enc_ctx->flags |= CODEC_FLAG_GLOBAL_HEADER;  
153.   
154.     }  
155.     av_dump_format(ofmt_ctx, 0, filename, 1);  
156.   
157.     if (!(ofmt_ctx->oformat->flags & AVFMT_NOFILE)) {  
158.         ret = avio_open(&ofmt_ctx->pb, filename, AVIO_FLAG_WRITE);  
159.         if (ret < 0) {  
160.             av_log(NULL, AV_LOG_ERROR, "Could not open output file ‘%s‘", filename);  
161.             return ret;  
162.         }  
163.     }  
164.   
165.     /* init muxer, write output file header */  
166.     ret = avformat_write_header(ofmt_ctx, NULL);  
167.     if (ret < 0) {  
168.         av_log(NULL, AV_LOG_ERROR, "Error occurred when opening output file\n");  
169.         return ret;  
170.     }  
171.   
172.     return 0;  
173. }  
174.   
175. static int init_filter(FilteringContext* fctx, AVCodecContext *dec_ctx,  
176.     AVCodecContext *enc_ctx, const char *filter_spec)  
177. {  
178.     char args[512];  
179.     int ret = 0;  
180.     AVFilter *buffersrc = NULL;  
181.     AVFilter *buffersink = NULL;  
182.     AVFilterContext *buffersrc_ctx = NULL;  
183.     AVFilterContext *buffersink_ctx = NULL;  
184.     AVFilterInOut *outputs = avfilter_inout_alloc();  
185.     AVFilterInOut *inputs = avfilter_inout_alloc();  
186.     AVFilterGraph *filter_graph = avfilter_graph_alloc();  
187.   
188.     if (!outputs || !inputs || !filter_graph) {  
189.         ret = AVERROR(ENOMEM);  
190.         goto end;  
191.     }  
192.   
193.     if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {  
194.         buffersrc = avfilter_get_by_name("buffer");  
195.         buffersink = avfilter_get_by_name("buffersink");  
196.         if (!buffersrc || !buffersink) {  
197.             av_log(NULL, AV_LOG_ERROR, "filtering source or sink element not found\n");  
198.             ret = AVERROR_UNKNOWN;  
199.             goto end;  
200.         }  
201.   
202.         snprintf(args, sizeof(args),  
203.             "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",  
204.             dec_ctx->width, dec_ctx->height, dec_ctx->pix_fmt,  
205.             dec_ctx->time_base.num, dec_ctx->time_base.den,  
206.             dec_ctx->sample_aspect_ratio.num,  
207.             dec_ctx->sample_aspect_ratio.den);  
208.   
209.         ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",  
210.             args, NULL, filter_graph);  
211.         if (ret < 0) {  
212.             av_log(NULL, AV_LOG_ERROR, "Cannot create buffer source\n");  
213.             goto end;  
214.         }  
215.   
216.         ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",  
217.             NULL, NULL, filter_graph);  
218.         if (ret < 0) {  
219.             av_log(NULL, AV_LOG_ERROR, "Cannot create buffer sink\n");  
220.             goto end;  
221.         }  
222.   
223.         ret = av_opt_set_bin(buffersink_ctx, "pix_fmts",  
224.             (uint8_t*)&enc_ctx->pix_fmt, sizeof(enc_ctx->pix_fmt),  
225.             AV_OPT_SEARCH_CHILDREN);  
226.         if (ret < 0) {  
227.             av_log(NULL, AV_LOG_ERROR, "Cannot set output pixel format\n");  
228.             goto end;  
229.         }  
230.     }  
231.     else if (dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {  
232.         buffersrc = avfilter_get_by_name("abuffer");  
233.         buffersink = avfilter_get_by_name("abuffersink");  
234.         if (!buffersrc || !buffersink) {  
235.             av_log(NULL, AV_LOG_ERROR, "filtering source or sink element not found\n");  
236.             ret = AVERROR_UNKNOWN;  
237.             goto end;  
238.         }  
239.   
240.         if (!dec_ctx->channel_layout)  
241.             dec_ctx->channel_layout =  
242.             av_get_default_channel_layout(dec_ctx->channels);  
243.         snprintf(args, sizeof(args),  
244.             "time_base=%d/%d:sample_rate=%d:sample_fmt=%s:channel_layout=0x%"PRIx64,  
245.             dec_ctx->time_base.num, dec_ctx->time_base.den, dec_ctx->sample_rate,  
246.             av_get_sample_fmt_name(dec_ctx->sample_fmt),  
247.             dec_ctx->channel_layout);  
248.         ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",  
249.             args, NULL, filter_graph);  
250.         if (ret < 0) {  
251.             av_log(NULL, AV_LOG_ERROR, "Cannot create audio buffer source\n");  
252.             goto end;  
253.         }  
254.   
255.         ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",  
256.             NULL, NULL, filter_graph);  
257.         if (ret < 0) {  
258.             av_log(NULL, AV_LOG_ERROR, "Cannot create audio buffer sink\n");  
259.             goto end;  
260.         }  
261.   
262.         ret = av_opt_set_bin(buffersink_ctx, "sample_fmts",  
263.             (uint8_t*)&enc_ctx->sample_fmt, sizeof(enc_ctx->sample_fmt),  
264.             AV_OPT_SEARCH_CHILDREN);  
265.         if (ret < 0) {  
266.             av_log(NULL, AV_LOG_ERROR, "Cannot set output sample format\n");  
267.             goto end;  
268.         }  
269.   
270.         ret = av_opt_set_bin(buffersink_ctx, "channel_layouts",  
271.             (uint8_t*)&enc_ctx->channel_layout,  
272.             sizeof(enc_ctx->channel_layout), AV_OPT_SEARCH_CHILDREN);  
273.         if (ret < 0) {  
274.             av_log(NULL, AV_LOG_ERROR, "Cannot set output channel layout\n");  
275.             goto end;  
276.         }  
277.   
278.         ret = av_opt_set_bin(buffersink_ctx, "sample_rates",  
279.             (uint8_t*)&enc_ctx->sample_rate, sizeof(enc_ctx->sample_rate),  
280.             AV_OPT_SEARCH_CHILDREN);  
281.         if (ret < 0) {  
282.             av_log(NULL, AV_LOG_ERROR, "Cannot set output sample rate\n");  
283.             goto end;  
284.         }  
285.     }  
286.     else {  
287.         ret = AVERROR_UNKNOWN;  
288.         goto end;  
289.     }  
290.   
291.     /* Endpoints for the filter graph. */  
292.     outputs->name = av_strdup("in");  
293.     outputs->filter_ctx = buffersrc_ctx;  
294.     outputs->pad_idx = 0;  
295.     outputs->next = NULL;  
296.   
297.     inputs->name = av_strdup("out");  
298.     inputs->filter_ctx = buffersink_ctx;  
299.     inputs->pad_idx = 0;  
300.     inputs->next = NULL;  
301.   
302.     if (!outputs->name || !inputs->name) {  
303.         ret = AVERROR(ENOMEM);  
304.         goto end;  
305.     }  
306.   
307.     if ((ret = avfilter_graph_parse_ptr(filter_graph, filter_spec,  
308.         &inputs, &outputs, NULL)) < 0)  
309.         goto end;  
310.   
311.     if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0)  
312.         goto end;  
313.   
314.     /* Fill FilteringContext */  
315.     fctx->buffersrc_ctx = buffersrc_ctx;  
316.     fctx->buffersink_ctx = buffersink_ctx;  
317.     fctx->filter_graph = filter_graph;  
318.   
319. end:  
320.     avfilter_inout_free(&inputs);  
321.     avfilter_inout_free(&outputs);  
322.   
323.     return ret;  
324. }  
325.   
326. static int init_filters(void)  
327. {  
328.     const char *filter_spec;  
329.     unsigned int i;  
330.     int ret;  
331.     filter_ctx = (FilteringContext*)av_malloc_array(ifmt_ctx->nb_streams, sizeof(*filter_ctx));  
332.     if (!filter_ctx)  
333.         return AVERROR(ENOMEM);  
334.   
335.     for (i = 0; i < ifmt_ctx->nb_streams; i++) {  
336.         filter_ctx[i].buffersrc_ctx = NULL;  
337.         filter_ctx[i].buffersink_ctx = NULL;  
338.         filter_ctx[i].filter_graph = NULL;  
339.         if (!(ifmt_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO  
340.             || ifmt_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO))  
341.             continue;  
342.   
343.   
344.         if (ifmt_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO)  
345.             filter_spec = "null"; /* passthrough (dummy) filter for video */  
346.         else  
347.             filter_spec = "anull"; /* passthrough (dummy) filter for audio */  
348.         ret = init_filter(&filter_ctx[i], ifmt_ctx->streams[i]->codec,  
349.             ofmt_ctx->streams[i]->codec, filter_spec);  
350.         if (ret)  
351.             return ret;  
352.     }  
353.     return 0;  
354. }  
355.   
356. static int encode_write_frame(AVFrame *filt_frame, unsigned int stream_index, int *got_frame) {  
357.     int ret;  
358.     int got_frame_local;  
359.     AVPacket enc_pkt;  
360.     int(*enc_func)(AVCodecContext *, AVPacket *, const AVFrame *, int *) =  
361.         (ifmt_ctx->streams[stream_index]->codec->codec_type ==  
362.         AVMEDIA_TYPE_VIDEO) ? avcodec_encode_video2 : avcodec_encode_audio2;  
363.   
364.     if (!got_frame)  
365.         got_frame = &got_frame_local;  
366.   
367.     av_log(NULL, AV_LOG_INFO, "Encoding frame\n");  
368.     /* encode filtered frame */  
369.     enc_pkt.data = NULL;  
370.     enc_pkt.size = 0;  
371.     av_init_packet(&enc_pkt);  
372.     ret = enc_func(ofmt_ctx->streams[stream_index]->codec, &enc_pkt,  
373.         filt_frame, got_frame);  
374.     av_frame_free(&filt_frame);  
375.     if (ret < 0)  
376.         return ret;  
377.     if (!(*got_frame))  
378.         return 0;  
379.   
380.     /* prepare packet for muxing */  
381.     enc_pkt.stream_index = stream_index;  
382.     av_packet_rescale_ts(&enc_pkt,  
383.         ofmt_ctx->streams[stream_index]->codec->time_base,  
384.         ofmt_ctx->streams[stream_index]->time_base);  
385.   
386.     av_log(NULL, AV_LOG_DEBUG, "Muxing frame\n");  
387.     /* mux encoded frame */  
388.     ret = av_interleaved_write_frame(ofmt_ctx, &enc_pkt);  
389.     return ret;  
390. }  
391.   
392. static int filter_encode_write_frame(AVFrame *frame, unsigned int stream_index)  
393. {  
394.     int ret;  
395.     AVFrame *filt_frame;  
396.   
397.     av_log(NULL, AV_LOG_INFO, "Pushing decoded frame to filters\n");  
398.     /* push the decoded frame into the filtergraph */  
399.     ret = av_buffersrc_add_frame_flags(filter_ctx[stream_index].buffersrc_ctx,  
400.         frame, 0);  
401.     if (ret < 0) {  
402.         av_log(NULL, AV_LOG_ERROR, "Error while feeding the filtergraph\n");  
403.         return ret;  
404.     }  
405.   
406.     /* pull filtered frames from the filtergraph */  
407.     while (1) {  
408.         filt_frame = av_frame_alloc();  
409.         if (!filt_frame) {  
410.             ret = AVERROR(ENOMEM);  
411.             break;  
412.         }  
413.         av_log(NULL, AV_LOG_INFO, "Pulling filtered frame from filters\n");  
414.         ret = av_buffersink_get_frame(filter_ctx[stream_index].buffersink_ctx,  
415.             filt_frame);  
416.         if (ret < 0) {  
417.             /* if no more frames for output - returns AVERROR(EAGAIN) 
418.             * if flushed and no more frames for output - returns AVERROR_EOF 
419.             * rewrite retcode to 0 to show it as normal procedure completion 
420.             */  
421.             if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)  
422.                 ret = 0;  
423.             av_frame_free(&filt_frame);  
424.             break;  
425.         }  
426.   
427.         filt_frame->pict_type = AV_PICTURE_TYPE_NONE;  
428.         ret = encode_write_frame(filt_frame, stream_index, NULL);  
429.         if (ret < 0)  
430.             break;  
431.     }  
432.   
433.     return ret;  
434. }  
435.   
436. static int flush_encoder(unsigned int stream_index)  
437. {  
438.     int ret;  
439.     int got_frame;  
440.   
441.     if (!(ofmt_ctx->streams[stream_index]->codec->codec->capabilities &  
442.         CODEC_CAP_DELAY))  
443.         return 0;  
444.   
445.     while (1) {  
446.         av_log(NULL, AV_LOG_INFO, "Flushing stream #%u encoder\n", stream_index);  
447.         ret = encode_write_frame(NULL, stream_index, &got_frame);  
448.         if (ret < 0)  
449.             break;  
450.         if (!got_frame)  
451.             return 0;  
452.     }  
453.     return ret;  
454. }  
455.   
456. int main(int argc, char **argv)  
457. {  
458.     int ret;  
459.     AVPacket packet; //= { .data = NULL, .size = 0 };  
460.     packet.data = NULL;  
461.     packet.size = 0;  
462.     AVFrame *frame = NULL;  
463.     enum AVMediaType type;  
464.     unsigned int stream_index;  
465.     unsigned int i;  
466.     int got_frame;  
467.     int(*dec_func)(AVCodecContext *, AVFrame *, int *, const AVPacket *);  
468.   
469.     av_register_all();  
470.     avfilter_register_all();  
471.   
472.     if ((ret = open_input_file("test.ts")) < 0)  
473.         goto end;  
474.     if ((ret = open_output_file("test.avi")) < 0)  
475.         goto end;  
476.     if ((ret = init_filters()) < 0)  
477.         goto end;  
478.   
479.     /* read all packets */  
480.     while (1) {  
481.         if ((ret = av_read_frame(ifmt_ctx, &packet)) < 0)  
482.             break;  
483.         stream_index = packet.stream_index;  
484.         type = ifmt_ctx->streams[packet.stream_index]->codec->codec_type;  
485.         av_log(NULL, AV_LOG_DEBUG, "Demuxer gave frame of stream_index %u\n",  
486.             stream_index);  
487.   
488.         if (filter_ctx[stream_index].filter_graph) {  
489.             av_log(NULL, AV_LOG_DEBUG, "Going to reencode&filter the frame\n");  
490.             frame = av_frame_alloc();  
491.             if (!frame) {  
492.                 ret = AVERROR(ENOMEM);  
493.                 break;  
494.             }  
495.             av_packet_rescale_ts(&packet,  
496.                 ifmt_ctx->streams[stream_index]->time_base,  
497.                 ifmt_ctx->streams[stream_index]->codec->time_base);  
498.             dec_func = (type == AVMEDIA_TYPE_VIDEO) ? avcodec_decode_video2 :  
499.                 avcodec_decode_audio4;  
500.             ret = dec_func(ifmt_ctx->streams[stream_index]->codec, frame,  
501.                 &got_frame, &packet);  
502.             if (ret < 0) {  
503.                 av_frame_free(&frame);  
504.                 av_log(NULL, AV_LOG_ERROR, "Decoding failed\n");  
505.                 break;  
506.             }  
507.   
508.             if (got_frame) {  
509.                 frame->pts = av_frame_get_best_effort_timestamp(frame);  
510.                 ret = filter_encode_write_frame(frame, stream_index);  
511.                 av_frame_free(&frame);  
512.                 if (ret < 0)  
513.                     goto end;  
514.             }  
515.             else {  
516.                 av_frame_free(&frame);  
517.             }  
518.         }  
519.         else {  
520.             /* remux this frame without reencoding */  
521.             av_packet_rescale_ts(&packet,  
522.                 ifmt_ctx->streams[stream_index]->time_base,  
523.                 ofmt_ctx->streams[stream_index]->time_base);  
524.   
525.             ret = av_interleaved_write_frame(ofmt_ctx, &packet);  
526.             if (ret < 0)  
527.                 goto end;  
528.         }  
529.         av_free_packet(&packet);  
530.     }  
531.   
532.     /* flush filters and encoders */  
533.     for (i = 0; i < ifmt_ctx->nb_streams; i++) {  
534.         /* flush filter */  
535.         if (!filter_ctx[i].filter_graph)  
536.             continue;  
537.         ret = filter_encode_write_frame(NULL, i);  
538.         if (ret < 0) {  
539.             av_log(NULL, AV_LOG_ERROR, "Flushing filter failed\n");  
540.             goto end;  
541.         }  
542.   
543.         /* flush encoder */  
544.         ret = flush_encoder(i);  
545.         if (ret < 0) {  
546.             av_log(NULL, AV_LOG_ERROR, "Flushing encoder failed\n");  
547.             goto end;  
548.         }  
549.     }  
550.   
551.     av_write_trailer(ofmt_ctx);  
552. end:  
553.     av_free_packet(&packet);  
554.     av_frame_free(&frame);  
555.     for (i = 0; i < ifmt_ctx->nb_streams; i++) {  
556.         avcodec_close(ifmt_ctx->streams[i]->codec);  
557.         if (ofmt_ctx && ofmt_ctx->nb_streams > i && ofmt_ctx->streams[i] && ofmt_ctx->streams[i]->codec)  
558.             avcodec_close(ofmt_ctx->streams[i]->codec);  
559.         if (filter_ctx && filter_ctx[i].filter_graph)  
560.             avfilter_graph_free(&filter_ctx[i].filter_graph);  
561.     }  
562.     av_free(filter_ctx);  
563.     avformat_close_input(&ifmt_ctx);  
564.     if (ofmt_ctx && !(ofmt_ctx->oformat->flags & AVFMT_NOFILE))  
565.         avio_closep(&ofmt_ctx->pb);  
566.     avformat_free_context(ofmt_ctx);  
567.   
568.     if (ret < 0)  
569.         av_log(NULL, AV_LOG_ERROR, "Error occurred: %s\n"); //av_err2str(ret));  
570.   
571.     return ret ? 1 : 0;  
572. }  
573.   
574. </span>  

 

 

源代码下载：

csdn工程：http://download.csdn.NET/detail/rootusers/8425619

from:http://blog.csdn.net/rootusers/article/details/43488827