#include "streams.h"

#include <mmreg.h>

#include <dvdmedia.h>

#include <tchar.h>

#include <strsafe.h>

#define STREAMS_PROVIDE_CUSTOM_FACTORY

#pragma comment(lib, "WinMM.lib")

#include <initguid.h>

DEFINE_GUID(IID_IPin,0x56A86891,0xAD4,0x11CE,0xB0,0x3A,0x0,0x20,0xAF,0xB,0xA7,0x70);

DEFINE_GUID(IID_IEnumPins,0x56A86892,0xAD4,0x11CE,0xB0,0x3A,0x0,0x20,0xAF,0xB,0xA7,0x70);

DEFINE_GUID(IID_IEnumMediaTypes,0x89C31040,0x846B,0x11CE,0x97,0xD3,0x0,0xAA,0x0,0x55,0x59,0x5A);

DEFINE_GUID(IID_IMediaFilter,0x56A86899,0xAD4,0x11CE,0xB0,0x3A,0x0,0x20,0xAF,0xB,0xA7,0x70);

DEFINE_GUID(IID_IBaseFilter,0x56A86895,0xAD4,0x11CE,0xB0,0x3A,0x0,0x20,0xAF,0xB,0xA7,0x70);

DEFINE_GUID(IID_IMediaSample,0x56A8689A,0xAD4,0x11CE,0xB0,0x3A,0x0,0x20,0xAF,0xB,0xA7,0x70);

DEFINE_GUID(IID_IMediaSample2,0x36B73884,0xC2C8,0x11CF,0x8B,0x46,0x0,0x80,0x5F,0x6C,0xEF,0x60);

DEFINE_GUID(IID_IMemAllocator,0x56A8689C,0xAD4,0x11CE,0xB0,0x3A,0x0,0x20,0xAF,0xB,0xA7,0x70);

DEFINE_GUID(IID_IMemAllocatorCallbackTemp,0x379A0CF0,0xC1DE,0x11D2,0xAB,0xF5,0x0,0xA0,0xC9,0x5,0xF3,0x75);

DEFINE_GUID(IID_IMemInputPin,0x56A8689D,0xAD4,0x11CE,0xB0,0x3A,0x0,0x20,0xAF,0xB,0xA7,0x70);

DEFINE_GUID(IID_IAMovieSetup,0xA3D8CEC0,0x7E5A,0x11CF,0xBB,0xC5,0x0,0x80,0x5F,0x6C,0xEF,0x20);

DEFINE_GUID(IID_IFilterMapper,0x56A868A3,0xAD4,0x11CE,0xB0,0x3A,0x0,0x20,0xAF,0xB,0xA7,0x70);

DEFINE_GUID(IID_IFilterMapper2,0xB79BB0B0,0x33C1,0x11D1,0xAB,0xE1,0x0,0xA0,0xC9,0x5,0xF3,0x75);

DEFINE_GUID(IID_IMediaEventSink,0x56A868A2,0xAD4,0x11CE,0xB0,0x3A,0x0,0x20,0xAF,0xB,0xA7,0x70);

DEFINE_GUID(IID_IFilterGraph2,0x36B73882,0xC2C8,0x11CF,0x8B,0x46,0x0,0x80,0x5F,0x6C,0xEF,0x60);

DEFINE_GUID(IID_ISeekingPassThru,0x36B73883,0xC2C8,0x11CF,0x8B,0x46,0x0,0x80,0x5F,0x6C,0xEF,0x60);

DEFINE_GUID(IID_IPinConnection,0x4A9A62D3,0x27D4,0x403D,0x91,0xE9,0x89,0xF5,0x40,0xE5,0x55,0x34);

DEFINE_GUID(IID_IPinFlowControl,0xC56E9858,0xDBF3,0x4F6B,0x81,0x19,0x38,0x4A,0xF2,0x6,0xD,0xEB);

DEFINE_GUID(IID_IAMStreamConfig,0xc6e13340,0x30ac,0x11d0,0xa1,0x8c,0x00,0xa0,0xc9,0x11,0x89,0x56);

DEFINE_GUID(IID_IKsPropertySet,0x31efac30,0x515c,0x11d0,0xa9,0xaa,0x0,0xaa,0x0,0x61,0xbe,0x93);

#ifndef NUMELMS

#if _WIN32_WINNT < 0x0600

#define NUMELMS(aa) (sizeof(aa)/sizeof((aa)[0]))

#else

#define NUMELMS(aa) ARRAYSIZE(aa)

#endif

#endif

#pragma warning(push)

#pragma warning(disable: 4312 4244)

// _GetWindowLongPtr

// Templated version of GetWindowLongPtr, to suppress spurious compiler warning.

template <class T>

T _GetWindowLongPtr(HWND hwnd, int nIndex)

{

return (T)GetWindowLongPtr(hwnd, nIndex);

}

// _SetWindowLongPtr

// Templated version of SetWindowLongPtr, to suppress spurious compiler warning.

template <class T>

LONG_PTR _SetWindowLongPtr(HWND hwnd, int nIndex, T p)

{

return SetWindowLongPtr(hwnd, nIndex, (LONG_PTR)p);

}

