avi_mapDecode.cpp

Go to the documentation of this file.

// File avi_mapDecode.cpp


// This form of decoding might be useful for formats that cant be decoded by VFW
// but it hasn't been tested or finised yet. At the moment all it might do is
// write bitmaps from the data stream. 
// Might be abue to get frames by using the media position interface.

#pragma warning( disable : 4311 4312 4133)

#define _WIN32_DCOM 

#include <windows.h>
#include <atlbase.h>
#include <stdio.h>
#include <dshow.h>
#include "streams.h"   // for CMedia
#include "qedit.h"     // for ISample

struct __declspec(uuid("{1125E600-3F8F-4856-9491-34B1443B0E60}")) CLSID_TransSmpte;

class CTransSmpte : public CTransInPlaceFilter {
public:
    HRESULT Transform(IMediaSample *pSample);
    HRESULT CheckInputType(const CMediaType *mtIn);
    HRESULT SetMediaType( PIN_DIRECTION pindir, const CMediaType *pMediaType);
    // Constructor
    CTransSmpte( LPUNKNOWN punk, HRESULT *phr );
    ~CTransSmpte( );
private:
    int         m_nWidth;
    int         m_nHeight;
    HBITMAP     m_DibSection;
    HDC         m_DC;
    void *      m_pDibBits;
    HGDIOBJ     m_OldObject;
    double      m_dFPS;
};

HRESULT GetInterfaces(void);
HRESULT CaptureVideo();
HRESULT SetupVideoWindow(void);
HRESULT HandleGraphEvent(void);

void Msg(TCHAR *szFormat, ...);
void CloseInterfaces(void);
void ResizeVideoWindow(void);

#define SAFE_RELEASE(x) { if (x) x->Release(); x = NULL; }

