Воспроизведение видео с ip камеры

#include <windows.h>
//---------------------------------------------------------------------------
extern "C" {
#include <libavformat/avformat.h>
#include <libavdevice/avdevice.h>
#include <libswscale/swscale.h>
}
 
#include <stdio.h>
 
class ipc_t
{
public:
    AVFormatContext *format_ctx;
 
    int stream;
 
    AVCodecContext *codec_ctx;
 
    AVFrame *frame;
 
    AVFrame *x_bgr_frame;
 
    SwsContext *x_bgr_ctx;
 
    HANDLE thread_h;
    int terminated;
 
    DWORD proc(void);
 
    void ffmpeg_test_start(char *src);
    void ffmpeg_test_stop(void);
    int ffmpeg_test_get_bmp(void *bmp_bits, int w, int h);
 
 
/********************/
 
 
    HWND hWnd;
     
    int buffer_w, buffer_h;
     
    char *form_bmp_bits;
    HBITMAP form_bmp_h;
     
    void cb(void);
    void create_frame_buffer(void);
    void destroy_frame_buffer(void);
    void init(void);
    void paint(void);
    void uninit(void);
};
 
static DWORD WINAPI global_proc(LPVOID arg)
{
    ipc_t *ipc= (ipc_t *)arg;
    return ipc->proc();
}
 
DWORD ipc_t::proc(void)
{
    AVPacket packet;
    int finished;
    while (!terminated)
    {
        if (av_read_frame(format_ctx, &packet) != 0)
        {
            return 0;
        }
        else if (packet.stream_index == stream)
        {
            if (avcodec_decode_video2(codec_ctx, frame, &finished, &packet) > 0)
            {
                if (finished)
                {
                    cb();
                }
            }
        }
        av_free_packet(&packet);
    }
 
    return 0;
}
 
void ipc_t::ffmpeg_test_start(char *src)
{
    av_register_all();
 
    format_ctx = avformat_alloc_context();
    if (!format_ctx)
    {
        return;
    }
 
    AVDictionary *opts = 0;
    //av_dict_set(&opts, "rtsp_transport", "tcp", 0);
 
    if (avformat_open_input(&format_ctx, src, 0, &opts) != 0)
    {
        return;
    }
 
    if (avformat_find_stream_info(format_ctx, 0) < 0)
    {
        return;
    }
  
    stream = -1;
    for (int i = 0; i < format_ctx->nb_streams; i++)
        if (format_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO)
        {
            stream = i;
            break;
        }
    if (stream == -1)
    {
        return;
    }
  
    codec_ctx = format_ctx->streams[stream]->codec;
  
    AVCodec *codec = avcodec_find_decoder(codec_ctx->codec_id);
    if (!codec)
    {
        return;
    }
 
    if (avcodec_open2(codec_ctx, codec, 0) != 0)
    {
        return;
    }
 
    frame = av_frame_alloc();
    if (!frame)
    {
        return;
    }
 
    x_bgr_frame = 0;
 
    terminated = 0;
    DWORD thread_id;
    thread_h = CreateThread
    (
        0,
        0,
        global_proc,
        this,
        0,
        &thread_id
    );
}
 
void ipc_t::ffmpeg_test_stop(void)
{
    terminated = 1;
 
    WaitForSingleObject(thread_h, INFINITE);
    CloseHandle(thread_h);
 
    sws_freeContext(x_bgr_ctx);
 
    av_free(x_bgr_frame);
    av_free(frame);
  
    avcodec_close(codec_ctx);
  
    avformat_close_input(&format_ctx);
 
    avformat_free_context(format_ctx);
}
 
