FFmpeg入门，简单播放器

一个偶然的机缘，好像要做直播相关的项目

为了筹备，前期做一些只是储备，于是开始学习ffmpeg

这是学习的第一课

做一个简单的播放器，播放视频画面帧

思路是，将视频文件解码，得到帧，然后使用定时器，1秒显示24帧

1.创建win32工程，添加菜单项 “打开”

   为了避免闪烁，MyRegisterClass中设置hbrBackground为null

2.在main函数中初始化ffmpeg库：av_register_all();

3.响应菜单打开

void LoadVideoPlay(HWND hWnd)
{
    if (gbLoadVideo)
    {
        return;
    }

    TCHAR szPath[1024] = { 0 };
    DWORD dwPath = 1024;
    OPENFILENAME ofn = { 0 };
    ofn.lStructSize = sizeof(ofn);
    ofn.hwndOwner = hWnd;
    ofn.hInstance = hInst;
    ofn.lpstrFile = szPath;
    ofn.nMaxFile = dwPath;
    ofn.lpstrFilter = _T("Video(*.mp4)*.MP4*;*.avi*");
    ofn.Flags = OFN_FILEMUSTEXIST | OFN_HIDEREADONLY;
    ofn.lpstrInitialDir = _T("F:\");

    if (!GetOpenFileName(&ofn))
    {
        DWORD dwErr = CommDlgExtendedError();
        OutputDebugString(_T("GetOpenFileName
"));
        return;
    }

    std::wstring strVideo = szPath;
    std::thread loadVideoThread([hWnd, strVideo]() {
        gbLoadVideo = TRUE;
        std::string sVideo = UnicodeToUTF_8(strVideo.c_str(), strVideo.size());
        OpenVideoByFFmpeg(hWnd, sVideo.c_str());
        gbLoadVideo = FALSE;
    });

    loadVideoThread.detach();
}

使用c++11的线程来加载视频文件并进行解码工作。

4.在加载完视频之后，设置窗口为不可缩放

  创建缓存DC等显示环境

  设置播放帧画面的定时器

5.将解码的帧画面转化为 RGB 32位格式，并存储至队列中等待播放

6.播放帧画面

   在WM_PAINT消息中进行绘画

   

void PlayFrame(HWND hWnd, UCHAR* buffer, UINT uWidth, UINT uHeight)
{
    do 
    {
        if (GetFramesSize() > (24 * 5)) // 缓冲5秒的帧数
        {
            if (WaitForSingleObject(ghExitEvent, 3000) == WAIT_OBJECT_0)
            {
                return;
            }
        }
        else
        {
            HDC hDC = GetDC(hWnd);
            HBITMAP hFrame = CreateBitmapFromPixels(hDC, uWidth, uHeight, 32, buffer);
            if (hFrame)
            {
                PushFrame(hFrame);
            }
            ReleaseDC(hWnd, hDC);
            break;
        }

    } while (true);
}

因为解码拿到的是像素数据，需要将像素数据转化为Win32兼容位图

HBITMAP CreateBitmapFromPixels(HDC hDC, UINT uWidth, UINT uHeight, UINT uBitsPerPixel, LPVOID pBits)
{
    if (uBitsPerPixel <= 8) // NOT IMPLEMENTED YET
        return NULL;

    HBITMAP hBitmap = 0;
    if (!uWidth || !uHeight || !uBitsPerPixel)
        return hBitmap;
    LONG lBmpSize = uWidth * uHeight * (uBitsPerPixel / 8);
    BITMAPINFO bmpInfo = { 0 };
    bmpInfo.bmiHeader.biBitCount = uBitsPerPixel;
    bmpInfo.bmiHeader.biHeight = -(static_cast<LONG>(uHeight)); // 因为拿到的帧图像是颠倒的
    bmpInfo.bmiHeader.biWidth = uWidth;
    bmpInfo.bmiHeader.biPlanes = 1;
    bmpInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    // Pointer to access the pixels of bitmap
    UINT * pPixels = 0;
    hBitmap = CreateDIBSection(hDC, (BITMAPINFO *)&
        bmpInfo, DIB_RGB_COLORS, (void **)&
        pPixels, NULL, 0);

    if (!hBitmap)
        return hBitmap; // return if invalid bitmaps

    memcpy(pPixels, pBits, lBmpSize);

    return hBitmap;
}

7.播放完毕，回复窗口设定，关闭定时器

代码流程一目了然，用来学习ffmpeg入门

最后贴上总的代码

// main.cpp : 定义应用程序的入口点。
//

#include "stdafx.h"
#include "testPlayVideo.h"

#include <windows.h>
#include <commdlg.h>
#include <deque>
#include <string>
#include <mutex>
#include <thread>

extern "C" {
#include "libavcodec/avcodec.h"
#include "libavformat/avformat.h"
#include "libavutil/pixfmt.h"
#include "libavutil/imgutils.h"
#include "libavdevice/avdevice.h"
#include "libswscale/swscale.h"
}

#pragma comment(lib, "Comdlg32.lib")

#define MAX_LOADSTRING  100
#define TIMER_FRAME     101
#define CHECK_TRUE(v) {if(!v) goto cleanup;}
#define CHECK_ZERO(v) {if(v<0) goto cleanup;}

// 全局变量: 
HINSTANCE hInst;                                // 当前实例
WCHAR szTitle[MAX_LOADSTRING];                  // 标题栏文本
WCHAR szWindowClass[MAX_LOADSTRING];            // 主窗口类名

std::mutex gFrameLock;                          // 图像位图帧的访问锁
std::deque<HBITMAP> gFrames;                    // 所有解码的视频图像位图帧
HDC ghFrameDC;                                  // 视频帧图像兼容DC
HBITMAP ghFrameBmp;                             // 兼容DC的内存位图
HBRUSH ghFrameBrush;                            // 兼容DC的背景画刷
HANDLE ghExitEvent;                             // 程序退出通知事件
UINT uFrameTimer;                               // 定时器，刷新窗口显示图像位图帧
UINT uBorderWidth;
UINT uBorderHeight;
BOOL gbLoadVideo;
DWORD dwWndStyle;

// 此代码模块中包含的函数的前向声明: 
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);
HBITMAP CreateBitmapFromPixels(HDC hDC, UINT uWidth, UINT uHeight, UINT uBitsPerPixel, LPVOID pBits);

HBITMAP PopFrame(void)
{
    std::lock_guard<std::mutex> lg(gFrameLock);

    if (gFrames.empty())
    {
        return nullptr;
    }
    else
    {
        HBITMAP hFrame = gFrames.front();
        gFrames.pop_front();
        return hFrame;
    }
}

void PushFrame(HBITMAP hFrame)
{
    std::lock_guard<std::mutex> lg(gFrameLock);
    gFrames.push_back(hFrame);
}

size_t GetFramesSize(void)
{
    std::lock_guard<std::mutex> lg(gFrameLock);
    return gFrames.size();
}

void ReleasePaint(void)
{
    if (ghFrameDC) DeleteDC(ghFrameDC);
    if (ghFrameBmp) DeleteObject(ghFrameBmp);
    if (ghFrameBrush) DeleteObject(ghFrameBrush);

    ghFrameDC = nullptr;
    ghFrameBmp = nullptr;
    ghFrameBrush = nullptr;
}

void CreatePaint(HWND hWnd)
{
    RECT rc;
    GetClientRect(hWnd, &rc);
    HDC hDC = GetDC(hWnd);
    ghFrameDC = CreateCompatibleDC(hDC);
    ghFrameBmp = CreateCompatibleBitmap(hDC, rc.right - rc.left, rc.bottom - rc.top);
    ghFrameBrush = CreateSolidBrush(RGB(5, 5, 5));
    SelectObject(ghFrameDC, ghFrameBmp);
    ReleaseDC(hWnd, hDC);
}

void ReleaseFrames(void)
{
    std::lock_guard<std::mutex> lg(gFrameLock);
    for (auto& hFrame : gFrames)
    {
        DeleteObject(hFrame);
    }
    gFrames.clear();
    
    ReleasePaint();
}

void PlayFrame(HWND hWnd, UCHAR* buffer, UINT uWidth, UINT uHeight)
{
    do 
    {
        if (GetFramesSize() > (24 * 5)) // 缓冲5秒的帧数
        {
            if (WaitForSingleObject(ghExitEvent, 3000) == WAIT_OBJECT_0)
            {
                return;
            }
        }
        else
        {
            HDC hDC = GetDC(hWnd);
            HBITMAP hFrame = CreateBitmapFromPixels(hDC, uWidth, uHeight, 32, buffer);
            if (hFrame)
            {
                PushFrame(hFrame);
            }
            ReleaseDC(hWnd, hDC);
            break;
        }

    } while (true);
}

std::string UnicodeToUTF_8(const wchar_t *pIn, size_t nSize)
{
    if (pIn == NULL || nSize == 0)
    {
        return "";
    }

    std::string s;
    int n = WideCharToMultiByte(CP_UTF8, NULL, pIn, nSize, NULL, 0, NULL, NULL);
    if (n > 0)
    {
        s.resize(n);
        WideCharToMultiByte(CP_UTF8, NULL, pIn, nSize, &s[0], n, NULL, NULL);
    }

    return s;
}

int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
                     _In_opt_ HINSTANCE hPrevInstance,
                     _In_ LPWSTR    lpCmdLine,
                     _In_ int       nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);

    // TODO: 在此放置代码。
    ghExitEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr);
    av_register_all();

    // 初始化全局字符串
    LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadStringW(hInstance, IDC_TESTPLAYVIDEO, szWindowClass, MAX_LOADSTRING);
    MyRegisterClass(hInstance);

    // 执行应用程序初始化: 
    if (!InitInstance (hInstance, nCmdShow))
    {
        return FALSE;
    }

    HACCEL hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_TESTPLAYVIDEO));

    MSG msg;

    // 主消息循环: 
    while (GetMessage(&msg, nullptr, 0, 0))
    {
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }

    return (int) msg.wParam;
}



