FFmpeg实时解码H264

最新推荐文章于 2024-09-22 15:00:00 发布
最新推荐文章于 2024-09-22 15:00:00 发布
阅读量2.8k 收藏 4
点赞数 1
分类专栏： 音视频 文章标签： ffmpeg h264解码

原文地址：http://blog.csdn.net/qq_41051855/article/details/79051667

    ffmpeg的解码过程在前面已经稍微总结了下，这里主要是测试一下用ffmpeg如何进行实时的解码。

    在解码之前，我们先做好准备工作，调用摄像头。编码的过程中，进行入队出队操作，出队后的数据交给解码器，进行解码。

    接下来依次介绍各个模块。


1.调用摄像头：

[cpp]  view plain  copy
  1. VideoCapture capture(0);  
  2.   
  3. int w = capture.get(CV_CAP_PROP_FRAME_WIDTH);  
  4. int h = capture.get(CV_CAP_PROP_FRAME_HEIGHT);  
  5. int yuv_bufLen = w * h * 3 / 2;  
  6. unsigned char* pYuvBuf = new unsigned char[yuv_bufLen];  
  7.   
  8. cout << "Frame size : " << w << " x " << h << endl;  
  9. namedWindow("opencamera", CV_WINDOW_AUTOSIZE);  
  10.   
  11. while (1)  
  12. {  
  13.     Mat frame;  
  14.     capture >> frame;  
  15.     imshow("opencamera", frame);  
  16.     if (waitKey(30) == 27) break;         
  17. }  
    怎么利用opencv调用摄像头，这里不做过多介绍，可以参考这里： 点击打开链接。

2.编码过程：

