(ffmpeg)ffmpeg+SDL2的简单音视频播放器2

在上一章的基础上添加了包队列和帧队列，有些和上一章相同的地方注释不再赘述。

(ffmpeg)ffmpeg+SDL2的简单音视频播放器

player.cpp

/*
1) 所有在类里声明的回调函数必须为静态函数，且只能调用静态变量，所以都传递了this指针
2) 关闭窗口时，先置标志，然后等待所有线程退出，事件处理线程等待其他所有线程退出后退出
3) 相比1.0版本，把取包和解码分为两个线程，转换放在音视频线程中，但是感觉解码和转换放在一起更合适，且帧队列改为转换后帧的队列
*/
#include "player.h"

using namespace player;

#define ASSERT(c)   do{if(c == NULL){printf("%s is NULL\n",#c);return -1;}}while(0);

#if 1

#define dprintf(fmt,args...)    printf(fmt,##args)

#else

#define dprintf(fmt,args...)

#endif

Player::Player(const char *file):
    screenH(0)
    ,screenW(0)
    ,filename(NULL)
    ,isEventClose(true)
    ,pFormatCtx(NULL)
    ,pPacket(NULL)
    ,pCodec(NULL)
    ,isReadPackClose(true)
    ,isDecodeClose(true)
    ,isAudioClose(true)
    ,isVideoClose(true)
    ,audioStreamIndex(-1)
    ,videoStreamIndex(-1)
    ,eventThread(NULL)
    ,readPackThread(NULL)
    ,decodeThread(NULL)
    ,audioPlayerThread(NULL)
    ,videoPlayerThread(NULL)
{
    if(file)
    {
        filename = (char *)malloc(strlen(file)+1);
        if(filename)
            sprintf(filename,"%s",file);
    }
    else
        filename = NULL;
    avformat_network_init();
    pMutex = SDL_CreateMutex();
    closeOver.allOver = 0;
}
Player::~Player()
{
    if(filename)
        free(filename);
    SDL_DestroyMutex(pMutex);
}
int Player::versionShow(void)
{
    dprintf(VERSION);
    return 0;
}
//同1.0注释，不再赘述
int Player::init(void)
{
    pFormatCtx = avformat_alloc_context();
    ASSERT(pFormatCtx)
    dprintf("filename:%s\n",filename);
	if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER | SDL_INIT_EVENTS)) {  
		dprintf( "Could not initialize SDL - %s\n", SDL_GetError()); 
		return -1;
	}else
    {
        if(avformat_open_input(&pFormatCtx,filename,NULL,NULL)!=0){
            dprintf("Couldn't open input stream.\n");
            return -1;
        }
        if(avformat_find_stream_info(pFormatCtx,NULL)<0){
            dprintf("Couldn't find stream information.\n");
            return -1;
        }
        av_dump_format(pFormatCtx, 0, filename, false);
        eventThread = SDL_CreateThread(eventLoop,"event",(void *)this);
        ASSERT(eventThread)  
        isEventClose = false;      
        readPackThread = SDL_CreateThread(readPackLoop,"readpack",(void *)this);
        ASSERT(readPackThread)
    }
    return 0;
}
int Player::exit(void)
{
    //想要音视频线程结束，直接置标志即可
    if(closeOver.closeSingle.audioOver == 0)
    {
        isAudioClose = true;
    }
    if(closeOver.closeSingle.videoOver == 0)
    {
        isVideoClose = true;
    }
    //解码线程有可能处于等待条件变量的状态，所以结束时先置标志位，再从等待状态唤醒
    if(closeOver.closeSingle.decodeOver == 0)
    {
        if(!isDecodeClose)
        {
            isDecodeClose = true; 
            SDL_LockMutex(pCodec[videoStreamIndex].pFrameQueue->pMutex);
            SDL_CondSignal(pCodec[videoStreamIndex].pFrameQueue->pCond);
            SDL_UnlockMutex(pCodec[videoStreamIndex].pFrameQueue->pMutex);  
            SDL_LockMutex(pCodec[audioStreamIndex].pFrameQueue->pMutex);
            SDL_CondSignal(pCodec[audioStreamIndex].pFrameQueue->pCond);
            SDL_UnlockMutex(pCodec[audioStreamIndex].pFrameQueue->pMutex);     
        }
    }
    //解包线程同上
    if(closeOver.closeSingle.readPacketOver == 0)
    {
        isReadPackClose = true;   
        SDL_LockMutex(packetQueue.pMutex);
        SDL_CondSignal(packetQueue.pCond);
        SDL_UnlockMutex(packetQueue.pMutex);     
    }  
    //按资源依赖顺序释放线程后，阻塞等待线程结束
    while(closeOver.allOver != 0xF);
    SDL_Quit();
    if(pFormatCtx)
    {
        avformat_close_input(&pFormatCtx);
        pFormatCtx = NULL;
    }
    isEventClose = true;
    return 0;
}
int Player::keyEvent(int key)
{
    switch (key)
    {
    case SDLK_SPACE:
        
        break;
    
    default:
        break;
    }
    return 0;
}

