基于FFMPEG 4.1.3 和SDL2.0的视频播放简单实例，使用C++

秒速五厘米 2022-01-06 14:23 235阅读 0赞

具体的播放流程参考雷神博客地址  
[https://blog.csdn.net/leixiaohua1020/article/details/38868499][https_blog.csdn.net_leixiaohua1020_article_details_38868499]  
本实例使用最新FFMPEG接口，以及SDL2.0接口替换，并封装成一个简单的C++类，部分功能相关注释已在源代码中添加，代码已测可播放视频。  
类使用方式样例:

FFmpegSDLPlayer ffmpegSDLPlayer("SDL Player", 640, 480);
    ffmpegSDLPlayer.play("test.mp4");

完整可运行项目地址见：  
[https://github.com/lesliefish/FFMPEG/tree/master/ffmpeg/FFMPEG][https_github.com_lesliefish_FFMPEG_tree_master_ffmpeg_FFMPEG]

环境：Qt5.9.6+vs2015+SDL2.0+FFMPEG4.1.3

--------------------

## 头文件 ##

/** @file   FFmpegSDLPlayer.h
     *  @brief  FFmpegSDLPlayer 基于FFmpeg + SDL2.0播放
     *  @note
     *  @author lesliefish
     *  @date   2019/06/20
     */
    #pragma once
    
    #include <string>
    #include <stdio.h>
    
    #ifdef _WIN32
    extern "C"
    {
    #include "libavcodec/avcodec.h"
    #include "libavformat/avformat.h"
    #include "libswscale/swscale.h"
    #include "libavutil/pixfmt.h"
    #include "libavutil/imgutils.h"
    }
    #endif
    
    #include "sdl/sdl.h"
    
    class FFmpegSDLPlayer
    {
    public:
        FFmpegSDLPlayer(const std::string& playerName, int playWindowWidth = 1280, int playWindowHeight = 720);
        ~FFmpegSDLPlayer();
    
    public:
        void play(const std::string& filePath);
        
    private:
        // 初始化基本数据
        bool initDatas();
        // 初始化sdl2
        bool initSdlInfo();
        // 获取流 音频流 视频流等
        bool getStreams();
        // 打开解码器
        bool avcodecOpen();
    private:
        // 文件
        std::string m_filePath{};
        const AVCodec* m_avCodec{ nullptr };
    
        // 包含码流参数较多的结构体
        AVFormatContext* m_formatCtx{ nullptr }; 
        
        // 解析器
        AVCodecParserContext* m_codecParserContext{ nullptr };
        
        // 变量结构体 包括编解码器类型、采样率、声道数等等
        AVCodecContext* m_codecContext{ nullptr }; 
        AVFrame* m_yuvFrame{ nullptr };// 解码后frame
        AVFrame* m_frame{ nullptr }; // 存储转码后frame
        AVPacket* m_avPacket{ nullptr };
        SwsContext* m_swsContext{ nullptr };
    
        SDL_Window *m_playerWindow{ nullptr };
        SDL_Renderer* m_sdlRenderer{ nullptr };
        SDL_Texture* m_sdlTexture{ nullptr };
    
        int m_audioStream{ -1 }; // 音频流id
        int m_videoStream{ -1 }; // 视频流id
    
        // 默认窗口大小
        int m_playerWidth{ 1280 };
        int m_playerHeight{ 720 };
    
        std::string m_playerName;
    };

--------------------

cpp源文件类如下：

#include "FFmpegSDLPlayer.h"
    #include <iostream>
    #include <memory>
    #include <future>
    
    using namespace std;
    
    // 自定义刷新事件
    #define REFRESH_EVENT  (SDL_USEREVENT + 1)
    
    
    /*
     * @func   FFmpegSDLPlayer::FFmpegSDLPlayer 
     * @brief  构造函数
     * @param  [in]  const std::string & playerName  播放器名称
     * @param  [in]  int playWindowWidth  初始播放器宽度
     * @param  [in]  int playWindowHeight  初始播放器高度
     * @return   
     */ 
    FFmpegSDLPlayer::FFmpegSDLPlayer(const std::string& playerName, int playWindowWidth /*= 1280*/, int playWindowHeight /*= 720*/)
    {
        initDatas();
        m_playerWidth = playWindowWidth;
        m_playerHeight = playWindowHeight;
        m_playerName = playerName;
    }
    
    FFmpegSDLPlayer::~FFmpegSDLPlayer()
    {
        SDL_DestroyWindow(m_playerWindow);
        SDL_DestroyTexture(m_sdlTexture);
        SDL_Quit();
        av_free(m_yuvFrame); m_yuvFrame = nullptr;
        av_free(m_frame); m_frame = nullptr;
        avcodec_close(m_codecContext); m_codecContext = nullptr;
        avformat_close_input(&m_formatCtx); m_formatCtx = nullptr;
    }
    
    /*
     * @func   FFmpegSDLPlayer::play 
     * @brief  播放视频文件
     * @param  [in]  const std::string & filePath  
     * @return void  
     */ 
    void FFmpegSDLPlayer::play(const std::string& filePath)
    {
        m_filePath = filePath;
        // 获取流
        if (!getStreams())
        {
            return;
        }
    
        // 打开解码器
        if (!avcodecOpen())
        {
            return;
        }
    
        // 初始化SDL播放窗口
        if (!initSdlInfo())
        {
            return;
        }
    
        // 一帧AV_PIX_FMT_YUV420P格式图像size
        int numBytes = av_image_get_buffer_size(AV_PIX_FMT_YUV420P, m_playerWidth, m_playerHeight, 1);
        shared_ptr<uint8_t*> buffer = make_shared<uint8_t*>(new uint8_t[numBytes]);
        av_image_fill_arrays(m_yuvFrame->data, m_yuvFrame->linesize, *buffer.get(), AV_PIX_FMT_YUV420P, m_playerWidth, m_playerHeight, 1);
        SDL_Rect rect;
        SDL_Event event;
    
        // 是否读数据完毕
        bool isReadOver{ false };
    
        // 线程处理部分 每隔40ms读取一帧视频数据
        auto fut = std::async([&]
        {
            while (!isReadOver)
            {
                SDL_Event event;
                event.type = REFRESH_EVENT;
                SDL_PushEvent(&event);
                SDL_Delay(40); // 40ms取一帧数据, 刷新一次
            }
    
            // 读完数据后发送关闭消息
            SDL_Event event;
            event.type = SDL_QUIT;
            SDL_PushEvent(&event);
        });
    
        for (;;)
        {
            SDL_WaitEvent(&event);
            if (event.type == SDL_QUIT)
            {
                // 退出事件
                isReadOver = true;
                break;
            }
            else if (event.type == SDL_WINDOWEVENT)
            {
                // 主要用来检测窗口是否发生变化
                int curWidth{ 0 };
                int curHeight{ 0 };
                SDL_GetWindowSize(m_playerWindow, &curWidth, &curHeight);
                if (curWidth != m_playerWidth || curHeight != m_playerHeight)
                {
                    // 仅当尺寸变了时才执行如下语句
                    m_playerWidth = curWidth;
                    m_playerHeight = curHeight;
                    int bytes = av_image_get_buffer_size(AV_PIX_FMT_YUV420P, m_playerWidth, m_playerHeight, 1);
                    shared_ptr<uint8_t*> buffer = make_shared<uint8_t*>(new uint8_t[bytes]);
                    av_image_fill_arrays(m_yuvFrame->data, m_yuvFrame->linesize, *buffer.get(), AV_PIX_FMT_YUV420P, m_playerWidth, m_playerHeight, 1);
                }
            }
            else if (event.type == REFRESH_EVENT)
            {
                bool findVideoStream{ false }; // 是否读到视频流
                while (!findVideoStream)
                {
                    // 一直读数据 直到读到视频流为止
                    if (av_read_frame(m_formatCtx, m_avPacket) < 0)
                    {
                        isReadOver = true;
                        break;
                    }
    
                    if (m_avPacket->stream_index != m_videoStream)
                    {
                        continue;
                    }
                    findVideoStream = true;
                }
    
                int ret = avcodec_send_packet(m_codecContext, m_avPacket);
                if (ret < 0)
                {
                    fprintf(stderr, "Error sending a packet for decoding\n");
                    continue;
                }
    
                ret = avcodec_receive_frame(m_codecContext, m_frame);
                if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
                {
                    continue;
                }
                else if (ret < 0)
                {
                    fprintf(stderr, "Error during decoding\n");
                    continue;
                }
    
                // SDL绘制处理 
                m_swsContext = sws_getContext(m_codecContext->width, m_codecContext->height,
                    m_codecContext->pix_fmt, m_playerWidth, m_playerHeight, AV_PIX_FMT_YUV420P, SWS_BICUBIC,
                    nullptr, nullptr, nullptr);
                if (!m_swsContext)
                {
                    continue;
                }
                
                // 将帧数据转为播放窗口需要的大小
                sws_scale(m_swsContext, (const uint8_t* const*)m_frame->data, m_frame->linesize, 0,
                    m_codecContext->height, m_yuvFrame->data, m_yuvFrame->linesize);
                sws_freeContext(m_swsContext);
    
                rect.x = 0;
                rect.y = 0;
                rect.w = m_playerWidth;
                rect.h = m_playerHeight;
    
                SDL_UpdateTexture(m_sdlTexture, &rect, m_yuvFrame->data[0], m_yuvFrame->linesize[0]);
                SDL_RenderClear(m_sdlRenderer);
                SDL_RenderCopy(m_sdlRenderer, m_sdlTexture, &rect, &rect);
                SDL_RenderPresent(m_sdlRenderer);
                av_free_packet(m_avPacket);
            }
        }
    }
    
    bool FFmpegSDLPlayer::initDatas()
    {
        m_avPacket = av_packet_alloc();
        m_formatCtx = avformat_alloc_context();
        m_yuvFrame = av_frame_alloc();
        m_frame = av_frame_alloc();
    
        return true;
    }
    
    bool FFmpegSDLPlayer::initSdlInfo()
    {
        if (SDL_Init(SDL_INIT_VIDEO))
        {
            cout << "Could not initialize SDL : " << SDL_GetError() << endl;
            return false;
        }
        // 播放窗口创建
        m_playerWindow = SDL_CreateWindow(m_playerName.c_str(),
            SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
            m_playerWidth, m_playerHeight, SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE);
    
        if (!m_playerWindow)
        {
            cout << "SDL: could not create window - exiting: " << SDL_GetError() << endl;
            return false;
        }
    
        // 渲染
        m_sdlRenderer = SDL_CreateRenderer(m_playerWindow, -1, 0);
        if (!m_sdlRenderer)
        {
            cout << "SDL: could not create render - exiting: " << SDL_GetError() << endl;
            return false;
        }
    
        // 纹理
        m_sdlTexture = SDL_CreateTexture(m_sdlRenderer, SDL_PIXELFORMAT_YV12, SDL_TEXTUREACCESS_STREAMING, m_codecContext->width, m_codecContext->height);
        if (!m_sdlTexture)
        {
            cout << "SDL: could not create texture - exiting: " << SDL_GetError() << endl;
            return false;
        }
    
        return true;
    }
    
    bool FFmpegSDLPlayer::getStreams()
    {
        //打开输入视频文件
        if (avformat_open_input(&m_formatCtx, m_filePath.c_str(), nullptr, nullptr) != 0)
        {
            fprintf(stderr, "Could not get input file format\n");
            return false;
        }
    
        //获取视频文件信息
        if (avformat_find_stream_info(m_formatCtx, NULL) < 0)
        {
            fprintf(stderr, "Could not get input file stream info\n");
            return false;
        }
    
        // 找到音频流和视频流
        for (int i = 0; i < m_formatCtx->nb_streams; i++)
        {
            //流的类型
            if (m_formatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO)
            {
                m_videoStream = i;
            }
            else if (m_formatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO)
            {
                m_audioStream = i;
            }
        }
    
        return true;
    }
    
    bool FFmpegSDLPlayer::avcodecOpen()
    {
        m_codecContext = m_formatCtx->streams[m_videoStream]->codec;
        // 寻找解码器
        m_avCodec = avcodec_find_decoder(m_codecContext->codec_id);
    
        if (!m_avCodec)
        {
            return false;
        }
    
        m_codecParserContext = av_parser_init(m_avCodec->id);
        if (!m_codecParserContext)
        {
            return false;
        }
    
        // 打开解码器
        if (avcodec_open2(m_codecContext, m_avCodec, nullptr) < 0)
        {
            fprintf(stderr, "Could not open codec\n");
            return false;
        }
    
        //输出视频信息
        cout << "video format ： " << m_formatCtx->iformat->name << endl;
        cout << "video duration ： " << m_formatCtx->duration / 1000000 << endl;
        cout << "video width * height : " << m_codecContext->width << " * " << m_codecContext->height << endl;
        cout << "video name : " << m_avCodec->name << endl;
    
        av_dump_format(m_formatCtx, 0, m_filePath.c_str(), 0);
        return true;
    }

[https_blog.csdn.net_leixiaohua1020_article_details_38868499]: https://blog.csdn.net/leixiaohua1020/article/details/38868499
[https_github.com_lesliefish_FFMPEG_tree_master_ffmpeg_FFMPEG]: https://github.com/lesliefish/FFMPEG/tree/master/ffmpeg/FFMPEG