使用ffmpeg实现转码样例(代码实现)

孙悟空

使用ffmpeg实现转码样例(代码实现)

作者 ： www.ChinaFFmpeg.com  孙悟空


使用ffmpeg转码主要工作如下:
Demux -> Decoding -> Encoding -> Muxing

其中接口调用如下：

1. av_register_all();
   
2. avformat_open_input
   
3. avformat_find_stream_info
   
4. open_codec_context
   
5. av_image_alloc
   
6. avcodec_alloc_frame
   
7. avformat_alloc_output_context2
   
8. avcodec_open2
   
9. avcodec_alloc_frame
   
10. avpicture_alloc
    
11. avpicture_alloc
    
12. avformat_write_header
    
13. av_init_packet
    
14. av_read_frame
    
15. avcodec_decode_video2
    
16. av_image_copy
    
17. avcodec_encode_video2
    
18. av_interleaved_write_frame
    
19. av_write_trailer

复制代码

下面的代码为主要将视频转码，封装为h264编码格式的mp4文件，音频为mp3，但是主要操作并不处理音频文件。代码如下

1. #include <stdlib.h>
   
2. #include <stdio.h>
   
3. #include <string.h>
   
4. #include <math.h>
   
5. 
   
6. #include <libavutil/opt.h>
   
7. #include <libavutil/mathematics.h>
   
8. #include <libavformat/avformat.h>
   
9. #include <libswscale/swscale.h>
   
10. #include <libswresample/swresample.h>
    
11. 
    
12. /* 5 seconds stream duration */
    
13. #define STREAM_DURATION   200.0
    
14. #define STREAM_FRAME_RATE 25 /* 25 images/s */
    
15. #define STREAM_NB_FRAMES  ((int)(STREAM_DURATION * STREAM_FRAME_RATE))
    
16. #define STREAM_PIX_FMT    AV_PIX_FMT_YUV420P /* default pix_fmt */
    
17. 
    
18. static AVFormatContext *input_fmt_ctx = NULL;
    
19. static int sws_flags = SWS_BICUBIC;
    
20. static AVPacket input_pkt;
    
21. static int video_stream_idx = -1;
    
22. static uint8_t *video_dst_data[4] = {NULL};
    
23. static int      video_dst_linesize[4];
    
24. static AVStream *input_video_stream;
    
25. static AVFrame *input_frame;
    
26. static AVCodecContext *video_dec_ctx = NULL;
    
27. static int video_dst_bufsize;
    
28. 
    
29. 
    
30. static int open_codec_context(int *stream_idx,
    
31.         AVFormatContext *fmt_ctx, enum AVMediaType type)
    
32. {
    
33.     int ret;
    
34.     AVStream *st;
    
35.     AVCodecContext *dec_ctx = NULL;
    
36.     AVCodec *dec = NULL;
    
37. 
    
38.     ret = av_find_best_stream(fmt_ctx, type, -1, -1, NULL, 0);
    
39.     if (ret < 0) {
    
40.         return ret;
    
41.     } else {
    
42.         *stream_idx = ret;
    
43.         st = fmt_ctx->streams[*stream_idx];
    
44. 
    
45.         /* find decoder for the stream */
    
46.         dec_ctx = st->codec;
    
47.         dec = avcodec_find_decoder(dec_ctx->codec_id);
    
48.         if (!dec) {
    
49.             fprintf(stderr, "Failed to find %s codec\n",
    
50.                     av_get_media_type_string(type));
    
51.             return ret;
    
52.         }
    
53. 
    
54.         if ((ret = avcodec_open2(dec_ctx, dec, NULL)) < 0) {
    
55.             fprintf(stderr, "Failed to open %s codec\n",
    
56.                     av_get_media_type_string(type));
    
57.             return ret;
    
58.         }
    
59.     }
    
60. 
    
61.     return 0;
    
62. }
    
63. 
    
64. /* Add an output stream. */
    
65. static AVStream *add_stream(AVFormatContext *oc, AVCodec **codec,
    
66.         enum AVCodecID codec_id)
    
