C語言使用ffmpeg實現單線程異步的視頻播放器

更新時間：2022年12月16日 10:22:46 作者：CodeOfCC

這篇文章主要為大家詳細介紹了C語言如何使用ffmpeg實現單線程異步的視頻播放器功能，文中的示例代碼講解詳細，感興趣的小伙伴可以嘗試一下

前言

ffplay是一個不錯的播放器，是基于多線程實現的，播放視頻時一般至少有4個線程：讀包線程、視頻解碼線程、音頻解碼線程、視頻渲染線程。如果需要多路播放時，線程不可避免的有點多，比如需要播放8路視頻時則需要32個線程，這樣對性能的消耗還是比較大的。于是想到用單線程實現一個播放器，經過實踐發(fā)現是可行的，播放本地文件時可以做到完全單線程、播放網絡流時需要一個線程實現讀包異步。

一、播放流程

二、關鍵實現

因為是基于單線程的播放器有些細節(jié)還是要注意的。

1.視頻

（1）解碼

解碼時需要注意設置多線程解碼或者硬解以確保解碼速度，因為在單線程中解碼過慢則會導致視頻卡頓。

//使用多線程解碼
if (!av_dict_get(opts, "threads", NULL, 0))
    av_dict_set(&opts, "threads", "auto", 0);
//打開解碼器
if (avcodec_open2(decoder->codecContext, codec, &opts) < 0) {
    LOG_ERROR("Could not open codec");
    av_dict_free(&opts);
    return ERRORCODE_DECODER_OPENFAILED;
}

或者根據情況設置硬解碼器

codec = avcodec_find_decoder_by_name("hevc_qsv");
//打開解碼器
if (avcodec_open2(decoder->codecContext, codec, &opts) < 0) {
    LOG_ERROR("Could not open codec");
    av_dict_free(&opts);
    return ERRORCODE_DECODER_OPENFAILED;
}

2、音頻

（1）修正時鐘

雖然音頻的播放是基于流的，時鐘也可以按照播放的數據量計算，但是出現丟包或者定位的一些情況時，按照數據量累計的方式會導致時鐘不正確，所以在解碼后的數據放入播放隊列時應該進行時鐘修正。

synchronize_setClockTime參考《c語言將音視頻時鐘同步封裝成通用模塊》。在音頻解碼之后：

//讀取解碼的音頻幀
av_fifo_generic_read(play->audio.decoder.fifoFrame, &frame, sizeof(AVFrame*), NULL);
//同步(修正)時鐘
AVRational timebase = play->formatContext->streams[audio->decoder.streamIndex]->time_base;
//當前幀的時間戳
double pts = (double)frame->pts * timebase.num / timebase.den;
//減去播放隊列剩余數據的時長就是當前的音頻時鐘
pts -= (double)av_audio_fifo_size(play->audio.playFifo) / play->audio.spec.freq;
synchronize_setClockTime(&play->synchronize, &play->synchronize.audio, pts);
//同步(修正)時鐘--end
//寫入播放隊列
av_audio_fifo_write(play->audio.playFifo, (void**)&data, samples);

3、時鐘同步

需要時鐘同步的地方有3處，一處是音頻解碼后即上面的2、（1）。另外兩處則是音頻播放和視頻渲染的地方。

（1）音頻播放

synchronize_updateAudio參考《c語言將音視頻時鐘同步封裝成通用模塊》。

//sdl音頻回調
static void audio_callback(void* userdata, uint8_t* stream, int len) {
   Play* play = (Play*)userdata;
   //需要寫入的數據量
   samples = play->audio.spec.samples;
  //時鐘同步，獲取應該寫入的數據量，如果是同步到音頻，則需要寫入的數據量始終等于應該寫入的數據量。
   samples = synchronize_updateAudio(&play->synchronize, samples, play->audio.spec.freq);
   //略
}

（2）視頻播放

在視頻渲染處實現如下代碼，其中synchronize_updateVideo參考《c語言將音視頻時鐘同步封裝成通用模塊》。

//---------------時鐘同步--------------        
AVRational timebase = play->formatContext->streams[video->decoder.streamIndex]->time_base;
//計算視頻幀的pts
double    pts = frame->pts * (double)timebase.num / timebase.den;
//視頻幀的持續(xù)時間
double duration = frame->pkt_duration * (double)timebase.num / timebase.den;
double delay = synchronize_updateVideo(&play->synchronize, pts, duration);
if (delay > 0)
    //延時
{
    play->wakeupTime = getCurrentTime() + delay;
    return 0;
}
else if (delay < 0)
    //丟幀
{
    av_fifo_generic_read(video->decoder.fifoFrame, &frame, sizeof(AVFrame*), NULL);
    av_frame_unref(frame);
    av_frame_free(&frame);
    return 0;
}
else
    //播放
{
    av_fifo_generic_read(video->decoder.fifoFrame, &frame, sizeof(AVFrame*), NULL);
}
//---------------時鐘同步--------------    end

4、異步讀包

如果是本地文件單線程播放是完全沒有問題的。但是播放網絡流時，由于av_read_frame不是異步的，網絡狀況差時會導致延時過高影響到其他部分功能的正常進行，所以只能是將讀包的操作放到子線程執(zhí)行，這里采用async、await的思想實現異步。

（1）async

將av_read_frame的放到線程池中執(zhí)行。

//異步讀取包，子線程中調用此方法
static int packet_readAsync(void* arg)
{
    Play* play = (Play*)arg;
    play->eofPacket = av_read_frame(play->formatContext, &play->packet);
    //回到播放線程處理包
    play_beginInvoke(play, packet_readAwait, play);
    return 0;
}

（2）await

執(zhí)行完成后通過消息隊列通知播放器線程，將后續(xù)操作放在播放線程中執(zhí)行

//異步讀取包完成后的操作
static int packet_readAwait(void* arg)
{
    Play* play = (Play*)arg;
    if (play->eofPacket == 0)
    {
        if (play->packet.stream_index == play->video.decoder.streamIndex)
            //寫入視頻包隊
        {
            AVPacket* packet = av_packet_clone(&play->packet);
            av_fifo_generic_write(play->video.decoder.fifoPacket, &packet, sizeof(AVPacket*), NULL);
        }
        else if (play->packet.stream_index == play->audio.decoder.streamIndex)
            //寫入音頻包隊
        {
            AVPacket* packet = av_packet_clone(&play->packet);
            av_fifo_generic_write(play->audio.decoder.fifoPacket, &packet, sizeof(AVPacket*), NULL);
        }
        av_packet_unref(&play->packet);
    }
    else if (play->eofPacket == AVERROR_EOF)
    {
        play->eofPacket = 1;
        //寫入空包flush解碼器中的緩存
        AVPacket* packet = &play->packet;
        if (play->audio.decoder.fifoPacket)
            av_fifo_generic_write(play->audio.decoder.fifoPacket, &packet, sizeof(AVPacket*), NULL);
        if (play->video.decoder.fifoPacket)
            av_fifo_generic_write(play->video.decoder.fifoPacket, &packet, sizeof(AVPacket*), NULL);
    }
    else
    {
        LOG_ERROR("read packet erro!\n");
        play->exitFlag = 1;
        play->isAsyncReading = 0;
        return ERRORCODE_PACKET_READFRAMEFAILED;
    }
    play->isAsyncReading = 0;
    return 0;
}

（3）消息處理

在播放線程中調用如下方法，處理事件，當await方法拋入消息隊列后，就可以通過消息循環(huán)獲取await方法在播放線程中執(zhí)行。

//事件處理
static void play_eventHandler(Play* play) {
    PlayMessage msg;
    while (messageQueue_poll(&play->mq, &msg)) {
        switch (msg.type)
        {
        case PLAYMESSAGETYPE_INVOKE:
            SDL_ThreadFunction fn = (SDL_ThreadFunction)msg.param1;
            fn(msg.param2);
            break;
        }
    }
}

三、完整代碼

完整代碼c和c++都可以運行，使用ffmpeg4.3、sdl2。

main.c/cpp

#include <stdio.h>
#include <stdint.h>
#include "SDL.h"
#include<stdint.h>
#include<string.h>
#ifdef  __cplusplus
extern "C" {
#endif 
#include "libavformat/avformat.h"
#include "libavcodec/avcodec.h"
#include "libswscale/swscale.h"
#include "libavutil/imgutils.h"
#include "libavutil/avutil.h"
#include "libavutil/time.h"
#include "libavutil/audio_fifo.h"
#include "libswresample/swresample.h"
#ifdef  __cplusplus
}
#endif 

/************************************************************************
* @Project:  	play
* @Decription:  視頻播放器
* 這是一個播放器，基于單線程實現的播放器。如果是播放本地文件可以做到完全單線程，播放網絡流則讀取包的時候是異步的，當然
* 主流程依然是單線程。目前是讀取包始終異步，未作判斷本地文件同步讀包處理。
* @Verision:  	v0.0.0
* @Author:  	Xin Nie
* @Create:  	2022/12/12 21:21:00
* @LastUpdate:  2022/12/12 21:21:00
************************************************************************
* Copyright @ 2022. All rights reserved.
************************************************************************/