int ipc_t::ffmpeg_test_get_bmp(void *bmp_bits, int w, int h)
{
    if (!x_bgr_frame || x_bgr_frame->width != w || x_bgr_frame->height != h)
    {
        sws_freeContext(x_bgr_ctx);
        av_free(x_bgr_frame);
 
        x_bgr_frame = 0;
        x_bgr_ctx = 0;
 
        x_bgr_frame = av_frame_alloc();
        if (!x_bgr_frame)
        {
            return 0;
        }
 
        x_bgr_frame->width = w;
        x_bgr_frame->height = h;
 
        if 
        (
            avpicture_fill((AVPicture *)x_bgr_frame, 0, PIX_FMT_RGB32, w, h) < 0
        )
        {
            return 0;
        }
 
        x_bgr_ctx = sws_getContext(codec_ctx->width, codec_ctx->height, codec_ctx->pix_fmt, w, h, PIX_FMT_RGB32, SWS_BICUBIC, 0, 0, 0);
        if (!x_bgr_ctx)
        {
            return 0;
        }
    }
 
    x_bgr_frame->data[0] = (uint8_t *)bmp_bits;
    x_bgr_frame->data[0] += x_bgr_frame->linesize[0] * (h - 1);
    x_bgr_frame->linesize[0] = -x_bgr_frame->linesize[0];   
    sws_scale(x_bgr_ctx, frame->data, frame->linesize, 0, codec_ctx->height, x_bgr_frame->data, x_bgr_frame->linesize);
    x_bgr_frame->linesize[0] = -x_bgr_frame->linesize[0]; 
 
    return 1;
}
//---------------------------------------------------------------------------
void ipc_t::cb(void)
{
    ffmpeg_test_get_bmp(form_bmp_bits, buffer_w, buffer_h);
    InvalidateRect(hWnd, NULL, FALSE);    
}
//---------------------------------------------------------------------------
void ipc_t::create_frame_buffer(void)
{
    BITMAPINFOHEADER form_bmi_hdr;
    form_bmi_hdr.biSize = sizeof(BITMAPINFOHEADER);
    form_bmi_hdr.biWidth = buffer_w;
    form_bmi_hdr.biHeight = buffer_h;
    form_bmi_hdr.biPlanes = 1;
    form_bmi_hdr.biBitCount = 32;
    form_bmi_hdr.biCompression = BI_RGB;
    form_bmi_hdr.biSizeImage = form_bmi_hdr.biWidth * form_bmi_hdr.biHeight * 4;
    form_bmi_hdr.biXPelsPerMeter = 0;
    form_bmi_hdr.biYPelsPerMeter = 0;
    form_bmi_hdr.biClrUsed = 0;
    form_bmi_hdr.biClrImportant = 0;
 
    form_bmp_h = CreateDIBSection(0, (BITMAPINFO *)&form_bmi_hdr, DIB_RGB_COLORS, (void **)&form_bmp_bits, 0, 0);
}
//---------------------------------------------------------------------------
void ipc_t::destroy_frame_buffer(void)
{
    DeleteObject(form_bmp_h);
}
//---------------------------------------------------------------------------
void ipc_t::init(void)
{
    create_frame_buffer();
 
    ffmpeg_test_start("rtsp://127.0.0.1:8554/");
}
//---------------------------------------------------------------------------
void ipc_t::paint(void)
{
    if (form_bmp_h)
    {
        PAINTSTRUCT ps;
        HDC paint_hdc = BeginPaint(hWnd, &ps);
 
        HDC hdc_1 = CreateCompatibleDC(paint_hdc);
        HDC hdc_2 = CreateCompatibleDC(paint_hdc);
 
        HBITMAP h_1 = CreateCompatibleBitmap(paint_hdc, buffer_w, buffer_h);
        HBITMAP old_h_1 = (HBITMAP)SelectObject(hdc_1, h_1);
 
        HBITMAP old_h_2 = (HBITMAP)SelectObject(hdc_2, form_bmp_h);
        BitBlt(hdc_1, 0, 0, buffer_w, buffer_h, hdc_2, 0, 0, SRCCOPY);
 
        BitBlt(paint_hdc, 0, 0, buffer_w, buffer_h, hdc_1, 0, 0, SRCCOPY);
 
        SelectObject(hdc_1, old_h_1);
        SelectObject(hdc_2, old_h_2);
 
        DeleteObject(h_1);
 
        DeleteDC(hdc_1);
        DeleteDC(hdc_2);
 
        EndPaint(hWnd, &ps);
    }
}
//---------------------------------------------------------------------------
void ipc_t::uninit(void)
{
    ffmpeg_test_stop();
 
    destroy_frame_buffer();
}
//---------------------------------------------------------------------------
ipc_t ipc;
 
