Windows 视频解码及显示[转]

最新推荐文章于 2024-03-28 19:34:00 发布
最新推荐文章于 2024-03-28 19:34:00 发布
阅读量301 收藏
点赞数
分类专栏： OpenGL学习笔记
原文链接：https://mp.csdn.net/mp_blog/creation/editor/119491213
版权

Windows 视频解码及显示[转]

目录

创建窗口

单线程解码并且绘制

多线程解码并且绘制

速率控制

创建窗口

#pragma once

#include <windows.h>
#include <tchar.h>

LRESULT CALLBACK    windowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch (msg)
    {
    case WM_PAINT:
    {
        PAINTSTRUCT ps;
        HDC         hdc;
        hdc = BeginPaint(hWnd, &ps);
        EndPaint(hWnd, &ps);
    }
    break;
    case WM_SIZE:
        break;
    case WM_CLOSE:
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        break;
    }

    return  DefWindowProc(hWnd, msg, wParam, lParam);
}

int     WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
    //  1   注册窗口类
    ::WNDCLASSEXA winClass;
    winClass.lpszClassName = "FFVideoPlayer";
    winClass.cbSize = sizeof(::WNDCLASSEX);
    winClass.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC | CS_DBLCLKS;
    winClass.lpfnWndProc = windowProc;
    winClass.hInstance = hInstance;
    winClass.hIcon = 0;
    winClass.hIconSm = 0;
    winClass.hCursor = LoadCursor(NULL, IDC_ARROW);
    winClass.hbrBackground = (HBRUSH)(BLACK_BRUSH);
    winClass.lpszMenuName = NULL;
    winClass.cbClsExtra = 0;
    winClass.cbWndExtra = 0;
    RegisterClassExA(&winClass);

    //  2 创建窗口
    HWND    hWnd = CreateWindowEx(
        NULL,
        "FFVideoPlayer",
        "FFVideoPlayer",
        WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
        0,
        0,
        480,
        320,
        0,
        0,
        hInstance,
        0
        );

    UpdateWindow(hWnd);
    ShowWindow(hWnd, SW_SHOW);

    MSG     msg = { 0 };
    while (GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    return  0;
}

单线程解码并且绘制

#pragma once
#include <windows.h>
#include <tchar.h>
#include "FFVideoReader.hpp"

HBITMAP         g_hBmp = 0;
HDC             g_hMem = 0;
BYTE* g_imageBuf = 0;
FFVideoReader   g_reader;

LRESULT CALLBACK    windowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch (msg)
    {
    case WM_PAINT:
    {
        PAINTSTRUCT ps;
        HDC         hdc;
        hdc = BeginPaint(hWnd, &ps);
        BitBlt(hdc, 0, 0, g_reader._screenW, g_reader._screenH, g_hMem, 0, 0, SRCCOPY);
        EndPaint(hWnd, &ps);
    }
    break;
    case WM_SIZE:
        break;
    case WM_CLOSE:
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    case WM_TIMER:
    {
        BYTE* data = (BYTE*)g_reader.readFrame();
        for (int i = 0; i < g_reader._screenW * g_reader._screenH * 3; i += 3)
        {  //RGB  -> BGR
            g_imageBuf[i + 0] = data[i + 2];
            g_imageBuf[i + 1] = data[i + 1];
            g_imageBuf[i + 2] = data[i + 0];
        }
        InvalidateRect(hWnd, 0, 0);  //窗口刷新 调用WM_PAINT
    }
    break;
    default:
        break;
    }

    return  DefWindowProc(hWnd, msg, wParam, lParam);
}

void  getResourcePath(HINSTANCE hInstance, char pPath[1024])
{
    char    szPathName[1024];
    char    szDriver[64];
    char    szPath[1024];
    GetModuleFileNameA(hInstance, szPathName, sizeof(szPathName));
    _splitpath(szPathName, szDriver, szPath, 0, 0);
    sprintf(pPath, "%s%s", szDriver, szPath);
}