[cpp]  view plain  copy
  1. DWORD WINAPI x264_encode(LPVOID lparam)  
  2. {  
  3.     VideoCapture capture(0);  
  4.     if (!capture.isOpened())  
  5.     {  
  6.         cout << "Cannot open the video cam" << endl;  
  7.         return -1;  
  8.     }  
  9.   
  10.     int w = capture.get(CV_CAP_PROP_FRAME_WIDTH);  
  11.     int h = capture.get(CV_CAP_PROP_FRAME_HEIGHT);  
  12.   
  13.     result_link_type* result_link = (result_link_type*)lparam;  
  14.   
  15.     int yuv_bufLen = w * h * 3 / 2;  
  16.     //unsigned char* pYuvBuf = new unsigned char[yuv_bufLen];  
  17.   
  18.     //int fps =25;  
  19.     size_t yuv_size = w * h * 3 / 2;  
  20.     x264_t *encoder;  
  21.     x264_picture_t pic_in, pic_out;  
  22.     uint8_t *yuv_buffer;  
  23.   
  24.     x264_param_t param;  
  25.     //x264_param_default_preset(¶m, "veryfast", "zerolatency");  //为结构体param赋默认值  
  26.     x264_param_default_preset(¶m, "veryfast", "animation");  
  27.   
  28.     //param.i_threads = 1;         //并行编码多帧  
  29.     param.i_width = w;           //视频图像的宽  
  30.     param.i_height = h;  
  31.                                                                                                                                                                                                                                                                     //  param.i_fps_num = fps;       //帧率分子  
  32.     //param.i_fps_den = 1;         //帧率分母 , fps_num / fps_den = 帧率  
  33.     //param.i_keyint_max = 50;     //IDR帧之间的间隔  
  34.     //param.b_intra_refresh = 1;   //是否使用周期帧内刷新IDR帧  
  35.     //param.b_annexb = 1;          //加前缀码0x00000001  
  36.     //param.rc.b_mb_tree = 0;      //实时编码必须为0，否则有延迟  
  37.     //param.b_sliced_threads = 0;  
  38.   
  39.     //x264_param_apply_profile(¶m, "baseline");    //编码器的参数，使用baseline编码，可以跟上面的参数做冲突比较  
  40.   
  41.     encoder = x264_encoder_open(¶m);     //打开编码器，初始化param  
  42.   
  43. #if 1  
  44.     x264_picture_alloc(&pic_in, X264_CSP_I420, w, h);    //为pic_in分配内存   
  45.     yuv_buffer = (uint8_t*)malloc(yuv_size);     //给yuv_buffer分配内存  
  46.   
  47.     pic_in.img.plane[0] = yuv_buffer;       //pic_in的三通道分别赋值  
  48.     pic_in.img.plane[1] = pic_in.img.plane[0] + w * h;  
  49.     pic_in.img.plane[2] = pic_in.img.plane[1] + w * h / 4;  
  50.   
  51.     int64_t i_pts = 0;  
  52.     x264_nal_t *nals;  
  53.     int nnal;  
  54.   
  55.     FILE *fp_out = fopen("test.h264", "wb");  
  56.     if (!fp_out)  
  57.     {  
  58.         printf("Could not open output 264 file\n");  
  59.         return -1;  
  60.     }  
  61.   
  62. #if 1  
  63.     FILE* pFileOut = fopen("test.yuv", "w+");  
  64.     if (!pFileOut)  
  65.     {  
  66.         printf("Could not open input yuv file\n");  
  67.         return -1;  
  68.     }  
  69. #endif  
  70.   
  71.     cout << "Frame size : " << w << " x " << h << endl;  
  72.     namedWindow("opencamera", CV_WINDOW_AUTOSIZE);  
  73.     Mat frame;  
  74.     while (1)  
  75.     {  
  76.         capture >> frame;             //摄像头处抓取一帧  
  77.         imshow("opencamera", frame);  //显示  
  78.         //if (waitKey(30) == 27) break;   
  79.         waitKey(1);  
  80.   
  81.         cv::Mat yuvImg;  
  82.         cv::cvtColor(frame, yuvImg, CV_BGR2YUV_I420);    //YUV转RGB  
  83.         memcpy(yuv_buffer, yuvImg.data, yuv_bufLen*sizeof(unsigned char));    //YUV数据复制到yuv_buffer中  
  84.         //fwrite(yuv_buffer, yuv_bufLen*sizeof(unsigned char), 1, pFileOut);    //YUV写入本地  
  85.   
  86.         //while (fread(yuv_buffer, 1, yuv_size, inf) > 0)  
  87.         //{  
  88.         pic_in.i_pts = i_pts++;  
  89.         x264_encoder_encode(encoder, &nals, &nnal, &pic_in, &pic_out);      //编码一帧数据  
  90.         x264_nal_t *nal;  
  91.   
  92.         int j = 0;  
  93.         struct result_node_datatype *result_node = new struct result_node_datatype;  
  94.         result_node->result = new unsigned char[800000];  
  95.         memset(result_node->result, '\0', 800000);  
  96.         result_node->size = 0;  
  97.         for (nal = nals; nal < nals + nnal; nal++)  
  98.         {  
  99.             //fwrite(nal->p_payload, 1, nal->i_payload, fp_out);      //产生的NAL保存在本地  
  100.             //result_node->size += nal->i_payload;  
  101.             //memcpy(result_node->result, nal->p_payload, nal->i_payload);  
  102.             //cout << "nal->i_payload = " <<nal->i_payload<< endl;  
  103.             //j = j + nal->i_payload;  
  104.             //result_push(result_link, result_node);  
  105.             //cout << "in for(nal)： j = "<<j << endl;  
  106.   
  107.             memcpy(result_node->result + j, nal->p_payload, nal->i_payload);  
  108.             j = j + nal->i_payload;  
  109.         }  
  110.         result_node->size = j;  
  111.         cout << "result_node->size = " << result_node->size << endl;  
  112.         result_push(result_link, result_node);  
  113.     }  
  114.   
  115.     x264_encoder_close(encoder);   //关闭编码器  
  116.     //fclose(inf);  
  117.     //free(yuv_buffer);  
  118.     //fclose(pFileOut);  
  119.     //delete[] pYuvBuf;  
  120.     //Sleep(100);  
  121. #endif  
  122.     return NULL;  
  123. }  

    X264编码的过程可以参考这里：点击打开链接。

    需要注意的是，我们定义了一个为0的值j。编码产生后的NAL单元个数是nnal，编码后数据的起始地址是nal->p_payload，长度是nal->i_payload。增加j的原因是想把得到的一个个NAL单元累加在一起，组成一个完整帧的数据，最后一帧的长度就是j，然后将得到的一帧数据与长度送入队列，这是一个线程函数。对解码器来说，只有接收到完整的一帧，才能成功解码。


