Using Windowless Mode

I am sorry, but how to handle WM_DISPLAYCHANGE message at MFC? I did not find handler for it at MSDN and headers. May be there are equivalent messages and handlers?

What is "rc2" variable? Is it "rcClient"?

I get sound but no video in full screen mode, while in windowed mode i get both video and audio.

Anyone know what the deal could be?

Code attached in case it helps illuminate anything, based heavily on the directx tutorial here: http://www.directxtutorial.com/tutorial9/b-direct3dbasics/dx9b2.aspx#still


// include the basic windows header files and the Direct3D header file
#include <windows.h>
#include <windowsx.h>
#include <d3d9.h>
#include <DShow.h>
#include "assert.h"

// define the screen resolution
#define SCREEN_WIDTH  1280//800
#define SCREEN_HEIGHT 720//600

// include the Direct3D Library file
#pragma comment (lib, "d3d9.lib")
#pragma comment (lib, "Strmiids.lib")

// global declarations
LPDIRECT3D9 d3d; // the pointer to our Direct3D interface
LPDIRECT3DDEVICE9 d3ddev; // the pointer to the device class
D3DPRESENT_PARAMETERS d3dpp; // create a struct to hold various device information

// function prototypes
void initD3D(HWND hWnd); // sets up and initializes Direct3D
void render_frame(void); // renders a single frame
void cleanD3D(void); // closes Direct3D and releases memory
void checkForLostDevice(void);

// the WindowProc function prototype
LRESULT CALLBACK WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);

bool deviceIsLost = false;
bool moviePlaying = false;
HWND hWnd;

// the entry point for any Windows program
int WINAPI WinMain(HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   LPSTR lpCmdLine,
                   int nCmdShow)
{
    WNDCLASSEX wc;

    ZeroMemory(&wc, sizeof(WNDCLASSEX));

    wc.cbSize = sizeof(WNDCLASSEX);
    wc.style = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc = WindowProc;
    wc.hInstance = hInstance;
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    // wc.hbrBackground = (HBRUSH)COLOR_WINDOW;    // not needed any more
    wc.lpszClassName = L"WindowClass";

    RegisterClassEx(&wc);

    hWnd = CreateWindowEx(NULL,
        L"WindowClass",
        L"Our Direct3D Program",
        //WS_EX_TOPMOST | WS_POPUP,    // fullscreen values
        (WS_OVERLAPPEDWINDOW) & ~(WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_THICKFRAME),
        0, 0,    // the starting x and y positions should be 0
        SCREEN_WIDTH, SCREEN_HEIGHT,    // set the window to 640 x 480
        NULL,
        NULL,
        hInstance,
        NULL);

    ShowWindow(hWnd, nCmdShow);

    // set up and initialize Direct3D
    initD3D(hWnd);

    // enter the main loop:

    MSG msg;

    while(TRUE)
    {
        while(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }

        if(msg.message == WM_QUIT)
            break;

        checkForLostDevice();

        if(!deviceIsLost)
            render_frame();
    }

    // clean up DirectX and COM
    cleanD3D();

    return msg.wParam;
}

struct IGraphBuilder *pGB;
struct IMediaControl *pMC;
struct IMediaEvent *pME;
IVMRWindowlessControl* pWC = NULL;

HRESULT InitializeWindowlessVMR(IVMRWindowlessControl** ppWC, DWORD dwNumStreams, bool blendAppImage)
{
    IBaseFilter* pBF = NULL;
    IVMRWindowlessControl* pWC = NULL;
    *ppWC = NULL;

    // Create VMR and add it to the filter graph
    HRESULT hr = CoCreateInstance(CLSID_VideoMixingRenderer, NULL, CLSCTX_INPROC, IID_IBaseFilter, (void**)&pBF);
    assert(!FAILED(hr));

    hr = pGB->AddFilter(pBF, L"Video Mixing Renderer");
    assert(!FAILED(hr));

    // set rendering mode and number of streams
    IVMRFilterConfig* pConfig;
    hr = pBF->QueryInterface(IID_IVMRFilterConfig, (void**)&pConfig);

    if(SUCCEEDED(hr))
    {
        pConfig->SetRenderingMode(VMRMode_Windowless);

        // Set the VMR-7 to mixing mode if you want more than one video
        // stream, or you want to mix a static bitmap over the video.
        // (The VMR-9 defaults to mixing mode with four inputs.)
        if(dwNumStreams > 1 || blendAppImage)
        {
            pConfig->SetNumberOfStreams(dwNumStreams);
        }
        pConfig->Release();

        hr = pBF->QueryInterface(IID_IVMRWindowlessControl, (void**)&pWC);

        if(SUCCEEDED(hr))
        {
            hr = pWC->SetVideoClippingWindow(hWnd);
            *ppWC = pWC;
        }
    }
    pBF->Release();

    return hr;
}

