SDL与FFmpeg结合实现简单的视频播放器

用FFmpeg与SDL写了一个简单的音视频播放器，但还有很大的问题。首先并没有使用多线程，音视频的解码渲染操作都在主线程中，导致在同时播放视频的时候，音频的播放会出现断断续续的情况，把视频的播放关闭就不会出现问题。还有就是队列的实现，目前只有音频使用了队列，而视频则是直接播放渲染, 要使用队列的话就不得不实现多线程了。之后还有音视频的同步等等，这些都是需要改进的点。不过我相信在后面的学习中都会解决的<(￣︶￣)↗[GO!]

这里就直接放源码了(○｀ 3′○)

#include <stdio.h>
#include <windows.h>
#include <SDL.h>

#include <libavutil/log.h>
#include <libavutil/avutil.h>
#include <libavutil/fifo.h>
#include <libavformat/avformat.h>
#include <libavcodec/avcodec.h>
#include <libswresample/swresample.h>

#define AUDIO_BUFFER_SIZE 1024

typedef struct _PacketQueue{
    AVFifo *pkts;
    int nb_packets;
    int size;
    int64_t duration;

    SDL_mutex *mutex;
    SDL_cond *cond;
}PacketQueue;

typedef struct _VideoState{
    AVCodecContext *avctx;
    AVPacket *pkt;
    AVFrame *frame;
    SDL_Texture *texture;

    struct SwrContext *swr_ctx;

    uint8_t *audio_buf;
    int audio_buf_size;
    int audio_buf_index;

    PacketQueue audioq;
    PacketQueue videoq;
}VideoState;


typedef struct MyPacketEle{
    AVPacket *pkt;
}MyPacketEle;


static int w_width = 640;
static int w_height = 480;

static SDL_Window *win = NULL;
static SDL_Renderer *renderer = NULL;

static int packet_queue_init(PacketQueue *q){
    memset(q, 0, sizeof(PacketQueue));
    q->pkts = av_fifo_alloc2(1, sizeof(MyPacketEle), AV_FIFO_FLAG_AUTO_GROW);
    if(!q->pkts){
        return AVERROR(ENOMEM);
    }

    q->mutex = SDL_CreateMutex();
    if(!q->mutex){
        return AVERROR(ENOMEM);
    }

    q->cond = SDL_CreateCond();
    if(!q->cond){
        return AVERROR(ENOMEM);
    }
}

static int packet_queue_put_priv(PacketQueue *q, AVPacket *pkt){
    MyPacketEle mypkt;
    int ret;
    mypkt.pkt = pkt;
    ret = av_fifo_write(q->pkts, &mypkt, 1);
    if(ret < 0){
        return ret;
    }
    q->nb_packets++;
    q->size += mypkt.pkt->size + sizeof(mypkt);
    q->duration += mypkt.pkt->duration;
    SDL_CondSignal(q->cond);
    return 0;
}

static int packet_queue_put(PacketQueue *q, AVPacket *pkt){
    AVPacket *pkt1;
    int ret = -1;
    pkt1 = av_packet_alloc();
    if(!pkt1){
        av_packet_unref(pkt1);
        return -1;
    }
    av_packet_move_ref(pkt1, pkt);
    SDL_LockMutex(q->mutex);

    ret = packet_queue_put_priv(q, pkt1);
    SDL_UnlockMutex(q->mutex);

    if(ret < 0){
        av_packet_free(&pkt1);
    }

    return ret;
}

static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block){
    MyPacketEle mypkt;
    int ret = 1;

    SDL_LockMutex(q->mutex);
    while(1){
        if(av_fifo_read(q->pkts, &mypkt, 1) >= 0){
            q->nb_packets--;
            q->size -= mypkt.pkt->size + sizeof(mypkt);
            q->duration -=mypkt.pkt->duration;
            av_packet_move_ref(pkt, mypkt.pkt);
            av_packet_free(&mypkt.pkt);
            ret = 1;
            break;
        }else if(!block){
            ret = 0;
            break;
        }else{
            SDL_CondWait(q->cond, q->mutex);
        }
    }
    SDL_UnlockMutex(q->mutex);
    return ret;
}

static void packet_queue_flush(PacketQueue *q){
    MyPacketEle mypkt;
    SDL_LockMutex(q->mutex);
    while(av_fifo_read(q->pkts, &mypkt, 1) > 0){
        av_packet_free(&mypkt.pkt);
    }
    q->nb_packets = 0;
    q->size = 0;
    q->duration = 0;
    SDL_UnlockMutex(q->mutex);
}

static void packet_queue_destroy(PacketQueue *q){
    packet_queue_flush(q);
    av_fifo_freep2(&q->pkts);
    SDL_DestroyMutex(q->mutex);
    SDL_DestroyCond(q->cond);
}