/// <summary>
/// 消息隊列
/// </summary>
typedef struct {
	//隊列長度
	int _capacity;
	//消息對象大小
	int _elementSize;
	//隊列
	AVFifoBuffer* _queue;
	//互斥變量
	SDL_mutex* _mtx;
	//條件變量
	SDL_cond* _cv;
}MessageQueue;
/// <summary>
/// 對象池
/// </summary>
typedef struct {
	//對象緩存
	void* buffer;
	//對象大小
	int elementSize;
	//對象個數
	int arraySize;
	//對象使用狀態(tài)1使用，0未使用
	int* _arrayUseState;
	//互斥變量
	SDL_mutex* _mtx;
	//條件變量
	SDL_cond* _cv;
}OjectPool;
/// <summary>
/// 線程池
/// </summary>
typedef struct {
	//最大線程數
	int maxThreadCount;
	//線程信息對象池
	OjectPool _pool;
}ThreadPool;
/// <summary>
/// 線程信息
/// </summary>
typedef struct {
	//所屬線程池
	ThreadPool* _threadPool;
	//線程句柄
	SDL_Thread* _thread;
	//消息隊列
	MessageQueue _queue;
	//線程回調方法
	SDL_ThreadFunction _fn;
	//線程回調參數
	void* _arg;
}ThreadInfo;
//解碼器
typedef  struct {
	//解碼上下文
	AVCodecContext* codecContext;
	//解碼器
	const AVCodec* codec;
	//解碼臨時幀
	AVFrame* frame;
	//包隊列
	AVFifoBuffer* fifoPacket;
	//幀隊列
	AVFifoBuffer* fifoFrame;
	//流下標
	int	streamIndex;
	//解碼結束標記
	int eofFrame;
}Decoder;
/// <summary>
/// 時鐘對象
/// </summary>
typedef  struct {
	//起始時間
	double startTime;
	//當前pts
	double currentPts;
}Clock;
/// <summary>
/// 時鐘同步類型
/// </summary>
typedef enum {
	//同步到音頻
	SYNCHRONIZETYPE_AUDIO,
	//同步到視頻
	SYNCHRONIZETYPE_VIDEO,
	//同步到絕對時鐘
	SYNCHRONIZETYPE_ABSOLUTE
}SynchronizeType;
/// <summary>
/// 時鐘同步對象
/// </summary>
typedef  struct {
	/// <summary>
	/// 音頻時鐘
	/// </summary>
	Clock audio;
	/// <summary>
	/// 視頻時鐘
	/// </summary>
	Clock video;
	/// <summary>
	/// 絕對時鐘
	/// </summary>
	Clock absolute;
	/// <summary>
	/// 時鐘同步類型
	/// </summary>
	SynchronizeType type;
	/// <summary>
	/// 估算的視頻幀時長
	/// </summary>
	double estimateVideoDuration;
	/// <summary>
	/// 估算視頻幀數
	/// </summary>
	double n;
}Synchronize;
//視頻模塊
typedef  struct {
	//解碼器
	Decoder decoder;
	//輸出格式
	enum AVPixelFormat forcePixelFormat;
	//重采樣對象
	struct SwsContext* swsContext;
	//重采樣緩存
	uint8_t* swsBuffer;
	//渲染器
	SDL_Renderer* sdlRenderer;
	//紋理
	SDL_Texture* sdlTexture;
	//窗口
	SDL_Window* screen;
	//窗口寬
	int screen_w;
	//窗口高
	int	screen_h;
	//旋轉角度
	 double  angle;
	//播放結束標記
	int eofDisplay;
	//播放開始標記
	int sofDisplay;
}Video;

//音頻模塊
typedef  struct {
	//解碼器
	Decoder decoder;
	//輸出格式
	enum AVSampleFormat forceSampleFormat;
	//音頻設備id
	SDL_AudioDeviceID audioId;
	//期望的音頻設備參數
	SDL_AudioSpec wantedSpec;
	//實際的音頻設備參數
	SDL_AudioSpec spec;
	//重采樣對象
	struct SwrContext* swrContext;
	//重采樣緩存
	uint8_t* swrBuffer;
	//播放隊列
	AVAudioFifo* playFifo;
	//播放隊列互斥鎖
	SDL_mutex* mutex;
	//累積的待播放采樣數
	int accumulateSamples;
	//音量
	int volume;
	//聲音混合buffer
	uint8_t* mixBuffer;
	//播放結束標記
	int eofPlay;
	//播放開始標記
	int sofPlay;
}Audio;

//播放器
typedef  struct {
	//視頻url
	char* url;
	//解復用上下文
	AVFormatContext* formatContext;
	//包
	AVPacket packet;
	//是否正在讀取包
	int isAsyncReading;
	//包讀取結束標記
	int eofPacket;
	//視頻模塊
	Video video;
	//音頻模塊
	Audio audio;
	//時鐘同步
	Synchronize synchronize;
	//延時結束時間
	double wakeupTime;
	//播放一幀
	int step;
	//是否暫停
	int isPaused;
	//是否循環(huán)
	int isLoop;
	//退出標記
	int exitFlag;
	//消息隊列
	MessageQueue mq;
}Play;

//播放消息類型
typedef enum {
	//調用方法
	PLAYMESSAGETYPE_INVOKE
}PlayMessageType;

//播放消息
typedef  struct {
	PlayMessageType type;
	void* param1;
	void* param2;
}PlayMessage;

//格式映射
static const struct TextureFormatEntry {
	enum AVPixelFormat format;
	int texture_fmt;
} sdl_texture_format_map[] = {
	{ AV_PIX_FMT_RGB8, SDL_PIXELFORMAT_RGB332 },
	{ AV_PIX_FMT_RGB444, SDL_PIXELFORMAT_RGB444 },
	{ AV_PIX_FMT_RGB555, SDL_PIXELFORMAT_RGB555 },
	{ AV_PIX_FMT_BGR555, SDL_PIXELFORMAT_BGR555 },
	{ AV_PIX_FMT_RGB565, SDL_PIXELFORMAT_RGB565 },
	{ AV_PIX_FMT_BGR565, SDL_PIXELFORMAT_BGR565 },
	{ AV_PIX_FMT_RGB24, SDL_PIXELFORMAT_RGB24 },
	{ AV_PIX_FMT_BGR24, SDL_PIXELFORMAT_BGR24 },
	{ AV_PIX_FMT_0RGB32, SDL_PIXELFORMAT_RGB888 },
	{ AV_PIX_FMT_0BGR32, SDL_PIXELFORMAT_BGR888 },
	{ AV_PIX_FMT_NE(RGB0, 0BGR), SDL_PIXELFORMAT_RGBX8888 },
	{ AV_PIX_FMT_NE(BGR0, 0RGB), SDL_PIXELFORMAT_BGRX8888 },
	{ AV_PIX_FMT_RGB32, SDL_PIXELFORMAT_ARGB8888 },
	{ AV_PIX_FMT_RGB32_1, SDL_PIXELFORMAT_RGBA8888 },
	{ AV_PIX_FMT_BGR32, SDL_PIXELFORMAT_ABGR8888 },
	{ AV_PIX_FMT_BGR32_1, SDL_PIXELFORMAT_BGRA8888 },
	{ AV_PIX_FMT_YUV420P, SDL_PIXELFORMAT_IYUV },
	{ AV_PIX_FMT_YUYV422, SDL_PIXELFORMAT_YUY2 },
	{ AV_PIX_FMT_UYVY422, SDL_PIXELFORMAT_UYVY },
	{ AV_PIX_FMT_NONE, SDL_PIXELFORMAT_UNKNOWN },
};

/// <summary>
/// 錯誤碼
/// </summary>
typedef  enum {
	//無錯誤
	ERRORCODE_NONE = 0,
	//播放
	ERRORCODE_PLAY_OPENINPUTSTREAMFAILED = -0xffff,//打開輸入流失敗
	ERRORCODE_PLAY_VIDEOINITFAILED,//視頻初始化失敗
	ERRORCODE_PLAY_AUDIOINITFAILED,//音頻初始化失敗
	ERRORCODE_PLAY_LOOPERROR,//播放循環(huán)錯誤
	ERRORCODE_PLAY_READPACKETERROR,//解包錯誤
	ERRORCODE_PLAY_VIDEODECODEERROR,//視頻解碼錯誤
	ERRORCODE_PLAY_AUDIODECODEERROR,//音頻解碼錯誤
	ERRORCODE_PLAY_VIDEODISPLAYERROR,//視頻播放錯誤
	ERRORCODE_PLAY_AUDIOPLAYERROR,//音頻播放錯誤
	//解包
	ERRORCODE_PACKET_CANNOTOPENINPUTSTREAM,//無法代碼輸入流
	ERRORCODE_PACKET_CANNOTFINDSTREAMINFO,//查找不到流信息
	ERRORCODE_PACKET_DIDNOTFINDDANYSTREAM,//找不到任何流
	ERRORCODE_PACKET_READFRAMEFAILED,//讀取包失敗
	//解碼
	ERRORCODE_DECODER_CANNOTALLOCATECONTEXT,//解碼器上下文申請內存失敗
	ERRORCODE_DECODER_SETPARAMFAILED,//解碼器上下文設置參數失敗
	ERRORCODE_DECODER_CANNOTFINDDECODER,//找不到解碼器
	ERRORCODE_DECODER_OPENFAILED,//打開解碼器失敗
	ERRORCODE_DECODER_SENDPACKEDFAILED,//解碼失敗
	ERRORCODE_DECODER_MISSINGASTREAMTODECODE,//缺少用于解碼的流
	//視頻
	ERRORCODE_VIDEO_DECODERINITFAILED,//音頻解碼器初始化失敗
	ERRORCODE_VIDEO_CANNOTGETSWSCONTEX,//無法獲取ffmpeg swsContext
	ERRORCODE_VIDEO_IMAGEFILLARRAYFAILED,//將圖像數據映射到數組時失?。篴v_image_fill_arrays
	ERRORCODE_VIDEO_CANNOTRESAMPLEAFRAME,//無法重采樣視頻幀
	ERRORCODE_VIDEO_MISSINGSTREAM,//缺少視頻流
	//音頻
	ERRORCODE_AUDIO_DECODERINITFAILED,//音頻解碼器初始化失敗
	ERRORCODE_AUDIO_UNSUPORTDEVICESAMPLEFORMAT,//不支持音頻設備采樣格式
	ERRORCODE_AUDIO_SAMPLESSIZEINVALID,//采樣大小不合法
	ERRORCODE_AUDIO_MISSINGSTREAM,//缺少音頻流
	ERRORCODE_AUDIO_SWRINITFAILED,//ffmpeg swr重采樣對象初始化失敗
	ERRORCODE_AUDIO_CANNOTCONVERSAMPLE,//音頻重采樣失敗
	ERRORCODE_AUDIO_QUEUEISEMPTY,//隊列數據為空
	//幀
	ERRORCODE_FRAME_ALLOCFAILED,//初始化幀失敗
	//隊列
	ERRORCODE_FIFO_ALLOCFAILED,//初始化隊列失敗
	//sdl
	ERRORCODE_SDL_INITFAILED,//sdl初始化失敗
	ERRORCODE_SDL_CANNOTCREATEMUTEX,//無法創(chuàng)建互斥鎖
	ERRORCODE_SDL_CANNOTOPENDEVICE, //無法打開音頻設備
	ERRORCODE_SDL_CREATEWINDOWFAILED,//創(chuàng)建窗口失敗
	ERRORCODE_SDL_CREATERENDERERFAILED,//創(chuàng)建渲染器失敗
	ERRORCODE_SDL_CREATETEXTUREFAILED,//創(chuàng)建紋理失敗
	//內存
	ERRORCODE_MEMORY_ALLOCFAILED,//申請內存失敗
	ERRORCODE_MEMORY_LEAK,//內存泄漏
	//參數
	ERRORCODE_ARGUMENT_INVALID,//參數不合法
	ERRORCODE_ARGUMENT_OUTOFRANGE,//超出范圍
}ErrorCode;