#pragma warning(pop)

#ifdef DEBUG

#ifdef UNICODE

#ifndef _UNICODE

#define _UNICODE

#endif // _UNICODE

#endif // UNICODE

#endif // DEBUG

//------------------------------------------------------------------------------

// File: FourCC.h

//

// Desc: DirectShow base classes.

//

// Copyright (c) 1992-2001 Microsoft Corporation. All rights reserved.

//------------------------------------------------------------------------------

// FOURCCMap

//

// provides a mapping between old-style multimedia format DWORDs

// and new-style GUIDs.

//

// A range of 4 billion GUIDs has been allocated to ensure that this

// mapping can be done straightforwardly one-to-one in both directions.

//

// January 95

#ifndef __FOURCC__

#define __FOURCC__

// Multimedia format types are marked with DWORDs built from four 8-bit

// chars and known as FOURCCs. New multimedia AM_MEDIA_TYPE definitions include

// a subtype GUID. In order to simplify the mapping, GUIDs in the range:

// XXXXXXXX-0000-0010-8000-00AA00389B71

// are reserved for FOURCCs.

class FOURCCMap : public GUID

{

public:

FOURCCMap();

FOURCCMap(DWORD Fourcc);

FOURCCMap(const GUID *);

DWORD GetFOURCC(void);

void SetFOURCC(DWORD fourcc);

void SetFOURCC(const GUID *);

private:

void InitGUID();

};

#define GUID_Data2 0

#define GUID_Data3 0x10

#define GUID_Data4_1 0xaa000080

#define GUID_Data4_2 0x719b3800

inline void

FOURCCMap::InitGUID() {

Data2 = GUID_Data2;

Data3 = GUID_Data3;

((DWORD *)Data4)[0] = GUID_Data4_1;

((DWORD *)Data4)[1] = GUID_Data4_2;

}

inline

FOURCCMap::FOURCCMap() {

InitGUID();

SetFOURCC( DWORD(0));

}

inline

FOURCCMap::FOURCCMap(DWORD fourcc)

{

InitGUID();

SetFOURCC(fourcc);

}

inline

FOURCCMap::FOURCCMap(const GUID * pGuid)

{

InitGUID();

SetFOURCC(pGuid);

}

inline void

FOURCCMap::SetFOURCC(const GUID * pGuid)

{

FOURCCMap * p = (FOURCCMap*) pGuid;

SetFOURCC(p->GetFOURCC());

}

inline void

FOURCCMap::SetFOURCC(DWORD fourcc)

{

Data1 = fourcc;

}

inline DWORD

FOURCCMap::GetFOURCC(void)

{

return Data1;

}

#endif /* __FOURCC__ */

//------------------------------------------------------------------------------

// File: MsgThrd.h

//

// Desc: DirectShow base classes - provides support for a worker thread

// class to which one can asynchronously post messages.

//

// Copyright (c) 1992-2001 Microsoft Corporation. All rights reserved.

//------------------------------------------------------------------------------

#ifndef __MSGTHRD__

#define __MSGTHRD__

// Message class - really just a structure.

//

class CMsg {

public:

UINT uMsg;

DWORD dwFlags;

LPVOID lpParam;

CAMEvent *pEvent;

CMsg(UINT u, DWORD dw, __inout_opt LPVOID lp, __in_opt CAMEvent *pEvnt)

: uMsg(u), dwFlags(dw), lpParam(lp), pEvent(pEvnt) {}

CMsg()

: uMsg(0), dwFlags(0L), lpParam(NULL), pEvent(NULL) {}

};

// This is the actual thread class. It exports all the usual thread control

// functions. The created thread is different from a normal WIN32 thread in

// that it is prompted to perform particaular tasks by responding to messages

// posted to its message queue.

//

class AM_NOVTABLE CMsgThread {

private:

static DWORD WINAPI DefaultThreadProc(__inout LPVOID lpParam);

DWORD m_ThreadId;

HANDLE m_hThread;

protected:

// if you want to override GetThreadMsg to block on other things

// as well as this queue, you need access to this

CGenericList<CMsg> m_ThreadQueue;

CCritSec m_Lock;

HANDLE m_hSem;

LONG m_lWaiting;

public:

CMsgThread()

: m_ThreadId(0),

m_hThread(NULL),

m_lWaiting(0),

m_hSem(NULL),

// make a list with a cache of 5 items

m_ThreadQueue(NAME("MsgThread list"), 5)

{

}

~CMsgThread();

// override this if you want to block on other things as well

// as the message loop

void virtual GetThreadMsg(__out CMsg *msg);

// override this if you want to do something on thread startup

virtual void OnThreadInit() {

};

BOOL CreateThread();

BOOL WaitForThreadExit(__out LPDWORD lpdwExitCode) {

if (m_hThread != NULL) {

WaitForSingleObject(m_hThread, INFINITE);

return GetExitCodeThread(m_hThread, lpdwExitCode);

}

return FALSE;

}

DWORD ResumeThread() {

return ::ResumeThread(m_hThread);

}

DWORD SuspendThread() {

return ::SuspendThread(m_hThread);

}

int GetThreadPriority() {

return ::GetThreadPriority(m_hThread);

}

BOOL SetThreadPriority(int nPriority) {

return ::SetThreadPriority(m_hThread, nPriority);

}

HANDLE GetThreadHandle() {

return m_hThread;

}

DWORD GetThreadId() {

return m_ThreadId;

}

void PutThreadMsg(UINT uMsg, DWORD dwMsgFlags,

__in_opt LPVOID lpMsgParam, __in_opt CAMEvent *pEvent = NULL) {

CAutoLock lck(&m_Lock);

CMsg* pMsg = new CMsg(uMsg, dwMsgFlags, lpMsgParam, pEvent);

m_ThreadQueue.AddTail(pMsg);

if (m_lWaiting != 0) {

ReleaseSemaphore(m_hSem, m_lWaiting, 0);

m_lWaiting = 0;

}

}

// This is the function prototype of the function that the client

// supplies. It is always called on the created thread, never on

// the creator thread.

//

virtual LRESULT ThreadMessageProc(

UINT uMsg, DWORD dwFlags, __inout_opt LPVOID lpParam, __in_opt CAMEvent *pEvent) = 0;

};

