首页 > 其他 > 详细

ffmpeg 最简单的视频播放

时间：2014-10-30 13:20:41      阅读：335      评论：0      收藏：0      [点我收藏+]
   网上有很多关于ffmpeg的视频播放版本，但是都相对比较老，而且同步方式很繁琐，效果也不一定是最好，本人自己重现配合SDL实现了一个播放器，仅供参考，实现音视频同步功能。
  先来说下音视频同步：其实并不像网上那些教程说的那么复杂。
  原理是这样的：
  所有文件在出现前其实都是经历了压片操作，就是编码的工作，而在编码的时候，其实video和audio的每一帧都打上了一个叫时间戳的东西，而这个东西的数值你可能会比较奇怪，从ffmpeg中的packet包中可以看到一包video数据中的一帧数据的时间戳是很长的一个数字，你不用对这个有过多的想法它其实就是一个用来记录音频和视频之间有差距的一个标志，比如一帧视频时234545566，音频是123214124，那很明显就是在播放的时候，如果你手上有这两帧的数据， 那你就不能一起将他们送去SDL渲染，而是先播放audio的， 然后video要等上234545566-123214124的时间才可以。
  看吧，很简单，这就是音视频同步的方法和概念。
  好 上代码，其实ffmpeg已经将文件里面的时间戳都解出来放在了每个packet中，可以直接从这里获取，当然，也可以自己通过视频的帧率和audio的帧率自己来计算并从视频起始时间开始叠加计算，但个人认为没这个必要，ffmpeg提供的pts都是比较准确的。
  video的帧率公式： 1/FPS  (FPS=帧率 , 每秒多少帧数据)
  audio的持续时间公式：  其实这里有个问题，播放音频是一个采样一个采样播放的，然而解码出的frame中的采样个数却不是一个，每种格式都有固定的采样数，比如aac=1024，mp3=1152 其实这个不用去记住， 
ffmpeg会根据文件解析的时候就判断出这个数值，直接从AVCodecCtx的frame_size中获取即可。  比如aac： 1024*1.0/44100
通过上面的两个东西不停的一帧一帧的叠加就能算出每帧数据的PTS了。
   

    这个事player的累，主要播放同步功能都在其中   

