ffmpeg+D3D实现的MFC音视频播放器，支持录像、截图、音视频播放、码流信息 ...

熊熊出没  金牌会员 | 2024-11-14 04:48:21 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 833|帖子 833|积分 2499

一、简介

    本播放器是在vs2019下开发，通过ffmpeg实现拉流解码功能，通过D3D实现视频的渲染功能。截图功能采用libjpeg实现，可以截取jpg图片，图片的默认保存路径是在C:\MYRecPath中。录像功能采用封装好的类Mp4Record实现，在Mp4Record类中主要还是采用ffmpeg的相关函数方法进行mp4视频的录制。音频的播放采用DirectSound实现，将ffmpeg解码后的音频数据存储到DirectSound的buffer中，再调用DirectSound的play实现对音频的播放功能。码流信息的表现，通过D3D的文本绘制实现。本播放器提供源码下载，直接下载请点击末了的下载链接。
二、界面展示


三、相关代码

开始播放
  1. int CVideoPlayer::StartPlay(const char* sUrl)
  2. {
  3.     m_bStop = false;
  4.     m_nVideoIndex = -1;
  5.     m_nAudioIndex = -1;
  6.     int i = 0, res = 0,  nValue = 0;
  7.     char buf[64] = { 0 };
  8.     m_bPlaying = false;
  9.     AVStream* in_stream;
  10.    
  12.     _snprintf_s(m_sConnectUrl, sizeof(m_sConnectUrl), sizeof(m_sConnectUrl) - 1, "%s", sUrl);
  14.     //av_register_all();
  15.     avformat_network_init();
  17.     AVDictionary* optionsDict = nullptr;
  19.     av_dict_set(&optionsDict, "rtsp_transport", "tcp", 0);
  20.     av_dict_set(&optionsDict, "stimeout", "5000000", 0);
  21.     av_dict_set(&optionsDict, "buffer_size", "8192000", 0);
  22.     av_dict_set(&optionsDict, "recv_buffer_size", "8192000", 0);
  24.     m_lastReadPacktTime = av_gettime();
  25.     m_pAVFmtCxt = avformat_alloc_context();
  26.     m_pAVFmtCxt->interrupt_callback.opaque = this;
  27.     m_pAVFmtCxt->interrupt_callback.callback = decodeInterruptCb;
  29.     res = avformat_open_input(&m_pAVFmtCxt, m_sConnectUrl, NULL, &optionsDict);
  30.     if (res < 0)
  31.     {
  32.         myprint("avformat_open_input fail: %d", res);
  33.         return -1;
  34.     }
  35.    
  36.     if (!m_pAVFmtCxt)
  37.     {
  38.         return -1;
  39.     }
  41.     m_pAVFmtCxt->probesize = 100 * 1024;   
  42.     m_pAVFmtCxt->max_analyze_duration = 1 * AV_TIME_BASE;
  44.     res = avformat_find_stream_info(m_pAVFmtCxt, NULL);
  45.     if (res < 0)
  46.     {
  47.         myprint("error %x in avformat_find_stream_info\n", res);
  48.         return -1;
  49.     }
  51.     av_dump_format(m_pAVFmtCxt, 0, m_sConnectUrl, 0);
  53.     for (i = 0; i < m_pAVFmtCxt->nb_streams; i++)
  54.     {
  55.         if (m_pAVFmtCxt->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
  56.         {
  57.             m_nVideoIndex = i;
  58.         }
  59.         else if (m_pAVFmtCxt->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
  60.             m_nAudioIndex = i;
  61.         }
  63.         myprint("m_pAVFmtCxt->streams[i]->codec->codec_type:%d", m_pAVFmtCxt->streams[i]->codecpar->codec_type);
  65.     }
  67.     //videoindex not find
  68.     if (m_nVideoIndex == -1)
  69.     {
  70.         myprint("can't find video stream.");
  71.         return -1;
  72.     }
  74.     m_pCodec = avcodec_find_decoder(m_pAVFmtCxt->streams[m_nVideoIndex]->codecpar->codec_id);
  75.     if (!m_pCodec)
  76.     {
  77.         myprint("video decoder not found\n");
  78.         return -1;
  79.     }
  80.     if (m_bSupportAudio && m_nAudioIndex != -1)
  81.     {
  82.         myprint("start audio decoder \n");
  84.         if (!m_pAudioCodecCxt)
  85.             m_pAudioCodecCxt = avcodec_alloc_context3(NULL);
  86.         auto pAudioCodecpar = m_pAVFmtCxt->streams[m_nAudioIndex]->codecpar;
  87.         avcodec_parameters_to_context(m_pAudioCodecCxt, pAudioCodecpar);
  89.         m_pAudioCodec = avcodec_find_decoder(pAudioCodecpar->codec_id);
  91.         if (nullptr == m_pAudioCodec || nullptr == m_pAudioCodecCxt)
  92.         {
  93.             myprint("audio decoder not found\n");
  94.             return -1;
  95.         }
  97.         m_pSwrContext = swr_alloc_set_opts(0,                                 
  98.             av_get_default_channel_layout(m_channels_play),
  99.             AV_SAMPLE_FMT_S16,                        
  100.             m_nSampleRate,                     
  101.             av_get_default_channel_layout(m_pAudioCodecCxt->channels),
  102.             m_pAudioCodecCxt->sample_fmt,      
  103.             m_pAudioCodecCxt->sample_rate,      
  104.             0,
  105.             0);
  106.         auto ret = swr_init(m_pSwrContext);
  107.         if (ret < 0)
  108.         {
  109.             myprint("Failed to swr_init(pSwrContext);");
  110.             return -1;
  111.         }
  113.         if (InitDirectSound() == FALSE)
  114.             m_bSupportAudio = false;
  115.     }
  117.     m_CodecId = m_pCodec->id;
  118.     if(!m_pCodecCxt)
  119.         m_pCodecCxt = avcodec_alloc_context3(NULL);
  120.     avcodec_parameters_to_context(m_pCodecCxt, m_pAVFmtCxt->streams[m_nVideoIndex]->codecpar);
  121.     if (m_pCodecCxt)
  122.     {
  123.         if (m_pCodecCxt->width == 0 || m_pCodecCxt->height == 0)
  124.         {
  125.             myprint("m_pCodecCxt->width:%d, m_pCodecCxt->height:%d", m_pCodecCxt->width, m_pCodecCxt->height);
  126.             return -1;
  127.         }
  128.     }
  129.     else
  130.         return -1;
  132.     AVCodecContext* temp_codecctx = m_pCodecCxt;
  133.     memcpy(temp_codecctx, m_pCodecCxt, sizeof(m_pCodecCxt));
  134.     if (m_pCodecCxt->codec_type == AVMEDIA_TYPE_VIDEO)
  135.     {
  136.         myprint("Soft Solution");
  137.         avcodec_close(m_pCodecCxt);
  138.         m_pCodecCxt = temp_codecctx;
  139.         m_pCodecCxt->thread_count = 4;
  140.         if (m_Dxva2D3DRender.InitD3DRender(m_showWnd, m_pCodecCxt->width, m_pCodecCxt->height) == false)
  141.         {
  142.             myprint("InitD3DRender fail");
  143.         }
  144.         m_pOutBuffer = (uint8_t*)av_malloc(av_image_get_buffer_size(AV_PIX_FMT_YUV420P, m_pCodecCxt->width, m_pCodecCxt->height, 1));
  145.         if (nullptr == m_pOutBuffer)
  146.             return -1;
  148.         av_image_fill_arrays(m_pFrameBGR->data, m_pFrameBGR->linesize, m_pOutBuffer, AV_PIX_FMT_YUV420P, m_pCodecCxt->width, m_pCodecCxt->height, 1); //填充AVFrame数据缓冲
  149.         m_pImgConvertCtx = sws_getContext(m_pCodecCxt->width, m_pCodecCxt->height, m_pCodecCxt->pix_fmt, m_pCodecCxt->width, m_pCodecCxt->height, AV_PIX_FMT_YUV420P, SWS_FAST_BILINEAR, NULL, NULL, NULL);
  150.         if (nullptr == m_pImgConvertCtx)
  151.             return -1;
  153.       
  154.         m_nActualWidth = m_pCodecCxt->width;
  155.         m_nActualHeight = m_pCodecCxt->height;
  157.         res = avcodec_open2(m_pCodecCxt, m_pCodec, NULL);
  158.         if (res < 0)
  159.         {
  160.             myprint("avcodec_open2 video fail  error:%x", res);
  161.             return -1;
  162.         }
  163.     }
  165.     if (m_bSupportAudio && m_pAudioCodecCxt)
  166.     {
  167.         if (m_pAudioCodecCxt->codec_type == AVMEDIA_TYPE_AUDIO)
  168.         {
  169.             res = avcodec_open2(m_pAudioCodecCxt, m_pAudioCodec, NULL);
  170.             if (res < 0)
  171.             {
  172.                 myprint("avcodec_open2 audio fail  error:%x", res);
  173.                 avcodec_close(m_pAudioCodecCxt);
  174.                 return -1;
  175.             }
  177.             myprint("===Audio Message===");
  178.             myprint(" bit_rate = %d ", m_pAudioCodecCxt->bit_rate);
  179.             myprint(" sample_rate = %d ", m_pAudioCodecCxt->sample_rate);
  180.             myprint(" channels = %d ", m_pAudioCodecCxt->channels);
  181.             myprint(" code_name = %s ", m_pAudioCodecCxt->codec->name);
  182.             myprint(" block_align = %d ", m_pAudioCodecCxt->block_align);
  183.         }
  184.     }
  186.     m_pDecodeThread = (my_thread_t*)my_malloc(sizeof(my_thread_t));
  187.     if (nullptr != m_pDecodeThread)
  188.     {
  189.         m_bDecodeThreadRun = true;
  190.         res = my_thread_create(m_pDecodeThread, ThreadDecode, this);
  191.         if (res == -1)
  192.         {
  193.             myprint("my_thread_create ThreadDecode failed  res:%x", res);
  194.             return -1;
  195.         }
  196.     }
  198.     return 0;
  199. }
复制代码
停止播放
  1. void CVideoPlayer::StopPlay()
  2. {
  3.     m_bPlaying = false;
  4.     m_CaptureAudio.SetGrabAudioFrames(FALSE, NULL);
  5.     m_CaptureAudio.Close();
  7.     m_bStopAudio = true;
  8.     while (!m_AudioPlayQue.empty())
  9.     {
  10.         m_AudioPlayQue.pop();
  11.     }
  12.     while (!m_AudioTalkQue.empty())
  13.     {
  14.         EnterCriticalSection(&m_talklock);
  15.         m_AudioTalkQue.pop();
  16.         LeaveCriticalSection(&m_talklock);
  17.     }
  19.     m_bDecodeThreadRun = false;
  21.     if (m_pDecodeThread)
  22.     {
  23.         my_thread_join(m_pDecodeThread);
  24.         my_free(m_pDecodeThread);
  25.         m_pDecodeThread = nullptr;
  26.     }
  28.     if (m_pAudioPlayThread) {
  29.         SetEvent(m_event);
  30.         if (m_pAudioPlayThread->handle) {
  31.             my_thread_join(m_pAudioPlayThread);
  32.             m_pAudioPlayThread->handle = nullptr;
  33.         }
  34.     }
  36.     if (m_pDSBuffer8)
  37.     {
  38.         m_pDSBuffer8->Stop();
  39.         m_pDSBuffer8->Restore();
  40.     }
  42.     m_Dxva2D3DRender.UnitD3DRender();
  44.     if (m_pCodecCxt)
  45.     {
  46.         avcodec_close(m_pCodecCxt);
  47.     }
  49.     if (m_pAudioCodecCxt)
  50.     {
  51.         avcodec_close(m_pAudioCodecCxt);
  52.     }
  54.     if (m_pSwrContext)
  55.     {
  56.         swr_free(&m_pSwrContext);
  57.         m_pSwrContext = nullptr;
  58.     }
  60.     if (m_pAVFmtCxt) {
  61.         avformat_close_input(&m_pAVFmtCxt);
  62.         avformat_free_context(m_pAVFmtCxt);
  63.         m_pAVFmtCxt = nullptr;
  64.     }
  66. }
复制代码
解码线程
  1. void CVideoPlayer::DecodeAndShow()
  2. {
  3.     if (m_pAVFmtCxt == nullptr || m_pCodecCxt == nullptr)
  4.         return;
  6.     AVPacket pkt = { 0 };
  7.     m_bPlaying = true;
  8.     uint8_t* pBuffer;
  9.     bool bEnoughSpace = true;
  10.     int nTimeCnt = 0;
  11.     int res = 0;
  12.     struct SwsContext* img_convert_ctx = nullptr;
  13.     int nRectDrawWait = 0;
  14.     bool bRecordLastIFrame = false;
  15.     int num_av_read_frame_err = 0;
  16.     int num_stream_index_err = 0;
  17.     uint8_t * outData[2] = {0};
  18.     outData[0] = (uint8_t*)av_malloc(1152 * 8);
  19.     outData[1] = (uint8_t*)av_malloc(1152 * 8);
  21.     uint8_t* pktdata;
  22.     int pktsize;
  23.     int len = 0;
  24.     bool bPushAudioToQueue = false;
  25.     m_bStopAudio = false;
  26.     CRect ShowRect;
  28.     AVFrame* pAvFrame = av_frame_alloc();
  29.     if (nullptr == pAvFrame)
  30.         return;
  32.     AVFrame* pFrameRGB = av_frame_alloc();
  33.     if (nullptr == pFrameRGB)
  34.         return;
  36.     int numBytes = av_image_get_buffer_size(AV_PIX_FMT_RGB24, m_pCodecCxt->width, m_pCodecCxt->height, 1);
  37.     pBuffer = (uint8_t*)av_malloc(numBytes);
  38.     if (nullptr == pBuffer)
  39.         return;
  41.     av_image_fill_arrays(pFrameRGB->data,pFrameRGB->linesize, pBuffer, AV_PIX_FMT_RGB24, m_pCodecCxt->width, m_pCodecCxt->height, 1);
  42.     img_convert_ctx = sws_getCachedContext(img_convert_ctx, m_pCodecCxt->width, m_pCodecCxt->height,
  43.         m_pCodecCxt->pix_fmt, m_pCodecCxt->width, m_pCodecCxt->height, AV_PIX_FMT_RGB24, SWS_FAST_BILINEAR/*SWS_BICUBIC*/, NULL, NULL, NULL);
  46.     //Audio
  47.     if (m_bSupportAudio && m_pAudioPlayThread)
  48.     {
  49.         res = my_thread_create(m_pAudioPlayThread, ThreadAudioPlay, this);
  50.         if (res < 0)
  51.             myprint("my_thread_create ThreadAudioPlay fail");
  52.     }
  54.     while (m_bDecodeThreadRun && !m_bQuit)
  55.     {
  56.         if (m_bPause)
  57.         {
  58.             Sleep(100);
  59.             continue;
  60.         }
  62.         {
  63.             if (m_bReconnect)
  64.             {
  65.                 myprint("bReConnect = true, break");
  66.                 break;
  67.             }
  68.         }
  70.         m_lastReadPacktTime = av_gettime();
  71.         if (av_read_frame(m_pAVFmtCxt, &pkt) >= 0)
  72.         {
  73.             num_av_read_frame_err = 0;
  75.             if (pkt.stream_index == m_nVideoIndex || pkt.stream_index == m_nAudioIndex)
  76.             {
  77.                 if (m_bRecord)//Record
  78.                 {
  79.                     if (nTimeCnt != 0 || (!bRecordLastIFrame && pkt.flags == AV_PKT_FLAG_KEY)) {
  80.                         if (m_sRecPath[0] != '\0' && nTimeCnt++ % 200 == 0)
  81.                         {
  82.                             bEnoughSpace = CheckRemainSpace(m_sRecPath);
  83.                             if (bEnoughSpace == true)
  84.                             {
  85.                                 myprint("bEnoughSpace = true");
  86.                             }
  87.                             else
  88.                                 myprint("bEnoughSpace = false");
  89.                         }
  91.                         m_nRecordCurrentTime = time(NULL);
  92.                         if ((m_nRecordCurrentTime - m_nRecordStartTime) >= (m_nRecordTime * 60))
  93.                         {
  94.                             myprint("Record Finsh!");
  95.                             stopRecord();
  96.                         }
  97.                         else if (bEnoughSpace == false)
  98.                         {
  99.                             myprint("bEnoughSpace == false");
  100.                             stopRecord();
  101.                         }
  102.                         else
  103.                         {
  104.                             AVPacket* pPkt = av_packet_clone(&pkt);
  105.                             m_mp4Recorder.saveOneFrame(*pPkt, m_CodecId);
  106.                             av_packet_free(&pPkt);
  107.                         }
  108.                     }
  109.                     bRecordLastIFrame = pkt.flags == AV_PKT_FLAG_KEY;
  110.                 }
  111.                 else
  112.                     nTimeCnt = 0;
  113.             }
  115.             
  116.             if (pkt.stream_index == m_nVideoIndex)
  117.             {
  118.                 num_stream_index_err = 0;
  119.                 nTimeCnt = 0;
  121.                 if (pkt.flags == 1)
  122.                     bPushAudioToQueue = true;
  123.                 if (nullptr == m_pCodecCxt || nullptr == pAvFrame) {
  124.                     myprint("m_pCodecCxt == NULL || pAvFrame == NULL");
  125.                     break;
  126.                 }
  127.                 int gotvframe = 0;
  128.                 auto sd_ret = avcodec_send_packet(m_pCodecCxt, &pkt);
  129.                 if (sd_ret != 0 && sd_ret != AVERROR(EAGAIN)) {
  130.                     myprint("avcodec_send_packet err, rt=%d", sd_ret);
  131.                     enableReConnect();
  132.                 }
  133.                 else {
  134.                     while (gotvframe == 0 && !m_bQuit) {
  135.                         gotvframe = avcodec_receive_frame(m_pCodecCxt, pAvFrame);
  136.                         if (gotvframe == 0)
  137.                         {
  138.                             try
  139.                             {
  140.                                 GetShowRectSize(&ShowRect);
  141.                             }
  142.                             catch (const std::exception&)
  143.                             {
  144.                                 myprint("GetClientRect throw, error");
  145.                                 break;
  146.                             }
  148.                             m_nCurPKSize = pkt.size;   
  149.                             SetStreamInfoToD3d();
  151.                             if (pAvFrame->width != m_nActualWidth || pAvFrame->height != m_nActualHeight)
  152.                             {
  153.                                 myprint("video size change reconnect...");
  154.                                 enableReConnect();
  155.                                 m_nActualWidth = pAvFrame->width;
  156.                                 m_nActualHeight = pAvFrame->height;
  157.                                 av_packet_unref(&pkt);
  158.                                 continue;
  159.                             }
  161.                             if (m_pImgConvertCtx && m_pFrameBGR && m_pOutBuffer && pAvFrame)
  162.                             {
  163.                                 sws_scale(m_pImgConvertCtx, (const uint8_t* const*)pAvFrame->data, pAvFrame->linesize, 0,
  164.                                     m_pCodecCxt->height, m_pFrameBGR->data, m_pFrameBGR->linesize);
  166.                                 {                                    
  167.                                     try
  168.                                     {
  169.                                         int re = 5;
  170.                                         for (int i = 0; m_bPlaying && re == 5 && i < 10; ++i) {     // LockRect失败时重复尝试，最多10次
  171.                                             re = m_Dxva2D3DRender.D3DSoftDisplayFrame(m_pOutBuffer, pAvFrame->width, pAvFrame->height, ShowRect);
  172.                                             Sleep(1);
  173.                                         }
  174.                                     }
  175.                                     catch (int re)
  176.                                     {
  177.                                         myprint("m_Dxva2D3DRender.InitD3DRender again");
  178.                                         if (m_Dxva2D3DRender.InitD3DRender(m_showWnd, m_pCodecCxt->width, m_pCodecCxt->height) == false)
  179.                                         {
  180.                                             myprint("m_Dxva2D3DRender.InitD3DRender again fail");
  181.                                             av_packet_unref(&pkt);
  182.                                             continue;
  183.                                         }
  184.                                     }
  185.                                 }                                
  186.                             }
  187.                             if (m_bCapture /*&& pkt.flags == 1*/ && img_convert_ctx)
  188.                             {
  189.                                 sws_scale(img_convert_ctx, (const uint8_t* const*)pAvFrame->data,
  190.                                          pAvFrame->linesize, 0, m_pCodecCxt->height,
  191.                                     pFrameRGB->data, pFrameRGB->linesize);
  192.                                 SaveIFrameImage(pFrameRGB->data[0], m_pCodecCxt->width, m_pCodecCxt->height);
  193.                                 m_bCapture = false;
  194.                             }
  195.                            
  196.                         }
  197.                     }
  198.                 }
  199.             }
  200.             else if (pkt.stream_index == m_nAudioIndex)
  201.             {
  202.                 num_stream_index_err = 0;
  203.                 if (m_bSupportAudio) {
  204.                     pktdata = pkt.data;
  205.                     pktsize = pkt.size;
  207.                     if (pktsize > 0)
  208.                     {
  209.                         int gotframe = 0;
  210.                         if (nullptr == m_pAudioCodecCxt || nullptr == pAvFrame) {
  211.                             myprint("m_pAudioCodecCxt == NULL || pAvFrame == NULL");
  212.                             break;
  213.                         }
  214.                         len = avcodec_send_packet(m_pAudioCodecCxt, &pkt);
  215.                         if (len != 0 && len != AVERROR(EAGAIN))
  216.                         {
  217.                             pktsize = 0;
  218.                             myprint("avcodec_send_packet len < 0");
  219.                             break;
  220.                         }
  221.                         auto data_size = av_get_bytes_per_sample(m_pAudioCodecCxt->sample_fmt);
  222.                         if (data_size < 0) {
  223.                             myprint("Failed to calculate data size\n");
  224.                             break;
  225.                         }
  226.                         while (gotframe == 0 && !m_bQuit) {
  227.                             gotframe = avcodec_receive_frame(m_pAudioCodecCxt, pAvFrame);
  228.                             if (!gotframe)
  229.                             {
  231.                                 if (bPushAudioToQueue == true && m_bEnableAudio && !m_bStopAudio)
  232.                                 {
  233.                                     audio_frame_t audioFrame;
  234.                                     numBytes = av_get_bytes_per_sample(AV_SAMPLE_FMT_S16);
  235.                                     auto dstNbSamples = av_rescale_rnd(pAvFrame->nb_samples,
  236.                                         m_src_sample_rate,
  237.                                         pAvFrame->sample_rate,
  238.                                         AV_ROUND_ZERO);
  239.                                       
  240.                                     int data_size = 0;
  241.                                     try
  242.                                     {
  243.                                         auto nb = swr_convert(m_pSwrContext,
  244.                                             (uint8_t**)outData,
  245.                                             dstNbSamples,
  246.                                             (const uint8_t**)pAvFrame->data,
  247.                                             pAvFrame->nb_samples);
  248.                                         data_size = av_samples_get_buffer_size(nullptr, m_channels_play, nb, AV_SAMPLE_FMT_S16, 1);
  249.                                     }
  250.                                     catch (const std::exception&)
  251.                                     {
  252.                                         m_bSupportAudio = false;
  253.                                         myprint("swr_convert throw err, set m_bSupportAudio false");
  254.                                         continue;
  255.                                     }
  256.                                     
  257.                                     int copy_size = 0;
  258.                                     int copy_ptr = 0;                              
  259.                                     for (int isub = data_size; isub > 0; isub -= copy_size) {
  260.                                         if (isub > m_audio_buffer_notify_size) {
  261.                                             copy_size = m_audio_buffer_notify_size;
  262.                                             copy_ptr = data_size - isub;
  263.                                         }
  264.                                         else
  265.                                             copy_size = isub;
  266.                                         audioFrame.data_size = copy_size;
  267.                                         memcpy(audioFrame.data, outData[0] + copy_ptr, copy_size);
  268.                                         EnterCriticalSection(&m_lock);
  269.                                         m_AudioPlayQue.push(audioFrame);
  270.                                         LeaveCriticalSection(&m_lock);
  271.                                     }
  272.                                 }
  274.                             }
  275.                         }
  276.                     }
  277.                 }
  278.             }
  279.             else if (++num_stream_index_err > 20) {
  280.                 myprint("pkt.stream_index unfind, %d",pkt.stream_index);
  281.                 enableReConnect();
  282.             }
  284.             av_packet_unref(&pkt);
  285.         }
  286.         else {
  287.             if (++num_av_read_frame_err > 10) {
  288.                 myprint("num_av_read_frame_err is more than 10");
  289.                 enableReConnect();
  290.             }
  291.         }
  292.     }
  293.     if (m_bDecodeThreadRun) {
  294.         myprint("m_bDecodeThreadRun is true");
  295.         enableReConnect();
  296.     }
  298.     if (pAvFrame)
  299.         av_free(pAvFrame);
  301.     if (pFrameRGB)
  302.         av_free(pFrameRGB);
  304.     if (pBuffer)
  305.         av_free(pBuffer);
  307.     if (img_convert_ctx)
  308.         sws_freeContext(img_convert_ctx);
  310.     if (outData[0] && outData[1])
  311.     {
  312.         av_free(outData[0]);
  313.         av_free(outData[1]);
  314.         outData[0] = 0;
  315.         outData[1] = 0;
  316.     }
  317. }
复制代码
四、相关下载

链接: 可实行步伐下载
链接: 源码下载

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

熊熊出没

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

挺好的 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表