avi_write.cpp

Go to the documentation of this file.

#pragma warning( disable : 4311 4312 4133)


#define _WIN32_DCOM 

#include <atlbase.h>
#include <windows.h>
#include <dshow.h>
#include <stdio.h>
#include <streams.h>

#include "avi_write.h"
#include "avi_PushSource.h"

extern BOOL DoDialog(HINSTANCE hInstance, HWND hWnd);
extern void CentreDialogOnScreen(HWND);

HWND ghApp=0;
DWORD g_dwGraphRegister=0;

int gFirstF;
int gLastF;
int gCurrentF;  

BOOL bCompressed=TRUE;

HRESULT BuildFilterGraph(HINSTANCE hInstance, char *ffn);

IVideoWindow  * g_pVW = NULL;
IMediaControl * g_pMC = NULL;
IMediaEventEx * g_pME = NULL;
IGraphBuilder * g_pGraph = NULL;
IBaseFilter   * g_pMux=NULL;
IBaseFilter   * g_pVComp=NULL;
ICaptureGraphBuilder2 * g_pCapture = NULL;
PLAYSTATE g_psCurrent = Stopped;


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 = 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_IMediaEvent, (LPVOID *) &g_pME);
    if (FAILED(hr))        return hr;
    hr = g_pME->SetNotifyWindow((OAHWND)ghApp, WM_GRAPHNOTIFY, 0);
    return hr;
}

void CloseInterfaces(void){
    // Stop previewing data
    if (g_pMC)        g_pMC->StopWhenReady();
    g_psCurrent = Stopped;
    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_pVW);
    SAFE_RELEASE(g_pMux);
    SAFE_RELEASE(g_pVComp);
    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);
    }
}

HRESULT ChangePreviewState(int nShow){
    HRESULT hr=S_OK;
    // If the media control interface isn't ready, don't call it
    if (!g_pMC)        return S_OK;
    if (nShow)    {
        if (g_psCurrent != Running){
            // Start previewing video data
            hr = g_pMC->Run();
            g_psCurrent = Running;
        }
    }
    else    {
        // Stop previewing video data
        hr = g_pMC->StopWhenReady();
        g_psCurrent = Stopped;
    }
    return hr;
}

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;
          case EC_ERRORABORT:
            //MessageBox(NULL,"Error","Output",MB_OK);
            break;

        }
        //
        // Free event parameters to prevent memory leaks associated with
        // event parameter data.  While this application is not interested
        // in the received events, applications should always process them.
        //
        hr = g_pME->FreeEventParams(evCode, evParam1, evParam2);
        // Insert event processing code here, if desired
    }
    return hr;
}


LRESULT CALLBACK WndMainProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam){
    switch (message){
        case WM_CREATE:
            CentreDialogOnScreen(hwnd);
            break;
        case WM_GRAPHNOTIFY:
            HandleGraphEvent();
            break;
        case WM_SIZE:
            ResizeVideoWindow();
            break;
        case WM_PAINT:{
              HDC hDC;
              PAINTSTRUCT  ps;
              hDC = BeginPaint(hwnd, &ps); // Gcurrent Frame
              char strx[100]; 
              sprintf(strx,"Building Movie");
              TextOut(hDC,5,4,strx,(int)strlen(strx));
              sprintf(strx,"Please Wait ..");
              TextOut(hDC,5,20,strx,(int)strlen(strx));
              EndPaint(hwnd, &ps);
            }
            break;
        case WM_WINDOWPOSCHANGED:
            ChangePreviewState(! (IsIconic(hwnd)));
            break;
        case WM_CLOSE:            
            // Hide the main window while the graph is destroyed
            ShowWindow(ghApp, SW_HIDE);
            CloseInterfaces();  // Stop capturing and release interfaces
            break;
        case WM_DESTROY:
            //MessageBox(NULL,"Window Destroyed",NULL,MB_OK);
            PostQuitMessage(0);
            return 0;
    }
    // Pass this message to the video window for notification of system changes
    if (g_pVW)
        g_pVW->NotifyOwnerMessage((LONG_PTR) hwnd, message, wParam, lParam);
    return DefWindowProc (hwnd , message, wParam, lParam);
}

void  CreateCompressionFilter(IMoniker *pMoniker, BOOL dvPal){
  HRESULT hr;
  hr = pMoniker->BindToObject(NULL, NULL, IID_IBaseFilter, 
                                       (void**)&g_pVComp);
  if (FAILED(hr)){MessageBox(NULL,"Failed to create compression Filter",NULL,MB_OK); return;}
  if(!dvPal)return;
  IDVEnc * pDVEnc=NULL;
  hr = g_pVComp->QueryInterface(IID_IDVEnc, (LPVOID *) &pDVEnc);
  if (FAILED(hr)){
    MessageBox(NULL,"Failed to Get IDVENC interface",NULL,MB_OK);
    return;
  }
  hr =  pDVEnc->put_IFormatResolution(DVENCODERVIDEOFORMAT_PAL,
                                      DVENCODERFORMAT_DVSD,
                                      DVENCODERRESOLUTION_720x480,
                                      FALSE,NULL);  
  if (FAILED(hr))MessageBox(NULL,"Failed to Set Resolution",NULL,MB_OK);
  SAFE_RELEASE(pDVEnc);
  return;
}