void StopMovie()
{
    pMC->Stop();
    pWC->Release();
    pWC = NULL;
    moviePlaying = false;
}

void PlayMovie(const char *fileName)
{
    if(moviePlaying)
    {
        StopMovie();
        return;
    }

    //This creates the filter graph manager
    HRESULT hr = CoCreateInstance(CLSID_FilterGraph, NULL, CLSCTX_INPROC, IID_IGraphBuilder, (void **)&pGB);
    assert(!FAILED(hr));

    //Query COM interfaces
    pGB->QueryInterface(IID_IMediaControl, (void **)&pMC);
    pGB->QueryInterface(IID_IMediaEvent, (void **)&pME);

    int    length;        // length of filename
    WCHAR*    wfilename;    // where we store WCHAR version of filename

    length = strlen(fileName)+1;
    wfilename = new WCHAR[length];
    MultiByteToWideChar(CP_ACP, 0, fileName, -1, wfilename, length);

    pWC = NULL;
    hr = InitializeWindowlessVMR(&pWC, 1, false);
    if(SUCCEEDED(hr))
    {
        // build the filter graph
        hr = pGB->RenderFile(wfilename, NULL);
        assert(!FAILED(hr));

        // run the movie
        hr = pMC->Run();
        assert(!FAILED(hr));
    }

    long vidWidth, vidHeight;
    hr = pWC->GetNativeVideoSize(&vidWidth, &vidHeight, NULL, NULL);
    if(SUCCEEDED(hr))
    {
        RECT rcSrc, rcDest;

        // Set Source Rect
        SetRect(&rcSrc, 0, 0, vidWidth, vidHeight);

        // Get Client Rect
        GetClientRect(hWnd, &rcDest);

        // Set Destination Rect, taking into account letterboxing
        SetRect(&rcDest, 0, 0, rcDest.right, rcDest.bottom);

        // Set video position
        hr = pWC->SetVideoPosition(&rcSrc, &rcDest);
    }

    moviePlaying = true;
}

void onPaint()
{
    PAINTSTRUCT ps;
    HDC         hdc;
    RECT        rcClient;
    GetClientRect(hWnd, &rcClient);
    hdc = BeginPaint(hWnd, &ps);
    if (pWC != NULL)
    {
        /*
        // Find the region where the application can paint by subtracting
        // the video destination rectangle from the client area.
        // (Assume that g_rcDest was calculated previously.)
        HRGN rgnClient = CreateRectRgnIndirect(&rcClient);
        HRGN rgnVideo  = CreateRectRgnIndirect(&g_rcDest); 
        CombineRgn(rgnClient, rgnClient, rgnVideo, RGN_DIFF); 

        // Paint on window.
        HBRUSH hbr = GetSysColorBrush(COLOR_BTNFACE);
        FillRgn(hdc, rgnClient, hbr);

        // Clean up.
        DeleteObject(hbr);
        DeleteObject(rgnClient);
        DeleteObject(rgnVideo);
        */

        // Request the VMR to paint the video.
        HRESULT hr = pWC->RepaintVideo(hWnd, hdc); 
    }

    EndPaint(hWnd, &ps);
}