3.队列函数：

[cpp]  view plain  copy
  1. void result_push(result_link_type* result_link, result_node_datatype * result_node) //入队操作  
  2. {  
  3.     if (result_link->head == NULL)  
  4.     {  
  5.         result_link->head = result_node;  
  6.         result_link->end = result_link->head;  
  7.         result_link->result_num++;  
  8.     //  cout << "0: result_link->result_num++" << endl;  
  9.     }  
  10.     else  
  11.     {  
  12.         result_link->end->next = result_node;  
  13.         result_link->end = result_node;  
  14.         result_link->result_num++;  
  15.     //  cout << "1: result_link->result_num++" << endl;  
  16.     }  
  17. }  
  18.   
  19. struct result_node_datatype* result_pop(result_link_type* result_link) //出队操作  
  20. {  
  21.     struct result_node_datatype* tmp_node;  
  22.     if (result_link->head == NULL)  
  23.         return NULL;  
  24.     else if (result_link->head == result_link->end)  
  25.     {  
  26.         //  cout << "result_link->head == result_link->end " << endl;  
  27.         return NULL;  
  28.     }  
  29.     else  
  30.     {  
  31.         tmp_node = result_link->head;  
  32.         result_link->head = result_link->head->next;  
  33.         result_link->result_num--;  
  34.         //cout << "result_link->result_num--" << endl;  
  35.         return tmp_node;  
  36.     }  
  37. }  


4.解码过程：

    解码之前，要添加标志位0001。

[cpp]  view plain  copy
  1. bool get_h264_data(uchar* buf,int in_len,uchar* out_buf, int &out_len)  
  2. {  
  3.     char nalu[4] = { 0x00, 0x00, 0x00, 0x01 };  
  4.     memcpy(out_buf, nalu, 4);  
  5.     out_buf += 4;  
  6.     memcpy(out_buf, buf, in_len);  
  7.     out_len = in_len + 4;  
  8. //  cout << "out_len = " <<out_len<< endl;  
  9.     return true;  
  10. }  

    解码过程：