extern "C"  int AVIEntryPoint(HINSTANCE hInstance, long first_file, long last_file, 
                              char *avi_outname){
    MSG msg={0};
    int rval=1;
    WNDCLASS wc;
    if(FAILED(CoInitializeEx(NULL, COINIT_APARTMENTTHREADED)))    {
        Msg(TEXT("CoInitialize Failed!\r\n"));   
        exit(1);
    } 
    ZeroMemory(&wc, sizeof wc);
    wc.lpfnWndProc   = WndMainProc;
    wc.hInstance     = hInstance;
    wc.lpszClassName = CLASSNAME;
    wc.lpszMenuName  = NULL;
    wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
    wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
    wc.hIcon         = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_VIDPREVIEW));
    if(!RegisterClass(&wc))    {
        Msg(TEXT("RegisterClass Failed! Error=0x%x\r\n"), GetLastError());
        CoUninitialize();
        exit(1);
    }
    ghApp = CreateWindow(CLASSNAME, APPLICATIONNAME,
                         WS_OVERLAPPEDWINDOW | WS_CAPTION | WS_CLIPCHILDREN,
                         CW_USEDEFAULT, CW_USEDEFAULT,
                         DEFAULT_VIDEO_WIDTH, DEFAULT_VIDEO_HEIGHT,
                         0, 0, hInstance, 0);
    gFirstF = first_file;
    gLastF = last_file;
    {
      HRESULT hr;
      if(DoDialog(hInstance,NULL)){
        hr = BuildFilterGraph(hInstance,avi_outname);
        if (FAILED (hr)) {
            CloseInterfaces();
            DestroyWindow(ghApp);
        }
        else{
            ShowWindow(ghApp,SW_SHOW);
        }
      } 
      else {
        rval=0;
        DestroyWindow(ghApp);
      }
      while(GetMessage(&msg,NULL,0,0))        {
          TranslateMessage(&msg);
          DispatchMessage(&msg);
      }
    }

    if(UnregisterClass(CLASSNAME,hInstance) == 0){
      MessageBox(NULL,"Unregister Class Failed",NULL,MB_OK);
    }
    //MessageBox(NULL,"Entry terminated",NULL,MB_OK);
    CoUninitialize();
    return (int)rval;
}


HRESULT BuildFilterGraph(HINSTANCE hInstance, char *ffn){
    USES_CONVERSION;
    HRESULT hr;
    char MediaOutput[256];
    CComPtr<IBaseFilter> pSource;      // Texture Renderer Filter
//    IBaseFilter *pSource;
    CPushSourceBitmapSet *pCTR=0;  
    strcpy(MediaOutput,ffn);
    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;
    }
    // put in our in place filter 
    pCTR = new CPushSourceBitmapSet(0,NULL, &hr);
    pSource=pCTR;
    hr = g_pGraph->AddFilter(pSource, L"Video Capture");
    if (FAILED(hr))    {
        Msg(TEXT("Couldn't add the capture filter to the graph!  hr=0x%x\r\n\r\n") 
            TEXT("The sample will now close."), hr);
        return hr;
    }
    hr = g_pCapture->SetOutputFileName(
           &MEDIASUBTYPE_Avi,  // Specifies AVI for the target file.
            A2W(MediaOutput),
            &g_pMux,              // Receives a pointer to the AVI mux.
            NULL);              // (Optional) Receives a pointer to the file sink.
    if (FAILED(hr)){
          Msg(TEXT("Failed to set Output filename!  hr=0x%x"), hr);
          return hr;
    }
    if(bCompressed && g_pVComp != NULL){
      hr=g_pGraph->AddFilter(g_pVComp,L"recompress");
      if (FAILED(hr))    {
         Msg(TEXT("Failed to add the compression filter: hr=0x%x"), hr);
         return hr;
      }
      hr = g_pCapture->RenderStream(0,0,pSource,g_pVComp,g_pMux);
    }
    else{
      hr = g_pCapture->RenderStream(0,0,pSource,0,g_pMux);
    }
    if (FAILED(hr)){ Msg("Fail to connect Mux"); return hr;}

    // Start previewing video data
//MessageBox(NULL,"Graph Running",NULL,MB_OK);
    hr = g_pMC->Run();
    if (FAILED(hr))    {
        Msg(TEXT("Couldn't run the graph!  hr=0x%x"), hr);
        return hr;
    }
    // Remember current state
    g_psCurrent = Running;
    return S_OK;
}