#endif /* __MSGTHRD__ */

//------------------------------------------------------------------------------

// File: Schedule.h

//

// Desc: DirectShow base classes.

//

// Copyright (c) 1996-2001 Microsoft Corporation. All rights reserved.

//------------------------------------------------------------------------------

#ifndef __CAMSchedule__

#define __CAMSchedule__

class CAMSchedule : private CBaseObject

{

public:

virtual ~CAMSchedule();

// ev is the event we should fire if the advise time needs re-evaluating

CAMSchedule( HANDLE ev );

DWORD GetAdviseCount();

REFERENCE_TIME GetNextAdviseTime();

// We need a method for derived classes to add advise packets, we return the cookie

DWORD_PTR AddAdvisePacket( const REFERENCE_TIME & time1, const REFERENCE_TIME & time2, HANDLE h, BOOL periodic );

// And a way to cancel

HRESULT Unadvise(DWORD_PTR dwAdviseCookie);

// Tell us the time please, and we'll dispatch the expired events. We return the time of the next event.

// NB: The time returned will be "useless" if you start adding extra Advises. But that's the problem of

// whoever is using this helper class (typically a clock).

REFERENCE_TIME Advise( const REFERENCE_TIME & rtTime );

// Get the event handle which will be set if advise time requires re-evaluation.

HANDLE GetEvent() const { return m_ev; }

private:

// We define the nodes that will be used in our singly linked list

// of advise packets. The list is ordered by time, with the

// elements that will expire first at the front.

class CAdvisePacket

{

public:

CAdvisePacket()

{}

CAdvisePacket * m_next;

DWORD_PTR m_dwAdviseCookie;

REFERENCE_TIME m_rtEventTime; // Time at which event should be set

REFERENCE_TIME m_rtPeriod; // Periodic time

HANDLE m_hNotify; // Handle to event or semephore

BOOL m_bPeriodic; // TRUE => Periodic event

CAdvisePacket( __inout_opt CAdvisePacket * next, LONGLONG time ) : m_next(next), m_rtEventTime(time)

{}

void InsertAfter( __inout CAdvisePacket * p )

{

p->m_next = m_next;

m_next = p;

}

int IsZ() const // That is, is it the node that represents the end of the list

{ return m_next == 0; }

CAdvisePacket * RemoveNext()

{

CAdvisePacket *const next = m_next;

CAdvisePacket *const new_next = next->m_next;

m_next = new_next;

return next;

}

void DeleteNext()

{

delete RemoveNext();

}

CAdvisePacket * Next() const

{

CAdvisePacket * result = m_next;

if (result->IsZ()) result = 0;

return result;

}

DWORD_PTR Cookie() const

{ return m_dwAdviseCookie; }

};

// Structure is:

// head -> elmt1 -> elmt2 -> z -> null

// So an empty list is: head -> z -> null

// Having head & z as links makes insertaion,

// deletion and shunting much easier.

CAdvisePacket head, z; // z is both a tail and a sentry

volatile DWORD_PTR m_dwNextCookie; // Strictly increasing

volatile DWORD m_dwAdviseCount; // Number of elements on list

CCritSec m_Serialize;

// AddAdvisePacket: adds the packet, returns the cookie (0 if failed)

DWORD_PTR AddAdvisePacket( __inout CAdvisePacket * pPacket );

// Event that we should set if the packed added above will be the next to fire.

const HANDLE m_ev;

// A Shunt is where we have changed the first element in the

// list and want it re-evaluating (i.e. repositioned) in

// the list.

void ShuntHead();

// Rather than delete advise packets, we cache them for future use

CAdvisePacket * m_pAdviseCache;

DWORD m_dwCacheCount;

enum { dwCacheMax = 5 }; // Don't bother caching more than five

void Delete( __inout CAdvisePacket * pLink );// This "Delete" will cache the Link

// Attributes and methods for debugging

public:

#ifdef DEBUG

void DumpLinkedList();

#else

void DumpLinkedList() {}

#endif

};

