C语言将音视频时钟同步封装成通用模块的方法

//视频时钟起点，单位秒
double videoStartTime=0;

//更新视频时钟（或者说矫正更准确）起点，pts为当前视频帧的时间戳，getCurrentTime为获取当前系统时钟的时间，单位秒
videoStartTime=getCurrentTime()-pts;

//获取视频时钟，单位秒
double videoTime=getCurrentTime()-videoStartTime;

/// 

/// 同步视频时钟
/// 视频帧显示前调用此方法，传入帧的pts和duration，根据此方法的返回值确定显示还是丢帧或者延时。
/// 
/// 视频帧pts,单位为s
/// 视频帧时长,单位为s。
/// 大于0则延时,值为延时时长,单位s。等于0显示。小于0丢帧
double synVideo(double pts, double duration)
{
	if (videoStartTime== 0)
	//初始化视频起点
	{
		videoStartTime= getCurrentTime() - pts;
	}
	//以下变量时间单位为s	
	//获取视频时钟
	double currentTime = getCurrentTime() - videoStartTime;
	//计算时间差,大于0则late，小于0则early。
	double diff = currentTime - pts;
	//时间早了延时
	if (diff < -0.001)
	{
		if (diff < -0.1)
		{
			diff = -0.1;
		}
		return -diff;
	}
	//时间晚了丢帧，duration为一帧的持续时间，在一个duration内是正常时间，加一个duration作为阈值来判断丢帧。
	if (diff > 2 * duration)
	{
		return -1;
	}
	//更新视频时钟起点
	videoStartTime= getCurrentTime() - pts;
	return 0;
}

//计算时间差,大于0则late，小于0则early。
double diff = currentTime - pts;
//同步到另一个时钟-start	
double sDiff = 0;
//anotherStartTime为另一个时钟的起始时间
sDiff = videoStartTime - anotherStartTime;
diff += sDiff;
//同步到另一个时钟-end
//时间早了延时
if (diff < -0.001)

//声道数
int channels=2;
//采样率
int samplerate=48000;
//位深
int bitsPerSample=32;
//数据长度
int dataSize=8192;
//时长，单位秒
double duration=(double)dataSize/(channels*samplerate*bitsPerSample/8);
//duration 值为：0.0426666...

//采样数
int samples=1024;
//采样率
int samplerate=48000;
//时长，单位秒
double duration=(double)samples/samplerate;
//duration值为0.021333333...

//音频时钟起点，单位秒
double audioStartTime=0;
//音频时间戳，单位秒
double currentPts=0;

//计算时间戳，samples为当前播放的采样数
currentPts += (double)samples / samplerate;
//计算音频起始时间
audioStartTime= getCurrentTime() - currentPts;

currentPts += (double)bytesSize / (channels *samplerate *bitsPerSample/8);
//计算音频起始时间
audioStartTime= getCurrentTime() - currentPts;

//获取音频时钟，单位秒
double audioTime= getCurrentTime() - audioStartTime;

/// 

/// 更新音频时钟
/// 
/// 采样数
/// 采样率
/// 应该播放的采样数
int synAudio(int samples, int samplerate) {
	currentPts += (double)samples / samplerate;
	//getCurrentTime为获取当前系统时钟的时间
	audioStartTime= getCurrentTime() - currentPts;
	return samples;
}
/// 

/// 更新音频时钟，通过数据长度
/// 
/// 数据长度
/// 采样率
/// 声道数
/// 位深
/// 应该播放的采样数
int synAudioByBytesSize(size_t bytesSize, int samplerate, int channels, int bitsPerSample) {
	return synAudio((double)bytesSize / (channels * bitsPerSample/8), samplerate) * (bitsPerSample/8)* channels;
}

//获取音频时钟当前时间
double audioTime = getCurrentTime() - audioStartTime;
double diff = 0;
//计算差值，getMasterTime获取另一个时钟的当前时间	
diff = getMasterTime(syn) - audioTime;
int oldSamples = samples;
if (fabs(diff) > 0.01)
//超过偏差阈值，加上差值对应的采样数
 {
	samples += diff * samplerate;
}
if (samples < 0)
//最小以不播放等待
{
	samples = 0;
}
if (samples > oldSamples * 2)
//最大以2倍速追赶
{
	samples = oldSamples * 2;
}
//输出samples为写入数据长度，后面音频时钟计算也以此samples为准。