67. {
    
68.     AVCodecContext *c;
    
69.     AVStream *st;
    
70. 
    
71.     /* find the encoder */
    
72.     *codec = avcodec_find_encoder(codec_id);
    
73.     if (!(*codec)) {
    
74.         fprintf(stderr, "Could not find encoder for '%s'\n",
    
75.                 avcodec_get_name(codec_id));
    
76.         exit(1);
    
77.     }
    
78. 
    
79.     st = avformat_new_stream(oc, *codec);
    
80.     if (!st) {
    
81.         fprintf(stderr, "Could not allocate stream\n");
    
82.         exit(1);
    
83.     }
    
84.     st->id = oc->nb_streams-1;
    
85.     c = st->codec;
    
86. 
    
87.     switch ((*codec)->type) {
    
88.         case AVMEDIA_TYPE_AUDIO:
    
89.             c->sample_fmt  = AV_SAMPLE_FMT_FLTP;
    
90.             c->bit_rate    = 64000;
    
91.             c->sample_rate = 44100;
    
92.             c->channels    = 2;
    
93.             break;
    
94. 
    
95.         case AVMEDIA_TYPE_VIDEO:
    
96.             c->codec_id = codec_id;
    
97. 
    
98.             c->bit_rate = 400000;
    
99.             c->time_base.den = STREAM_FRAME_RATE;
    
100.             c->time_base.num = 1;
     
101.             c->gop_size      = 12;
     
102.             c->pix_fmt       = STREAM_PIX_FMT;
     
103.             break;
     
104. 
     
105.         default:
     
106.             break;
     
107.     }
     
108. 
     
109.     /* Some formats want stream headers to be separate. */
     
110.     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
     
111.         c->flags |= CODEC_FLAG_GLOBAL_HEADER;
     
112. 
     
113.     return st;
     
114. }
     
115. 
     
116. /**************************************************************/
     
117. /* audio output */
     
118. 
     
119. static float t, tincr, tincr2;
     
120. 
     
121. static uint8_t **src_samples_data;
     
122. static int       src_samples_linesize;
     
123. static int       src_nb_samples;
     
124. 
     
125. static int max_dst_nb_samples;
     
126. uint8_t **dst_samples_data;
     
127. int       dst_samples_linesize;
     
128. int       dst_samples_size;
     
129. 
     
130. struct SwrContext *swr_ctx = NULL;
     
131. 
     
132. static void open_audio(AVFormatContext *oc, AVCodec *codec, AVStream *st)
     
133. {
     
134.     AVCodecContext *c;
     
135.     int ret;
     
136. 
     
137.     c = st->codec;
     
138. 
     
139.     /* open it */
     
140.     ret = avcodec_open2(c, codec, NULL);
     
141.     if (ret < 0) {
     
142.         fprintf(stderr, "Could not open audio codec: %s\n", av_err2str(ret));
     
143.         exit(1);
     
144.     }
     
145. 
     
146.     /* init signal generator */
     
147.     t     = 0;
     
148.     tincr = 2 * M_PI * 110.0 / c->sample_rate;
     
149.     /* increment frequency by 110 Hz per second */
     
150.     tincr2 = 2 * M_PI * 110.0 / c->sample_rate / c->sample_rate;
     
151. 
     
152.     src_nb_samples = c->codec->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE ?
     
153.         10000 : c->frame_size;
     
154. 
     
155.     ret = av_samples_alloc_array_and_samples(&src_samples_data, &src_samples_linesize, c->channels,
     
156.             src_nb_samples, c->sample_fmt, 0);
     
157.     if (ret < 0) {
     
158.         fprintf(stderr, "Could not allocate source samples\n");
     
159.         exit(1);
     
160.     }
     
161. 
     
162.     /* create resampler context */
     
163.     if (c->sample_fmt != AV_SAMPLE_FMT_S16) {
     
164.         swr_ctx = swr_alloc();
     
165.         if (!swr_ctx) {
     
166.             fprintf(stderr, "Could not allocate resampler context\n");
     
167.             exit(1);
     
168.         }
     
169. 
     
170.         /* set options */
     
171.         av_opt_set_int       (swr_ctx, "in_channel_count",   c->channels,       0);
     
172.         av_opt_set_int       (swr_ctx, "in_sample_rate",     c->sample_rate,    0);
     
173.         av_opt_set_sample_fmt(swr_ctx, "in_sample_fmt",      AV_SAMPLE_FMT_S16, 0);
     
174.         av_opt_set_int       (swr_ctx, "out_channel_count",  c->channels,       0);
     
175.         av_opt_set_int       (swr_ctx, "out_sample_rate",    c->sample_rate,    0);
     
176.         av_opt_set_sample_fmt(swr_ctx, "out_sample_fmt",     c->sample_fmt,     0);
     
177. 
     
178.         /* initialize the resampling context */
     
179.         if ((ret = swr_init(swr_ctx)) < 0) {
     
180.             fprintf(stderr, "Failed to initialize the resampling context\n");
     
181.             exit(1);
     
182.         }
     
183.     }
     
184. 
     
185.     /* compute the number of converted samples: buffering is avoided
     
186.      * ensuring that the output buffer will contain at least all the
     
187.      * converted input samples */
     
188.     max_dst_nb_samples = src_nb_samples;
     
189.     ret = av_samples_alloc_array_and_samples(&dst_samples_data, &dst_samples_linesize, c->channels,
     
190.             max_dst_nb_samples, c->sample_fmt, 0);
     
191.     if (ret < 0) {
     
192.         fprintf(stderr, "Could not allocate destination samples\n");
     
193.         exit(1);
     
194.     }
     
195.     dst_samples_size = av_samples_get_buffer_size(NULL, c->channels, max_dst_nb_samples,
     
196.             c->sample_fmt, 0);
     
197. }
     