#endif // __CAMSchedule__

//------------------------------------------------------------------------------

// File: RefClock.h

//

// Desc: DirectShow base classes - defines the IReferenceClock interface.

//

// Copyright (c) 1992-2001 Microsoft Corporation. All rights reserved.

//------------------------------------------------------------------------------

#ifndef __BASEREFCLOCK__

#define __BASEREFCLOCK__

const UINT RESOLUTION = 1; /* High resolution timer */

const INT ADVISE_CACHE = 4; /* Default cache size */

const LONGLONG MAX_TIME = 0x7FFFFFFFFFFFFFFF; /* Maximum LONGLONG value */

inline LONGLONG WINAPI ConvertToMilliseconds(const REFERENCE_TIME& RT)

{

/* This converts an arbitrary value representing a reference time

into a MILLISECONDS value for use in subsequent system calls */

return (RT / (UNITS / MILLISECONDS));

}

/* This class hierarchy will support an IReferenceClock interface so

that an audio card (or other externally driven clock) can update the

system wide clock that everyone uses.

The interface will be pretty thin with probably just one update method

This interface has not yet been defined.

*/

/* This abstract base class implements the IReferenceClock

* interface. Classes that actually provide clock signals (from

* whatever source) have to be derived from this class.

*

* The abstract class provides implementations for:

* CUnknown support

* locking support (CCritSec)

* client advise code (creates a thread)

*

* Question: what can we do about quality? Change the timer

* resolution to lower the system load? Up the priority of the

* timer thread to force more responsive signals?

*

* During class construction we create a worker thread that is destroyed during

* destuction. This thread executes a series of WaitForSingleObject calls,

* waking up when a command is given to the thread or the next wake up point

* is reached. The wakeup points are determined by clients making Advise

* calls.

*

* Each advise call defines a point in time when they wish to be notified. A

* periodic advise is a series of these such events. We maintain a list of

* advise links and calculate when the nearest event notification is due for.

* We then call WaitForSingleObject with a timeout equal to this time. The

* handle we wait on is used by the class to signal that something has changed

* and that we must reschedule the next event. This typically happens when

* someone comes in and asks for an advise link while we are waiting for an

* event to timeout.

*

* While we are modifying the list of advise requests we

* are protected from interference through a critical section. Clients are NOT

* advised through callbacks. One shot clients have an event set, while

* periodic clients have a semaphore released for each event notification. A

* semaphore allows a client to be kept up to date with the number of events

* actually triggered and be assured that they can't miss multiple events being

* set.

*

* Keeping track of advises is taken care of by the CAMSchedule class.

*/

class CBaseReferenceClock

: public CUnknown, public IReferenceClock, public CCritSec, public IReferenceClockTimerControl

{

protected:

virtual ~CBaseReferenceClock(); // Don't let me be created on the stack!

public:

CBaseReferenceClock(__in_opt LPCTSTR pName,

__inout_opt LPUNKNOWN pUnk,

__inout HRESULT *phr,

__inout_opt CAMSchedule * pSched = 0 );

STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, __deref_out void ** ppv);

DECLARE_IUNKNOWN

/* IReferenceClock methods */

// Derived classes must implement GetPrivateTime(). All our GetTime

// does is call GetPrivateTime and then check so that time does not

// go backwards. A return code of S_FALSE implies that the internal

// clock has gone backwards and GetTime time has halted until internal

// time has caught up. (Don't know if this will be much use to folk,

// but it seems odd not to use the return code for something useful.)

STDMETHODIMP GetTime(__out REFERENCE_TIME *pTime);

// When this is called, it sets m_rtLastGotTime to the time it returns.

/* Provide standard mechanisms for scheduling events */

/* Ask for an async notification that a time has elapsed */

STDMETHODIMP AdviseTime(

REFERENCE_TIME baseTime, // base reference time

REFERENCE_TIME streamTime, // stream offset time

HEVENT hEvent, // advise via this event

__out DWORD_PTR *pdwAdviseCookie// where your cookie goes

);

/* Ask for an asynchronous periodic notification that a time has elapsed */

STDMETHODIMP AdvisePeriodic(

REFERENCE_TIME StartTime, // starting at this time

REFERENCE_TIME PeriodTime, // time between notifications

HSEMAPHORE hSemaphore, // advise via a semaphore

__out DWORD_PTR *pdwAdviseCookie// where your cookie goes

);

/* Cancel a request for notification(s) - if the notification was

* a one shot timer then this function doesn't need to be called

* as the advise is automatically cancelled, however it does no

* harm to explicitly cancel a one-shot advise. It is REQUIRED that

* clients call Unadvise to clear a Periodic advise setting.

*/

STDMETHODIMP Unadvise(DWORD_PTR dwAdviseCookie);

/* Methods for the benefit of derived classes or outer objects */

// GetPrivateTime() is the REAL clock. GetTime is just a cover for

// it. Derived classes will probably override this method but not

// GetTime() itself.

// The important point about GetPrivateTime() is it's allowed to go

// backwards. Our GetTime() will keep returning the LastGotTime

