-

1 files changed, 0 insertions, 540 deletions

diff --git a/branches/1.0/thirdparties/win32/include/directshow/wxutil.h b/branches/1.0/thirdparties/win32/include/directshow/wxutil.h
deleted file mode 100644
index 9cf4ef5..0000000
--- a/branches/1.0/thirdparties/win32/include/directshow/wxutil.h
+++ /dev/null
@@ -1,540 +0,0 @@
-//------------------------------------------------------------------------------

-// File: WXUtil.h

-//

-// Desc: DirectShow base classes - defines helper classes and functions for

-//       building multimedia filters.

-//

-// Copyright (c) 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);

-

-    CRITICAL_SECTION m_CritSec;

-

-#ifdef DEBUG

-public:

-    DWORD   m_currentOwner;

-    DWORD   m_lockCount;

-    BOOL    m_fTrace;        // Trace this one

-public:

-    CCritSec();

-    ~CCritSec();

-    void Lock();

-    void Unlock();

-#else

-

-public:

-    CCritSec() {

-        InitializeCriticalSection(&m_CritSec);

-    };

-

-    ~CCritSec() {

-        DeleteCriticalSection(&m_CritSec);

-    };

-

-    void Lock() {

-        EnterCriticalSection(&m_CritSec);

-    };

-

-    void Unlock() {

-        LeaveCriticalSection(&m_CritSec);

-    };

-#endif

-};

-

-//

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

-#else

-    #define CritCheckIn(x) TRUE

-    #define CritCheckOut(x) TRUE

-    #define DbgLockTrace(pc, fT)

-#endif

-

-

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

-

-protected:

-    CCritSec * m_pLock;

-

-public:

-    CAutoLock(CCritSec * plock)

-    {

-        m_pLock = plock;

-        m_pLock->Lock();

-    };

-

-    ~CAutoLock() {

-        m_pLock->Unlock();

-    };

-};

-

-

-

-// wrapper for event objects

-class CAMEvent

-{

-

-    // make copy constructor and assignment operator inaccessible

-

-    CAMEvent(const CAMEvent &refEvent);

-    CAMEvent &operator=(const CAMEvent &refEvent);

-

-protected:

-    HANDLE m_hEvent;

-public:

-    CAMEvent(BOOL fManualReset = FALSE);

-    ~CAMEvent();

-

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

-{

-

-public:

-

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

-

-protected:

-    HANDLE m_hThread;

-

-    // thread will run this function on startup

-    // must be supplied by derived class

-    virtual DWORD ThreadProc() = 0;

-

-public:

-    CAMThread();

-    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(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() {

-        #pragma warning( push )

-        // C4312: 'type cast' : conversion from 'LONG' to 'PVOID' of greater size

-        //

-        // This code works correctly on 32-bit and 64-bit systems.

-        #pragma warning( disable : 4312 )

-        HANDLE hThread = (HANDLE)InterlockedExchangePointer(&m_hThread, 0);

-        #pragma warning( pop )

-

-        if (hThread) {

-            WaitForSingleObject(hThread, INFINITE);

-            CloseHandle(hThread);

-        }

-    };

-

-    // 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(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();

-};

-

-

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

-

-#define DEFAULT_QUEUESIZE   2

-

-template <class T> class CQueue {

-private:

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

-        InitializeCriticalSection(&CritSect);

-        hSemPut = CreateSemaphore(NULL, n, n, NULL);

-        hSemGet = CreateSemaphore(NULL, 0, n, NULL);

-        QueueObjects = new T[n];

-    }

-

-

-public:

-    CQueue(int n) {

-        Initialize(n);

-    }

-

-    CQueue() {

-        Initialize(DEFAULT_QUEUESIZE);

-    }

-

-    ~CQueue() {

-        delete [] QueueObjects;

-        DeleteCriticalSection(&CritSect);

-        CloseHandle(hSemPut);

-        CloseHandle(hSemGet);

-    }

-

-    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);

-

-        EnterCriticalSection(&CritSect);

-        iSlot = iNextGet++ % nMax;

-        Object = QueueObjects[iSlot];

-        LeaveCriticalSection(&CritSect);

-

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

-

-        EnterCriticalSection(&CritSect);

-        iSlot = iNextPut++ % nMax;

-        QueueObjects[iSlot] = Object;

-        LeaveCriticalSection(&CritSect);

-

-        // Release anyone waiting to remove an object from our queue as there

-        // is now an object available to be removed.

-        //

-        ReleaseSemaphore(hSemGet, 1L, &lPrevious);

-    }