/************************************************************************
* @Project:  	Synchronize
* @Decription:  视频时钟同步模块
* 这是一个通用的视频时钟同步模块，支持3种同步方式：同步到视频时钟、同步到音频时钟、以及同步到外部时钟（绝对时钟）。
* 使用方法也比较简单，初始化之后在视频显示和音频播放处调用相应方法即可。
* 非线程安全：内部实现未使用线程安全机制。对于单纯的同步一般不用线程安全机制。当需要定位时可能需要一定的互斥操作。
* 没有特殊依赖（目前版本依赖了ffmpeg的获取系统时钟功能，如果换成c++则一行代码可以实现，否则需要宏区分实现各个平台的系统时钟获取）
* @Verision:  	v1.0
* @Author:  	Xin Nie
* @Create:  	2022/9/03 14:55:00
* @LastUpdate:  2022/9/22 16:36:00
************************************************************************
* Copyright @ 2022. All rights reserved.
************************************************************************/
/// 

/// 时钟对象
/// 
typedef  struct {
	//起始时间
	double startTime;
	//当前pts
	double currentPts;
}Clock;

/// 

/// 时钟同步类型
/// 
typedef enum {
	//同步到音频
	SYNCHRONIZETYPE_AUDIO,
	//同步到视频
	SYNCHRONIZETYPE_VIDEO,
	//同步到绝对时钟
	SYNCHRONIZETYPE_ABSOLUTE
}SynchronizeType;

/// 

/// 时钟同步对象
/// 
typedef  struct {
	/// 

	/// 音频时钟
	/// 
	Clock audio;
	/// 

	/// 视频时钟
	/// 
	Clock video;
	/// 

	/// 绝对时钟
	/// 
	Clock absolute;
	/// 

	/// 时钟同步类型
	/// 
	SynchronizeType type;
	/// 

	/// 估算的视频帧时长
	/// 
	double estimateVideoDuration;
	/// 

	/// 估算视频帧数
	/// 
	double n;
}Synchronize;
/// 

/// 返回当前时间
/// 
/// 当前时间，单位秒，精度微秒
static double  getCurrentTime()
{
	//此处用的是ffmpeg的av_gettime_relative。如果没有ffmpeg环境，则可替换成平台获取时钟的方法：单位为秒，精度需要微妙，相对绝对时钟都可以。
	return av_gettime_relative() / 1000000.0;
}
/// 

/// 重置时钟同步
/// 通常用于暂停、定位
/// 
/// 时钟同步对象
void synchronize_reset(Synchronize* syn) {
	SynchronizeType type = syn->type;
	memset(syn, 0, sizeof(Synchronize));
	syn->type = type;
}
/// 

/// 获取主时钟
/// 
/// 时钟同步对象
/// 主时钟对象
Clock* synchronize_getMasterClock(Synchronize* syn) {
	switch (syn->type)
	{
	case SYNCHRONIZETYPE_AUDIO:
		return &syn->audio;
	case SYNCHRONIZETYPE_VIDEO:
		return &syn->video;
	case SYNCHRONIZETYPE_ABSOLUTE:
		return &syn->absolute;
	default:
		break;
	}
	return 0;
}
/// 

/// 获取主时钟的时间
/// 
/// 时钟同步对象
/// 时间，单位s
double synchronize_getMasterTime(Synchronize* syn) {
	return getCurrentTime() - synchronize_getMasterClock(syn)->startTime;
}
/// 

/// 设置时钟的时间
/// 
/// 时钟同步对象
/// 当前时间，单位s
void synchronize_setClockTime(Synchronize* syn, Clock* clock, double pts)
{
	clock->currentPts = pts;
	clock->startTime = getCurrentTime() - pts;
}
/// 

/// 获取时钟的时间
/// 
/// 时钟同步对象
/// 时钟对象
/// 时间，单位s
double synchronize_getClockTime(Synchronize* syn, Clock* clock)
{
	return  getCurrentTime() - clock->startTime;
}
/// 

/// 更新视频时钟
/// 
/// 时钟同步对象
/// 视频帧pts,单位为s
/// 视频帧时长,单位为s。缺省值为0，内部自动估算duration
/// 大于0则延时值为延时时长，等于0显示，小于0丢帧
double synchronize_updateVideo(Synchronize* syn, double pts, double duration)
{
	if (duration == 0)
		//估算duration
	{
		if (pts != syn->video.currentPts)
			syn->estimateVideoDuration = (syn->estimateVideoDuration * syn->n + pts - syn->video.currentPts) / (double)(syn->n + 1);
		duration = syn->estimateVideoDuration;
		//只估算最新3帧
		if (syn->n++ > 3)
			syn->estimateVideoDuration = syn->n = 0;
		if (duration == 0)
			duration = 0.1;
	}
	if (syn->video.startTime == 0)
	{
		syn->video.startTime = getCurrentTime() - pts;
	}
	//以下变量时间单位为s	
	//当前时间
	double currentTime = getCurrentTime() - syn->video.startTime;
	//计算时间差,大于0则late，小于0则early。
	double diff = currentTime - pts;
	double sDiff = 0;
	if (syn->type != SYNCHRONIZETYPE_VIDEO && synchronize_getMasterClock(syn)->startTime != 0)
		//同步到主时钟	
	{
		sDiff = syn->video.startTime - synchronize_getMasterClock(syn)->startTime;
		diff += sDiff;
	}
	//时间早了延时
	if (diff < -0.001)
	{
		if (diff < -0.1)
		{
			diff = -0.1;
		}
		return -diff;
	}
	syn->video.currentPts = pts;
	//时间晚了丢帧，duration为一帧的持续时间，在一个duration内是正常时间，加一个duration作为阈值来判断丢帧。
	if (diff > 2 * duration)
	{
		return -1;
	}
	//更新视频时钟
	printf("video-time：%.3lfs  audio-time:%.3lfs absolute-time:%.3lfs synDiff:%.4lfms diff:%.4lfms  \r", pts, getCurrentTime() - syn->audio.startTime, getCurrentTime() - syn->absolute.startTime, sDiff * 1000, diff * 1000);
	syn->video.startTime = getCurrentTime() - pts;
	if (syn->absolute.startTime == 0)
	//初始化绝对时钟
	{
		syn->absolute.startTime = syn->video.startTime;
	}
	return 0;
}