// until GetPrivateTime() catches up.

virtual REFERENCE_TIME GetPrivateTime();

/* Provide a method for correcting drift */

STDMETHODIMP SetTimeDelta( const REFERENCE_TIME& TimeDelta );

CAMSchedule * GetSchedule() const { return m_pSchedule; }

// IReferenceClockTimerControl methods

//

// Setting a default of 0 disables the default of 1ms

STDMETHODIMP SetDefaultTimerResolution(

REFERENCE_TIME timerResolution // in 100ns

);

STDMETHODIMP GetDefaultTimerResolution(

__out REFERENCE_TIME* pTimerResolution // in 100ns

);

private:

REFERENCE_TIME m_rtPrivateTime; // Current best estimate of time

DWORD m_dwPrevSystemTime; // Last vaule we got from timeGetTime

REFERENCE_TIME m_rtLastGotTime; // Last time returned by GetTime

REFERENCE_TIME m_rtNextAdvise; // Time of next advise

UINT m_TimerResolution;

#ifdef PERF

int m_idGetSystemTime;

#endif

// Thread stuff

public:

void TriggerThread() // Wakes thread up. Need to do this if

{ // time to next advise needs reevaluating.

EXECUTE_ASSERT(SetEvent(m_pSchedule->GetEvent()));

}

private:

BOOL m_bAbort; // Flag used for thread shutdown

HANDLE m_hThread; // Thread handle

HRESULT AdviseThread(); // Method in which the advise thread runs

static DWORD __stdcall AdviseThreadFunction(__in LPVOID); // Function used to get there

protected:

CAMSchedule * m_pSchedule;

void Restart (IN REFERENCE_TIME rtMinTime = 0I64) ;

};

#endif

//------------------------------------------------------------------------------

// File: VideoCtl.h

//

// Desc: DirectShow base classes.

//

// Copyright (c) 1992-2001 Microsoft Corporation. All rights reserved.

//------------------------------------------------------------------------------

#ifndef __VIDEOCTL__

#define __VIDEOCTL__

// These help with property page implementations. The first can be used to

// load any string from a resource file. The buffer to load into is passed

// as an input parameter. The same buffer is the return value if the string

// was found otherwise it returns TEXT(""). The GetDialogSize is passed the

// resource ID of a dialog box and returns the size of it in screen pixels

#define STR_MAX_LENGTH 256

LPTSTR WINAPI StringFromResource(__out_ecount(STR_MAX_LENGTH) LPTSTR pBuffer, int iResourceID);

#ifdef UNICODE

#define WideStringFromResource StringFromResource

LPSTR WINAPI StringFromResource(__out_ecount(STR_MAX_LENGTH) LPSTR pBuffer, int iResourceID);

#else

LPWSTR WINAPI WideStringFromResource(__out_ecount(STR_MAX_LENGTH) LPWSTR pBuffer, int iResourceID);

#endif

BOOL WINAPI GetDialogSize(int iResourceID, // Dialog box resource identifier

DLGPROC pDlgProc, // Pointer to dialog procedure

LPARAM lParam, // Any user data wanted in pDlgProc

__out SIZE *pResult);// Returns the size of dialog box

// Class that aggregates an IDirectDraw interface

class CAggDirectDraw : public IDirectDraw, public CUnknown

{

protected:

LPDIRECTDRAW m_pDirectDraw;

public:

DECLARE_IUNKNOWN

STDMETHODIMP NonDelegatingQueryInterface(REFIID riid,__deref_out void **ppv);

// Constructor and destructor

CAggDirectDraw(__in_opt LPCTSTR pName,__inout_opt LPUNKNOWN pUnk) :

CUnknown(pName,pUnk),

m_pDirectDraw(NULL) { };

virtual CAggDirectDraw::~CAggDirectDraw() { };

// Set the object we should be aggregating

void SetDirectDraw(__inout LPDIRECTDRAW pDirectDraw) {

m_pDirectDraw = pDirectDraw;

}

// IDirectDraw methods

STDMETHODIMP Compact();

STDMETHODIMP CreateClipper(DWORD dwFlags,__deref_out LPDIRECTDRAWCLIPPER *lplpDDClipper,__inout_opt IUnknown *pUnkOuter);

STDMETHODIMP CreatePalette(DWORD dwFlags,__in LPPALETTEENTRY lpColorTable,__deref_out LPDIRECTDRAWPALETTE *lplpDDPalette,__inout_opt IUnknown *pUnkOuter);

STDMETHODIMP CreateSurface(__in LPDDSURFACEDESC lpDDSurfaceDesc,__deref_out LPDIRECTDRAWSURFACE *lplpDDSurface,__inout_opt IUnknown *pUnkOuter);

STDMETHODIMP DuplicateSurface(__in LPDIRECTDRAWSURFACE lpDDSurface,__deref_out LPDIRECTDRAWSURFACE *lplpDupDDSurface);

STDMETHODIMP EnumDisplayModes(DWORD dwSurfaceDescCount,__in LPDDSURFACEDESC lplpDDSurfaceDescList,__in LPVOID lpContext,__in LPDDENUMMODESCALLBACK lpEnumCallback);

STDMETHODIMP EnumSurfaces(DWORD dwFlags,__in LPDDSURFACEDESC lpDDSD,__in LPVOID lpContext,__in LPDDENUMSURFACESCALLBACK lpEnumCallback);

STDMETHODIMP FlipToGDISurface();

STDMETHODIMP GetCaps(__out LPDDCAPS lpDDDriverCaps,__out LPDDCAPS lpDDHELCaps);

STDMETHODIMP GetDisplayMode(__out LPDDSURFACEDESC lpDDSurfaceDesc);

STDMETHODIMP GetFourCCCodes(__inout LPDWORD lpNumCodes,__out_ecount(*lpNumCodes) LPDWORD lpCodes);

STDMETHODIMP GetGDISurface(__deref_out LPDIRECTDRAWSURFACE *lplpGDIDDSurface);

STDMETHODIMP GetMonitorFrequency(__out LPDWORD lpdwFrequency);

STDMETHODIMP GetScanLine(__out LPDWORD lpdwScanLine);

STDMETHODIMP GetVerticalBlankStatus(__out LPBOOL lpblsInVB);

STDMETHODIMP Initialize(__in GUID *lpGUID);

STDMETHODIMP RestoreDisplayMode();

STDMETHODIMP SetCooperativeLevel(HWND hWnd,DWORD dwFlags);

STDMETHODIMP SetDisplayMode(DWORD dwWidth,DWORD dwHeight,DWORD dwBpp);

STDMETHODIMP WaitForVerticalBlank(DWORD dwFlags,HANDLE hEvent);

};

