ffmpeg的tutorial中文版学习笔记(五)

于 2016-08-10 10:58:08 发布
阅读量412 收藏
点赞数
分类专栏： ffmpeg
如何同步视频

源代码:tutorial05-1.c

前面整个的一段时间，我们有了一个几乎无用的电影播放器。当然，它能播放视频，也能播放音频，但是它还不能被称为一部电影。那么我们还要做什么呢？

PTS和DTS

幸运的是，音频和视频流都有一些关于以多快速度和什么时间来播放它们的信息在里面。音频流有采样，视频流有帧率。然而，如果我们只是简单的通过帧数和乘以帧率的方式来同步视频，那么就很有可能会失去同步。于是作为一种补充，在流中的包有种叫做DTS（解码时间戳）和PTS（显示时间戳）的机制。为了这两个参数，你需要了解电影存放的方式。像MPEG等格式，使用被叫做B帧（B表示双向bidrectional）的方式。另外两种帧被叫做I帧和P帧（I表示关键帧，P表示预测帧）。I帧包含了某个特定的完整图像。P帧依赖于前面的I帧或P帧，并且使用比较或者差分的方式来编码。B帧与P帧有点类似，但是它是依赖于前面和后面的帧的信息的。这也就解释了为什么我们可能在调用avcodec_decode_video以后会得不到一帧图像。

所以对于一个电影，帧是这样来显示的：I B B P。现在我们需要在显示B帧之前知道P帧中的信息。因此，帧可能会按照这样的方式来存储：IPBB。这就是为什么我们会有一个解码时间戳和一个显示时间戳的原因。解码时间戳告诉我们什么时候需要解码，显示时间戳告诉我们什么时候需要显示。所以，在这种情况下，我们的流可以是这样的：

[cpp]  view plain  copy
 print ?
  1.    PTS: 1 4 2 3  
  2.    DTS: 1 2 3 4  
  3. Stream: I P B B  

通常PTS和DTS只有在流中有B帧的时候会不同。

当我们调用av_read_frame()得到一个包的时候，PTS和DTS的信息也会保存在包中。但是我们真正想要的PTS是我们刚刚解码出来的原始帧的PTS，这样我们才能知道什么时候来显示它。然而，我们从avcodec_decode_video()函数中得到的帧只是一个AVFrame，其中并没有包含有用的PTS值（注意：AVFrame含有一成员pts，但这并不一定就含着我们想要的pts值）。然而，ffmpeg会将包重新排序，这样正被avcodec_decode_video()处理的包的DTS就与其之前返回的那帧的PTS相同。但同样要注意的是：我们也并不一定就能得到这个信息。

不用担心，因为有另外一种办法可以找到帧的PTS，我们可以让程序自己来重新排序包。我们保存一帧的第一个包的PTS：这将作为整个这一帧的PTS。我们可以通过函数avcodec_decode_video()来计算出哪个包是一帧的第一个包。怎样实现呢？任何时候当一个包开始一帧的时候，avcodec_decode_video()将调用一个函数来为一帧申请一个缓冲。当然，ffmpeg允许我们重新定义这个分配内存的函数。所以我们制作了一个新的函数来保存一个包的时间戳。

当然，尽管那样，我们可能还是得不到一个正确的时间戳。我们将在后面处理这个问题。

同步

现在，知道了什么时候来显示一个视频帧，但是我们怎样来实际操作呢？想法是：当我们显示了一帧以后，我们计算出下一帧显示的时间，然后我们简单的设置一个新的定时器来在一定间隔后刷新屏幕。你可能会想，我们以系统时钟为准来检查下一帧的PTS值来看应该设置多长时间。这种方式可以工作，但是有两种情况要处理。

首先，要知道下一个PTS是什么。现在我们能添加视频速率到我们的PTS中－－太对了！然而，有些电影需要帧重复。这意味着我们重复播放当前的帧。这将导致程序显示下一帧太快了。所以我们需要计算它们。

第二，正如已有的程序那样，视频和音频各自播放很欢快，一点也不受同步的影响。如果一切都工作得很好的话，我们不必担心。但是，你的电脑并不总是那么完美的，很多视频文件也不是完好的。所以，我们有三种选择：同步音频到视频，同步视频到音频，或者都同步到外部时钟（例如你的电脑时钟）。从现在开始，我们将同步视频到音频。

写代码：获得帧的时间戳

