753 lines
24 KiB
C++
753 lines
24 KiB
C++
// Copyright (c) 1996 - 1999 Microsoft Corporation. All Rights Reserved.
|
|
|
|
#ifndef __DYNLINK_H__
|
|
#define __DYNLINK_H__
|
|
|
|
// Add DYNLINKAVI to the class definition statement
|
|
// for all classes that use AVI/VFW function
|
|
// to enable dynamic linking to AVI. That, and #includ'ing this file
|
|
// should be the only thing you need to do
|
|
//
|
|
// For example:
|
|
// class CAVIDec : public CTransformFilter DYNLINKAVI DYNLINKVFW
|
|
//
|
|
// In the case where the filter is being built into its own DLL dynamic
|
|
// linking is not enabled and DYNLINKAVI is #define'd to nothing.
|
|
//
|
|
// If the class in which you want to use dynamic linking does not
|
|
// inherit from anything else use _DYNLINKAVI or _DYNLINKVFW
|
|
//
|
|
// For example:
|
|
// class CNoInherit : _DYNLINKAVI
|
|
// or
|
|
// class CNoInherit : _DYNLINKVFW
|
|
// or
|
|
// class CNoInterit : _DYNLINKVFW DYNLINKAVI //etc...
|
|
//
|
|
|
|
#define NODRAWDIB
|
|
#define NOAVIFMT
|
|
#include <vfw.h> // we need the avi definitions
|
|
#include <urlmon.h>
|
|
|
|
#ifdef FILTER_DLL
|
|
|
|
#define DYNLINKAVI
|
|
#define DYNLINKVFW
|
|
#define DYNLINKACM
|
|
#define DYNLINKURLMON
|
|
#define _DYNLINKAVI
|
|
#define _DYNLINKVFW
|
|
#define _DYNLINKACM
|
|
#define _DYNLINKURLMON
|
|
#else
|
|
|
|
// Add DYNLINKAVI at the end of the class definition statement
|
|
// for all classes that use AVI/VFW function
|
|
// to enable dynamic linking to AVI. That, and #includ'ing this file
|
|
// should be the only thing you need to do
|
|
|
|
// define string that will bind dynamic linking to the class definition
|
|
#define DYNLINKAVI , CAVIDynLink
|
|
#define DYNLINKVFW , CVFWDynLink
|
|
#define DYNLINKACM , CACMDynLink
|
|
#define DYNLINKURLMON , CURLMonDynLink
|
|
|
|
// for those classes that have no inheritance and still want dynamic linking
|
|
#define _DYNLINKAVI CAVIDynLink
|
|
#define _DYNLINKVFW CVFWDynLink
|
|
#define _DYNLINKACM CACMDynLink
|
|
#define _DYNLINKURLMON CURLMonDynLink
|
|
|
|
//
|
|
// typedef the AVIFILE API set that we redirect
|
|
//
|
|
|
|
typedef HRESULT (STDAPICALLTYPE *pAVIFileOpenW )(PAVIFILE FAR * ppfile, LPCWSTR szFile, UINT uMode, LPCLSID lpHandler);
|
|
typedef HRESULT (STDAPICALLTYPE *pAVIStreamRead)(PAVISTREAM pavi, LONG lStart, LONG lSamples, LPVOID lpBuffer, LONG cbBuffer, LONG FAR * plBytes, LONG FAR * plSamples);
|
|
typedef LONG (STDAPICALLTYPE *pAVIStreamStart) (PAVISTREAM pavi);
|
|
typedef LONG (STDAPICALLTYPE *pAVIStreamLength) (PAVISTREAM pavi);
|
|
typedef LONG (STDAPICALLTYPE *pAVIStreamTimeToSample)(PAVISTREAM pavi, LONG lTime);
|
|
typedef LONG (STDAPICALLTYPE *pAVIStreamSampleToTime)(PAVISTREAM pavi, LONG lSample);
|
|
typedef HRESULT (STDAPICALLTYPE *pAVIStreamBeginStreaming)(PAVISTREAM pavi, LONG lStart, LONG lEnd, LONG lRate);
|
|
typedef HRESULT (STDAPICALLTYPE *pAVIStreamEndStreaming)(PAVISTREAM pavi);
|
|
typedef LONG (STDAPICALLTYPE *pAVIStreamFindSample)(PAVISTREAM pavi, LONG lPos, LONG lFlags);
|
|
|
|
#undef AVIStreamEnd // sigh... nasty AVI macro
|
|
|
|
//
|
|
// Class to link dynamically to AVIFIL32.DLL entry points
|
|
//
|
|
|
|
class CAVIDynLink {
|
|
|
|
private:
|
|
static HMODULE m_hAVIFile32; // handle to AVIFIL32
|
|
static LONG m_dynlinkCount; // instance count for this process
|
|
static CRITICAL_SECTION m_LoadAVILock; // serialise constructor/destructor
|
|
|
|
public:
|
|
static void CAVIDynLinkLoad() {
|
|
InitializeCriticalSection(&CAVIDynLink::m_LoadAVILock); // serialise constructor/destructor
|
|
}
|
|
static void CAVIDynLinkUnload() {
|
|
DeleteCriticalSection(&CAVIDynLink::m_LoadAVILock); // serialise constructor/destructor
|
|
}
|
|
|
|
static void AVIFileInit(void);
|
|
static void AVIFileExit(void);
|
|
static HRESULT AVIFileOpenW (PAVIFILE FAR * ppfile, LPCWSTR szFile,
|
|
UINT uMode, LPCLSID lpHandler);
|
|
|
|
static HRESULT AVIStreamRead(PAVISTREAM pavi,
|
|
LONG lStart,
|
|
LONG lSamples,
|
|
LPVOID lpBuffer,
|
|
LONG cbBuffer,
|
|
LONG FAR * plBytes,
|
|
LONG FAR * plSamples)
|
|
{
|
|
return(pavi->Read(lStart, lSamples, lpBuffer, cbBuffer, plBytes, plSamples));
|
|
}
|
|
|
|
static LONG AVIStreamStart(PAVISTREAM pavi)
|
|
{
|
|
AVISTREAMINFOW aviStreamInfo;
|
|
HRESULT hr;
|
|
hr = pavi->Info(&aviStreamInfo, sizeof(aviStreamInfo));
|
|
if (hr!=NOERROR) {
|
|
aviStreamInfo.dwStart=0;
|
|
}
|
|
return(LONG)aviStreamInfo.dwStart;
|
|
//return(((pAVIStreamStart)aAVIEntries[indxAVIStreamStart])(pavi));
|
|
}
|
|
|
|
static LONG AVIStreamLength(PAVISTREAM pavi)
|
|
{
|
|
AVISTREAMINFOW aviStreamInfo;
|
|
HRESULT hr;
|
|
hr = pavi->Info(&aviStreamInfo, sizeof(aviStreamInfo));
|
|
if (hr!=NOERROR) {
|
|
aviStreamInfo.dwLength=1;
|
|
}
|
|
return (LONG)aviStreamInfo.dwLength;
|
|
//return(((pAVIStreamLength)aAVIEntries[indxAVIStreamLength])(pavi));
|
|
}
|
|
|
|
/*static*/ LONG AVIStreamTimeToSample (PAVISTREAM pavi, LONG lTime);
|
|
/*static*/ LONG AVIStreamSampleToTime (PAVISTREAM pavi, LONG lSample);
|
|
/*static*/ HRESULT AVIStreamBeginStreaming(PAVISTREAM pavi, LONG lStart, LONG lEnd, LONG lRate);
|
|
/*static*/ HRESULT AVIStreamEndStreaming(PAVISTREAM pavi);
|
|
|
|
static LONG AVIStreamFindSample(PAVISTREAM pavi, LONG lPos, LONG lFlags)
|
|
{
|
|
// The use of AVIStreamFindSample within Quartz ALWAYS set the type
|
|
// and direction
|
|
ASSERT(lFlags & FIND_TYPE);
|
|
ASSERT(lFlags & FIND_DIR);
|
|
|
|
return(pavi->FindSample(lPos, lFlags));
|
|
//return(((pAVIStreamFindSample)aAVIEntries[indxAVIStreamFindSample])(pavi));
|
|
}
|
|
|
|
static LONG AVIStreamEnd(PAVISTREAM pavi)
|
|
{
|
|
AVISTREAMINFOW aviStreamInfo;
|
|
HRESULT hr;
|
|
hr = pavi->Info(&aviStreamInfo, sizeof(aviStreamInfo));
|
|
if (hr!=NOERROR) {
|
|
aviStreamInfo.dwStart=0;
|
|
aviStreamInfo.dwLength=1;
|
|
}
|
|
return (LONG)aviStreamInfo.dwLength + (LONG)aviStreamInfo.dwStart;
|
|
//return(((pAVIStreamStart)aAVIEntries[indxAVIStreamStart])(pavi)
|
|
// + ((pAVIStreamLength)aAVIEntries[indxAVIStreamLength])(pavi));
|
|
}
|
|
|
|
|
|
CAVIDynLink();
|
|
~CAVIDynLink();
|
|
|
|
private:
|
|
|
|
// make copy and assignment inaccessible
|
|
CAVIDynLink(const CAVIDynLink &refAVIDynLink);
|
|
CAVIDynLink &operator=(const CAVIDynLink &refAVIDynLink);
|
|
};
|
|
|
|
//
|
|
// Class for dynamic linking to MSVFW32.DLL
|
|
//
|
|
// Most of the IC API set are macros that call ICSendMessage. There are
|
|
// a couple of awkward ones that we expand inline.
|
|
//
|
|
|
|
|
|
//
|
|
// Dynamically loaded array of entry points
|
|
//
|
|
extern FARPROC aVFWEntries[];
|
|
|
|
//
|
|
// List of index entries into the array for each redirected API
|
|
//
|
|
#define indxICClose 0
|
|
#define indxICSendMessage 1
|
|
#define indxICLocate 2
|
|
#define indxICOpen 3
|
|
#define indxICInfo 4
|
|
#define indxICGetInfo 5
|
|
|
|
|
|
//
|
|
// typedef the API set that we redirect
|
|
//
|
|
|
|
typedef LRESULT (WINAPI *pICClose)(HIC hic);
|
|
typedef HIC (WINAPI *pICLocate)(DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut, WORD wFlags);
|
|
typedef LRESULT (WINAPI *pICSendMessage)(HIC hic, UINT msg, DWORD_PTR dw1, DWORD_PTR dw2);
|
|
typedef HIC (VFWAPI *pICOpen)(DWORD fccType, DWORD fccHandler, UINT wMode);
|
|
typedef BOOL (VFWAPI *pICInfo)(DWORD fccType, DWORD fccHandler, ICINFO FAR* lpicinfo);
|
|
typedef BOOL (VFWAPI *pICGetInfo)(HIC hic, ICINFO FAR* lpicinfo, DWORD cb);
|
|
|
|
class CVFWDynLink {
|
|
|
|
private:
|
|
static HMODULE m_hVFW; // handle to MSVFW32
|
|
static LONG m_vfwlinkCount; // instance count for this process
|
|
static CRITICAL_SECTION m_LoadVFWLock; // serialise constructor/destructor
|
|
|
|
public:
|
|
static void CVFWDynLinkLoad()
|
|
{
|
|
InitializeCriticalSection(&m_LoadVFWLock); // serialise constructor/destructor
|
|
}
|
|
static void CVFWDynLinkUnload()
|
|
{
|
|
DeleteCriticalSection(&m_LoadVFWLock); // serialise constructor/destructor
|
|
}
|
|
|
|
static DWORD_PTR ICDecompress(
|
|
HIC hic,
|
|
DWORD dwFlags, // flags (from AVI index...)
|
|
LPBITMAPINFOHEADER lpbiFormat, // BITMAPINFO of compressed data
|
|
// biSizeImage has the chunk size
|
|
// biCompression has the ckid (AVI only)
|
|
LPVOID lpData, // data
|
|
LPBITMAPINFOHEADER lpbi, // DIB to decompress to
|
|
LPVOID lpBits)
|
|
{
|
|
ICDECOMPRESS icd;
|
|
icd.dwFlags = dwFlags;
|
|
icd.lpbiInput = lpbiFormat;
|
|
icd.lpInput = lpData;
|
|
|
|
icd.lpbiOutput = lpbi;
|
|
icd.lpOutput = lpBits;
|
|
icd.ckid = 0;
|
|
return ICSendMessage(hic, ICM_DECOMPRESS, (DWORD_PTR)(LPVOID)&icd, sizeof(ICDECOMPRESS));
|
|
}
|
|
|
|
static LRESULT CVFWDynLink::ICClose(HIC hic)
|
|
{
|
|
return((((pICClose)aVFWEntries[indxICClose]))(hic));
|
|
}
|
|
|
|
static HIC ICLocate(DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut, WORD wFlags)
|
|
{
|
|
return((((pICLocate)aVFWEntries[indxICLocate]))(fccType, fccHandler, lpbiIn, lpbiOut, wFlags));
|
|
}
|
|
|
|
|
|
static LRESULT ICSendMessage(HIC hic, UINT msg, DWORD_PTR dw1, DWORD_PTR dw2)
|
|
{
|
|
return((((pICSendMessage)aVFWEntries[indxICSendMessage]))(hic, msg, dw1, dw2));
|
|
}
|
|
|
|
static HIC ICOpen(DWORD fccType, DWORD fccHandler, UINT wMode)
|
|
{
|
|
return((((pICOpen)aVFWEntries[indxICOpen]))(fccType, fccHandler, wMode));
|
|
}
|
|
|
|
static BOOL ICInfo(DWORD fccType, DWORD fccHandler, ICINFO* lpicinfo)
|
|
{
|
|
return((((pICInfo)aVFWEntries[indxICInfo]))(fccType, fccHandler, lpicinfo));
|
|
}
|
|
|
|
static BOOL ICGetInfo(HIC hic, ICINFO* lpicinfo, DWORD cb)
|
|
{
|
|
return((((pICGetInfo)aVFWEntries[indxICGetInfo]))(hic, lpicinfo, cb));
|
|
}
|
|
|
|
static LRESULT ICDecompressEx(
|
|
HIC hic,
|
|
DWORD dwFlags,
|
|
LPBITMAPINFOHEADER lpbiSrc,
|
|
LPVOID lpSrc,
|
|
int xSrc,int ySrc,int dxSrc,int dySrc,LPBITMAPINFOHEADER lpbiDst,
|
|
LPVOID lpDst,
|
|
int xDst,int yDst,int dxDst,int dyDst)
|
|
{
|
|
ICDECOMPRESSEX ic;
|
|
|
|
ic.dwFlags = dwFlags;
|
|
ic.lpbiSrc = lpbiSrc;
|
|
ic.lpSrc = lpSrc;
|
|
ic.xSrc = xSrc;
|
|
ic.ySrc = ySrc;
|
|
ic.dxSrc = dxSrc;
|
|
ic.dySrc = dySrc;
|
|
ic.lpbiDst = lpbiDst;
|
|
ic.lpDst = lpDst;
|
|
ic.xDst = xDst;
|
|
ic.yDst = yDst;
|
|
ic.dxDst = dxDst;
|
|
ic.dyDst = dyDst;
|
|
|
|
// note that ICM swaps round the length and pointer
|
|
// length in lparam2, pointer in lparam1
|
|
return ICSendMessage(hic, ICM_DECOMPRESSEX, (DWORD_PTR)&ic, sizeof(ic));
|
|
}
|
|
|
|
static LRESULT ICDecompressExQuery(
|
|
HIC hic,
|
|
DWORD dwFlags,
|
|
LPBITMAPINFOHEADER lpbiSrc,
|
|
LPVOID lpSrc,
|
|
int xSrc,int ySrc,int dxSrc,int dySrc,
|
|
LPBITMAPINFOHEADER lpbiDst,
|
|
LPVOID lpDst,
|
|
int xDst,int yDst,int dxDst,int dyDst)
|
|
{
|
|
ICDECOMPRESSEX ic;
|
|
|
|
ic.dwFlags = dwFlags;
|
|
ic.lpbiSrc = lpbiSrc;
|
|
ic.lpSrc = lpSrc;
|
|
ic.xSrc = xSrc;
|
|
ic.ySrc = ySrc;
|
|
ic.dxSrc = dxSrc;
|
|
ic.dySrc = dySrc;
|
|
ic.lpbiDst = lpbiDst;
|
|
ic.lpDst = lpDst;
|
|
ic.xDst = xDst;
|
|
ic.yDst = yDst;
|
|
ic.dxDst = dxDst;
|
|
ic.dyDst = dyDst;
|
|
|
|
// note that ICM swaps round the length and pointer
|
|
// length in lparam2, pointer in lparam1
|
|
return ICSendMessage(hic, ICM_DECOMPRESSEX_QUERY, (DWORD_PTR)&ic, sizeof(ic));
|
|
}
|
|
|
|
static LRESULT ICDecompressExBegin(
|
|
HIC hic,
|
|
DWORD dwFlags,
|
|
LPBITMAPINFOHEADER lpbiSrc,
|
|
LPVOID lpSrc,
|
|
int xSrc,int ySrc,int dxSrc,int dySrc,
|
|
LPBITMAPINFOHEADER lpbiDst,
|
|
LPVOID lpDst,
|
|
int xDst,int yDst,int dxDst,int dyDst)
|
|
{
|
|
ICDECOMPRESSEX ic;
|
|
|
|
ic.dwFlags = dwFlags;
|
|
ic.lpbiSrc = lpbiSrc;
|
|
ic.lpSrc = lpSrc;
|
|
ic.xSrc = xSrc;
|
|
ic.ySrc = ySrc;
|
|
ic.dxSrc = dxSrc;
|
|
ic.dySrc = dySrc;
|
|
ic.lpbiDst = lpbiDst;
|
|
ic.lpDst = lpDst;
|
|
ic.xDst = xDst;
|
|
ic.yDst = yDst;
|
|
ic.dxDst = dxDst;
|
|
ic.dyDst = dyDst;
|
|
|
|
// note that ICM swaps round the length and pointer
|
|
// length in lparam2, pointer in lparam1
|
|
return ICSendMessage(hic, ICM_DECOMPRESSEX_BEGIN, (DWORD_PTR)&ic, sizeof(ic));
|
|
}
|
|
|
|
static DWORD_PTR VFWAPIV ICDrawBegin(
|
|
HIC hic,
|
|
DWORD dwFlags, // flags
|
|
HPALETTE hpal, // palette to draw with
|
|
HWND hwnd, // window to draw to
|
|
HDC hdc, // HDC to draw to
|
|
int xDst, // destination rectangle
|
|
int yDst,
|
|
int dxDst,
|
|
int dyDst,
|
|
LPBITMAPINFOHEADER lpbi, // format of frame to draw
|
|
int xSrc, // source rectangle
|
|
int ySrc,
|
|
int dxSrc,
|
|
int dySrc,
|
|
DWORD dwRate, // frames/second = (dwRate/dwScale)
|
|
DWORD dwScale)
|
|
{
|
|
ICDRAWBEGIN icdraw;
|
|
icdraw.dwFlags = dwFlags;
|
|
icdraw.hpal = hpal;
|
|
icdraw.hwnd = hwnd;
|
|
icdraw.hdc = hdc;
|
|
icdraw.xDst = xDst;
|
|
icdraw.yDst = yDst;
|
|
icdraw.dxDst = dxDst;
|
|
icdraw.dyDst = dyDst;
|
|
icdraw.lpbi = lpbi;
|
|
icdraw.xSrc = xSrc;
|
|
icdraw.ySrc = ySrc;
|
|
icdraw.dxSrc = dxSrc;
|
|
icdraw.dySrc = dySrc;
|
|
icdraw.dwRate = dwRate;
|
|
icdraw.dwScale = dwScale;
|
|
|
|
return ICSendMessage(hic, ICM_DRAW_BEGIN, (DWORD_PTR)(LPVOID)&icdraw, sizeof(ICDRAWBEGIN));
|
|
}
|
|
|
|
static DWORD_PTR VFWAPIV ICDraw(
|
|
HIC hic,
|
|
DWORD dwFlags, // flags
|
|
LPVOID lpFormat, // format of frame to decompress
|
|
LPVOID lpData, // frame data to decompress
|
|
DWORD cbData, // size in bytes of data
|
|
LONG lTime) // time to draw this frame (see drawbegin dwRate and dwScale)
|
|
{
|
|
ICDRAW icdraw;
|
|
icdraw.dwFlags = dwFlags;
|
|
icdraw.lpFormat = lpFormat;
|
|
icdraw.lpData = lpData;
|
|
icdraw.cbData = cbData;
|
|
icdraw.lTime = lTime;
|
|
|
|
return ICSendMessage(hic, ICM_DRAW, (DWORD_PTR)(LPVOID)&icdraw, sizeof(ICDRAW));
|
|
}
|
|
|
|
CVFWDynLink();
|
|
~CVFWDynLink();
|
|
|
|
private:
|
|
|
|
// make copy and assignment inaccessible
|
|
CVFWDynLink(const CVFWDynLink &refVFWDynLink);
|
|
CVFWDynLink &operator=(const CVFWDynLink &refVFWDynLink);
|
|
};
|
|
|
|
|
|
//
|
|
// Class for dynamic linking to MSACM32.DLL
|
|
//
|
|
|
|
|
|
//
|
|
// Dynamically loaded array of entry points
|
|
//
|
|
extern FARPROC aACMEntries[];
|
|
|
|
//
|
|
// List of index entries into the array for each redirected API
|
|
//
|
|
#define indxacmStreamConvert 0
|
|
#define indxacmStreamSize 1
|
|
#define indxacmStreamPrepareHeader 2
|
|
#define indxacmMetrics 3
|
|
#define indxacmStreamUnprepareHeader 4
|
|
#define indxacmStreamOpen 5
|
|
#define indxacmFormatSuggest 6
|
|
#define indxacmStreamClose 7
|
|
#ifdef UNICODE
|
|
# define indxacmFormatEnumW 8
|
|
#else
|
|
# define indxacmFormatEnumA 8
|
|
#endif
|
|
|
|
|
|
//
|
|
// typedef the API set that we redirect
|
|
//
|
|
|
|
typedef MMRESULT (ACMAPI *pacmStreamConvert)(HACMSTREAM has, LPACMSTREAMHEADER pash, DWORD fdwConvert);
|
|
typedef MMRESULT (ACMAPI *pacmStreamSize)
|
|
(
|
|
HACMSTREAM has,
|
|
DWORD cbInput,
|
|
LPDWORD pdwOutputBytes,
|
|
DWORD fdwSize
|
|
);
|
|
typedef MMRESULT (ACMAPI *pacmStreamPrepareHeader)
|
|
(
|
|
HACMSTREAM has,
|
|
LPACMSTREAMHEADER pash,
|
|
DWORD fdwPrepare
|
|
);
|
|
typedef MMRESULT (ACMAPI *pacmMetrics)
|
|
(
|
|
HACMOBJ hao,
|
|
UINT uMetric,
|
|
LPVOID pMetric
|
|
);
|
|
typedef MMRESULT (ACMAPI *pacmStreamUnprepareHeader)
|
|
(
|
|
HACMSTREAM has,
|
|
LPACMSTREAMHEADER pash,
|
|
DWORD fdwUnprepare
|
|
);
|
|
typedef MMRESULT (ACMAPI *pacmStreamOpen)
|
|
(
|
|
LPHACMSTREAM phas, // pointer to stream handle
|
|
HACMDRIVER had, // optional driver handle
|
|
LPWAVEFORMATEX pwfxSrc, // source format to convert
|
|
LPWAVEFORMATEX pwfxDst, // required destination format
|
|
LPWAVEFILTER pwfltr, // optional filter
|
|
DWORD_PTR dwCallback, // callback
|
|
DWORD_PTR dwInstance, // callback instance data
|
|
DWORD fdwOpen // ACM_STREAMOPENF_* and CALLBACK_*
|
|
);
|
|
typedef MMRESULT (ACMAPI *pacmFormatSuggest)
|
|
(
|
|
HACMDRIVER had,
|
|
LPWAVEFORMATEX pwfxSrc,
|
|
LPWAVEFORMATEX pwfxDst,
|
|
DWORD cbwfxDst,
|
|
DWORD fdwSuggest
|
|
);
|
|
typedef MMRESULT (ACMAPI *pacmStreamClose)
|
|
(
|
|
HACMSTREAM has,
|
|
DWORD fdwClose
|
|
);
|
|
typedef MMRESULT (ACMAPI *pacmFormatEnumA)
|
|
(
|
|
HACMDRIVER had,
|
|
LPACMFORMATDETAILSA pafd,
|
|
ACMFORMATENUMCBA fnCallback,
|
|
DWORD_PTR dwInstance,
|
|
DWORD fdwEnum
|
|
);
|
|
|
|
typedef MMRESULT (ACMAPI *pacmFormatEnumW)
|
|
(
|
|
HACMDRIVER had,
|
|
LPACMFORMATDETAILSW pafd,
|
|
ACMFORMATENUMCBW fnCallback,
|
|
DWORD_PTR dwInstance,
|
|
DWORD fdwEnum
|
|
);
|
|
|
|
|
|
class CACMDynLink {
|
|
|
|
private:
|
|
static HMODULE m_hACM; // handle to MSVFW32
|
|
static LONG m_ACMlinkCount; // instance count for this process
|
|
static CRITICAL_SECTION m_LoadACMLock; // serialise constructor/destructor
|
|
|
|
public:
|
|
static void CACMDynLinkLoad()
|
|
{
|
|
InitializeCriticalSection(&m_LoadACMLock); // serialise constructor/destructor
|
|
}
|
|
static void CACMDynLinkUnload()
|
|
{
|
|
DeleteCriticalSection(&m_LoadACMLock); // serialise constructor/destructor
|
|
}
|
|
|
|
static MMRESULT ACMAPI acmStreamConvert(HACMSTREAM has, LPACMSTREAMHEADER pash, DWORD fdwConvert)
|
|
{
|
|
return((((pacmStreamConvert)aACMEntries[indxacmStreamConvert]))(has, pash, fdwConvert));
|
|
}
|
|
|
|
static MMRESULT ACMAPI acmStreamSize
|
|
(
|
|
HACMSTREAM has,
|
|
DWORD cbInput,
|
|
LPDWORD pdwOutputBytes,
|
|
DWORD fdwSize
|
|
)
|
|
{
|
|
return((((pacmStreamSize)aACMEntries[indxacmStreamSize]))(has, cbInput, pdwOutputBytes, fdwSize));
|
|
}
|
|
|
|
|
|
static MMRESULT ACMAPI acmStreamPrepareHeader
|
|
(
|
|
HACMSTREAM has,
|
|
LPACMSTREAMHEADER pash,
|
|
DWORD fdwPrepare
|
|
)
|
|
{
|
|
return((((pacmStreamPrepareHeader)aACMEntries[indxacmStreamPrepareHeader]))(has, pash, fdwPrepare));
|
|
}
|
|
|
|
static MMRESULT ACMAPI acmMetrics
|
|
(
|
|
HACMOBJ hao,
|
|
UINT uMetric,
|
|
LPVOID pMetric
|
|
)
|
|
{
|
|
return((((pacmMetrics)aACMEntries[indxacmMetrics]))(hao, uMetric, pMetric));
|
|
}
|
|
|
|
static MMRESULT ACMAPI acmStreamUnprepareHeader
|
|
(
|
|
HACMSTREAM has,
|
|
LPACMSTREAMHEADER pash,
|
|
DWORD fdwUnprepare
|
|
)
|
|
{
|
|
return((((pacmStreamUnprepareHeader)aACMEntries[indxacmStreamUnprepareHeader]))(has, pash, fdwUnprepare));
|
|
}
|
|
|
|
static MMRESULT ACMAPI acmStreamOpen
|
|
(
|
|
LPHACMSTREAM phas, // pointer to stream handle
|
|
HACMDRIVER had, // optional driver handle
|
|
LPWAVEFORMATEX pwfxSrc, // source format to convert
|
|
LPWAVEFORMATEX pwfxDst, // required destination format
|
|
LPWAVEFILTER pwfltr, // optional filter
|
|
DWORD_PTR dwCallback, // callback
|
|
DWORD_PTR dwInstance, // callback instance data
|
|
DWORD fdwOpen // ACM_STREAMOPENF_* and CALLBACK_*
|
|
)
|
|
{
|
|
return((((pacmStreamOpen)aACMEntries[indxacmStreamOpen]))(phas,had,pwfxSrc,pwfxDst,pwfltr,dwCallback,dwInstance,fdwOpen));
|
|
}
|
|
|
|
static MMRESULT ACMAPI acmFormatSuggest
|
|
(
|
|
HACMDRIVER had,
|
|
LPWAVEFORMATEX pwfxSrc,
|
|
LPWAVEFORMATEX pwfxDst,
|
|
DWORD cbwfxDst,
|
|
DWORD fdwSuggest
|
|
)
|
|
{
|
|
return((((pacmFormatSuggest)aACMEntries[indxacmFormatSuggest]))(had, pwfxSrc, pwfxDst, cbwfxDst, fdwSuggest));
|
|
}
|
|
|
|
static MMRESULT ACMAPI acmStreamClose
|
|
(
|
|
HACMSTREAM has,
|
|
DWORD fdwClose
|
|
)
|
|
{
|
|
return((((pacmStreamClose)aACMEntries[indxacmStreamClose]))(has, fdwClose));
|
|
}
|
|
|
|
#ifdef UNICODE
|
|
static MMRESULT ACMAPI acmFormatEnumW
|
|
(
|
|
HACMDRIVER had,
|
|
LPACMFORMATDETAILSW pafd,
|
|
ACMFORMATENUMCBW fnCallback,
|
|
DWORD_PTR dwInstance,
|
|
DWORD fdwEnum
|
|
)
|
|
{
|
|
return((((pacmFormatEnumW)aACMEntries[indxacmFormatEnumW]))(had,pafd,fnCallback,dwInstance,fdwEnum));
|
|
}
|
|
#else
|
|
static MMRESULT ACMAPI acmFormatEnumA
|
|
(
|
|
HACMDRIVER had,
|
|
LPACMFORMATDETAILSA pafd,
|
|
ACMFORMATENUMCBA fnCallback,
|
|
DWORD_PTR dwInstance,
|
|
DWORD fdwEnum
|
|
)
|
|
{
|
|
return((((pacmFormatEnumA)aACMEntries[indxacmFormatEnumA]))(had,pafd,fnCallback,dwInstance,fdwEnum));
|
|
}
|
|
#endif
|
|
|
|
CACMDynLink();
|
|
~CACMDynLink();
|
|
|
|
private:
|
|
|
|
// make copy and assignment inaccessible
|
|
CACMDynLink(const CVFWDynLink &refVFWDynLink);
|
|
CACMDynLink &operator=(const CVFWDynLink &refVFWDynLink);
|
|
};
|
|
|
|
|
|
//
|
|
// Class for dynamic linking to URLMON.DLL
|
|
//
|
|
//
|
|
// Dynamically loaded array of entry points
|
|
//
|
|
extern FARPROC aURLMonEntries[];
|
|
|
|
//
|
|
// List of index entries into the array for each redirected API
|
|
//
|
|
#define indxurlmonCreateURLMoniker 0
|
|
#define indxurlmonRegisterCallback 1
|
|
#define indxurlmonRevokeCallback 2
|
|
|
|
//
|
|
// typedef the API set that we redirect
|
|
//
|
|
|
|
|
|
typedef HRESULT (STDAPICALLTYPE * pCreateURLMoniker) (LPMONIKER pMkCtx, LPCWSTR szURL, LPMONIKER FAR * ppmk);
|
|
typedef HRESULT (STDAPICALLTYPE * pRegisterBindStatusCallback)(LPBC pBC, IBindStatusCallback *pBSCb,
|
|
IBindStatusCallback** ppBSCBPrev, DWORD dwReserved);
|
|
typedef HRESULT (STDAPICALLTYPE * pRevokeBindStatusCallback)(LPBC pBC, IBindStatusCallback *pBSCb);
|
|
|
|
|
|
class CURLMonDynLink {
|
|
|
|
private:
|
|
static HMODULE m_hURLMon; // handle to URLMON
|
|
static LONG m_URLMonlinkCount; // instance count for this process
|
|
static CRITICAL_SECTION m_LoadURLMonLock; // serialise constructor/destructor
|
|
|
|
public:
|
|
static void CURLMonDynLinkLoad()
|
|
{
|
|
InitializeCriticalSection(&m_LoadURLMonLock); // serialise constructor/destructor
|
|
}
|
|
static void CURLMonDynLinkUnload()
|
|
{
|
|
DeleteCriticalSection(&m_LoadURLMonLock); // serialise constructor/destructor
|
|
}
|
|
|
|
static HRESULT STDAPICALLTYPE CreateURLMoniker (LPMONIKER pMkCtx, LPCWSTR szURL, LPMONIKER FAR * ppmk)
|
|
{
|
|
return((((pCreateURLMoniker)aURLMonEntries[indxurlmonCreateURLMoniker]))
|
|
(pMkCtx, szURL, ppmk));
|
|
}
|
|
|
|
static HRESULT STDAPICALLTYPE RegisterBindStatusCallback (LPBC pBC, IBindStatusCallback *pBSCb,
|
|
IBindStatusCallback** ppBSCBPrev, DWORD dwReserved)
|
|
{
|
|
return((((pRegisterBindStatusCallback)aURLMonEntries[indxurlmonRegisterCallback]))
|
|
(pBC, pBSCb, ppBSCBPrev, dwReserved));
|
|
}
|
|
static HRESULT STDAPICALLTYPE RevokeBindStatusCallback (LPBC pBC, IBindStatusCallback *pBSCb)
|
|
{
|
|
return((((pRevokeBindStatusCallback)aURLMonEntries[indxurlmonRevokeCallback]))
|
|
(pBC, pBSCb));
|
|
}
|
|
|
|
CURLMonDynLink();
|
|
~CURLMonDynLink();
|
|
|
|
private:
|
|
|
|
// make copy and assignment inaccessible
|
|
CURLMonDynLink(const CVFWDynLink &refVFWDynLink);
|
|
CURLMonDynLink &operator=(const CVFWDynLink &refVFWDynLink);
|
|
};
|
|
|
|
#endif // FILTER_DLL
|
|
#endif // __DYNLINK_H__
|
|
|