#define JIF(x) if (FAILED(hr=(x))) \
    {Msg(TEXT("FAILED(hr=0x%x) in ") TEXT(#x) TEXT("\n\0"), hr); return hr;}

#define DEFAULT_VIDEO_WIDTH     320
#define DEFAULT_VIDEO_HEIGHT    240

#define APPLICATIONNAME TEXT("AVI GET FRAME \0")
#define CLASSNAME       TEXT("OFX:AVI_READER\0")

// Application-defined message to notify app of filtergraph events
#define WM_GRAPHNOTIFY  WM_APP+1

char bmproot[255]="c:\\rsfz";
HWND ghApp=0;
BOOL bDir=TRUE;
long framecount=0;
BOOL b32=FALSE;
char MediaFile[255];

IVideoWindow  * g_pVW = NULL;
IMediaControl * g_pMC = NULL;
IMediaEventEx * g_pME = NULL;
IMediaFilter  * g_pMF = NULL;
IGraphBuilder * g_pGraph = NULL;
ICaptureGraphBuilder2 * g_pCapture = NULL;
IBaseFilter * g_pMux=NULL;
IBaseFilter * g_pTee=NULL;
IBaseFilter * pSmpte=NULL;

HRESULT CaptureVideo(){
    HRESULT hr;
    IBaseFilter *pSrcFilter=NULL;
    hr = GetInterfaces();
    if (FAILED(hr))    {
        Msg(TEXT("Failed to get video interfaces!  hr=0x%x"), hr);
        return hr;
    }
    hr = g_pCapture->SetFiltergraph(g_pGraph);
    if (FAILED(hr)){
        Msg(TEXT("Failed to set capture filter graph!  hr=0x%x"), hr);
        return hr;
    }
    CA2W pszWW( MediaFile );
    hr=g_pGraph->AddSourceFilter(pszWW,L"Source File",&pSrcFilter);
    if (FAILED(hr))    {
        Msg(TEXT("Failed to set Input Filename!%s,  hr=0x%x"), MediaFile,hr);
        return hr;
    }
    hr=g_pGraph->AddFilter(g_pTee,L"Inf TEE");
    if (FAILED(hr))    {
        Msg(TEXT("Failed to add the InfTEE filter: hr=0x%x"), hr);
        return hr;
    }
    pSmpte = new CTransSmpte(NULL, &hr);
    hr=g_pGraph->AddFilter(pSmpte,L"TransSmpte");
    if (FAILED(hr))    {
        Msg(TEXT("Failed to add the smpte filter: hr=0x%x"), hr);
        return hr;
    }
    CComPtr< IBaseFilter > pVideoFilter;  // insert instance of Grabber filer
    if(!b32){
    pVideoFilter.CoCreateInstance(CLSID_SampleGrabber);
    if(!pVideoFilter)    {
        Msg(TEXT("Could not create SampleGrabber from Qedit.dll"));
        return hr;
    }
    CComQIPtr< ISampleGrabber, &IID_ISampleGrabber > pVideoGrab(pVideoFilter);
    CMediaType VideoType;
    VideoType.SetType(&MEDIATYPE_Video);
    VideoType.SetSubtype(&MEDIASUBTYPE_RGB24);
    hr = pVideoGrab->SetMediaType(&VideoType);
    if(FAILED(hr))    {
        Msg(TEXT("Could not set sample grabber's media type"));
        return hr;
    }
    hr = g_pGraph->AddFilter(pVideoFilter, L"VideoGrabber");
    if(FAILED(hr))    {
        Msg(TEXT("Could not add VideoGrabber to the graph"));
        return hr; 
    }
    CComPtr<IPin> pSourcePin;//     = GetOutPin(pSrcFilter,   0);
    hr = g_pCapture->FindPin(pSrcFilter,PINDIR_OUTPUT,0,0,TRUE,0,&pSourcePin); 
    if (FAILED(hr)){Msg("Fail find pin Source"); return hr;}
    CComPtr<IPin> pVideoIn;//       = GetInPin (pVideoFilter,  0);
    hr = g_pCapture->FindPin(pVideoFilter,PINDIR_INPUT,0,0,TRUE,0,&pVideoIn); 
    if (FAILED(hr)){Msg("Fail find pin GrabIn"); return hr;}
    hr=g_pGraph->Connect( pSourcePin, pVideoIn );
    if(FAILED(hr))    {
        Msg(TEXT("Bad Connect Vout-> Grab IN : hr=0x%x"), hr);
        return hr;
    }
    }  // b32
    hr = g_pCapture->RenderStream(
                      NULL, // Pin category.
                      NULL,      // Media type.
                      (b32 ? pSrcFilter:pVideoFilter),                  // Capture filter.
                      pSmpte,                  // Intermediate filter (optional).
                      NULL);                 // Mux or file sink filter.
    if (FAILED(hr))    {
        Msg(TEXT("Couldn't render the video file capture stream.  hr=0x%x\r\n"), hr);
    }
    SetupVideoWindow();  // only needed if not rendering to Mux
    pSrcFilter->Release();
    // Disable the reference clock so that ALL frames are converted
    hr = g_pMF->SetSyncSource(NULL);
    if (FAILED(hr)){
        Msg(TEXT("Couldn't set the reference clock:  hr=0x%x"), hr);
        return hr;
    }
    hr = g_pMC->Run();
    if (FAILED(hr)){
        Msg(TEXT("Couldn't run the graph!  hr=0x%x"), hr);
        return hr;
    }
    return S_OK;
}

HRESULT GetInterfaces(void){
    HRESULT hr;
    hr = CoCreateInstance (CLSID_FilterGraph, NULL, CLSCTX_INPROC,
                           IID_IGraphBuilder, (void **) &g_pGraph);
    if (FAILED(hr))        return hr;
    hr = CoCreateInstance (CLSID_CaptureGraphBuilder2 , NULL, CLSCTX_INPROC,
                           IID_ICaptureGraphBuilder2, (void **) &g_pCapture);
    if (FAILED(hr))return hr;
    hr = CoCreateInstance (CLSID_InfTee, NULL, CLSCTX_INPROC,
                           IID_IBaseFilter, (void **) &g_pTee);
    if (FAILED(hr))return hr;
    hr = g_pGraph->QueryInterface(IID_IMediaControl,(LPVOID *) &g_pMC);
    if (FAILED(hr))        return hr;
    hr = g_pGraph->QueryInterface(IID_IVideoWindow, (LPVOID *) &g_pVW);
    if (FAILED(hr))return hr;
    hr = g_pGraph->QueryInterface(IID_IMediaFilter, (LPVOID *) &g_pMF);
    if (FAILED(hr))return hr;
    hr = g_pGraph->QueryInterface(IID_IMediaEvent, (LPVOID *) &g_pME);
    if (FAILED(hr))return hr;
    // Set the window handle used to process graph events
    hr = g_pME->SetNotifyWindow((OAHWND)ghApp, WM_GRAPHNOTIFY, 0);
    return hr;
}

void CloseInterfaces(void){
    if (g_pMC)        g_pMC->StopWhenReady();
    if (g_pME)        g_pME->SetNotifyWindow(NULL, WM_GRAPHNOTIFY, 0);
    if(g_pVW)    {
        g_pVW->put_Visible(OAFALSE);
        g_pVW->put_Owner(NULL);
    }
    SAFE_RELEASE(g_pMC);
    SAFE_RELEASE(g_pME);
    SAFE_RELEASE(g_pMF);
    SAFE_RELEASE(g_pVW);
    SAFE_RELEASE(g_pMux);
    SAFE_RELEASE(g_pTee);
    if(pSmpte)delete pSmpte;
    SAFE_RELEASE(g_pGraph);
    SAFE_RELEASE(g_pCapture);
}


HRESULT SetupVideoWindow(void){
    HRESULT hr;
    hr = g_pVW->put_Owner((OAHWND)ghApp);
    if (FAILED(hr))        return hr;
    hr = g_pVW->put_WindowStyle(WS_CHILD | WS_CLIPCHILDREN);
    if (FAILED(hr))        return hr;
    ResizeVideoWindow();
    hr = g_pVW->put_Visible(OATRUE);
    if (FAILED(hr))        return hr;
    return hr;
}

void ResizeVideoWindow(void){
    if (g_pVW){
        RECT rc;
        GetClientRect(ghApp, &rc);
        g_pVW->SetWindowPosition(0, 0, rc.right, rc.bottom);
    }
}

void Msg(TCHAR *szFormat, ...){
    TCHAR szBuffer[1024];  // Large buffer for long filenames or URLs
    const size_t NUMCHARS = sizeof(szBuffer) / sizeof(szBuffer[0]);
    const int LASTCHAR = NUMCHARS - 1;
    va_list pArgs;
    va_start(pArgs, szFormat);
    _vsntprintf(szBuffer, NUMCHARS - 1, szFormat, pArgs);
    va_end(pArgs);
    szBuffer[LASTCHAR] = TEXT('\0');
    MessageBox(NULL, szBuffer, TEXT("PlayCap Message"), MB_OK | MB_ICONERROR);
}

HRESULT HandleGraphEvent(void){
    LONG evCode, evParam1, evParam2;
    HRESULT hr=S_OK;
    if (!g_pME)
        return E_POINTER;
    while(SUCCEEDED(g_pME->GetEvent(&evCode, (LONG_PTR *) &evParam1, 
                   (LONG_PTR *) &evParam2, 0)))    {
        switch (evCode){
          case EC_COMPLETE:
            MessageBox(NULL,"Complete","Output",MB_OK);
            PostMessage(ghApp,WM_CLOSE,0,0); 
            break;
        }
        hr = g_pME->FreeEventParams(evCode, evParam1, evParam2);
    }
    return hr;
}

LRESULT CALLBACK WndMainProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam){
    switch (message){
        case WM_GRAPHNOTIFY:
            HandleGraphEvent();
            break;
        case WM_SIZE:
            ResizeVideoWindow();
            break;
        case WM_CLOSE:            
            ShowWindow(ghApp, SW_HIDE);
            CloseInterfaces();  // Stop capturing and release interfaces
            break;
        case WM_DESTROY:
            PostQuitMessage(0);
            return 0;
    }
    if (g_pVW)
        g_pVW->NotifyOwnerMessage((LONG_PTR) hwnd, message, wParam, lParam);
    return DefWindowProc (hwnd , message, wParam, lParam);
}

extern "C"  int AviDecoderEntry(HINSTANCE hInstance, char *movie_name, long frame){
    MSG msg={0};
    WNDCLASS wc;
    if(FAILED(CoInitializeEx(NULL, COINIT_APARTMENTTHREADED))){
        Msg(TEXT("CoInitialize Failed!\r\n"));   
        return 0;
    } 
    ZeroMemory(&wc, sizeof wc);
    wc.lpfnWndProc   = WndMainProc;
    wc.hInstance     = hInstance;
    wc.lpszClassName = CLASSNAME;
    wc.lpszMenuName  = NULL;
    wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
    wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
    wc.hIcon         = NULL; //LoadIcon(hInstance, MAKEINTRESOURCE(IDI_VIDPREVIEW));
    if(!RegisterClass(&wc)){
        Msg(TEXT("RegisterClass Failed! Error=0x%x\r\n"), GetLastError());
        CoUninitialize();
        return 0;
    }
    strcpy(MediaFile,movie_name);
    // Create the main window.  The WS_CLIPCHILDREN style is required.
    ghApp = CreateWindow(CLASSNAME, APPLICATIONNAME,
                         WS_OVERLAPPEDWINDOW | WS_CAPTION | WS_CLIPCHILDREN,
                         CW_USEDEFAULT, CW_USEDEFAULT,
                         DEFAULT_VIDEO_WIDTH, DEFAULT_VIDEO_HEIGHT,
                         0, 0, hInstance, 0);
    if(ghApp){
        HRESULT hr;
        hr = CaptureVideo();
        if (FAILED (hr)){
            CloseInterfaces();
            DestroyWindow(ghApp);
        }
        else{
            ShowWindow(ghApp,SW_SHOW);
        }       
        while(GetMessage(&msg,NULL,0,0)){
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
    if(UnregisterClass(CLASSNAME,hInstance) == 0){
      MessageBox(NULL,"Unregister Class Failed",NULL,MB_OK);
    }
    CoUninitialize();
    return 1;
}

void WriteBitmap(long nx, long ny, unsigned char *S, long f);

CTransSmpte::CTransSmpte(LPUNKNOWN punk,HRESULT *phr) 
    : CTransInPlaceFilter(TEXT("TransSmpte"), punk, __uuidof(CLSID_TransSmpte), phr)
    , m_nWidth(0)
    , m_nHeight(0)
    , m_pDibBits(NULL)
    , m_DibSection(NULL)
    , m_DC(NULL)
    , m_OldObject(NULL)
    , m_dFPS( 0.0 )
{
}

CTransSmpte::~CTransSmpte( ){
    if( m_OldObject ){
        SelectObject( m_DC, m_OldObject );
        m_OldObject = NULL;
    }
    if( m_DC )    {
        DeleteDC( m_DC );
        m_DC = NULL;
    }
    if( m_DibSection )    {
        DeleteObject( m_DibSection );
        m_DibSection = NULL;
    }
}


HRESULT CTransSmpte::SetMediaType( PIN_DIRECTION pindir, const CMediaType *pMediaType){
    CheckPointer(pMediaType,E_POINTER);
    VIDEOINFO* pVI = (VIDEOINFO*) pMediaType->Format();
    CheckPointer(pVI,E_UNEXPECTED);

    m_nWidth  = pVI->bmiHeader.biWidth;
    m_nHeight = pVI->bmiHeader.biHeight;
    double tpf = double(pVI->AvgTimePerFrame) / UNITS;
    m_dFPS = tpf;
    return CTransInPlaceFilter::SetMediaType( pindir, pMediaType );
}


HRESULT CTransSmpte::CheckInputType(const CMediaType *mtIn){
    CheckPointer(mtIn,E_POINTER);
    if (*mtIn->FormatType() != FORMAT_VideoInfo) {
        return E_INVALIDARG;
    }
    if( *mtIn->Type( ) != MEDIATYPE_Video ){
        return E_INVALIDARG;
    }
    if( *mtIn->Subtype( ) == MEDIASUBTYPE_RGB24 )b32=FALSE;
    if(( *mtIn->Subtype( ) != MEDIASUBTYPE_RGB32 ) &&
    ( *mtIn->Subtype( ) != MEDIASUBTYPE_RGB24 ))  {
        return E_INVALIDARG;
    }
    VIDEOINFO *pVI = (VIDEOINFO *) mtIn->Format();
    CheckPointer(pVI,E_UNEXPECTED);
    if( pVI->bmiHeader.biBitCount == 24 )b32=FALSE;
    if(( pVI->bmiHeader.biBitCount != 32 ) &&
    ( pVI->bmiHeader.biBitCount != 24 ))    {
        return E_INVALIDARG;
    }
    if( pVI->bmiHeader.biHeight < 0 )    {
        return E_INVALIDARG;
    }
    return NOERROR;
}

HRESULT CTransSmpte::Transform(IMediaSample *pSample){
    CheckPointer(pSample,E_POINTER);
    if(bDir)framecount++; else framecount--;
    char *pBuffer = 0;
    pSample->GetPointer( (LPBYTE*) &pBuffer );
    WriteBitmap(m_nWidth, m_nHeight, (unsigned char*)pBuffer,framecount);
    return NOERROR;
}

static  char szOutFileName[255];

#define BFT_BITMAP 0x4d42

void WriteBitmap(long nx, long ny, unsigned char *S, long f){
 HANDLE hfbm;
 DWORD dwRead;
 BITMAPFILEHEADER hdr,*lphdr;
 BITMAPINFOHEADER bfi,*lpbi;
 long imagesize,mx;
 if(b32) mx=((nx*32+31)/32) * 4;
 else    mx=((nx*24+31)/32) * 4;
 sprintf(szOutFileName,"%s%0.4ld.bmp",bmproot,f);
//MessageBox(NULL,szOutFileName,bmproot,MB_OK);
 if((hfbm=CreateFile(szOutFileName,GENERIC_WRITE,FILE_SHARE_WRITE,
   NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,
   (HANDLE)NULL)) == INVALID_HANDLE_VALUE){
   MessageBox(NULL,szOutFileName,"File Open Fail",MB_OK);
   MessageBeep(MB_OK);
   return;
 }
 lpbi=&bfi;
 lpbi->biSize=sizeof(BITMAPINFOHEADER);
 lpbi->biWidth=(DWORD)nx;
 lpbi->biHeight=(DWORD)ny;
 lpbi->biPlanes=1;
 if(b32)lpbi->biBitCount=32;
 else   lpbi->biBitCount=24;
 lpbi->biCompression=BI_RGB;
 lpbi->biSizeImage = imagesize = (DWORD)(mx*ny);
 lpbi->biXPelsPerMeter=0;
 lpbi->biYPelsPerMeter=0;
 lpbi->biClrUsed=0;
 lpbi->biClrImportant=0;
 lphdr=&hdr;
//{char ttt[256]; sprintf(ttt,"imagesize=%ld BitCcunt=%ld -  mx %ld ny %ld", imagesize,lpbi->biBitCount,mx,ny);
//MessageBox(NULL,ttt,"Test",MB_OK); }
 hdr.bfType          = BFT_BITMAP;
 hdr.bfSize          = (sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)
                        + imagesize);
 hdr.bfReserved1     = 0;
 hdr.bfReserved2     = 0;
 hdr.bfOffBits       = (DWORD)sizeof(BITMAPFILEHEADER) + lpbi->biSize;
 WriteFile(hfbm,lphdr,sizeof(BITMAPFILEHEADER),&dwRead,(LPOVERLAPPED)NULL);
 WriteFile(hfbm,lpbi,sizeof(BITMAPINFOHEADER),&dwRead,(LPOVERLAPPED)NULL);
 WriteFile(hfbm,S,imagesize,&dwRead,(LPOVERLAPPED)NULL);
 if(dwRead != imagesize){
   MessageBeep(MB_OK);
   MessageBox(NULL,"Bad write",NULL,MB_OK);
 }
 if(!CloseHandle(hfbm)){
   MessageBeep(MB_OK);
   MessageBox(NULL,"Bad close",NULL,MB_OK);
 }
 return;
}