/// <summary>
/// 日志等級
/// </summary>
typedef  enum {
	LOGLEVEL_NONE = 0,
	LOGLEVEL_INFO = 1,
	LOGLEVEL_DEBUG = 2,
	LOGLEVEL_TRACE = 4,
	LOGLEVEL_WARNNING = 8,
	LOGLEVEL_ERROR = 16,
	LOGLEVEL_ALL = LOGLEVEL_INFO | LOGLEVEL_DEBUG | LOGLEVEL_TRACE | LOGLEVEL_WARNNING | LOGLEVEL_ERROR
}
LogLevel;

//輸出日志
#define LOGHELPERINTERNALLOG(message,level,...)  aclog(__FILE__,__FUNCTION__,__LINE__,level,message,##__VA_ARGS__)  
#define LOG_INFO(message,...) LOGHELPERINTERNALLOG(message,LOGLEVEL_INFO, ##__VA_ARGS__)
#define LOG_DEBUG(message,...) LOGHELPERINTERNALLOG(message,LOGLEVEL_DEBUG,##__VA_ARGS__)
#define LOG_TRACE(message,...) LOGHELPERINTERNALLOG(cmessage,LOGLEVEL_TRACE,##__VA_ARGS__)
#define LOG_WARNNING(message,...) LOGHELPERINTERNALLOG(message,LOGLEVEL_WARNNING,##__VA_ARGS__)
#define LOG_ERROR(message,...) LOGHELPERINTERNALLOG(message,LOGLEVEL_ERROR,##__VA_ARGS__)

static int logLevelFilter = LOGLEVEL_ALL;
static ThreadPool* _pool = NULL;

//寫日志
void aclog(const char* fileName, const char* methodName, int line, LogLevel level, const char* message, ...) {
	if ((logLevelFilter & level) == 0)
		return;
	char dateTime[32];
	time_t tt = time(0);
	struct tm* t;
	va_list valist;
	char buf[512];
	char* pBuf = buf;
	va_start(valist, message);
	int size = vsnprintf(pBuf, sizeof(buf), message, valist);
	if (size > sizeof(buf))
	{
		pBuf = (char*)av_malloc(size + 1);
		vsnprintf(pBuf, size + 1, message, valist);
	}
	va_end(valist);
	t = localtime(&tt);
	sprintf(dateTime, "%04d-%02d-%02d %02d:%02d:%02d", t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec);
	//在此處可替換為寫文件
	printf("%s %d %d %s %s %d: %s\n", dateTime, level, SDL_ThreadID(), fileName, methodName, line, pBuf);
	if (pBuf != buf)
		av_free(pBuf);
}
//日志過濾，設為LOGLEVEL_NONE則不輸出日志
void setLogFilter(LogLevel level) {
	logLevelFilter = level;
}


//初始化消息隊列
int messageQueue_init(MessageQueue* _this, int capacity, int elementSize) {
	_this->_queue = av_fifo_alloc(elementSize * capacity);
	if (!_this->_queue)
		return ERRORCODE_MEMORY_ALLOCFAILED;
	_this->_mtx = SDL_CreateMutex();
	if (!_this->_mtx)
		return ERRORCODE_MEMORY_ALLOCFAILED;
	_this->_cv = SDL_CreateCond();
	if (!_this->_cv)
		return ERRORCODE_MEMORY_ALLOCFAILED;
	_this->_capacity = capacity;
	_this->_elementSize = elementSize;
	return 0;
}
//反初始化消息隊列
void messageQueue_deinit(MessageQueue* _this) {
	if (_this->_queue)
		av_fifo_free(_this->_queue);
	if (_this->_cv)
		SDL_DestroyCond(_this->_cv);
	if (_this->_mtx)
		SDL_DestroyMutex(_this->_mtx);
	memset(_this, 0, sizeof(MessageQueue));
}

//推入消息
int messageQueue_push(MessageQueue* _this, void* msg) {
	int ret = 0;
	SDL_LockMutex(_this->_mtx);
	ret = av_fifo_generic_write(_this->_queue, msg, _this->_elementSize, NULL);
	SDL_CondSignal(_this->_cv);
	SDL_UnlockMutex(_this->_mtx);
	return  ret > 0;
}
//輪詢序消息
int messageQueue_poll(MessageQueue* _this, void* msg) {
	SDL_LockMutex(_this->_mtx);
	int size = av_fifo_size(_this->_queue);
	if (size >= _this->_elementSize)
	{
		av_fifo_generic_read(_this->_queue, msg, _this->_elementSize, NULL);
	}
	SDL_UnlockMutex(_this->_mtx);
	return size;
}
//等待消息
void messageQueue_wait(MessageQueue* _this, void* msg) {
	SDL_LockMutex(_this->_mtx);
	while (1) {
		int size = av_fifo_size(_this->_queue);
		if (size >= _this->_elementSize)
		{
			av_fifo_generic_read(_this->_queue, msg, _this->_elementSize, NULL);
			break;
		}
		SDL_CondWait(_this->_cv, _this->_mtx);
	}
	SDL_UnlockMutex(_this->_mtx);
}

//初始化對象池
int ojectPool_init(OjectPool* _this, void* bufferArray, int elementSize, int arraySize)
{
	if (elementSize < 1 || arraySize < 1)
		return ERRORCODE_ARGUMENT_INVALID;
	_this->buffer = (unsigned char*)bufferArray;
	_this->elementSize = elementSize;
	_this->arraySize = arraySize;
	_this->_arrayUseState = (int*)av_mallocz(sizeof(int) * arraySize);
	if (!_this->_arrayUseState)
		return ERRORCODE_MEMORY_ALLOCFAILED;
	_this->_mtx = SDL_CreateMutex();
	if (!_this->_mtx)
		return ERRORCODE_MEMORY_ALLOCFAILED;
	_this->_cv = SDL_CreateCond();
	if (!_this->_cv)
		return ERRORCODE_MEMORY_ALLOCFAILED;
	return 0;
}
//反初始化對象池
void objectPool_deinit(OjectPool* _this)
{
	av_free(_this->_arrayUseState);
	if (_this->_cv)
		SDL_DestroyCond(_this->_cv);
	if (_this->_mtx)
		SDL_DestroyMutex(_this->_mtx);
	memset(_this, 0, sizeof(OjectPool));
}

//取出對象
void* objectPool_take(OjectPool* _this, int timeout) {
	void* element = NULL;
	SDL_LockMutex(_this->_mtx);
	while (1)
	{
		for (int i = 0; i < _this->arraySize; i++)
		{
			if (!_this->_arrayUseState[i])
			{
				element = &((Uint8*)_this->buffer)[i * _this->elementSize];
				_this->_arrayUseState[i] = 1;
				break;
			}
		}
		if (!element)
		{
			if (timeout == -1)
			{
				int ret = SDL_CondWait(_this->_cv, _this->_mtx);
				if (ret == -1)
				{
					LOG_ERROR("SDL_CondWait error");
					break;
				}
			}
			else
			{
				int ret = SDL_CondWaitTimeout(_this->_cv, _this->_mtx, timeout);
				if (ret != 0)
				{
					if (ret == -1)
					{
						LOG_ERROR("SDL_CondWait error");
					}
					break;
				}
			}
		}
		else
		{
			break;
		}
	}
	SDL_UnlockMutex(_this->_mtx);
	return element;
}

//歸還對象
void objectPool_restore(OjectPool* _this, void* element) {
	SDL_LockMutex(_this->_mtx);
	for (int i = 0; i < _this->arraySize; i++)
	{
		if (_this->_arrayUseState[i] && &((Uint8*)_this->buffer)[i * _this->elementSize] == element)
		{
			SDL_CondSignal(_this->_cv);
			_this->_arrayUseState[i] = 0;
			break;
		}
	}
	SDL_UnlockMutex(_this->_mtx);
}

//初始化線程池
int threadPool_init(ThreadPool* _this, int maxThreadCount) {
	_this->maxThreadCount = maxThreadCount;
	return ojectPool_init(&_this->_pool, av_mallocz(sizeof(ThreadInfo) * maxThreadCount), sizeof(ThreadInfo), maxThreadCount);
}
//反初始化線程池
void threadPool_denit(ThreadPool* _this) {
	ThreadInfo* threads = (ThreadInfo*)_this->_pool.buffer;
	if (threads)
	{
		for (int i = 0; i < _this->maxThreadCount; i++)
		{
			int status;
			if (threads[i]._thread)
			{
				int msg = 0;
				messageQueue_push(&threads[i]._queue, &msg);
				SDL_WaitThread(threads[i]._thread, &status);
				messageQueue_deinit(&threads[i]._queue);
			}
		}
	}
	av_freep(&_this->_pool.buffer);
	objectPool_deinit(&_this->_pool);
}
//線程池，線程處理過程
int threadPool_threadProc(void* data)
{
	ThreadInfo* info = (ThreadInfo*)data;
	int msg = 1;
	while (msg) {
		info->_fn(info->_arg);
		objectPool_restore(&info->_threadPool->_pool, info);
		messageQueue_wait(&info->_queue, &msg);
	}
	return 0;
}
//在線程池中運行方法
void threadPool_run(ThreadPool* _this, SDL_ThreadFunction fn, void* arg) {
	ThreadInfo* info = (ThreadInfo*)objectPool_take(&_this->_pool, -1);
	info->_fn = fn;
	info->_arg = arg;
	if (info->_thread)
	{
		int msg = 1;
		messageQueue_push(&info->_queue, &msg);
	}
	else
	{
		info->_threadPool = _this;
		messageQueue_init(&info->_queue, 1, sizeof(int));
		info->_thread = SDL_CreateThread(threadPool_threadProc, "threadPool_threadProc", info);
	}
}