int     WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
    //  1   注册窗口类
    ::WNDCLASSEXA winClass;
    winClass.lpszClassName = "FFVideoPlayer";
    winClass.cbSize = sizeof(::WNDCLASSEX);
    winClass.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC | CS_DBLCLKS;
    winClass.lpfnWndProc = windowProc;
    winClass.hInstance = hInstance;
    winClass.hIcon = 0;
    winClass.hIconSm = 0;
    winClass.hCursor = LoadCursor(NULL, IDC_ARROW);
    winClass.hbrBackground = (HBRUSH)(BLACK_BRUSH);
    winClass.lpszMenuName = NULL;
    winClass.cbClsExtra = 0;
    winClass.cbWndExtra = 0;
    RegisterClassExA(&winClass);

    //  2 创建窗口
    HWND    hWnd = CreateWindowEx(
        NULL,
        "FFVideoPlayer",
        "FFVideoPlayer",
        WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
        0,
        0,
        480,
        320,
        0,
        0,
        hInstance,
        0
        );

    UpdateWindow(hWnd);
    ShowWindow(hWnd, SW_SHOW);

    char    szPath[1024];
    char    szPathName[1024];

    getResourcePath(hInstance, szPath);

    sprintf(szPathName, "%sdata/11.flv", szPath);



    HDC     hDC = GetDC(hWnd);
    g_hMem = ::CreateCompatibleDC(hDC);
    g_reader.setup();
    g_reader.load(szPathName);

    BITMAPINFO	bmpInfor = { 0 };
    bmpInfor.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    bmpInfor.bmiHeader.biWidth = g_reader._screenW;
    bmpInfor.bmiHeader.biHeight = -g_reader._screenH;
    bmpInfor.bmiHeader.biPlanes = 1;
    bmpInfor.bmiHeader.biBitCount = 24;
    bmpInfor.bmiHeader.biCompression = BI_RGB;
    bmpInfor.bmiHeader.biSizeImage = 0;
    bmpInfor.bmiHeader.biXPelsPerMeter = 0;
    bmpInfor.bmiHeader.biYPelsPerMeter = 0;
    bmpInfor.bmiHeader.biClrUsed = 0;
    bmpInfor.bmiHeader.biClrImportant = 0;

    g_hBmp = CreateDIBSection(hDC, &bmpInfor, DIB_RGB_COLORS, (void**)&g_imageBuf, 0, 0);
    SelectObject(g_hMem, g_hBmp);

    SetTimer(hWnd, 1, 40, 0);

    MSG     msg = { 0 };
    while (GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    return  0;
}

多线程解码并且绘制

#pragma once

#include <windows.h>

class   Thread
{
public:
    DWORD               _threadId;
    HANDLE              _thread;
protected:
   
    /**
    *   线程入口函数
    */
    static  DWORD    CALLBACK threadEnter(void* pVoid)
    {
        Thread* pThis   =   (Thread*)pVoid;
        if (pThis)
        {
            pThis->run();
        }
        return  0;
    }
public:
    Thread()
    {
        _thread     =   0;
        _threadId   =   0;
    }
    virtual ~Thread()
    {
        join();
    }
   
    virtual bool    run()
    {
        return  true;
    }
    /**
    *   启动线程函数
    */
    virtual bool    start()
    {
        if (_thread != 0)
        {
            return  false;
        }
        else
        {
            //HIGH_PRIORITY_CLASS
            _thread     =   CreateThread(0,0,&Thread::threadEnter,this,0,&_threadId);
            return  true;
        }
    }
    /**
    *   等待退出函数
    */
    virtual void    join()
    {
        if (_thread)
        {
            WaitForSingleObject(_thread,0xFFFFFFFF);
            CloseHandle(_thread);
            _thread     =   0;
        }
    }
};
#include <windows.h>
#include <tchar.h>
#include "FFVideoReader.hpp"
#include "Thread.hpp"
#define WM_UPDATE_VIDEO WM_USER + 100

void  getResourcePath(HINSTANCE hInstance, char pPath[1024])
{
    char    szPathName[1024];
    char    szDriver[64];
    char    szPath[1024];
    GetModuleFileNameA(hInstance, szPathName, sizeof(szPathName));
    _splitpath(szPathName, szDriver, szPath, 0, 0);
    sprintf(pPath, "%s%s", szDriver, szPath);
}

BYTE* g_imageBuf = 0;
HDC             g_hMem = 0;
HBITMAP	        g_hBmp = 0;

