Воспроизведение видео с 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;
}

//h-файл
 
        BEGIN_MESSAGE_MAP
            VCL_MESSAGE_HANDLER(WM_HOTKEY, TMessage, hot_key_message)
        END_MESSAGE_MAP(TForm)
 
        void __fastcall hot_key_message(TMessage &Message);
 
//в конструкторе
 
    RegisterHotKey(Handle, 0, 0, VK_F11);
 
//в FormCloseQuery
 
    UnregisterHotKey(Handle, 0);
 
//обработчик
 
void __fastcall Tstart_form::hot_key_message(TMessage &Message)
{
    if ((UINT)LOWORD(Message.LParam) == 0)
    {
        if ((UINT)HIWORD(Message.LParam) == VK_F11)
        {
            //делаем что-то
        }
    }
 
    TForm::Dispatch(&Message);
}

if(i_can_video_start<50)
    {
      i_can_video_start++;
    s = "Запись видео";
    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);
    }

int i_zap=0;
void __fastcall Tmain_form::FormKeyPress(TObject *Sender, char &Key)
{
     switch ( Key ) {
       case 'q':
       case 'Q':
       case 'é':
       case 'É': {
 
       if (i_zap<1)
                  {
       i_zap=1;
       i_can_video_start=0;
       ShellExecute(Handle, "open", "ffmpeg.exe", "-y -i rtsp://192.168.0.199:554/user=admin_password=tlJwpbo6_channel=1_stream=0.sdp?real_stream -c copy ./video/video_555.h264", NULL, SW_HIDE);
                   }
       else
            {
       i_can_video_end=0;
       AnsiString command =  AnsiString("taskkill.exe /f /im ffmpeg.exe");
       WinExec(command.c_str(),SW_HIDE);
            }
                          }break;
}