// this is the main message handler for the program
LRESULT CALLBACK WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch(message)
    {
    case WM_KEYUP:
        {
            if(wParam == 'F')
            {
                d3dpp.Windowed = !d3dpp.Windowed;
                d3ddev->Reset(&d3dpp);

                if(d3dpp.Windowed)
                {
                    //SetWindowLong(hWnd, GWL_STYLE, (WS_OVERLAPPEDWINDOW) & ~(WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_THICKFRAME));
                    //ShowWindow(hWnd,1);
                }
                else
                {
                    //SetWindowLong(hWnd, GWL_STYLE, WS_EX_TOPMOST | WS_POPUP);
                    //ShowWindow(hWnd,1);
                }               
            }
            else if(wParam = 'P')
            {
                PlayMovie("AttractMovie.wmv");
            }
            break;
        }
    case WM_DISPLAYCHANGE:
        {
            if(pWC)
                pWC->DisplayModeChanged();
            break;
        }
    case WM_PAINT:
        {
            onPaint();
            break;
        }
    case WM_WINDOWPOSCHANGED:
    case WM_SIZE:
        {
            long vidWidth, vidHeight;
            HRESULT hr = pWC->GetNativeVideoSize(&vidWidth, &vidHeight, NULL, NULL);
            if(SUCCEEDED(hr))
            {
                RECT rcSrc, rcDest;

                // Set Source Rect
                SetRect(&rcSrc, 0, 0, vidWidth, vidHeight);

                // Get Client Rect
                GetClientRect(hWnd, &rcDest);

                // Set Destination Rect, taking into account letterboxing
                SetRect(&rcDest, 0, 0, rcDest.right, rcDest.bottom);

                // Set video position
                hr = pWC->SetVideoPosition(&rcSrc, &rcDest);
            }
            break;
        }
    case WM_DESTROY:
        {
            PostQuitMessage(0);
            return 0;
        } break;
    }

    return DefWindowProc (hWnd, message, wParam, lParam);
}

// this function initializes and prepares Direct3D for use
void initD3D(HWND hWnd)
{
    d3d = Direct3DCreate9(D3D_SDK_VERSION); // create the Direct3D interface

    ZeroMemory(&d3dpp, sizeof(d3dpp));    // clear out the struct for use
    d3dpp.Windowed = TRUE;    // program fullscreen, not windowed
    d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;    // discard old frames
    d3dpp.hDeviceWindow = hWnd;    // set the window to be used by Direct3D
    d3dpp.BackBufferFormat = D3DFMT_X8R8G8B8;    // set the back buffer format to 32-bit
    d3dpp.BackBufferWidth = SCREEN_WIDTH;    // set the width of the buffer
    d3dpp.BackBufferHeight = SCREEN_HEIGHT;    // set the height of the buffer


    // create a device class using this information and the info from the d3dpp stuct
    d3d->CreateDevice(D3DADAPTER_DEFAULT,
        D3DDEVTYPE_HAL,
        hWnd,
        D3DCREATE_SOFTWARE_VERTEXPROCESSING,
        &d3dpp,
        &d3ddev);
}


// this is the function used to render a single frame
void render_frame(void)
{
    if(!moviePlaying)
    {
        // clear the window to a deep blue
        d3ddev->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 40, 100), 1.0f, 0);

        d3ddev->BeginScene();    // begins the 3D scene

        // do 3D rendering on the back buffer here

        d3ddev->EndScene();    // ends the 3D scene

        d3ddev->Present(NULL, NULL, NULL, NULL);   // displays the created frame on the screen
    }
}


// this is the function that cleans up Direct3D and COM
void cleanD3D(void)
{
    d3ddev->Release(); // close and release the 3D device
    d3d->Release(); // close and release Direct3D
}

void checkForLostDevice(void)
{
    HRESULT hr = d3ddev->TestCooperativeLevel();

    if(hr == D3DERR_DEVICELOST || hr == D3DERR_DEVICENOTRESET)
    {
        deviceIsLost = true;
        //freeVolatileResources();

        if(hr == D3DERR_DEVICENOTRESET)
        {
            hr = d3ddev->Reset(&d3dpp);

            if(SUCCEEDED(hr))
            {
                //initVolatileResources();
            }
            else if(hr == D3DERR_INVALIDCALL)
            {
                //platform->log("Device Reset returned D3DERR_INVALIDCALL. Some unmanaged resources haven't yet been destroyed like they should have been!");
            }
            else
            {
                //platform->log("Device Reset returned an unknown error:  %i", hr);
            }
        }
    }
    else if(FAILED(hr))
    {
        //platform->log("WindowsDirect3DRenderer TestCooperativeLevel returned an unknown error:  %i", hr);
        deviceIsLost = true;
    }
    else
    {
        deviceIsLost = false;
    }
}

May be third parameter is "CLSCTX_INPROC_SERVER" but not "CLSCTX_INPROC"?

The code snip above the Position the Video

IVMRWindowlessControl *pWc = NULL;
hr = InitWindowlessVMR(hwnd, pGraph, &g_pWc);

Should g_pWc be pWc?