static void render(VideoState *is){
    SDL_UpdateYUVTexture(is->texture, NULL, 
    is->frame->data[0], is->frame->linesize[0], 
    is->frame->data[1], is->frame->linesize[1], 
    is->frame->data[2], is->frame->linesize[2]);

    SDL_RenderClear(renderer);
    SDL_RenderCopy(renderer, is->texture, NULL, NULL);
    SDL_RenderPresent(renderer);
}

static int decode(VideoState *is){
    int ret = -1;
    ret = avcodec_send_packet(is->avctx, is->pkt);
    if(ret < 0){
        av_log(NULL, AV_LOG_ERROR, "Failed to send pkt to video decoder!\n");
        goto __OUT;
    }
    while(ret >= 0){
        ret = avcodec_receive_frame(is->avctx, is->frame);
        if(ret == AVERROR(EAGAIN) || ret == AVERROR_EOF){
            ret = 0;
            goto __OUT;
        }else if(ret < 0){
            ret = -1;
            goto __OUT;
        }
        render(is);
    }
__OUT:
    return ret;
}

static int audio_decode_frame(VideoState *ais){
    int ret = -1;
    int len2;

    int data_size = 0;

    AVPacket pkt;
    while(1){
        if(packet_queue_get(&ais->audioq, &pkt, 1) < 0){
            return -1;
        }
        ret = avcodec_send_packet(ais->avctx, &pkt);
        if(ret < 0){
            av_log(ais->avctx, AV_LOG_ERROR, "Failed to send pkt to audio decoder!\n");
            goto __OUT;
        }
        while(ret >= 0){
            ret = avcodec_receive_frame(ais->avctx, ais->frame);
            if(ret == AVERROR(EAGAIN) || ret == AVERROR_EOF){
                break;
            }else if(ret < 0){
                av_log(ais->avctx, AV_LOG_ERROR, "Failed to receive frame from audio decoder!\n");
                goto __OUT;
            }

            if(!ais->swr_ctx){
                AVChannelLayout in_ch_layout, out_ch_layout;
                av_channel_layout_copy(&in_ch_layout, &ais->avctx->ch_layout);
                av_channel_layout_copy(&out_ch_layout, &ais->avctx->ch_layout);
                if(ais->avctx->sample_fmt != AV_SAMPLE_FMT_S16){
                    swr_alloc_set_opts2(&ais->swr_ctx, &out_ch_layout, AV_SAMPLE_FMT_S16, ais->avctx->sample_rate, &in_ch_layout, ais->avctx->sample_fmt, ais->avctx->sample_rate, 0, NULL);
                    swr_init(ais->swr_ctx);
                }
            }

            if(ais->swr_ctx){
                const uint8_t **in = (const uint8_t **)ais->frame->extended_data;
                uint8_t **out = &ais->audio_buf;
                int out_cont = ais->frame->nb_samples + 512;
                int in_cont = ais->frame->nb_samples;

                int out_size = av_samples_get_buffer_size(NULL, ais->frame->ch_layout.nb_channels, out_cont, AV_SAMPLE_FMT_S16, 0);
                av_fast_malloc(&ais->audio_buf, &ais->audio_buf_size, out_size);

                len2 = swr_convert(ais->swr_ctx, out, out_cont, in, in_cont);
                data_size = len2 * ais->frame->ch_layout.nb_channels * av_get_bytes_per_sample(AV_SAMPLE_FMT_S16);
            }else {
                ais->audio_buf = *(ais->frame->extended_data);
                data_size = av_samples_get_buffer_size(NULL, ais->frame->ch_layout.nb_channels, ais->frame->nb_samples, ais->frame->format, 1);
            }

            av_packet_unref(&pkt);
            av_frame_unref(ais->frame);

            return data_size;
        }
    }
__OUT:
    return ret;
}

static void sdl_audio_callback(void *userdata, Uint8 *stream, int len){
    int audio_size = 0, len1 = 0;
    VideoState *ais = (VideoState*)userdata;

    SDL_memset(stream, 0, len);
    while(len > 0){
        if(ais->audio_buf_index >= ais->audio_buf_size){
            audio_size = audio_decode_frame(ais);
            if(audio_size < 0){
                ais->audio_buf_size = AUDIO_BUFFER_SIZE;
                ais->audio_buf = NULL;
            }else {
                ais->audio_buf_size = audio_size;
            }
            ais->audio_buf_index = 0;
        }
        len1 = ais->audio_buf_size - ais->audio_buf_index;
        if(len1 > len){
            len1 = len;
        }
        if(ais->audio_buf){
            memcpy(stream, (uint8_t *)ais->audio_buf + ais->audio_buf_index, len1); 
            //SDL_MixAudio(stream, ais->audio_buf, len1, SDL_MIX_MAXVOLUME);
        }else {
            memset(stream, 0, len1);
        }
        len -= len1;
        stream += len1;
        ais->audio_buf_index += len1;
    }
}

