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

//------------------------------------------------------------------------------
//ffmpeg_test 1.0
//------------------------------------------------------------------------------
#ifndef ffmpeg_test_h
#define ffmpeg_test_h
//------------------------------------------------------------------------------
#include <windows.h>
//------------------------------------------------------------------------------
#ifdef EXPORT
#define DECL_SPEC __declspec(dllexport) __stdcall
#else
#define DECL_SPEC __declspec(dllimport) __stdcall
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
//------------------------------------------------------------------------------
void DECL_SPEC ffmpeg_test_start(char *src, void (*cb_fn)(void));
void DECL_SPEC ffmpeg_test_stop(void);
int DECL_SPEC ffmpeg_test_get_bmp(void *bmp_bits, int w, int h); //32 bit
//------------------------------------------------------------------------------
#ifdef __cplusplus
} //extern "C"
#endif
 
#undef EXPORT
//------------------------------------------------------------------------------
#endif //ffmpeg_test_h

#define EXPORT
#include "ffmpeg_test.h"
 
extern "C" {
#include <libavformat/avformat.h>
#include <libavdevice/avdevice.h>
#include <libswscale/swscale.h>
}
 
#include <stdio.h>
 
static AVFormatContext *format_ctx;
 
static int stream;
 
static AVCodecContext *codec_ctx;
 
static AVFrame *frame;
 
static AVFrame *x_bgr_frame;
 
static SwsContext *x_bgr_ctx;
 
static HANDLE thread_h;
static int terminated;
 
void (*cb_fn)(void);
 
static DWORD WINAPI proc(LPVOID arg)
{
    AVPacket packet;
    int finished;
    while (!terminated)
    {
        if (av_read_frame(format_ctx, &packet) != 0)
        {
            ExitThread(0);
        }
        else if (packet.stream_index == stream)
        {
            if (avcodec_decode_video2(codec_ctx, frame, &finished, &packet) > 0)
            {
                if (finished)
                {
                    cb_fn();
                }
            }
        }
        av_free_packet(&packet);
    }
 
    ExitThread(0);
}
 
void DECL_SPEC ffmpeg_test_start(char *src, void (*cb_fn)(void))
{
    ::cb_fn = cb_fn;
 
    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,
        proc,
        0,
        0,
        &thread_id
    );
}
 
void DECL_SPEC 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 DECL_SPEC 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)
    {
        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;
}
 
BOOL APIENTRY DllMain( HMODULE hModule,
                       DWORD  ul_reason_for_call,
                       LPVOID lpReserved
                     )
{
    switch (ul_reason_for_call)
    {
    case DLL_PROCESS_ATTACH:
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
    case DLL_PROCESS_DETACH:
        break;
    }
    return TRUE;
}

//---------------------------------------------------------------------------
 
#ifndef main_form_unitH
#define main_form_unitH
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
//---------------------------------------------------------------------------
class Tmain_form;
//---------------------------------------------------------------------------
class repaint_thread_t : public TThread
{
public:
    Tmain_form *form;
 
    repaint_thread_t(bool CreateSuspended, Tmain_form *form);
 
    void __fastcall repaint(void);
 
    virtual void __fastcall Execute(void);
};
//---------------------------------------------------------------------------
class Tmain_form : public TForm
{
__published:    // IDE-managed Components
        void __fastcall FormCloseQuery(TObject *Sender, bool &CanClose);
        void __fastcall FormResize(TObject *Sender);
private:    // User declarations
public:     // User declarations
        __fastcall Tmain_form(TComponent* Owner);
 
        void __fastcall WMPaint(TWMPaint& Message);
        void __fastcall WMEraseBkgnd(TWMEraseBkgnd& Message);
 
        BEGIN_MESSAGE_MAP
            VCL_MESSAGE_HANDLER(WM_PAINT, TWMPaint, WMPaint)
            VCL_MESSAGE_HANDLER(WM_ERASEBKGND, TWMEraseBkgnd, WMEraseBkgnd)
        END_MESSAGE_MAP(TForm)
 