-};

-

-// miscellaneous string conversion functions

-// NOTE: as we need to use the same binaries on Win95 as on NT this code should

-// be compiled WITHOUT unicode being defined.  Otherwise we will not pick up

-// these internal routines and the binary will not run on Win95.

-

-// int WINAPIV wsprintfWInternal(LPWSTR, LPCWSTR, ...);

-

-//LPWSTR

-//WINAPI

-//lstrcpyWInternal(

-//    LPWSTR lpString1,

-//    LPCWSTR lpString2

-//    );

-LPWSTR

-WINAPI

-lstrcpynWInternal(

-    LPWSTR lpString1,

-    LPCWSTR lpString2,

-    int     iMaxLength

-    );

-int

-WINAPI

-lstrcmpWInternal(

-    LPCWSTR lpString1,

-    LPCWSTR lpString2

-    );

-int

-WINAPI

-lstrcmpiWInternal(

-    LPCWSTR lpString1,

-    LPCWSTR lpString2

-    );

-int

-WINAPI

-lstrlenWInternal(

-    LPCWSTR lpString

-    );

-

-#ifndef UNICODE

-#define wsprintfW wsprintfWInternal

-#define lstrcpyW lstrcpyWInternal

-#define lstrcpynW lstrcpynWInternal

-#define lstrcmpW lstrcmpWInternal

-#define lstrcmpiW lstrcmpiWInternal

-#define lstrlenW lstrlenWInternal

-#endif

-

-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

-exit_memchr:

-    }

-    return pRet;

-

-#else

-    while ( cnt && (*(unsigned char *)buf != (unsigned char)chr) ) {

-        buf = (unsigned char *)buf + 1;

-        cnt--;

-    }

-

-    return(cnt ? (void *)buf : NULL);

-#endif

-}

-

-void WINAPI IntToWstr(int i, LPWSTR wstr, size_t len);

-

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

-#else

-#define GetSubtypeName GetSubtypeNameA

-#endif

-

-STDAPI_(LONG) GetBitmapFormatSize(const BITMAPINFOHEADER *pHeader);

-STDAPI_(DWORD) GetBitmapSize(const BITMAPINFOHEADER *pHeader);

-STDAPI_(BOOL) ContainsPalette(const VIDEOINFOHEADER *pVideoInfo);

-STDAPI_(const RGBQUAD *) GetBitmapPalette(const VIDEOINFOHEADER *pVideoInfo);

-

-

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

-LONGLONG WINAPI llMulDiv(LONGLONG a, LONGLONG b, LONGLONG c, LONGLONG rnd);

-LONGLONG WINAPI Int64x32Div32(LONGLONG a, LONG b, LONG c, LONG rnd);

-

-

-// Avoids us dyna-linking to SysAllocString to copy BSTR strings

-STDAPI WriteBSTR(BSTR * pstrDest, LPCWSTR szSrc);

-STDAPI FreeBSTR(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, 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(IUnknown** pp, IUnknown* lp);

-

-template <class T>

-class QzCComPtr

-{

-public:

-	typedef T _PtrClass;

-	QzCComPtr() {p=NULL;}

-	QzCComPtr(T* lp)

-	{

-		if ((p = lp) != NULL)

-			p->AddRef();

-	}

-	QzCComPtr(const QzCComPtr<T>& lp)

-	{

-		if ((p = lp.p) != NULL)

-			p->AddRef();

-	}

-	~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);}

-#else

-	BOOL operator!(){return (p == NULL) ? TRUE : FALSE;}

-#endif

-	T* p;

-};

-

-MMRESULT CompatibleTimeSetEvent( UINT uDelay, UINT uResolution, LPTIMECALLBACK lpTimeProc, DWORD_PTR dwUser, UINT fuEvent );

-bool TimeKillSynchronousFlagAvailable( void );

-

-#endif /* __WXUTIL__ */