//在播放線程中運行方法
void play_beginInvoke(Play* _this, SDL_ThreadFunction fn, void* arg)
{
	PlayMessage msg;
	msg.type = PLAYMESSAGETYPE_INVOKE;
	msg.param1 = fn;
	msg.param2 = arg;
	messageQueue_push(&_this->mq, &msg);
}

//#include<chrono>
/// <summary>
/// 返回當前時間
/// </summary>
/// <returns>當前時間，單位秒，精度微秒</returns>
static double  getCurrentTime()
{
	//此處用的是ffmpeg的av_gettime_relative。如果沒有ffmpeg環(huán)境，則可替換成平臺獲取時鐘的方法：單位為秒，精度需要微妙，相對絕對時鐘都可以。
	return av_gettime_relative() / 1000000.0;
	//return std::chrono::time_point_cast <std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now()).time_since_epoch().count() / 1e+9;
}

/// <summary>
/// 重置時鐘同步
/// 通常用于暫停、定位
/// </summary>
/// <param name="syn">時鐘同步對象</param>
void synchronize_reset(Synchronize* syn) {
	SynchronizeType type = syn->type;
	memset(syn, 0, sizeof(Synchronize));
	syn->type = type;
}

/// <summary>
/// 獲取主時鐘
/// </summary>
/// <param name="syn">時鐘同步對象</param>
/// <returns>主時鐘對象</returns>
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;
}

/// <summary>
/// 獲取主時鐘的時間
/// </summary>
/// <param name="syn">時鐘同步對象</param>
/// <returns>時間，單位s</returns>
double synchronize_getMasterTime(Synchronize* syn) {
	return getCurrentTime() - synchronize_getMasterClock(syn)->startTime;
}

/// <summary>
/// 設置時鐘的時間
/// </summary>
/// <param name="syn">時鐘同步對象</param>
/// <param name="pts">當前時間，單位s</param>
void synchronize_setClockTime(Synchronize* syn, Clock* clock, double pts)
{
	clock->currentPts = pts;
	clock->startTime = getCurrentTime() - pts;
}

/// <summary>
/// 獲取時鐘的時間
/// </summary>
/// <param name="syn">時鐘同步對象</param>
/// <param name="clock">時鐘對象</param>
/// <returns>時間，單位s</returns>
double synchronize_getClockTime(Synchronize* syn, Clock* clock)
{
	return  getCurrentTime() - clock->startTime;
}

/// <summary>
/// 更新視頻時鐘
/// </summary>
/// <param name="syn">時鐘同步對象</param>
/// <param name="pts">視頻幀pts,單位為s</param>
/// <param name="duration">視頻幀時長,單位為s。缺省值為0，內部自動估算duration</param>
/// <returns>大于0則延時值為延時時長，等于0顯示，小于0丟幀</returns>
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;
	}
	修正時間，時鐘和視頻幀偏差超過0.1s時重新設置起點時間。
	//if (diff > 0.1)
	//{
	//	syn->video.startTime = getCurrentTime() - pts;
	//	currentTime = pts;
	//	diff = 0;
	//}
	//時間早了延時
	if (diff < -0.001)
	{
		if (diff < -0.1)
		{
			diff = -0.1;
		}
		//printf("video-time：%.3lfs audio-time:%.3lfs avDiff:%.4lfms early:%.4lfms  \n", getCurrentTime() - syn->video.startTime, getCurrentTime() - syn->audio.startTime, sDiff * 1000, diff * 1000);
		return -diff;
	}
	syn->video.currentPts = pts;
	//時間晚了丟幀，duration為一幀的持續(xù)時間，在一個duration內是正常時間，加一個duration作為閾值來判斷丟幀。
	if (diff > 2 * duration)
	{
		//printf("time:%.3lfs avDiff %.4lfms late for:%.4lfms droped\n", pts, sDiff * 1000, diff * 1000);
		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;
}

//double lastTime = 0;
/// <summary>
/// 更新音頻時鐘
/// </summary>
/// <param name="syn">時鐘同步對象</param>
/// <param name="samples">采樣數</param>
/// <param name="samplerate">采樣率</param>
/// <returns>應該播放的采樣數</returns>
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;
}

/// <summary>
/// 更新音頻時鐘，通過數據長度
/// </summary>
/// <param name="syn">時鐘同步對象</param>
/// <param name="bytesSize">數據長度</param>
/// <param name="samplerate">采樣率</param>
/// <param name="channels">聲道數</param>
/// <param name="bitsPerSample">位深</param>
/// <returns>應該播放的數據長度</returns>
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;
}

//初始化解碼器
static int decoder_init(Play* play, Decoder* decoder, int wantFifoPacketSize, int wantFifoFrameSize) {
	//創(chuàng)建解碼上下文
	decoder->codecContext = avcodec_alloc_context3(NULL);
	AVDictionary* opts = NULL;
	if (decoder->codecContext == NULL)
	{
		LOG_ERROR("Could not allocate AVCodecContext");
		return ERRORCODE_DECODER_CANNOTALLOCATECONTEXT;
	}
	//獲取解碼器
	if (avcodec_parameters_to_context(decoder->codecContext, play->formatContext->streams[decoder->streamIndex]->codecpar) < 0)
	{
		LOG_ERROR("Could not init AVCodecContext");
		return ERRORCODE_DECODER_SETPARAMFAILED;
	}
	AVCodec* codec = avcodec_find_decoder(decoder->codecContext->codec_id);
	if (codec == NULL) {
		LOG_ERROR("Codec not found");
		return ERRORCODE_DECODER_CANNOTFINDDECODER;
	}
	//使用多線程解碼
	if (!av_dict_get(opts, "threads", NULL, 0))
		av_dict_set(&opts, "threads", "auto", 0);
	//打開解碼器
	if (avcodec_open2(decoder->codecContext, codec, &opts) < 0) {
		LOG_ERROR("Could not open codec");
		av_dict_free(&opts);
		return ERRORCODE_DECODER_OPENFAILED;
	}
	av_dict_free(&opts);
	//初始化臨時幀
	decoder->frame = av_frame_alloc();
	if (!decoder->frame)
	{
		LOG_ERROR("Alloc avframe failed");
		return ERRORCODE_FRAME_ALLOCFAILED;
	}
	//初始化包隊列
	decoder->fifoPacket = av_fifo_alloc(sizeof(AVPacket*) * wantFifoPacketSize);
	if (!decoder->fifoPacket)
	{
		LOG_ERROR("alloc packet fifo failed");
		return ERRORCODE_FIFO_ALLOCFAILED;
	}
	//初始化幀隊列
	decoder->fifoFrame = av_fifo_alloc(sizeof(AVFrame*) * wantFifoFrameSize);
	if (!decoder->fifoFrame)
	{
		LOG_ERROR("alloc frame fifo failed");
		return ERRORCODE_FIFO_ALLOCFAILED;
	}
	return 0;
}
//清空解碼隊列
static void decoder_clear(Play* play, Decoder* decoder) {
	//清空包隊列
	if (decoder->fifoPacket)
	{
		while (av_fifo_size(decoder->fifoPacket) > 0)
		{
			AVPacket* packet;
			av_fifo_generic_read(decoder->fifoPacket, &packet, sizeof(AVPacket*), NULL);
			if (packet != &play->packet)
			{
				av_packet_unref(packet);
				av_packet_free(&packet);
			}
		}
	}
	//清空幀隊列
	if (decoder->fifoFrame)
	{
		while (av_fifo_size(decoder->fifoFrame) > 0)
		{
			AVFrame* frame;
			av_fifo_generic_read(decoder->fifoFrame, &frame, sizeof(AVFrame*), NULL);
			av_frame_unref(frame);
			av_frame_free(&frame);
		}
	}

	//清空解碼器緩存
	if (decoder->codecContext)
	{
		avcodec_flush_buffers(decoder->codecContext);
	}
}
//反初始化解碼器
static void decoder_deinit(Play* play, Decoder* decoder)
{
	decoder_clear(play, decoder);
	if (decoder->codecContext)
	{
		avcodec_close(decoder->codecContext);
		avcodec_free_context(&decoder->codecContext);
	}
	if (decoder->fifoPacket)
	{
		av_fifo_free(decoder->fifoPacket);
		decoder->fifoPacket = NULL;
	}
	if (decoder->fifoFrame)
	{
		av_fifo_free(decoder->fifoFrame);
		decoder->fifoFrame = NULL;
	}
	if (decoder->frame)
	{
		if (decoder->frame->format != -1)
		{
			av_frame_unref(decoder->frame);
		}
		av_frame_free(&decoder->frame);
	}
	decoder->eofFrame = 0;
}
//解碼
static int decoder_decode(Play* play, Decoder* decoder) {
	int ret = 0;
	AVPacket* packet = NULL;
	if (decoder->streamIndex == -1)
	{
		LOG_ERROR("Decoder missing a stream");
		return ERRORCODE_DECODER_MISSINGASTREAMTODECODE;
	}
	if (av_fifo_space(decoder->fifoFrame) < 1)
		//幀隊列已滿
	{
		goto end;
	}
	//接收上次解碼的幀
	while (avcodec_receive_frame(decoder->codecContext, decoder->frame) == 0) {
		AVFrame* frame = av_frame_clone(decoder->frame);
		av_frame_unref(decoder->frame);
		av_fifo_generic_write(decoder->fifoFrame, &frame, sizeof(AVFrame*), NULL);
		if (av_fifo_space(decoder->fifoFrame) < 1)
			//幀隊列已滿
		{
			goto end;
		}
	}
	if (av_fifo_size(decoder->fifoPacket) > 0)
		//包隊列有數據，開始解碼
	{
		av_fifo_generic_read(decoder->fifoPacket, &packet, sizeof(AVPacket*), NULL);
		//發(fā)送包
		if (avcodec_send_packet(decoder->codecContext, packet) < 0)
		{
			LOG_ERROR("Decode error");
			ret = ERRORCODE_DECODER_SENDPACKEDFAILED;
			goto end;
		}
		//接收解碼的幀
		while (avcodec_receive_frame(decoder->codecContext, decoder->frame) == 0) {
			AVFrame* frame = av_frame_clone(decoder->frame);
			av_frame_unref(decoder->frame);
			av_fifo_generic_write(decoder->fifoFrame, &frame, sizeof(AVFrame*), NULL);
			if (av_fifo_space(decoder->fifoFrame) < 1)
				//幀隊列已滿
			{
				goto end;
			}
		}
	}
	if (play->eofPacket)
	{
		decoder->eofFrame = 1;
	}
end:
	if (packet && packet != &play->packet)
	{
		av_packet_unref(packet);
		av_packet_free(&packet);
	}
	return ret;
}



