音视频开发系列（15）：视频与音频同步
Posted 初衷qaq
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了音视频开发系列（15）：视频与音频同步相关的知识，希望对你有一定的参考价值。
上次分享了将视频与音频同时推流到服务上的代码封装，然后上节分享在测试后会发现音视频不同步，这边说一下原因：
从帧率及采样率，即可知道视频/音频播放速度。声卡和显卡均是以一帧数据来作为播放单位，如果单纯依赖帧率及采样率来进行播放，在理想条件下，应该是同步的，不会出现偏差。
以一个44.1KHz的AAC音频流和24FPS的视频流为例：
一个AAC音频frame每个声道包含1024个采样点，则一个frame的播放时长(duration)为：(1024/44100)×1000ms = 23.22ms；一个视频frame播放时长(duration)为：1000ms/24 = 41.67ms。理想情况下，音视频完全同步。
但实际情况下，如果用上面那种简单的方式，慢慢的就会出现音视频不同步的情况，要不是视频播放快了，要么是音频播放快了。可能的原因如下：
1、一帧的播放时间，难以精准控制。音视频解码及渲染的耗时不同，可能造成每一帧输出有一点细微差距，长久累计，不同步便越来越明显。（例如受限于性能，42ms才能输出一帧）
2、音频输出是线性的，而视频输出可能是非线性，从而导致有偏差。
3、媒体流本身音视频有差距。（特别是TS实时流，音视频能播放的第一个帧起点不同）。
由于会存在以上原因，所以最终会导致音视频推送不同步。
要做到音视频同步，主要有以下三种方法：
1、将视频同步到音频上：就是以音频的播放速度为基准来同步视频。
2、将音频同步到视频上：就是以视频的播放速度为基准来同步音频。
3、将视频和音频同步外部的时钟上：选择一个外部时钟为基准，视频和音频的播放速度都以该时钟为标准。
本次分享的主要是以第三种策略来进行同步，即采用外部时钟的方法。
主要思路大概如下：
1.首先开启视频和音频的线程，上次介绍过线程的策略为：音频利用qt的读取音频的接口，然后在在开启的线程中一直往一个链表中写入数据，视频利用的opencv的接口，然后在线程中的策略与音频的一致，都是利用一个链表来读写音视频数据，这边需要注意的地方是需要利用锁的机制，控制不能同时读写链表。
2.然后就是初始化音视频编解码器，配置音视频编解码器所需要的参数，配置的参数可以具体看我分享的代码。
3.初始化输出封装器，添加视频和音频流，这边主要用于音视频推流。
4.记录当前的时间并将之前在线程中存储的音视频数据进行清除，以便同步更为准确。
5.进入死循环读取音视频帧进行推流。这边会记录下当前的时间，传入每一帧的数据，规定每一帧的pts。这边的时间基数time_base都设置为1/1000000，即设置单位为微秒。
大概流程如上所示。
这边会出现一个问题，由于音频数据会出现两次的pts时间相同，这时候会报错，这边进行的处理是如果出现相同的时间的情况，就在上一次记录的时间的基础上加上1.2ms。
下面是代码的分享，里面有注释，如果需要工程的话可以在评论区留言，看到的话会进行发送的。
main.cpp
#include <QtCore/QCoreApplication>
#include <QThread>
#include <iostream>
#include "XMediaEncode.h"
#include "XRtmp.h"
#include "XAudioRecord.h"
#include "XVideoCapture.h"
using namespace std;
int main(int argc, char *argv[])
QCoreApplication a(argc, argv);
int ret = 0;
char *outUrl = "rtmp://192.168.198.128/live";
int sampleRate = 44100;
int channels = 2;
int sampleByte = 2;
int nbSample = 1024;
///打开摄像机
XVideoCapture *xv = XVideoCapture::Get();
if (!xv->Init(0))
cout << "open camera failed!" << endl;
getchar();
return -1;
cout << "open camera success!" << endl;
xv->Start();
///1 qt音频开始录制
XAudioRecord *ar = XAudioRecord::Get();
ar->sampleRate = sampleRate;
ar->channels = channels;
ar->sampleByte = sampleByte;
ar->nbSample = nbSample;
if (!ar->Init())
cout << "XAudioRecord Init failed!" << endl;
getchar();
return -1;
ar->Start();
///初始化格式上下文
XMediaEncode *xe = XMediaEncode::Get();
xe->inWidth = xv->width;
xe->inHeight = xv->height;
xe->outHeight = xv->height;
xe->outWidth = xv->width;
if (!xe->InitScale())
cout << "InitScale Init failed!" << endl;
getchar();
return -1;
cout << "初始化视频像素转换上下文成功！" << endl;
///音频重采样
xe->channels = channels;
xe->nbSample = 1024;
xe->sampleRate = sampleRate;
xe->inSampleFmt = XSampleFMT::X_S16;
xe->outSampleFmt = XSampleFMT::X_FLTP;
if (!xe->InitResample())
getchar();
return -1;
///4 初始化音频编码器
if (!xe->InitAudioCodec())
getchar();
return -1;
///4 初始化视频编码器
if (!xe->InitVideoCodec())
getchar();
return -1;
///5 封装器和音频流配置
//a.创建输出封装器上下文
XRtmp *xr = XRtmp::Get(0);
if (!xr->Init(outUrl))
getchar();
return -1;
int vindex = 0;
vindex = xr->AddStream(xe->vc);
//b.添加视频流
if (vindex<0)
getchar();
return -1;
int aindex = 0;
aindex = xr->AddStream(xe->ac);
//b.添加视频流
if (aindex<0)
getchar();
return -1;
//从编码器复制参数
///6 打开rtmp的网络输出io
//写入封装头
if (!xr->SendHead())
getchar();
return -1;
//一次读取一帧音频的字节数
int readSize = xe->nbSample*channels*sampleByte;
char *buf = new char[readSize];
ar->Clear();
xv->Clear();
long long beginTime = GetCurTime();
for (;;)
//一次读取一帧音频
XData ad = ar->Pop();
XData vd = xv->Pop();
if (ad.size <= 0&&vd.size<=0)
QThread::msleep(1);
continue;
if (ad.size > 0)
ad.pts = ad.pts - beginTime;
//已经读取一帧源数据
//重采样数据
XData pcm = xe->Resample(ad);
ad.Drop();
XData pkt = xe->EncodeAudio(pcm);
if (pkt.size>0)
//推流
if (xr->SendFrame(pkt,aindex))
cout << "#" << flush;
if (vd.size > 0)
vd.pts = vd.pts - beginTime;
XData yuv = xe->RGBToYUV(vd);
vd.Drop();
XData pkt = xe->EncodeVideo(yuv);
if (pkt.size>0)
//推流
if (xr->SendFrame(pkt,vindex))
cout << "@" << flush;
delete buf;
getchar();
return a.exec();
XAudioRecord.h
#pragma once
#include "XDataThread.h"
enum XAUDIOTYPE
X_AUDIO_QT
;
class XAudioRecord:public XDataThread
public:
int sampleRate = 44100;//样本率
int channels = 2;//声道数
int sampleByte = 2;//样本大小
int nbSample = 1024;//一帧音频每个通道的样本数量
static XAudioRecord *Get(XAUDIOTYPE type= X_AUDIO_QT,unsigned char index = 0);
//开始录制
virtual bool Init()=0;
//停止录制
virtual void Stop()=0;
virtual ~XAudioRecord();
protected:
XAudioRecord();
;
XAudioRecord.cpp
#include "XAudioRecord.h"
#include <QAudioInput>
#include <iostream>
#include <list>
using namespace std;
class CXAudioRecord :public XAudioRecord
public:
void run()
cout << "进入音频录制线程" << endl;
int readSize = nbSample*channels*sampleByte;
char *buf = new char[readSize];
while (!isExit)
//读取已录制音频
//一次读取一帧音频
if (input->bytesReady() < readSize)
QThread::msleep(1);
continue;
int size = 0;
while (size != readSize)
int len = io->read(buf + size, readSize - size);
if (len < 0)break;
size += len;
if (size != readSize)
continue;
long long pts = GetCurTime();
//已读取一帧音频
Push(XData(buf,readSize,pts));
delete buf;
cout << "退出音频录制线程" << endl;
//开始录制
bool Init()
Stop();
///1 qt音频开始录制
QAudioFormat fmt;
int ret;
//采样频率
fmt.setSampleRate(sampleRate);
//通道数量
fmt.setChannelCount(channels);
//样本大小
fmt.setSampleSize(sampleByte * 8);
//格式
fmt.setCodec("audio/pcm");
//字节序
fmt.setByteOrder(QAudioFormat::LittleEndian);
fmt.setSampleType(QAudioFormat::UnSignedInt);
QAudioDeviceInfo info = QAudioDeviceInfo::defaultInputDevice();
if (!info.isFormatSupported(fmt))
cout << "Audio format not support!" << endl;
fmt = info.nearestFormat(fmt);
cout << "Audio format success" << endl;
input = new QAudioInput(fmt);
//开始录制音频
io = input->start();
if (!io)return false;
return true;
//停止录制
virtual void Stop()
XDataThread::Stop();
if (input)
input->stop();
if (io)
io->close();
input = NULL;
io = NULL;
QAudioInput *input = NULL;
QIODevice *io = NULL;
;
XAudioRecord *XAudioRecord::Get(XAUDIOTYPE type, unsigned char index)
static CXAudioRecord record[255];
return &record[index];
XAudioRecord::XAudioRecord()
XAudioRecord::~XAudioRecord()
XData.h
#pragma once
class XData
public:
char *data = 0;
int size = 0;
long long pts = 0;
void Drop();
XData();
//创建空间，并复制data内容
XData(char *data,int size,long long p=0);
~XData();
;
//获取当前时间戳(us)
long long GetCurTime();XData.cpp
#include "XData.h"
#include <stdlib.h>
#include <string.h>
extern "C"
#include <libavutil/time.h>
XData::XData(char *data, int size, long long p)
this->data = new char[size];
memcpy(this->data, data, size);
this->size = size;
this->pts = p;
void XData::Drop()
if (data)
delete data;
data = 0;
size = 0;
XData::XData()
XData::~XData()
long long GetCurTime()
return av_gettime();
XDataThread.h
#pragma once
#include <QThread>
#include "XData.h"
#include <list>
class XDataThread : public QThread
public:
//（缓冲列表大小）列表最大值，超出删除最旧的数据
int maxList = 100;
//在列表结尾插入
virtual void Push(XData d);
//读取列表中最早的数据,返回数据需要调用Xdata.Drop清理
virtual XData Pop();
//启动线程
virtual bool Start();
//退出线程，并等待线程退出(阻塞)
virtual void Stop();
virtual void Clear();
XDataThread();
virtual ~XDataThread();
protected:
//存放交互数据 插入策略 先进先出
std::list<XData> datas;
//互斥访问 datas
QMutex mutex;
//交互数据列表大小
int dataCount = 0;
//处理线程退出
bool isExit = false;
;
XDataThread.cpp
#include "XDataThread.h"
void XDataThread::Clear()
mutex.lock();
while (!datas.empty())
datas.front().Drop();
datas.pop_front();
mutex.unlock();
//在列表结尾插入
void XDataThread::Push(XData d)
mutex.lock();
//超出最大大小
if (datas.size()>maxList)
datas.front().Drop();
datas.pop_front();
datas.push_back(d);
mutex.unlock();
//读取列表中最早的数据
XData XDataThread::Pop()
mutex.lock();
if (datas.empty())
mutex.unlock();
return XData();
XData d = datas.front();
datas.pop_front();
mutex.unlock();
return d;
//启动线程
bool XDataThread::Start()
isExit = false;
QThread::start();
return true;
//退出线程，并等待线程退出(阻塞)
void XDataThread::Stop()
isExit = true;
wait();
XDataThread::XDataThread()
XDataThread::~XDataThread()
XMediaEncode.h
#pragma once
class AVCodecContext;
enum XSampleFMT
X_S16 = 1,
X_FLTP = 8
;
#include <XData.h>
///音视频编码接口类
class XMediaEncode
public:
///输入参数
int inWidth = 1280;
int inHeight = 720;
int inPixSize = 3;
int channels = 2;
int sampleRate = 44100;
XSampleFMT inSampleFmt = X_S16;
///输出参数
int outWidth = 1280;
int outHeight = 720;
int bitrate = 4000000;
int fps = 25;
int nbSample = 1024;
XSampleFMT outSampleFmt = X_FLTP;
//工厂的生产方法
static XMediaEncode *Get(unsigned char index = 0);
//初始化像素格式转换的上下文
virtual bool InitScale() = 0;
//音频重采样上下文初始化
virtual bool InitResample() = 0;
virtual XData Resample(XData d) = 0;
virtual XData RGBToYUV(XData rgb) = 0;
//视频编码器初始化
virtual bool InitVideoCodec() = 0;
//音频编码器初始化
virtual bool InitAudioCodec() = 0;
//视频编码 返回值无需调用者清理
virtual XData EncodeVideo(XData frame) = 0;
//音频编码 返回值无需调用者清理
virtual XData EncodeAudio(XData frame) = 0;
virtual ~XMediaEncode();
AVCodecContext *vc = 0; //编码器上下文
AVCodecContext *ac = 0; //音频编码器上下文
protected:
XMediaEncode();
;
XMediaEncode.cpp
#include "XMediaEncode.h"
#include <iostream>
extern "C"
#include <libswscale/swscale.h>
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include "libswresample/swresample.h"
#pragma comment(lib,"swscale.lib")
#pragma comment(lib,"avcodec.lib")
#pragma comment(lib,"avutil.lib")
#pragma comment(lib,"swresample.lib")
using namespace std;
#if defined WIN32 || defined _WIN32
#include <windows.h>
#endif
//获取CPU数量
static int XGetCpuNum()
#if defined WIN32 || defined _WIN32
SYSTEM_INFO sysinfo;
GetSystemInfo(&sysinfo);
return (int)sysinfo.dwNumberOfProcessors;
#elif defined __linux__
return (int)sysconf(_SC_NPROCESSORS_ONLN);
#elif defined __APPLE__
int numCPU = 0;
int mib[4];
size_t len = sizeof(numCPU);
// set the mib for hw.ncpu
mib[0] = CTL_HW;
mib[1] = HW_AVAILCPU; // alternatively, try HW_NCPU;
// get the number of CPUs from the system
sysctl(mib, 2, &numCPU, &len, NULL, 0);
if (numCPU < 1)
mib[1] = HW_NCPU;
sysctl(mib, 2, &numCPU, &len, NULL, 0);
if (numCPU < 1)
numCPU = 1;
return (int)numCPU;
#else
return 1;
#endif
class CXMediaEncode :public XMediaEncode
public:
void Close()
if (vsc)
sws_freeContext(vsc);
vsc = NULL;
if (yuv)
av_frame_free(&yuv);
if (asc)
swr_free(&asc);
if (vc)
avcodec_free_context(&vc);
if (vc)
avcodec_free_context(&vc);
if (pcm)
av_frame_free(&pcm);
vpts = 0;
apts = 0;
av_packet_unref(&vpack);
av_packet_unref(&apack);
bool InitVideoCodec()
///4.初始化编码上下文
//a 找到编码器
if (!(vc = CreateCodec(AV_CODEC_ID_H264)))
return false;
//vc->codec_id = codec->id;
vc->bit_rate = 50 * 1024 * 8; //压缩后每秒视频的bit位大小 200kB
vc->width = outWidth;
vc->height = outHeight;
//vc->time_base = 1,fps ;
vc->framerate = fps,1 ;
//画面组的大小，多少帧一个关键帧
vc->gop_size = 50;
//设置不需要b帧
vc->max_b_frames = 0;
//设置像素格式
vc->pix_fmt = AV_PIX_FMT_YUV420P;
//d 打开编码器上下文
int ret = avcodec_open2(vc, 0, 0);
if (ret != 0)
char buf[1024] = 0 ;
av_strerror(ret, buf, sizeof(buf) - 1);
cout << buf << endl;
return false;
cout << "avcodec_open2 success!" << endl;
return true;
bool InitAudioCodec()
///4 初始化音频编码器
if (!(ac=CreateCodec(AV_CODEC_ID_AAC)))
return false;
//音频的参数
ac->bit_rate = 40000;
ac->sample_rate = sampleRate;
ac->sample_fmt = AV_SAMPLE_FMT_FLTP;
ac->channels = channels;
ac->channel_layout = av_get_default_channel_layout(channels);
//打开编码器
return OpenCodec(&ac);
XData EncodeVideo(XData frame)
av_packet_unref(&vpack);
XData r;
if (frame.size <= 0 || !frame.data)return r;
AVFrame *p = (AVFrame *)frame.data;
// frame->pts = vpts;
// vpts++;
int ret = avcodec_send_frame(vc, p);
if (ret != 0)
return r;
ret = avcodec_receive_packet(vc, &vpack);
if (ret != 0 || vpack.size < 0)
return r;
r.data = (char *)&vpack;
r.size = vpack.size;
r.pts = frame.pts;
return r;
long long lasta = -1;
XData EncodeAudio(XData frame)
XData r;
if (frame.size <= 0 || !frame.data)return r;
AVFrame *p = (AVFrame *)frame.data;
if (lasta == p->pts)
p->pts += 1200;
lasta = p->pts;
int ret = avcodec_send_frame(ac, p);
if (ret != 0)return r;
av_packet_unref(&apack);
ret = avcodec_receive_packet(ac, &apack);
//cout << "avcodec_receive_packet " << ret << endl;
if (ret != 0)return r;
r.data = (char *)&apack;
r.size = apack.size;
r.pts = frame.pts;
return r;
bool InitScale()
///2.初始化格式转换上下文
vsc = sws_getCachedContext(vsc,
//源宽、高、像素格式
inWidth, inHeight, AV_PIX_FMT_BGR24,
//目标宽、高、像素格式
outWidth, outHeight, AV_PIX_FMT_YUV420P,
SWS_BICUBIC, //尺寸变化使用的算法
0, 0, 0
);
if (!vsc)
cout << "sws_getCachedContext failed";
return false;
///3.输出的数据结构
yuv = av_frame_alloc();
yuv->format = AV_PIX_FMT_YUV420P;
yuv->width = inWidth;
yuv->height = inHeight;
yuv->pts = 0;
//分配yuv空间
int ret = av_frame_get_buffer(yuv, 32);
if (ret != 0)
char buf[1024] = 0 ;
av_strerror(ret, buf, sizeof(buf) - 1);
throw exception(buf);
return true;
bool InitResample()
asc = NULL;
asc = swr_alloc_set_opts(asc,
av_get_default_channel_layout(channels), (AVSampleFormat)outSampleFmt, sampleRate, //输出格式
av_get_default_channel_layout(channels), (AVSampleFormat)inSampleFmt, sampleRate,//输入格式
0, 0);
if (!asc)
cout << "swr_alloc_set_opts failed!" << endl;
return false;
int ret = swr_init(asc);
if (ret != 0)
char err[1024] = 0 ;
av_strerror(ret, err, sizeof(err) - 1);
cout << err << endl;
return false;
cout << "音频重采样 上下文初始化成功" << endl;
///3 音频重采样输出空间分配
pcm = av_frame_alloc();
pcm->format = outSampleFmt;
pcm->channels = channels;
pcm->channel_layout = av_get_default_channel_layout(channels);
pcm->nb_samples = nbSample;//一帧音频一通道的采样数量
ret = av_frame_get_buffer(pcm, 0); //给pcm分配存储空间
if (ret != 0)
char err[1024] = 0 ;
av_strerror(ret, err, sizeof(err) - 1);
cout << err << endl;
return false;
return true;
XData RGBToYUV(XData d)
XData r;
r.pts = d.pts;
///rgb to yuv
//3.初始化输入的数据结构
uint8_t *indata[AV_NUM_DATA_POINTERS] = 0 ;
//indata[0] bgrbgrbgr
//plane indata[0] bbbbb indata[1]ggggg indata[2] rrrrr
indata[0] = (uint8_t*)d.data;
int insize[AV_NUM_DATA_POINTERS] = 0 ;
//一行(宽)数据的字节数
insize[0] = inWidth*inPixSize;
int h = sws_scale(vsc, indata, insize, 0, inHeight,//源数据
yuv->data, yuv->linesize);
if (h <= 0)
return r;
yuv->pts = d.pts;
r.data = (char *)yuv;
int *p = yuv->linesize;
while ((*p))
r.size += (*p)*outHeight;
p++;
return r;
XData Resample(XData d)
XData r;
const uint8_t *indata[AV_NUM_DATA_POINTERS] = 0 ;
indata[0] = (uint8_t *)d.data;
//已经读取一帧源数据
//重采样数据
int len = swr_convert(asc, pcm->data, pcm->nb_samples,//输出参数,输出存储地址，样本数
indata, pcm->nb_samples
);
if (len <= 0)
return r;
//从采集就记录pts
pcm->pts = d.pts;
r.data = (char *)pcm;
r.size = pcm->nb_samples*pcm->channels * 2;
r.pts = d.pts;
return r;
private:
bool OpenCodec(AVCodecContext **c)
int ret = avcodec_open2(*c, 0, 0);
if (ret != 0)
char err[1024] = 0 ;
av_strerror(ret, err, sizeof(err) - 1);
cout << err << endl;
avcodec_free_context(c);
return false;
cout << "avcodec_open2 success!" << endl;
return true;
AVCodecContext * CreateCodec(AVCodecID cid)
///4 初始化编码器
AVCodec *codec = avcodec_find_encoder(cid);
if (!codec)
cout << "avcodec_find_encoder failed!" << endl;
return NULL;
//音频编码器上下文
AVCodecContext * c = avcodec_alloc_context3(codec);
if (!c)
cout << "avcodec_alloc_context3 failed!" << endl;
return NULL;
cout << "avcodec_alloc_context3 success!" << endl;
c->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
c->thread_count = XGetCpuNum();
c->time_base = 1,1000000 ;
return c;
SwsContext *vsc = NULL; //像素格式转换上下文
AVFrame *yuv = NULL; //输出的yuv
SwrContext *asc = NULL; //音频重采样上下文
AVPacket vpack = 0; //视频帧
AVPacket apack = 0 ; //音频帧
AVFrame *pcm = NULL; //重采样输出的pcm
int vpts = 0;
int apts = 0;
;
XMediaEncode *XMediaEncode::Get(unsigned char index)
static bool isFirst = true;
if (isFirst)
//注册所有的编解码器
avcodec_register_all();
isFirst = false;
static CXMediaEncode cxm[255];
return &cxm[index];
XMediaEncode::XMediaEncode()
XMediaEncode::~XMediaEncode()
XRtmp.h
#pragma once
class AVCodecContext;
class AVPacket;
#include "XData.h"
class XRtmp
public:
static XRtmp *Get(unsigned char index = 0);
//初始化封装器上下文
virtual bool Init(const char *url) = 0;
//添加视频或者音频流 失败返回-1 成功返回流索引
virtual int AddStream(const AVCodecContext *c) = 0;
//打开rtmp网络IO，发送封装头
virtual bool SendHead() = 0;
//rtmp 帧推流
virtual bool SendFrame(XData d,int streamIndex=0) = 0;
~XRtmp();
protected:
XRtmp();
;
XRtmp.cpp
#include "XRtmp.h"
#include <iostream>
#include <string>
using namespace std;
extern "C"
#include <libavformat/avformat.h>
#pragma comment(lib,"avformat.lib")
class CXRtmp :public XRtmp
public:
void Close()
if (ic)
avformat_close_input(&ic);
vs = NULL;
vc = NULL;
url = "";
bool Init(const char *url)
//a.创建输出封装器上下文
int ret = avformat_alloc_output_context2(&ic, 0, "flv", url);
this->url = url;
if (ret != 0)
char buf[1024] = 0 ;
av_strerror(ret, buf, sizeof(buf) - 1);
cout << buf << endl;
return false;
return true;
int AddStream(const AVCodecContext *c)
if (!c)return -1;
AVStream *st = avformat_new_stream(ic, NULL);
if (!st)
cout << ("avformat_new_stream failed!") << endl;
return -1;
st->codecpar->codec_tag = 0;
//从编码器复制参数
avcodec_parameters_from_context(st->codecpar, c);
av_dump_format(ic, 0, url.c_str(), 1);
if (c->codec_type == AVMEDIA_TYPE_VIDEO)
vc = c;
vs = st;
else if (c->codec_type == AVMEDIA_TYPE_AUDIO)
ac = c;
as = st;
return st->index;
bool SendHead()
int ret = avio_open(&ic->pb, url.c_str(), AVIO_FLAG_WRITE);
if (ret != 0)
char buf[1024] = 0 ;
av_strerror(ret, buf, sizeof(buf) - 1);
cout << buf << endl;
return false;
//写入封装头
ret = avformat_write_header(ic, NULL);
if (ret != 0)
char buf[1024] = 0 ;
av_strerror(ret, buf, sizeof(buf) - 1);
cout << buf << endl;
return false;
return true;
bool SendFrame(XData d, int streamIndex)
if (!d.data || d.size <= 0 )return false;
AVPacket *pack = (AVPacket *)d.data;
//判断是音频还是视频
pack->stream_index = streamIndex;
AVRational stime;
AVRational dtime;
if (as && ac &&pack->stream_index == as->index)
stime = ac->time_base;
dtime = as->time_base;
else if (vs && vc && pack->stream_index == vs->index)
stime = vc->time_base;
dtime = vs->time_base;
else
return false;
//推流
pack->pts = av_rescale_q(pack->pts, stime, dtime);
pack->dts = av_rescale_q(pack->dts, stime, dtime);
pack->duration = av_rescale_q(pack->duration, stime, dtime);
int ret = av_interleaved_write_frame(ic, pack);
if (ret == 0)
cout << "#" << flush;
return true;
return false;
private:
AVFormatContext *ic = NULL; //rtmp flv 封装器
string url = "";
//视频编码器流
const AVCodecContext *vc = NULL;
//视频流
AVStream *vs = NULL;
//音频编码器流
const AVCodecContext *ac = NULL;
//音频流
AVStream *as = NULL;
;
XRtmp * XRtmp::Get(unsigned char index)
static CXRtmp cxr[255];
static bool isFirst = true;
if (isFirst)
//注册所有的封装器
av_register_all();
//注册所有的网络协议
avformat_network_init();
isFirst = false;
return &cxr[index];
XRtmp::XRtmp()
XRtmp::~XRtmp()
XVideoCapture.h
#pragma once
#include "XDataThread.h"
class XVideoCapture:public XDataThread
public:
int width = 0;
int height = 0;
int fps = 0;
static XVideoCapture *Get(unsigned char index = 0);
virtual bool Init(int camIdex = 0) = 0;
virtual bool Init(const char *url) = 0;
virtual void Stop() = 0;
virtual ~XVideoCapture();
protected:
XVideoCapture();
;
XVideoCapture.cpp
#include "XVideoCapture.h"
#include <opencv2/highgui.hpp>
#include <iostream>
using namespace cv;
using namespace std;
#pragma comment(lib,"opencv_world320.lib")
class CXVideoCapture:public XVideoCapture
public:
VideoCapture cam;
void run()
Mat frame;
cout << "进入视频线程" << endl;
while (!isExit)
if (!cam.read(frame))
msleep(1);
continue;
if (frame.empty())
msleep(1);
continue;
//确保数据是连续的
XData d((char *)frame.data, frame.cols*frame.rows*frame.elemSize(),GetCurTime());
Push(d);
cout << "退出视频线程" << endl;
bool Init(int camIdex = 0)
//使用opencv打开本地相机
cam.open(camIdex);
///1.打开摄像头
if (!cam.isOpened())
cout<<"cam open failed!";
return false;
cout << "cam open success" << endl;
width = cam.get(CAP_PROP_FRAME_WIDTH);
height = cam.get(CAP_PROP_FRAME_HEIGHT);
fps = cam.get(CAP_PROP_FPS);
if (fps == 0)fps = 25;
return true;
bool Init(const char *url)
//使用opencv打开本地相机
cam.open(url);
///1.打开摄像头
if (!cam.isOpened())
cout << "cam open failed!";
return false;
cout << "cam open success" << endl;
width = cam.get(CAP_PROP_FRAME_WIDTH);
height = cam.get(CAP_PROP_FRAME_HEIGHT);
fps = cam.get(CAP_PROP_FPS);
if (fps == 0)fps = 25;
return true;
void Stop()
XDataThread::Stop();
if (cam.isOpened())
cam.release();
;
XVideoCapture *XVideoCapture::Get(unsigned char index)
static CXVideoCapture xc[255];
return &xc[index];
XVideoCapture::XVideoCapture()
XVideoCapture::~XVideoCapture()
有没有更好的方法将音频与视频同步（不只是将其放入视频本身）？
【中文标题】有没有更好的方法将音频与视频同步（不只是将其放入视频本身）？【英文标题】：Is there a better way to sync audio with video (w/o just putting it in the video itself)? 【发布时间】：2016-08-30 03:39:12 【问题描述】：我正在尝试开发一个在动画 cc 中工作的播放器栏，并在 html5 画布上播放视频和所述视频前面的动画。
我希望它可以加快音频速度，因为屏幕上的视频确实会超前，但它的播放速度是正确的。所以我尝试了这个：
//Position the scrubber, handle press/release events for scrubber
this.addEventListener("tick", fl_MouseClickHandler.bind(this));
function fl_MouseClickHandler()
if(isDragging == false)
proportion = this.currentFrame/this.totalFrames;
if(Math.round(this.currentFrame/30) % 10 == 0) // do this every 10 seconds
audioSync(proportion);
this.scrubber.x = scrubberStart + (proportion * barWidth);
else
if (stage.mouseX > scrubberStart && stage.mouseX < (scrubberStart + barWidth))
proportion = (stage.mouseX-scrubberStart)/barWidth;
this.scrubber.x = stage.mouseX;
function audioSync(var p)
audioInstance.setPosition(p * audioInstance.duration);
//is there a better way to do this without it getting choppy?
//currently sounds like
//fo-o-o-d-d-d S-s-aaaaffttey-y-y when set to 2 seconds
//(it gets off that fast)
//it does those glitchy sounds for a few seconds when you increase the interval
//(if set to do it 10 seconds, ~3 seconds glitch, ~7 seconds normal)
现在，当他们放慢人声并且变得非常波涛汹涌时，它最终听起来有点像愚蠢朋克。 （参见“Alive 2007”第 7 轨的 0:00 到 1:30，“面对面/短路”(c)Daft Punk Legals，作为一个很好的例子）。
这是不同步的演示：http://mhardingfoodsafe.github.io/player-audio-messed-up/
当我尝试做audioInstance.currentTime = video.currentTime; 时，什么都没有改变
当我执行video.currentTime = audioInstance.currentTime; 时，我收到一条错误消息，提示它无法读取非有限值。
这实际上是在做我所描述的事情（不是我想要的）：http://mhardingfoodsafe.github.io/player-bar-v2/
【问题讨论】：
可能的帮助：***.com/questions/6433900/… 我只是尝试这样做，但由于某种原因它不喜欢它。他们仍然以不同的价格播放。 （在“滴答声”侦听器和滴答声侦听器中尝试了 audioSync()，但在“每 10 秒执行一次”条件之外）：/ 您是否尝试过反转它以便将视频同步到音频？我真的帮不上忙，因为我不太了解情况 对，我几乎为你准备了一个演示 :) 当我昨天这样做时，它闪现了视频。我可以在不同的地方再试一次，看看是否有帮助，但我会先发布演示 好的，迈克。当提供演示时，人们测试和实验要容易得多。这使得调试过程和到达答案的速度更快。 【参考方案1】：发现确保所有动画都在带有音频的视频中更容易，这样它就不那么复杂并保持同步......
为什么：
在使用 html5 画布时，视频可以比 animate cc 更好地跟踪同步。
只添加视频控件比同时添加帧、音频和视频更容易。
在尝试通过多种不同类型的 Internet 连接和设备实施时不易出错。
基本一样，只是去掉了音频同步功能。只需确保场景有足够的帧以匹配您设置的 fps 的视频长度即可。
【讨论】：
以上是关于音视频开发系列（15）：视频与音频同步的主要内容，如果未能解决你的问题，请参考以下文章