// Class that aggregates an IDirectDrawSurface interface

class CAggDrawSurface : public IDirectDrawSurface, public CUnknown

{

protected:

LPDIRECTDRAWSURFACE m_pDirectDrawSurface;

public:

DECLARE_IUNKNOWN

STDMETHODIMP NonDelegatingQueryInterface(REFIID riid,__deref_out void **ppv);

// Constructor and destructor

CAggDrawSurface(__in_opt LPCTSTR pName,__inout_opt LPUNKNOWN pUnk) :

CUnknown(pName,pUnk),

m_pDirectDrawSurface(NULL) { };

virtual ~CAggDrawSurface() { };

// Set the object we should be aggregating

void SetDirectDrawSurface(__inout LPDIRECTDRAWSURFACE pDirectDrawSurface) {

m_pDirectDrawSurface = pDirectDrawSurface;

}

// IDirectDrawSurface methods

STDMETHODIMP AddAttachedSurface(__in LPDIRECTDRAWSURFACE lpDDSAttachedSurface);

STDMETHODIMP AddOverlayDirtyRect(__in LPRECT lpRect);

STDMETHODIMP Blt(__in LPRECT lpDestRect,__in LPDIRECTDRAWSURFACE lpDDSrcSurface,__in LPRECT lpSrcRect,DWORD dwFlags,__in LPDDBLTFX lpDDBltFx);

STDMETHODIMP BltBatch(__in_ecount(dwCount) LPDDBLTBATCH lpDDBltBatch,DWORD dwCount,DWORD dwFlags);

STDMETHODIMP BltFast(DWORD dwX,DWORD dwY,__in LPDIRECTDRAWSURFACE lpDDSrcSurface,__in LPRECT lpSrcRect,DWORD dwTrans);

STDMETHODIMP DeleteAttachedSurface(DWORD dwFlags,__in LPDIRECTDRAWSURFACE lpDDSAttachedSurface);

STDMETHODIMP EnumAttachedSurfaces(__in LPVOID lpContext,__in LPDDENUMSURFACESCALLBACK lpEnumSurfacesCallback);

STDMETHODIMP EnumOverlayZOrders(DWORD dwFlags,__in LPVOID lpContext,__in LPDDENUMSURFACESCALLBACK lpfnCallback);

STDMETHODIMP Flip(__in LPDIRECTDRAWSURFACE lpDDSurfaceTargetOverride,DWORD dwFlags);

STDMETHODIMP GetAttachedSurface(__in LPDDSCAPS lpDDSCaps,__deref_out LPDIRECTDRAWSURFACE *lplpDDAttachedSurface);

STDMETHODIMP GetBltStatus(DWORD dwFlags);

STDMETHODIMP GetCaps(__out LPDDSCAPS lpDDSCaps);

STDMETHODIMP GetClipper(__deref_out LPDIRECTDRAWCLIPPER *lplpDDClipper);

STDMETHODIMP GetColorKey(DWORD dwFlags,__out LPDDCOLORKEY lpDDColorKey);

STDMETHODIMP GetDC(__out HDC *lphDC);

STDMETHODIMP GetFlipStatus(DWORD dwFlags);

STDMETHODIMP GetOverlayPosition(__out LPLONG lpdwX,__out LPLONG lpdwY);

STDMETHODIMP GetPalette(__deref_out LPDIRECTDRAWPALETTE *lplpDDPalette);

STDMETHODIMP GetPixelFormat(__out LPDDPIXELFORMAT lpDDPixelFormat);

STDMETHODIMP GetSurfaceDesc(__out LPDDSURFACEDESC lpDDSurfaceDesc);

STDMETHODIMP Initialize(__in LPDIRECTDRAW lpDD,__in LPDDSURFACEDESC lpDDSurfaceDesc);

STDMETHODIMP IsLost();

STDMETHODIMP Lock(__in LPRECT lpDestRect,__inout LPDDSURFACEDESC lpDDSurfaceDesc,DWORD dwFlags,HANDLE hEvent);

STDMETHODIMP ReleaseDC(HDC hDC);

STDMETHODIMP Restore();

STDMETHODIMP SetClipper(__in LPDIRECTDRAWCLIPPER lpDDClipper);

STDMETHODIMP SetColorKey(DWORD dwFlags,__in LPDDCOLORKEY lpDDColorKey);

STDMETHODIMP SetOverlayPosition(LONG dwX,LONG dwY);

STDMETHODIMP SetPalette(__in LPDIRECTDRAWPALETTE lpDDPalette);

STDMETHODIMP Unlock(__in LPVOID lpSurfaceData);

STDMETHODIMP UpdateOverlay(__in LPRECT lpSrcRect,__in LPDIRECTDRAWSURFACE lpDDDestSurface,__in LPRECT lpDestRect,DWORD dwFlags,__in LPDDOVERLAYFX lpDDOverlayFX);

STDMETHODIMP UpdateOverlayDisplay(DWORD dwFlags);

STDMETHODIMP UpdateOverlayZOrder(DWORD dwFlags,__in LPDIRECTDRAWSURFACE lpDDSReference);

};

