The question is being asked from time to time. Everyone knows what is full screen video. Video renderers implement full screen capability since long ago through their IVideoWindow::put_FullScreenMode property, and even Filter Graph Manager exposes its own IVideoWindow interface to forward calls to filter’s implementation of IVideoWindow interface.

However, for Video Mixing Renderers, version 7 and 9, the preferred and recommended mode is windowless, where no IVideoWindow interface is available.

Note The IVMRWindowlessControl or IVMRWindowlessControl9 interface is now preferred over IVideoWindow. For more information, see Using Windowless Mode.

So in order to implement full screen mode it takes the application to attach Video Mixing Renderer filter to a private frameless window, to its entire client area and expand the window to entire monitor area.

The sample project FullScreenWindowlessVmrSample01 is illustrating this technique.

Main application dialog owns a special window to host renderer, implemented by CRendererDialog class.

class CRendererDialog :
    public CDialogImpl<CRendererDialog>
{
public:

    enum { IDD = IDD_RENDERER };

BEGIN_MSG_MAP_EX(CRendererDialog)
    MSG_WM_INITDIALOG(OnInitDialog)
    MSG_WM_DESTROY(OnDestroy)
    MSG_WM_ERASEBKGND(OnEraseBkgnd)
    MSG_WM_PAINT(OnPaint)
    MSG_WM_DISPLAYCHANGE(OnDisplayChange)
    MSG_WM_KEYDOWN(OnKeyDown)
    COMMAND_ID_HANDLER_EX(IDCANCEL, OnCancel)
END_MSG_MAP()

private:
    CMainDialog& m_Owner;
//...

The dialog template does not have a caption, it has no frame and has its window rectangle equal to client area. As a result, spanning the Video Mixing Renderer to the entire client area and proper positioning of the dialog window is showing video on the entire monitor.

ATLVERIFY(m_RendererDialog.Create(m_hWnd));
ATLVERIFY(m_RendererDialog.MoveWindow(MonitorData.m_Position));
m_RendererDialog.ShowWindow(SW_SHOWNORMAL);
// ...
ATLENSURE_SUCCEEDED(pVmrWindowlessControl->SetVideoClippingWindow(m_RendererDialog));
ATLENSURE_SUCCEEDED(pVmrWindowlessControl->SetVideoPosition(NULL, m_RendererDialog.GetVideoPosition()));

Visual C++ .NET 2008 source code is available from SVN, release binary included. The project is using ATL and WTL libraries.

A 100-lines code snippet which illustrates how a bitmap is overlaid over displayed video with Video Mixing Renderer 9 Filter using IVMRMixerBitmap9 interface. A video clip is played (default is Windows clock.avi, but you can replace it with your longer one to see overlay is really in a loop).

http://code.assembla.com/…/VmrMixerBitmapSample01/…

VMR9AlphaBitmap AlphaBitmap;
ZeroMemory(&AlphaBitmap, sizeof AlphaBitmap);
AlphaBitmap.dwFlags = VMR9AlphaBitmap_hDC;
AlphaBitmap.hdc = Dc;
AlphaBitmap.rSrc = CRect(0, 0, 32, 32);
AlphaBitmap.rDest.left = (FLOAT) 0.75;
AlphaBitmap.rDest.top = (FLOAT) 0.75;
AlphaBitmap.rDest.right = (FLOAT) 0.95;
AlphaBitmap.rDest.bottom = (FLOAT) 0.95;
AlphaBitmap.fAlpha = 0.75;
const HRESULT nSetAlphaBitmapResult = pVmrMixerBitmap->SetAlphaBitmap(&AlphaBitmap);
ATLENSURE_SUCCEEDED(nSetAlphaBitmapResult);

With a low FPS clip like clock.avi it is clear that the overlaid image is only updated with the next “main” video frame.

Visual C++ .NET 2008 source code is available from SVN, release binary included.

Recently it was the time to sort out an issue with a video DMO, which outputs YV12 video and in the same time is capable of supporting extended video strides in order to efficiently make a direct connection to Video Mixing Renderer Filters.

From past experience, I already knew that some bugs are definitely involved but their effect was yet unexplored. For a testbed application, I took good old FrameRateSample02 application, which generates multiple video feeds and routes it to video renderers:

With new source video choices the application is capable of constructing filter graphs that use a private DMO (that is hosted inside the executable) wrapped with DMO Wrapper Filter, with a graph topology shown below:

The DMO does not do any processing, except support for extended strides while copying original data into buffer streamed to video renderer. Extended strides for a planar YUV format is a bit tricky. Are they supported at all? Yes, they are and video renderer might still request an extended stride and in which case origial MxN video needs to be copied into (M+P)xN buffer. Unlike packed pixel format, unused space is distributed in a bit different way but still very much similarly: output buffer is still a regular (M+P)xN rectangle, where the effective picture of size MxN should be copied into top left corner.

The problem I was aware of from past experience showed up immediately once the filters connected. After a dynamic format change initiated by the VMR, the filters report different connection media types. DMO Wrapper Filter still shows original connection time connection media type, while Video Mixing Renderer Filter shows media type it switched to.

This looks like DMO Wrapper Filter bug, but was yet to check if it still handles the new media type properly and passes the format change to the underlying DMO object. Taking into consideration the extent DMOs are used by Microsoft, it had to, thought I never met this in the MSDN documentation.

Further debugging revealed that DMO Wrapper Filter does handle the media type change and forward it to the DMO through IMediaObject::SetOutputType method. This happens when DMO already received its first input, and immediately before following IMediaObject::ProcessOutput method call:

rodmo.h(293) : CMediaObjectT<class CVideoDmo>::AllocateStreamingResources: ...
rodshow.h(2716) : CBaseFilterT<class CMainDialog::CSourceFilter>::Pause: ...
rodshow.h(2722) : CBaseFilterT<class CMainDialog::CSourceFilter>::Pause: m_State 0
rodshow.h(2730) : CBaseFilterT<class CMainDialog::CSourceFilter>::Pause: m_State 1
rodshow.h(2784) : CBaseFilterT<class CMainDialog::CSourceFilter>::GetState: nTimeout 0
rodmo.h(679) : CSimpleMediaObjectT<class CVideoDmo,1>::GetInputStatus: nInputStreamIndex 0
rodmo.h(702) : CSimpleMediaObjectT<class CVideoDmo,1>::ProcessInput: nInputStreamIndex 0, nFlags 0x1
rodmo.h(527) : CSimpleMediaObjectT<class CVideoDmo,1>::SetOutputType: nOutputStreamIndex 0, nFlags 0x0
rodmo.h(727) : CSimpleMediaObjectT<class CVideoDmo,1>::ProcessOutput: nFlags 0x1, nOutputBufferCount 1

So, the media type change is handled and the problem is only limited to reporting wrong (original) media type off the wrapper filter output pin.

Investigation of filter connection however brought up another interesting fact, memory allocator properties:

As the filters switched to a new media type, with extended strides, the memory allocator should obviously have been updated accordingly, in order to support larger buffer. However current memory allocator properties indicate old buffer size of 460,800 bytes, while new media type assumes 737,280 buffer size at the very least. The samples are however streamed fine, so the issue is also limited to incorrectly reported size.

This memory allocator is managed by the Video Mixing Renderer Filter, so the problem seems to be relating to it.

Good news however was that video was streamed and displayed correctly.

One thing that deserves special attention is making a DMO private. I already wrote another post on private DMOs some time ago, and this time the sample shows even a better way in case one does not need the DMO available for Intelligent Connect (in which case DMORegister call along with administrative privileges will be required),  just for a private instantiation. DMO is typically created by CoCreateInstance from inside the DMO Wrapper Filter, e.g. using IDMOWrapperFilter::Init method, so it is necessary to either register COM class, or… just register its class object for the process using CoRegisterClassObject.

There is no need for direct usage of API since ATL already wrapped the calls and we are to take advantage of what is already available. First of all, the DMO class requires certain CLSID, because we don’t have one typically declared in IDL. A good place for attaching CLSID is class declaration and __declspec keyword:

class __declspec(uuid("88B976BE-EEE6-45b1-A21B-42A941DF8819")) ATL_NO_VTABLE CVideoDmo :
    public CComObjectRootEx<CComMultiThreadModelNoCS>,
    public CComCoClass<CVideoDmo>,
    public CSimpleMediaObjectT<CVideoDmo, 1>
{

Further a COM class is typically referenced into module’s object map byan OBJECT_ENTRY_AUTO macro:

//OBJECT_ENTRY_AUTO(__uuidof(VideoDmo), CVideoDmo)

But we don’t need this this time as we don’t need standard COM registration for the class. We will register its class object manually and temporarily, at the time of DMO initialization:

CComQIPtr<IBaseFilter> pBaseFilter;
CVideoDmo* pVideoDmo;
{
    BEGIN_OBJECT_MAP(g_pObjectMap)
        OBJECT_ENTRY(__uuidof(CVideoDmo), CVideoDmo)
    END_OBJECT_MAP()
    ATLASSERT(DIM(g_pObjectMap) == 2 && !g_pObjectMap[1].pclsid);
    ATLENSURE_SUCCEEDED(g_pObjectMap[0].RegisterClassObject(CLSCTX_INPROC_SERVER, REGCLS_SINGLEUSE));
    _ATLTRY
    {
        CComPtr<IDMOWrapperFilter> pDmoWrapperFilter = ConstructDmoWrappedFilter(__uuidof(CVideoDmo), CVideoDmo::GetCategory());
        pBaseFilter = pDmoWrapperFilter;
        ATLENSURE_THROW(pBaseFilter, E_NOINTERFACE);
        CComQIPtr<IMediaObject> pMediaObject = pDmoWrapperFilter;
        ATLENSURE_THROW(pMediaObject, E_NOINTERFACE);
        pVideoDmo = static_cast<CVideoDmo*>((IMediaObject*) pMediaObject);
    }
    _ATLCATCHALL()
    {
        ATLVERIFY(SUCCEEDED(g_pObjectMap[0].RevokeClassObject()));
        _ATLRETHROW;
    }
    ATLVERIFY(SUCCEEDED(g_pObjectMap[0].RevokeClassObject()));
}
pVideoDmo->Initialize(CDmoMediaType(m_pMediaType), CopyYv12MediaBuffer);
ATLENSURE_SUCCEEDED(pGraphBuilder->AddFilter(pBaseFilter, CStringW(_T("Pass-Through DMO"))));
ATLENSURE_SUCCEEDED(pGraphBuilder->Connect(pOutputPin, _FilterGraphHelper::GetFilterPin(pBaseFilter, PINDIR_INPUT)));
pOutputPin = _FilterGraphHelper::GetFilterPin(pBaseFilter, PINDIR_OUTPUT)

What is being done in the code snippet above is:

• local object map with a single OBJECT_ENTRY item to have ATL manage class object registration/revokation for us
• registration of a private class/CLSID
• instantiation and initialization of a DMO Wrapper Filter which is to pick up our class
• cast back to native C++ pointer for easy further access (a private interface would be more accurate here)
• revokation for CLSID

For information, the interfaces queried from the DMO:

Find all "CVideoDmo::InternalQueryInterface", Hidden, Find Results 1, Current Document
CVideoDmo::InternalQueryInterface: Interface IMediaObject, Result 0x00000000
CVideoDmo::InternalQueryInterface: Interface IDMOQualityControl, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IDMOVideoOutputOptimizations, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IMediaObject, Result 0x00000000
CVideoDmo::InternalQueryInterface: Interface IWMGetSecureChannel, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IAMOpenProgress, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IAMDeviceRemoval, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IDirectVobSub, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IDirectVobSub, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IWMCodecAMVideoAccelerator, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IDirectVobSub, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IWMCodecAMVideoAccelerator, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IWMCodecAMVideoAccelerator, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IMediaSeeking, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IMediaPosition, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IAMFilterMiscFlags, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IVideoWindow, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IBasicAudio, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IAMFilterMiscFlags, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IKsPropertySet, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IReferenceClock, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IWMCodecAMVideoAccelerator, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IAMDeviceRemoval, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IAMOpenProgress, Result 0x80004002
Matching lines: 24

A Visual C++ .NET 2008 source code is available from SVN. Additional files will be required to compile, but binary is also incuded.

This is a begged MFC code for multiple windowless video renderers. MFC project, two independent video renderers hosted by the same parent window (actually through owned controls but this makes no major difference), VMR9 in windowless mode.

There are no WM_PAINT/WM_ERASEBKGND handlers, IVMRWindowlessControl9::RepaintVideo calls and other basically required code, instead a minimalistic snippet to make video rendered the requested way.

A Visual C++ .NET 2008 source code is available from SVN, release binary included.

A simple question being asked all over again. Given IBasicVideo, IBasicVideo2, IVMRWindowlessControl or IVMRWindowlessControl9, how to save image to file? It is easy. It is a bit easier with IBasicVideo because it is possible to query this interface directly from graph’s interface, such as IGraphBuilder, and the call will be forwarded to video renderer. This code assumes internal bitmap format is non-paletted, which I believe is always the case.

LONG nBufferSize = 0;
ATLENSURE_SUCCEEDED(pBasicVideo->GetCurrentImage(&nBufferSize, NULL));
CHeapPtr<BITMAPINFO> pBitmapInfo;
ATLENSURE_THROW(pBitmapInfo.AllocateBytes(nBufferSize), E_OUTOFMEMORY);
ATLENSURE_SUCCEEDED(pBasicVideo->GetCurrentImage(&nBufferSize, (LONG*) (BITMAPINFO*) pBitmapInfo));
const BYTE* pnData = (const BYTE*) (&pBitmapInfo->bmiHeader + 1);
// NOTE: You might wish to handle <=8 bpp bitmaps here
ATLASSERT(pBitmapInfo->bmiHeader.biBitCount > 8);
ATLASSERT(pBitmapInfo->bmiHeader.biCompression == BI_RGB);
ATLASSERT(pBitmapInfo->bmiHeader.biSizeImage);
BITMAPFILEHEADER BitmapFileHeader;
ZeroMemory(&BitmapFileHeader, sizeof BitmapFileHeader);
BitmapFileHeader.bfType = 'MB';
BitmapFileHeader.bfSize = (DWORD) (sizeof (BITMAPFILEHEADER) + pBitmapInfo->bmiHeader.biSize + pBitmapInfo->bmiHeader.biSizeImage);
BitmapFileHeader.bfOffBits = (DWORD) (sizeof (BITMAPFILEHEADER) + pBitmapInfo->bmiHeader.biSize);
ATLENSURE_SUCCEEDED(File.Write(&BitmapFileHeader, sizeof BitmapFileHeader));
ATLENSURE_SUCCEEDED(File.Write(&pBitmapInfo->bmiHeader, pBitmapInfo->bmiHeader.biSize));
ATLENSURE_SUCCEEDED(File.Write(pnData, (DWORD) pBitmapInfo->bmiHeader.biSizeImage));