yuque_diagram.jpg

  • 打开输入流设备
  • 打开编码器
  • 采集并准备数据 AVFrame
  • 转换YUYV422到YUV420P（NV12转YUV420P）

  • H264编码

    打开编码器

  • 使用哪个编码器 libx264

  • GOP设置，码率设置，宽高设置

    1. /**
    2. *  @brief 
    3. *  @param[in]
    4. *  @param[in]
    5. *  @param[out]
    6. */
    7. static int open_encoder(int width, int height, AVCodecContext** enc_ctx)
    8. {
    9.   int ret = 0;
    10.   AVCodec* codec = NULL;
    12.   codec = avcodec_find_encoder_by_name("libx264");
    13.   if (!codec)
    14.   {
    15.       printf("Codec libx264 not found\n");
    16.       exit(1);
    17.   }
    19.   *enc_ctx =  avcodec_alloc_context3(codec);
    20.   if (!enc_ctx)
    21.   {
    22.       printf("Counld out allocate video codec context\n\n");
    23.       exit(1);
    24.   }
    26.   //SPS
    27.   (*enc_ctx)->profile = FF_PROFILE_H264_HIGH_444;
    28.   (*enc_ctx)->level = 50; //表示LEVELE是5.0
    30.   //设置分辨率
    31.   (*enc_ctx)->width = width;
    32.   (*enc_ctx)->height = height;
    34.   //GOP
    35.   (*enc_ctx)->gop_size = 250;
    36.   //图像有很多变化的时候可以自动插入一个I帧，即最小的gop size
    37.   (*enc_ctx)->keyint_min = 25; //option 可选
    39.   //设置B帧的数量
    40.   (*enc_ctx)->max_b_frames = 3;//option 可选
    41.   (*enc_ctx)->has_b_frames = 1;//option 可选
    43.   //设置参考帧的数量
    44.   (*enc_ctx)->refcounted_frames = 3; //option 可选
    46.   //输入的YUV格式
    47.   (*enc_ctx)->pix_fmt = AV_PIX_FMT_YUV420P;
    49.   //设置码率
    50.   (*enc_ctx)->bit_rate = 600000; //600kbps
    52.   //设置帧率
    53.   AVRational time_base_t = { 1, 25 };
    54.   AVRational framerate_t = { 25, 1 };
    55.   (*enc_ctx)->time_base = time_base_t; //帧与帧之间的间隔是time_base
    56.   (*enc_ctx)->framerate = framerate_t;  //帧率, 每秒25帧
    58.   ret = avcodec_open2((*enc_ctx), codec, NULL);
    59.   if (ret < 0)
    60.   {
    61.       //printf("Counld not open codec: %s\n", av_err2str(ret));
    62.       printf("Counld not open codec: %d\n", ret);
    63.       exit(1);
    64.   }
    65. }

    采集并准备数据 AVFrame

    获取到的av package是个输出,需要把av package数据导入av frame中

    1. /**
    2. *  @brief xxxx
    3. *  @param[in] width
    4. *  @param[in] height
    5. *  @return AVFrame*
    6. */ 
    7. static AVFrame* create_frame(int width, int height, AVPixelFormat pix_fmt)
    8. {
    9.   int ret = 0;
    10.   AVFrame* frame = NULL;
    12.   frame = av_frame_alloc();
    13.   if (!frame)
    14.   {
    15.       printf("Error, No Memory!\n");
    16.       goto __ERROR;
    17.   }
    19.   //设置参数
    20.   frame->width = width;
    21.   frame->height = height;
    22.   frame->format = pix_fmt;
    24.   //alloc inner memory
    25.   ret = av_frame_get_buffer(frame, 32); //按32位对齐 【视频必须是32位对齐】
    26.   if (ret < 0)
    27.   {
    28.       printf("Error, Failed to alloc buffer for frame!\n");
    29.       goto __ERROR;
    30.   }
    32.   return frame;
    33. __ERROR:
    34.   if (frame)
    35.   {
    36.       av_frame_free(&frame);
    37.   }
    38.   return NULL;
    39. }

    转换YUYV422到YUV420P（NV12转YUV420P）

  • 自己编写代码转换（NV12 —-> YUV420p）

    1.       //YYYYYYYYUVUV NV12
    2.       //YYYYYYYYUUVV YUV420P
    3.       //Y
    4.       memcpy(frame->data[0], pkt->data, V_WIDTH * V_HEIGHT);
    5.       //V_WIDTH * V_HEIGHT之后是UV
    6.       for (i = 0; i < V_WIDTH * V_HEIGHT / 4; i++)
    7.       {
    8.           frame->data[1][i] = pkt->data[V_WIDTH * V_HEIGHT + i*2];
    9.           frame->data[2][i] = pkt->data[V_WIDTH * V_HEIGHT + i*2 + 1];
    10.       }
    12.       fwrite(frame->data[0], 1, V_WIDTH * V_HEIGHT, yuvoutfile);
    13.       fwrite(frame->data[1], 1, V_WIDTH * V_HEIGHT/4, yuvoutfile);
    14.       fwrite(frame->data[2], 1, V_WIDTH * V_HEIGHT/4, yuvoutfile);

  • 使用sws_scale函数转换

    1.       //sws_scale函数转换 yuyv422 -> yuv420p
    2.       //avpicture_fill((AVPicture*)frame_yuyv422, (unsigned char*)pkt->data, (AVPixelFormat)in_pix_fmt, V_WIDTH, V_HEIGHT); //该函数ffmpeg弃用了
    3.       av_image_fill_arrays(frame_yuyv422->data, frame_yuyv422->linesize, pkt->data, in_pix_fmt, V_WIDTH, V_HEIGHT, 4);
    5.       //yuyv422 -> yuv420p
    6.       sws_scale(img_convert_ctx, frame_yuyv422->data, frame_yuyv422->linesize,
    7.           0, V_HEIGHT, frame_yuv420->data, frame_yuv420->linesize);
    9.       fwrite(frame_yuv420->data[0], 1, V_WIDTH * V_HEIGHT, yuvoutfile);
    10.       fwrite(frame_yuv420->data[1], 1, V_WIDTH * V_HEIGHT / 4, yuvoutfile);
    11.       fwrite(frame_yuv420->data[2], 1, V_WIDTH * V_HEIGHT / 4, yuvoutfile);

    H264编码

  • avcodec_send_frame(enc_ctx, frame_yuv420);

  • avcodec_receive_packet(enc_ctx, newpkt); ```cpp while ((ret = av_read_frame(fmt_ctx, pkt)) == 0) {

    if 1 //sws_scale函数转换 yuyv422 -> yuv420p

    1.   //avpicture_fill((AVPicture*)frame_yuyv422, (unsigned char*)pkt->data, (AVPixelFormat)in_pix_fmt, V_WIDTH, V_HEIGHT);
    2.   av_image_fill_arrays(frame_yuyv422->data, frame_yuyv422->linesize, pkt->data, in_pix_fmt, V_WIDTH, V_HEIGHT, 4);
    3.   //yuyv422 -> yuv420p
    4.   sws_scale(img_convert_ctx, frame_yuyv422->data, frame_yuyv422->linesize,
    5.       0, V_HEIGHT, frame_yuv420->data, frame_yuv420->linesize);
    7.   fwrite(frame_yuv420->data[0], 1, V_WIDTH * V_HEIGHT, yuv_outfile);
    8.   fwrite(frame_yuv420->data[1], 1, V_WIDTH * V_HEIGHT / 4, yuv_outfile);
    9.   fwrite(frame_yuv420->data[2], 1, V_WIDTH * V_HEIGHT / 4, yuv_outfile);

else //代码处理将pkt->data里的数据按yuv420p的方式存储

  1.     //YYYYYYYYUVUV NV12
  2.     //YYYYYYYYUUVV YUV420P
  3.     //Y
  4.     memcpy(frame->data[0], pkt->data, V_WIDTH * V_HEIGHT);
  5.     //V_WIDTH * V_HEIGHT之后是UV
  6.     for (i = 0; i < V_WIDTH * V_HEIGHT / 4; i++)
  7.     {
  8.         frame->data[1][i] = pkt->data[V_WIDTH * V_HEIGHT + i*2];
  9.         frame->data[2][i] = pkt->data[V_WIDTH * V_HEIGHT + i*2 + 1];
  10.     }
  12.     fwrite(frame->data[0], 1, V_WIDTH * V_HEIGHT, yuvoutfile);
  13.     fwrite(frame->data[1], 1, V_WIDTH * V_HEIGHT/4, yuvoutfile);
  14.     fwrite(frame->data[2], 1, V_WIDTH * V_HEIGHT/4, yuvoutfile);

endif

  1.     frame_yuv420->pts = base++; //告知编码器输入帧与帧之间的关系，否则编出来的数据会花屏
  3.     encode(enc_ctx, frame_yuv420, newpkt, h264_outfile);
  4. }
  6. encode(enc_ctx, NULL, newpkt, h264_outfile);//传入NULL的frame，告诉编码器数据结束了，
  7.                   //让编码器输出所有的数据，防止丢帧。
  2. <a name="JrrL5"></a>
  3. # 完整代码
  4. ```cpp
  6. #include <iostream>
  8. using namespace std;
  10. extern "C"
  11. {
  12. #include "libavcodec/avcodec.h"
  13. #include "libavutil/avutil.h"
  14. #include "libavutil/opt.h"
  15. #include "libavutil/channel_layout.h"
  16. #include "libavdevice/avdevice.h"
  17. #include "libswscale/swscale.h"
  18. #include "libswresample/swresample.h"
  19. #include "libavutil/samplefmt.h"
  20. #include "libavutil/error.h"
  21. #include "libavutil/imgutils.h"
  22. }
  24. #define V_WIDTH  640
  25. #define V_HEIGHT 480
  28. /**
  29.  *  @brief 
  30.  *  @param[in]
  31.  *  @param[in]
  32.  *  @param[out]
  33.  */
  34. static int open_encoder(int width, int height, AVCodecContext** enc_ctx)
  35. {
  36.     int ret = 0;
  37.     AVCodec* codec = NULL;
  39.     codec = avcodec_find_encoder_by_name("libx264");
  40.     if (!codec)
  41.     {
  42.         printf("Codec libx264 not found\n");
  43.         exit(1);
  44.     }
  46.     *enc_ctx =  avcodec_alloc_context3(codec);
  47.     if (!enc_ctx)
  48.     {
  49.         printf("Counld out allocate video codec context\n\n");
  50.         exit(1);
  51.     }
  53.     //SPS
  54.     (*enc_ctx)->profile = FF_PROFILE_H264_HIGH_444;
  55.     (*enc_ctx)->level = 50; //表示LEVELE是5.0
  57.     //设置分辨率
  58.     (*enc_ctx)->width = width;
  59.     (*enc_ctx)->height = height;
  61.     //GOP
  62.     (*enc_ctx)->gop_size = 250;
  63.     //图像有很多变化的时候可以自动插入一个I帧，即最小的gop size
  64.     (*enc_ctx)->keyint_min = 25; //option 可选
  66.     //设置B帧的数量
  67.     (*enc_ctx)->max_b_frames = 3;//option 可选
  68.     (*enc_ctx)->has_b_frames = 1;//option 可选
  70.     //设置参考帧的数量
  71.     (*enc_ctx)->refcounted_frames = 3; //option 可选
  73.     //输入的YUV格式
  74.     (*enc_ctx)->pix_fmt = AV_PIX_FMT_YUV420P;
  76.     //设置码率
  77.     (*enc_ctx)->bit_rate = 400000; //600kbps
  79.     //设置帧率
  80.     AVRational time_base_t = { 1, 15 };
  81.     AVRational framerate_t = { 15, 1 };
  82.     (*enc_ctx)->time_base = time_base_t; //帧与帧之间的间隔是time_base
  83.     (*enc_ctx)->framerate = framerate_t;  //帧率, 每秒30帧
  85.     ret = avcodec_open2((*enc_ctx), codec, NULL);
  86.     if (ret < 0)
  87.     {
  88.         //printf("Counld not open codec: %s\n", av_err2str(ret));
  89.         printf("Counld not open codec: %d\n", ret);
  90.         exit(1);
  91.     }
  92. }
  94. /**
  95.  *  @brief xxxx
  96.  *  @param[in] width
  97.  *  @param[in] height
  98.  *  @return AVFrame*
  99.  */ 
  100. static AVFrame* create_frame(int width, int height, AVPixelFormat pix_fmt)
  101. {
  102.     int ret = 0;
  103.     AVFrame* frame = NULL;
  105.     frame = av_frame_alloc();
  106.     if (!frame)
  107.     {
  108.         printf("Error, No Memory!\n");
  109.         goto __ERROR;
  110.     }
  112.     //设置参数
  113.     frame->width = width;
  114.     frame->height = height;
  115.     frame->format = pix_fmt;
  117.     //alloc inner memory
  118.     ret = av_frame_get_buffer(frame, 32); //按32位对齐 【视频必须是32位对齐】
  119.     if (ret < 0)
  120.     {
  121.         printf("Error, Failed to alloc buffer for frame!\n");
  122.         goto __ERROR;
  123.     }
  125.     return frame;
  126. __ERROR:
  127.     if (frame)
  128.     {
  129.         av_frame_free(&frame);
  130.     }
  131.     return NULL;
  132. }
  134. void encode(AVCodecContext* enc_ctx, AVFrame* frame, AVPacket* newpkt, FILE* outfile) 
  135. {
  136.     if (frame)
  137.         printf("send frame to encoder, pts = %lld\n", frame->pts);
  138.     //把AVFrame传给编码器，送原始数据给编码器进行编码
  139.     int ret = avcodec_send_frame(enc_ctx, frame);
  140.     if (ret < 0) 
  141.     {
  143.     }
  144.     //从编码器获取编码好的数据
  145.     //从编码器获取编码是连续输出的，有可能喂frame数据给编码器的是编码器并不输出
  146.     //有可能一次输出好几个编码好的数据。
  147.     while (ret >= 0)
  148.     {
  149.         ret = avcodec_receive_packet(enc_ctx, newpkt);
  150.         //编码器数据不足时，返回EAGAIN，或者到数据结尾时返回AVERROR_EOF
  151.         if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
  152.             return;
  153.         if (ret < 0) {
  154.             printf("error, failed to encode.\n");
  155.             exit(1);
  156.         }
  157.         //outfile输出h264的编码
  158.         fwrite(newpkt->data, 1, newpkt->size, outfile);
  159.         av_packet_unref(newpkt);//减少newpkt的引用计数
  160.     }
  161. }
  163. int main()
  164. {
  165.     int base = 0;
  166.     int ret = 0;
  167.     AVPacket* pkt = NULL;
  168.     AVInputFormat* in_format = NULL;
  169.     AVFormatContext* fmt_ctx = NULL;
  170.     AVDictionary* options = NULL;
  172.     AVFrame* frame_yuyv422 = NULL;
  173.     AVFrame* frame_yuv420 = NULL;
  175.     FILE* out_file = NULL;
  176.     char errors[1024] = { 0 };
  177.     char device_name[256] = "video=Integrated Webcam";
  179.     //图像转换参数
  180.     struct SwsContext* img_convert_ctx = NULL;
  181.     AVPixelFormat in_pix_fmt = AV_PIX_FMT_YUYV422;
  182.     AVPixelFormat out_pix_fmt = AV_PIX_FMT_YUV420P;
  183.     static int sws_flags = SWS_BICUBIC; //差值算法,双三次
  185.     //create file
  186.     const char* yuvout = "video.yuv"; //yuv420p
  187.     const char* h264out = "out.h264"; //h264
  188.     AVCodecContext* enc_ctx = NULL;
  190.     FILE* yuv_outfile = fopen(yuvout, "wb+");
  191.     FILE* h264_outfile = fopen(h264out, "wb+");
  193.     av_register_all();
  194.     avdevice_register_all();
  196.     //设置采集
  197.     in_format = av_find_input_format("dshow");
  198.     if (in_format == NULL)
  199.     {
  200.         printf("av_find_input_format error\n");
  201.     }
  203.     av_dict_set(&options, "video_size", "640*480", 0);
  204.     av_dict_set(&options, "framerate", "30", 0);
  205.     av_dict_set(&options, "pixel_format", "yuyv422", 0);
  207.     if ((ret = avformat_open_input(&fmt_ctx, device_name, in_format, &options)) != 0)
  208.     {
  209.         av_strerror(ret, errors, 1024);
  210.         printf("Failed to open video device, [%s][%d]\n", errors, ret);
  211.         return -1;
  212.     }
  214.     pkt = av_packet_alloc();
  215.     av_init_packet(pkt);
  217.     av_dump_format(fmt_ctx, 0, device_name, 0);
  219.     //打开编码器
  220.     open_encoder(V_WIDTH, V_HEIGHT, &enc_ctx);
  222.     //创建avframe
  223.     frame_yuyv422 = create_frame(V_WIDTH, V_HEIGHT, in_pix_fmt);
  224.     frame_yuv420 = create_frame(V_WIDTH, V_HEIGHT, out_pix_fmt);
  227.     //设置转换context
  228.     if (img_convert_ctx == NULL)
  229.     {
  230.         img_convert_ctx = sws_getContext(V_WIDTH, V_HEIGHT,
  231.             (AVPixelFormat)in_pix_fmt,
  232.             V_WIDTH,
  233.             V_HEIGHT,
  234.             (AVPixelFormat)out_pix_fmt,
  235.             sws_flags, NULL, NULL, NULL);
  236.         if (img_convert_ctx == NULL)
  237.         {
  238.             fprintf(stderr, "Cannot initialize the conversion context\n");
  239.             return -1;
  240.         }
  241.     }
  244.     //创建编码输出的packet
  245.     AVPacket* newpkt = av_packet_alloc();
  246.     if (!newpkt)
  247.     {
  248.         printf("Error, Failed to alloc avpacket!\n");
  249.         goto __END;
  250.     }
  252.     while ((ret = av_read_frame(fmt_ctx, pkt)) == 0)
  253.     {
  254. #if 1 //sws_scale函数转换 yuyv422 -> yuv420p
  255.         //avpicture_fill((AVPicture*)frame_yuyv422, (unsigned char*)pkt->data, (AVPixelFormat)in_pix_fmt, V_WIDTH, V_HEIGHT);
  256.         av_image_fill_arrays(frame_yuyv422->data, frame_yuyv422->linesize, pkt->data, in_pix_fmt, V_WIDTH, V_HEIGHT, 4);
  257.         //yuyv422 -> yuv420p
  258.         sws_scale(img_convert_ctx, frame_yuyv422->data, frame_yuyv422->linesize,
  259.             0, V_HEIGHT, frame_yuv420->data, frame_yuv420->linesize);
  261.         fwrite(frame_yuv420->data[0], 1, V_WIDTH * V_HEIGHT, yuv_outfile);
  262.         fwrite(frame_yuv420->data[1], 1, V_WIDTH * V_HEIGHT / 4, yuv_outfile);
  263.         fwrite(frame_yuv420->data[2], 1, V_WIDTH * V_HEIGHT / 4, yuv_outfile);
  265. #else   //代码处理将pkt->data里的数据按yuv420p的方式存储
  266.         //YYYYYYYYUVUV NV12
  267.         //YYYYYYYYUUVV YUV420P
  268.         //Y
  269.         memcpy(frame->data[0], pkt->data, V_WIDTH * V_HEIGHT);
  270.         //V_WIDTH * V_HEIGHT之后是UV
  271.         for (i = 0; i < V_WIDTH * V_HEIGHT / 4; i++)
  272.         {
  273.             frame->data[1][i] = pkt->data[V_WIDTH * V_HEIGHT + i*2];
  274.             frame->data[2][i] = pkt->data[V_WIDTH * V_HEIGHT + i*2 + 1];
  275.         }
  277.         fwrite(frame->data[0], 1, V_WIDTH * V_HEIGHT, yuvoutfile);
  278.         fwrite(frame->data[1], 1, V_WIDTH * V_HEIGHT/4, yuvoutfile);
  279.         fwrite(frame->data[2], 1, V_WIDTH * V_HEIGHT/4, yuvoutfile);
  280. #endif
  282.         frame_yuv420->pts = base++; //告知编码器输入帧与帧之间的关系，否则编出来的数据会花屏
  284.         encode(enc_ctx, frame_yuv420, newpkt, h264_outfile);
  285.     }
  287.     encode(enc_ctx, NULL, newpkt, h264_outfile);//传入NULL的frame，告诉编码器数据结束了，
  288.                       //让编码器输出所有的数据，防止丢帧。
  290. __END:
  291.     if (frame_yuyv422)
  292.     {
  293.         av_frame_free(&frame_yuyv422);
  294.         frame_yuyv422 = NULL;
  295.     }
  296.     if (frame_yuv420)
  297.     {
  298.         av_frame_free(&frame_yuv420);
  299.         frame_yuv420 = NULL;
  300.     }
  301.     av_packet_free(&pkt);
  302.     cout << "Hello World!\n";
  303. }