/// 

/// 更新音频时钟
/// 
/// 时钟同步对象
/// 采样数
/// 采样率
/// 应该播放的采样数
int synchronize_updateAudio(Synchronize* syn, int samples, int samplerate) {

	if (syn->type != SYNCHRONIZETYPE_AUDIO && synchronize_getMasterClock(syn)->startTime != 0)
	{
		//同步到主时钟	
		double audioTime = getCurrentTime() - syn->audio.startTime;
		double diff = 0;
		diff = synchronize_getMasterTime(syn) - audioTime;
		int oldSamples = samples;
		if (fabs(diff) > 0.01) {
			samples += diff * samplerate;
		}
		if (samples < 0)
		{
			samples = 0;
		}
		if (samples > oldSamples * 2)
		{
			samples = oldSamples * 2;
		}
	}
	syn->audio.currentPts += (double)samples / samplerate;
	syn->audio.startTime = getCurrentTime() - syn->audio.currentPts;
	if (syn->absolute.startTime == 0)
	//初始化绝对时钟
	{
		syn->absolute.startTime = syn->audio.startTime;
	}
	return samples;
}
/// 

/// 更新音频时钟，通过数据长度
/// 
/// 时钟同步对象
/// 数据长度
/// 采样率
/// 声道数
/// 位深
/// 应该播放的数据长度
int synchronize_updateAudioByBytesSize(Synchronize* syn, size_t bytesSize, int samplerate, int channels, int bitsPerSample) {
	return synchronize_updateAudio(syn, bytesSize / (channels * bitsPerSample/8), samplerate) * (bitsPerSample /8)* channels;
}

Synchronize syn;
memset(&syn,0,sizeof(Synchronize));

//同步到音频
syn->type=SYNCHRONIZETYPE_AUDIO;
//同步到视频
syn->type=SYNCHRONIZETYPE_VIDEO;
//同步到绝对时钟
syn->type=SYNCHRONIZETYPE_ABSOLUTE;

//当前帧的pts，单位s
double pts;
//当前帧的duration，单位s
double duration;
//视频同步
double delay =synchronize_updateVideo(&syn,pts，duration);
if (delay > 0)
	//延时
{
	//延时delay时长，单位s
}
else if (delay < 0)
	//丢帧
{
	
}
else
	//播放
{
	
}

//将要写入的采样数
int samples;
//音频的采样率
int samplerate;
//时钟同步,返回的samples为实际写入的采样数,将要写入的采样数不能变，实际采样数需要压缩或拓展到将要写入的采样数。
samples = synchronize_updateAudio(&syn, samples, samplerate);

//返回当前时钟，单位s。
double cursorTime=synchronize_getMasterTime(&syn);

void pause(){
//暂停逻辑
...
//重置时钟
synchronize_reset(&syn);
}

void seek(double pts){
//定位逻辑
...
//重置时钟
synchronize_reset(&syn);
}

//音频定位后第一帧的时间戳。
double pts;
synchronize_setClockTime(&syn, &syn.audio, pts);

#include
/// 

/// 返回当前时间
/// 
/// 当前时间，单位秒，精度微秒
static double  getCurrentTime()
{
	LARGE_INTEGER ticks, Frequency;
	QueryPerformanceFrequency(&Frequency);
	QueryPerformanceCounter(&ticks);
	return  (double)ticks.QuadPart / (double)Frequency.QuadPart;
}

#include
/// 

/// 返回当前时间
/// 
/// 当前时间，单位秒，精度微秒
static double  getCurrentTime()
{
	return std::chrono::time_point_cast (std::chrono::high_resolution_clock::now()).time_since_epoch().count() / 1e+9;
}