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

class TfrmCamera_1;
class repaint_thread_t : public TThread
{
public:
    TfrmCamera_1 *form;
 
    repaint_thread_t(bool CreateSuspended, TfrmCamera_1 *form);
 
    void __fastcall repaint(void);
 
    virtual void __fastcall Execute(void);
};
 
class TfrmCamera_1 : public TForm
{
__published:    
 
.....
 
   void __fastcall FormCloseQuery(TObject *Sender, bool &CanClose);
   void __fastcall FormResize(TObject *Sender);
 
private:    // User declarations
public:     // User declarations
   __fastcall TfrmCamera_1(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);
 
};

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, TfrmCamera_1 *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(frmCamera_1->form_bmp_bits, frmCamera_1->buffer_w, frmCamera_1->buffer_h);
    cs.unlock();
 
    ResetEvent(frmCamera_1->h_b);
    SetEvent(frmCamera_1->h_a);
    ResetEvent(frmCamera_1->h_a);
    SetEvent(frmCamera_1->h_b);
}
//---------------------------------------------------------------------------
__fastcall TfrmCamera_1::TfrmCamera_1(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:Gavrilovo1595159@192.168.0.151/mjpeg/ch1/sub/av_stream", cb_fn);
 
}
 
//---------------------------------------------------------------------------
void __fastcall TfrmCamera_1::FormCloseQuery(TObject *Sender,
      bool &CanClose)
{
    CloseHandle(h_a);
    CloseHandle(h_b);
 
    if(frmMain->ffmpeg_test_stoped ==0)
      ffmpeg_test_stop();
 
    delete repaint_thread;
 
    destroy_frame_buffer();
    frmMain->ffmpeg_test_stoped = 1;
 
}
//---------------------------------------------------------------------------
void __fastcall TfrmCamera_1::FormResize(TObject *Sender)
{
    cs.lock();
    destroy_frame_buffer();
    create_frame_buffer();
    cs.unlock();
}
//---------------------------------------------------------------------------
void __fastcall TfrmCamera_1::WMEraseBkgnd(TWMEraseBkgnd& Message)
{
    Message.Result = 1;
}
//---------------------------------------------------------------------------
 
void __fastcall TfrmCamera_1::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 TfrmCamera_1::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 TfrmCamera_1::destroy_frame_buffer(void)
{
    DeleteObject(form_bmp_h);
}
//---------------------------------------------------------------------------
void TfrmCamera_1::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);
}

#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 AVFormatContext *format_ctx2;
 
static int stream;
static int stream2;
 
static AVCodecContext *codec_ctx;
static AVCodecContext *codec_ctx2;
 
static AVFrame *frame;
static AVFrame *frame2;
 
static AVFrame *x_bgr_frame;
static AVFrame *x_bgr_frame2;
 
static SwsContext *x_bgr_ctx;
static SwsContext *x_bgr_ctx2;
 
static HANDLE thread_h;
static HANDLE thread_h2;
static int terminated;
static int terminated2;
 
void (*cb_fn)(void);
void (*cb_fn2)(void);
 
static DWORD WINAPI proc(LPVOID arg)
{
    AVPacket packet;
    AVPacket packet2;    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);
}
///////////////////////////////////////////
 
