//------------------------------------------------------------------------------
// File: WinUtil.h
//
// Desc: DirectShow base classes - defines generic handler classes.
//
// Copyright (c) 1992-2001 Microsoft Corporation. All rights reserved.
//------------------------------------------------------------------------------
// Make sure that you call PrepareWindow to initialise the window after
// the object has been constructed. It is a separate method so that
// derived classes can override useful methods like MessageLoop. Also
// any derived class must call DoneWithWindow in its destructor. If it
// doesn't a message may be retrieved and call a derived class member
// function while a thread is executing the base class destructor code
#ifndef __WINUTIL__
#define __WINUTIL__
const int DEFWIDTH = 320; // Initial window width
const int DEFHEIGHT = 240; // Initial window height
const int CAPTION = 256; // Maximum length of caption
const int TIMELENGTH = 50; // Maximum length of times
const int PROFILESTR = 128; // Normal profile string
const WORD PALVERSION = 0x300; // GDI palette version
const LONG PALETTE_VERSION = (LONG) 1; // Initial palette version
const COLORREF VIDEO_COLOUR = 0; // Defaults to black background
const HANDLE hMEMORY = (HANDLE) (-1); // Says to open as memory file
#define WIDTH(x) ((*(x)).right - (*(x)).left)
#define HEIGHT(x) ((*(x)).bottom - (*(x)).top)
#define SHOWSTAGE TEXT("WM_SHOWSTAGE")
#define SHOWSTAGETOP TEXT("WM_SHOWSTAGETOP")
#define REALIZEPALETTE TEXT("WM_REALIZEPALETTE")
class AM_NOVTABLE CBaseWindow
{
protected:
HINSTANCE m_hInstance; // Global module instance handle
HWND m_hwnd; // Handle for our window
HDC m_hdc; // Device context for the window
LONG m_Width; // Client window width
LONG m_Height; // Client window height
BOOL m_bActivated; // Has the window been activated
LPTSTR m_pClassName; // Static string holding class name
DWORD m_ClassStyles; // Passed in to our constructor
DWORD m_WindowStyles; // Likewise the initial window styles
DWORD m_WindowStylesEx; // And the extended window styles
UINT m_ShowStageMessage; // Have the window shown with focus
UINT m_ShowStageTop; // Makes the window WS_EX_TOPMOST
UINT m_RealizePalette; // Makes us realize our new palette
HDC m_MemoryDC; // Used for fast BitBlt operations
HPALETTE m_hPalette; // Handle to any palette we may have
BYTE m_bNoRealize; // Don't realize palette now
BYTE m_bBackground; // Should we realise in background
BYTE m_bRealizing; // already realizing the palette
CCritSec m_WindowLock; // Serialise window object access
BOOL m_bDoGetDC; // Should this window get a DC
bool m_bDoPostToDestroy; // Use PostMessage to destroy
CCritSec m_PaletteLock; // This lock protects m_hPalette.
// It should be held anytime the
// program use the value of m_hPalette.
// Maps windows message procedure into C++ methods
friend LRESULT CALLBACK WndProc(HWND hwnd, // Window handle
UINT uMsg, // Message ID
WPARAM wParam, // First parameter
LPARAM lParam); // Other parameter
virtual LRESULT OnPaletteChange(HWND hwnd, UINT Message);
public:
CBaseWindow(BOOL bDoGetDC = TRUE, bool bPostToDestroy = false);
#ifdef DEBUG
virtual ~CBaseWindow();
#endif
virtual HRESULT DoneWithWindow();
virtual HRESULT PrepareWindow();
virtual HRESULT InactivateWindow();
virtual HRESULT ActivateWindow();
virtual BOOL OnSize(LONG Width, LONG Height);
virtual BOOL OnClose();
virtual RECT GetDefaultRect();
virtual HRESULT UninitialiseWindow();
virtual HRESULT InitialiseWindow(HWND hwnd);
HRESULT CompleteConnect();
HRESULT DoCreateWindow();
HRESULT PerformanceAlignWindow();
HRESULT DoShowWindow(LONG ShowCmd);
void PaintWindow(BOOL bErase);
void DoSetWindowForeground(BOOL bFocus);
virtual HRESULT SetPalette(HPALETTE hPalette);
void SetRealize(BOOL bRealize)
{
m_bNoRealize = !bRealize;
}
// Jump over to the window thread to set the current palette
HRESULT SetPalette();
void UnsetPalette(void);
virtual HRESULT DoRealisePalette(BOOL bForceBackground = FALSE);
void LockPaletteLock();
void UnlockPaletteLock();
virtual BOOL PossiblyEatMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
{ return FALSE; };
// Access our window information
bool WindowExists();
LONG GetWindowWidth();
LONG GetWindowHeight();
HWND GetWindowHWND();
HDC GetMemoryHDC();
HDC GetWindowHDC();
#ifdef DEBUG
HPALETTE GetPalette();
#endif // DEBUG
// This is the window procedure the derived object should override
virtual LRESULT OnReceiveMessage(HWND hwnd, // Window handle
UINT uMsg, // Message ID
WPARAM wParam, // First parameter
LPARAM lParam); // Other parameter
// Must be overriden to return class and window styles
virtual LPTSTR GetClassWindowStyles(
__out DWORD *pClassStyles, // Class styles
__out DWORD *pWindowStyles, // Window styles
__out DWORD *pWindowStylesEx) PURE; // Extended styles
};
// This helper class is entirely subservient to the owning CBaseWindow object
// All this object does is to split out the actual drawing operation from the
// main object (because it was becoming too large). We have a number of entry
// points to set things like the draw device contexts, to implement the actual
// drawing and to set the destination rectangle in the client window. We have
// no critical section locking in this class because we are used exclusively
// by the owning window object which looks after serialising calls into us
// If you want to use this class make sure you call NotifyAllocator once the
// allocate has been agreed, also call NotifyMediaType with a pointer to a
// NON stack based CMediaType once that has been set (we keep a pointer to
// the original rather than taking a copy). When the palette changes call
// IncrementPaletteVersion (easiest thing to do is to also call this method
// in the SetMediaType method most filters implement). Finally before you
// start rendering anything call SetDrawContext so that we can get the HDCs
// for drawing from the CBaseWindow object we are given during construction
class CDrawImage
{
protected:
CBaseWindow *m_pBaseWindow; // Owning video window object
CRefTime m_StartSample; // Start time for the current sample
CRefTime m_EndSample; // And likewise it's end sample time
HDC m_hdc; // Main window device context
HDC m_MemoryDC; // Offscreen draw device context
RECT m_TargetRect; // Target destination rectangle
RECT m_SourceRect; // Source image rectangle
BOOL m_bStretch; // Do we have to stretch the images
BOOL m_bUsingImageAllocator; // Are the samples shared DIBSECTIONs
CMediaType *m_pMediaType; // Pointer to the current format
int m_perfidRenderTime; // Time taken to render an image
LONG m_PaletteVersion; // Current palette version cookie
// Draw the video images in the window
void SlowRender(IMediaSample *pMediaSample);
void FastRender(IMediaSample *pMediaSample);
void DisplaySampleTimes(IMediaSample *pSample);
void UpdateColourTable(HDC hdc,__in BITMAPINFOHEADER *pbmi);
void SetStretchMode();
public:
// Used to control the image drawing
CDrawImage(__inout CBaseWindow *pBaseWindow);
BOOL DrawImage(IMediaSample *pMediaSample);
BOOL DrawVideoImageHere(HDC hdc, IMediaSample *pMediaSample,
__in LPRECT lprcSrc, __in LPRECT lprcDst);
void SetDrawContext();
void SetTargetRect(__in RECT *pTargetRect);
void SetSourceRect(__in RECT *pSourceRect);
void GetTargetRect(__out RECT *pTargetRect);
void GetSourceRect(__out RECT *pSourceRect);
virtual RECT ScaleSourceRect(const RECT *pSource);
// Handle updating palettes as they change
LONG GetPaletteVersion();
void ResetPaletteVersion();
void IncrementPaletteVersion();
// Tell us media types and allocator assignments
void NotifyAllocator(BOOL bUsingImageAllocator);
void NotifyMediaType(__in CMediaType *pMediaType);
BOOL UsingImageAllocator();
// Called when we are about to draw an image
void NotifyStartDraw() {
MSR_START(m_perfidRenderTime);
};
// Called when we complete an image rendering
void NotifyEndDraw() {
MSR_STOP(m_perfidRenderTime);
};
};
// This is the structure used to keep information about each GDI DIB. All the
// samples we create from our allocator will have a DIBSECTION allocated to
// them. When we receive the sample we know we can BitBlt straight to an HDC
typedef struct tagDIBDATA {
LONG PaletteVersion; // Current palette version in use
DIBSECTION DibSection; // Details of DIB section allocated
HBITMAP hBitmap; // Handle to bitmap for drawing
HANDLE hMapping; // Handle to shared memory block
BYTE *pBase; // Pointer to base memory address
} DIBDATA;
// This class inherits from CMediaSample and uses all of it's methods but it
// overrides the constructor to initialise itself with the DIBDATA structure
// When we come to render an IMediaSample we will know if we are using our own
// allocator, and if we are, we can cast the IMediaSample to a pointer to one
// of these are retrieve the DIB section information and hence the HBITMAP
class CImageSample : public CMediaSample
{
protected:
DIBDATA m_DibData; // Information about the DIBSECTION
BOOL m_bInit; // Is the DIB information setup
public:
// Constructor
CImageSample(__inout CBaseAllocator *pAllocator,
__in_opt LPCTSTR pName,
__inout HRESULT *phr,
__in_bcount(length) LPBYTE pBuffer,
LONG length);
// Maintain the DIB/DirectDraw state
void SetDIBData(__in DIBDATA *pDibData);
__out DIBDATA *GetDIBData();
};
// This is an allocator based on the abstract CBaseAllocator base class that
// allocates sample buffers in shared memory. The number and size of these
// are determined when the output pin calls Prepare on us. The shared memory
// blocks are used in subsequent calls to GDI CreateDIBSection, once that
// has been done the output pin can fill the buffers with data which will
// then be handed to GDI through BitBlt calls and thereby remove one copy
class CImageAllocator : public CBaseAllocator
{
protected:
CBaseFilter *m_pFilter; // Delegate reference counts to
CMediaType *m_pMediaType; // Pointer to the current format
// Used to create and delete samples
HRESULT Alloc();
void Free();
// Manage the shared DIBSECTION and DCI/DirectDraw buffers
HRESULT CreateDIB(LONG InSize,DIBDATA &DibData);
STDMETHODIMP CheckSizes(__in ALLOCATOR_PROPERTIES *pRequest);
virtual CImageSample *CreateImageSample(__in_bcount(Length) LPBYTE pData,LONG Length);
public:
// Constructor and destructor
CImageAllocator(__inout CBaseFilter *pFilter,__in_opt LPCTSTR pName,__inout HRESULT *phr);
#ifdef DEBUG
~CImageAllocator();
#endif
STDMETHODIMP_(ULONG) NonDelegatingAddRef();
STDMETHODIMP_(ULONG) NonDelegatingRelease();
void NotifyMediaType(__in CMediaType *pMediaType);
// Agree the number of buffers to be used and their size
STDMETHODIMP SetProperties(
__in ALLOCATOR_PROPERTIES *pRequest,
__out ALLOCATOR_PROPERTIES *pActual);
};
// This class is a fairly specialised helper class for image renderers that
// have to create and manage palettes. The CBaseWindow class looks after
// realising palettes once they have been installed. This class can be used
// to create the palette handles from a media format (which must contain a
// VIDEOINFO structure in the format block). We try to make the palette an
// identity palette to maximise performance and also only change palettes
// if actually required to (we compare palette colours before updating).
// All the methods are virtual so that they can be overriden if so required
class CImagePalette
{
protected:
CBaseWindow *m_pBaseWindow; // Window to realise palette in
CBaseFilter *m_pFilter; // Media filter to send events
CDrawImage *m_pDrawImage; // Object who will be drawing
HPALETTE m_hPalette; // The palette handle we own
public:
CImagePalette(__inout CBaseFilter *pBaseFilter,
__inout CBaseWindow *pBaseWindow,
__inout CDrawImage *pDrawImage);
#ifdef DEBUG
virtual ~CImagePalette();
#endif
static HPALETTE MakePalette(const VIDEOINFOHEADER *pVideoInfo, __in LPSTR szDevice);
HRESULT RemovePalette();
static HRESULT MakeIdentityPalette(__inout_ecount_full(iColours) PALETTEENTRY *pEntry,INT iColours, __in LPSTR szDevice);
HRESULT CopyPalette(const CMediaType *pSrc,__out CMediaType *pDest);
BOOL ShouldUpdate(const VIDEOINFOHEADER *pNewInfo,const VIDEOINFOHEADER *pOldInfo);
HRESULT PreparePalette(const CMediaType *pmtNew,const CMediaType *pmtOld,__in LPSTR szDevice);
BOOL DrawVideoImageHere(HDC hdc, IMediaSample *pMediaSample, __in LPRECT lprcSrc, __in LPRECT lprcDst)
{
return m_pDrawImage->DrawVideoImageHere(hdc, pMediaSample, lprcSrc,lprcDst);
}
};
// Another helper class really for video based renderers. Most such renderers
// need to know what the display format is to some degree or another. This
// class initialises itself with the display format. The format can be asked
// for through GetDisplayFormat and various other accessor functions. If a
// filter detects a display format change (perhaps it gets a WM_DEVMODECHANGE
// message then it can call RefreshDisplayType to reset that format). Also
// many video renderers will want to check formats as they are proposed by
// source filters. This class provides methods to check formats and only
// accept those video formats that can be efficiently drawn using GDI calls
class CImageDisplay : public CCritSec
{
protected:
// This holds the display format; biSize should not be too big, so we can
// safely use the VIDEOINFO structure
VIDEOINFO m_Display;
static DWORD CountSetBits(const DWORD Field);
static DWORD CountPrefixBits(const DWORD Field);
static BOOL CheckBitFields(const VIDEOINFO *pInput);
public:
// Constructor and destructor
CImageDisplay();
// Used to manage BITMAPINFOHEADERs and the display format
const VIDEOINFO *GetDisplayFormat();
HRESULT RefreshDisplayType(__in_opt LPSTR szDeviceName);
static BOOL CheckHeaderValidity(const VIDEOINFO *pInput);
static BOOL CheckPaletteHeader(const VIDEOINFO *pInput);
BOOL IsPalettised();
WORD GetDisplayDepth();
// Provide simple video format type checking
HRESULT CheckMediaType(const CMediaType *pmtIn);
HRESULT CheckVideoType(const VIDEOINFO *pInput);
HRESULT UpdateFormat(__inout VIDEOINFO *pVideoInfo);
const DWORD *GetBitMasks(const VIDEOINFO *pVideoInfo);
BOOL GetColourMask(__out DWORD *pMaskRed,
__out DWORD *pMaskGreen,
__out DWORD *pMaskBlue);
};
// Convert a FORMAT_VideoInfo to FORMAT_VideoInfo2
STDAPI ConvertVideoInfoToVideoInfo2(__inout AM_MEDIA_TYPE *pmt);
// Check a media type containing VIDEOINFOHEADER
STDAPI CheckVideoInfoType(const AM_MEDIA_TYPE *pmt);
// Check a media type containing VIDEOINFOHEADER
STDAPI CheckVideoInfo2Type(const AM_MEDIA_TYPE *pmt);
#endif // __WINUTIL__