class   DecodeThread :public Thread
{
public:
    FFVideoReader   _ffReader;
    HWND            _hWnd;
    bool            _exitFlag;
public:
    DecodeThread()
    {
        _ffReader.setup();
        _hWnd = 0;
        _exitFlag = false;
    }

    void    exitThread()
    {
        _exitFlag = true;
        join();
    }
    /**
    *   加载文件
    */
    virtual void    load(const char* fileName)
    {
        _ffReader.load(fileName);
    }
    /**
    *   线程执行函数
    */
    virtual bool    run()
    {
        while (!_exitFlag)
        {
            FrameInfor  infor;
            if (!_ffReader.readFrame(infor))
            {
                break;
            }

            BYTE* data = (BYTE*)infor._data;
            for (int i = 0; i < infor._dataSize; i += 3)
            {
                g_imageBuf[i + 0] = data[i + 2];
                g_imageBuf[i + 1] = data[i + 1];
                g_imageBuf[i + 2] = data[i + 0];
            }
            InvalidateRect(_hWnd, 0, 0);
        }

        return  true;
    }
};

DecodeThread    g_decode;

LRESULT CALLBACK    windowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch (msg)
    {

    case WM_PAINT:
    {
        PAINTSTRUCT ps;
        HDC         hdc;
        hdc = BeginPaint(hWnd, &ps);
        if (g_hMem)
        {
            BITMAPINFO  bmpInfor;
            GetObject(g_hBmp, sizeof(bmpInfor), &bmpInfor);
            BitBlt(hdc, 0, 0, bmpInfor.bmiHeader.biWidth, bmpInfor.bmiHeader.biHeight, g_hMem, 0, 0, SRCCOPY);
        }

        EndPaint(hWnd, &ps);
    }
    break;
    case WM_SIZE:
        break;
    case WM_CLOSE:
    case WM_DESTROY:
        g_decode.exitThread();
        PostQuitMessage(0);
        break;
    default:
        break;
    }

    return  DefWindowProc(hWnd, msg, wParam, lParam);
}

int     WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
    //  1   注册窗口类
    ::WNDCLASSEXA winClass;
    winClass.lpszClassName = "FFVideoPlayer";
    winClass.cbSize = sizeof(::WNDCLASSEX);
    winClass.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC | CS_DBLCLKS;
    winClass.lpfnWndProc = windowProc;
    winClass.hInstance = hInstance;
    winClass.hIcon = 0;
    winClass.hIconSm = 0;
    winClass.hCursor = LoadCursor(NULL, IDC_ARROW);
    winClass.hbrBackground = (HBRUSH)(BLACK_BRUSH);
    winClass.lpszMenuName = NULL;
    winClass.cbClsExtra = 0;
    winClass.cbWndExtra = 0;
    RegisterClassExA(&winClass);

    //  2 创建窗口
    HWND    hWnd = CreateWindowExA(
        NULL,
        "FFVideoPlayer",
        "FFVideoPlayer",
        WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
        0,
        0,
        480,
        320,
        0,
        0,
        hInstance,
        0
        );

    UpdateWindow(hWnd);
    ShowWindow(hWnd, SW_SHOW);

    char    szPath[1024];
    char    szPathName[1024];

    getResourcePath(hInstance, szPath);
    sprintf(szPathName, "%sdata/11.flv", szPath);

    HDC     hDC = GetDC(hWnd);
    g_hMem = ::CreateCompatibleDC(hDC);

    g_decode._hWnd = hWnd;
    g_decode.load(szPathName);


    BITMAPINFO	bmpInfor;
    bmpInfor.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    bmpInfor.bmiHeader.biWidth = g_decode._ffReader._screenW;
    bmpInfor.bmiHeader.biHeight = -g_decode._ffReader._screenH;
    bmpInfor.bmiHeader.biPlanes = 1;
    bmpInfor.bmiHeader.biBitCount = 24;
    bmpInfor.bmiHeader.biCompression = BI_RGB;
    bmpInfor.bmiHeader.biSizeImage = 0;
    bmpInfor.bmiHeader.biXPelsPerMeter = 0;
    bmpInfor.bmiHeader.biYPelsPerMeter = 0;
    bmpInfor.bmiHeader.biClrUsed = 0;
    bmpInfor.bmiHeader.biClrImportant = 0;

    g_hBmp = CreateDIBSection(hDC, &bmpInfor, DIB_RGB_COLORS, (void**)&g_imageBuf, 0, 0);
    SelectObject(g_hMem, g_hBmp);

    g_decode.start();

    MSG     msg = { 0 };
    while (GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    return  0;
}