LRESULT CALLBACK PictViewWndProc(HWND hWnd, UINT Message, UINT wParam, LONG lParam) {
    switch (Message) {
    case WM_PAINT:
        ipc.paint();
        return 0;
    case WM_DESTROY:
        ipc.uninit();
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc(hWnd, Message, wParam, lParam);
}
 
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdParam, int nCmdShow) {
    WNDCLASS WndClass;
    MSG Msg;
    char szClassName[] = "PictView";
 
    WndClass.style = CS_HREDRAW | CS_VREDRAW;
    WndClass.lpfnWndProc = PictViewWndProc;
    WndClass.cbClsExtra = 0;
    WndClass.cbWndExtra = 0;
    WndClass.hInstance = hInstance;
    WndClass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    WndClass.hCursor = LoadCursor(NULL, IDC_ARROW);
    WndClass.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
    WndClass.lpszMenuName = NULL;
    WndClass.lpszClassName = TEXT("PictView");
 
    if (!RegisterClass(&WndClass)) {
        MessageBox(NULL, TEXT("Can't register class"), TEXT("Error"), MB_OK);
        return 0;
    }
 
    ipc.hWnd = CreateWindow(TEXT("PictView"), TEXT("Picture View"), WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
        CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, hInstance, NULL);
    if (!ipc.hWnd) {
        MessageBox(NULL, TEXT("Can't create window"), TEXT("Error"), MB_OK);
        return 0;
    }
 
    ShowWindow(ipc.hWnd, nCmdShow);
    UpdateWindow(ipc.hWnd);
 
    RECT rect;
    GetWindowRect(ipc.hWnd, &rect);
    ipc.buffer_w = rect.right - rect.left;
    ipc.buffer_h = rect.bottom - rect.top;
 
    ipc.init();
    while (GetMessage(&Msg, NULL, 0, 0)) {
        TranslateMessage(&Msg);
        DispatchMessage(&Msg);
    }
    return Msg.wParam;
}

// Инециализация
SpriteSheet::SpriteSheet(const std::shared_ptr<DX::DeviceResources>& deviceResources) : m_deviceResources(deviceResources)
{
        m_ipc = std::unique_ptr<FFUtil::ipc_t>(new FFUtil::ipc_t()); // класс ipc_t
    m_bitMap = m_deviceResources->GetD2DTargetBitmap(); // Microsoft::WRL::ComPtr<ID2D1Bitmap> m_bitMap;
        ipc->buffer_w = 200; // передаю ширину
    ipc->buffer_h = 150; // передаю высоту
}
 
// Обновляет контент, который требуется отобразить..
void SpriteSheet::Update(DX::StepTimer const & timer)
{
        BYTE * byteData = new BYTE[sizeof(ipc->form_bmp_bits)];
    *byteData = *(BYTE *)ipc->form_bmp_bits;
    ComPtr<IWICBitmap> iwicBit;
        unsigned int stride = 0;
    stride = 200 * 5;
    unsigned int bufferSize = 200 * stride; // create a buffer of the appropriate size, width 10.
    auto wicFactory = m_deviceResources->GetWicImagingFactory();
    DX::ThrowIfFailed(wicFactory->CreateBitmapFromMemory(200, 150, GUID_WICPixelFormat32bppPBGRA, stride, bufferSize, byteData, &iwicBit));
        auto d2dContext = m_deviceResources->GetD2DDeviceContext();
    DX::ThrowIfFailed(d2dContext->CreateBitmapFromWicBitmap(iwicBit.Get(), nullptr, &m_bitMap));
}
// Прорисовывает кадр на экране.
void SpriteSheet::Render()
{
        if (!m_bitMap) return;
    auto d2dContext = m_deviceResources->GetD2DDeviceContext();
    d2dContext->BeginDraw();
        d2dContext->DrawBitmap(
        m_bitMap.Get(), // Изображение
        &D2D1::RectF(0, 0, m_bitMap->GetSize().width, m_bitMap->GetSize().height), // Место назначения
        1.0f, // Прозрачность
        D2D1_BITMAP_INTERPOLATION_MODE::D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR, // Интерполяционный режим
        &D2D1::RectF(0.0f, 0.0f, m_bitMap->GetSize().width, m_bitMap->GetSize().height) // Источник
    );
    HRESULT hr = d2dContext->EndDraw(); [COLOR="Red"][B]// Вот здесь выдает ошибку[/B][/COLOR]
    if (hr != D2DERR_RECREATE_TARGET)
    {
        DX::ThrowIfFailed(hr);
    }
}