class CLoadDirectDraw

{

LPDIRECTDRAW m_pDirectDraw; // The DirectDraw driver instance

HINSTANCE m_hDirectDraw; // Handle to the loaded library

public:

CLoadDirectDraw();

~CLoadDirectDraw();

HRESULT LoadDirectDraw(__in LPSTR szDevice);

void ReleaseDirectDraw();

HRESULT IsDirectDrawLoaded();

LPDIRECTDRAW GetDirectDraw();

BOOL IsDirectDrawVersion1();

};

#endif // __VIDEOCTL__

//------------------------------------------------------------------------------

// File: Measure.h

//

// Desc: DirectShow base classes.

//

// Copyright (c) 1992-2001 Microsoft Corporation. All rights reserved.

//------------------------------------------------------------------------------

/*

The idea is to pepper the source code with interesting measurements and

have the last few thousand of these recorded in a circular buffer that

can be post-processed to give interesting numbers.

WHAT THE LOG LOOKS LIKE:

Time (sec) Type Delta Incident_Name

0.055,41 NOTE -. Incident Nine - Another note

0.055,42 NOTE 0.000,01 Incident Nine - Another note

0.055,44 NOTE 0.000,02 Incident Nine - Another note

0.055,45 STOP -. Incident Eight - Also random

0.055,47 START -. Incident Seven - Random

0.055,49 NOTE 0.000,05 Incident Nine - Another note

------- <etc. there is a lot of this> ----------------

0.125,60 STOP 0.000,03 Msr_Stop

0.125,62 START -. Msr_Start

0.125,63 START -. Incident Two - Start/Stop

0.125,65 STOP 0.000,03 Msr_Start

0.125,66 START -. Msr_Stop

0.125,68 STOP 0.000,05 Incident Two - Start/Stop

0.125,70 STOP 0.000,04 Msr_Stop

0.125,72 START -. Msr_Start

0.125,73 START -. Incident Two - Start/Stop

0.125,75 STOP 0.000,03 Msr_Start

0.125,77 START -. Msr_Stop

0.125,78 STOP 0.000,05 Incident Two - Start/Stop

0.125,80 STOP 0.000,03 Msr_Stop

0.125,81 NOTE -. Incident Three - single Note

0.125,83 START -. Incident Four - Start, no stop

0.125,85 START -. Incident Five - Single Start/Stop

0.125,87 STOP 0.000,02 Incident Five - Single Start/Stop

Number Average StdDev Smallest Largest Incident_Name

10 0.000,58 0.000,10 0.000,55 0.000,85 Incident One - Note

50 0.000,05 0.000,00 0.000,05 0.000,05 Incident Two - Start/Stop

1 -. -. -. -. Incident Three - single Note

0 -. -. -. -. Incident Four - Start, no stop

1 0.000,02 -. 0.000,02 0.000,02 Incident Five - Single Start/Stop

0 -. -. -. -. Incident Six - zero occurrences

100 0.000,25 0.000,12 0.000,02 0.000,62 Incident Seven - Random

100 0.000,79 0.000,48 0.000,02 0.001,92 Incident Eight - Also random

5895 0.000,01 0.000,01 0.000,01 0.000,56 Incident Nine - Another note

10 0.000,03 0.000,00 0.000,03 0.000,04 Msr_Note

50 0.000,03 0.000,00 0.000,03 0.000,04 Msr_Start

50 0.000,04 0.000,03 0.000,03 0.000,31 Msr_Stop

WHAT IT MEANS:

The log shows what happened and when. Each line shows the time at which

something happened (see WHAT YOU CODE below) what it was that happened

and (if approporate) the time since the corresponding previous event

(that's the delta column).

The statistics show how many times each event occurred, what the average

delta time was, also the standard deviation, largest and smalles delta.

WHAT YOU CODE:

Before anything else executes: - register your ids

int id1 = Msr_Register("Incident One - Note");

int id2 = Msr_Register("Incident Two - Start/Stop");

int id3 = Msr_Register("Incident Three - single Note");

etc.

At interesting moments:

// To measure a repetitive event - e.g. end of bitblt to screen

Msr_Note(Id9); // e.g. "video frame hiting the screen NOW!"

or

// To measure an elapsed time e.g. time taken to decode an MPEG B-frame

Msr_Start(Id2); // e.g. "Starting to decode MPEG B-frame"

. . .

MsrStop(Id2); // "Finished MPEG decode"

At the end:

HANDLE hFile;

hFile = CreateFile("Perf.log", GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);

Msr_Dump(hFile); // This writes the log out to the file

CloseHandle(hFile);

or

Msr_Dump(NULL); // This writes it to DbgLog((LOG_TRACE,0, ... ));

// but if you are writing it out to the debugger

// then the times are probably all garbage because

// the debugger can make things run awfully slow.

A given id should be used either for start / stop or Note calls. If Notes

are mixed in with Starts and Stops their statistics will be gibberish.

If you code the calls in upper case i.e. MSR_START(idMunge); then you get

macros which will turn into nothing unless PERF is defined.

You can reset the statistical counts for a given id by calling Reset(Id).

They are reset by default at the start.

It logs Reset as a special incident, so you can see it in the log.

The log is a circular buffer in storage (to try to minimise disk I/O).

It overwrites the oldest entries once full. The statistics include ALL

incidents since the last Reset, whether still visible in the log or not.

*/