速率控制

#pragma once


extern "C"
{
#include <libavutil/imgutils.h>
#include <libavutil/parseutils.h>
#include <libswscale/swscale.h>
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavformat/avio.h>
#include <libavutil/file.h>
}


struct  FrameInfor
{
    void*   _data;
    int     _dataSize;
    int     _width;
    int     _height;
    int64_t _pts;
    double  _timeBase;
    
};
class   FFVideoReader
{
public:
    AVFormatContext*_formatCtx;
    int             _videoIndex;
    AVCodecContext* _codecCtx;
    AVCodec*        _codec;
    AVFrame*        _frame;
    AVFrame*        _frameRGB;
    SwsContext*     _convertCtx;
public:
    int             _screenW;
    int             _screenH;

    int             _imageSize;
public:
    FFVideoReader()
    {
        _formatCtx  =   0;
        _videoIndex =   -1;
        _codecCtx   =   0;
        _codec      =   0;
        _frame      =   0;
        _frameRGB   =   0;
        _convertCtx =   0;
        _screenW    =   0;
        _screenH    =   0;
        
    }

    ~FFVideoReader()
    {
        sws_freeContext(_convertCtx);
        av_free(_frameRGB);
        av_free(_frame);
        avcodec_close(_codecCtx);
        avformat_close_input(&_formatCtx);
    }

    void    setup()
    {
        av_register_all();
        _formatCtx  =   avformat_alloc_context();
    }
    int     load(const char* filepath = "11.flv")
    {
        int     ret     =   0;

        //! 打开文件
        if (avformat_open_input(&_formatCtx, filepath, NULL, NULL) != 0) 
        {
            return -1;
        }
        //! 检测文件中是否存在数据流
        if (avformat_find_stream_info(_formatCtx, NULL) < 0)
        {
            return -1;
        }
        //! 获取视频流索引
        _videoIndex = -1;
        for (int i = 0; i < _formatCtx->nb_streams; i++)
        {
            if (_formatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) 
            {
                _videoIndex = i;
                break;
            }
        }
        /**
        *   没有视频流，则返回
        */
        if (_videoIndex == -1) 
        {
            return -1;
        }
        _codecCtx   =   _formatCtx->streams[_videoIndex]->codec;

        double dur  =   _formatCtx->duration/double(AV_TIME_BASE);
        _codec      =   avcodec_find_decoder(_codecCtx->codec_id);
        if (_codec == NULL)
        {
            return -1;
        }
        /**
        *   打开解码器
        */
        if (avcodec_open2(_codecCtx, _codec, NULL) < 0) 
        {
            return -1;
        }
        _frame      =   av_frame_alloc();
        _frameRGB   =   av_frame_alloc();

        _screenW    =   _codecCtx->width;
        _screenH    =   _codecCtx->height;

        _convertCtx =   sws_getContext(
                                    _codecCtx->width
                                    , _codecCtx->height
                                    , _codecCtx->pix_fmt
                                    , _codecCtx->width
                                    , _codecCtx->height
                                    , AV_PIX_FMT_RGB24
                                    , SWS_BICUBIC
                                    , NULL
                                    , NULL
                                    , NULL
                                    );

        int     numBytes    =   avpicture_get_size(AV_PIX_FMT_RGB24, _codecCtx->width,_codecCtx->height);
        uint8_t*buffer      =   (uint8_t *) av_malloc (numBytes * sizeof(uint8_t));
        avpicture_fill((AVPicture *)_frameRGB, buffer, AV_PIX_FMT_RGB24,_codecCtx->width, _codecCtx->height);
        _imageSize  =   numBytes;
        return  0;
    }