198. 
     
199. /* Prepare a 16 bit dummy audio frame of 'frame_size' samples and
     
200. * 'nb_channels' channels. */
     
201. static void get_audio_frame(int16_t *samples, int frame_size, int nb_channels)
     
202. {
     
203.     int j, i, v;
     
204.     int16_t *q;
     
205. 
     
206.     q = samples;
     
207.     for (j = 0; j < frame_size; j++) {
     
208.         v = (int)(sin(t) * 10000);
     
209.         for (i = 0; i < nb_channels; i++)
     
210.             *q++ = v;
     
211.         t     += tincr;
     
212.         tincr += tincr2;
     
213.     }
     
214. }
     
215. 
     
216. static void write_audio_frame(AVFormatContext *oc, AVStream *st)
     
217. {
     
218.     AVCodecContext *c;
     
219.     AVPacket pkt = { 0 }; // data and size must be 0;
     
220.     AVFrame *frame = avcodec_alloc_frame();
     
221.     int got_packet, ret, dst_nb_samples;
     
222. 
     
223.     av_init_packet(&pkt);
     
224.     c = st->codec;
     
225. 
     
226.     get_audio_frame((int16_t *)src_samples_data[0], src_nb_samples, c->channels);
     
227. 
     
228.     /* convert samples from native format to destination codec format, using the resampler */
     
229.     if (swr_ctx) {
     
230.         /* compute destination number of samples */
     
231.         dst_nb_samples = av_rescale_rnd(swr_get_delay(swr_ctx, c->sample_rate) + src_nb_samples,
     
232.                 c->sample_rate, c->sample_rate, AV_ROUND_UP);
     
233.         if (dst_nb_samples > max_dst_nb_samples) {
     
234.             av_free(dst_samples_data[0]);
     
235.             ret = av_samples_alloc(dst_samples_data, &dst_samples_linesize, c->channels,
     
236.                     dst_nb_samples, c->sample_fmt, 0);
     
237.             if (ret < 0)
     
238.                 exit(1);
     
239.             max_dst_nb_samples = dst_nb_samples;
     
240.             dst_samples_size = av_samples_get_buffer_size(NULL, c->channels, dst_nb_samples,
     
241.                     c->sample_fmt, 0);
     
242.         }
     
243. 
     
244.         /* convert to destination format */
     
245.         ret = swr_convert(swr_ctx,
     
246.                 dst_samples_data, dst_nb_samples,
     
247.                 (const uint8_t **)src_samples_data, src_nb_samples);
     
248.         if (ret < 0) {
     
249.             fprintf(stderr, "Error while converting\n");
     
250.             exit(1);
     
251.         }
     
252.     } else {
     
253.         dst_samples_data[0] = src_samples_data[0];
     
254.         dst_nb_samples = src_nb_samples;
     
255.     }
     
256. 
     
257.     frame->nb_samples = dst_nb_samples;
     
258.     avcodec_fill_audio_frame(frame, c->channels, c->sample_fmt,
     
259.             dst_samples_data[0], dst_samples_size, 0);
     
260. 
     
261.     ret = avcodec_encode_audio2(c, &pkt, frame, &got_packet);
     
262.     if (ret < 0) {
     
263.         fprintf(stderr, "Error encoding audio frame: %s\n", av_err2str(ret));
     
264.         exit(1);
     
265.     }
     
266. 
     
267.     if (!got_packet)
     
268.         return;
     
269. 
     
270.     pkt.stream_index = st->index;
     
271. 
     
272.     /* Write the compressed frame to the media file. */
     
273.     ret = av_interleaved_write_frame(oc, &pkt);
     
274.     if (ret != 0) {
     
275.         fprintf(stderr, "Error while writing audio frame: %s\n",
     
276.                 av_err2str(ret));
     
277.         exit(1);
     
278.     }
     
279.     avcodec_free_frame(&frame);
     
280. }
     