//
//  函数: MyRegisterClass()
//
//  目的: 注册窗口类。
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
    WNDCLASSEXW wcex;

    wcex.cbSize = sizeof(WNDCLASSEX);

    wcex.style          = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc    = WndProc;
    wcex.cbClsExtra     = 0;
    wcex.cbWndExtra     = 0;
    wcex.hInstance      = hInstance;
    wcex.hIcon          = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_TESTPLAYVIDEO));
    wcex.hCursor        = LoadCursor(nullptr, IDC_ARROW);
    wcex.hbrBackground  = /*(HBRUSH)(COLOR_WINDOW+1)*/nullptr;
    wcex.lpszMenuName   = MAKEINTRESOURCEW(IDC_TESTPLAYVIDEO);
    wcex.lpszClassName  = szWindowClass;
    wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

    return RegisterClassExW(&wcex);
}

//
//   函数: InitInstance(HINSTANCE, int)
//
//   目的: 保存实例句柄并创建主窗口
//
//   注释: 
//
//        在此函数中，我们在全局变量中保存实例句柄并
//        创建和显示主程序窗口。
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   hInst = hInstance; // 将实例句柄存储在全局变量中

   HWND hWnd = CreateWindowW(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, nullptr, nullptr, hInstance, nullptr);

   if (!hWnd)
   {
      return FALSE;
   }

   ShowWindow(hWnd, nCmdShow);
   UpdateWindow(hWnd);

   return TRUE;
}

