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

指导6：同步音频

源代码：tutorial06-1.c

同步音频

现在我们已经有了一个比较像样的播放器。所以让我们看一下还有哪些零碎的东西没处理。上次，我们掩饰了一点同步问题，也就是同步音频到视频而不是其它的同 步方式。我们将采用和视频一样的方式：做一个内部视频时钟来记录视频线程播放了多久，然后同步音频到上面去。后面我们也来看一下如何推而广之把音频和视频 都同步到外部时钟。

生成一个视频时钟

现在我们要生成一个类似于上次我们的声音时钟的视频时钟：一个给出当前视频播放时间的内部值。开始，你可能会想这和使用上一帧的时间戳来更新定时器一样简 单。但是，不要忘了视频帧之间的时间间隔是很长的，以毫秒为计量的。解决办法是跟踪另外一个值：我们在设置上一帧时间戳的时候的时间值。于是当前视频时间 值就是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函数中。

[cpp]  view plain  copy

 print ?

1. void video_refresh_timer(void *userdata)   
2. {  
3.   VideoState *is = (VideoState *)userdata;  
4.   VideoPicture *vp;  
5.   double actual_delay, delay, sync_threshold, ref_clock, diff;  
6.     
7.   if(is->video_st)   
8.   {  
9.     if(is->pictq_size == 0)   
10.     {  
11.       schedule_refresh(is, 1);  
12.     }   
13.     else   
14.     {  
15.       vp = &is->pictq[is->pictq_rindex];  
16.       is->video_current_pts = vp->pts;  
17.       is->video_current_pts_time = av_gettime();  

不要忘记在stream_component_open函数中初始化它：

[cpp]  view plain  copy

 print ?

1. is->video_current_pts_time = av_gettime();  

现在我们需要一种得到信息的方式：

[cpp]  view plain  copy

 print ?

1. double get_video_clock(VideoState *is)   
2. {  
3.   double delta;  
4.   delta = (av_gettime() - is->video_current_pts_time) / 1000000.0;  
5.   return is->video_current_pts + delta;  
6. }  

提取时钟

但是为什么要强制使用视频时钟呢？我们更改视频同步代码以致于音频和视频不会试着去相互同步。想像一下我们让它像ffplay一样有一个命令行参数。所以 让我们抽象一样这件事情：我们将做一个新的封装函数get_master_clock，用来检测av_sync_type变量然后决定调用 get_audio_clock还是get_video_clock或者其它的想使用的获得时钟的函数。我们甚至可以使用电脑时钟，这个函数我们叫做 get_external_clock：

[cpp]  view plain  copy

 print ?

1. enum {  
2.   AV_SYNC_AUDIO_MASTER,  
3.   AV_SYNC_VIDEO_MASTER,  
4.   AV_SYNC_EXTERNAL_MASTER,  
5. };  
6. <pre name="code" class="cpp">#define DEFAULT_AV_SYNC_TYPE AV_SYNC_VIDEO_MASTER  

[cpp]  view plain  copy

 print ?

1. double get_master_clock(VideoState *is)   
2. {  
3.   if(is->av_sync_type == AV_SYNC_VIDEO_MASTER)   
4.   {  
5.     return get_video_clock(is);  
6.   }   
7.   else if(is->av_sync_type == AV_SYNC_AUDIO_MASTER)   
8.   {  
9.     return get_audio_clock(is);  
10.   }   
11.   else   
12.   {  
13.     return get_external_clock(is);  
14.   }  
15. }  

[cpp]  view plain  copy

 print ?

1. int main(int argc, char *argv[]) {  
2.     ....  
3. is->av_sync_type = DEFAULT_AV_SYNC_TYPE;  
4.     ....  
5. }  

同步音频

现在是最难的部分：同步音频到视频时钟。我们的策略是测量声音的位置，把它与视频时间比较然后算出我们需要修正多少的样本数，也就是说：我们是否需要通过丢弃样本的方式来加速播放还是需要通过插值样本的方式来放慢播放？

我们将在每次处理声音样本的时候运行一个synchronize_audio的函数来正确的收缩或者扩展声音样本。然而，我们不想在每次发现有偏差的时候 都进行同步，因为这样会使同步音频多于视频包。所以我们为函数synchronize_audio设置一个最小连续值来限定需要同步的时刻，这样我们就不 会总是在调整了。当然，就像上次那样，“失去同步”意味着声音时钟和视频时钟的差异大于我们的阈值。

所以我们将使用一个分数系数，叫c，所以现在可以说我们得到了N个失去同步的声音样本。失去同步的数量可能会有很多变化，所以我们要计算一下失去同步的长 度的均值。例如，第一次调用的时候，显示出来我们失去同步的长度为40ms，下次变为50ms等等。但是我们不会使用一个简单的均值，因为距离现在最近的 值比靠前的值要重要的多。所以我们将使用一个分数系统，叫c，然后用这样的公式来计算差异：diff_sum = new_diff + diff_sum*c。当我们准备好去找平均差异的时候，我们用简单的计算方式：avg_diff = diff_sum * (1-c)。

注意：为什么会在这里？这个公式看来很神奇！嗯，它基本上是一个使用等比级数的加权平均值。我不知道这是否有名字（我甚至查过维基百科！），但是如果想要更多的信息，这里是一个解释http://www.dranger.com/ffmpeg/weightedmean.html或者在http://www.dranger.com/ffmpeg/weightedmean.txt里。

下面是我们的函数：

[cpp]  view plain  copy

 print ?

1. /* Add or subtract samples to get a better sync, return new 
2. audio buffer size */  
3. int synchronize_audio(VideoState *is, short *samples,int samples_size, double pts)   
4. {  
5.   int n;  
6.   double ref_clock;  
7.   n = 2 * is->audio_st->codec->channels;  
8.   if(is->av_sync_type != AV_SYNC_AUDIO_MASTER)   
9.   {  
10.     double diff, avg_diff;  
11.     int wanted_size, min_size, max_size /*, nb_samples */;  
12.       
13.     ref_clock = get_master_clock(is);  
14.     diff = get_audio_clock(is) - ref_clock;  
15.   
16.     if(diff < AV_NOSYNC_THRESHOLD)   
17.     {  
18.       // accumulate the diffs  
19.       is->audio_diff_cum = diff + is->audio_diff_avg_coef* is->audio_diff_cum;  
20.       if(is->audio_diff_avg_count < AUDIO_DIFF_AVG_NB)   
21.       {  
22.         is->audio_diff_avg_count++;  
23.       }   
24.       else   
25.       {  
26.         avg_diff = is->audio_diff_cum * (1.0 - is->audio_diff_avg_coef);  
27.         if(fabs(avg_diff) >= is->audio_diff_threshold)   
28.         {  
29.           wanted_size = samples_size + ((int)(diff * is->audio_st->codec->sample_rate) * n);  
30.           min_size = samples_size * ((100 - SAMPLE_CORRECTION_PERCENT_MAX) / 100);  
31.           max_size = samples_size * ((100 + SAMPLE_CORRECTION_PERCENT_MAX) / 100);  
32.           if(wanted_size < min_size)   
33.           {  
34.             wanted_size = min_size;  
35.           }   
36.           else if (wanted_size > max_size)   
37.           {  
38.             wanted_size = max_size;  
39.           }  
40.           if(wanted_size < samples_size)   
41.           {  
42.             /* remove samples */  
43.             samples_size = wanted_size;  
44.           }  
45.            else if(wanted_size > samples_size)   
46.            {  
47.               uint8_t *samples_end, *q;  
48.               int nb;  
49.   
50.               /* add samples by copying final sample*/  
51.               nb = (samples_size - wanted_size);  
52.               samples_end = (uint8_t *)samples + samples_size - n;  
53.               q = samples_end + n;  
54.               printf(".......%d\n",nb );  
55.               while(nb > 0) //No carry  
56.               {  
57.                 printf("-----%d------\n",nb );  
58.                 memcpy(q, samples_end, n);  
59.                 q += n;  
60.                 nb -= n;  
61.               }  
62.               samples_size = wanted_size;  
63.             }  
64.           }  
65.         }  
66.     }   
67.     else   
68.     {  
69.       /* difference is TOO big; reset diff stuff */  
70.       is->audio_diff_avg_count = 0;  
71.       is->audio_diff_cum = 0;  
72.     }  
73.   }  
74.   return samples_size;  
75. }  

现在我们已经做得很好；我们已经近似的知道如何用视频或者其它的时钟来调整音频了。所以让我们来计算一下要在添加和砍掉多少样本，并且如何在“Shrinking/expanding buffer code”部分来写上代码：

[cpp]  view plain  copy

 print ?

1. avg_diff = is->audio_diff_cum * (1.0 - is->audio_diff_avg_coef);  
2. if(fabs(avg_diff) >= is->audio_diff_threshold)   
3. {  
4.   wanted_size = samples_size + ((int)(diff * is->audio_st->codec->sample_rate) * n);  
5.   min_size = samples_size * ((100 - SAMPLE_CORRECTION_PERCENT_MAX) / 100);  
6.   max_size = samples_size * ((100 + SAMPLE_CORRECTION_PERCENT_MAX) / 100);  
7.   if(wanted_size < min_size)   
8.   {  
9.     wanted_size = min_size;  
10.   }   
11.   else if (wanted_size > max_size)   
12.   {  
13.     wanted_size = max_size;  
14.   }  

记住audio_length * (sample_rate * # of channels * 2)就是audio_length秒时间的声音的样本数。所以，我们想要的样本数就是我们根据声音偏移添加或者减少后的声音样本数。我们也可以设置一个范围来限定我们一次进行修正的长度，因为如果我们改变的太多，用户会听到刺耳的声音。

修正样本数

现在我们要真正的修正一下声音。你可能会注意到我们的同步函数synchronize_audio返回了一个样本数，这可以告诉我们有多少个字节被送到流 中。所以我们只要调整样本数为wanted_size就可以了。这会让样本更小一些。但是如果我们想让它变大，我们不能只是让样本大小变大，因为在缓冲区 中没有多余的数据！所以我们必需添加上去。但是我们怎样来添加呢？最笨的办法就是试着来推算声音，所以让我们用已有的数据在缓冲的末尾添加上最后的样本。

[cpp]  view plain  copy

 print ?

1. if(wanted_size < samples_size)   
2. {  
3.   /* remove samples */  
4.   samples_size = wanted_size;  
5. }  
6.  else if(wanted_size > samples_size)   
7.  {  
8.     uint8_t *samples_end, *q;  
9.     int nb;  
10.   
11.     /* add samples by copying final sample*/  
12.     nb = (samples_size - wanted_size);  
13.     samples_end = (uint8_t *)samples + samples_size - n;  
14.     q = samples_end + n;  
15.     printf(".......%d\n",nb );  
16.     while(nb > 0) //No carry  
17.     {  
18.       //printf("-----%d------\n",nb );  
19.       memcpy(q, samples_end, n);  
20.       q += n;  
21.       nb -= n;  
22.     }  
23.     samples_size = wanted_size;  
24.   }  

现在我们通过这个函数返回的是样本数。我们现在要做的是使用它：

[cpp]  view plain  copy

 print ?

1. void audio_callback(void *userdata, Uint8 *stream, int len)   
2. {  
3.   
4.   VideoState *is = (VideoState *)userdata;  
5.   int len1, audio_size;  
6.   double pts;  
7.   
8.   while(len > 0)   
9.   {  
10.     if(is->audio_buf_index >= is->audio_buf_size)   
11.     {  
12.       /* We have already sent all our data; get more */  
13.       audio_size = audio_decode_frame(is, &pts);  
14.       if(audio_size < 0)   
15.       {  
16.         /* If error, output silence */  
17.         is->audio_buf_size = 1024;  
18.         memset(is->audio_buf, 0, is->audio_buf_size);  
19.       }   
20.       else   
21.       {  
22.         audio_size = synchronize_audio(is, (int16_t *)is->audio_buf,audio_size, pts);  
23.         is->audio_buf_size = audio_size;  
24.       }  

我们要做的是把函数synchronize_audio插入进去。（同时，保证在初始化上面变量的时候检查一下代码，这些我没有赘述）。

结束之前的最后一件事情：我们需要添加一个if语句来保证我们不会在视频为主时钟的时候也来同步视频。

[cpp]  view plain  copy

 print ?

1. /* update delay to sync to audio if not master source */  
2. if(is->av_sync_type != AV_SYNC_VIDEO_MASTER)   
3. {  
4.   ref_clock = get_master_clock(is);  
5.   diff = vp->pts - ref_clock;  
6.   
7.   /* Skip or repeat the frame. Take delay into account 
8.   FFPlay still doesn't "know if this is the best guess." */  
9.   sync_threshold = (delay > AV_SYNC_THRESHOLD) ? delay : AV_SYNC_THRESHOLD;  
10.   if(fabs(diff) < AV_NOSYNC_THRESHOLD)   
11.   {  
12.     if(diff <= -sync_threshold)   
13.     {  
14.       delay = 0;  
15.     }   
16.     else if(diff >= sync_threshold)   
17.     {  
18.       delay = 2 * delay;  
19.     }  
20.   }  
21. }  

添加后就可以了。要保证整个程序中我没有赘述的变量都被初始化过了。然后编译它：

[plain]  view plain  copy

 print ?

1. gcc ./tutorial06-1.c -o ./tutorial06-1 -lavutil -lavformat -lavcodec -lswscale -lz -lm `sdl-config --cflags --libs`   
2. -I /home/Jiakun/ffmpeg_build/include/ -L /home/Jiakun/ffmpeg_build/lib/ -I /usr/include/SDL/  

然后你就可以运行它了。

下次我们要做的是让你可以让电影快退和快进。