博客

FFMpeg写MP4文件例子分析

  • Post author:
  • Post category:其他



http://blog.csdn.net/eightdegree/article/details/7425811

这段时间看了FFMpeg提供的例子muxing.c，我略微修改了下源代码，使其生成一个MP4文件，音频使用AAC编码，视频使用H.264编码。代码很简单，我就不做说明了，代码如下。

以后我们继续写如何将DirectShow中采集的音视频数据编码并生成MP4文件。


[cpp]


view plain


copy



  1. /* 5 seconds stream duration */


  2. #define STREAM_DURATION   5.0


  3. #define STREAM_FRAME_RATE 25 /* 25 images/s */


  4. #define STREAM_NB_FRAMES  ((int)(STREAM_DURATION * STREAM_FRAME_RATE))


  5. #define STREAM_PIX_FMT PIX_FMT_YUV420P /* default pix_fmt */



  7. static




    int


    sws_flags = SWS_BICUBIC;



  9. /**************************************************************/


  10. /* audio output */



  12. static




    float


    t, tincr, tincr2;


  13. static


    int16_t *samples;


  14. static


    uint8_t *audio_outbuf;


  15. static




    int


    audio_outbuf_size;


  16. static




    int


    audio_input_frame_size;



  18. /*


  19. * add an audio output stream


  20. */


  21. static


    AVStream *add_audio_stream(AVFormatContext *oc,


    enum


    CodecID codec_id)

  22. {

  23. AVCodecContext *c;

  24. AVStream *st;


  26. st = avformat_new_stream(oc, NULL);


  27. if


    (!st) {

  28. fprintf(stderr,

    “Could not alloc stream\n”


    );

  29. exit(1);

  30. }

  31. st->id = 1;


  33. c = st->codec;

  34. c->codec_id = codec_id;

  35. c->codec_type = AVMEDIA_TYPE_AUDIO;



  37. /* put sample parameters */

  38. c->sample_fmt = AV_SAMPLE_FMT_S16;

  39. c->bit_rate = 64000;

  40. c->sample_rate = 44100;

  41. c->channels = 2;



  43. // some formats want stream headers to be separate


  44. if


    (oc->oformat->flags & AVFMT_GLOBALHEADER)

  45. c->flags |= CODEC_FLAG_GLOBAL_HEADER;



  47. return


    st;

  48. }



  50. static




    void


    open_audio(AVFormatContext *oc, AVStream *st)

  51. {

  52. AVCodecContext *c;

  53. AVCodec *codec;


  55. c = st->codec;



  57. /* find the audio encoder */

  58. codec = avcodec_find_encoder(c->codec_id);


  59. if


    (!codec) {

  60. fprintf(stderr,

    “codec not found\n”


    );

  61. exit(1);

  62. }



  64. /* open it */


  65. if


    (avcodec_open(c, codec) < 0) {

  66. fprintf(stderr,

    “could not open codec\n”


    );

  67. exit(1);

  68. }



  70. /* init signal generator */

  71. t = 0;

  72. tincr = 2 * M_PI * 110.0 / c->sample_rate;


  73. /* increment frequency by 110 Hz per second */

  74. tincr2 = 2 * M_PI * 110.0 / c->sample_rate / c->sample_rate;


  76. audio_outbuf_size = 10000;

  77. audio_outbuf = (uint8_t *)av_malloc(audio_outbuf_size);



  79. /* ugly hack for PCM codecs (will be removed ASAP with new PCM


  80. support to compute the input frame size in samples */


  81. if


    (c->frame_size <= 1) {

  82. audio_input_frame_size = audio_outbuf_size / c->channels;


  83. switch


    (st->codec->codec_id) {


  84. case


    CODEC_ID_PCM_S16LE:


  85. case


    CODEC_ID_PCM_S16BE:


  86. case


    CODEC_ID_PCM_U16LE:


  87. case


    CODEC_ID_PCM_U16BE:

  88. audio_input_frame_size >>= 1;


  89. break


    ;


  90. default


    :


  91. break


    ;

  92. }

  93. }

    else


    {

  94. audio_input_frame_size = c->frame_size;

  95. }

  96. samples = (int16_t *)av_malloc(audio_input_frame_size * 2 * c->channels);

  97. }



  99. /* prepare a 16 bit dummy audio frame of ‘frame_size’ samples and


  100. ‘nb_channels’ channels */


  101. static




    void


    get_audio_frame(int16_t *samples,


    int


    frame_size,


    int


    nb_channels)

  102. {


  103. int


    j, i, v;

  104. int16_t *q;


  106. q = samples;


  107. for


    (j = 0; j < frame_size; j++) {

  108. v = (

    int


    )(sin(t) * 10000);


  109. for


    (i = 0; i < nb_channels; i++)

  110. *q++ = v;

  111. t += tincr;

  112. tincr += tincr2;

  113. }

  114. }



  116. static




    void


    write_audio_frame(AVFormatContext *oc, AVStream *st)

  117. {

  118. AVCodecContext *c;

  119. AVPacket pkt;

  120. av_init_packet(&pkt);


  122. c = st->codec;


  124. get_audio_frame(samples, audio_input_frame_size, c->channels);


  126. pkt.size = avcodec_encode_audio(c, audio_outbuf, audio_outbuf_size, samples);



  128. if


    (c->coded_frame && c->coded_frame->pts != AV_NOPTS_VALUE)

  129. pkt.pts= av_rescale_q(c->coded_frame->pts, c->time_base, st->time_base);

  130. pkt.flags |= AV_PKT_FLAG_KEY;

  131. pkt.stream_index = st->index;

  132. pkt.data = audio_outbuf;



  134. /* write the compressed frame in the media file */


  135. if


    (av_interleaved_write_frame(oc, &pkt) != 0) {

  136. fprintf(stderr,

    “Error while writing audio frame\n”


    );

  137. exit(1);

  138. }

  139. }



  141. static




    void


    close_audio(AVFormatContext *oc, AVStream *st)

  142. {

  143. avcodec_close(st->codec);


  145. av_free(samples);

  146. av_free(audio_outbuf);

  147. }



  149. /**************************************************************/


  150. /* video output */



  152. static


    AVFrame *picture, *tmp_picture;


  153. static


    uint8_t *video_outbuf;


  154. static




    int


    frame_count, video_outbuf_size;



  156. /* add a video output stream */


  157. static


    AVStream *add_video_stream(AVFormatContext *oc,


    enum


    CodecID codec_id)

  158. {

  159. AVCodecContext *c;

  160. AVStream *st;

  161. AVCodec *codec;


  163. st = avformat_new_stream(oc, NULL);


  164. if


    (!st) {

  165. fprintf(stderr,

    “Could not alloc stream\n”


    );

  166. exit(1);

  167. }


  169. c = st->codec;



  171. /* find the video encoder */

  172. codec = avcodec_find_encoder(codec_id);


  173. if


    (!codec) {

  174. fprintf(stderr,

    “codec not found\n”


    );

  175. exit(1);

  176. }

  177. avcodec_get_context_defaults3(c, codec);


  179. c->codec_id = codec_id;



  181. /* put sample parameters */

  182. c->bit_rate =

    /*400000*/


    3000000;


  183. /* resolution must be a multiple of two */

  184. c->width =

    /*352*/


    640;

  185. c->height =

    /*288*/


    480;


  186. /* time base: this is the fundamental unit of time (in seconds) in terms


  187. of which frame timestamps are represented. for fixed-fps content,


  188. timebase should be 1/framerate and timestamp increments should be


  189. identically 1. */

  190. c->time_base.den = STREAM_FRAME_RATE;

  191. c->time_base.num = 1;

  192. c->gop_size = 12;

    /* emit one intra frame every twelve frames at most */

  193. c->pix_fmt = STREAM_PIX_FMT;


  194. if


    (c->codec_id == CODEC_ID_MPEG2VIDEO) {


  195. /* just for testing, we also add B frames */

  196. c->max_b_frames = 2;

  197. }


  198. if


    (c->codec_id == CODEC_ID_MPEG1VIDEO){


  199. /* Needed to avoid using macroblocks in which some coeffs overflow.


  200. This does not happen with normal video, it just happens here as


  201. the motion of the chroma plane does not match the luma plane. */

  202. c->mb_decision=2;

  203. }


  204. // some formats want stream headers to be separate


  205. if


    (oc->oformat->flags & AVFMT_GLOBALHEADER)

  206. c->flags |= CODEC_FLAG_GLOBAL_HEADER;





  210. return


    st;

  211. }



  213. static


    AVFrame *alloc_picture(


    enum


    PixelFormat pix_fmt,


    int


    width,


    int


    height)

  214. {

  215. AVFrame *picture;

  216. uint8_t *picture_buf;


  217. int


    size;


  219. picture = avcodec_alloc_frame();


  220. if


    (!picture)


  221. return


    NULL;

  222. size = avpicture_get_size(pix_fmt, width, height);

  223. picture_buf = (uint8_t *)av_malloc(size);


  224. if


    (!picture_buf) {

  225. av_free(picture);


  226. return


    NULL;

  227. }

  228. avpicture_fill((AVPicture *)picture, picture_buf,

  229. pix_fmt, width, height);


  230. return


    picture;

  231. }



  233. static




    void


    open_video(AVFormatContext *oc, AVStream *st)

  234. {

  235. AVCodec *codec;

  236. AVCodecContext *c;


  238. c = st->codec;



  240. /* find the video encoder */

  241. codec = avcodec_find_encoder(c->codec_id);


  242. if


    (!codec) {

  243. fprintf(stderr,

    “codec not found\n”


    );

  244. exit(1);

  245. }



  247. /* open the codec */


  248. if


    (avcodec_open(c, codec) < 0) {

  249. fprintf(stderr,

    “could not open codec\n”


    );

  250. exit(1);

  251. }


  253. video_outbuf = NULL;


  254. if


    (!(oc->oformat->flags & AVFMT_RAWPICTURE)) {


  255. /* allocate output buffer */


  256. /* XXX: API change will be done */


  257. /* buffers passed into lav* can be allocated any way you prefer,


  258. as long as they’re aligned enough for the architecture, and


  259. they’re freed appropriately (such as using av_free for buffers


  260. allocated with av_malloc) */

  261. video_outbuf_size = 200000;

  262. video_outbuf = (uint8_t *)av_malloc(video_outbuf_size);

  263. }



  265. /* allocate the encoded raw picture */

  266. picture = alloc_picture(c->pix_fmt, c->width, c->height);


  267. if


    (!picture) {

  268. fprintf(stderr,

    “Could not allocate picture\n”


    );

  269. exit(1);

  270. }



  272. /* if the output format is not YUV420P, then a temporary YUV420P


  273. picture is needed too. It is then converted to the required


  274. output format */

  275. tmp_picture = NULL;


  276. if


    (c->pix_fmt != PIX_FMT_YUV420P) {

  277. tmp_picture = alloc_picture(PIX_FMT_YUV420P, c->width, c->height);


  278. if


    (!tmp_picture) {

  279. fprintf(stderr,

    “Could not allocate temporary picture\n”


    );

  280. exit(1);

  281. }

  282. }

  283. }



  285. /* prepare a dummy image */


  286. static




    void


    fill_yuv_image(AVFrame *pict,


    int


    frame_index,


    int


    width,


    int


    height)

  287. {


  288. int


    x, y, i;


  290. i = frame_index;



  292. /* Y */


  293. for


    (y = 0; y < height; y++) {


  294. for


    (x = 0; x < width; x++) {

  295. pict->data[0][y * pict->linesize[0] + x] = x + y + i * 3;

  296. }

  297. }



  299. /* Cb and Cr */


  300. for


    (y = 0; y < height/2; y++) {


  301. for


    (x = 0; x < width/2; x++) {

  302. pict->data[1][y * pict->linesize[1] + x] = 128 + y + i * 2;

  303. pict->data[2][y * pict->linesize[2] + x] = 64 + x + i * 5;

  304. }

  305. }

  306. }



  308. static




    void


    write_video_frame(AVFormatContext *oc, AVStream *st)

  309. {


  310. int


    out_size, ret;

  311. AVCodecContext *c;


  312. static




    struct


    SwsContext *img_convert_ctx;


  314. c = st->codec;



  316. if


    (frame_count >= STREAM_NB_FRAMES) {


  317. /* no more frame to compress. The codec has a latency of a few


  318. frames if using B frames, so we get the last frames by


  319. passing the same picture again */

  320. }

    else


    {


  321. if


    (c->pix_fmt != PIX_FMT_YUV420P) {


  322. /* as we only generate a YUV420P picture, we must convert it


  323. to the codec pixel format if needed */


  324. if


    (img_convert_ctx == NULL) {

  325. img_convert_ctx = sws_getContext(c->width, c->height,

  326. PIX_FMT_YUV420P,

  327. c->width, c->height,

  328. c->pix_fmt,

  329. sws_flags, NULL, NULL, NULL);


  330. if


    (img_convert_ctx == NULL) {

  331. fprintf(stderr,

    “Cannot initialize the conversion context\n”


    );

  332. exit(1);

  333. }

  334. }

  335. fill_yuv_image(tmp_picture, frame_count, c->width, c->height);

  336. sws_scale(img_convert_ctx, tmp_picture->data, tmp_picture->linesize,

  337. 0, c->height, picture->data, picture->linesize);

  338. }

    else


    {

  339. fill_yuv_image(picture, frame_count, c->width, c->height);

  340. }

  341. }




  344. if


    (oc->oformat->flags & AVFMT_RAWPICTURE) {


  345. /* raw video case. The API will change slightly in the near


  346. future for that. */

  347. AVPacket pkt;

  348. av_init_packet(&pkt);


  350. pkt.flags |= AV_PKT_FLAG_KEY;

  351. pkt.stream_index = st->index;

  352. pkt.data = (uint8_t *)picture;

  353. pkt.size =

    sizeof


    (AVPicture);


  355. ret = av_interleaved_write_frame(oc, &pkt);

  356. }

    else


    {


  357. /* encode the image */

  358. out_size = avcodec_encode_video(c, video_outbuf, video_outbuf_size, picture);


  359. /* if zero size, it means the image was buffered */


  360. if


    (out_size > 0) {

  361. AVPacket pkt;

  362. av_init_packet(&pkt);



  364. if


    (c->coded_frame->pts != AV_NOPTS_VALUE)

  365. pkt.pts= av_rescale_q(c->coded_frame->pts, c->time_base, st->time_base);


  366. if


    (c->coded_frame->key_frame)

  367. pkt.flags |= AV_PKT_FLAG_KEY;

  368. pkt.stream_index = st->index;

  369. pkt.data = video_outbuf;

  370. pkt.size = out_size;



  372. //          printf(“pts %d \n”, c->coded_frame->pts);



  374. /* write the compressed frame in 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\n”


    );

  382. exit(1);

  383. }

  384. frame_count++;

  385. }



  387. static




    void


    close_video(AVFormatContext *oc, AVStream *st)

  388. {

  389. avcodec_close(st->codec);

  390. av_free(picture->data[0]);

  391. av_free(picture);


  392. if


    (tmp_picture) {

  393. av_free(tmp_picture->data[0]);

  394. av_free(tmp_picture);

  395. }

  396. av_free(video_outbuf);

  397. }



  399. /**************************************************************/


  400. /* media file output */




  403. int


    main(


    int


    argc,


    char


    **argv)

  404. {


  405. const




    char


    *filename;

  406. AVOutputFormat *fmt;

  407. AVFormatContext *oc;

  408. AVStream *audio_st, *video_st;


  409. double


    audio_pts, video_pts;


  410. int


    i;



  412. /* initialize libavcodec, and register all codecs and formats */

  413. av_register_all();



  415. #if 0


  416. if


    (argc != 2) {

  417. printf(

    “usage: %s output_file\n”


  418. “API example program to output a media file with libavformat.\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. }


  425. filename = argv[1];


  426. #endif



  428. //#define RTMP_STREAM


  429. #ifdef RTMP_STREAM

  430. filename =

    “rtmp://192.168.0.239/live/livestream”


    ;


  431. #else

  432. filename =

    “1.mp4”


    ;


  433. #endif



  435. /* allocate the output media context */

  436. avformat_alloc_output_context2(&oc, NULL, NULL, filename);


  437. if


    (!oc)

  438. {

  439. printf(

    “Could not deduce output format from file extension: using MPEG.\n”


    );

  440. avformat_alloc_output_context2(&oc, NULL,

    /*”mpeg”*/


    “flv”


    , filename);

  441. }



  443. if


    (!oc)

  444. {


  445. return


    1;

  446. }



  448. // 强制指定 264 编码

  449. oc->oformat->video_codec = CODEC_ID_H264;

  450. oc->oformat->audio_codec = CODEC_ID_AAC;


  452. fmt = oc->oformat;



  454. /* add the audio and video streams using the default format codecs


  455. and initialize the codecs */

  456. video_st = NULL;

  457. audio_st = NULL;


  458. if


    (fmt->video_codec != CODEC_ID_NONE) {

  459. video_st = add_video_stream(oc, fmt->video_codec);

  460. }


  461. if


    (fmt->audio_codec != CODEC_ID_NONE) {

  462. audio_st = add_audio_stream(oc, fmt->audio_codec);

  463. }


  465. av_dump_format(oc, 0, filename, 1);



  467. /* now that all the parameters are set, we can open the audio and


  468. video codecs and allocate the necessary encode buffers */


  469. if


    (video_st)

  470. open_video(oc, video_st);


  471. if


    (audio_st)

  472. open_audio(oc, audio_st);



  474. /* open the output file, if needed */


  475. if


    (!(fmt->flags & AVFMT_NOFILE)) {


  476. if


    (avio_open(&oc->pb, filename, AVIO_FLAG_WRITE) < 0) {

  477. fprintf(stderr,

    “Could not open ‘%s’\n”


    , filename);


  478. return


    1;

  479. }

  480. }



  482. /* write the stream header, if any */

  483. avformat_write_header(oc, NULL);

  484. picture->pts = 0;


  485. for


    (;;)

  486. {


  487. /* compute current audio and video time */


  488. if


    (audio_st)

  489. audio_pts = (

    double


    )audio_st->pts.val * audio_st->time_base.num / audio_st->time_base.den;


  490. else

  491. audio_pts = 0.0;



  493. if


    (video_st)

  494. video_pts = (

    double


    )video_st->pts.val * video_st->time_base.num / video_st->time_base.den;


  495. else

  496. video_pts = 0.0;



  498. if


    ((!audio_st || audio_pts >= STREAM_DURATION) &&

  499. (!video_st || video_pts >= STREAM_DURATION))


  500. break


    ;



  502. /* write interleaved audio and video frames */


  503. if


    (!video_st || (video_st && audio_st && audio_pts < video_pts)) {

  504. write_audio_frame(oc, audio_st);


  506. }

    else


    {

  507. write_video_frame(oc, video_st);


  509. picture->pts++;

  510. }

  511. }



  513. /* write the trailer, if any.  the trailer must be written


  514. * before you close the CodecContexts open when you wrote the


  515. * header; otherwise write_trailer may try to use memory that


  516. * was freed on av_codec_close() */

  517. av_write_trailer(oc);



  519. /* close each codec */


  520. if


    (video_st)

  521. close_video(oc, video_st);


  522. if


    (audio_st)

  523. close_audio(oc, audio_st);



  525. /* free the streams */


  526. for


    (i = 0; i < oc->nb_streams; i++) {

  527. av_freep(&oc->streams[i]->codec);

  528. av_freep(&oc->streams[i]);

  529. }



  531. if


    (!(fmt->flags & AVFMT_NOFILE)) {


  532. /* close the output file */

  533. avio_close(oc->pb);

  534. }



  536. /* free the stream */

  537. av_free(oc);



  539. return


    0;

  540. }