HBITMAP CreateBitmapFromPixels(HDC hDC, UINT uWidth, UINT uHeight, UINT uBitsPerPixel, LPVOID pBits)
{
    if (uBitsPerPixel <= 8) // NOT IMPLEMENTED YET
        return NULL;

    HBITMAP hBitmap = 0;
    if (!uWidth || !uHeight || !uBitsPerPixel)
        return hBitmap;
    LONG lBmpSize = uWidth * uHeight * (uBitsPerPixel / 8);
    BITMAPINFO bmpInfo = { 0 };
    bmpInfo.bmiHeader.biBitCount = uBitsPerPixel;
    bmpInfo.bmiHeader.biHeight = -(static_cast<LONG>(uHeight)); // 因为拿到的帧图像是颠倒的
    bmpInfo.bmiHeader.biWidth = uWidth;
    bmpInfo.bmiHeader.biPlanes = 1;
    bmpInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    // Pointer to access the pixels of bitmap
    UINT * pPixels = 0;
    hBitmap = CreateDIBSection(hDC, (BITMAPINFO *)&
        bmpInfo, DIB_RGB_COLORS, (void **)&
        pPixels, NULL, 0);

    if (!hBitmap)
        return hBitmap; // return if invalid bitmaps

    memcpy(pPixels, pBits, lBmpSize);

    return hBitmap;
}

void PaintFrame(HWND hWnd, HDC hDC, RECT rc)
{
    FillRect(ghFrameDC, &rc, ghFrameBrush);
    HBITMAP hFrame = PopFrame();
    if (hFrame)
    {
        BITMAP bmp;
        GetObject(hFrame, sizeof(bmp), &bmp);
        HDC hFrameDC = CreateCompatibleDC(hDC);
        HBITMAP hOld = (HBITMAP)SelectObject(hFrameDC, hFrame);
        BitBlt(ghFrameDC, 4, 2, bmp.bmWidth, bmp.bmHeight, hFrameDC, 0, 0, SRCCOPY);
        SelectObject(hFrameDC, hOld);
        DeleteObject(hFrame);
        DeleteDC(hFrameDC);
    }

    BitBlt(hDC, 0, 0, rc.right - rc.left, rc.bottom - rc.top, ghFrameDC, 0, 0, SRCCOPY);
}