int Player::eventLoop(void *pthis)
{
    ASSERT(pthis)
    SDL_Event event;
    Player *tmpthis = (Player *) pthis;
    tmpthis->isEventClose = false;
    while((!tmpthis->isEventClose) && (pthis !=NULL))
    {
        SDL_WaitEvent(&event);
        switch (event.type)
        {
        case SDL_KEYDOWN:
            tmpthis->keyEvent(event.key.keysym.sym);
            break;
        case SDL_QUIT:
            tmpthis->exit();
            break;
        default:
            break;
        }
    }
    dprintf("leave eventLoop\n");
    return 0;
}
//同1.0基本相同，多添加了队列初始化
int Player::codecContextInit(int streamIndex)
{
    dprintf("Init %d\n",streamIndex);
    pCodec[streamIndex].pCodeCtx = avcodec_alloc_context3(NULL);
    ASSERT(pCodec[streamIndex].pCodeCtx)
    avcodec_parameters_to_context(pCodec[streamIndex].pCodeCtx,pFormatCtx->streams[streamIndex]->codecpar);
    pCodec[streamIndex].pCodeCtx->pkt_timebase = pFormatCtx->streams[streamIndex]->time_base;
    pCodec[streamIndex].pAvCodec = avcodec_find_decoder(pCodec[streamIndex].pCodeCtx->codec_id);
    ASSERT(pCodec[streamIndex].pAvCodec)
    if(avcodec_open2(pCodec[streamIndex].pCodeCtx, pCodec[streamIndex].pAvCodec,NULL)<0){
        dprintf("Could not open codec.\n");
        return -1;
    }
    switch (pFormatCtx->streams[streamIndex]->codecpar->codec_type)
    {
    case AVMEDIA_TYPE_VIDEO:
    dprintf("AVMEDIA_TYPE_VIDEO\n");
        videoStreamIndex = streamIndex;
        if(pCodec[streamIndex].pCodeCtx->pix_fmt == AV_PIX_FMT_YUV420P)
        {
            pCodec[streamIndex].pFrame = av_frame_alloc();
            ASSERT(pCodec[streamIndex].pFrame)
            pCodec[streamIndex].videoOutFmt.pOutFrame = av_frame_alloc();
            ASSERT(pCodec[streamIndex].videoOutFmt.pOutFrame)
            pCodec[streamIndex].pBuffer=(unsigned char *)av_malloc(av_image_get_buffer_size(AV_PIX_FMT_YUV420P,  pCodec[streamIndex].pCodeCtx->width, pCodec[streamIndex].pCodeCtx->height,1));
            ASSERT(pCodec[streamIndex].pBuffer)
            av_image_fill_arrays(pCodec[streamIndex].videoOutFmt.pOutFrame->data, pCodec[streamIndex].videoOutFmt.pOutFrame->linesize,pCodec[streamIndex].pBuffer, \
                AV_PIX_FMT_YUV420P,pCodec[streamIndex].pCodeCtx->width, pCodec[streamIndex].pCodeCtx->height,1);
            pCodec[streamIndex].pSwsConvertCtx = sws_getContext(pCodec[streamIndex].pCodeCtx->width, pCodec[streamIndex].pCodeCtx->height, pCodec[streamIndex].pCodeCtx->pix_fmt, \
            pCodec[streamIndex].pCodeCtx->width, pCodec[streamIndex].pCodeCtx->height,AV_PIX_FMT_YUV420P , SWS_BICUBIC, NULL, NULL, NULL);
            ASSERT(pCodec[streamIndex].pSwsConvertCtx)
        }
        else
        {
            pCodec[streamIndex].pFrame = av_frame_alloc();
            ASSERT(pCodec[streamIndex].pFrame)
            pCodec[streamIndex].videoOutFmt.pOutFrame = av_frame_alloc();
            ASSERT(pCodec[streamIndex].videoOutFmt.pOutFrame)
            pCodec[streamIndex].pBuffer=(unsigned char *)av_malloc(av_image_get_buffer_size(AV_PIX_FMT_RGB24,  pCodec[streamIndex].pCodeCtx->width, pCodec[streamIndex].pCodeCtx->height,1));
            ASSERT(pCodec[streamIndex].pBuffer)
            av_image_fill_arrays(pCodec[streamIndex].videoOutFmt.pOutFrame->data, pCodec[streamIndex].videoOutFmt.pOutFrame->linesize,pCodec[streamIndex].pBuffer, \
                AV_PIX_FMT_RGB24,pCodec[streamIndex].pCodeCtx->width, pCodec[streamIndex].pCodeCtx->height,1);
            pCodec[streamIndex].pSwsConvertCtx = sws_getContext(pCodec[streamIndex].pCodeCtx->width, pCodec[streamIndex].pCodeCtx->height, pCodec[streamIndex].pCodeCtx->pix_fmt, \
            pCodec[streamIndex].pCodeCtx->width, pCodec[streamIndex].pCodeCtx->height,AV_PIX_FMT_RGB24 , SWS_BICUBIC, NULL, NULL, NULL);
            ASSERT(pCodec[streamIndex].pSwsConvertCtx)
        }
        if(screenWwidth)
            screenW = pCodec[streamIndex].pCodeCtx->width;
        if(screenHheight)
            screenH = pCodec[streamIndex].pCodeCtx->height;
        //初始化frame队列
        pCodec[streamIndex].pFrameQueue = (FrameQueue *)malloc(sizeof(FrameQueue));
        ASSERT(pCodec[streamIndex].pFrameQueue);
        memset(pCodec[streamIndex].pFrameQueue,0,sizeof(FrameQueue));
        //初始化帧队列互斥量
        pCodec[streamIndex].pFrameQueue->pMutex = SDL_CreateMutex();
        //初始化帧队列条件变量
        pCodec[streamIndex].pFrameQueue->pCond = SDL_CreateCond();
        //帧队列最大值
        pCodec[streamIndex].pFrameQueue->maxSize = FRAME_QUEUE_MAX_SIZE;
        //直接为每个帧队列元素申请空间，而非使用时申请
        for(int i=0;imaxSize;i++)
        {
            pCodec[streamIndex].pFrameQueue->qFrame[i] = av_frame_alloc();
            ASSERT(pCodec[streamIndex].pFrameQueue->qFrame[i])
        }
        break;
    case AVMEDIA_TYPE_AUDIO:
    dprintf("AVMEDIA_TYPE_AUDIO\n");
        audioStreamIndex = streamIndex;
        pCodec[streamIndex].pAudioOutFmt = (AudioOutFmt *)malloc(sizeof(AudioOutFmt));
        ASSERT(pCodec[streamIndex].pAudioOutFmt)
        memset(pCodec[streamIndex].pAudioOutFmt,0,sizeof(AudioOutFmt));
        pCodec[streamIndex].pAudioOutFmt->outChLayout = AV_CH_LAYOUT_STEREO;
        pCodec[streamIndex].pAudioOutFmt->outNbSamples = pCodec[streamIndex].pCodeCtx->frame_size;
        pCodec[streamIndex].pAudioOutFmt->outNbSampleFmt = AV_SAMPLE_FMT_S16;
        pCodec[streamIndex].pAudioOutFmt->outSamplesRate = pCodec[streamIndex].pCodeCtx->sample_rate;
        pCodec[streamIndex].pAudioOutFmt->outChannels = av_get_channel_layout_nb_channels(pCodec[streamIndex].pAudioOutFmt->outChLayout);
        pCodec[streamIndex].pAudioOutFmt->outFrameSize = av_samples_get_buffer_size(NULL,pCodec[streamIndex].pAudioOutFmt->outChannels ,pCodec[streamIndex].pAudioOutFmt->outNbSamples,pCodec[streamIndex].pAudioOutFmt->outNbSampleFmt, 1);
        pCodec[streamIndex].audioBufCtrl.audioLen = 0;
        pCodec[streamIndex].audioBufCtrl.pAudioChunk = NULL;
        pCodec[streamIndex].audioBufCtrl.pAudioPos = NULL;
        pCodec[streamIndex].pBuffer = (unsigned char *)av_malloc(MAX_AUDIO_FRAME_SIZE*2);
        ASSERT(pCodec[streamIndex].pBuffer)
        pCodec[streamIndex].pFrame = av_frame_alloc();
        ASSERT(pCodec[streamIndex].pFrame)
        //初始化frame队列，同上
        pCodec[streamIndex].pFrameQueue = (FrameQueue *)malloc(sizeof(FrameQueue));
        ASSERT(pCodec[streamIndex].pFrameQueue);
        memset(pCodec[streamIndex].pFrameQueue,0,sizeof(FrameQueue));
        pCodec[streamIndex].pFrameQueue->pMutex = SDL_CreateMutex();
        pCodec[streamIndex].pFrameQueue->pCond = SDL_CreateCond();
        pCodec[streamIndex].pFrameQueue->maxSize = FRAME_QUEUE_MAX_SIZE;
        for(int i=0;imaxSize;i++)
        {
            pCodec[streamIndex].pFrameQueue->qFrame[i] = av_frame_alloc();
            ASSERT(pCodec[streamIndex].pFrameQueue->qFrame[i])
        }
        break;
    default:
        break;
    }
    return 0;
}
int Player::codecContextExit(int streamIndex)
{
    if(pCodec != NULL)
    {
        if(pCodec[streamIndex].pCodeCtx != NULL)
        {
            SDL_LockMutex(pMutex);
            avcodec_close(pCodec[streamIndex].pCodeCtx);
            pCodec[streamIndex].pCodeCtx = NULL;
            SDL_UnlockMutex(pMutex);
        }
    }
    return 0;
}
//大部分同1.0相同，不再赘述
int Player::readPackLoop(void *pthis)
{
    ASSERT(pthis)
    Player *tmpthis = (Player *) pthis;
    tmpthis->isReadPackClose = false;
    tmpthis->pCodec = (Codec *)malloc(sizeof(Codec)*(tmpthis->pFormatCtx->nb_streams));
    ASSERT(tmpthis->pCodec)
    memset(tmpthis->pCodec,0,sizeof(Codec)*(tmpthis->pFormatCtx->nb_streams));
 	for(int i=0; i < tmpthis->pFormatCtx->nb_streams; i++)
    {
        if(tmpthis->codecContextInit(i)<0)
        {
            dprintf("Stream%d init failed\n",i);
            return -1;
        }
    }
    //初始化包队列互斥量
    tmpthis->packetQueue.pMutex = SDL_CreateMutex();
    //初始化包队列条件变量
    tmpthis->packetQueue.pCond = SDL_CreateCond();
    //创建其他线程
    tmpthis->decodeThread = SDL_CreateThread(decodeLoop,"decode",(void *)pthis);
    ASSERT(tmpthis->decodeThread)
    tmpthis->isDecodeClose = false;
    tmpthis->audioPlayerThread = SDL_CreateThread(audioLoop,"audio",(void *)pthis);
    ASSERT(tmpthis->audioPlayerThread)
    tmpthis->isAudioClose = false;
    tmpthis->videoPlayerThread = SDL_CreateThread(videoLoop,"video",(void *)pthis);
    ASSERT(tmpthis->videoPlayerThread)
    tmpthis->isVideoClose = false;
    //每次读包存入队列前临时存储
    tmpthis->pPacket = av_packet_alloc();
    ASSERT(tmpthis->pPacket)
    //这两个变量改为局部也行
    tmpthis->gotAudioPicture = -1;
    tmpthis->gotVideoPicture = -1;
   while(!tmpthis->isReadPackClose)
    {   //判断队列是否已满
        if(tmpthis->packetQueue.qPacket.size()pFormatCtx, tmpthis->pPacket) == 0)
            {
                //存入队列前要上锁
                SDL_LockMutex(tmpthis->packetQueue.pMutex);
                //申请一个包变量
                AVPacket *tmppacket = av_packet_alloc();
                if (!tmppacket) {
                    dprintf("tmppacket malloc failed\n");
                    av_packet_unref(tmppacket);
                    return -1;
                }
                //把取到的包存入新申请的包变量
                av_packet_move_ref(tmppacket, tmpthis->pPacket);
                //入队
                tmpthis->packetQueue.qPacket.push(tmppacket);
                SDL_UnlockMutex(tmpthis->packetQueue.pMutex);
                //临时存包的变量可以释放，等待下次存储
                av_packet_unref(tmpthis->pPacket);
            }
            //队列没满但是读取包失败了，则认为包已经被读取完了，线程结束
            else
            {
                tmpthis->isReadPackClose = true;
                dprintf("readPacket Over\n");
            }
        }
        //队列已经满了则等待条件变量，此条件在解码线程每次从包队列里取出一个包就满足一次
        else
        {
            SDL_LockMutex(tmpthis->packetQueue.pMutex);
            SDL_CondWait(tmpthis->packetQueue.pCond,tmpthis->packetQueue.pMutex);
            SDL_UnlockMutex(tmpthis->packetQueue.pMutex);
        }
    }
    dprintf("leave readPackLoop\n");
    //因为包队列元素空间释放在解码线程，所以解包线程要退出，必须等待解码线程退出，以保证队列里所有包资源都已被释放
    while(tmpthis->closeOver.closeSingle.decodeOver == 0);
    if(tmpthis->pCodec)
    {
        free(tmpthis->pCodec);
        tmpthis->pCodec = NULL;        
    }
    SDL_DestroyMutex(tmpthis->packetQueue.pMutex);
    SDL_DestroyCond(tmpthis->packetQueue.pCond);
    av_packet_free(&tmpthis->pPacket);
    tmpthis->pPacket = NULL;
    tmpthis->codecContextExit(tmpthis->audioStreamIndex);
    tmpthis->codecContextExit(tmpthis->videoStreamIndex);
    tmpthis->isReadPackClose = true;
    tmpthis->closeOver.closeSingle.readPacketOver = 1;
    dprintf("readPackLoop free over\n");
    return 0;
}
int Player::decodeLoop(void *pthis)
{
    ASSERT(pthis)
    Player *tmpthis = (Player *)pthis; 
    tmpthis->isDecodeClose = false;
    while (!tmpthis->isDecodeClose)
    {
        //判断包队列是否有元素可取
        if(tmpthis->packetQueue.qPacket.size()>0)
        {
            //有元素可取，操作前先上锁
            SDL_LockMutex(tmpthis->packetQueue.pMutex);
            //取首个元素
            AVPacket *tmpPacket = tmpthis->packetQueue.qPacket.front();
            //从队列中弹出，即size-1，但是资源未释放
            tmpthis->packetQueue.qPacket.pop();
            //判断包类型
            switch (tmpthis->pFormatCtx->streams[tmpPacket->stream_index]->codecpar->codec_type)
            {
            case AVMEDIA_TYPE_AUDIO:
                tmpthis->audioStreamIndex = tmpPacket->stream_index;
                avcodec_send_packet(tmpthis->pCodec[tmpthis->audioStreamIndex].pCodeCtx,tmpPacket);
                //释放包资源
                av_packet_free(&tmpPacket);
                //置位条件
                SDL_CondSignal(tmpthis->packetQueue.pCond);
                SDL_UnlockMutex(tmpthis->packetQueue.pMutex);
                //判断帧队列是否已满
                if(tmpthis->pCodec[tmpthis->audioStreamIndex].pFrameQueue->qSize >= tmpthis->pCodec[tmpthis->audioStreamIndex].pFrameQueue->maxSize)
                {
                    //帧队列满了，则等待条件变量，此变量在对应播放线程被满足
                    SDL_LockMutex(tmpthis->pCodec[tmpthis->audioStreamIndex].pFrameQueue->pMutex);    
                    SDL_CondWait(tmpthis->pCodec[tmpthis->audioStreamIndex].pFrameQueue->pCond,tmpthis->pCodec[tmpthis->audioStreamIndex].pFrameQueue->pMutex);
                    SDL_UnlockMutex(tmpthis->pCodec[tmpthis->audioStreamIndex].pFrameQueue->pMutex);      
                }
                //条件被满足后，证明帧队列已经被取走一个元素
                SDL_LockMutex(tmpthis->pCodec[tmpthis->audioStreamIndex].pFrameQueue->pMutex);  
                //判断写索引是否需要从头开始 
                if(tmpthis->pCodec[tmpthis->audioStreamIndex].pFrameQueue->writePrt > tmpthis->pCodec[tmpthis->audioStreamIndex].pFrameQueue->maxSize-1)
                {
                    tmpthis->pCodec[tmpthis->audioStreamIndex].pFrameQueue->writePrt = 0;
                }
                //解码
                tmpthis->gotAudioPicture = avcodec_receive_frame(tmpthis->pCodec[tmpthis->audioStreamIndex].pCodeCtx,
                tmpthis->pCodec[tmpthis->audioStreamIndex].pFrameQueue->qFrame[tmpthis->pCodec[tmpthis->audioStreamIndex].pFrameQueue->writePrt]); 
                if(tmpthis->gotAudioPicture == 0)
                {
                    //解码成功后队列size+1，写索引+1
                    tmpthis->pCodec[tmpthis->audioStreamIndex].pFrameQueue->qSize++;
                    tmpthis->pCodec[tmpthis->audioStreamIndex].pFrameQueue->writePrt++;
                }
                SDL_UnlockMutex(tmpthis->pCodec[tmpthis->audioStreamIndex].pFrameQueue->pMutex);
                break;
            case AVMEDIA_TYPE_VIDEO:
                //同上
                tmpthis->videoStreamIndex = tmpPacket->stream_index;
                avcodec_send_packet(tmpthis->pCodec[tmpthis->videoStreamIndex].pCodeCtx,tmpPacket);
                av_packet_free(&tmpPacket);
                SDL_CondSignal(tmpthis->packetQueue.pCond);
                SDL_UnlockMutex(tmpthis->packetQueue.pMutex);

                if(tmpthis->pCodec[tmpthis->videoStreamIndex].pFrameQueue->qSize >= tmpthis->pCodec[tmpthis->videoStreamIndex].pFrameQueue->maxSize)
                {
                    SDL_LockMutex(tmpthis->pCodec[tmpthis->videoStreamIndex].pFrameQueue->pMutex);     
                    SDL_CondWait(tmpthis->pCodec[tmpthis->videoStreamIndex].pFrameQueue->pCond,tmpthis->pCodec[tmpthis->videoStreamIndex].pFrameQueue->pMutex);
                    SDL_UnlockMutex(tmpthis->pCodec[tmpthis->videoStreamIndex].pFrameQueue->pMutex);      
                }
                SDL_LockMutex(tmpthis->pCodec[tmpthis->videoStreamIndex].pFrameQueue->pMutex);  
                if(tmpthis->pCodec[tmpthis->videoStreamIndex].pFrameQueue->writePrt>tmpthis->pCodec[tmpthis->videoStreamIndex].pFrameQueue->maxSize-1)
                {
                    tmpthis->pCodec[tmpthis->videoStreamIndex].pFrameQueue->writePrt = 0;
                }   
                tmpthis->gotVideoPicture = avcodec_receive_frame(tmpthis->pCodec[tmpthis->videoStreamIndex].pCodeCtx,
                tmpthis->pCodec[tmpthis->videoStreamIndex].pFrameQueue->qFrame[tmpthis->pCodec[tmpthis->videoStreamIndex].pFrameQueue->writePrt]); 
                if(tmpthis->gotVideoPicture == 0)
                {
                    tmpthis->pCodec[tmpthis->videoStreamIndex].pFrameQueue->qSize++;
                    tmpthis->pCodec[tmpthis->videoStreamIndex].pFrameQueue->writePrt++;
                }
                SDL_UnlockMutex(tmpthis->pCodec[tmpthis->videoStreamIndex].pFrameQueue->pMutex);
                break;
            default:
                break;
            }
        }
        else
        {
            if(tmpthis->isReadPackClose)
            {
                tmpthis->isDecodeClose = true;
                dprintf("isDecodeClose is true\n");
            }
        }
    }
    dprintf("leave decodeLoop\n");
    //等待音频与视频线程结束，防止使用帧时异常
    while(!((tmpthis->closeOver.closeSingle.audioOver==1) && (tmpthis->closeOver.closeSingle.videoOver==1)));
    //释放包队列所有元素
    if(tmpthis->packetQueue.qPacket.size()>0)
    {
        for(int i=0;ipacketQueue.qPacket.size();i++)
        {
            AVPacket *tmpPacket = tmpthis->packetQueue.qPacket.front();
            av_packet_free(&tmpPacket);
            tmpPacket = NULL;
            tmpthis->packetQueue.qPacket.pop();           
        }
    }
    //释放音频帧队列所有元素
    for(int z = 0;zpCodec[tmpthis->audioStreamIndex].pFrameQueue->maxSize;z++)
    {
        av_frame_free(&tmpthis->pCodec[tmpthis->audioStreamIndex].pFrameQueue->qFrame[z]);
        tmpthis->pCodec[tmpthis->audioStreamIndex].pFrameQueue->qFrame[z] = NULL;
        tmpthis->pCodec[tmpthis->audioStreamIndex].pFrameQueue->maxSize = 0;
        tmpthis->pCodec[tmpthis->audioStreamIndex].pFrameQueue->qSize = 0;
    }
    SDL_DestroyMutex(tmpthis->pCodec[tmpthis->audioStreamIndex].pFrameQueue->pMutex);
    SDL_DestroyCond(tmpthis->pCodec[tmpthis->audioStreamIndex].pFrameQueue->pCond);
    //释放视频帧队列所有元素
    for(int z = 0;zpCodec[tmpthis->videoStreamIndex].pFrameQueue->maxSize;z++)
    {
        av_frame_free(&tmpthis->pCodec[tmpthis->videoStreamIndex].pFrameQueue->qFrame[z]);
        tmpthis->pCodec[tmpthis->videoStreamIndex].pFrameQueue->qFrame[z] = NULL;
        tmpthis->pCodec[tmpthis->videoStreamIndex].pFrameQueue->maxSize = 0;
        tmpthis->pCodec[tmpthis->videoStreamIndex].pFrameQueue->qSize = 0;
    }
    SDL_DestroyMutex(tmpthis->pCodec[tmpthis->videoStreamIndex].pFrameQueue->pMutex);
    SDL_DestroyCond(tmpthis->pCodec[tmpthis->videoStreamIndex].pFrameQueue->pCond);
    
    av_frame_free(&tmpthis->pCodec[tmpthis->audioStreamIndex].pFrame);
    tmpthis->pCodec[tmpthis->audioStreamIndex].pFrame = NULL;
    av_frame_free(&tmpthis->pCodec[tmpthis->videoStreamIndex].pFrame);
    tmpthis->pCodec[tmpthis->videoStreamIndex].pFrame = NULL;
    tmpthis->isDecodeClose = true;
    tmpthis->closeOver.closeSingle.decodeOver = 1;
    dprintf("decodeLoop free over\n");
    return 0;
}
//同1.0
void Player::audioCallBack(void *pthis,unsigned char *stream,int len)
{
    if(pthis == NULL)
        return;
    Player *tmpthis = (Player *)pthis;
    SDL_memset(stream, 0, len);
	if(tmpthis->pCodec[tmpthis->audioStreamIndex].audioBufCtrl.audioLen == 0)
		return; 
	len=(len>tmpthis->pCodec[tmpthis->audioStreamIndex].audioBufCtrl.audioLen?tmpthis->pCodec[tmpthis->audioStreamIndex].audioBufCtrl.audioLen:len);
	memcpy(stream, tmpthis->pCodec[tmpthis->audioStreamIndex].audioBufCtrl.pAudioPos, len);
	tmpthis->pCodec[tmpthis->audioStreamIndex].audioBufCtrl.pAudioPos += len; 
	tmpthis->pCodec[tmpthis->audioStreamIndex].audioBufCtrl.audioLen -= len; 
}
int Player::audioLoop(void *pthis)
{
    ASSERT(pthis)
    Player *tmpthis = (Player *)pthis; 
    tmpthis->isAudioClose = false;
    SDL_AudioSpec audioSpec;
    int i = tmpthis->audioStreamIndex;
    audioSpec.freq = tmpthis->pCodec[i].pAudioOutFmt->outSamplesRate;
    audioSpec.format = AUDIO_S16SYS;
    audioSpec.channels = tmpthis->pCodec[i].pAudioOutFmt->outChannels;
    audioSpec.silence = 0;
    audioSpec.samples = tmpthis->pCodec[i].pAudioOutFmt->outNbSamples;
    audioSpec.callback = audioCallBack;
    audioSpec.userdata = pthis;
	if (SDL_OpenAudio(&audioSpec, NULL)<0){ 
		dprintf("can't open audio.\n"); 
		return -1; 
	} 
    tmpthis->pCodec[i].pSwrConvertCtx = swr_alloc();
    ASSERT(tmpthis->pCodec[i].pSwrConvertCtx)
	tmpthis->pCodec[i].pSwrConvertCtx=swr_alloc_set_opts(tmpthis->pCodec[i].pSwrConvertCtx, \
    tmpthis->pCodec[i].pAudioOutFmt->outChLayout,                                                                                                \
    tmpthis->pCodec[i].pAudioOutFmt->outNbSampleFmt,                                                                                      \
    tmpthis->pCodec[i].pAudioOutFmt->outSamplesRate,                                                                                         \
    av_get_default_channel_layout(tmpthis->pCodec[i].pCodeCtx->channels),                                           \
    tmpthis->pCodec[i].pCodeCtx->sample_fmt ,                                                                                                         \
    tmpthis->pCodec[i].pCodeCtx->sample_rate,0, NULL);
	swr_init(tmpthis->pCodec[i].pSwrConvertCtx);   
    SDL_PauseAudio(0);
    while(!tmpthis->isAudioClose)
    {
        //判断是否有帧可取
        if(tmpthis->pCodec[tmpthis->audioStreamIndex].pFrameQueue->qSize>0)
        {
            //有帧可取，则根据读索引，直接使用帧队列元素
            SDL_LockMutex(tmpthis->pCodec[tmpthis->audioStreamIndex].pFrameQueue->pMutex);     
            swr_convert(tmpthis->pCodec[tmpthis->audioStreamIndex].pSwrConvertCtx,   \
            &tmpthis->pCodec[tmpthis->audioStreamIndex].pBuffer,                                                 \
            MAX_AUDIO_FRAME_SIZE,                                                                                            \
            (const uint8_t **)tmpthis->pCodec[tmpthis->audioStreamIndex].pFrameQueue->qFrame[tmpthis->pCodec[tmpthis->audioStreamIndex].pFrameQueue->readPrt]->data, \
            tmpthis->pCodec[tmpthis->audioStreamIndex].pFrameQueue->qFrame[tmpthis->pCodec[tmpthis->audioStreamIndex].pFrameQueue->readPrt]->nb_samples);      
            tmpthis->pCodec[tmpthis->audioStreamIndex].pFrameQueue->readPrt++;
            if(tmpthis->pCodec[tmpthis->audioStreamIndex].pFrameQueue->readPrt>tmpthis->pCodec[tmpthis->audioStreamIndex].pFrameQueue->maxSize-1)
                tmpthis->pCodec[tmpthis->audioStreamIndex].pFrameQueue->readPrt = 0; 
            tmpthis->pCodec[tmpthis->audioStreamIndex].pFrameQueue->qSize--;
            SDL_CondSignal(tmpthis->pCodec[tmpthis->audioStreamIndex].pFrameQueue->pCond);
            SDL_UnlockMutex(tmpthis->pCodec[tmpthis->audioStreamIndex].pFrameQueue->pMutex);    
            while(tmpthis->pCodec[tmpthis->audioStreamIndex].audioBufCtrl.audioLen>0)
            {
                SDL_Delay(1); 
            }
            tmpthis->pCodec[tmpthis->audioStreamIndex].audioBufCtrl.pAudioChunk = tmpthis->pCodec[tmpthis->audioStreamIndex].pBuffer; 
            tmpthis->pCodec[tmpthis->audioStreamIndex].audioBufCtrl.audioLen =tmpthis->pCodec[tmpthis->audioStreamIndex].pAudioOutFmt->outFrameSize;
            tmpthis->pCodec[tmpthis->audioStreamIndex].audioBufCtrl.pAudioPos = tmpthis->pCodec[tmpthis->audioStreamIndex].audioBufCtrl.pAudioChunk;                 
        }  

    }
    dprintf("leave audioLoop\n");
    if(tmpthis->pCodec[tmpthis->audioStreamIndex].pAudioOutFmt!=NULL)
    {
        free(tmpthis->pCodec[tmpthis->audioStreamIndex].pAudioOutFmt);
        tmpthis->pCodec[tmpthis->audioStreamIndex].pAudioOutFmt = NULL;
    }
    swr_free(&tmpthis->pCodec[tmpthis->audioStreamIndex].pSwrConvertCtx);
    tmpthis->pCodec[tmpthis->audioStreamIndex].pSwrConvertCtx = NULL;
    av_free(tmpthis->pCodec[tmpthis->audioStreamIndex].pBuffer);
    tmpthis->pCodec[tmpthis->audioStreamIndex].pBuffer = NULL;
    SDL_CloseAudio();
    tmpthis->isAudioClose = true;
    tmpthis->closeOver.closeSingle.audioOver = 1;
    dprintf("audioLoop free over\n");
    return 0;
}
//同音频线程处理方式
int Player::videoLoop(void *pthis)
{
    ASSERT(pthis)
    Player *tmpthis = (Player *)pthis; 
    tmpthis->isVideoClose = false;
    SDL_Window *screen;
    screen = SDL_CreateWindow("Player",SDL_WINDOWPOS_UNDEFINED,SDL_WINDOWPOS_UNDEFINED,\
    tmpthis->screenW,tmpthis->screenH,SDL_WINDOW_SHOWN);
    if(!screen)
    {
        dprintf("Can't Create Window -- %s\n",SDL_GetError());
        return -1;
    }
    SDL_Renderer* sdlRenderer = SDL_CreateRenderer(screen, -1, 0);
    SDL_RenderClear(sdlRenderer);
    SDL_Texture* sdlTexture = NULL;
    if(tmpthis->pCodec[tmpthis->videoStreamIndex].pCodeCtx->pix_fmt == AV_PIX_FMT_YUV420P)
        sdlTexture = SDL_CreateTexture(sdlRenderer,SDL_PIXELFORMAT_IYUV,\
        SDL_TEXTUREACCESS_STREAMING,tmpthis->screenW,tmpthis->screenH);//SDL_PIXELFORMAT_RGB24 /SDL_PIXELFORMAT_IYUV
    else
        sdlTexture = SDL_CreateTexture(sdlRenderer,SDL_PIXELFORMAT_RGB24,\
        SDL_TEXTUREACCESS_STREAMING,tmpthis->screenW,tmpthis->screenH);//SDL_PIXELFORMAT_RGB24 /SDL_PIXELFORMAT_IYUV
	SDL_Rect sdlRect;
    sdlRect.h = tmpthis->screenH;
    sdlRect.w = tmpthis->screenW;
    while(!tmpthis->isVideoClose)
    {
        if(tmpthis->pCodec[tmpthis->videoStreamIndex].pFrameQueue->qSize>0)
        {
            SDL_LockMutex(tmpthis->pCodec[tmpthis->videoStreamIndex].pFrameQueue->pMutex); 
            sws_scale(tmpthis->pCodec[tmpthis->videoStreamIndex].pSwsConvertCtx, 
            (const unsigned char* const*)tmpthis->pCodec[tmpthis->videoStreamIndex].pFrameQueue->qFrame[tmpthis->pCodec[tmpthis->videoStreamIndex].pFrameQueue->readPrt]->data, 
            tmpthis->pCodec[tmpthis->videoStreamIndex].pFrameQueue->qFrame[tmpthis->pCodec[tmpthis->videoStreamIndex].pFrameQueue->readPrt]->linesize, 
            0, 
            tmpthis->pCodec[tmpthis->videoStreamIndex].pCodeCtx->height, 
            tmpthis->pCodec[tmpthis->videoStreamIndex].videoOutFmt.pOutFrame->data, 
            tmpthis->pCodec[tmpthis->videoStreamIndex].videoOutFmt.pOutFrame->linesize);

            tmpthis->pCodec[tmpthis->videoStreamIndex].pFrameQueue->readPrt++;
            if(tmpthis->pCodec[tmpthis->videoStreamIndex].pFrameQueue->readPrt>tmpthis->pCodec[tmpthis->videoStreamIndex].pFrameQueue->maxSize-1)
                tmpthis->pCodec[tmpthis->videoStreamIndex].pFrameQueue->readPrt = 0; 
            tmpthis->pCodec[tmpthis->videoStreamIndex].pFrameQueue->qSize--;         
            SDL_CondSignal(tmpthis->pCodec[tmpthis->videoStreamIndex].pFrameQueue->pCond);   
            SDL_UnlockMutex(tmpthis->pCodec[tmpthis->videoStreamIndex].pFrameQueue->pMutex);   
            SDL_UpdateTexture( sdlTexture, &sdlRect,                                                                                            \
            tmpthis->pCodec[tmpthis->videoStreamIndex].videoOutFmt.pOutFrame->data[0],         \
            tmpthis->pCodec[tmpthis->videoStreamIndex].videoOutFmt.pOutFrame->linesize[0] ); \
            SDL_RenderClear( sdlRenderer );  
            SDL_RenderCopy( sdlRenderer, sdlTexture, NULL, &sdlRect);  
            SDL_RenderPresent( sdlRenderer ); 
            tmpthis->gotVideoPicture = -1;             
        }
    }
    dprintf("leave videoLoop\n");
    av_free(tmpthis->pCodec[tmpthis->videoStreamIndex].pBuffer);
    tmpthis->pCodec[tmpthis->videoStreamIndex].pBuffer = NULL;
    av_frame_free(&tmpthis->pCodec[tmpthis->videoStreamIndex].videoOutFmt.pOutFrame);
    tmpthis->pCodec[tmpthis->videoStreamIndex].videoOutFmt.pOutFrame = NULL;
    sws_freeContext(tmpthis->pCodec[tmpthis->videoStreamIndex].pSwsConvertCtx);
    tmpthis->pCodec[tmpthis->videoStreamIndex].pSwsConvertCtx = NULL;
    tmpthis->isVideoClose = true;
    tmpthis->closeOver.closeSingle.videoOver = 1;
    SDL_DestroyWindow(screen);
    dprintf("videoLoop free over\n");
    return 0;
}