//音頻設備播放回調
static void audio_callback(void* userdata, uint8_t* stream, int len) {
	Play* play = (Play*)userdata;
	int samples = 0;
	//讀取隊列中的音頻數據，由于AVAudioFifo非線程安全，且是子線程觸發(fā)此回調，所以需要加鎖
	SDL_LockMutex(play->audio.mutex);
	if (!play->isPaused)
	{
		if (av_audio_fifo_size(play->audio.playFifo) >= play->audio.spec.samples)
		{
			int drain = 0;
			//需要寫入的數據量
			samples = play->audio.spec.samples;
			//時鐘同步，獲取應該寫入的數據量，如果是同步到音頻，則需要寫入的數據量始終等于應該寫入的數據量。
			samples = synchronize_updateAudio(&play->synchronize, samples, play->audio.spec.freq);
			samples += play->audio.accumulateSamples;
			if (samples > av_audio_fifo_size(play->audio.playFifo))
			{
				play->audio.accumulateSamples = samples - av_audio_fifo_size(play->audio.playFifo);
				samples = av_audio_fifo_size(play->audio.playFifo);
			}
			else
			{
				play->audio.accumulateSamples = 0;
			}
			if (samples > play->audio.spec.samples)
				//比需要寫入的數據量大，則丟棄一部分
			{
				drain = samples - play->audio.spec.samples;
				samples = play->audio.spec.samples;
			}
			if (play->audio.volume + SDL_MIX_MAXVOLUME != SDL_MIX_MAXVOLUME)
				//改變音量
			{
				if (!play->audio.mixBuffer)
				{
					play->audio.mixBuffer = (uint8_t*)av_malloc(len);
					if (!play->audio.mixBuffer)
					{
						LOG_ERROR("mixBuffer alloc failed");
						return;
					}
				}
				av_audio_fifo_read(play->audio.playFifo, (void**)&play->audio.mixBuffer, samples);
				int len2 = av_samples_get_buffer_size(0, play->audio.spec.channels, samples, play->audio.forceSampleFormat, 1);
				memset(stream, 0, len2);
				SDL_MixAudioFormat(stream, play->audio.mixBuffer, play->audio.spec.format, len2, play->audio.volume + SDL_MIX_MAXVOLUME);
			}
			else
				//直接寫入
			{
				av_audio_fifo_read(play->audio.playFifo, (void**)&stream, samples);
			}
			av_audio_fifo_drain(play->audio.playFifo, drain);
		}
	}
	SDL_UnlockMutex(play->audio.mutex);
	//補充靜音數據
	int fillSize = av_samples_get_buffer_size(0, play->audio.spec.channels, samples, play->audio.forceSampleFormat, 1);
	if (fillSize < 0)
		fillSize = 0;
	if (len - fillSize > 0)
	{
		memset(stream + fillSize, 0, len - fillSize);
	}

}
//初始化音頻模塊
static int audio_init(Play* play, Audio* audio) {
	//初始化解碼器
	if (decoder_init(play, &audio->decoder, 600, 100) != 0)
	{
		LOG_ERROR("audio decoder init error");
		return 	ERRORCODE_AUDIO_DECODERINITFAILED;
	}
	//初始化sdl
	if ((SDL_WasInit(0) & (SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER)) == 0)
	{
		if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER)) {
			LOG_ERROR("Could not initialize SDL - %s", SDL_GetError());
			return ERRORCODE_SDL_INITFAILED;
		}
	}
	//打開音頻設備
	audio->wantedSpec.channels = av_get_channel_layout_nb_channels(audio->decoder.codecContext->channel_layout);
	audio->wantedSpec.freq = audio->decoder.codecContext->sample_rate;
	audio->wantedSpec.format = AUDIO_F32SYS;
	audio->wantedSpec.silence = 0;
	audio->wantedSpec.samples = FFMAX(512, 2 << av_log2(audio->wantedSpec.freq / 30));
	audio->wantedSpec.callback = audio_callback;
	audio->wantedSpec.userdata = play;
	audio->audioId = SDL_OpenAudioDevice(NULL, 0, &audio->wantedSpec, &audio->spec, SDL_AUDIO_ALLOW_ANY_CHANGE);
	if (audio->audioId < 2)
	{
		LOG_ERROR("Open audio device error");
		return ERRORCODE_SDL_CANNOTOPENDEVICE;
	}
	//匹配音頻格式
	switch (audio->spec.format)
	{
	case	AUDIO_S16SYS:
		audio->forceSampleFormat = AV_SAMPLE_FMT_S16;
		break;
	case	AUDIO_S32SYS:
		audio->forceSampleFormat = AV_SAMPLE_FMT_S32;
		break;
	case	AUDIO_F32SYS:
		audio->forceSampleFormat = AV_SAMPLE_FMT_FLT;
		break;
	default:

		LOG_ERROR("audio device format was not surported %d", (int)audio->spec.format);
		return ERRORCODE_AUDIO_UNSUPORTDEVICESAMPLEFORMAT;
	}
	//初始化音頻幀隊列的互斥鎖
	audio->mutex = SDL_CreateMutex();
	if (!audio->mutex)
	{
		LOG_ERROR("alloc mutex failed");
		return ERRORCODE_SDL_CANNOTCREATEMUTEX;
	}
	//音頻播放隊列
	audio->playFifo = av_audio_fifo_alloc(audio->forceSampleFormat, audio->spec.channels, audio->spec.samples * 30);
	if (!audio->playFifo)
	{
		LOG_ERROR("alloc audio fifo failed");
		return ERRORCODE_FIFO_ALLOCFAILED;
	}
	//設備開啟播放
	SDL_PauseAudioDevice(audio->audioId, 0);
	return 0;
}
//音頻初始化
static void audio_deinit(Play* play, Audio* audio)
{
	if (audio->audioId >= 2)
	{
		SDL_PauseAudioDevice(audio->audioId, 1);
		SDL_CloseAudioDevice(audio->audioId);
		audio->audioId = 0;
	}
	if (audio->mutex)
	{
		SDL_DestroyMutex(audio->mutex);
		audio->mutex = NULL;
	}
	if (play->audio.playFifo)
	{
		av_audio_fifo_free(play->audio.playFifo);
		play->audio.playFifo = NULL;
	}
	if (audio->swrContext)
	{
		swr_free(&audio->swrContext);
	}
	if (audio->swrBuffer)
	{
		av_freep(&audio->swrBuffer);
	}
	if (audio->mixBuffer)
	{
		av_freep(&audio->mixBuffer);
	}
	decoder_deinit(play, &audio->decoder);
	audio->eofPlay = 0;
	audio->sofPlay = 0;
}


//音頻播放
static int audio_play(Play* play, Audio* audio) {
	if (audio->decoder.streamIndex == -1)
	{
		LOG_ERROR("audio play missing audio stream");
		//沒有音頻流
		return ERRORCODE_AUDIO_MISSINGSTREAM;
	}
	if (play->video.decoder.streamIndex != -1 && !play->video.sofDisplay)
	{
		return 0;
	}
	while (av_fifo_size(play->audio.decoder.fifoFrame) > 0)
	{
		AVFrame* frame = NULL;
		uint8_t* data = NULL;
		int dataSize = 0;
		int samples = 0;
		av_fifo_generic_peek(play->audio.decoder.fifoFrame, &frame, sizeof(AVFrame*), NULL);
		if (play->audio.forceSampleFormat != play->audio.decoder.codecContext->sample_fmt || play->audio.spec.freq != frame->sample_rate || play->audio.spec.channels != frame->channels)
			//重采樣
		{
			//計算輸入采樣數
			int out_count = (int64_t)frame->nb_samples * play->audio.spec.freq / frame->sample_rate + 256;
			//計算輸出數據大小
			int out_size = av_samples_get_buffer_size(NULL, play->audio.spec.channels, out_count, play->audio.forceSampleFormat, 0);
			//輸入數據指針
			const uint8_t** in = (const uint8_t**)frame->extended_data;
			//輸出緩沖區(qū)指針
			uint8_t** out = &play->audio.swrBuffer;
			int len2 = 0;
			if (out_size < 0) {
				LOG_ERROR("sample output size value %d was invalid", out_size);
				return ERRORCODE_AUDIO_SAMPLESSIZEINVALID;
			}
			if (!play->audio.swrContext)
				//初始化重采樣對象
			{
				play->audio.swrContext = swr_alloc_set_opts(NULL, av_get_default_channel_layout(play->audio.spec.channels), play->audio.forceSampleFormat, play->audio.spec.freq, play->audio.decoder.codecContext->channel_layout, play->audio.decoder.codecContext->sample_fmt, play->audio.decoder.codecContext->sample_rate, 0, NULL);
				if (!play->audio.swrContext || swr_init(play->audio.swrContext) < 0) {
					LOG_ERROR("swr_alloc_set_opts or swr_init failed");
					return ERRORCODE_AUDIO_SWRINITFAILED;
				}
			}
			if (!play->audio.swrBuffer)
				//申請輸出緩沖區(qū)
			{
				play->audio.swrBuffer = (uint8_t*)av_mallocz(out_size);
				if (!play->audio.swrBuffer)
				{
					LOG_ERROR("audio swr ouput buffer alloc failed");
					return ERRORCODE_MEMORY_ALLOCFAILED;
				}
			}
			//執(zhí)行重采樣
			len2 = swr_convert(play->audio.swrContext, out, out_count, in, frame->nb_samples);
			if (len2 < 0) {
				LOG_ERROR("swr_convert failed");
				return ERRORCODE_AUDIO_CANNOTCONVERSAMPLE;
			}
			//取得輸出數據
			data = play->audio.swrBuffer;
			//輸出數據長度
			dataSize = av_samples_get_buffer_size(0, play->audio.spec.channels, len2, play->audio.forceSampleFormat, 1);
			samples = len2;
		}
		else
			//無需重采樣
		{
			data = frame->data[0];
			dataSize = av_samples_get_buffer_size(frame->linesize, frame->channels, frame->nb_samples, play->audio.forceSampleFormat, 0);
			samples = frame->nb_samples;
		}
		if (dataSize < 0)
		{
			LOG_ERROR("sample data size value %d was invalid", dataSize);
			return ERRORCODE_AUDIO_SAMPLESSIZEINVALID;
		}
		//寫入播放隊列
		SDL_LockMutex(play->audio.mutex);
		if (av_audio_fifo_space(play->audio.playFifo) >= samples)
		{
			//同步(修正)時鐘
			AVRational timebase = play->formatContext->streams[audio->decoder.streamIndex]->time_base;
			//當前幀的時間戳
			double pts = (double)frame->pts * timebase.num / timebase.den;
			//減去播放隊列剩余數據的時長就是當前的音頻時鐘
			pts -= (double)av_audio_fifo_size(play->audio.playFifo) / play->audio.spec.freq;
			//設置音頻時鐘
			synchronize_setClockTime(&play->synchronize, &play->synchronize.audio, pts);
			//同步(修正)時鐘--end
			//寫入播放隊列
			av_audio_fifo_write(play->audio.playFifo, (void**)&data, samples);
			//解碼隊列的幀出隊
			av_fifo_generic_read(play->audio.decoder.fifoFrame, &frame, sizeof(AVFrame*), NULL);
			av_frame_unref(frame);
			av_frame_free(&frame);
			if (!audio->sofPlay)
				//標記開始
			{
				audio->sofPlay = 1;
			}
		}
		else
		{
			SDL_UnlockMutex(play->audio.mutex);
			break;
		}
		SDL_UnlockMutex(play->audio.mutex);
	}
	//計算睡眠延時
	SDL_LockMutex(play->audio.mutex);
	double canSleepTime = (double)av_audio_fifo_size(play->audio.playFifo) / play->audio.spec.freq;
	double wakeupTime = getCurrentTime() + canSleepTime;
	if (play->video.decoder.streamIndex == -1 || wakeupTime < play->wakeupTime)
	{
		play->wakeupTime = wakeupTime;
	}
	SDL_UnlockMutex(play->audio.mutex);
	if (av_fifo_size(play->audio.decoder.fifoFrame) < 1 && audio->decoder.eofFrame)
		//標記結束
	{
		audio->eofPlay = 1;
	}
	return 0;
}