现在让我们到代码中来做这些事情。我们将需要为我们的大结构体添加一些成员，但是我们会根据需要来做。首先，让我们看一下视频线程。记住，在这里我们得到了解码线程输出到队列中的包。这里我们需要的是从avcodec_decode_video函数中得到帧的时间戳。我们讨论的第一种方式是从上次处理的包中得到DTS，这是很容易的：

[cpp]  view plain  copy
 print ?
  1. double pts;  
  2.   
  3. pFrame = avcodec_alloc_frame();  
  4.   
  5. for(;;)   
  6. {  
  7.   if(packet_queue_get(&is->videoq, packet, 1) < 0)   
  8.   {  
  9.     // means we quit getting packets  
  10.     break;  
  11.   }  
  12.   pts = 0;  
  13.   
  14.   // Save global pts to be stored in pFrame in first call  
  15.   global_video_pkt_pts = packet->pts;  
  16.   // Decode video frame  
  17.   avcodec_decode_video2(is->video_st->codec, pFrame, &frameFinished,packet);  
  18.   
  19.   if(packet->dts == AV_NOPTS_VALUE&& pFrame->opaque && *(uint64_t*)pFrame->opaque != AV_NOPTS_VALUE)   
  20.   {  
  21.     pts = *(uint64_t *)pFrame->opaque;  
  22.   }   
  23.   else if(packet->dts != AV_NOPTS_VALUE)   
  24.   {  
  25.     pts = packet->dts;  
  26.   }   
  27.   else   
  28.   {  
  29.     pts = 0;  
  30.   }  
  31.   pts *= av_q2d(is->video_st->time_base);  


如果我们得不到PTS就把它设置为0。

好，那是很容易的。但是我们所说的如果包的DTS不能帮到我们，我们需要使用这一帧的第一个包的PTS（两种途径标记一样）。我们通过让ffmpeg使用我们自己的申请帧程序来实现。下面的是函数的格式：

[cpp]  view plain  copy
 print ?
  1. int get_buffer(struct AVCodecContext *c, AVFrame *pic);  
  2.   
  3. void release_buffer(struct AVCodecContext *c, AVFrame *pic);  


申请函数没有告诉我们关于包的任何事情，所以我们要自己每次在得到一个包的时候把PTS保存到一个全局变量中去。然后，我们把值保存到AVFrame结构体的变量opaque中。所以一开始，这就是我们的函数：

[cpp]  view plain  copy
 print ?
  1. uint64_t global_video_pkt_pts = AV_NOPTS_VALUE;  
  2.   
  3. /* These are called whenever we allocate a frame 
  4. * buffer. We use this to store the global_pts in 
  5. * a frame at the time it is allocated. 
  6. */  
  7. int our_get_buffer(struct AVCodecContext *c, AVFrame *pic)   
  8. {  
  9.   int ret = avcodec_default_get_buffer(c, pic);  
  10.   uint64_t *pts = av_malloc(sizeof(uint64_t));  
  11.   *pts = global_video_pkt_pts;  
  12.   pic->opaque = pts;  
  13.   return ret;  
  14. }  
  15. void our_release_buffer(struct AVCodecContext *c, AVFrame *pic)   
  16. {  
  17.   if(pic)   
  18.     av_freep(&pic->opaque);  
  19.   avcodec_default_release_buffer(c, pic);  
  20. }  

函数avcodec_default_get_buffer和avcodec_default_release_buffer是ffmpeg中默认的申请缓冲的函数。函数av_freep是一个内存管理函数，它不但把内存释放而且把指针设置为NULL。

现在到了我们流打开的函数（stream_component_open），我们添加这几行来告诉ffmpeg如何去做：

[cpp]  view plain  copy
 print ?
  1. codecCtx->get_buffer = our_get_buffer;  
  2. codecCtx->release_buffer = our_release_buffer;  

现在我们必需添加代码来保存PTS到全局变量中，然后在需要的时候来使用它。我们的代码现在看起来应该是这样子：

[cpp]  view plain  copy
 print ?
  1. for(;;)   
  2. {  
  3.   if(packet_queue_get(&is->videoq, packet, 1) < 0)   
  4.   {  
  5.     // means we quit getting packets  
  6.     break;  
  7.   }  
  8.   pts = 0;  
  9.   
  10.   // Save global pts to be stored in pFrame in first call  
  11.   global_video_pkt_pts = packet->pts;  
  12.   // Decode video frame  
  13.   avcodec_decode_video2(is->video_st->codec, pFrame, &frameFinished,packet);  
  14.   
  15.   if(packet->dts == AV_NOPTS_VALUE&& pFrame->opaque && *(uint64_t*)pFrame->opaque != AV_NOPTS_VALUE)   
  16.   {  
  17.     pts = *(uint64_t *)pFrame->opaque;  
  18.   }   
  19.   else if(packet->dts != AV_NOPTS_VALUE)   
  20.   {  
  21.     pts = packet->dts;  
  22.   }   
  23.   else   
  24.   {  
  25.     pts = 0;  
  26.   }  
  27.   pts *= av_q2d(is->video_st->time_base);  

技术提示：你可能已经注意到我们使用int64来表示PTS。这是因为PTS是以整型来保存的。这个值是一个时间戳相当于时间的度量，用来以流的time_base为单位进行时间度量。例如，如果一个流是24帧每秒，值为42的PTS表示这一帧应该排在第42个帧的位置。 如果我们每秒有24帧（当然这值也许并不完全正确）。我们可以通过除以帧率来把这个值转化为秒。流中的time_base值以1/framerate表示（对于固定帧率来说），所以为得到以秒为单位的PTS，我们需要乘以time_base。

写代码：使用PTS来同步

现在我们得到了PTS。我们要注意前面讨论到的两个同步问题。我们将定义一个函数叫做synchronize_video，它可以更新同步的PTS。这个函数也能最终处理我们得不到PTS的情况。同时我们要知道下一帧的时间以便于正确设置刷新速率。我们可以使用内部的反映当前视频已经播放时间的时钟video_clock来完成这个功能。我们把这些值添加到大结构体中。

[cpp]  view plain  copy
 print ?
  1. typedef struct VideoState   
  2. {  
  3.       ...........  
  4.       double video_clock; ///<pts of last decoded frame / predicted pts of next decoded frame  
  5.       ...........  
  6. }  


下面的是函数synchronize_video，它可以很好的自我注释：

[cpp]  view plain  copy
 print ?
  1. double synchronize_video(VideoState *is, AVFrame *src_frame, double pts)   
  2. {  
  3.   
  4.   double frame_delay;  
  5.   
  6.   if(pts != 0)   
  7.   {  
  8.     /* if we have pts, set video clock to it */  
  9.     is->video_clock = pts;  
  10. printf("pts=%lf\n",pts);  
  11.   }   
  12.   else   
  13.   {  
  14.     /* if we aren't given a pts, set it to the clock */  
  15.     pts = is->video_clock;  
  16.   }  
  17.   /* update the video clock */  
  18.   frame_delay = av_q2d(is->video_st->codec->time_base);  
  19.   /* if we are repeating a frame, adjust clock accordingly */  
  20.   frame_delay += src_frame->repeat_pict * (frame_delay * 0.5);  
  21.   is->video_clock += frame_delay;  
  22.   return pts;  
  23. }  

你也会注意到我们也计算了重复的帧。


现在让我们得到正确的PTS并且使用queue_picture来队列化帧，添加一个新的时间戳参数pts：

[cpp]  view plain  copy
 print ?
  1. // Did we get a video frame?  
  2. if(frameFinished)   
  3. {  
  4.   pts = synchronize_video(is, pFrame, pts);  
  5.   if(queue_picture(is, pFrame, pts) < 0)   
  6.   {  
  7.     break;  
  8.   }  
  9. }  

对于queue_picture来说唯一改变的事情就是我们把时间戳值pts保存到VideoPicture结构体中，我们我们必需添加一个时间戳变量到结构体中并且添加一行代码：

[cpp]  view plain  copy
 print ?
  1. typedef struct VideoPicture   
  2. {  
  3.   .......  
  4.   double pts;  
  5. } VideoPicture;  
  6.   
  7. <p style="text-align:left" align="left"><span lang="EN-US" style="font-family:宋体;color:#333333;font-size:9pt">int queue_picture(VideoState *is, AVFrame *pFrame, double pts) {</span></p><p style="text-align:left" align="left"><span lang="EN-US" style="font-family:宋体;color:#333333;font-size:9pt">  ... stuff ...</span></p><p style="text-align:left" align="left"><span lang="EN-US" style="font-family:宋体;color:#333333;font-size:9pt">  if(vp->bmp) {</span></p><p style="text-align:left" align="left"><span lang="EN-US" style="font-family:宋体;color:#333333;font-size:9pt">    ... convert picture ...</span></p><p style="text-align:left" align="left"><span lang="EN-US" style="font-family:宋体;color:#333333;font-size:9pt">    vp->pts = pts;</span></p><p style="text-align:left" align="left"><span lang="EN-US" style="font-family:宋体;color:#333333;font-size:9pt">    ... alert queue ...</span></p><p style="text-align:left" align="left"><span lang="EN-US" style="font-family:宋体;color:#333333;font-size:9pt">  }</span></p>}  

现在我们的图像队列中的所有图像都有了正确的时间戳值，所以让我们看一下视频刷新函数。你会记得上次我们用80ms的刷新时间来欺骗它。那么，现在我们将会算出实际的值。

我们的策略是通过简单计算前一帧和现在这一帧的时间戳来预测出下一个时间戳的时间。同时，我们需要同步视频到音频。我们将设置一个音频时间audio clock；一个内部值记录了我们正在播放的音频的位置。就像从任意的mp3播放器中读出来的数字一样。既然我们把视频同步到音频，视频线程使用这个值来算出是否太快还是太慢。

我们将在后面来实现这些代码；现在我们假设我们已经有一个可以给我们音频时间的函数get_audio_clock。一旦我们有了这个值，我们在音频和视频失去同步的时候应该做些什么呢？我们应调整下次刷新的值:如果时间戳太落后于音频时间，我们加倍计算延迟。如果时间戳太领先于音频时间，我们将尽可能快的刷新（原文这么写对吗？？？--还是参考代码好了，老外的表述与我们的理解有差别）。我们有了调整过的刷新时间（或延迟），并记录了运行时间frame_timer（frame_timer = 电影开始播放时的系统时间 + 播放中所有延时的总和）。我们简单的添加新的时延到frame_timer，并把它和电脑的系统时间进行比较，然后使用那个差值来调度下一次刷新。这可能有点难以理解，所以请认真研究代码：

[cpp]  view plain  copy
 print ?
  1. void video_refresh_timer(void *userdata)   
  2. {  
  3.   
  4.   VideoState *is = (VideoState *)userdata;  
  5.   VideoPicture *vp;  
  6.   double actual_delay, delay, sync_threshold, ref_clock, diff;  
  7.     
  8.   if(is->video_st)   
  9.   {  
  10.     if(is->pictq_size == 0)   
  11.     {  
  12.       schedule_refresh(is, 1);  
  13.     }   
  14.     else   
  15.     {  
  16.       vp = &is->pictq[is->pictq_rindex];  
  17.   
  18.       delay = vp->pts - is->frame_last_pts; /* the pts from last time */  
  19.       if(delay <= 0 || delay >= 1.0)   
  20.       {  
  21.         /* if incorrect delay, use previous one */  
  22.         delay = is->frame_last_delay;  
  23.       }  
  24.       /* save for next time */  
  25.       is->frame_last_delay = delay;  
  26.       is->frame_last_pts = vp->pts;  
  27.   
  28.       /* update delay to sync to audio */  
  29.       ref_clock = get_audio_clock(is);  
  30.       diff = vp->pts - ref_clock;  
  31.   
  32.       /* Skip or repeat the frame. Take delay into account 
  33.       FFPlay still doesn't "know if this is the best guess." */  
  34.       sync_threshold = (delay > AV_SYNC_THRESHOLD) ? delay : AV_SYNC_THRESHOLD;  
  35.       if(fabs(diff) < AV_NOSYNC_THRESHOLD)   
  36.       {  
  37.         if(diff <= -sync_threshold)   
  38.         {  
  39.           delay = 0;  
  40.         }   
  41.         else if(diff >= sync_threshold)   
  42.         {  
  43.           delay = 2 * delay;  
  44.         }  
  45.       }  
  46.       is->frame_timer += delay;  
  47.       /* computer the REAL delay */  
  48.       actual_delay = is->frame_timer - (av_gettime() / 1000000.0);  
  49.       if(actual_delay < 0.010)   
  50.       {  
  51.         /* Really it should skip the picture instead */  
  52.         actual_delay = 0.010;  
  53.       }  
  54.       schedule_refresh(is, (int)(actual_delay * 1000 + 0.5));  
  55.       /* show the picture! */  
  56.       video_display(is);  
  57.         
  58.       /* update queue for next picture! */  
  59.       if(++is->pictq_rindex == VIDEO_PICTURE_QUEUE_SIZE)   
  60.       {  
  61.         is->pictq_rindex = 0;  
  62.       }  
  63.       SDL_LockMutex(is->pictq_mutex);  
  64.       is->pictq_size--;  
  65.       SDL_CondSignal(is->pictq_cond);  
  66.       SDL_UnlockMutex(is->pictq_mutex);  
  67.     }  
  68.   }   
  69.   else   
  70.   {  
  71.     schedule_refresh(is, 100);  
  72.   }  
  73. }  


我们在这里做了一些检查：首先，我们保证现在的时间戳和上一个时间戳之间的时延delay是有意义的。如果不是的话，我们就猜测着用上次的延迟。接着，我们有一个同步阈值，因为在同步的时候事情并不总是那么完美的。在ffplay中使用0.01作为它的值。我们也保证阈值不会比时间戳之间的间隔短。最后，我们把最小的刷新值设置为10毫秒。（事实上这里我们应该跳过这一帧，但是我们不想为此而烦恼。）

我们给大结构体添加了很多的变量，所以不要忘记检查一下代码。同时也不要忘记在函数stream_component_open中初始化帧时间frame_timer和前面的帧延迟frame delay：

[cpp]  view plain  copy
 print ?
  1. is->frame_timer = (double)av_gettime() / 1000000.0;  
  2. is->frame_last_delay = 40e-3;  

同步：声音时钟

现在让我们看一下怎样来得到声音时钟。我们可以在声音解码函数audio_decode_frame中更新时钟时间。现在，请记住我们并不是每次调用这个函数的时候都在处理新的包，所以有我们要在两个地方更新时钟。第一个地方是我们得到新的包的时候：我们简单的设置声音时钟为这个包的时间戳。然后，如果一个包里有许多帧，我们通过样本数和采样率来计算，所以当我们得到包的时候：

[cpp]  view plain  copy
 print ?
  1. /* if update, update the audio clock w/pts */  
  2. if(pkt->pts != AV_NOPTS_VALUE)   
  3. {  
  4.   is->audio_clock = av_q2d(is->audio_st->time_base)*pkt->pts;  
  5.   //printf("--%g----%g--%g\n",is->audio_clock,av_q2d(is->audio_st->time_base),pkt->pts);  
  6.   
  7. }  

然后当我们处理这个包的时候：

[cpp]  view plain  copy
 print ?
  1. pts = is->audio_clock;  
  2. *pts_ptr = pts;  
  3. n = 2 * is->audio_st->codec->channels;  
  4. //printf("%d,,,%d\n",is->audio_st->codec->sample_rate,data_size );  
  5. is->audio_clock += (double)data_size /(double)(n * is->audio_st->codec->sample_rate);  

一点细节：此函数多包含了一个参数pts_ptr。这时的pts_ptr是一个用来通知audio_callback函数当前声音包的时间戳的指针。这将在下次用来同步声音和视频。

现在我们可以最后来实现我们的get_audio_clock函数。它并不只是得到is->audio_clock值那样简单。注意我们会在每次处理它的时候设置声音时间戳，但是如果你看了audio_callback函数，它花费了时间来把数据从声音包中移到我们的输出缓冲区中。这意味着我们声音时钟中记录的时间比实际的要早太多。(我猜也即先计算出is->audio_clock,但是相应的数据可能在audio_callback函数中还没从声音包中移到我们的输出缓冲区中，所以要减去这部分多算的时间。)所以我们必须要检查一下我们还有多少没有写入。下面是完整的代码：


[cpp]  view plain  copy
 print ?
  1. double get_audio_clock(VideoState *is)   
  2. {  
  3.   double pts;  
  4.   int hw_buf_size, bytes_per_sec, n;  
  5.     
  6.   pts = is->audio_clock; /* maintained in the audio thread */  
  7.   hw_buf_size = is->audio_buf_size - is->audio_buf_index;  
  8.   bytes_per_sec = 0;  
  9.   n = is->audio_st->codec->channels * 2;  
  10.   if(is->audio_st)   
  11.   {  
  12.     bytes_per_sec = is->audio_st->codec->sample_rate * n;  
  13.   }  
  14.   if(bytes_per_sec)   
  15.   {  
  16.     pts -= (double)hw_buf_size / bytes_per_sec;  
  17.   }  
  18.   return pts;  
  19. }  
你应该知道为什么这个函数可以正常工作了;)

这就是了！让我们编译它：

[cpp]  view plain  copy
 print ?
  1. gcc ./<span class="css-truncate css-truncate-target"><span class="js-directory-link">tutorial05-1.c</span></span> -o ./<span class="css-truncate css-truncate-target"><span class="js-directory-link">tutorial05-1</span></span> -lavutil -lavformat -lavcodec -lswscale  -lz -lm `sdl-config --cflags --libs` -I /home/Jiakun/ffmpeg_build/include/  
  2.  -L /home/Jiakun/ffmpeg_build/lib/ -I /usr/include/SDL/  
郑亚帅
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ffmpeg_笔记
tianyu的专栏 - Linux site:blog.csdn.net/wishfly
12-23 373
0. ffmpeg_examples https://github.com/liuty2006/。ffmpeg_examples 1. 100行代码实现最简单的基于FFMPEG+SDL的视频播放器（SDL1.x） https://blog.csdn.net/leixiaohua1020/article/details/8652605 2. ffmpeg + SDL2 实现的视频播放器「视音...
ffmpeg的tutorial中文版.pdf
09-16
用FFmpeg编写一个简单播放器
ffmpeg的tutorial中文版学习笔记(一)
郑亚帅
08-10 457
在网上下载了一些pdf版的ffmpeg的tutorial中文版，在学习过程中发现有很多错误，这些错误，或者是文章中的代码中的变量作者没有定义，或者是由于ffmpeg一直在更新，”以时俱进“，而这些资料早已年久失修，一些函数早已更名，或被别的函数替代，学习过程中发现很多问题，故决定做下笔记，做出总结：           FFMPEG 是一个很好的库，可以用来创建视频应用或者生成特定的工具。FFM
ffmpeg的tutorial中文版学习笔记(四)
郑亚帅
08-10 360
源代码：tutorial04-1.c 综述 前面我们利用SDL的音频函数实现了对音频解码和播放的支持，我们定义一个包含音频回调函数callbacks的线程函数，当我们需要音频的时候就使SDL启动这个线程。现在我们将要对视频播放做同样的事情，这样能使代码更容易模块化和协作，尤其有利于音视频同步，那么我们从哪里开始呢？ 首先注意到，我们的主函数需要做太多的事情：运行event循环，读pa
ffmpeg的tutorial中文版学习笔记(六)
坤哥的学习笔记
07-15 1022
指导6：同步音频 同步音频 现在我们已经有了一个比较像样的播放器。所以让我们看一下还有哪些零碎的东西没处理。上次，我们掩饰了一点同步问题，也就是同步音频到视频而不是其它的同 步方式。我们将采用和视频一样的方式：做一个内部视频时钟来记录视频线程播放了多久，然后同步音频到上面去。后面我们也来看一下如何推而广之把音频和视频 都同步到外部时钟。 生成一个视频时钟 现在我
ffmpeg的tutorial中文版学习笔记(二)
坤哥的学习笔记
07-15 1409
教程2：输出到屏幕           视频为了在屏幕上显示，我们将使用SDL，SDL 是Simple Direct Layer 的缩写。它是一个出色的多媒体库，适用于多平台，并且被用在许多工程中。你可以从它的官方网站的网址http://www.libsdl.org/ 上来得到这个库的源代码或者如果有可能的话你可以直接下载开发包到你的操作系统中。按照这个指导，你将需要编译这个库。（剩下的几个
ffmpeg的tutorial中文版学习笔记(三)
坤哥的学习笔记
07-15 1510
fmpeg 教程3：播放声音           现在我们要来播放声音。SDL 也为我们准备了输出声音的方法。函数SDL_OpenAudio()本身就是用来打开声音设备的。它使用一个叫做SDL_AudioSpec 结构体作为参数，这个结构体中包含了我们将要输出的音频的所有信息。           在我们展示如何建立之前，让我们先解释一下电脑是如何处理音频的。数字音频是由一长串的样本流组成的。
ffmpeg的tutorial中文版学习笔记(七)
坤哥的学习笔记
07-15 1644
指导7：快进快退 处理快进快退命令 现在我们来为我们的播放器加入一些快进和快退的功能，因为如果你不能全局搜索一部电影是很让人讨厌的。同时，这将告诉你av_seek_frame函数是多么容易使用。 我们将在电影播放中使用左方向键和右方向键来表示向后和向前一小段，使用向上和向下键来表示向前和向后一大段。这里一小段是10秒，一大段是60 秒。所以 我们需要设置我们的主循环来捕捉键盘
ffmpeg的tutorial中文版学习笔记(八)
坤哥的学习笔记
07-15 1014
指导8：软件缩放 软件缩放库libswscale 近来ffmpeg添加了新的接口：libswscale来处理图像缩放。 但是在前面我们使用img_convert来把RGB转换成YUV12，我们现在使用新的接口。新接口更加标准和快速，而且我相信里面有了MMX优化代码。换句话说，它是做缩放更好的方式。 我们将用来缩放的基本函数是sws_scale。但一开始，我们必需建立一个SwsConte
ffmpeg的tutorial中文版学习笔记(四)(新版函数额外补充)
郑亚帅
08-10 196
在ffmpeg官方论团中找到的第四篇教程中，在decode_thread函数中多了些一些没见过的函数，现在补充如下： 1：struct AVIOInterruptCB: 头文件：#include avio.h>   成员变量： int(*  callback )(void *)   void *  opaque
ffmpeg的tutorial中文版完美版+源码
10-11
本教程基于“ffmpeg的tutorial中文版完美版”展开，涵盖了从基础到进阶的多个方面，通过源码分析加深理解。以下是针对每个教程章节的详细知识点介绍： 1. **教程01.c**： - 入门介绍：讲解如何使用FFmpeg库进行...
FFmpeg Tutorial.pdf(中文版)
12-04
FFMPEG 是一个很好的库，可以用来创建视频应用或者生成特定的工具。FFMPEG 几乎为你把所有的繁重工 作都做了，比如解码、编码、复用和解复用。这使得多媒体应用程序变得容易编写。它是一个简单的，用C 编写 的，快速...
计算机系统结构(02325)自考真题(201704)
最新发布
07-28
计算机系统结构(02325)自考真题(201704) 计算机系统结构（Computer Architecture）也称为计算机体系结构，它是由计算机结构外特性，内特性，微外特性组成的。经典的计算机系统结构的定义是指计算机系统多级层次结构中机器语言机器级的结构，它是软件和硬件/固件的主要交界面，是由机器语言程序、汇编语言源程序和高级语言源程序翻译生成的机器语言目标程序能在机器上正确运行所应具有的界面结构和功能。 计算机系统结构指的是什么? 是一台计算机的外表? 还是是指一台计算机内部的一块块板卡安放结构? 都不是，那么它是什么? 计算机系统结构就是计算机的机器语言程序员或编译程序编写者所看到的外特性。所谓外特性，就是计算机的概念性结构和功能特性。用一个不恰当的比喻一，比如动物吧，它的"系统结构"是指什么呢? 它的概念性结构和功能特性，就相当于动物的器官组成及其功能特性，如鸡有胃，胃可以消化食物。至于鸡的胃是什么形状的、鸡的胃部由什么组成就不是"系统结构"研究的问题了。
国家电零售业中上市公司融资问题研究—以国美电器为例.docx
07-28
国家电零售业中上市公司融资问题研究—以国美电器为例.docx
python + opencv 加载 onnx 人脸检测模型识别人脸测试使用的 人脸照片
07-28
python + opencv 加载 onnx 人脸检测模型识别人脸测试使用的 人脸照片
亲测运营版PHP汽车二手车拍卖网站源码事故车竞拍拍卖系统
07-28
PHP汽车二手车拍卖网站源码 事故车竞拍拍卖系统/内附安装教程 安装说明： 1、导入文件到数据库 2、配置数据库连接地址\include\conn.inc.php 3、后台地址 : 域名/manage
基于SpringCloud微服务架构的B2C电子商务系统-可执行内含文档代码-可执行内含文档代码.zip
07-28
基于SpringCloud微服务架构的B2C电子商务系统-可执行内含文档代码-可执行内含文档代码.zip
【2022】2022巨量引擎汽车后市场行业洞察报告-巨量算数&途虎养车_70页.pdf
07-28
【2022】2022巨量引擎汽车后市场行业洞察报告-巨量算数&途虎养车_70页.pdf
ffmpeg教程 中文版
09-27
FFmpeg 的中文教程包括了基本的安装与配置步骤，以及常用的命令使用示例。首先，我们需要下载 FFmpeg 的压缩包，然后解压到指定目录。接着，配置环境变量，将 FFmpeg 的可执行文件路径添加到系统的 PATH 变量中。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值