[cpp]  view plain  copy
  1. int main(int argc, char* argv[])  
  2. {  
  3.     HANDLE thread1;  
  4.     result_link_type *result_link = new result_link_type;  
  5.     result_link->head = result_link->end = NULL;  
  6.     result_link->result_num = 0;  
  7.     thread1 = CreateThread(NULL, 0, x264_encode, (LPVOID)result_link, 0, NULL);  
  8.     Sleep(1);  
  9.     //system("pause");  
  10. #if 1  
  11.     Mat pCvMat;  
  12.     AVCodec *pCodec;  
  13.     AVCodecContext *pCodecCtx = NULL;  
  14.     AVCodecParserContext *pCodecParserCtx = NULL;  
  15.   
  16.     int frame_count;  
  17.     FILE *fp_in;  
  18.     FILE *fp_out;  
  19.     AVFrame *pFrame, *pFrameYUV;  
  20.     uint8_t *out_buffer;  
  21. //  const int in_buffer_size = 4096;  
  22.     const int in_buffer_size = 800000;  
  23.     //uint8_t in_buffer[in_buffer_size + FF_INPUT_BUFFER_PADDING_SIZE] = { 0 };  
  24.     uint8_t in_buffer[in_buffer_size];  
  25.     memset(in_buffer, 0, sizeof(in_buffer));  
  26.     uint8_t *cur_ptr;  
  27.     int cur_size;  
  28.   
  29.     AVPacket packet;  
  30.     int ret, got_picture;  
  31.   
  32.     int y_size;  
  33.   
  34.     AVCodecID codec_id = AV_CODEC_ID_H264;  
  35. //  char filepath_in[] = "test.h264";  
  36.   
  37. //  char filepath_out[] = "1.yuv";  
  38.     int first_time = 1;  
  39.   
  40.     struct SwsContext *img_convert_ctx;  
  41.   
  42.     //av_log_set_level(AV_LOG_DEBUG);  
  43.   
  44.     avcodec_register_all();  
  45.   
  46.     pCodec = avcodec_find_decoder(codec_id);  
  47.     if (!pCodec) {  
  48.         printf("Codec not found\n");  
  49.         return -1;  
  50.     }  
  51.     pCodecCtx = avcodec_alloc_context3(pCodec);  
  52.     if (!pCodecCtx){  
  53.         printf("Could not allocate video codec context\n");  
  54.         return -1;  
  55.     }  
  56.   
  57.     pCodecParserCtx = av_parser_init(codec_id);  
  58.     if (!pCodecParserCtx){  
  59.         printf("Could not allocate video parser context\n");  
  60.         return -1;  
  61.     }  
  62.   
  63.     if (pCodec->capabilities&CODEC_CAP_TRUNCATED)  
  64.         pCodecCtx->flags |= CODEC_FLAG_TRUNCATED; /* we do not send complete frames */  
  65.   
  66.     if (avcodec_open2(pCodecCtx, pCodec, NULL) < 0) {  
  67.         printf("Could not open codec\n");  
  68.         return -1;  
  69.     }  
  70. #if 0  
  71.     //Input File  
  72.     fp_in = fopen(filepath_in, "rb");  
  73.     if (!fp_in) {  
  74.         printf("Could not open input stream\n");  
  75.         return -1;  
  76.     }  
  77.     //Output File  
  78.     fp_out = fopen(filepath_out, "wb");  
  79.     if (!fp_out) {  
  80.         printf("Could not open output YUV file\n");  
  81.         return -1;  
  82.     }  
  83. #endif  
  84.     pFrame = av_frame_alloc();  
  85.     av_init_packet(&packet);  
  86.     AVFrame* pFrameBGR = av_frame_alloc(); //存储解码后转换的RGB数据    
  87.     // 保存BGR，opencv中是按BGR来保存的    
  88.     int size;  
  89.     //cout << "pCodecCtx->width = " << pCodecCtx->width << "\npCodecCtx->height = " << pCodecCtx->height << endl;  
  90.     //pCvMat.create(cv::Size(pCodecCtx->width, pCodecCtx->height), CV_8UC3);  
  91.     struct result_node_datatype *result_node2 = NULL;  
  92.   
  93.     int out_len;  
  94.   
  95.     while (1)   
  96.     {  
  97.     //  cur_size = fread(in_buffer, 1, in_buffer_size, fp_in);  
  98.     //  cout << "result_link->size = " << result_link->result_num << endl;  
  99.         result_node2 = result_pop(result_link);  
  100.         if (result_node2 == NULL)  
  101.         {  
  102.             Sleep(1);  
  103.         //  cout << "result_node2 is NULL" << endl;  
  104.             continue;  
  105.         }  
  106.         //cur_size = result_node2->size;  
  107.         //cout<<"after result_pop()" << endl;  
  108.       
  109.         get_h264_data(result_node2->result, result_node2->size, in_buffer, out_len);  
  110.   
  111.         //cur_size = result_node2->size;  
  112.         cur_size = out_len;  
  113.         cout << "cur_size = " << cur_size << endl;  
  114.         if (cur_size == 0)  
  115.             break;  
  116.         cur_ptr = in_buffer;  
  117.         //cur_ptr = result_node2->result;  
  118.   
  119.         while (cur_size>0){  
  120.   
  121.             int len = av_parser_parse2(  
  122.                 pCodecParserCtx, pCodecCtx,  
  123.                 &packet.data, &packet.size,  
  124.                 cur_ptr, cur_size,  
  125.                 AV_NOPTS_VALUE, AV_NOPTS_VALUE, AV_NOPTS_VALUE);  
  126.   
  127.             cur_ptr += len;  
  128.             cur_size -= len;  
  129.   
  130.             if (packet.size == 0)  
  131.                 continue;  
  132.   
  133.             //Some Info from AVCodecParserContext  
  134.             printf("Packet Size:%6d\t", packet.size);  
  135.             switch (pCodecParserCtx->pict_type){  
  136.             case AV_PICTURE_TYPE_I: printf("Type: I\t"); break;  
  137.             case AV_PICTURE_TYPE_P: printf("Type: P\t"); break;  
  138.             case AV_PICTURE_TYPE_B: printf("Type: B\t"); break;  
  139.             default: printf("Type: Other\t"); break;  
  140.             }  
  141.             printf("Output Number:%4d\t", pCodecParserCtx->output_picture_number);  
  142.             printf("Offset:%8ld\n", pCodecParserCtx->cur_offset);  
  143.   
  144.             ret = avcodec_decode_video2(pCodecCtx, pFrame, &got_picture, &packet);  
  145.             if (ret < 0) {  
  146.                 printf("Decode Error.(解码错误)\n");  
  147.                 return ret;  
  148.             }  
  149.             if (got_picture) {  
  150.                 if (first_time){  
  151.                     printf("\nCodec Full Name:%s\n", pCodecCtx->codec->long_name);  
  152.                     printf("width:%d\nheight:%d\n\n", pCodecCtx->width, pCodecCtx->height);  
  153.                     //SwsContext  
  154.                     //img_convert_ctx = sws_getContext(pCodecCtx->width, pCodecCtx->height, pCodecCtx->pix_fmt,  
  155.                     //  pCodecCtx->width, pCodecCtx->height, PIX_FMT_YUV420P, SWS_BICUBIC, NULL, NULL, NULL);  
  156.                     img_convert_ctx = sws_getContext(pCodecCtx->width, pCodecCtx->height, pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height, AV_PIX_FMT_BGR24, SWS_BICUBIC, NULL, NULL, NULL);  
  157.                     //pFrameYUV = av_frame_alloc();  
  158.                     //out_buffer = (uint8_t *)av_malloc(avpicture_get_size(PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height));  
  159.                     //avpicture_fill((AVPicture *)pFrameYUV, out_buffer, PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height);  
  160.   
  161.                     //y_size = pCodecCtx->width*pCodecCtx->height;  
  162.                     //size = avpicture_get_size(AV_PIX_FMT_BGR24, pCodecCtx->width, pCodecCtx->height);  
  163.   
  164.                     size = avpicture_get_size(AV_PIX_FMT_BGR24, pCodecCtx->width, pCodecCtx->height);  
  165.                     out_buffer = (uint8_t *)av_malloc(size);  
  166.                     avpicture_fill((AVPicture *)pFrameBGR, out_buffer, AV_PIX_FMT_BGR24, pCodecCtx->width, pCodecCtx->height); // allocator memory for BGR buffer    
  167.                     cout << "pCodecCtx->width = " << pCodecCtx->width << "\npCodecCtx->height = " << pCodecCtx->height << endl;  
  168.                     pCvMat.create(cv::Size(pCodecCtx->width, pCodecCtx->height), CV_8UC3);  
  169.                     first_time = 0;  
  170.                 }  
  171.   
  172.                 printf("Succeed to decode 1 frame!\n");  
  173.                 //sws_scale(img_convert_ctx, (const uint8_t* const*)pFrame->data, pFrame->linesize, 0, pCodecCtx->height,pFrameYUV->data, pFrameYUV->linesize);  
  174.                 sws_scale(img_convert_ctx, (const uint8_t* const*)pFrame->data, pFrame->linesize, 0, pCodecCtx->height, pFrameBGR->data, pFrameBGR->linesize);  
  175.   
  176.                 //fwrite(pFrameYUV->data[0], 1, y_size, fp_out);     //Y   
  177.                 //fwrite(pFrameYUV->data[1], 1, y_size / 4, fp_out);   //U  
  178.                 //fwrite(pFrameYUV->data[2], 1, y_size / 4, fp_out);   //V  
  179.                 cout << "size = " << size << endl;  
  180.                 memcpy(pCvMat.data, out_buffer, size);  
  181.                 imshow("RGB", pCvMat);  
  182.                 waitKey(1);  
  183.   
  184.             }  
  185.         }  
  186.     }  
  187.   
  188.     system("pause");  
  189.     //Flush Decoder  
  190.     packet.data = NULL;  
  191.     packet.size = 0;  
  192.   
  193. #if 0  
  194.     while (1){  
  195.         ret = avcodec_decode_video2(pCodecCtx, pFrame, &got_picture, &packet);  
  196.         if (ret < 0) {  
  197.             printf("Decode Error.(解码错误)\n");  
  198.             return ret;  
  199.         }  
  200.         if (!got_picture)  
  201.             break;  
  202.         if (got_picture) {  
  203.             printf("Flush Decoder: Succeed to decode 1 frame!\n");  
  204.             sws_scale(img_convert_ctx, (const uint8_t* const*)pFrame->data, pFrame->linesize, 0, pCodecCtx->height,  
  205.                 pFrameYUV->data, pFrameYUV->linesize);  
  206.   
  207.             fwrite(pFrameYUV->data[0], 1, y_size, fp_out);     //Y  
  208.             fwrite(pFrameYUV->data[1], 1, y_size / 4, fp_out);   //U  
  209.             fwrite(pFrameYUV->data[2], 1, y_size / 4, fp_out);   //V  
  210.         }  
  211.     }  
  212. #endif  
  213.   
  214. //  fclose(fp_in);  
  215. //  fclose(fp_out);  
  216.   
  217.     sws_freeContext(img_convert_ctx);  
  218.     av_parser_close(pCodecParserCtx);  
  219.   
  220.     //av_frame_free(&pFrameYUV);  
  221.     av_frame_free(&pFrameBGR);  
  222.     av_frame_free(&pFrame);  
  223.     avcodec_close(pCodecCtx);  
  224.     av_free(pCodecCtx);  
  225. #endif  
  226.     return 0;  
  227. }  

    解码流程以及基本参数和函数的意义，可以参考链接：点击打开链接。

    解码成功后，got_picture为非零值，在这个判断里面，解码出的数据转为RGB格式，并用opencv显示出来。


    运行效果图：

 

    运行的过程中，对比上面的效果图，发现解码后的图像比摄像头要延迟几秒钟，这是因为在编码的过程，我们使用了参数animation，编码开始前会缓存几帧，再开始，这样帧间编码效果好，压缩效率高。如果使用zerolatency（零延时），基本不会有延时效果，但是压缩效果不太好。

    

    完整测试项目的代码下载地址：点击打开链接