281. 
     
282. static void close_audio(AVFormatContext *oc, AVStream *st)
     
283. {
     
284.     avcodec_close(st->codec);
     
285.     av_free(src_samples_data[0]);
     
286.     av_free(dst_samples_data[0]);
     
287. }
     
288. 
     
289. /***********************bbs.ChinaFFmpeg.com****孙悟空***********************/
     
290. /* video output */
     
291. 
     
292. static AVFrame *frame;
     
293. static AVPicture src_picture, dst_picture;
     
294. static int frame_count;
     
295. 
     
296. static void open_video(AVFormatContext *oc, AVCodec *codec, AVStream *st)
     
297. {
     
298.     int ret;
     
299.     AVCodecContext *c = st->codec;
     
300. 
     
301.     /* open the codec */
     
302.     ret = avcodec_open2(c, codec, NULL);
     
303.     if (ret < 0) {
     
304.         fprintf(stderr, "Could not open video codec: %s\n", av_err2str(ret));
     
305.         exit(1);
     
306.     }
     
307. 
     
308.     /* allocate and init a re-usable frame */
     
309.     frame = avcodec_alloc_frame();
     
310.     if (!frame) {
     
311.         fprintf(stderr, "Could not allocate video frame\n");
     
312.         exit(1);
     
313.     }
     
314. 
     
315.     /* Allocate the encoded raw picture. */
     
316.     ret = avpicture_alloc(&dst_picture, c->pix_fmt, c->width, c->height);
     
317.     if (ret < 0) {
     
318.         fprintf(stderr, "Could not allocate picture: %s\n", av_err2str(ret));
     
319.         exit(1);
     
320.     }
     
321. 
     
322.     /* If the output format is not YUV420P, then a temporary YUV420P
     
323.      * picture is needed too. It is then converted to the required
     
324.      * output format. */
     
325.     if (c->pix_fmt != AV_PIX_FMT_YUV420P) {
     
326.         ret = avpicture_alloc(&src_picture, AV_PIX_FMT_YUV420P, c->width, c->height);
     
327.         if (ret < 0) {
     
328.             fprintf(stderr, "Could not allocate temporary picture: %s\n",
     
329.                     av_err2str(ret));
     
330.             exit(1);
     
331.         }
     
332.     }
     
333. 
     
334.     /* copy data and linesize picture pointers to frame */
     
335.     *((AVPicture *)frame) = dst_picture;
     
336. }
     
337. 
     
338. static void write_video_frame(AVFormatContext *oc, AVStream *st)
     