int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
    //1. 设置参数
    int ret = -1;
    int vIdx = -1, aIdx = -1;

    SDL_Texture *texture = NULL;
    SDL_Event event;

    Uint32 pixformat = 0;
    int video_width = 0;
    int video_height = 0;

    VideoState *vis = NULL;
    VideoState *ais = NULL;

    SDL_AudioSpec wanted_spec, spec;

    AVFormatContext *FmtCtx = NULL;
    AVStream *vinstream = NULL;
    AVStream *ainstream = NULL;

    const AVCodec *vdec = NULL;
    AVCodecContext *vctx = NULL;
    const AVCodec *adec = NULL;
    AVCodecContext *actx = NULL;

    AVPacket *vpkt = NULL;
    AVFrame *vframe = NULL;
    AVPacket *apkt = NULL;
    AVFrame *aframe = NULL;
    AVPacket *pkt = NULL;

    char *src = NULL;
    src = strtok(lpCmdLine, " ");
    if(!src){
        printf("Error: Expected one parameters.\n");
        goto __END;
    }
    
    vis = av_mallocz(sizeof(VideoState));
    if(!vis){
        av_log(NULL, AV_LOG_ERROR, "NO MEMORY!\n");
        goto __END;
    }
    ais = av_mallocz(sizeof(VideoState));
    if(!ais){
        av_log(NULL, AV_LOG_ERROR, "NO MEMORY!\n");
        goto __END;
    }

    // // strtok 用于分割命令行字符串，默认分隔符为空格
    // src = strtok(lpCmdLine, " ");
    // if (src != NULL) {
    //     dst = strtok(NULL, " ");
    // }

    // // 检查是否成功解析了两个参数
    // if (src != NULL && dst != NULL) {
    //     printf("Parameter 1: %s\n", src);
    //     printf("Parameter 2: %s\n", dst);
    // } else {
    //     printf("Error: Expected two parameters.\n");
    // }

    //2. 初始化SDL，并创建窗口和Render
    if (SDL_Init(SDL_INIT_AUDIO | SDL_INIT_VIDEO)) {
        printf("初始化 SDL 失败！\n");
        return ret;
    }

    win = SDL_CreateWindow("YUV Player", 
                            SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 
                            w_width, w_height, SDL_WINDOW_OPENGL|SDL_WINDOW_RESIZABLE);
    if(!win){
        printf("Failed to create window, %s\n", SDL_GetError());
        goto __END;
    }
    renderer = SDL_CreateRenderer(win, -1, 0);

    //3. 打开多媒体文件，并获取流信息
    if((ret = avformat_open_input(&FmtCtx, src, NULL, NULL)) < 0){
        av_log(NULL, AV_LOG_ERROR, "%s\n", av_err2str(ret));
        goto __END;
    }
    ret = avformat_find_stream_info(FmtCtx, NULL);
    if(ret < 0){
        av_log(NULL, AV_LOG_ERROR, "%s\n", av_err2str(ret));
        goto __END;
    }

    //4. 查找流
    for(int i = 0; i < FmtCtx->nb_streams; i++){
        if(FmtCtx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && vIdx < 0){
            vIdx = i;
        }
        if(FmtCtx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && aIdx < 0){
            aIdx = i;
        }
        if(vIdx > -1 && aIdx > -1){
            break;
        }
    }
    if(vIdx < 0 || aIdx < 0){
        av_log(NULL, AV_LOG_ERROR, "视频有问题!");
        goto __END;
    }

    ainstream = FmtCtx->streams[aIdx];
    vinstream = FmtCtx->streams[vIdx];

    //5. 根据流中的codec_id，获得视频解码器
    vdec = avcodec_find_decoder(vinstream->codecpar->codec_id);
    if(!vdec){
        av_log(NULL, AV_LOG_ERROR, "Could not find codec");
        goto __END;
    }
    //6. 创建解码器上下文
    vctx = avcodec_alloc_context3(vdec);
    if(!vctx){
        av_log(NULL, AV_LOG_ERROR, "NO MEMRORY\n");
        goto __END;
    }
    //7. 从多媒体文件中拷贝解码器参数到解码器上下文中
    ret = avcodec_parameters_to_context(vctx, vinstream->codecpar);
    if(ret < 0){
        av_log(vctx, AV_LOG_ERROR, "Could not copy codecpar to codec ctx!\n");
        goto __END;
    }

    //8. 绑定解码器上下文
    ret = avcodec_open2(vctx, vdec, NULL);
    if(ret < 0){
        av_log(vctx, AV_LOG_ERROR, "Don't open codec:%s\n", av_err2str(ret));
        goto __END;
    }

    //9. 根据流中的codec_id，获得音频解码器
    adec = avcodec_find_decoder(ainstream->codecpar->codec_id);
    if(!adec){
        av_log(NULL, AV_LOG_ERROR, "Could not find codec");
        goto __END;
    }
    //10. 创建解码器上下文
    actx = avcodec_alloc_context3(adec);
    if(!actx){
        av_log(NULL, AV_LOG_ERROR, "NO MEMRORY\n");
        goto __END;
    }
    //11. 从多媒体文件中拷贝解码器参数到解码器上下文中
    ret = avcodec_parameters_to_context(actx, ainstream->codecpar);
    if(ret < 0){
        av_log(actx, AV_LOG_ERROR, "Could not copy codecpar to codec ctx!\n");
        goto __END;
    }
    //12. 绑定解码器上下文
    ret = avcodec_open2(actx, adec, NULL);
    if(ret < 0){
        av_log(actx, AV_LOG_ERROR, "Don't open codec:%s\n", av_err2str(ret));
        goto __END;
    }

    //13. 设置音视频纹理参数
    video_width = vctx->width;
    video_height = vctx->height;
    pixformat = SDL_PIXELFORMAT_IYUV;
    texture = SDL_CreateTexture(renderer, pixformat, SDL_TEXTUREACCESS_STREAMING, video_width, video_height);

    
    vpkt = av_packet_alloc();
    vframe = av_frame_alloc();

    apkt = av_packet_alloc();
    aframe = av_frame_alloc();

    pkt = av_packet_alloc();

    vis->texture = texture;
    vis->avctx = vctx;
    vis->pkt = vpkt;
    vis->frame = vframe;
    packet_queue_init(&vis->videoq);

    ais->texture = texture;
    ais->avctx = actx;
    ais->pkt = apkt;
    ais->frame = aframe;
    packet_queue_init(&ais->audioq);

    wanted_spec.freq = actx->sample_rate;
    wanted_spec.format = AUDIO_S16SYS;
    wanted_spec.channels = actx->ch_layout.nb_channels;
    wanted_spec.silence = 0;
    wanted_spec.samples = AUDIO_BUFFER_SIZE;
    wanted_spec.callback = sdl_audio_callback;
    wanted_spec.userdata = (void *)ais;

    if(SDL_OpenAudio(&wanted_spec, NULL) < 0){
        av_log(NULL, AV_LOG_ERROR, "Failed to open audio device!\n");
        goto __END;
    }

    SDL_PauseAudio(0);

    //14. 从多媒体文件中读取数据，进行解码
    while(1){
        av_read_frame(FmtCtx, pkt);
        //15. 对解码后的视频数据进行渲染
        if(pkt->stream_index == vIdx){
            vis->pkt = pkt;
            decode(vis);
            // if(packet_queue_put(&vis->videoq, pkt) < 0){
            //     printf("向队列添加音频数据失败!");
            // }
        }else if(pkt->stream_index == aIdx){
            if(packet_queue_put(&ais->audioq, pkt) < 0){
                printf("向队列添加音频数据失败!");
            }
        }else {
            av_packet_unref(pkt);
        }
        //延迟 1 毫秒，防止 CPU 占用过高
        SDL_Delay(1);

        //16. 处理SDL事件
        SDL_PollEvent(&event);
        switch(event.type){
            case SDL_QUIT:
                exit(-1);
            default:
                break;
        }
        av_packet_unref(vpkt);
    }

    vis->pkt = NULL;
    decode(vis);
    packet_queue_put(&ais->audioq, NULL);

__END:
    //17. 收尾，释放资源
    if(vframe){
        av_frame_free(&vframe);
    }
    if(vpkt){
        av_packet_free(&vpkt);
    }
    if(aframe){
        av_frame_free(&aframe);
    }
    if(apkt){
        av_packet_free(&apkt);
    }
    if(vctx){
        avcodec_free_context(&vctx);
    }
    if(FmtCtx){
        avformat_close_input(&FmtCtx);
    }
    if(win){
        SDL_DestroyWindow(win);
    }
    if(renderer){
        SDL_DestroyRenderer(renderer);
    }
    if(texture){
        SDL_DestroyTexture(texture);
    }
    if(ais){
        av_free(ais);
    }
    if(vis){
        av_free(vis);
    }
    SDL_Quit();
    return ret;
}