void OpenVideoByFFmpeg(HWND hWnd, const char* szVideo)
{
    AVFormatContext* pFmtCtx = nullptr;
    AVCodecContext* pCodecCtx = nullptr;
    AVCodec* pCodec = nullptr;
    AVFrame* pFrameSrc = nullptr;
    AVFrame* pFrameRGB = nullptr;
    AVPacket* pPkt = nullptr;
    UCHAR* out_buffer = nullptr;
    struct SwsContext * pImgCtx = nullptr;
    int ret = 0;
    int videoStream = -1;
    int numBytes = 0;

    pFmtCtx = avformat_alloc_context();
    CHECK_TRUE(pFmtCtx);
    ret = avformat_open_input(&pFmtCtx, szVideo, nullptr, nullptr);
    CHECK_ZERO(ret);
    ret = avformat_find_stream_info(pFmtCtx, nullptr);
    CHECK_ZERO(ret);

    for (UINT i = 0; i < pFmtCtx->nb_streams; ++i)
    {
        if (pFmtCtx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
        {
            videoStream = i;
            break;
        }
    }
    CHECK_ZERO(videoStream);

    pCodecCtx = avcodec_alloc_context3(nullptr);
    CHECK_TRUE(pCodecCtx);
    ret = avcodec_parameters_to_context(pCodecCtx, pFmtCtx->streams[videoStream]->codecpar);
    CHECK_ZERO(ret);
    pCodec = avcodec_find_decoder(pCodecCtx->codec_id);
    CHECK_TRUE(pCodec);
    ret = avcodec_open2(pCodecCtx, pCodec, nullptr);
    CHECK_ZERO(ret);

    pFrameSrc = av_frame_alloc();
    pFrameRGB = av_frame_alloc();
    CHECK_TRUE(pFrameSrc);
    CHECK_TRUE(pFrameRGB);

    pImgCtx = sws_getContext(pCodecCtx->width, pCodecCtx->height, pCodecCtx->pix_fmt, 
        pCodecCtx->width, pCodecCtx->height, AV_PIX_FMT_RGB32, SWS_BICUBIC, nullptr, nullptr, nullptr);
    CHECK_TRUE(pImgCtx);

    numBytes = av_image_get_buffer_size(AV_PIX_FMT_RGB32, pCodecCtx->width, pCodecCtx->height, 1);
    out_buffer = (UCHAR*)av_malloc(numBytes);
    CHECK_TRUE(out_buffer);

    ret = av_image_fill_arrays(pFrameRGB->data, pFrameRGB->linesize, out_buffer, 
        AV_PIX_FMT_RGB32, pCodecCtx->width, pCodecCtx->height, 1);
    CHECK_ZERO(ret);

    pPkt = new AVPacket;
    ret = av_new_packet(pPkt, pCodecCtx->width * pCodecCtx->height);
    CHECK_ZERO(ret);

    SetWindowPos(hWnd, nullptr, 0, 0, pCodecCtx->width + uBorderWidth, pCodecCtx->height + uBorderHeight, SWP_NOMOVE);
    ReleasePaint();
    CreatePaint(hWnd);
    dwWndStyle = GetWindowLong(hWnd, GWL_STYLE);
    ::SetWindowLong(hWnd, GWL_STYLE, dwWndStyle&~WS_SIZEBOX);
    if (!uFrameTimer) uFrameTimer = SetTimer(hWnd, TIMER_FRAME, 40, nullptr);

    while (true)
    {
        if (av_read_frame(pFmtCtx, pPkt) < 0)
        {
            break;
        }

        if (pPkt->stream_index == videoStream)
        {
            ret = avcodec_send_packet(pCodecCtx, pPkt);
            if (ret < 0) continue;
            ret = avcodec_receive_frame(pCodecCtx, pFrameSrc);
            if (ret < 0) continue;

            ret = sws_scale(pImgCtx, pFrameSrc->data, pFrameSrc->linesize,
                0, pCodecCtx->height, pFrameRGB->data, pFrameRGB->linesize);
            if (ret <= 0) continue;
            PlayFrame(hWnd, out_buffer, pCodecCtx->width, pCodecCtx->height);
        }

        av_packet_unref(pPkt);
    }

    if (uFrameTimer)
    {
        KillTimer(hWnd, uFrameTimer);
        uFrameTimer = 0;
    }

    if (dwWndStyle) ::SetWindowLong(hWnd, GWL_STYLE, dwWndStyle);

cleanup:
    if (pFmtCtx) avformat_free_context(pFmtCtx);
    if (pCodecCtx) avcodec_free_context(&pCodecCtx);
    if (pFrameSrc) av_frame_free(&pFrameSrc);
    if (pFrameRGB) av_frame_free(&pFrameRGB);
    if (pImgCtx) sws_freeContext(pImgCtx);
    if (out_buffer) av_free(out_buffer);
    if (pPkt)
    {
        av_packet_unref(pPkt);
        delete pPkt;
    }
}

void LoadVideoPlay(HWND hWnd)
{
    if (gbLoadVideo)
    {
        return;
    }

    TCHAR szPath[1024] = { 0 };
    DWORD dwPath = 1024;
    OPENFILENAME ofn = { 0 };
    ofn.lStructSize = sizeof(ofn);
    ofn.hwndOwner = hWnd;
    ofn.hInstance = hInst;
    ofn.lpstrFile = szPath;
    ofn.nMaxFile = dwPath;
    ofn.lpstrFilter = _T("Video(*.mp4)*.MP4*;*.avi*");
    ofn.Flags = OFN_FILEMUSTEXIST | OFN_HIDEREADONLY;
    ofn.lpstrInitialDir = _T("F:\");

    if (!GetOpenFileName(&ofn))
    {
        DWORD dwErr = CommDlgExtendedError();
        OutputDebugString(_T("GetOpenFileName
"));
        return;
    }

    std::wstring strVideo = szPath;
    std::thread loadVideoThread([hWnd, strVideo]() {
        gbLoadVideo = TRUE;
        std::string sVideo = UnicodeToUTF_8(strVideo.c_str(), strVideo.size());
        OpenVideoByFFmpeg(hWnd, sVideo.c_str());
        gbLoadVideo = FALSE;
    });

    loadVideoThread.detach();
}

//
//  函数: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  目的:    处理主窗口的消息。
//
//  WM_COMMAND  - 处理应用程序菜单
//  WM_PAINT    - 绘制主窗口
//  WM_DESTROY  - 发送退出消息并返回
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
    case WM_CREATE:
    {
        CreatePaint(hWnd);

        RECT rc;
        GetClientRect(hWnd, &rc);
        RECT rcWnd;
        GetWindowRect(hWnd, &rcWnd);
        uBorderWidth = (rcWnd.right - rcWnd.left) - (rc.right - rc.left) + 2;
        uBorderHeight = (rcWnd.bottom - rcWnd.top) - (rc.bottom - rc.top) + 4;
    }
    break;
    case WM_TIMER:
    {
        if (uFrameTimer && (uFrameTimer == wParam))
        {
            if (IsIconic(hWnd)) // 如果最小化了，则直接移除图像帧
            {
                HBITMAP hFrame = PopFrame();
                if (hFrame)
                {
                    DeleteObject(hFrame);
                }
            }
            else
            {
                InvalidateRect(hWnd, nullptr, FALSE);
            }
        }
    }
    break;
    case WM_COMMAND:
        {
            int wmId = LOWORD(wParam);
            // 分析菜单选择: 
            switch (wmId)
            {
            case IDM_OPEN:
                LoadVideoPlay(hWnd);
                break;
            case IDM_ABOUT:
                DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
                break;
            case IDM_EXIT:
                DestroyWindow(hWnd);
                break;
            default:
                return DefWindowProc(hWnd, message, wParam, lParam);
            }
        }
        break;
    case WM_PAINT:
        {
            PAINTSTRUCT ps;
            RECT rc;
            GetClientRect(hWnd, &rc);
            HDC hdc = BeginPaint(hWnd, &ps);
            PaintFrame(hWnd, hdc, rc);
            EndPaint(hWnd, &ps);
        }
        break;
    case WM_DESTROY:
        SetEvent(ghExitEvent);
        ReleaseFrames();
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}

// “关于”框的消息处理程序。
INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    UNREFERENCED_PARAMETER(lParam);
    switch (message)
    {
    case WM_INITDIALOG:
        return (INT_PTR)TRUE;

    case WM_COMMAND:
        if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
        {
            EndDialog(hDlg, LOWORD(wParam));
            return (INT_PTR)TRUE;
        }
        break;
    }
    return (INT_PTR)FALSE;
}

完结撒花