339. {
     
340.     int ret;
     
341.     static struct SwsContext *sws_ctx;
     
342.     AVCodecContext *c = st->codec;
     
343. 
     
344.     //    fill_yuv_image(&dst_picture, frame_count, c->width, c->height);
     
345. 
     
346. 
     
347.     if (oc->oformat->flags & AVFMT_RAWPICTURE) {
     
348.         /* Raw video case - directly store the picture in the packet */
     
349.         AVPacket pkt;
     
350.         av_init_packet(&pkt);
     
351. 
     
352.         pkt.flags        |= AV_PKT_FLAG_KEY;
     
353.         pkt.stream_index  = st->index;
     
354.         pkt.data          = dst_picture.data[0];
     
355.         pkt.size          = sizeof(AVPicture);
     
356. 
     
357.         ret = av_interleaved_write_frame(oc, &pkt);
     
358.     } else {
     
359.         AVPacket pkt = { 0 };
     
360.         int got_packet;
     
361.         av_init_packet(&pkt);
     
362. 
     
363.         /* encode the image */
     
364.         ret = avcodec_encode_video2(c, &pkt, frame, &got_packet);
     
365.         if (ret < 0) {
     
366.             fprintf(stderr, "Error encoding video frame: %s\n", av_err2str(ret));
     
367.             exit(1);
     
368.         }
     
369.         /* If size is zero, it means the image was buffered. */
     
370. 
     
371.         if (!ret && got_packet && pkt.size) {
     
372.             pkt.stream_index = st->index;
     
373. 
     
374.             /* Write the compressed frame to the media file. */
     
375.             ret = av_interleaved_write_frame(oc, &pkt);
     
376.         } else {
     
377.             ret = 0;
     
378.         }
     
379.     }
     
380.     if (ret != 0) {
     
381.         fprintf(stderr, "Error while writing video frame: %s\n", av_err2str(ret));
     
382.         exit(1);
     
383.     }
     
384.     frame_count++;
     
385. }
     
386. 
     
387. static void close_video(AVFormatContext *oc, AVStream *st)
     
388. {
     
389.     avcodec_close(st->codec);
     
390.     av_free(src_picture.data[0]);
     
391.     av_free(dst_picture.data[0]);
     
392.     av_free(frame);
     
393. }
     
394. 
     
395. /**************************************************************/
     
396. /* media file output */
     
397. 
     
398. int main(int argc, char **argv)
     
