文章目录
- 1. 音视频同步基础
- 1.1 音视频同步策略
- 1.2 音视频同步概念
- 1.3 FFmpeg中的时间单位
- 1.4 不同结构体的time_base/duration分析
- 1.5 不同结构体的pts/dts分析
- 1.6 ffplay中Frame结构体分析
- 1.7 Vidoe Frame PTS获取及矫正
- 1.8 Audio Frame PTS的获取
- 2.以音频为基准
- 3.以视频为基准
- 3.1 音频主流程
- 4.以外部时钟为基准
- 总结
1. 音视频同步基础
视频和音频是不同的线程,并且也不会同时解出同一个pts的音视频帧,因此需要音视频同步;
1.1 音视频同步策略
- 以音频为基准
- 视频慢了则丢掉部分视频帧(视觉感受就是掉帧)
- 视频快了就继续渲染上一帧
- 以视频为基准
- 音频慢了则加速播放(或者丢帧,丢帧会断音,体验感特别差)
- 音频快了就放慢数据点(或者重复上一帧)
- 改变音频速度时涉及到重采样
- 以外部时钟为基准
- 综合1 2,根据外部时钟改变播放速度
- 视频和音频各种输出,不做同步处理(一般不会这样)
由于人对听觉变化比对视觉变化更加强烈,因此一般选择同步策略时经常采用以音频为基准!
1.2 音视频同步概念
- DTS(Decoding Time Stamp):解码时间戳,是告诉播放器什么时候解码这一帧数据的
- PTS(Presentation Time Stamp):显示时间戳,是告诉播放器什么时候播放这一帧数据
- time_base时基:就是FFmpeg采用的单位而已
如果视频中没有B帧的话,那么DTS和PTS顺序就一样
time_base 结构为:
typedef struct AVRational
int num; ///< 分子
int den; ///< 分母
} AVRational;
计算时间戳:
timestame(秒)=pts*av_qtd(st->time_base)
计算帧时长:
time(秒)=duration*av_qtd(st->time_base)
不同时间基转换:
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
音视频同步的时候需要一个"时钟"的概念,音频,视频,外部时钟都有自己的时钟,各种set自己的时钟,以谁为基准,get时钟的时候就是谁
typedef struct Clock {
double pts; // 时钟基础, 当前帧(待播放)显示时间戳，播放后，当前帧变成上一帧
// 当前pts与当前系统时钟的差值, audio、video对于该值是独立的
double pts_drift; // clock base minus time at which we updated the clock
// 当前时钟(如视频时钟)最后一次更新时间，也可称当前时钟时间
double last_updated; // 最后一次更新的系统时钟
double speed; // 时钟速度控制，用于控制播放速度
// 播放序列，所谓播放序列就是一段连续的播放动作，一个seek操作会启动一段新的播放序列
int serial; // clock is based on a packet with this serial
int paused; // = 1 说明是暂停状态
// 指向packet_serial
int *queue_serial; //指向当前数据包队列串行的指针，用于过时时钟检测
} Clock;
时钟的工作原理:
-
需要不停地调用set_clock_at进行"对时",需要pts,serial,time(系统时间)
-
获取的时间也是一个估算值,估算是通过"对时"的pts_drift估算的.
图中的时间轴是按照time递增的,我们调用set_Clock进行一次对时间,假设pts是落后于time的那么pts_drift=pts-time,计算出pts和time的差值
过一会需要get_clock来获取pts,那么就可以通过刚刚的差值pts_drift和time推算出来,pts=time+pts_drift,time可以通过ffmpeg提供的av_gettime_relative函数来获取
1.3 FFmpeg中的时间单位
AV_TIME_BASE
- #define AV_TIME_BASE 1000000
- FFmpeg内部计时单位
AV_TIME_BASE_Q
- #define AV_TIME_BASE_Q (AVRational){1, AV_TIME_BASE}
- FFmpeg内部时间基的分数表示,就是AV_TIME_BASE的倒数
时间基转换公式
- timestamp(FFmpeg内部时间戳)=AV_TIME_BASE*time(秒)
- time(秒)=timestamp*AV_TIME_BASE_Q
1.4 不同结构体的time_base/duration分析
FFmpeg存在很多时间基,对应着不同的结构体,每一个时间基的值都不一样
-
AVFormatContext
- duration:代表着整个码流的时间长,获取正常时长时需要除以AV_TIME_BASE,获得结果为秒
-
AVStream
- time_base:单位为秒,比如AAC音频可能是{1,44100},TS流按{1,90KHZ}
- duration:表示数据流的时长,单位为AVStream->time_base
-
AVStream的time_base是在dumuxer或者muxer中设置的
TS
- avpriv_set_pts_info(st,33,1,90000)
FLV
- avpriv_set_pts_info(st,32,1,10000)
MP4
- avpriv_set_pts_info(st,64,1,sc->time_scale)
- avpriv_set_pts_info(st,64,1,track->timescale)
1.5 不同结构体的pts/dts分析
AVPacket和AVFrame时间上都是来自于AVStream->time_base
这里重点说一下编码时各个流的time_base是avformat_write_header后设置的,具体源码暂不分析,但是各位别陷入编码时不知道time_base是怎么来的!
1.6 ffplay中Frame结构体分析
typedef struct Frame {
AVFrame *frame; // 指向数据帧
AVSubtitle sub; // 用于字幕
int serial; // 帧序列，在seek的操作时serial会变化
double pts; // 时间戳，单位为秒
double duration; // 该帧持续时间，单位为秒
int64_t pos; // 该帧在输入文件中的字节位置
int width; // 图像宽度
int height; // 图像高读
int format; // 对于图像为(enum AVPixelFormat)，
// 对于声音则为(enum AVSampleFormat)
AVRational sar; // 图像的宽高比（16:9，4:3...），如果未知或未指定则为0/1
int uploaded; // 用来记录该帧是否已经显示过？
int flip_v; // =1则垂直翻转， = 0则正常播放
} Frame;
为什么Frame结构体中的pts和duration是double类型?
因为我们在写入帧的时候对pts和duration进行了转换,具体实现在queue_picture函数中,因此此时的pts和duration单位应该为秒!
1.7 Vidoe Frame PTS获取及矫正
pts矫正
frame->pts=frame->best_effort_timestamp;
/**
*使用各种启发式估计的帧时间戳，以流时基为单位
*-编码：未使用
*-解码：由libavcodec设置，由用户读取。
*/
int64_t best_effort_timestamp;
对frame的pts进行矫正,具体矫正算法由libavcodec设置,帧时间戳，基本与 pts 相同，如果当前 pts 存在不合理值，会尝试进行一系列校准来得到这个更合理的值.
1.8 Audio Frame PTS的获取
ffplay有3次pts转换
-
由AVStream->time_base转为{1,采样率}
我认为应该是重采样导致采样率改变,如果还使用AVStream->time_base就会出错!
frame->pts = av_rescale_q(frame->pts, d->avctx->pkt_timebase, tb); -
将采样率转化为秒,就是queue_picture放入帧队列时需要
af->pts = (frame->pts == AV_NOPTS_VALUE) ? NAN : frame->pts * av_q2d(tb); -
根据拷贝给SDL的数据量进行估算调整
set_clock_at(&is->audclk, is->audio_clock - (double)(2 * is->audio_hw_buf_size + is->audio_write_buf_size) / is->audio_tgt.bytes_per_sec, is->audio_clock_serial, audio_callback_time / 1000000.0);
2.以音频为基准
ffplay默认采用音频同步模式,而音频同步模式的时钟设置设置在sdl_audio_callback中
static void sdl_audio_callback(void *opaque, Uint8 *stream, int len)
{
audio_callback_time = av_gettime_relative(); // while可能产生延迟
.............................................
is->audio_write_buf_size = is->audio_buf_size - is->audio_buf_index;
/* Let's assume the audio driver that is used by SDL has two periods. */
if (!isnan(is->audio_clock)) {
set_clock_at(&is->audclk, is->audio_clock -
(double)(2 * is->audio_hw_buf_size + is->audio_write_buf_size)
/ is->audio_tgt.bytes_per_sec,
is->audio_clock_serial,
audio_callback_time / 1000000.0);
sync_clock_to_slave(&is->extclk, &is->audclk);
}
}
这块和我之前分析的视频播放线程里面是一样的可以看看
下面的流程是视频播放的主流程,也可以看看之前的讲解
![]](https://img-blog.csdnimg.cn/9ca17c23e75a4ca381fe99a64ed7fbc9.png)
重点就是计算上一帧显示时长比较重要,看一下代码:
static void video_refresh(void *opaque, double *remaining_time)
{
VideoState *is = opaque;
double time;
Frame *sp, *sp2;
if (!is->paused && get_master_sync_type(is) == AV_SYNC_EXTERNAL_CLOCK && is->realtime)
check_external_clock_speed(is);
if (!display_disable && is->show_mode != SHOW_MODE_VIDEO && is->audio_st) {
time = av_gettime_relative() / 1000000.0;
if (is->force_refresh || is->last_vis_time + rdftspeed < time) {
video_display(is);
is->last_vis_time = time;
}
*remaining_time = FFMIN(*remaining_time, is->last_vis_time + rdftspeed - time);
}
if (is->video_st) {
retry:
if (frame_queue_nb_remaining(&is->pictq) == 0) {// 帧队列是否为空
// nothing to do, no picture to display in the queue
// 什么都不做，队列中没有图像可显示
} else { // 重点是音视频同步
double last_duration, duration, delay;
Frame *vp, *lastvp;
/* dequeue the picture */
// 从队列取出上一个Frame
lastvp = frame_queue_peek_last(&is->pictq);//读取上一帧
vp = frame_queue_peek(&is->pictq); // 读取待显示帧
// lastvp 上一帧(正在显示的帧)
// vp 等待显示的帧
if (vp->serial != is->videoq.serial) {
// 如果不是最新的播放序列，则将其出队列，以尽快读取最新序列的帧
frame_queue_next(&is->pictq);
goto retry;
}
if (lastvp->serial != vp->serial) {
// 新的播放序列重置当前时间
is->frame_timer = av_gettime_relative() / 1000000.0;
}
if (is->paused)
{
goto display;
printf("视频暂停is->paused");
}
/* compute nominal last_duration */
//lastvp上一帧，vp当前帧 ，nextvp下一帧
//last_duration 计算上一帧应显示的时长
last_duration = vp_duration(is, lastvp, vp);
// 经过compute_target_delay方法，计算出待显示帧vp需要等待的时间
// 如果以video同步，则delay直接等于last_duration。
// 如果以audio或外部时钟同步，则需要比对主时钟调整待显示帧vp要等待的时间。
delay = compute_target_delay(last_duration, is); // 上一帧需要维持的时间
time= av_gettime_relative()/1000000.0;
// is->frame_timer 实际上就是上一帧lastvp的播放时间,
// is->frame_timer + delay 是待显示帧vp该播放的时间
if (time < is->frame_timer + delay) { //判断是否继续显示上一帧
// 当前系统时刻还未到达上一帧的结束时刻，那么还应该继续显示上一帧。
// 计算出最小等待时间
*remaining_time = FFMIN(is->frame_timer + delay - time, *remaining_time);
goto display;
}
// 走到这一步，说明已经到了或过了该显示的时间，待显示帧vp的状态变更为当前要显示的帧
is->frame_timer += delay; // 更新当前帧播放的时间
if (delay > 0 && time - is->frame_timer > AV_SYNC_THRESHOLD_MAX) {
is->frame_timer = time; //如果和系统时间差距太大，就纠正为系统时间
}
SDL_LockMutex(is->pictq.mutex);
if (!isnan(vp->pts))
update_video_pts(is, vp->pts, vp->pos, vp->serial); // 更新video时钟
SDL_UnlockMutex(is->pictq.mutex);
//丢帧逻辑
if (frame_queue_nb_remaining(&is->pictq) > 1) {//有nextvp才会检测是否该丢帧
Frame *nextvp = frame_queue_peek_next(&is->pictq);
duration = vp_duration(is, vp, nextvp);
if(!is->step // 非逐帧模式才检测是否需要丢帧 is->step==1 为逐帧播放
&& (framedrop>0 || // cpu解帧过慢
(framedrop && get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER)) // 非视频同步方式
&& time > is->frame_timer + duration // 确实落后了一帧数据
) {
printf("%s(%d) dif:%lfs, drop frame\n", __FUNCTION__, __LINE__,
(is->frame_timer + duration) - time);
is->frame_drops_late++; // 统计丢帧情况
frame_queue_next(&is->pictq); // 这里实现真正的丢帧
//(这里不能直接while丢帧，因为很可能audio clock重新对时了，这样delay值需要重新计算)
goto retry; //回到函数开始位置，继续重试
}
}
........
}
重点看一下delay = compute_target_delay(last_duration, is);
static double compute_target_delay(double delay, VideoState *is)
{
double sync_threshold, diff = 0;
/* update delay to follow master synchronisation source */
/* 如果发现当前主Clock源不是video，则计算当前视频时钟与主时钟的差值 */
if (get_master_sync_type(is) != AV_SYNC_VIDEO_MASTER) {
/* if video is slave, we try to correct big delays by
duplicating or deleting a frame
通过重复帧或者删除帧来纠正延迟*/
diff = get_clock(&is->vidclk) - get_master_clock(is);
/* skip or repeat frame. We take into account the
delay to compute the threshold. I still don't know
if it is the best guess */
sync_threshold = FFMAX(AV_SYNC_THRESHOLD_MIN,
FFMIN(AV_SYNC_THRESHOLD_MAX, delay));
if (!isnan(diff) && fabs(diff) < is->max_frame_duration) { // diff在最大帧duration内
if (diff <= -sync_threshold) { // 视频已经落后了
delay = FFMAX(0, delay + diff); // 上一帧持续的时间往小的方向去调整
}
else if (diff >= sync_threshold && delay > AV_SYNC_FRAMEDUP_THRESHOLD) {
// delay = 0.2秒
// diff = 1秒
// delay = 0.2 + 1 = 1.2
// 视频超前
//AV_SYNC_FRAMEDUP_THRESHOLD是0.1，此时如果delay>0.1, 如果2*delay时间就有点久
delay = delay + diff; // 上一帧持续时间往大的方向去调整
av_log(NULL, AV_LOG_INFO, "video: delay=%0.3f A-V=%f\n",
delay, -diff);
}
else if (diff >= sync_threshold) {
// 上一帧持续时间往大的方向去调整
// delay = 0.2 *2 = 0.4
delay = 2 * delay; // 保持在 2 * AV_SYNC_FRAMEDUP_THRESHOLD内, 即是2*0.1 = 0.2秒内
// delay = delay + diff; // 上一帧持续时间往大的方向去调整
} else {
// 音视频同步精度在 -sync_threshold ~ +sync_threshold
// 其他条件就是 delay = delay; 维持原来的delay, 依靠frame_timer+duration和当前时间进行对比
}
}
} else {
// 如果是以video为同步，则直接返回last_duration
}
av_log(NULL, AV_LOG_TRACE, "video: delay=%0.3f A-V=%f\n",
这个 delay, -diff);
return delay;
}
这个函数通过视频时钟和音频时钟计算的差值和delay进行比较来确定delay的值为多少
步骤:
-
计算diff,就是用视频的时钟-音频的时钟的值
-
sync_threshold是delay在AV_SYNC_THRESHOLD_MIN和AV_SYNC_THRESHOLD_MIN范围类的值,计算方法为:
sync_threshold = FFMAX(AV_SYNC_THRESHOLD_MIN, FFMIN(AV_SYNC_THRESHOLD_MAX, delay)); -
如果diff这个差值比设置的max_frame_duration还大的话,就直接 delay不需要做调整了,直接 返回出去有外部决定丢帧还是继续上一帧
-
diff小于max_frame_duration,那么我们就要对delay作出调整,因为播放时间不能总固定为duration,而是更具实际误差来决定的,比如说音频比视频快半帧,那么视频这个播放时间就不能太久,得缩短,如果慢半帧的话,视频播放时间得延长
-
if (diff <= -sync_threshold) { // 视频已经落后了 delay = FFMAX(0, delay + diff); // 上一帧持续的时间往小的方向去调整 } else if (diff >= sync_threshold && delay > AV_SYNC_FRAMEDUP_THRESHOLD) { // delay = 0.2秒 // diff = 1秒 // delay = 0.2 + 1 = 1.2 // 视频超前 //AV_SYNC_FRAMEDUP_THRESHOLD是0.1，此时如果delay>0.1, 如果2*delay时间就有点久 delay = delay + diff; // 上一帧持续时间往大的方向去调整 av_log(NULL, AV_LOG_INFO, "video: delay=%0.3f A-V=%f\n", delay, -diff); } else if (diff >= sync_threshold) { // 上一帧持续时间往大的方向去调整 // delay = 0.2 *2 = 0.4 delay = 2 * delay; // 保持在 2 * AV_SYNC_FRAMEDUP_THRESHOLD内, 即是2*0.1 = 0.2秒内 // delay = delay + diff; // 上一帧持续时间往大的方向去调整 } else { // 音视频同步精度在 -sync_threshold ~ +sync_threshold // 其他条件就是 delay = delay; 维持原来的delay, 依靠frame_timer+duration和当前时间进行对比 }-
第一个if (diff <= -sync_threshold)
是说视频落后了,这个时候的diff是负数,那么delay就应该变小,采取的是delay = FFMAX(0, delay + diff);毕竟不能为0
-
第二个if (diff >= sync_threshold && delay > AV_SYNC_FRAMEDUP_THRESHOLD)
是说视频快于音频了,并且显示时间大于AV_SYNC_FRAMEDUP_THRESHOLD,那么采取的措施是延长delay = delay + diff;
-
第三个if (diff >= sync_threshold)就是快于音频,并且显示时间小于AV_SYNC_FRAMEDUP_THRESHOLD,采取的措施就是 delay = 2 * delay
-
3.以视频为基准
媒体流里面只有视频成分时,才会使用以视频为基准!
在以音频为基准时采用的是丢帧或者是等待的策略,而以视频为基准时就不能简单的丢帧处理了,因为人对声音非常敏感,一旦断音了非常容易感觉的到!
3.1 音频主流程
音频同步策略就是重采样,改变一帧的样本数从而实现变速效果,如果音频慢了就减少样本数,如果音频快了就增加样本数
具体实现看audio_decode_frame:
static int audio_decode_frame(VideoState *is)
{
int data_size, resampled_data_size;
int64_t dec_channel_layout;
av_unused double audio_clock0;
int wanted_nb_samples;
Frame *af;
if (is->paused)
return -1;
do {
// 若队列头部可读，则由af指向可读帧
if (!(af = frame_queue_peek_readable(&is->sampq)))
return -1;
frame_queue_next(&is->sampq);
} while (af->serial != is->audioq.serial);
// 根据frame中指定的音频参数获取缓冲区的大小 af->frame->channels * af->frame->nb_samples * 2
data_size = av_samples_get_buffer_size(NULL,
af->frame->channels,
af->frame->nb_samples,
af->frame->format, 1);
// 获取声道布局
dec_channel_layout =
(af->frame->channel_layout &&
af->frame->channels == av_get_channel_layout_nb_channels(af->frame->channel_layout)) ?
af->frame->channel_layout : av_get_default_channel_layout(af->frame->channels);
// 获取样本数校正值：若同步时钟是音频，则不调整样本数；否则根据同步需要调整样本数
wanted_nb_samples = synchronize_audio(is, af->frame->nb_samples);
// is->audio_tgt是SDL可接受的音频帧数，是audio_open()中取得的参数
// 在audio_open()函数中又有"is->audio_src = is->audio_tgt""
// 此处表示：如果frame中的音频参数 == is->audio_src == is->audio_tgt，
// 那音频重采样的过程就免了(因此时is->swr_ctr是NULL)
// 否则使用frame(源)和is->audio_tgt(目标)中的音频参数来设置is->swr_ctx，
// 并使用frame中的音频参数来赋值is->audio_src
if (af->frame->format != is->audio_src.fmt || // 采样格式
dec_channel_layout != is->audio_src.channel_layout || // 通道布局
af->frame->sample_rate != is->audio_src.freq || // 采样率
// 第4个条件, 要改变样本数量, 那就是需要初始化重采样
(wanted_nb_samples != af->frame->nb_samples && !is->swr_ctx) // samples不同且swr_ctx没有初始化
) {
swr_free(&is->swr_ctx);
is->swr_ctx = swr_alloc_set_opts(NULL,
is->audio_tgt.channel_layout, // 目标输出
is->audio_tgt.fmt,
is->audio_tgt.freq,
dec_channel_layout, // 数据源
af->frame->format,
af->frame->sample_rate,
0, NULL);
if (!is->swr_ctx || swr_init(is->swr_ctx) < 0) {
av_log(NULL, AV_LOG_ERROR,
"Cannot create sample rate converter for conversion of %d Hz %s %d channels to %d Hz %s %d channels!\n",
af->frame->sample_rate, av_get_sample_fmt_name(af->frame->format), af->frame->channels,
is->audio_tgt.freq, av_get_sample_fmt_name(is->audio_tgt.fmt), is->audio_tgt.channels);
swr_free(&is->swr_ctx);
return -1;
}
is->audio_src.channel_layout = dec_channel_layout;
is->audio_src.channels = af->frame->channels;
is->audio_src.freq = af->frame->sample_rate;
is->audio_src.fmt = af->frame->format;
}
if (is->swr_ctx) {
// 重采样输入参数1：输入音频样本数是af->frame->nb_samples
// 重采样输入参数2：输入音频缓冲区
const uint8_t **in = (const uint8_t **)af->frame->extended_data; // data[0] data[1]
// 重采样输出参数1：输出音频缓冲区尺寸
uint8_t **out = &is->audio_buf1; //真正分配缓存audio_buf1，指向是用audio_buf
// 重采样输出参数2：输出音频缓冲区
int out_count = (int64_t)wanted_nb_samples * is->audio_tgt.freq / af->frame->sample_rate
+ 256;
int out_size = av_samples_get_buffer_size(NULL, is->audio_tgt.channels,
out_count, is->audio_tgt.fmt, 0);
int len2;
if (out_size < 0) {
av_log(NULL, AV_LOG_ERROR, "av_samples_get_buffer_size() failed\n");
return -1;
}
// 如果frame中的样本数经过校正，则条件成立
if (wanted_nb_samples != af->frame->nb_samples) {
int sample_delta = (wanted_nb_samples - af->frame->nb_samples) * is->audio_tgt.freq
/ af->frame->sample_rate;
int compensation_distance = wanted_nb_samples * is->audio_tgt.freq / af->frame->sample_rate;
// swr_set_compensation
if (swr_set_compensation(is->swr_ctx,
sample_delta,
compensation_distance) < 0) {
av_log(NULL, AV_LOG_ERROR, "swr_set_compensation() failed\n");
return -1;
}
}
av_fast_malloc(&is->audio_buf1, &is->audio_buf1_size, out_size);
if (!is->audio_buf1)
return AVERROR(ENOMEM);
// 音频重采样：返回值是重采样后得到的音频数据中单个声道的样本数
len2 = swr_convert(is->swr_ctx, out, out_count, in, af->frame->nb_samples);
if (len2 < 0) {
av_log(NULL, AV_LOG_ERROR, "swr_convert() failed\n");
return -1;
}
if (len2 == out_count) {
av_log(NULL, AV_LOG_WARNING, "audio buffer is probably too small\n");
if (swr_init(is->swr_ctx) < 0)
swr_free(&is->swr_ctx);
}
// 重采样返回的一帧音频数据大小(以字节为单位)
is->audio_buf = is->audio_buf1;
resampled_data_size = len2 * is->audio_tgt.channels * av_get_bytes_per_sample(is->audio_tgt.fmt);
} else {
// 未经重采样，则将指针指向frame中的音频数据
is->audio_buf = af->frame->data[0]; // s16交错模式data[0], fltp data[0] data[1]
resampled_data_size = data_size;
}
audio_clock0 = is->audio_clock;
/* update the audio clock with the pts */
if (!isnan(af->pts))
is->audio_clock = af->pts + (double) af->frame->nb_samples / af->frame->sample_rate;
else
is->audio_clock = NAN;
is->audio_clock_serial = af->serial;
return resampled_data_size;
}
这里重点讲解一下如何计算wanted_nb_samples这个值,分析一下synchronize_audio函数:
static int synchronize_audio(VideoState *is, int nb_samples)
{
int wanted_nb_samples = nb_samples;
/* if not master, then we try to remove or add samples to correct the clock */
if (get_master_sync_type(is) != AV_SYNC_AUDIO_MASTER) {//不是以音频为基准时
double diff, avg_diff;
int min_nb_samples, max_nb_samples;
diff = get_clock(&is->audclk) - get_master_clock(is);//过去音频和默认时钟的差值
if (!isnan(diff) && fabs(diff) < AV_NOSYNC_THRESHOLD) {//如果差值大于AV_NOSYNC_THRESHOLD则正常播放,不做任何处理,一般这种情况就出现错误了
is->audio_diff_cum = diff + is->audio_diff_avg_coef * is->audio_diff_cum;
if (is->audio_diff_avg_count < AUDIO_DIFF_AVG_NB) {
/* not enough measures to have a correct estimate */
is->audio_diff_avg_count++; // 连续20次不同步才进行校正
} else {
/* estimate the A-V difference */
avg_diff = is->audio_diff_cum * (1.0 - is->audio_diff_avg_coef);
// avg_diff = diff;
if (fabs(avg_diff) >= is->audio_diff_threshold) {
wanted_nb_samples = nb_samples + (int)(diff * is->audio_src.freq);
min_nb_samples = ((nb_samples * (100 - SAMPLE_CORRECTION_PERCENT_MAX) / 100));
max_nb_samples = ((nb_samples * (100 + SAMPLE_CORRECTION_PERCENT_MAX) / 100));
// av_clip 用来限制wanted_nb_samples最终落在 min_nb_samples~max_nb_samples
// nb_samples *（90%~110%）
wanted_nb_samples = av_clip(wanted_nb_samples, min_nb_samples, max_nb_samples);
}
av_log(NULL, AV_LOG_INFO, "diff=%f adiff=%f sample_diff=%d apts=%0.3f %f\n",
diff, avg_diff, wanted_nb_samples - nb_samples,
is->audio_clock, is->audio_diff_threshold);
}
} else {
// > AV_NOSYNC_THRESHOLD 阈值，该干嘛就干嘛
/* too big difference : may be initial PTS errors, so
reset A-V filter */
is->audio_diff_avg_count = 0;
is->audio_diff_cum = 0; // 恢复正常后重置为0
}
}
return wanted_nb_samples;
}
代码中的audio_diff_cum是计算加权总和
我们先看一下audio_diff_avg_coef是什么?
is->audio_diff_avg_coef = exp(log(0.01) / AUDIO_DIFF_AVG_NB)//exp 自然常数
这个值是固定的,在计算加权总和时也就是一个固定比例
仔细分析一下:s->audio_diff_cum = diff + is->audio_diff_avg_coef * is->audio_diff_cum;
这个数最后会循环AUDIO_DIFF_AVG_NB次,得到加权总和,
而avg_diff = is->audio_diff_cum * (1.0 - is->audio_diff_avg_coef);
是加权总和/权重和得到的结果avg_diff,后面使用avg_diff作为差值比较
is->audio_diff_threshold = (double)(is->audio_hw_buf_size) / is->audio_tgt.bytes_per_sec;
这个值是计算差值的阀值时间为多少,如果大于这个值就要进行同步~
同步算法很简单
通过diff*采样率得到差值的样本数量
wanted_nb_samples = nb_samples + (int)(diff * is->audio_src.freq);//获取想要的样本数
min_nb_samples = ((nb_samples * (100 - SAMPLE_CORRECTION_PERCENT_MAX) / 100));//样本数减少10%的样本数
max_nb_samples = ((nb_samples * (100 + SAMPLE_CORRECTION_PERCENT_MAX) / 100));//样本数增加10%的样本数
// av_clip 用来限制wanted_nb_samples最终落在 min_nb_samples~max_nb_samples
// nb_samples *（90%~110%）
wanted_nb_samples = av_clip(wanted_nb_samples, min_nb_samples, max_nb_samples);//av_clip就是取中间值,如果大于max就取max,小于min就取min,反正就是将wanted_nb_samples保证在nb_samples *（90%~110%）
然后到达audio_decode_frame会进行重采样,重采样直接会调用swr_set_compensation是样本补偿函数!
4.以外部时钟为基准
外部时钟就是基于前两种时钟的
通过sync_clock_to_slave函数进行设置
static void sync_clock_to_slave(Clock *c, Clock *slave)
{
double clock = get_clock(c);
double slave_clock = get_clock(slave);
if (!isnan(slave_clock) && (isnan(clock) || fabs(clock - slave_clock) > AV_NOSYNC_THRESHOLD))
set_clock(c, slave_clock, slave->serial);
}
这里的c是外部时钟,slave是其他时钟,可以看出当其他时钟被设置,并且外部时钟没有设置的时候或者是都设置了但是相差大于了AV_NOSYNC_THRESHOLD就要重新设置.
因此可以看出基本上外部时钟只会设置一次,具体设置是看第一帧是音频还是视频,用他们的时钟进行设置即可
总结
具体以什么为基准时就是看你设置的参数,然后通过get_master_clock来获取主时钟,因此3大时钟都会 设置!!!
各个时钟设置位置:
音频时钟是:
set_clock_at(&is->audclk, is->audio_clock -
(double)(2 * is->audio_hw_buf_size + is->audio_write_buf_size)
/ is->audio_tgt.bytes_per_sec,
is->audio_clock_serial,
audio_callback_time / 1000000.0);
视频时钟是:
if (!isnan(vp->pts))
update_video_pts(is, vp->pts, vp->pos, vp->serial);
外部时钟是:
音频时钟设置的下面部分:
set_clock_at(&is->audclk, is->audio_clock -
(double)(2 * is->audio_hw_buf_size + is->audio_write_buf_size)
/ is->audio_tgt.bytes_per_sec,
is->audio_clock_serial,
audio_callback_time / 1000000.0);
sync_clock_to_slave(&is->extclk, &is->audclk);
还有一个是视频时钟设置的update_video_pts函数中:
static void update_video_pts(VideoState *is, double pts, int64_t pos, int serial) {
/* update current video pts */
set_clock(&is->vidclk, pts, serial);
sync_clock_to_slave(&is->extclk, &is->vidclk);
}