    bool    readFrame(FrameInfor& infor)
    {
        AVPacket packet;
        av_init_packet(&packet);
        for (;;) 
        {
            if (av_read_frame(_formatCtx, &packet)) 
            {
                av_free_packet(&packet);
                return false;
            }
            if (packet.stream_index != _videoIndex) 
            {
                continue;
            }
            int frame_finished = 0;

            int res = avcodec_decode_video2(_codecCtx, _frame, &frame_finished, &packet);

            if (frame_finished)
            {
                AVStream*   streams =   _formatCtx->streams[_videoIndex];
                double      tmbase  =   av_q2d(streams->time_base);
                int64_t     pts     =   _frame->pts;

                char        buf[128];
                sprintf(buf,"pts = %I64d     dts =  %I64d\n",packet.pts,packet.dts);
                int res = sws_scale(
                    _convertCtx
                    , (const uint8_t* const*)_frame->data
                    , _frame->linesize
                    , 0
                    , _codecCtx->height
                    , _frameRGB->data
                    , _frameRGB->linesize
                    );
                av_packet_unref(&packet);

                infor._data     =   _frameRGB->data[0];
                infor._dataSize =   _imageSize;
                infor._width    =   _screenW;
                infor._height   =   _screenH;
                infor._pts      =   _frame->pts;
                infor._timeBase =   av_q2d(streams->time_base);

                return  true;
            }
        }
        return  false;
    }
    void*   readFrame()
    {
        AVPacket packet;
        av_init_packet(&packet);
        for (;;) 
        {
            if (av_read_frame(_formatCtx, &packet)) 
            {
                av_free_packet(&packet);
                return 0;
            }
            if (packet.stream_index != _videoIndex) 
            {
                continue;
            }
            int frame_finished = 0;

            int res = avcodec_decode_video2(_codecCtx, _frame, &frame_finished, &packet);

            if (frame_finished)
            {
                AVStream*   streams =   _formatCtx->streams[_videoIndex];
                double      tmbase  =   av_q2d(streams->time_base);
                int64_t     pts     =   _frame->pts;

                char        buf[128];
                sprintf(buf,"pts = %I64d     dts =  %I64d\n",packet.pts,packet.dts);
                int res = sws_scale(
                    _convertCtx
                    , (const uint8_t* const*)_frame->data
                    , _frame->linesize
                    , 0
                    , _codecCtx->height
                    , _frameRGB->data
                    , _frameRGB->linesize
                    );
                av_packet_unref(&packet);

                return  _frameRGB->data[0];
            }
        }
        return  0;
    }
};
  • 时间：
#pragma once
#include <windows.h>
class Timestamp
{
public:
    Timestamp()
    {
        QueryPerformanceFrequency(&_frequency);
        QueryPerformanceCounter(&_startCount);
    }
    ~Timestamp()
    {}

    void    update()
    {
        QueryPerformanceCounter(&_startCount);
    }
    /**
    *   获取当前秒
    */
    double getElapsedSecond()
    {
        return  getElapsedTimeInMicroSec() * 0.000001;
    }
    /**
    *   获取毫秒
    */
    double getElapsedTimeInMilliSec()
    {
        return this->getElapsedTimeInMicroSec() * 0.001;
    }
    /**
    *   获取微妙
    */
    double getElapsedTimeInMicroSec()
    {
        LARGE_INTEGER endCount;
        QueryPerformanceCounter(&endCount);

        double  startTimeInMicroSec =   _startCount.QuadPart * (1000000.0 / _frequency.QuadPart);
        double  endTimeInMicroSec   =   endCount.QuadPart * (1000000.0 / _frequency.QuadPart);

        return  endTimeInMicroSec - startTimeInMicroSec;
    }
protected:
    LARGE_INTEGER   _frequency;
    LARGE_INTEGER   _startCount;
};
#include <windows.h>
#include <tchar.h>
#include "FFVideoReader.hpp"
#include "Thread.hpp"
#include "Timestamp.hpp"

void  getResourcePath(HINSTANCE hInstance,char pPath[1024])
{
    char    szPathName[1024];
    char    szDriver[64];
    char    szPath[1024];
    GetModuleFileNameA(hInstance,szPathName,sizeof(szPathName));
    _splitpath( szPathName, szDriver, szPath, 0, 0 );
    sprintf(pPath,"%s%s",szDriver,szPath);
}

class   DecodeThread :public Thread
{
public:
    FFVideoReader   _ffReader;
    HWND            _hWnd;
    BYTE*           _imageBuf;
    HDC             _hMem;
    HBITMAP	        _hBmp;