player.h

#ifndef PLAYER_H
#define PLAYER_H

extern "C"
{
#include 
#include 
#include 
#include 
#include 
#include 
}
#include 

//版本号
#define VERSION "2.0v\n"
//单帧最大数据
#define MAX_AUDIO_FRAME_SIZE 192000 // 1 second of 48khz 32bit audio
//包队列大小
#define PACKET_QUEUE_MAX_SIZE   8
//帧队列大小
#define FRAME_QUEUE_MAX_SIZE    16
//命名空间
namespace player
{
//音频播放控制
typedef struct AUDIOBUFCTRL
{
    //音频播放数据缓冲首地址
    unsigned char *pAudioChunk;
    //音频当前播放数据首指针
    unsigned char *pAudioPos;
    //音频当前播放剩余数据
    unsigned int audioLen;
}AudioBufCtrl;
//音频转换输出格式
typedef struct AUDIOOUTFMT
{  
    //单通道采样数据
    int outNbSamples;
    //采样率
    int outSamplesRate;
    //输出通道
    int outChannels;
    //输出帧大小
    int outFrameSize;
    //输出音频通道格式
    unsigned long outChLayout;
    //采样格式
    AVSampleFormat outNbSampleFmt;
}AudioOutFmt;
//视频转换输出格式
typedef struct VIDEOOUTFMT
{
    //存储转换后的单帧
    AVFrame *pOutFrame;
}VideoOutFmt;
//包队列相关
typedef struct PACKETQUEUE
{
    //包队列，使用C++队列模板，非线程安全
    std::queue qPacket;
    //互斥量
    SDL_mutex *pMutex;
    //条件变量
    SDL_cond *pCond;
}PacketQueue;
//帧队列相关
typedef struct FRAMEQUEUE
{
    //帧队列使用数组指针，初始化时申请所有内存，而非使用时申请
    AVFrame *qFrame[FRAME_QUEUE_MAX_SIZE];
    //队列存储最大值
    int maxSize;
    //队列当前存有元素个数
    int qSize;
    //读下标
    int readPrt;
    //写下标
    int writePrt;
    //互斥量
    SDL_mutex *pMutex;
    //条件变量
    SDL_cond *pCond;
}FrameQueue;
//编解码器相关
typedef struct CODEC
{
    //编解码器上下文
    AVCodecContext *pCodeCtx;
    //解码器
	const AVCodec *pAvCodec;
    //临时存储单帧
    AVFrame	*pFrame;
    //视频转码器
    struct SwsContext *pSwsConvertCtx;
    //音频转码器
    struct SwrContext *pSwrConvertCtx;
    //转换结果缓存
    unsigned char *pBuffer;
    //音频转换格式相关
    AudioOutFmt *pAudioOutFmt;
    //音频播放相关
    AudioBufCtrl audioBufCtrl;
    //视频转换格式相关
    VideoOutFmt videoOutFmt;
    //帧队列
    FrameQueue *pFrameQueue;
}Codec;
//所有线程退出状态
typedef union CLOSE
{
    //单个状态
    struct CLOSESINGLE
    {
        //解包线程结束状态
        unsigned char readPacketOver:1;
        //解码线程结束状态
        unsigned char decodeOver:1;
        //音频线程结束状态
        unsigned char audioOver:1;
        //视频线程结束状态
        unsigned char videoOver:1;       
    }closeSingle;
    //总状态
    unsigned char allOver;
}Close;
//播放器类
class Player
{
public:
    //输入文件名称
    char *filename;
    //事件线程是否已经退出
    bool isEventClose;
    //格式化上下文
    AVFormatContext	*pFormatCtx;
    //单包临时存储
    AVPacket *pPacket;
    //解码器数组
    Codec *pCodec;
    //构造函数
    Player(const char *file);
    //析构函数
    ~Player();
    //打印版本
    int versionShow(void);
    //初始化
    int init(void);
    //释放初始化资源
    int exit(void);
    //事件循环
    static int eventLoop(void *pthis);
    //解包循环
    static int readPackLoop(void *pthis);
    //解码循环
    static int decodeLoop(void *pthis);
    //音频循环
    static int audioLoop(void *pthis);
    //视频循环
    static int videoLoop(void *pthis);
    //音频播放回调
    static void audioCallBack(void *pthis,unsigned char *stream,int len);
    //解码器初始化
    int codecContextInit(int streamIndex);
    //解码器资源释放
    int codecContextExit(int streamIndex);
private:
    //关闭解包线程指示
    bool isReadPackClose;
    //关闭解码线程指示
    bool isDecodeClose;
    //关闭音频播放线程指示
    bool isAudioClose;
    //关闭视频播放线程指示
    bool isVideoClose;
    //线程退出状态
    Close closeOver;
    //窗口宽度
    int screenW;
    //窗口高度
    int screenH;
    //音频流索引
    int audioStreamIndex;
    //视频流索引
    int videoStreamIndex;
    //获取音频帧状态
    int gotAudioPicture;
    //获取视频帧状态
    int gotVideoPicture;
    //互斥量
    SDL_mutex *pMutex;
    //各线程索引
    SDL_Thread *eventThread;
    SDL_Thread *readPackThread;
    SDL_Thread *decodeThread;
    SDL_Thread *audioPlayerThread;
    SDL_Thread *videoPlayerThread;
    //包队列
    PacketQueue packetQueue;
    //处理键盘事件
    int keyEvent(int key);
};    
} 


#endif

player_main.cpp

#include "player.h"

using namespace player;

int main(int argc,char *argv[])
{
    if(argc!=2)
    {
        printf("参数异常\n");
        return 0;
    }
    Player player(argv[1]);
    player.versionShow();
    player.init();
    while(!player.isEventClose);
    return 0;
}

player_build.sh

#! /bin/sh
g++ player.cpp player_main.cpp -g -o player.a -I /usr/local/ffmpeg/include -I ./ -L /usr/local/ffmpeg/lib \
-lSDL2main -lSDL2 -lavformat -lavcodec -lavutil -lswresample -lswscale -lm -lpthread

gitee

[email protected]:Yi-Deng-Da-Shi/player_v2.git

遗留问题

1.目前帧队列存储的是从解码器接收到的帧，是否应该改为转换后的帧

2.播放某些文件时，比如gitee中的DuKou.flac时，farme_size为0，这会导致播放异常，此时farme_size应该在从解码器读取到一帧数据后设置，比如这里读取到一帧为4096，设置后播放正常。

3.代码臃肿

4.音视频同步