zwz1984
关注
专栏目录
ffmpeg实时解码H264数据流
大欢熊的专栏
12-06 3282
以下是一个测试程序，用的是读取h264文件数据然后用ffmpeg解码的方法，模拟实时数据的解码。测试已通过，解码正常。 至于如何编译ffmpeg、如何实现收发数据、如何拼帧这里不予说明，请查看相关文档。    1、.h文件里面 #ifdef __cplusplus extern "C" { #endif #include "libavformat/avformat.h"
h.264 视频解码的一点小经验
fg313071405的专栏
04-28 996
http://blog.csdn.net/qiqi5521/archive/2007/04/25/1584520.aspx 最近做视频文件264解码，由于对这个领域不是很熟悉，感觉困难重重。不过经过不懈的努力，已经取得一些进展，心里感觉特别庆幸。 刚开始做这个的时候，由于不熟悉，就在网上搜寻资料，网络上的资料虽然多，但是却很杂乱，因此一开始走了不少弯路，现在把我的一点小小心得写出来，后来的
C# 利用 FFmpeg 借助 NVIDIA GPU 实现 RTSP 硬解码+硬编码录制 MP4 —— 深度解析
最新发布
java专栏
09-22 580
通过简单的几行 C# 代码，我们就实现了利用 NVIDIA GPU 对 RTSP 视频流进行硬解码和硬编码，最后还把它录制成 MP4 文件了！嘿，小伙伴们，今天我们来玩个大的！你是否梦想过用 C# 来控制强大的 NVIDIA GPU，实现 RTSP 流的硬解码和硬编码，最后把它录制成 MP4 文件？硬解码和硬编码利用 GPU 加速处理视频流，相比于纯 CPU 解码和编码，可以大大提高效率，尤其是在处理高清视频时。首先，确保你的电脑上安装了 NVIDIA 显卡，并且已经安装了最新的驱动程序。
FFmpeg解码H264及swscale缩放详解
固本培元的专栏
02-23 1万+
本文介绍著名开源音视频编解码库ffmpeg如何解码h264码流，比较详细阐述了其h264码流输入过程，解码原理，解码过程。同时，大部分应用环境下，以原始码流视频大小展示并不是最佳方式，因此，开发者不仅仅需要对视频流解码，并且需要缩放图像以展示于不同窗体下。 综上，本文除介绍ffmpeg解码h264，同时阐述如何使用swscale缩放视频流。 文章使用的开发环境Ubuntu12.04.。交流邮箱：leoluopy@gmail.com。转载请注明出处 CSDN--固
FFmpeg的H.264解码器源代码简单分析：解码器主干部分
雷霄骅(leixiaohua1020)的专栏
04-14 2万+
本文分析FFmpeg的H.264解码器的主干部分。“主干部分”是相对于“熵解码”、“宏块解码”、“环路滤波”这些细节部分而言的。它包含了H.264解码器直到decode_slice()前面的函数调用关系（decode_slice()后面就是H.264解码器的细节部分，主要包含了“熵解码”、“宏块解码”、“环路滤波”3个部分）。
ffmpeg解码h264文件，opencv显示
张利 的博客
11-19 3475
H264.h#include <stdio.h> #include <stdlib.h> #include <conio.h> #include <string.h> #include <winsock2.h>typedef struct { int startcodeprefix_len; //! 4 for parameter sets and first slice in p
vs2010 ffmpeg实时解码h264码流
01-30
在本文中，我们将深入探讨如何在Visual Studio 2010环境下使用C++实时解码H264视频码流。H264是一种高效、先进的视频编码标准，广泛应用于高清视频传输、在线流媒体服务等领域。FFmpeg是一个强大的开源多媒体处理...
X264对摄像头编码，FFmpeg实时解码 （测试用）
01-14
5. 使用FFmpeg解码器：加载H.264码流，解码成原始视频帧。 6. 显示或处理解码后的帧：这些帧可以显示在屏幕上，或者进一步处理，如存储、分析等。 通过这样的测试代码，开发者可以更好地理解X264编码和FFmpeg解码的...
FFmpeg硬解码H264工程demo资源
04-23
本资源“FFmpeg硬解码H264工程demo资源”显然是一个基于Nvidia GPU的硬解码示例，用于演示如何在FFmpeg中利用Nvidia的硬件加速能力解码H264编码的视频。 H264，全称High Efficiency Video Coding（高效视频编码），...
ffmpeg 实时解码DEMO 实时解码H.264码流
08-28
为了在命令行中使用FFmpeg解码H.264流，可以使用如下的基本命令： ```bash ffmpeg -i input.h264 -c:v copy output.yuv ``` 这条命令将输入的H.264码流(input.h264)解码并输出为YUV格式(output.yuv)，这里使用了...
简单的FFmpeg解码，OpenCV显示
04-23
很简单的FFmpeg解码数据，OpenCV界面显示数据
ffmpeg解码h264视频文件，并且实时显示（mfc）
07-26
用ffmpeg解码h264视频文件，并且将解码出来的每帧图像用opencv封装进行显示，ffmpeg采用的是最新的3-2版本。另外，程序预留了将每帧图像保存成bmp的接口，注释详细。使用时须配置好ffmpeg和opencv，然后将自己的h264文件名称修改为1.h264 并将其置于当前目录即可运行（可作为2次开发的参考）
C#H264格式视频解码
01-09
C#H264格式视频解码, 使用FFMPEG解码为H264视频文件,解码后的数据保存为.YUV,可以使用VLC等播放器播放。
【FFmpeg】调用ffmpeg进行H264软解
weixin_42877471的博客
05-06 2052
参考FFmpeg当中的/doc/examples当中的video_decode.c文件，进行调用过程的理解和实现
FFmpeg的H.264解码器源代码简单分析：宏块解码（Decode）部分-帧内宏块（Intra）
热门推荐
雷霄骅(leixiaohua1020)的专栏
04-20 3万+
本文分析FFmpeg的H.264解码器的宏块解码（Decode）部分的源代码。FFmpeg的H.264解码器调用decode_slice()函数完成了解码工作。这些解码工作可以大体上分为3个步骤：熵解码，宏块解码以及环路滤波。本文分析这3个步骤中的第2个步骤。由于宏块解码部分的内容比较多，因此将本部分内容拆分成两篇文章：一篇文章记录帧内预测宏块（Intra）的宏块解码，另一篇文章记录帧间预测宏块（
Opencv Mat-＞data编码成H264 利用ffmpeg实现
qq_37120714的博客
05-27 1537
默认Mat 中的像素数据是BGR24 ffpmeg编码时，需要YUV420P 注意编码时的一帧画面的宽高 main Encodeh264 codeh264_obj; codeh264_obj.init_encoder(AV_CODEC_ID_H264,CANVAS_WIDTH, CANVAS_HEIGHT, AV_PIX_FMT_BGR24, CANVAS_WIDTH, CANVAS_HEIGHT, AV_PIX_FMT_YUV420P); while (1) { if (m_con.
FFmpeg解码H264视频流
程序猿老樊的博客
03-29 2986
解码H264视频流数据,支持输出RGB24或YUV420格式,非解码视频文件； 代码如下： FFmpegVideoDecoder.h #include <libavcodec/avcodec.h> /** 视频流解码器初始化 @param ctx 解码参数结构体AVCodecParameters @see FFmpeg_H264DecoderInit，此为解码...
基于ffmpeg+opencv的h264解码显示功能的实现
Ant
05-14 7512
最近做的一个项目中需要对h264编码的视频文件进行解码并转换为openc可以处理的格式进行显示和相关的图像处理操作。从网上找了借鉴了很多资料，但做的相对来说比较简单。因此，在网上现有的代码基础上进行了整理和优化。目前在项目中集成，效果良好。特分享给有共同需求的朋友，如有可继续优化的空间，还望各位朋友能指出，我们共同学习与提高。 下面，贴出相关代码。 decode_video.h #ifnde...
ffmpeg硬解码H264
04-19
在FFmpeg中，硬解码H.264可以通过使用硬件加速来提高解码性能。具体而言，可以利用显卡的硬件解码器来进行H.264视频的解码，以减轻CPU的负担。 要使用FFmpeg进行H.264的硬解码，需要先检查系统是否支持硬件解码器。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值