FFmpeg如何同步音视频的解决方案Word下载.docx

FFmpeg如何同步音视频的解决方案Word下载.docx

《FFmpeg如何同步音视频的解决方案Word下载.docx》由会员分享，可在线阅读，更多相关《FFmpeg如何同步音视频的解决方案Word下载.docx（27页珍藏版）》请在冰豆网上搜索。

当我们调用av_read_frame（）得到一个包的时候，PTS和DTS的信息也会保存在包中。

但是我们真正想要的PTS是我们刚刚解码出来的原始帧的PTS，这样我们才能知道什么时候来显示它。

然而，我们从avcodec_decode_video（）函数中得到的帧只是一个AVFrame，其中并没有包含有用的PTS值（注意：

AVFrame并没有包含时间戳信息，但当我们等到帧的时候并不是我们想要的样子）。

然而，ffmpeg重新排序包以便于被avcodec_decode_video（）函数处理的包的DTS可以总是与其返回的PTS相同。

但是，另外的一个警告是：

我们也并不是总能得到这个信息。

不用担心，因为有另外一种办法可以找到帧的PTS，我们可以让程序自己来重新排序包。

我们保存一帧的第一个包的PTS：

这将作为整个这一帧的PTS。

我们可以通过函数avcodec_decode_video（）来计算出哪个包是一帧的第一个包。

怎样实现呢？

任何时候当一个包开始一帧的时候，avcodec_decode_video（）将调用一个函数来为一帧申请一个缓冲。

当然，ffmpeg允许我们重新定义那个分配内存的函数。

所以我们制作了一个新的函数来保存一个包的时间戳。

当然，尽管那样，我们可能还是得不到一个正确的时间戳。

我们将在后面处理这个问题。

同步

现在，知道了什么时候来显示一个视频帧真好，但是我们怎样来实际操作呢？

这里有个主意：

当我们显示了一帧以后，我们计算出下一帧显示的时间。

然后我们简单的设置一个新的定时器来。

你可能会想，我们检查下一帧的PTS值而不是系统时钟来看超时是否会到。

这种方式可以工作，但是有两种情况要处理。

首先，要知道下一个PTS是什么。

现在我们能添加视频速率到我们的PTS中－－太对了！

然而，有些电影需要帧重复。

这意味着我们重复播放当前的帧。

这将导致程序显示下一帧太快了。

所以我们需要计算它们。

第二，正如程序现在这样，视频和音频播放很欢快，一点也不受同步的影响。

如果一切都工作得很好的话，我们不必担心。

但是，你的电脑并不是最好的，很多视频文件也不是完好的。

所以，我们有三种选择：

同步音频到视频，同步视频到音频，或者都同步到外部时钟（例如你的电脑时钟）。

从现在开始，我们将同步视频到音频。

写代码：

获得帧的时间戳

现在让我们到代码中来做这些事情。

我们将需要为我们的大结构体添加一些成员，但是我们会根据需要来做。

首先，让我们看一下视频线程。

记住，在这里我们得到了解码线程输出到队列中的包。

这里我们需要的是从avcodec_decode_video函数中得到帧的时间戳。

我们讨论的第一种方式是从上次处理的包中得到DTS，这是很容易的：

doublepts;

for（;

;