点击(此处)折叠或打开

  1. player::player():m_pVC(new VideoContext())
  2. {
  3. }

  5. player::~player()
  6. {

  8. }

  10. void player::play()
  11. {

  13. }

  15. void player::pause()
  16. {

  18. }

  20. void player::loadLocalFile(std::string filename)
  21. {
  22.     m_localFileName = filename;
  23.     init();
  24. }

  26. void player::loadStreamingFile()
  27. {

  29. }

  31. bool player::init()
  32. {
  33.     av_register_all();
  34.     SDL_Init(SDL_INIT_EVERYTHING);
  35.     printf("%s\n",m_localFileName.c_str());
  36.     if(avformat_open_input(&(m_pVC->pFormatCtx),m_localFileName.c_str(),NULL,NULL) < 0)
  37.     {
  38.         printf("open input file Error\n");
  39.         return false;
  40.     }
  41.     
  42.     if (avformat_find_stream_info(m_pVC->pFormatCtx, NULL) < 0)
  43.     {
  44.         printf("Could not find stream information\n");
  45.     }
  46.     av_dump_format(m_pVC->pFormatCtx, 0, m_localFileName.c_str(), 0);

  48.     m_pVC->nbStreams = m_pVC->pFormatCtx->nb_streams;
  49.     m_pVC->streams = new AVStream*[m_pVC->nbStreams];
  50.     for(int i = 0;i < m_pVC->nbStreams;i++)
  51.     {
  52.         m_pVC->streams[i] = m_pVC->pFormatCtx->streams[i];
  53.     }

  55.     //默认情况下之取第一个audio和video作为播放源
  56.     if(DEFAULT_AUDIO_AND_VIDEO)
  57.     {    
  58.         for(int i=0; i < m_pVC->nbStreams; i++)
  59.         {
  60.             if(m_pVC->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO)
  61.             {
  62.                 if(m_pVC->pVideoCodecCtx == NULL)
  63.                 {
  64.                     m_pVC->pVideoCodecCtx = m_pVC->streams[i]->codec;
  65.                     m_pVC->videoindex = i;
  66.                 }
  67.             }
  68.             else if(m_pVC->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO)
  69.             {
  70.                 if(m_pVC->pAudioCodecCtx == NULL)
  71.                 {
  72.                     m_pVC->pAudioCodecCtx = m_pVC->streams[i]->codec;
  73.                     m_pVC->audioindex = i;
  74.                 }
  75.             }
  76.             else if(m_pVC->streams[i]->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
  77.             {
  78.                 if(m_pVC->pSubCodecCtx == NULL)
  79.                 {
  80.                     m_pVC->pSubCodecCtx = m_pVC->streams[i]->codec;
  81.                     m_pVC->subindex = i;
  82.                 }
  83.             }
  84.         }
  85.     }
  86.     else
  87.     {

  89.     }
  90.     m_pVC->nbChannels = m_pVC->pAudioCodecCtx->channels;
  91.     m_pVC->audioCodecID = m_pVC->pAudioCodecCtx->codec_id;
  92.     m_pVC->videoCodecID = m_pVC->pVideoCodecCtx->codec_id;

  94.     m_pVC->pVideoDec = avcodec_find_decoder(m_pVC->videoCodecID);
  95.     if(m_pVC->pVideoDec == NULL)
  96.     {
  97.         printf("Can‘t find video dec\n");
  98.         return false;
  99.     }
  100.     if(avcodec_open2(m_pVC->pVideoCodecCtx,m_pVC->pVideoDec,NULL) < 0)
  101.     {
  102.         return false; // Could not open codec
  103.     }
  104.     m_pVC->pAudioDec = avcodec_find_decoder(m_pVC->audioCodecID);
  105.     if(m_pVC->pAudioDec == NULL)
  106.     {
  107.         printf("Can‘t find video dec\n");
  108.         return false;
  109.     }
  110.     if(avcodec_open2(m_pVC->pAudioCodecCtx,m_pVC->pAudioDec,NULL) < 0)
  111.     {
  112.         return false; // Could not open codec
  113.     }

  115.     initVideoDevice(m_pVC);
  116.     initAudioDevice(m_pVC);
  117.     
  118.     m_pVC->pVideoListMutex = SDL_CreateMutex();
  119.     m_pVC->pAudioListMutex = SDL_CreateMutex();
  120.     m_pVC->pSubListMutex = SDL_CreateMutex();
  121.     m_pVC->videoclockMutex = SDL_CreateMutex();
  122.     m_pVC->audioclockMutex = SDL_CreateMutex();
  123.     m_pVC->pVideoListCond = SDL_CreateCond();
  124.     m_pVC->pAudioListCond = SDL_CreateCond();
  125.     m_pVC->pSubListCond = SDL_CreateCond();

  127. }

  129. bool player::initVideoDevice(shared_ptr<VideoContext> pVC)
  130. {
  131.     pVC->videoClockTime = pVC->pFormatCtx->streams[pVC->videoindex]->start_time;
  132.     int flags = SDL_HWSURFACE | SDL_ASYNCBLIT | SDL_HWACCEL;
  133.     flags |= SDL_RESIZABLE;
  134.     pVC->pScrren = SDL_SetVideoMode(pVC->pVideoCodecCtx->width, pVC->pVideoCodecCtx->height, 0, flags);
  135.     if (!pVC->pScrren)
  136.     {
  137.         printf("SDL: could not set video mode - exiting\n");
  138.         return false;
  139.     }
  140.     //AVRational frame_rate = av_guess_frame_rate(pVC->pFormatCtx, pVC->pFormatCtx->streams[pVC->videoindex], NULL);
  141.     //pVC->videoDuration = av_q2d(pVC->pFormatCtx->streams[pVC->videoindex]->r_frame_rate)*av_q2d(pVC->pVideoCodecCtx->time_base);
  142.     SDL_WM_SetCaption("MAOYIKAI PLAYER ^_^", NULL);
  143.     if(!pVC->pBmp)
  144.     {
  145.         SDL_FreeYUVOverlay(pVC->pBmp);
  146.     }
  147.     pVC->pBmp = SDL_CreateYUVOverlay(pVC->pVideoCodecCtx->width,
  148.                                         pVC->pVideoCodecCtx->height,
  149.                                         SDL_IYUV_OVERLAY,
  150.                                         pVC->pScrren);
  151. }

  153. bool player::initAudioDevice(shared_ptr<VideoContext> pVC)
  154. {
  155.     pVC->audioClockTime = pVC->pFormatCtx->streams[pVC->audioindex]->start_time;
  156.     //pVC->audioDuration = 1024.0/pVC->pAudioCodecCtx->sample_rate;
  157.     //pVC->audioDuration = av_q2d(pVC->pFormatCtx->streams[pVC->audioindex]->r_frame_rate)*av_q2d(pVC->pFormatCtx->streams[pVC->audioindex]->time_base);
  158.     SDL_AudioSpec wantspec,spec;
  159.     int m_dwBitsPerSample = 0;
  160.     switch(pVC->pAudioCodecCtx->sample_fmt)
  161.     {
  162.     case AV_SAMPLE_FMT_U8:
  163.         {
  164.             m_dwBitsPerSample = 8;
  165.         }break;
  166.     case AV_SAMPLE_FMT_S16:
  167.         {
  168.             m_dwBitsPerSample = 16;
  169.         }break;
  170.     case AV_SAMPLE_FMT_S32:
  171.         {
  172.             m_dwBitsPerSample = 32;
  173.         }break;
  174.     case AV_SAMPLE_FMT_FLTP:
  175.         {
  176.             m_dwBitsPerSample = 32;
  177.         }break;
  178.     default:
  179.         {
  180.             m_dwBitsPerSample = 0;
  181.         }break;
  182.     }
  183.     wantspec.freq = pVC->pAudioCodecCtx->sample_rate;
  184.     switch(m_dwBitsPerSample)
  185.     {
  186.     case 8:
  187.         wantspec.format = AUDIO_S8;
  188.         break;
  189.     case 16:
  190.         wantspec.format = AUDIO_S16SYS;
  191.         break;
  192.     default:
  193.         wantspec.format = AUDIO_S16SYS;
  194.         break;
  195.     }
  196.     wantspec.channels = pVC->nbChannels;
  197.     wantspec.silence = 0;
  198.     wantspec.samples = pVC->pAudioCodecCtx->frame_size;
  199.     wantspec.callback = fill_audio;
  200.     wantspec.userdata = &(*pVC);

  202.     if(SDL_OpenAudio(&wantspec, &spec) < 0)
  203.     {
  204.         fprintf(stderr, "SDL_OpenAudio: %s\n", SDL_GetError());
  205.         return false;
  206.     }

  208.     if (spec.format != AUDIO_S16SYS)
  209.     {
  210.         fprintf(stderr, "SDL advised audio format %d is not supported!\n", spec.format);
  211.         return false;
  212.     }
  213.     pVC->pAu_covert = swr_alloc_set_opts(NULL,AV_CH_LAYOUT_STEREO,AV_SAMPLE_FMT_S16,pVC->pAudioCodecCtx->sample_rate,pVC->pAudioCodecCtx->channel_layout,
  214.                                         pVC->pAudioCodecCtx->sample_fmt,pVC->pAudioCodecCtx->sample_rate,0,NULL);
  215.     swr_init(pVC->pAu_covert);
  216.     pVC->out_buffer_size=av_samples_get_buffer_size(NULL,pVC->pAudioCodecCtx->channels ,pVC->pAudioCodecCtx->frame_size,*(pVC->pAudioDec->sample_fmts), 1);
  217.     pVC->out_buffer=(uint8_t *)av_malloc(pVC->out_buffer_size);
  218.     memset(pVC->out_buffer,0,pVC->out_buffer_size);
  219.     SDL_PauseAudio(0);
  220.     return true;
  221. }

  223. void player::fill_audio(void* user_data,Uint8* stream,int len)
  224. {
  225.     VideoContext* pVc = (VideoContext*)user_data;
  226.     SDL_LockMutex(pVc->pAudioListMutex);
  227.     if(pVc->audioList.empty())
  228.     {
  229.         if(pVc->frameEof == 1)
  230.         {
  231.             printf("audio is play over\n");
  232.             SDL_UnlockMutex(pVc->pAudioListMutex);
  233.             
  234.             if(pVc->videoList.empty())
  235.             {
  236.                 SDL_Event evt;
  237.                 evt.type = SDL_QUIT;
  238.                 SDL_PushEvent(&evt);
  239.             }
  240.             SDL_CloseAudio();
  241.             return ;
  242.         }
  243.         SDL_UnlockMutex(pVc->pAudioListMutex);
  244.         SDL_CondWait(pVc->pAudioListCond,NULL);
  245.         SDL_LockMutex(pVc->pAudioListMutex);
  246.     }
  247.     AVPacket *tmppkt = pVc->audioList.front();
  248.     if(!tmppkt)
  249.     {
  250.         printf("not include availble audio data\n");
  251.         return ;
  252.     }
  253.     SDL_UnlockMutex(pVc->pAudioListMutex);
  254.     AVFrame* pFrame = NULL;
  255.     int got_picture = 0,ret = 0;
  256.     pFrame=avcodec_alloc_frame();
  257.     ret = avcodec_decode_audio4( pVc->pAudioCodecCtx, pFrame,&got_picture, tmppkt);
  258.     if(ret < 0)
  259.     {
  260.         printf("Error in decoding audio frame.\n");
  261.         return ;
  262.     }
  263.     printf("-------audio clock time is %f\n",pVc->audioClockTime);
  264.     if(got_picture > 0)
  265.     {
  266.         //pVc->audioClockTime = tmppkt->pts * av_q2d(pVc->pFormatCtx->streams[pVc->audioindex]->time_base);
  267.         pVc->audioClockTime += pVc->pAudioCodecCtx->frame_size*1.0/pVc->pAudioCodecCtx->sample_rate; //tmppkt->duration*av_q2d(pVc->pFormatCtx->streams[pVc->audioindex]->time_base);
  268.         swr_convert(pVc->pAu_covert,&(pVc->out_buffer), pVc->out_buffer_size,(const uint8_t **)pFrame->data , pFrame->nb_samples);
  269.     }
  270.     else
  271.     {
  272.         memset(pVc->out_buffer,0,pVc->out_buffer_size);
  273.         SDL_LockMutex(pVc->pAudioListMutex);
  274.         pVc->audioList.pop_front();
  275.         SDL_UnlockMutex(pVc->pAudioListMutex);
  276.         return ;
  277.     }

  279.     memcpy(stream, (uint8_t*)(pVc->out_buffer),len);
  280.     memset(pVc->out_buffer,0,pVc->out_buffer_size);

  282.     SDL_LockMutex(pVc->pAudioListMutex);
  283.     pVc->audioList.pop_front();
  284.     SDL_UnlockMutex(pVc->pAudioListMutex);
  285.     av_free_packet(tmppkt);
  286.     avcodec_free_frame(&pFrame);

  288. }

  290. int player::readVideo(void* user_data)
  291. {    
  292.     VideoContext* pVc = (VideoContext*)user_data;
  293.     AVFrame * pFrame = NULL;
  294.     pFrame = avcodec_alloc_frame();
  295.     pVc->pDecodeVideoFrame = pFrame;
  296.     int frameFinished = 0,ret = 0;
  297.     while(1)
  298.     {
  299.         SDL_LockMutex(pVc->pVideoListMutex);
  300.         if(pVc->videoList.empty())
  301.         {
  302.             if(pVc->frameEof == 1)
  303.             {
  304.                 printf("video is play over\n");
  305.                 SDL_UnlockMutex(pVc->pVideoListMutex);
  306.                 return 0;
  307.             }
  308.             SDL_UnlockMutex(pVc->pVideoListMutex);
  309.             SDL_CondWait(pVc->pVideoListCond,NULL);
  310.             SDL_LockMutex(pVc->pVideoListMutex);
  311.         }
  312.         AVPacket *tmppkt = pVc->videoList.front();
  313.         if(!tmppkt)
  314.         {
  315.             printf("can‘t get packet data of video\n");
  316.             return 0;
  317.         }
  318.         SDL_UnlockMutex(pVc->pVideoListMutex);
  319.         ret = avcodec_decode_video2(pVc->pVideoCodecCtx, pFrame, &frameFinished,tmppkt);
  320.         if(ret < 0)
  321.         {
  322.             continue;
  323.         }
  324.     
  325.         printf("++++++++video clock time is %f\n",pVc->videoClockTime);

  327.          if(frameFinished)
  328.         {    
  329.             //pVc->videoClockTime = tmppkt->pts * av_q2d(pVc->pFormatCtx->streams[pVc->videoindex]->time_base);
  330.             pVc->videoClockTime += 1.0/av_q2d(pVc->pFormatCtx->streams[pVc->videoindex]->r_frame_rate);//tmppkt->duration * av_q2d(pVc->pFormatCtx->streams[pVc->videoindex]->time_base);
  331.             AVFrame * pOutputFrame = NULL;
  332.             struct SwsContext * img_convert_ctx;
  333.             pOutputFrame = avcodec_alloc_frame();

  335.             SDL_LockYUVOverlay(pVc->pBmp);

  337.             pOutputFrame->data[0] = pVc->pBmp->pixels[0];
  338.             pOutputFrame->data[1] = pVc->pBmp->pixels[1];
  339.             pOutputFrame->data[2] = pVc->pBmp->pixels[2];

  341.             pOutputFrame->linesize[0] = pVc->pBmp->pitches[0];
  342.             pOutputFrame->linesize[1] = pVc->pBmp->pitches[1];
  343.             pOutputFrame->linesize[2] = pVc->pBmp->pitches[2];

  345.             img_convert_ctx = sws_getContext(pFrame->width,pFrame->height, pVc->pFormatCtx->streams[pVc->videoindex]->codec->pix_fmt,
  346.                 pVc->pVideoCodecCtx->width,pVc->pVideoCodecCtx->height,AV_PIX_FMT_YUV420P,SWS_BICUBIC, NULL,NULL,NULL);
  347.             if(img_convert_ctx == NULL)
  348.             {
  349.                 fprintf(stderr, "Cannot initialize the conversion context!\n");
  350.                 getchar();
  351.             }
  352.             // 将图片转换为RGB格式
  353.             sws_scale(img_convert_ctx,pFrame->data,pFrame->linesize,0,
  354.                 pFrame->height,pOutputFrame->data,pOutputFrame->linesize);
  355.         
  356.             SDL_UnlockYUVOverlay(pVc->pBmp);

  358.             double time = 0;
  359.             if((pVc->videoClockTime - pVc->audioClockTime)*1000 > 0)
  360.             {
  361.                 time = (pVc->videoClockTime - pVc->audioClockTime)*1000;
  362.             }
  363.             else if((pVc->videoClockTime - pVc->audioClockTime)*1000 <= 0)
  364.             {
  365.                 time = 0;
  366.             }        
  367.             Sleep(time);
  368.             SDL_AddTimer(0,showVideo,&(*pVc));
  369.             avcodec_free_frame(&pOutputFrame);
  370.         }
  371.         else
  372.         {
  373.             printf("can‘t decode frame , lost frame\n");
  374.             pVc->videoClockTime += 1.0/av_q2d(pVc->pFormatCtx->streams[pVc->videoindex]->r_frame_rate);
  375.             //pVc->videoClockTime += tmppkt->duration*av_q2d(pVc->pFormatCtx->streams[pVc->videoindex]->time_base);//pVc->videoDuration;
  376.         }
  377.         av_free_packet(tmppkt);
  378.         //avcodec_free_frame(&pFrame);
  379.         SDL_LockMutex(pVc->pVideoListMutex);
  380.         pVc->videoList.pop_front();
  381.         SDL_UnlockMutex(pVc->pVideoListMutex);
  382.     }
  383. }

  385. Uint32 player::showVideo(Uint32 interval, void *param)
  386. {
  387.     VideoContext *data = (VideoContext*)param;
  388.     SDL_Rect rect;
  389.     rect.x = 0;
  390.     rect.y = 0;
  391.     rect.w = data->pVideoCodecCtx->width;
  392.     rect.h = data->pVideoCodecCtx->height;
  393.     SDL_DisplayYUVOverlay(data->pBmp, &rect);
  394.     return 0;
  395. }

  397. int player::readFrame(void* user_data)
  398. {
  399.     VideoContext* pVc = (VideoContext*)user_data;
  400.     while(1)
  401.     {
  402.         AVPacket *pkt = new AVPacket;
  403.         av_init_packet(pkt);
  404.         if(av_read_frame(pVc->pFormatCtx,pkt))
  405.         {
  406.             printf("read frame error or End of File\n");
  407.             pVc->frameEof = 1;
  408.             return 0;
  409.         }
  410.         if(pkt->stream_index == pVc->videoindex)
  411.         {
  412.             SDL_LockMutex(pVc->pVideoListMutex);
  413.             pVc->videoList.push_back(pkt);
  414.             SDL_CondSignal(pVc->pVideoListCond);
  415.             SDL_UnlockMutex(pVc->pVideoListMutex);
  416.         }
  417.         else if(pkt->stream_index == pVc->audioindex)
  418.         {
  419.             SDL_LockMutex(pVc->pAudioListMutex);
  420.             pVc->audioList.push_back(pkt);
  421.             SDL_CondSignal(pVc->pAudioListCond);
  422.             SDL_UnlockMutex(pVc->pAudioListMutex);
  423.         }
  424.         else if(pkt->stream_index == pVc->subindex)
  425.         {
  426.             SDL_LockMutex(pVc->pSubListMutex);
  427.             pVc->subList.push_back(pkt);
  428.             SDL_UnlockMutex(pVc->pSubListMutex);
  429.         }
  430.     }
  431. }

  433. void player::freeMem()
  434. {
  435.     avcodec_free_frame(&(m_pVC->pDecodeVideoFrame));
  436. }

  438. void player::load()
  439. {
  440.     m_pVC->read_tid = SDL_CreateThread(readFrame,&(*m_pVC));
  441.     m_pVC->videoPlay_tid = SDL_CreateThread(readVideo,&(*m_pVC));
  442. }
main函数

点击(此处)折叠或打开

  1. int main()
  2. {
  3.     player test;
  4.     test.loadLocalFile("E:\\C++Learning\\FFMPEG_SDL_WIN32_PLAYER_by_nick\\FLV_STREAM\\5.mp4");
  5.     test.load();
  6.     SDL_Event evt;
  7.     while ( 1 )
  8.     {
  9.         SDL_WaitEvent(&evt);
  10.         switch (evt.type)
  11.         {
  12.         case SDL_KEYDOWN:
  13.             {
  14.                 switch(evt.key.keysym.sym)
  15.                 {
  16.                 case SDLK_p:
  17.                     {
  18.                         printf("Print a Screen shoot\n");
  19.                     }break;
  20.                 }
  21.             }break;
  22.         case SDL_MOUSEMOTION:
  23.             break;
  24.         case SDL_MOUSEBUTTONDOWN:
  25.             break;
  26.         case SDL_QUIT:
  27.             {
  28.                 test.freeMem();
  29.                 exit(0);
  30.             }
  31.         }
  32.     }
  33.     return 0;
  34. }

代码地址：https://www.dropbox.com/sh/xr6n35e2utpe8vo/AACjsv1JgqATmwhpht9lMhI7a?dl=0

ffmpeg 最简单的视频播放

原文：http://blog.chinaunix.net/uid-24922718-id-4548972.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
分享档案
更多>
2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)
最新文章
更多>
教程昨日排行
更多>
友情链接
汇智网   PHP教程   插件网  
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣，分享程序人生！