399. {
     
400.     const char *filename;
     
401.     const char *input_file;
     
402.     AVOutputFormat *fmt;
     
403.     AVFormatContext *oc;
     
404.     AVStream *audio_st, *video_st;
     
405.     AVCodec *audio_codec, *video_codec;
     
406.     double audio_time, video_time;
     
407.     int ret;
     
408.     int decoded;
     
409.     int got_frame;
     
410. 
     
411.     /* Initialize libavcodec, and register all codecs and formats. */
     
412.     av_register_all();
     
413. 
     
414.     if (argc != 3) {
     
415.         printf("usage: %s output_file inputfile\n"
     
416.                 "API example program to output a media file with libavformat.\n"
     
417.                 "This program generates a synthetic audio and video stream, encodes and\n"
     
418.                 "muxes them into a file named output_file.\n"
     
419.                 "The output format is automatically guessed according to the file extension.\n"
     
420.                 "Raw images can also be output by using '%%d' in the filename.\n"
     
421.                 "\n", argv[0]);
     
422.         return 1;
     
423.     }
     
424. 
     
425.     input_file = argv[2];
     
426.     filename = argv[1];
     
427. 
     
428.     if (avformat_open_input( &input_fmt_ctx, input_file, NULL, NULL) < 0) {
     
429.         fprintf(stderr, "Could not open source file %s\n", input_file);
     
430.         exit(-1);
     
431.     }
     
432. 
     
433.     /* retrieve stream information */
     
434.     if (avformat_find_stream_info(input_fmt_ctx, NULL) < 0) {
     
435.         fprintf(stderr, "Could not find stream information\n");
     
436.         exit(1);
     
437.     }
     
438. 
     
439.     if (open_codec_context(&video_stream_idx, input_fmt_ctx, AVMEDIA_TYPE_VIDEO) >= 0) {
     
440.         input_video_stream = input_fmt_ctx->streams[video_stream_idx];
     
441.         video_dec_ctx = input_video_stream->codec;
     
442.         ret = av_image_alloc(video_dst_data, video_dst_linesize,
     
443.                 video_dec_ctx->width, video_dec_ctx->height,
     
444.                 video_dec_ctx->pix_fmt, 1);
     
445.         if (ret < 0) {
     
446.             fprintf(stderr, "Could not allocate raw video buffer\n");
     
447.         }
     
448.         video_dst_bufsize = ret;
     
449.     }
     
450. 
     
451. 
     
452.     input_frame = avcodec_alloc_frame();
     
453.     if (!input_frame) {
     
454.         fprintf(stderr, "Could not allocate frame\n");
     
455.         ret = AVERROR(ENOMEM);
     
456.         exit(-1);
     
457.     }
     
458. 
     
459.     /* allocate the output media context */
     
460.     avformat_alloc_output_context2(&oc, NULL, NULL, filename);
     
461.     if (!oc) {
     
462.         printf("Could not deduce output format from file extension: using MPEG.\n");
     
463.         avformat_alloc_output_context2(&oc, NULL, "mpeg", filename);
     
464.     }
     
465.     if (!oc) {
     
466.         return 1;
     
467.     }
     
468.     fmt = oc->oformat;
     
469. 
     
470.     video_st = NULL;
     
471.     audio_st = NULL;
     
472. 
     
473.     fmt->video_codec = AV_CODEC_ID_H264;
     
474.     if (fmt->video_codec != AV_CODEC_ID_NONE) {
     
475.         video_st = add_stream(oc, &video_codec, AV_CODEC_ID_H264);
     
476.     }
     
477.     if (video_st->codec) {
     
478.         video_st->codec->width = video_dec_ctx->width;
     
479.         video_st->codec->height = video_dec_ctx->height;
     
480.     }
     
481.     fmt->audio_codec = AV_CODEC_ID_MP3;
     
482.     if (fmt->audio_codec != AV_CODEC_ID_NONE) {
     
483.         audio_st = add_stream(oc, &audio_codec, AV_CODEC_ID_MP3);
     
484.     }
     
485. 
     
486.     /* Now that all the parameters are set, we can open the audio and
     
487.      * video codecs and allocate the necessary encode buffers. */
     
488.     if (video_st)
     
489.         open_video(oc, video_codec, video_st);
     
490.     if (audio_st)
     
491.         open_audio(oc, audio_codec, audio_st);
     
492. 
     
493.     av_dump_format(oc, 0, filename, 1);
     
494. 
     
495. 
     
496.     /* open the output file, if needed */
     
497.     if (!(fmt->flags & AVFMT_NOFILE)) {
     
498.         ret = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE);
     
499.         if (ret < 0) {
     
500.             fprintf(stderr, "Could not open '%s': %s\n", filename,
     
501.                     av_err2str(ret));
     
502.             return 1;
     
503.         }
     
504.     }
     
505. 
     
506.     /* Write the stream header, if any. */
     
507.     ret = avformat_write_header(oc, NULL);
     
508.     if (ret < 0) {
     
509.         fprintf(stderr, "Error occurred when opening output file: %s\n",
     
510.                 av_err2str(ret));
     
511.         return 1;
     
512.     }
     
513. 
     
514.     av_init_packet(&input_pkt);
     
515.     input_pkt.data = NULL;
     
516.     input_pkt.size = 0;
     
517. 
     
518. 
     
519.     if (frame)
     
520.         frame->pts = 0;
     