static DWORD WINAPI proc2(LPVOID arg)
{
    AVPacket packet;
    int finished;
    while (!terminated2)
    {
        if (av_read_frame(format_ctx2, &packet) != 0)
        {
            ExitThread(0);
        }
        else if (packet.stream_index == stream2)
        {
            if (avcodec_decode_video2(codec_ctx2, frame2, &finished, &packet) > 0)
            {
                if (finished)
                {
                    cb_fn2();
                }
            }
        }
 
 
 
        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_start2(char *src, void (*cb_fn2)(void))
{
    ::cb_fn2 = cb_fn2;
 
    av_register_all();
 
    format_ctx2 = avformat_alloc_context();
    if (!format_ctx2)
    {
        return;
    }
 
    AVDictionary *opts = 0;
    av_dict_set(&opts, "rtsp_transport", "tcp", 0);
 
    if (avformat_open_input(&format_ctx2, src, 0, &opts) != 0)
    {
        return;
    }
 
    if (avformat_find_stream_info(format_ctx2, 0) < 0)
    {
        return;
    }
 // 
    stream2 = -1;
    for (int i = 0; i < format_ctx2->nb_streams; i++)
        if (format_ctx2->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO)
        {
            stream2 = i;
            break;
        }
    if (stream2 == -1)
    {
        return;
    }
  
    codec_ctx2 = format_ctx2->streams[stream2]->codec;
  
    AVCodec *codec = avcodec_find_decoder(codec_ctx2->codec_id);
    if (!codec)
    {
        return;
    }
 
    if (avcodec_open2(codec_ctx2, codec, 0) != 0)
    {
        return;
    }
 
    frame2 = av_frame_alloc();
    if (!frame2)
    {
        return;
    }
 
    x_bgr_frame2 = 0;
 
    terminated2 = 0;
    DWORD thread_id;
    thread_h2 = CreateThread
    (
        0,
        0,
        proc2,
        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);
}
///////////////////////////////////
void DECL_SPEC ffmpeg_test_stop2(void)
{
    terminated2 = 1;
 
    WaitForSingleObject(thread_h2, INFINITE);
    CloseHandle(thread_h2);
 
    sws_freeContext(x_bgr_ctx2);
 
    av_free(x_bgr_frame2);
    av_free(frame2);
  
    avcodec_close(codec_ctx2);
  
    avformat_close_input(&format_ctx2);
 
    avformat_free_context(format_ctx2);
}
 
 
///////////////////////////////////
 
 
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;
}
/////////////////////////////////////
int DECL_SPEC ffmpeg_test_get_bmp2(void *bmp_bits, int w, int h)
{
    if (!x_bgr_frame2 || x_bgr_frame2->width != w || x_bgr_frame2->height != h)
    {
        x_bgr_frame2 = av_frame_alloc();
        if (!x_bgr_frame2)
        {
            return 0;
        }
 
        x_bgr_frame2->width = w;
        x_bgr_frame2->height = h;
 
        if 
        (
            avpicture_fill((AVPicture *)x_bgr_frame2, 0, PIX_FMT_RGB32, w, h) < 0
        )
        {
            return 0;
        }
 
        x_bgr_ctx2 = sws_getContext(codec_ctx2->width, codec_ctx2->height, codec_ctx2->pix_fmt, w, h, PIX_FMT_RGB32, SWS_BICUBIC, 0, 0, 0);
        if (!x_bgr_ctx2)
        {
            return 0;
        }
    }
 
    x_bgr_frame2->data[0] = (uint8_t *)bmp_bits;
    x_bgr_frame2->data[0] += x_bgr_frame2->linesize[0] * (h - 1);
    x_bgr_frame2->linesize[0] = -x_bgr_frame2->linesize[0];   
    sws_scale(x_bgr_ctx2, frame2->data, frame2->linesize, 0, codec_ctx2->height, x_bgr_frame2->data, x_bgr_frame2->linesize);
    x_bgr_frame2->linesize[0] = -x_bgr_frame2->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;
}

void DECL_SPEC ffmpeg_test_start(char *src, void (*cb_fn)(void));
void DECL_SPEC ffmpeg_test_stop(void);
void DECL_SPEC ffmpeg_test_start2(char *src, void (*cb_fn2)(void));
void DECL_SPEC ffmpeg_test_stop2(void);
int DECL_SPEC ffmpeg_test_get_bmp(void *bmp_bits, int w, int h); //32 bit
int DECL_SPEC ffmpeg_test_get_bmp2(void *bmp_bits, int w, int h); //32 bit
 
//------------------------------------------------------------------------------