#ifndef __MEASURE__

#define __MEASURE__

#ifdef PERF

#define MSR_INIT() Msr_Init()

#define MSR_TERMINATE() Msr_Terminate()

#define MSR_REGISTER(a) Msr_Register(a)

#define MSR_RESET(a) Msr_Reset(a)

#define MSR_CONTROL(a) Msr_Control(a)

#define MSR_START(a) Msr_Start(a)

#define MSR_STOP(a) Msr_Stop(a)

#define MSR_NOTE(a) Msr_Note(a)

#define MSR_INTEGER(a,b) Msr_Integer(a,b)

#define MSR_DUMP(a) Msr_Dump(a)

#define MSR_DUMPSTATS(a) Msr_DumpStats(a)

#else

#define MSR_INIT() ((void)0)

#define MSR_TERMINATE() ((void)0)

#define MSR_REGISTER(a) 0

#define MSR_RESET(a) ((void)0)

#define MSR_CONTROL(a) ((void)0)

#define MSR_START(a) ((void)0)

#define MSR_STOP(a) ((void)0)

#define MSR_NOTE(a) ((void)0)

#define MSR_INTEGER(a,b) ((void)0)

#define MSR_DUMP(a) ((void)0)

#define MSR_DUMPSTATS(a) ((void)0)

#endif

#ifdef __cplusplus

extern "C" {

#endif

// This must be called first - (called by the DllEntry)

void WINAPI Msr_Init(void);

// Call this last to clean up (or just let it fall off the end - who cares?)

void WINAPI Msr_Terminate(void);

// Call this to get an Id for an "incident" that you can pass to Start, Stop or Note

// everything that's logged is called an "incident".

int WINAPI Msr_Register(__in LPTSTR Incident);

// Reset the statistical counts for an incident

void WINAPI Msr_Reset(int Id);

// Reset all the counts for all incidents

#define MSR_RESET_ALL 0

#define MSR_PAUSE 1

#define MSR_RUN 2

void WINAPI Msr_Control(int iAction);

// log the start of an operation

void WINAPI Msr_Start(int Id);

// log the end of an operation

void WINAPI Msr_Stop(int Id);

// log a one-off or repetitive operation

void WINAPI Msr_Note(int Id);

// log an integer (on which we can see statistics later)

void WINAPI Msr_Integer(int Id, int n);

// print out all the vaialable log (it may have wrapped) and then the statistics.

// When the log wraps you lose log but the statistics are still complete.

// hFIle==NULL => use DbgLog

// otherwise hFile must have come from CreateFile or OpenFile.

void WINAPI Msr_Dump(HANDLE hFile);

// just dump the statistics - never mind the log

void WINAPI Msr_DumpStats(HANDLE hFile);

// Type definitions in case you want to declare a pointer to the dump functions

// (makes it a trifle easier to do dynamic linking

// i.e. LoadModule, GetProcAddress and call that)

// Typedefs so can declare MSR_DUMPPROC *MsrDumpStats; or whatever

typedef void WINAPI MSR_DUMPPROC(HANDLE hFile);

typedef void WINAPI MSR_CONTROLPROC(int iAction);

#ifdef __cplusplus

}

#endif

#endif // __MEASURE__

//------------------------------------------------------------------------------

// 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