    bool            _exitFlag;
    Timestamp       _timestamp;
public:
    DecodeThread()
    {
        _exitFlag   =   false;
        _hWnd       =   0;
    }

    virtual void    setup(HWND hwnd,const char* fileName = "11.flv")
    {
        _hWnd   =   hwnd;
        _ffReader.setup();
        _ffReader.load(fileName);

        HDC     hDC     =   GetDC(hwnd);
        _hMem   =   ::CreateCompatibleDC(hDC);
        
        BITMAPINFO	bmpInfor;
        bmpInfor.bmiHeader.biSize			=	sizeof(BITMAPINFOHEADER);
        bmpInfor.bmiHeader.biWidth			=	_ffReader._screenW;
        bmpInfor.bmiHeader.biHeight			=	-_ffReader._screenH;
        bmpInfor.bmiHeader.biPlanes			=	1;
        bmpInfor.bmiHeader.biBitCount		=	24;
        bmpInfor.bmiHeader.biCompression	=	BI_RGB;
        bmpInfor.bmiHeader.biSizeImage		=	0;
        bmpInfor.bmiHeader.biXPelsPerMeter	=	0;
        bmpInfor.bmiHeader.biYPelsPerMeter	=	0;
        bmpInfor.bmiHeader.biClrUsed		=	0;
        bmpInfor.bmiHeader.biClrImportant	=	0;

        _hBmp    =	CreateDIBSection(hDC,&bmpInfor,DIB_RGB_COLORS,(void**)&_imageBuf,0,0);
        SelectObject(_hMem,_hBmp);
    }
    /**
    *   加载文件
    */
    virtual void    load(const char* fileName)
    {
        _ffReader.load(fileName);
    }

    virtual void    join()
    {
        _exitFlag   =   true;
        Thread::join();
    }
    /**
    *   线程执行函数
    */
    virtual bool    run()
    {
        _timestamp.update();
        while(!_exitFlag)
        {
            FrameInfor  infor;
            if (!_ffReader.readFrame(infor))
            {
                break;
            }
            double      tims    =   infor._pts * infor._timeBase * 1000;
            BYTE*   data    =   (BYTE*)infor._data;
            for (int i = 0 ;i < infor._dataSize; i += 3 )
            {
                _imageBuf[i + 0 ]   =   data[i + 2];
                _imageBuf[i + 1 ]   =   data[i + 1];
                _imageBuf[i + 2 ]   =   data[i + 0];
            }
            //! 这里需要通知窗口进行重绘制更新，显示更新数据
            InvalidateRect(_hWnd,0,0);
            
            double      elsped  =   _timestamp.getElapsedTimeInMilliSec();
            double      sleeps  =   (tims - elsped);
            if (sleeps > 1)
            {
                Sleep((DWORD)sleeps);
            }
        }

        return  true;
    }
};

DecodeThread    g_decode;

LRESULT CALLBACK    windowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch(msg)
    {
    case WM_PAINT:
        {
            PAINTSTRUCT ps;
            HDC         hdc;
            hdc = BeginPaint(hWnd, &ps);
            if (g_decode._hMem)
            {
                BITMAPINFO  bmpInfor;
                GetObject(g_decode._hBmp,sizeof(bmpInfor),&bmpInfor);
                BitBlt(hdc,0,0,bmpInfor.bmiHeader.biWidth,bmpInfor.bmiHeader.biHeight,g_decode._hMem,0,0,SRCCOPY);
            }

            EndPaint(hWnd, &ps);
        }
        break;
    case WM_SIZE:
        break;
    case WM_CLOSE:
    case WM_DESTROY:
        g_decode.join();
        PostQuitMessage(0);
        break;
    default:
        break;
    }

    return  DefWindowProc( hWnd, msg, wParam, lParam );
}