        HANDLE h_a;
        HANDLE h_b;
 
        int buffer_w, buffer_h;
 
        char *form_bmp_bits;
        HBITMAP form_bmp_h;
 
        TCanvas *mem_c;
 
        repaint_thread_t *repaint_thread;
 
        void create_frame_buffer(void);
        void destroy_frame_buffer(void);
 
        void draw_text(TCanvas *c, int w, int h);
};
//---------------------------------------------------------------------------
extern PACKAGE Tmain_form *main_form;
//---------------------------------------------------------------------------
#endif

//---------------------------------------------------------------------------
 
#include <vcl.h>
#pragma hdrstop
 
#include "main_form_unit.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
Tmain_form *main_form;
//---------------------------------------------------------------------------
#include "ffmpeg_test.h"
//---------------------------------------------------------------------------
class mt_obj
{
public:
    mt_obj(void) {InitializeCriticalSection(&cs);}
    virtual ~mt_obj(void) {DeleteCriticalSection(&cs);}
 
    void lock(void) {EnterCriticalSection(&cs);}
    void unlock(void) {LeaveCriticalSection(&cs);}
 
private:
    CRITICAL_SECTION cs;
 
private:
    mt_obj(const mt_obj &) {}
    const mt_obj &operator =(const mt_obj &) {}
};
 
static mt_obj cs;
//---------------------------------------------------------------------------
repaint_thread_t::repaint_thread_t(bool CreateSuspended, Tmain_form *form): TThread(CreateSuspended), form(form) {}
 
void __fastcall repaint_thread_t::repaint(void)
{
    form->Repaint();
}
 
void __fastcall repaint_thread_t::Execute(void)
{
    while (!Terminated)
    {
        WaitForSingleObject(form->h_a, 250);
        Synchronize(repaint);
        WaitForSingleObject(form->h_b, 250);
    }
}
//---------------------------------------------------------------------------
void cb_fn(void)
{
    cs.lock();
    ffmpeg_test_get_bmp(main_form->form_bmp_bits, main_form->buffer_w, main_form->buffer_h);
    cs.unlock();
 
    ResetEvent(main_form->h_b);
    SetEvent(main_form->h_a);
    ResetEvent(main_form->h_a);
    SetEvent(main_form->h_b);
}
//---------------------------------------------------------------------------
void Tmain_form::create_frame_buffer(void)
{
    buffer_w = ClientWidth;
    buffer_h = ClientHeight;
 
    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 Tmain_form::destroy_frame_buffer(void)
{
    DeleteObject(form_bmp_h);
}
//---------------------------------------------------------------------------
__fastcall Tmain_form::Tmain_form(TComponent* Owner)
        : TForm(Owner)
{
    ClientWidth = 400;
    ClientHeight = 300;
 
    h_a = CreateEvent(0, FALSE, FALSE, 0);
    h_b = CreateEvent(0, FALSE, FALSE, 0);
 
    DoubleBuffered = true;
 
    mem_c = new TCanvas;
 
    create_frame_buffer();
 
    repaint_thread = new repaint_thread_t(false, this);
 
    ffmpeg_test_start("rtsp://admin:12345@192.168.1.2/h264/ch1/sub/av_stream", cb_fn);
}
//---------------------------------------------------------------------------
void Tmain_form::draw_text(TCanvas *c, int w, int h)
{
    AnsiString s = "...HELLO WORLD...";
 
    c->Brush->Style = bsClear;
    c->Font->Color = clWhite;
    c->Font->Size = 24;
    c->Font->Style = TFontStyles()<< fsBold;
    c->TextOutA(w / 2 - c->TextWidth(s) / 2, h / 2 - c->TextHeight(s) / 2, s);
}
//---------------------------------------------------------------------------
void __fastcall Tmain_form::WMPaint(TWMPaint& Message)
{
    if (form_bmp_h)
    {
        PAINTSTRUCT ps;
        HDC paint_hdc = BeginPaint(Handle, &ps);
 
        HDC hdc_1 = CreateCompatibleDC(paint_hdc);
        HDC hdc_2 = CreateCompatibleDC(paint_hdc);
        mem_c->Handle = hdc_1;
 
        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);
 
        // ...do something with hdc_1...
        draw_text(mem_c, buffer_w, buffer_h);
 
        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(Handle, &ps);
    }
}
//---------------------------------------------------------------------------
void __fastcall Tmain_form::WMEraseBkgnd(TWMEraseBkgnd& Message)
{
    Message.Result = 1;
}
//---------------------------------------------------------------------------
void __fastcall Tmain_form::FormCloseQuery(TObject *Sender, bool &CanClose)
{
    CloseHandle(h_a);
    CloseHandle(h_b);
 
    ffmpeg_test_stop();
 
    delete repaint_thread;
 
    destroy_frame_buffer();
}
//---------------------------------------------------------------------------
void __fastcall Tmain_form::FormResize(TObject *Sender)
{
    cs.lock();
    destroy_frame_buffer();
    create_frame_buffer();
    cs.unlock();
}
//---------------------------------------------------------------------------