521.     for (;;) {
     
522.         /* Compute current audio and video time. */
     
523.         audio_time = audio_st ? audio_st->pts.val * av_q2d(audio_st->time_base) : 0.0;
     
524.         video_time = video_st ? video_st->pts.val * av_q2d(video_st->time_base) : 0.0;
     
525. 
     
526.         if ((!audio_st || audio_time >= STREAM_DURATION) &&
     
527.                 (!video_st || video_time >= STREAM_DURATION))
     
528.             break;
     
529. 
     
530.         /* write interleaved audio and video frames */
     
531.         if (!video_st || (video_st && audio_st && audio_time < video_time)) {
     
532.             write_audio_frame(oc, audio_st);
     
533.         } else {
     
534.             av_read_frame(input_fmt_ctx, &input_pkt);
     
535. 
     
536.             decoded = input_pkt.size;
     
537.             if (input_pkt.stream_index == video_stream_idx) {
     
538.                 /* decode video frame */
     
539.                 ret = avcodec_decode_video2(video_dec_ctx, input_frame, &got_frame, &input_pkt);
     
540.                 if (ret < 0) {
     
541.                     fprintf(stderr, "Error decoding video frame\n");
     
542.                     return ret;
     
543.                 }
     
544. 
     
545.                 if (got_frame) {
     
546.                     av_image_copy(&dst_picture, video_dst_linesize,
     
547.                             (const uint8_t **)(input_frame->data), input_frame->linesize,
     
548.                             video_dec_ctx->pix_fmt, video_dec_ctx->width, video_dec_ctx->height);
     
549.                 }
     
550.             }
     
551. 
     
552.             write_video_frame(oc, video_st);
     
553.             frame->pts += av_rescale_q(1, video_st->codec->time_base, video_st->time_base);
     
554.         }
     
555.     }
     
556. 
     
557.     av_write_trailer(oc);
     
558. 
     
559.     /* Close each codec. */
     
560.     if (video_st)
     
561.         close_video(oc, video_st);
     
562.     if (audio_st)
     
563.         close_audio(oc, audio_st);
     
564. 
     
565.     if (!(fmt->flags & AVFMT_NOFILE))
     
566.         avio_close(oc->pb);
     
567. 
     
568.     avformat_free_context(oc);
     
569.     av_free(input_frame);
     
570.     av_free(video_dst_data[0]);
     
571.     avcodec_close(video_dec_ctx);
     
572.     return 0;
     
573. }

复制代码

编译命令如下：

1. gcc -g doc/examples/muxing.c -o muxing  -lavcodec -lavdevice -lavfilter -lavformat -lavutil -lswscale -lswresample -lpostproc -lx264 -lmp3lame -lz -liconv -lbz2

复制代码

以上代码为从dox/example/muxing.c中修改得到
执行命令如下：

1. ./muxing output.mp4 ~/Movies/input.avi

复制代码

执行后效果如下：

查看转码完成后的多媒体文件的信息：

查看转码后的文件的视频:


转帖请注明来处

pqiankui

学习了

BeyondCode

视频格式为h264，音频格式为g726，封装成什么容器最好？

liuxuejin

楼主这段代码能用于生产环境的转码么？？

孙悟空

liuxuejin 发表于 2013-10-12 00:52
楼主这段代码能用于生产环境的转码么？？

必须不能啊，这个不是往生产环境放的代码
这个是根据doc/example/下的例子修改的

生产环境需要处理很多内容，这个就是一个简单的例子而已

rocispeng

期待大师兄将此转码样例完善！顶起

BeyondCode

代码我用VS2010编译起来，跑不起来
提示错误： error C2664: “av_image_copy”: 不能将参数 1 从“AVPicture *”转换为“uint8_t *[]”，错误定位在av_image_copy函数的第一个参数；
我用强制转换或者改成dst_picture.data还是不行。

T-Bagwell

BeyondCode 发表于 2013-10-22 10:14
代码我用VS2010编译起来，跑不起来
提示错误： error C2664: “av_image_copy”: 不能将参数 1 从“AVPictu ...

在这个之前uint8_t *img = (uint8_t *)xxxx；
试试

T-Bagwell

BeyondCode 发表于 2013-10-22 10:14
代码我用VS2010编译起来，跑不起来
提示错误： error C2664: “av_image_copy”: 不能将参数 1 从“AVPictu ...

在这个之前uint8_t *img = (uint8_t *)xxxx；
试试

T-Bagwell

BeyondCode 发表于 2013-10-22 10:14
代码我用VS2010编译起来，跑不起来
提示错误： error C2664: “av_image_copy”: 不能将参数 1 从“AVPictu ...

在这个之前uint8_t *img = (uint8_t *)xxxx；
试试