//初始化視頻模塊
static int video_init(Play* play, Video* video) {
	//初始化解碼器
	if (decoder_init(play, &video->decoder, 600, 1) != 0)
	{
		LOG_ERROR("video decoder init error");
		return ERRORCODE_VIDEO_DECODERINITFAILED;
	}
	//初始化sdl
	if ((SDL_WasInit(0) & (SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER)) == 0)
	{
		if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER)) {
			LOG_ERROR("Could not initialize SDL - %s", SDL_GetError());
			return ERRORCODE_SDL_INITFAILED;
		}
	}
	return 0;
}
//反初始化視頻模塊
static void video_deinit(Play* play, Video* video) {
	if (video->swsContext)
	{
		sws_freeContext(video->swsContext);
		video->swsContext = NULL;
	}
	if (video->swsBuffer)
	{
		av_free(video->swsBuffer);
		video->swsBuffer = NULL;
	}
	if (video->sdlTexture)
	{
		SDL_DestroyTexture(video->sdlTexture);
		video->sdlTexture = NULL;
	}
	if (video->sdlRenderer)
	{
		SDL_DestroyRenderer(video->sdlRenderer);
		video->sdlRenderer = NULL;
	}
	if (video->screen)
	{
		SDL_DestroyWindow(video->screen);
		video->screen = NULL;
	}
	decoder_deinit(play, &video->decoder);
	video->eofDisplay = 0;
	video->sofDisplay = 0;

}


double get_rotation(AVStream* st)
{
	AVDictionaryEntry* rotate_tag = av_dict_get(st->metadata, "rotate", NULL, 0);
	double theta = 0;
	if (rotate_tag && *rotate_tag->value && strcmp(rotate_tag->value, "0")) {
		theta = atof(rotate_tag->value);
	}
	theta -= 360 * floor(theta / 360 + 0.9 / 360);
	if (fabs(theta - 90 * round(theta / 90)) > 2)
	{
		LOG_INFO("Odd rotation angle");
	}
	return theta;

}


/// <summary>
/// 計算旋轉的矩形大小
/// </summary>
/// <param name="src">原圖像區(qū)域</param>
/// <param name="dst">目標區(qū)域</param>
/// <param name="angle">旋轉角度</param>
/// <returns></returns>
static SDL_Rect getRotateRect(SDL_Rect *srcRect, SDL_Rect* dstRect,double angle) {
	SDL_Rect targetRect;
	const double PI = 3.1415926535897935384626;
	double theta = PI / 180.0 * angle;
	//計算旋轉后的邊框大小
	int width = srcRect->h * fabs(sin(theta) )+ srcRect->w * fabs(cos(theta)) + 0.5;
	int height = srcRect->h * fabs(cos(theta)) + srcRect->w * fabs(sin(theta)) + 0.5;
	double srcRatio = (double)srcRect->w / srcRect->h;
	double srcBorderRatio = (double)width / height;
	double dstRatio = (double)dstRect->w / dstRect->h;
	//計算邊框縮放到目標區(qū)域的大小
	int zoomWidth;
	int zoomHeight;
	if (srcBorderRatio > dstRatio)
	{
		zoomWidth = dstRect->w;
		zoomHeight = dstRect->w / srcBorderRatio;
	}
	else
	{
		zoomWidth = dstRect->h * srcBorderRatio;
		zoomHeight = dstRect->h;
	}
	//通過縮放后的邊框計算還原的圖像大小
	targetRect.h = (double)zoomWidth / (fabs(sin(theta) )+ srcRatio * fabs(cos(theta)));
	targetRect.w = targetRect.h * srcRatio;
	targetRect.x = (dstRect->w- targetRect.w ) / 2;
	targetRect.y = (dstRect->h- targetRect.h ) / 2;
	return targetRect;
}

//渲染到窗口
static int video_present(Play* play, Video* video, AVFrame* frame)
{
	SDL_Rect sdlRect;
	SDL_Rect sdlRect2;
	uint8_t* dst_data[4];
	int dst_linesize[4];

	if (!video->screen)
	{
		//創(chuàng)建窗口
		video->screen = SDL_CreateWindow("video play window", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
			video->screen_w, video->screen_h,
			SDL_WINDOW_OPENGL);
		if (!video->screen) {
			LOG_ERROR("SDL: could not create window - exiting:%s\n", SDL_GetError());
			return ERRORCODE_SDL_CREATEWINDOWFAILED;
		}
	}
	if (!video->sdlRenderer)
		//初始化sdl紋理
	{
		video->angle = get_rotation(play->formatContext->streams[play->video.decoder.streamIndex]);
		video->sdlRenderer = SDL_CreateRenderer(video->screen, -1, 0);
		if (!video->sdlRenderer)
		{
			LOG_ERROR("Create sdl renderer error");
			return ERRORCODE_SDL_CREATERENDERERFAILED;
		}
		//獲取合適的像素格式
		struct TextureFormatEntry format;
		format.format = AV_PIX_FMT_YUV420P;
		format.texture_fmt = SDL_PIXELFORMAT_IYUV;
		for (int i = 0; i < sizeof(sdl_texture_format_map) / sizeof(struct TextureFormatEntry); i++)
		{
			if (sdl_texture_format_map[i].format == video->decoder.codecContext->pix_fmt)
			{
				format = sdl_texture_format_map[i];
				break;
			}
		}
		video->forcePixelFormat = format.format;

		//創(chuàng)建和視頻大小一樣的紋理
		video->sdlTexture = SDL_CreateTexture(video->sdlRenderer, format.texture_fmt, SDL_TEXTUREACCESS_STREAMING, video->decoder.codecContext->width, video->decoder.codecContext->height);
		if (!video->sdlTexture)
		{
			LOG_ERROR("Create sdl texture error");
			return ERRORCODE_SDL_CREATETEXTUREFAILED;
		}
	}

	if (video->forcePixelFormat != video->decoder.codecContext->pix_fmt)
		//重采樣-格式轉換
	{
		video->swsContext = sws_getCachedContext(video->swsContext, video->decoder.codecContext->width, video->decoder.codecContext->height, video->decoder.codecContext->pix_fmt, video->decoder.codecContext->width, video->decoder.codecContext->height, video->forcePixelFormat, SWS_FAST_BILINEAR, NULL, NULL, NULL);
		if (!video->swsContext)
		{
			LOG_ERROR("sws_getCachedContext failed");
			return ERRORCODE_VIDEO_CANNOTGETSWSCONTEX;
		}
		if (!video->swsBuffer)
		{
			video->swsBuffer = (uint8_t*)av_malloc(av_image_get_buffer_size(video->forcePixelFormat, video->decoder.codecContext->width, video->decoder.codecContext->height, 64));
			if (video->swsBuffer)
			{
				LOG_ERROR("audio swr ouput buffer alloc failed");
				return ERRORCODE_MEMORY_ALLOCFAILED;
			}
		}
		if (av_image_fill_arrays(dst_data, dst_linesize, video->swsBuffer, video->forcePixelFormat, video->decoder.codecContext->width, video->decoder.codecContext->height, 1) < 0)
		{
			LOG_ERROR("sws_getCachedContext failed");
			return ERRORCODE_VIDEO_IMAGEFILLARRAYFAILED;
		}

		if (sws_scale(video->swsContext, frame->data, frame->linesize, 0, frame->height, dst_data, dst_linesize) < 0)
		{
			LOG_ERROR("Call sws_scale error");
			return ERRORCODE_VIDEO_CANNOTRESAMPLEAFRAME;
		}
	}
	else
		//無需重采樣
	{
		memcpy(dst_data, frame->data, sizeof(uint8_t*) * 4);
		memcpy(dst_linesize, frame->linesize, sizeof(int) * 4);
	}

	//窗口區(qū)域
	sdlRect.x = 0;
	sdlRect.y = 0;
	sdlRect.w = video->screen_w;
	sdlRect.h = video->screen_h;
	//視頻區(qū)域
	sdlRect2.x = 0;
	sdlRect2.y = 0;
	sdlRect2.w = video->decoder.codecContext->width;
	sdlRect2.h = video->decoder.codecContext->height;
	//渲染到sdl窗口
	SDL_RenderClear(video->sdlRenderer);
	SDL_UpdateYUVTexture(video->sdlTexture, &sdlRect2, dst_data[0], dst_linesize[0], dst_data[1], dst_linesize[1], dst_data[2], dst_linesize[2]);
	if (video->angle == 0)
		SDL_RenderCopy(video->sdlRenderer, video->sdlTexture, NULL, &sdlRect);
	else
		//旋轉視頻
	{
		SDL_Rect sdlRect3;
		sdlRect3= getRotateRect(&sdlRect2,&sdlRect,video->angle);
		SDL_RenderCopyEx(video->sdlRenderer, video->sdlTexture, NULL
			, &sdlRect3, video->angle, 0, SDL_FLIP_NONE);
	}
	SDL_RenderPresent(video->sdlRenderer);
}