int     WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd )
{
    //  1   注册窗口类
    ::WNDCLASSEXA winClass;
    winClass.lpszClassName  =   "FFVideoPlayer";
    winClass.cbSize         =   sizeof(::WNDCLASSEX);
    winClass.style          =   CS_HREDRAW | CS_VREDRAW | CS_OWNDC | CS_DBLCLKS;
    winClass.lpfnWndProc    =   windowProc;
    winClass.hInstance      =   hInstance;
    winClass.hIcon	        =   0;
    winClass.hIconSm	    =   0;
    winClass.hCursor        =   LoadCursor(NULL, IDC_ARROW);
    winClass.hbrBackground  =   (HBRUSH)(BLACK_BRUSH);
    winClass.lpszMenuName   =   NULL;
    winClass.cbClsExtra     =   0;
    winClass.cbWndExtra     =   0;
    RegisterClassExA(&winClass);

    //  2 创建窗口
    HWND    hWnd   =   CreateWindowExA(
        NULL,
        "FFVideoPlayer",
        "FFVideoPlayer",
        WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
        0,
        0,
        480,
        320, 
        0, 
        0,
        hInstance, 
        0
        );

    UpdateWindow( hWnd );
    ShowWindow(hWnd,SW_SHOW);

    char    szPath[1024];
    char    szPathName[1024];

    getResourcePath(hInstance,szPath);
    sprintf(szPathName,"%sdata/11.flv",szPath);

    g_decode.setup(hWnd,szPathName);
    g_decode.start();

    MSG     msg =   {0};
    while (GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    
    return  0;
}

NGC_2070
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
全能解码器 K-Lite Codec Pack Full v1698 （显示视频缩略图）
03-27
说明：WIN7和WIN10默认是无法显示视频文件缩略图的，有了这款解码器，视频无需打开即可一目了然。 几乎支持所有视频格式。标准版以上带播放器。 Basic=基础版，Standard=标准版（推荐），Full=完整版，Mega=增强版
Qt+FFMPEG解码视频并显示
04-03
是一个Windows下使用FFMPEG解码视频并保存成图片文件的简单的例子 FFMPEG的版本是2.5.2 关于代码的解释 请参考： http://blog.yundiantech.com/?log=blog&id=8 是一个Windows下使用FFMPEG解码视频 并使用QPaint...
MediaCodec之Decoder
热门推荐
hubinbin595959的专栏
05-08 49万+
1.介绍： MediaCodec类可用于访问Android底层的媒体编解码器，也就是，编码器/解码器组件。它是Android底层多媒体支持基本架构的一部分（通常与MediaExtractor, MediaSync, MediaMuxer, MediaCrypto, MediaDrm, Image, Surface, 以及AudioTrack一起使用）；MediaCodec作为比较年轻的Androi...
小窗播放视频的原理和实现（上）
老衲不出家
01-05 6074
本文对小窗视频播放进行了详细的研究，针对几种实现方案进行了深入的对比分析，进而给出实现小窗视频播放的最优解。其中通过对系统源码的分析，详细探究了如何完美地实现移动、缩放等效果，很有技术深度。文中几种方案的对比，以及SurfaceView、GLSurfaceView和TextureView相关知识点的讲解，非常实用，值得收藏。 — 责任编辑 junyihan 由于文章篇幅较长，将分为
Python库-FuzzyWuzzy使用介绍
最新发布
wt334502157的博客
03-28 2万+
FuzzyWuzzy是一个 Python 库，旨在提供模糊字符串匹配的功能。它能够比较两个字符串之间的相似度，即使它们在拼写或格式上略有不同。通过使用各种算法和方法，如基于字符、基于单词的匹配，以及部分匹配和排序匹配等技术，FuzzyWuzzy 能够有效地处理文本数据中的拼写错误、近义词和重复项。这使得它在数据清洗、搜索功能、自动完成和信息抽取等场景中非常实用。FuzzyWuzzy 提供了简单易用的 API，使得开发者可以轻松地将其集成到自己的项目中，并快速实现字符串匹配和相似度比较的功能。
GsyVideoPlayer视频分析（三）------------全屏实现
qq_15631341的博客
07-04 9253
首先思考以下几个问题： 1.点击全屏按钮，视频是怎么填充整个屏幕的？（以及视频放大时的动画效果实现） 2.视频填充屏幕后，又是如何实现横屏的？ 3.视频是如何做到，列表中的视频和放大后的视频，无缝衔接的？ 依旧通过代码分析： //设置全屏按键功能 gsyVideoPlayer.getFullscreenButton().setOnClickListener(new View.OnCl
LabVIEW与视频播放
laipin7的专栏
05-22 1万+
LabVIEW与视频播放摘要：本文介绍如何在LabVIEW平台利用Windows Media Player控件实现音视频播放。 关键字：LabVIEW，Windows Media Player SDK，视频播放 正文：在一些用LABVIEW开发的监控系统中，可能涉及视频监控部分。但LABVIEW只提供了音频操作的相关函数，并没有直接提供视频操作的相关节点，因此需
Directshow开发的基本技巧
智慧的鱼
05-26 7913
Directshow开发的基本技巧 摘要：本篇文档主要讲述了Directshow开发的一些基本概念和技巧 1视频播放（Video Rendering） dshow的视频提交过滤器可以在窗口模式和无窗口模式下工作。在窗口模式下，过滤器创建一个自己的窗口，在里面播放视频。在无窗口模式下，过滤器直接将视频在应用程序提供的窗口上显示，过滤器本身不创建窗口。窗口模式在窗口模式下，视频提交过滤器创建一个窗口，
windows万能播放视频 并带缩略图显示
09-24
windows系统下的视频，可以称得上万能播放，在我的电脑上直接能看到缩略图显示,打开附件，一直下一步直到完成，亲测可用
Windows 高级解码包 ADVANCED Codecs 14.9.5 for Windows 7810 免费版.zip
06-01
Windows 7、8、10（以前称为 Win7codecs）的高级编解码器是音频和视频编解码器程序包。在安装此简洁而全面的软件包之前，安装程序将自动从计算机中删除大多数其他流行的编解码器版本。ADVANCED Codecs 设置方法？您...
使用EasyNVR无插件实时播放海康摄像机视频
qq_27933251的博客
11-15 2733
EasyNVR官网 EasyNVR可以集成RTMP, HLS, FLV, RTSP视频格式，并且做到了低延时，支持了跨平台直播，视频回放，视频录制，视频下载，云台控制等。 下载官网软件压缩包，解压，此处路径不能有中文，双击 EasyNVR.exe 程序启动，如提示没有成功，点击下边添加服务，然后双击启动。 配置客户端视频 访问http://localhost:10800/打开客户端，用户名密...
win7视频解码器
01-09
有了它，电脑只需要自带的media player搞定一切
如何在计算机的夜间模式下使视频聊天看起来更好
09-02 279
I hate video chats. As a tool for a work-from-home writer, it’s obviously pretty essential, but between my pale complexion and a desk full of computer monitors, the picture streaming through my webcam...
［ffmpeg］解码并显示
minger1202的专栏
09-08 4002
ffmpeg ＋ sdl2 解码并显示
视频编解码笔记（一）
cwbguaijie的专栏
02-28 277
视频用来记录、显示运动对象，它由一系列在固定时间间隔拍摄的图片组成。采用25f/s或30f/s是电视图像的标准；50f/s或60f/s则能产生相当平滑的运动.视频可被分为模拟和数字类型。模拟视频用模拟信号来表示，由模拟摄像机进行逐行扫描或隔行扫描来捕获。数字视频常常用数字摄像机来捕获，也能由模拟视频信号转换得到。模拟信号是指信息参数在给定范围内表现为连续的信号。数字信号是指人们抽象出来的时间上不连...
文本的四种编码方式(转)
congjukun0600的博客
08-11 1047
文本的四种编码方式(转)[@more@]简单介绍一下这四种编码方式：　　ANSI：系统预设的标准文字储存格式。ANSI是American National Standards Institute的缩写。它成立于1918年，是一个...
FFmpeg 视频解码,窗口显示
HHCOO的博客
07-27 1019
#ifndef __DECODE_STREAM_FROM_CAMERA__ #define __DECODE_STREAM_FROM_CAMERA__ extern "C"{ #include "libavcodec/avcodec.h" #include "libavformat/avformat.h" #include "libavdevice/avdevice.h" #in
\avformat.h(40) : fatal error C1083: 无法打开包括文件:“libavcodec/avcodec.h”: No such file or directory...
weixin_34249367的博客
01-11 4953
在ffmpeg库下面的头文件包含时用"../"表示当前项目下的头文件就ok了  
windows下qt+ffmpeg+qsv解码显示
11-25
在Windows平台上，可以使用Qt和FFmpeg以及Intel Quick Sync Video（QSV）来进行视频解码和显示。首先，需要在Qt中集成FFmpeg库，以便能够使用其功能进行视频解码。可以使用QMediaPlayer类来实现视频的播放和显示，并...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值