blob: 305974a5f50c757bc3c0621980c6abcbf6abb082 [file] [log] [blame]
// File: WXUtil.h
// Desc: DirectShow base classes - defines helper classes and functions for
// building multimedia filters.
// Copyright (c) 1992-2001 Microsoft Corporation. All rights reserved.
#ifndef __WXUTIL__
#define __WXUTIL__
// eliminate spurious "statement has no effect" warnings.
#pragma warning(disable: 4705)
// wrapper for whatever critical section we have
class CCritSec {
// make copy constructor and assignment operator inaccessible
CCritSec(const CCritSec &refCritSec);
CCritSec &operator=(const CCritSec &refCritSec);
#ifdef DEBUG
DWORD m_currentOwner;
DWORD m_lockCount;
BOOL m_fTrace; // Trace this one
void Lock();
void Unlock();
CCritSec() {
~CCritSec() {
void Lock() {
void Unlock() {
// To make deadlocks easier to track it is useful to insert in the
// code an assertion that says whether we own a critical section or
// not. We make the routines that do the checking globals to avoid
// having different numbers of member functions in the debug and
// retail class implementations of CCritSec. In addition we provide
// a routine that allows usage of specific critical sections to be
// traced. This is NOT on by default - there are far too many.
#ifdef DEBUG
BOOL WINAPI CritCheckIn(CCritSec * pcCrit);
BOOL WINAPI CritCheckIn(const CCritSec * pcCrit);
BOOL WINAPI CritCheckOut(CCritSec * pcCrit);
BOOL WINAPI CritCheckOut(const CCritSec * pcCrit);
void WINAPI DbgLockTrace(CCritSec * pcCrit, BOOL fTrace);
#define CritCheckIn(x) TRUE
#define CritCheckOut(x) TRUE
#define DbgLockTrace(pc, fT)
// locks a critical section, and unlocks it automatically
// when the lock goes out of scope
class CAutoLock {
// make copy constructor and assignment operator inaccessible
CAutoLock(const CAutoLock &refAutoLock);
CAutoLock &operator=(const CAutoLock &refAutoLock);
CCritSec * m_pLock;
CAutoLock(CCritSec * plock)
m_pLock = plock;
~CAutoLock() {
// wrapper for event objects
class CAMEvent
// make copy constructor and assignment operator inaccessible
CAMEvent(const CAMEvent &refEvent);
CAMEvent &operator=(const CAMEvent &refEvent);
HANDLE m_hEvent;
CAMEvent(BOOL fManualReset = FALSE, __inout_opt HRESULT *phr = NULL);
CAMEvent(__inout_opt HRESULT *phr);
// Cast to HANDLE - we don't support this as an lvalue
operator HANDLE () const { return m_hEvent; };
void Set() {EXECUTE_ASSERT(SetEvent(m_hEvent));};
BOOL Wait(DWORD dwTimeout = INFINITE) {
return (WaitForSingleObject(m_hEvent, dwTimeout) == WAIT_OBJECT_0);
void Reset() { ResetEvent(m_hEvent); };
BOOL Check() { return Wait(0); };
// wrapper for event objects that do message processing
// This adds ONE method to the CAMEvent object to allow sent
// messages to be processed while waiting
class CAMMsgEvent : public CAMEvent
CAMMsgEvent(__inout_opt HRESULT *phr = NULL);
// Allow SEND messages to be processed while waiting
BOOL WaitMsg(DWORD dwTimeout = INFINITE);
// old name supported for the time being
#define CTimeoutEvent CAMEvent
// support for a worker thread
// simple thread class supports creation of worker thread, synchronization
// and communication. Can be derived to simplify parameter passing
class AM_NOVTABLE CAMThread {
// make copy constructor and assignment operator inaccessible
CAMThread(const CAMThread &refThread);
CAMThread &operator=(const CAMThread &refThread);
CAMEvent m_EventSend;
CAMEvent m_EventComplete;
DWORD m_dwParam;
DWORD m_dwReturnVal;
HANDLE m_hThread;
// thread will run this function on startup
// must be supplied by derived class
virtual DWORD ThreadProc() = 0;
CAMThread(__inout_opt HRESULT *phr = NULL);
virtual ~CAMThread();
CCritSec m_AccessLock; // locks access by client threads
CCritSec m_WorkerLock; // locks access to shared objects
// thread initially runs this. param is actually 'this'. function
// just gets this and calls ThreadProc
static DWORD WINAPI InitialThreadProc(__inout LPVOID pv);
// start thread running - error if already running
BOOL Create();
// signal the thread, and block for a response
DWORD CallWorker(DWORD);
// accessor thread calls this when done with thread (having told thread
// to exit)
void Close() {
// Disable warning: Conversion from LONG to PVOID of greater size
#pragma warning(push)
#pragma warning(disable: 4312)
HANDLE hThread = (HANDLE)InterlockedExchangePointer(&m_hThread, 0);
#pragma warning(pop)
if (hThread) {
WaitForSingleObject(hThread, INFINITE);
// ThreadExists
// Return TRUE if the thread exists. FALSE otherwise
BOOL ThreadExists(void) const
if (m_hThread == 0) {
return FALSE;
} else {
return TRUE;
// wait for the next request
DWORD GetRequest();
// is there a request?
BOOL CheckRequest(__out_opt DWORD * pParam);
// reply to the request
void Reply(DWORD);
// If you want to do WaitForMultipleObjects you'll need to include
// this handle in your wait list or you won't be responsive
HANDLE GetRequestHandle() const { return m_EventSend; };
// Find out what the request was
DWORD GetRequestParam() const { return m_dwParam; };
// call CoInitializeEx (COINIT_DISABLE_OLE1DDE) if
// available. S_FALSE means it's not available.
static HRESULT CoInitializeHelper();
#endif // AM_NOVTABLE
// CQueue
// Implements a simple Queue ADT. The queue contains a finite number of
// objects, access to which is controlled by a semaphore. The semaphore
// is created with an initial count (N). Each time an object is added
// a call to WaitForSingleObject is made on the semaphore's handle. When
// this function returns a slot has been reserved in the queue for the new
// object. If no slots are available the function blocks until one becomes
// available. Each time an object is removed from the queue ReleaseSemaphore
// is called on the semaphore's handle, thus freeing a slot in the queue.
// If no objects are present in the queue the function blocks until an
// object has been added.
template <class T> class CQueue {
HANDLE hSemPut; // Semaphore controlling queue "putting"
HANDLE hSemGet; // Semaphore controlling queue "getting"
CRITICAL_SECTION CritSect; // Thread seriallization
int nMax; // Max objects allowed in queue
int iNextPut; // Array index of next "PutMsg"
int iNextGet; // Array index of next "GetMsg"
T *QueueObjects; // Array of objects (ptr's to void)
void Initialize(int n) {
iNextPut = iNextGet = 0;
nMax = n;
hSemPut = CreateSemaphore(NULL, n, n, NULL);
hSemGet = CreateSemaphore(NULL, 0, n, NULL);
QueueObjects = new T[n];
CQueue(int n) {
CQueue() {
~CQueue() {
delete [] QueueObjects;
T GetQueueObject() {
int iSlot;
T Object;
LONG lPrevious;
// Wait for someone to put something on our queue, returns straight
// away is there is already an object on the queue.
WaitForSingleObject(hSemGet, INFINITE);
iSlot = iNextGet++ % nMax;
Object = QueueObjects[iSlot];
// Release anyone waiting to put an object onto our queue as there
// is now space available in the queue.
ReleaseSemaphore(hSemPut, 1L, &lPrevious);
return Object;
void PutQueueObject(T Object) {
int iSlot;
LONG lPrevious;
// Wait for someone to get something from our queue, returns straight
// away is there is already an empty slot on the queue.
WaitForSingleObject(hSemPut, INFINITE);
iSlot = iNextPut++ % nMax;
QueueObjects[iSlot] = Object;
// Release anyone waiting to remove an object from our queue as there
// is now an object available to be removed.
ReleaseSemaphore(hSemGet, 1L, &lPrevious);
// Ensures that memory is not read past the length source buffer
// and that memory is not written past the length of the dst buffer
// dst - buffer to copy to
// dst_size - total size of destination buffer
// cb_dst_offset - offset, first byte copied to dst+cb_dst_offset
// src - buffer to copy from
// src_size - total size of source buffer
// cb_src_offset - offset, first byte copied from src+cb_src_offset
// count - number of bytes to copy
// Returns:
// S_OK - no error
// E_INVALIDARG - values passed would lead to overrun
HRESULT AMSafeMemMoveOffset(
__in_bcount(dst_size) void * dst,
__in size_t dst_size,
__in DWORD cb_dst_offset,
__in_bcount(src_size) const void * src,
__in size_t src_size,
__in DWORD cb_src_offset,
__in size_t count);
extern "C"
void * __stdcall memmoveInternal(void *, const void *, size_t);
inline void * __cdecl memchrInternal(const void *buf, int chr, size_t cnt)
#ifdef _X86_
void *pRet = NULL;
_asm {
cld // make sure we get the direction right
mov ecx, cnt // num of bytes to scan
mov edi, buf // pointer byte stream
mov eax, chr // byte to scan for
repne scasb // look for the byte in the byte stream
jnz exit_memchr // Z flag set if byte found
dec edi // scasb always increments edi even when it
// finds the required byte
mov pRet, edi
return pRet;
while ( cnt && (*(unsigned char *)buf != (unsigned char)chr) ) {
buf = (unsigned char *)buf + 1;
return(cnt ? (void *)buf : NULL);
void WINAPI IntToWstr(int i, __out_ecount(12) LPWSTR wstr);
#define WstrToInt(sz) _wtoi(sz)
#define atoiW(sz) _wtoi(sz)
#define atoiA(sz) atoi(sz)
// These are available to help managing bitmap VIDEOINFOHEADER media structures
extern const DWORD bits555[3];
extern const DWORD bits565[3];
extern const DWORD bits888[3];
// These help convert between VIDEOINFOHEADER and BITMAPINFO structures
STDAPI_(const GUID) GetTrueColorType(const BITMAPINFOHEADER *pbmiHeader);
STDAPI_(const GUID) GetBitmapSubtype(const BITMAPINFOHEADER *pbmiHeader);
STDAPI_(WORD) GetBitCount(const GUID *pSubtype);
// strmbase.lib implements this for compatibility with people who
// managed to link to this directly. we don't want to advertise it.
// STDAPI_(/* T */ CHAR *) GetSubtypeName(const GUID *pSubtype);
STDAPI_(CHAR *) GetSubtypeNameA(const GUID *pSubtype);
STDAPI_(WCHAR *) GetSubtypeNameW(const GUID *pSubtype);
#ifdef UNICODE
#define GetSubtypeName GetSubtypeNameW
#define GetSubtypeName GetSubtypeNameA
STDAPI_(LONG) GetBitmapFormatSize(const BITMAPINFOHEADER *pHeader);
STDAPI_(DWORD) GetBitmapSize(const BITMAPINFOHEADER *pHeader);
#ifdef __AMVIDEO__
STDAPI_(BOOL) ContainsPalette(const VIDEOINFOHEADER *pVideoInfo);
STDAPI_(const RGBQUAD *) GetBitmapPalette(const VIDEOINFOHEADER *pVideoInfo);
#endif // __AMVIDEO__
// Compares two interfaces and returns TRUE if they are on the same object
BOOL WINAPI IsEqualObject(IUnknown *pFirst, IUnknown *pSecond);
// This is for comparing pins
#define EqualPins(pPin1, pPin2) IsEqualObject(pPin1, pPin2)
// Arithmetic helper functions
// Compute (a * b + rnd) / c
// Avoids us dyna-linking to SysAllocString to copy BSTR strings
STDAPI WriteBSTR(__deref_out BSTR * pstrDest, LPCWSTR szSrc);
STDAPI FreeBSTR(__deref_in BSTR* pstr);
// Return a wide string - allocating memory for it
// Returns:
// S_OK - no error
// E_POINTER - ppszReturn == NULL
// E_OUTOFMEMORY - can't allocate memory for returned string
STDAPI AMGetWideString(LPCWSTR pszString, __deref_out LPWSTR *ppszReturn);
// Special wait for objects owning windows
DWORD WINAPI WaitDispatchingMessages(
HANDLE hObject,
DWORD dwWait,
HWND hwnd = NULL,
UINT uMsg = 0,
HANDLE hEvent = NULL);
// HRESULT_FROM_WIN32 converts ERROR_SUCCESS to a success code, but in
// our use of HRESULT_FROM_WIN32, it typically means a function failed
// to call SetLastError(), and we still want a failure code.
#define AmHresultFromWin32(x) (MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, x))
// call GetLastError and return an HRESULT value that will fail the
// SUCCEEDED() macro.
HRESULT AmGetLastErrorToHResult(void);
// duplicate of ATL's CComPtr to avoid linker conflicts.
IUnknown* QzAtlComPtrAssign(__deref_inout_opt IUnknown** pp, __in_opt IUnknown* lp);
template <class T>
class QzCComPtr
typedef T _PtrClass;
QzCComPtr() {p=NULL;}
QzCComPtr(T* lp)
if ((p = lp) != NULL)
QzCComPtr(const QzCComPtr<T>& lp)
if ((p = lp.p) != NULL)
~QzCComPtr() {if (p) p->Release();}
void Release() {if (p) p->Release(); p=NULL;}
operator T*() {return (T*)p;}
T& operator*() {ASSERT(p!=NULL); return *p; }
//The assert on operator& usually indicates a bug. If this is really
//what is needed, however, take the address of the p member explicitly.
T** operator&() { ASSERT(p==NULL); return &p; }
T* operator->() { ASSERT(p!=NULL); return p; }
T* operator=(T* lp){return (T*)QzAtlComPtrAssign((IUnknown**)&p, lp);}
T* operator=(const QzCComPtr<T>& lp)
return (T*)QzAtlComPtrAssign((IUnknown**)&p, lp.p);
#if _MSC_VER>1020
bool operator!(){return (p == NULL);}
BOOL operator!(){return (p == NULL) ? TRUE : FALSE;}
T* p;
MMRESULT CompatibleTimeSetEvent( UINT uDelay, UINT uResolution, __in LPTIMECALLBACK lpTimeProc, DWORD_PTR dwUser, UINT fuEvent );
bool TimeKillSynchronousFlagAvailable( void );
// Helper to replace lstrcpmi
__inline int lstrcmpiLocaleIndependentW(LPCWSTR lpsz1, LPCWSTR lpsz2)
return CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, lpsz1, -1, lpsz2, -1) - CSTR_EQUAL;
__inline int lstrcmpiLocaleIndependentA(LPCSTR lpsz1, LPCSTR lpsz2)
return CompareStringA(LOCALE_INVARIANT, NORM_IGNORECASE, lpsz1, -1, lpsz2, -1) - CSTR_EQUAL;
#endif /* __WXUTIL__ */