//視頻顯示
static int video_display(Play* play, Video* video) {
	if (play->video.decoder.streamIndex == -1)
		//沒有視頻流
	{
		return ERRORCODE_VIDEO_MISSINGSTREAM;
	}
	if (play->audio.decoder.streamIndex != -1 && video->sofDisplay && !play->audio.sofPlay)
		return 0;
	AVFrame* frame = NULL;
	if (av_fifo_size(video->decoder.fifoFrame) > 0)
	{
		av_fifo_generic_peek(video->decoder.fifoFrame, &frame, sizeof(AVFrame*), NULL);
		//---------------時鐘同步--------------		
		AVRational timebase = play->formatContext->streams[video->decoder.streamIndex]->time_base;
		//計算視頻幀的pts
		double	pts = frame->pts * (double)timebase.num / timebase.den;
		//視頻幀的持續(xù)時間
		double duration = frame->pkt_duration * (double)timebase.num / timebase.den;
		double delay = synchronize_updateVideo(&play->synchronize, pts, duration);
		if (delay > 0)
			//延時
		{
			play->wakeupTime = getCurrentTime() + delay;
			return 0;
		}
		else if (delay < 0)
			//丟幀
		{
			av_fifo_generic_read(video->decoder.fifoFrame, &frame, sizeof(AVFrame*), NULL);
			av_frame_unref(frame);
			av_frame_free(&frame);
			return 0;
		}
		else
			//播放
		{
			av_fifo_generic_read(video->decoder.fifoFrame, &frame, sizeof(AVFrame*), NULL);
		}
		//---------------時鐘同步--------------	end
	}
	else if (video->decoder.eofFrame)
	{
		video->sofDisplay = 1;
		//標記結束
		video->eofDisplay = 1;
	}
	if (frame)
	{
		//渲染
		video_present(play, video, frame);
		av_frame_unref(frame);
		av_frame_free(&frame);
		if (!video->sofDisplay)
			video->sofDisplay = 1;
		if (play->step)
		{
			play->step--;
		}
	}
	return 0;
}



static int interrupt_cb(void* arg) {
	Play* play = (Play*)arg;
	return play->exitFlag;
}


//打開輸入流
static int packet_open(Play* play) {
	//打開輸入流
	play->formatContext = avformat_alloc_context();
	play->formatContext->interrupt_callback.callback = interrupt_cb;
	play->formatContext->interrupt_callback.opaque = play;
	if (avformat_open_input(&play->formatContext, play->url, NULL, NULL) != 0) {
		LOG_ERROR("Couldn't open input stream");
		return ERRORCODE_PACKET_CANNOTOPENINPUTSTREAM;
	}
	//查找輸入流信息
	if (avformat_find_stream_info(play->formatContext, NULL) < 0) {
		LOG_ERROR("Couldn't find stream information");
		return ERRORCODE_PACKET_CANNOTFINDSTREAMINFO;
	}
	//ignore = 0;
	play->video.decoder.streamIndex = -1;
	//獲取視頻流
	for (unsigned i = 0; i < play->formatContext->nb_streams; i++)
		if (play->formatContext->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
			play->video.decoder.streamIndex = i;
			break;
		}
	play->audio.decoder.streamIndex = -1;
	//獲取音頻流
	for (unsigned i = 0; i < play->formatContext->nb_streams; i++)
		if (play->formatContext->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
			play->audio.decoder.streamIndex = i;
			break;
		}
	//沒有找到任何流
	if (play->video.decoder.streamIndex == -1 && play->audio.decoder.streamIndex == -1) {
		LOG_ERROR("Didn't find any stream.");
		return ERRORCODE_PACKET_DIDNOTFINDDANYSTREAM;
	}
	play->eofPacket = 0;
	return 0;
}

//異步讀取包完成后的操作
static int packet_readAwait(void* arg)
{
	Play* play = (Play*)arg;
	if (play->eofPacket == 0)
	{
		if (play->packet.stream_index == play->video.decoder.streamIndex)
			//寫入視頻包隊
		{
			AVPacket* packet = av_packet_clone(&play->packet);
			av_fifo_generic_write(play->video.decoder.fifoPacket, &packet, sizeof(AVPacket*), NULL);
		}
		else if (play->packet.stream_index == play->audio.decoder.streamIndex)
			//寫入音頻包隊
		{
			AVPacket* packet = av_packet_clone(&play->packet);
			av_fifo_generic_write(play->audio.decoder.fifoPacket, &packet, sizeof(AVPacket*), NULL);
		}
		av_packet_unref(&play->packet);
	}
	else if (play->eofPacket == AVERROR_EOF)
	{
		play->eofPacket = 1;
		//寫入空包flush解碼器中的緩存
		AVPacket* packet = &play->packet;
		if (play->audio.decoder.fifoPacket)
			av_fifo_generic_write(play->audio.decoder.fifoPacket, &packet, sizeof(AVPacket*), NULL);
		if (play->video.decoder.fifoPacket)
			av_fifo_generic_write(play->video.decoder.fifoPacket, &packet, sizeof(AVPacket*), NULL);
	}
	else
	{
		LOG_ERROR("read packet erro!\n");
		play->exitFlag = 1;
		play->isAsyncReading = 0;
		return ERRORCODE_PACKET_READFRAMEFAILED;
	}
	play->isAsyncReading = 0;
	return 0;
}

//異步讀取包
static int packet_readAsync(void* arg)
{
	Play* play = (Play*)arg;
	play->eofPacket = av_read_frame(play->formatContext, &play->packet);
	//回到播放線程處理包
	play_beginInvoke(play, packet_readAwait, play);
	return 0;
}

//讀取包
static int packet_read(Play* play) {
	if (play->isAsyncReading)
		return 0;
	if (play->eofPacket)
	{
		return 0;
	}
	if (play->video.decoder.streamIndex != -1 && av_fifo_space(play->video.decoder.fifoPacket) < 1)
		//視頻包隊列已滿
	{
		return 0;
	}
	if (play->audio.decoder.streamIndex != -1 && av_fifo_space(play->audio.decoder.fifoPacket) < 1)
		//音頻包隊列已滿
	{
		return 0;
	}
	if (!_pool)
		//初始化線程池
	{
		_pool = (ThreadPool*)av_mallocz(sizeof(ThreadPool));
		threadPool_init(_pool, 32);
	}
	play->isAsyncReading = 1;
	//異步讀取包
	threadPool_run(_pool, packet_readAsync, play);
	return 0;
}
static void play_eventHandler(Play* play);
//等待讀包結束
static void packet_waitAsyncReadFinished(Play* play) {
	//確保異步操作結束
	while (play->isAsyncReading)
	{
		av_usleep(0.01 * 1000000);
		play_eventHandler(play);
	}
}

//關閉輸入流
static void packet_close(Play* play) {
	packet_waitAsyncReadFinished(play);
	if (play->packet.data)
	{
		av_packet_unref(&play->packet);
	}
	if (play->formatContext)
	{
		avformat_close_input(&play->formatContext);
	}
}

//定位
static int packet_seek(Play* play, double time) {
	packet_waitAsyncReadFinished(play);
	return avformat_seek_file(play->formatContext, -1, INT64_MIN, time * AV_TIME_BASE, INT64_MAX, 0) >= 0;
}



//設置窗口大小
void play_setWindowSize(Play* play, int width, int height) {
	play->video.screen_w = width;
	play->video.screen_h = height;
}


//定位
void play_seek(Play* play, double time) {

	if (time < 0)
	{
		time = 0;
	}
	if (packet_seek(play, time))
	{
		//重置屬性
		play->audio.accumulateSamples = 0;
		play->audio.sofPlay = 0;
		play->video.sofDisplay = 0;
		//清除緩存
		decoder_clear(play, &play->video.decoder);
		decoder_clear(play, &play->audio.decoder);
		avformat_flush(play->formatContext);
		if (play->audio.playFifo)
		{
			SDL_LockMutex(play->audio.mutex);
			av_audio_fifo_reset(play->audio.playFifo);
			synchronize_reset(&play->synchronize);
			SDL_UnlockMutex(play->audio.mutex);
		}
		else
		{
			synchronize_reset(&play->synchronize);
		}
		//暫停時需要播放一幀
		play->step = 1;
	}
}

//暫停
void play_pause(Play* play, int isPaused) {
	if (play->isPaused == isPaused)
		return;
	if (!isPaused)
	{
		play->audio.sofPlay = 0;
		play->video.sofDisplay = 0;
		synchronize_reset(&play->synchronize);
	}
	play->isPaused = isPaused;
}