#pragma once
 
//------------------------------------------------------------------------------
//ffmpeg_test 1.0
//------------------------------------------------------------------------------
#ifndef ffmpeg_test_h
#define ffmpeg_test_h
//------------------------------------------------------------------------------
#include <windows.h>
#include <windowsx.h>
#include <fstream>
#include <string>
#include<iostream>
#include <conio.h>
#include <stdio.h>
#include <vector>
using namespace std;
//------------------------------------------------------------------------------
#ifdef EXPORT
#define DECL_SPEC __declspec(dllexport) __stdcall
#else
#define DECL_SPEC __declspec(dllimport) __stdcall
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
    //------------------------------------------------------------------------------
    void DECL_SPEC ffmpeg_test_start(char *src, void(*cb_fn)(void));
    void DECL_SPEC ffmpeg_test_stop(void);
    int DECL_SPEC ffmpeg_test_get_bmp(void *bmp_bits, int w, int h); //32 bit
                                                                     //------------------------------------------------------------------------------
#ifdef __cplusplus
} //extern "C"
#endif
 
#undef EXPORT
  //------------------------------------------------------------------------------
#endif //ffmpeg_test_h
#define ID_FIRSTCHILD   100
#define ID_SECONDCHILD  101
#define ID_THIRDCHILD   102
BOOL CALLBACK EnumChildProc(HWND hwndChild, LPARAM lParam);
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK ChildProc(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK PictViewWndProc(HWND, UINT, UINT, LONG);
void init(void);
void paint(void);
void uninit(void);

#include "ffmpeg_test.h"
 
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
HWND hWnd;
 
int buffer_w, buffer_h;
 
char *form_bmp_bits;
HBITMAP form_bmp_h;
 
void create_frame_buffer(void);
void destroy_frame_buffer(void);
//char readFile(char *fName, int arg);
//char readFile2(char *fName, int arg);
//wstring s2ws(const string& str);
 
HINSTANCE hinst;
//---------------------------------------------------------------------------
int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    HWND hwnd;
    MSG msg;
    WNDCLASS w;
    hinst = hInstance;
    memset(&w, 0, sizeof(WNDCLASS));
    w.style = CS_HREDRAW | CS_VREDRAW;
    w.lpfnWndProc = PictViewWndProc;
    w.hInstance = hInstance;
    w.hbrBackground = GetStockBrush(WHITE_BRUSH);
    w.lpszClassName = TEXT("C Windows");
    w.hCursor = LoadCursor(NULL, IDC_ARROW);
    RegisterClass(&w);
    hwnd = CreateWindow(TEXT("C Windows"), TEXT("C Windows"), WS_OVERLAPPEDWINDOW,
        10, 10, 600, 480, NULL, NULL, hInstance, NULL);
    ShowWindow(hwnd, nCmdShow);
    UpdateWindow(hwnd);
    while (GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    return msg.wParam;
}
//---------------------------------------------------------------------------
LRESULT CALLBACK PictViewWndProc(HWND hwnd, UINT Message, WPARAM wparam, LPARAM lparam)
{
    RECT rcClient;
    int i;
    switch (Message)
    {
    case WM_CREATE: // создание основного окна
        for (int i = 0; i < 3; i++) // Создание трех  дочерних окна
        {
            WNDCLASS w;
            memset(&w, 0, sizeof(WNDCLASS));
            w.lpfnWndProc = ChildProc;
            w.hInstance = hinst;
            w.hbrBackground = GetStockBrush(WHITE_BRUSH);
            w.lpszClassName = TEXT("ChildWClass");
            w.hCursor = LoadCursor(NULL, IDC_CROSS);
            RegisterClass(&w);
            HWND child;
            child = CreateWindowEx(0, TEXT("ChildWClass"), (LPCTSTR)NULL,
                WS_CHILD | WS_BORDER | WS_VISIBLE, i * 50, i * 50,
                50, 50, hwnd, (HMENU)(int)(ID_FIRSTCHILD + i), hinst, NULL);
            ShowWindow(child, SW_NORMAL);
            UpdateWindow(child);
            RECT rect;
            GetWindowRect(hWnd, &rect);
            buffer_w = rect.right - rect.left;
            buffer_h = rect.bottom - rect.top;
 
            init();
        }
        return 0;
    case WM_SIZE:   // изменение размеров основного окна
                    // Получает габариты рабочей области главного окна и перечисляет дочерние окна.
                    // Передает габариты в дочерние окна в ходе перечисления.
        GetClientRect(hwnd, &rcClient);
        EnumChildWindows(hwnd, EnumChildProc, (LPARAM)&rcClient);
        return 0;
    }
    if (Message == WM_DESTROY)
    {
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc(hwnd, Message, wparam, lparam);
}
//---------------------------------------------------------------------------
LRESULT CALLBACK ChildProc(HWND hwnd, UINT Message, WPARAM wparam, LPARAM lparam)
{
    switch (Message) {
    case WM_PAINT:
        paint();
        return 0;
    case WM_DESTROY:
        uninit();
        PostQuitMessage(0);
        return 0;
    }
    /*if (Message == WM_DESTROY)
    {
        return 0;
    }*/
    return DefWindowProc(hwnd, Message, wparam, lparam);
}
//---------------------------------------------------------------------------
BOOL CALLBACK EnumChildProc(HWND hwndChild, LPARAM lParam)
{
    LPRECT rcParent;
    int i, idChild;
    // Восстановление идентификатора дочернего окна.
    // Использовать его для установки дочернего окна.
    idChild = GetWindowLong(hwndChild, GWL_ID);
    if (idChild == ID_FIRSTCHILD)
        i = 0;
    else if (idChild == ID_SECONDCHILD)
        i = 1;
    else
        i = 2;
    // Размер и позиция дочернего окна.
    rcParent = (LPRECT)lParam;
    MoveWindow(hwndChild, (rcParent->right / 3) * i, 0, rcParent->right / 3, rcParent->bottom, TRUE);
    // Удостоверитесь, что дочернее окно видимо
    ShowWindow(hwndChild, SW_SHOW);
    return TRUE;
}
//---------------------------------------------------------------------------
void cb_fn(void)
{
    ffmpeg_test_get_bmp(form_bmp_bits, buffer_w, buffer_h);
    InvalidateRect(hWnd, NULL, FALSE);
}
//---------------------------------------------------------------------------
void 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 destroy_frame_buffer(void)
{
    DeleteObject(form_bmp_h);
}
//---------------------------------------------------------------------------
void init(void)
{
    create_frame_buffer();
    ffmpeg_test_start("rtsp://admin:admin@192.168.1.108:554/cam/realmonitor?channel=1&subtype=0", cb_fn);
}
//---------------------------------------------------------------------------
void 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 uninit(void)
{
    ffmpeg_test_stop();
 
    destroy_frame_buffer();
}