）{

if（packet_queue_get（&

is->

videoq,packet,1）<

0）{

//meanswequitgettingpackets

break;

}

pts=0;

//Decodevideoframe

len1=avcodec_decode_video（is->

video_st->

codec,

pFrame,&

frameFinished,

packet->

data,packet->

size）;

if（packet->

dts!

=AV_NOPTS_VALUE）{

pts=packet->

dts;

}else{

pts*=av_q2d（is->

time_base）;

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

好，那是很容易的。

但是我们所说的如果包的DTS不能帮到我们，我们需要使用这一帧的第一个包的PTS。

我们通过让ffmpeg使用我们自己的申请帧程序来实现。

下面的是函数的格式：

intget_buffer（structAVCodecContext*c,AVFrame*pic）;

voidrelease_buffer（structAVCodecContext*c,AVFrame*pic）;

申请函数没有告诉我们关于包的任何事情，所以我们要自己每次在得到一个包的时候把PTS保存到一个全局变量中去。

我们自己以读到它。

然后，我们把值保存到AVFrame结构体难理解的变量中去。

所以一开始，这就是我们的函数：

uint64_tglobal_video_pkt_pts=AV_NOPTS_VALUE;

intour_get_buffer（structAVCodecContext*c,AVFrame*pic）{

intret=avcodec_default_get_buffer（c,pic）;

uint64_t*pts=av_malloc（sizeof（uint64_t））;

*pts=global_video_pkt_pts;

pic->

opaque=pts;

returnret;

voidour_release_buffer（structAVCodecContext*c,AVFrame*pic）{

if（pic）av_freep（&

opaque）;

avcodec_default_release_buffer（c,pic）;

函数avcodec_default_get_buffer和avcodec_default_release_buffer是ffmpeg中默认的申请缓冲的函数。

函数av_freep是一个内存管理函数，它不但把内存释放而且把指针设置为NULL。

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

codecCtx->

get_buffer=our_get_buffer;

release_buffer=our_release_buffer;

现在我们必需添加代码来保存PTS到全局变量中，然后在需要的时候来使用它。

我们的代码现在看起来应该是这样子：

//SaveglobalptstobestoredinpFrameinfirstcall

global_video_pkt_pts=packet->

pts;

codec,pFrame,&

dts==AV_NOPTS_VALUE

&

pFrame->

opaque&

*（uint64_t*）pFrame->

opaque!

pts=*（uint64_t*）pFrame->

opaque;

}elseif（packet->

技术提示：

你可能已经注意到我们使用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来完成这个功能。

我们把这些值添加到大结构体中。

typedefstructVideoState{

doublevideo_clock;

///

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

doublesynchronize_video（VideoState*is,AVFrame*src_frame,doublepts）{

doubleframe_delay;

if（pts!

=0）{

video_clock=pts;

pts=is->

video_clock;

frame_delay=av_q2d（is->

codec->

frame_delay+=src_frame->

repeat_pict*（frame_delay*0.5）;

video_clock+=frame_delay;

returnpts;

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

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

//Didwegetavideoframe?

if（frameFinished）{

pts=synchronize_video（is,pFrame,pts）;

if（queue_picture（is,pFrame,pts）<

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

typedefstructVideoPicture{

...

intqueue_picture（VideoState*is,AVFrame*pFrame,doublepts）{

...stuff...

if（vp->

bmp）{

...convertpicture...

vp->

pts=pts;

...alertqueue...

现在我们的图像队列中的所有图像都有了正确的时间戳值，所以让我们看一下视频刷新函数。

你会记得上次我们用80ms的刷新时间来欺骗它。

那么，现在我们将会算出实际的值。

我们的策略是通过简单计算前一帧和现在这一帧的时间戳来预测出下一个时间戳的时间。

同时，我们需要同步视频到音频。

我们将设置一个音频时间audioclock；

一个内部值记录了我们正在播放的音频的位置。

就像从任意的mp3播放器中读出来的数字一样。

既然我们把视频同步到音频，视频线程使用这个值来算出是否太快还是太慢。

我们将在后面来实现这些代码；

现在我们假设我们已经有一个可以给我们音频时间的函数get_audio_clock。

一旦我们有了这个值，我们在音频和视频失去同步的时候应该做些什么呢？

简单而有点笨的办法是试着用跳过正确帧或者其它的方式来解决。

作为一种替代的手段，我们会调整下次刷新的值；

如果时间戳太落后于音频时间，我们加倍计算延迟。

如果时间戳太领先于音频时间，我们将尽可能快的刷新。

既然我们有了调整过的时间和延迟，我们将把它和我们通过frame_timer计算出来的时间进行比较。

这个帧时间frame_timer将会统计出电影播放中所有的延时。

换句话说，这个frame_timer就是指我们什么时候来显示下一帧。

我们简单的添加新的帧定时器延时，把它和电脑的系统时间进行比较，然后使用那个值来调度下一次刷新。

这可能有点难以理解，所以请认真研究代码：

voidvideo_refresh_timer（void*userdata）{

VideoState*is=（VideoState*）userdata;

VideoPicture*vp;

doubleactual_delay,delay,sync_threshold,ref_clock,diff;

if（is->

video_st）{

pictq_size==0）{

schedule_refresh（is,1）;

vp=&

pictq[is->

pictq_rindex];

delay=vp->

pts-is->

frame_last_pts;

if（delay<

=0||delay>

=1.0）{

delay=is->

frame_last_delay;

frame_last_delay=delay;

frame_last_pts=vp->

ref_clock=get_audio_clock（is）;

diff=vp->

pts-ref_clock;

sync_threshold=（delay>

AV_SYNC_THRESHOLD）?

delay:

AV_SYNC_THRESHOLD;

if（fabs（diff）<

AV_NOSYNC_THRESHOLD）{

if（diff<

=-sync_threshold）{

delay=0;

}elseif（diff>

=sync_threshold）{

delay=2*delay;

frame_timer+=delay;

actual_delay=is->

frame_timer-（av_gettime（）/1000000.0）;

if（actual_delay<

0.010）{

actual_delay=0.010;

schedule_refresh（is,（int）（actual_delay*1000+0.5））;

video_display（is）;

if（++is->

pictq_rindex==VIDEO_PICTURE_QUEUE_SIZE）{

pictq_rindex=0;

SDL_LockMutex（is->

pictq_mutex）;

pictq_size--;

SDL_CondSignal（is->

pictq_cond）;

SDL_UnlockMutex（is->

schedule_refresh（is,100）;

我们在这里做了很多检查：

首先，我们保证现在的时间戳和上一个时间戳之间的处以delay是有意义的。

如果不是的话，我们就猜测着用上次的延迟。

接着，我们有一个同步阈值，因为在同步的时候事情并不总是那么完美的。

在ffplay中使用0.01作为它的值。

我们也保证阈值不会比时间戳之间的间隔短。

最后，我们把最小的刷新值设置为10毫秒。

（这句不知道应该放在哪里）事实上这里我们应该跳过这一帧，但是我们不想为此而烦恼。

我们给大结构体添加了很多的变量，所以不要忘记检查一下代码。

同时也不要忘记在函数streame_component_open中初始化帧时间frame_timer和前面的帧延迟framedelay：

frame_timer=（double）av_gettime（）/1000000.0;

frame_last_delay=40e-3;

同步：

声音时钟

现在让我们看一下怎样来得到声音时钟。

我们可以在声音解码函数audio_decode_frame中更新时钟时间。

现在，请记住我们并不是每次调用这个函数的时候都在处理新的包，所以有我们要在两个地方更新时钟。

第一个地方是我们得到新的包的时候：

我们简单的设置声音时钟为这个包的时间戳。

然后，如果一个包里有许多帧，我们通过样本数和采样率来计算，所以当我们得到包的时候：

if（pkt->

pts!

audio_clock=av_q2d（is->

audio_st->

time_base）*pkt->

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

audio_clock;

*pts_ptr=pts;

n=2*is->

channels;

audio_clock+=（double）data_size/

（double）（n*is->

sample_rate）;

一点细节：

临时函数被改成包含pts_ptr，所以要保证你已经改了那些。

这时的pts_ptr是一个用来通知audio_callback函数当前声音包的时间戳的指针。

这将在下次用来同步声音和视频。

现在我们可以最后来实现我们的get_audio_clock函数。

它并不像得到is->

audio_clock值那样简单。

注意我们会在每次处理它的时候设置声音时间戳，但是如果你看了audio_callback函数，它花费了时间来把数据从声音包中移到我们的输出缓冲区中。

这意味着我们声音时钟中记录的时间比实际的要早太多。

所以我们必须要检查一下我们还有多少没有写入。

下面是完整的代码：

doubleget_audio_clock（VideoState*is）{

inthw_buf_size,bytes_per_sec,n;

hw_buf_size=is->

audio_buf_size-is->

audio_buf_index;

bytes_per_sec=0;

n=is->

channels*2;

audio_st）{

bytes_per_sec=is->

sample_rate*n;

if（bytes_per_sec）{

pts-=（double）hw_buf_size/bytes_per_sec;

你应该知道为什么这个函数可以正常工作了;

）

这就是了！

让我们编译它：

gcc-otutorial05tutorial05.c-lavutil-lavformat-lavcodec-lz-lm`sdl-config--cflags--libs`

最后，你可以使用我们自己的电影播放器来看电影了。

下次我们将看一下声音同步，然后接下来的指导我们会讨论查询。

同步音频

现在我们已经有了一个比较像样的播放器。

所以让我们看一下还有哪些零碎的东西没处理。

上次，我们掩饰了一点同步问题，也就是同步音频到视频而不是其它的同步方式。

我们将采用和视频一样的方式：

做一个内部视频时钟来记录视频线程播放了多久，然后同步音频到上面去。

后面我们也来看一下如何推而广之把音频和视频都同步到外部时钟。

生成一个视频时钟

现在我们要生成一个类似于上次我们的声音时钟的视频时钟：

一个给出当前视频播放时间的内部值。

开始，你可能会想这和使用上一帧的时间戳来更新定时器一样简单。

但是，不要忘了视频帧之间的时间间隔是很长的，以毫秒为计量的。

解决办法是跟踪另外一个值：

我们在设置上一帧时间戳的时候的时间值。

于是当前视频时间值就是PTS_of_last_frame+（current_time-time_elapsed_since_PTS_value_was_set）。

这种解决方式与我们在函数get_audio_clock中的方式很类似。

所在在我们的大结构体中，我们将放上一个双精度浮点变量video_current_pts和一个64位宽整型变量video_current_pts_time。

时钟更新将被放在video_refresh_timer函数中。

video_current_pts=vp->

video_current_pts_time=av_