//靜音
void play_setVolume(Play* play, int value) {
	//移動到0作為最大音量。則初始化memset后不需要設置默認音量。
	if (value < 0)
		value = 0;
	value -= SDL_MIX_MAXVOLUME;
	if (play->audio.volume == value)
		return;
	play->audio.volume = value;
}

int play_getVolume(Play* play) {
	return play->audio.volume + SDL_MIX_MAXVOLUME;
}

//事件處理
static void play_eventHandler(Play* play) {

	PlayMessage msg;
	while (messageQueue_poll(&play->mq, &msg)) {
		switch (msg.type)
		{
		case PLAYMESSAGETYPE_INVOKE:
			SDL_ThreadFunction fn = (SDL_ThreadFunction)msg.param1;
			fn(msg.param2);
			break;
		}
	}

	//處理窗口消息
	SDL_Event sdl_event;
	if (SDL_PollEvent(&sdl_event))
	{
		switch (sdl_event.type)
		{
		case SDL_WINDOWEVENT:
			if (sdl_event.window.event == SDL_WINDOWEVENT_CLOSE)
				play->exitFlag = 1;
			break;
		case SDL_KEYDOWN:
			switch (sdl_event.key.keysym.sym) {
			case SDLK_UP:
				play_setVolume(play, play_getVolume(play) + 20);
				break;
			case SDLK_DOWN:
				play_setVolume(play, play_getVolume(play) - 20);
				break;
			case SDLK_LEFT:
				play_seek(play, synchronize_getMasterTime(&play->synchronize) - 10);
				break;
			case SDLK_RIGHT:
				play_seek(play, synchronize_getMasterTime(&play->synchronize) + 10);
				break;
			case SDLK_SPACE:
				play_pause(play, !play->isPaused);
				break;
			default:
				break;
			}
			break;
		}
	}
}

//播放循環(huán)
static int play_loop(Play* play)
{
	int ret = 0;
	double remainingTime = 0;
	while (!play->exitFlag)
	{
		if (!play->isPaused || play->step)
		{
			//解復用
			if ((ret = packet_read(play)) != 0)
			{
				LOG_ERROR("read packet error");
				ret = ERRORCODE_PLAY_READPACKETERROR;
				break;
			}
			//視頻解碼
			if ((ret = decoder_decode(play, &play->video.decoder)) != 0)
			{
				LOG_ERROR("video decode error");
				ret = ERRORCODE_PLAY_VIDEODECODEERROR;
				break;
			}
			//音頻解碼
			if ((ret = decoder_decode(play, &play->audio.decoder)) != 0)
			{
				LOG_ERROR("audio decode error");
				ret = ERRORCODE_PLAY_AUDIODECODEERROR;
				break;
			}
			//延時等待
			remainingTime = (play->wakeupTime - getCurrentTime()) / 2;
			if (remainingTime > 0)
			{
				av_usleep(remainingTime * 1000000);
			}
			//視頻顯示
			if ((ret = video_display(play, &play->video)) != 0)
			{
				LOG_ERROR("video display error");
				ret = ERRORCODE_PLAY_VIDEODISPLAYERROR;
				break;
			}
			//音頻播放
			if ((ret = audio_play(play, &play->audio)) != 0)
			{
				LOG_ERROR("audio play error");
				ret = ERRORCODE_PLAY_AUDIOPLAYERROR;
				break;
			}
			//檢查結尾
			if ((play->video.decoder.streamIndex == -1 || play->video.eofDisplay) && (play->audio.decoder.streamIndex == -1 || play->audio.eofPlay))
			{
				if (!play->isLoop)
					break;
				//循環(huán)播放，定位到起點
				play->eofPacket = 0;
				play->audio.decoder.eofFrame = 0;
				play->video.decoder.eofFrame = 0;
				play->audio.eofPlay = 0;
				play->video.eofDisplay = 0;
				play_seek(play, 0);
				continue;
			}
		}
		else
		{
			av_usleep(0.01 * 1000000);
		}
		//處理消息
		play_eventHandler(play);
	}

	return ret;
}

/// <summary>
/// 播放
/// 單線程阻塞播放
/// </summary>
/// <param name="play">播放器對象</param>
/// <param name="url">輸入流的地址，可以是本地路徑、http、https、rtmp、rtsp等</param>
/// <returns>錯誤碼，0表示無錯誤</returns>
int play_exec(Play* play, const char* url) {
	int ret = 0;
	play->url = (char*)url;
	//打開輸入流
	if ((ret = packet_open(play)) != 0)
	{
		LOG_ERROR("open input error");
		ret = ERRORCODE_PLAY_OPENINPUTSTREAMFAILED;
		goto end;
	}
	//初始化視頻模塊
	if (play->video.decoder.streamIndex != -1)
	{
		if ((ret = video_init(play, &play->video)) != 0)
		{
			LOG_ERROR("init video error");
			ret = ERRORCODE_PLAY_VIDEOINITFAILED;
			goto end;
		}
	}
	//初始化音頻模塊
	if (play->audio.decoder.streamIndex != -1)
	{
		if ((ret = audio_init(play, &play->audio)) != 0)
		{
			LOG_ERROR("init audio error");
			ret = ERRORCODE_PLAY_AUDIOINITFAILED;
			goto end;
		}
	}
	else
	{
		play->synchronize.type = SYNCHRONIZETYPE_ABSOLUTE;
	}
	//初始化消息隊列
	if ((ret = messageQueue_init(&play->mq, 500, sizeof(PlayMessage))) != 0)
	{
		LOG_ERROR("open input error");
		ret = ERRORCODE_PLAY_OPENINPUTSTREAMFAILED;
		goto end;
	}
	//進入播放循環(huán)進行：解碼-渲染-播放
	if ((ret = play_loop(play)) != 0)
	{
		ret = ERRORCODE_PLAY_LOOPERROR;
	}
end:
	//銷毀資源	
	if (play->video.decoder.streamIndex != -1)
	{
		video_deinit(play, &play->video);
	}
	if (play->audio.decoder.streamIndex != -1)
	{
		audio_deinit(play, &play->audio);
	}

	packet_close(play);
	synchronize_reset(&play->synchronize);
	messageQueue_deinit(&play->mq);
	play->url = NULL;
	play->exitFlag = 0;
	return ret;
}


/// <summary>
/// 退出播放
/// </summary>
/// <param name="play">播放器對象</param>
void play_exit(Play* play)
{
	play->exitFlag = 1;
}
#undef main
int main(int argc, char** argv) {
	Play play;
	//memset相當于初始化
	memset(&play, 0, sizeof(Play));
	play_setWindowSize(&play, 640, 360);
	play.isLoop = 1;
	//單線程阻塞播放
	return play_exec(&play, "D:\\test.mp4");
}

完整代碼項目：vs2022、makefile，Windows、Linux都可以運行，Linux需要自行配置ffmpeg和sdl

四、使用示例

#undef main
int main(int argc, char** argv) {
    Play play;
    //memset相當于初始化
    memset(&play, 0, sizeof(Play));
    play_setWindowSize(&play, 640, 360);
    play.isLoop = 1;
    //單線程阻塞播放。左快退、右快進、上下調音量、空格暫停。
    return play_exec(&play, "D:\\test.mp4");
}

總結

以上就是今天要講的內容，本文的播放器驗證了單線程播放是可行的，尤其是播放本地文件可以做到完全單線程，那這樣對于實現視頻剪輯工具就有很大的幫助了，每多一條軌道只需要增加一個線程。而且采用異步讀包之后也能正常播放網絡流，2個線程播放視頻依然比ffplay要優(yōu)化。

到此這篇關于C語言使用ffmpeg實現單線程異步的視頻播放器的文章就介紹到這了,更多相關C語言 ffmpeg視頻播放器內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

您可能感興趣的文章:

C++中的動態(tài)規(guī)劃子序列問題分析探討
可能有些讀者有接觸過動態(tài)規(guī)劃，可能也有一些讀者以前完全不知道動態(tài)規(guī)劃這個東西，別擔心，我這篇文章會為讀者做一個入門，好讓讀者掌握這個重要的知識點
2023-03-03
C++中inline用法案例詳解
這篇文章主要介紹了C++中inline用法案例詳解,本篇文章通過簡要的案例,講解了該項技術的了解與使用,以下就是詳細內容,需要的朋友可以參考下
2021-09-09
C語言strlen函數實現讀取字符串長度詳解
這篇文章主要介紹了用C語言的strlen函數來實現讀取字符串長度的過程，strlen所作的是一個計數器的工作，它從內存的某個位置開始掃描，直到碰到第一個字符串結束符'\0'為止
2022-04-04
C++命名空間實例詳解
這篇文章主要介紹了C++命名空間實例詳解，有感興趣的同學可以研究下
2021-02-02
C語言簡明分析選擇結構和循環(huán)結構的使用
C語言條件控制語句選擇結構，是屬于計算機的語言編輯，有在C語言條件控制中的語句選擇結構的存在，即是C語言條件控制語句選擇結構，循環(huán)控制語句是一個基于C語言的編程語句，該語句主要有while循環(huán)語句、do-while循環(huán)語句和for循環(huán)語句來實現循環(huán)結構
2022-04-04
C語言中char*和char[]用法區(qū)別分析
這篇文章主要介紹了C語言中char*和char[]用法區(qū)別,包括使用過程中的誤區(qū)及注意點分析,需要的朋友可以參考下
2014-09-09
基于稀疏圖上的Johnson算法的詳解
本篇文章介紹了，稀疏圖上的Johnson算法的詳解。需要的朋友參考下
2013-05-05
visual studio code 配置C++開發(fā)環(huán)境的教程詳解（windows 開發(fā)環(huán)境）
這篇文章主要介紹了 windows 開發(fā)環(huán)境下visual studio code 配置C++開發(fā)環(huán)境的圖文教程，本文給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值,需要的朋友可以參考下
2020-03-03
C語言之包含min函數的棧實例詳解
這篇文章主要為大家詳細介紹了C語言之包含min函數的棧，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下，希望能夠給你帶來幫助
2022-02-02
Qt6+QML實現Windows屏幕錄制功能
Qt6提供了很多豐富的多媒體支持類,本文將為大家詳細介紹一下Qt6如何結合QML實現Windows屏幕錄制功能,文中的示例代碼簡潔易懂,有需要的小伙伴可以參考一下
2025-04-04