Headers diff for msvfw32.dll between 5.2.3790.1830-Windows 5.0 and 6.0.6001.18000-Windows 6.0 versions

vfw.h (5.2.3790.1830-Windows 5.0)		vfw.h (6.0.6001.18000-Windows 6.0)

skipping to change at line 55		skipping to change at line 55
#endif /* __cplusplus */		#endif /* __cplusplus */

/****************************************************************************		/****************************************************************************
*		*
* types		* types
*		*
***************************************************************************/		***************************************************************************/

#define VFWAPI WINAPI		#define VFWAPI WINAPI
#define VFWAPIV WINAPIV		#define VFWAPIV WINAPIV

		#if (_WIN32_WINNT >= _WIN32_WINNT_WS03)
#define VFWAPI_INLINE WINAPI_INLINE		#define VFWAPI_INLINE WINAPI_INLINE

		#else
		#define VFWAPI_INLINE WINAPI
		#endif

/****************************************************************************		/****************************************************************************
*		*
* VideoForWindowsVersion() - returns version of VfW		* VideoForWindowsVersion() - returns version of VfW
*		*
***************************************************************************/		***************************************************************************/

DWORD FAR PASCAL VideoForWindowsVersion(void);		DWORD FAR PASCAL VideoForWindowsVersion(void);

/****************************************************************************		/****************************************************************************

skipping to change at line 340		skipping to change at line 344

/************************************************************************		/************************************************************************
************************************************************************/		************************************************************************/

#define ICCOMPRESS_KEYFRAME 0x00000001L		#define ICCOMPRESS_KEYFRAME 0x00000001L

typedef struct {		typedef struct {
DWORD dwFlags; // flags		DWORD dwFlags; // flags

LPBITMAPINFOHEADER lpbiOutput; // output format		LPBITMAPINFOHEADER lpbiOutput; // output format

LPVOID lpOutput; // output data		__field_bcount(lpbiOutput->biSizeImage) LPVOID lpOutput; // output data

LPBITMAPINFOHEADER lpbiInput; // format of frame to compress		LPBITMAPINFOHEADER lpbiInput; // format of frame to compress

LPVOID lpInput; // frame data to compress		__field_bcount(lpbiInput->biSizeImage) LPVOID lpInput; / / frame data to compress

LPDWORD lpckid; // ckid for data in AVI file		LPDWORD lpckid; // ckid for data in AVI file
LPDWORD lpdwFlags; // flags in the AVI index.		LPDWORD lpdwFlags; // flags in the AVI index.
LONG lFrameNum; // frame number of seq.		LONG lFrameNum; // frame number of seq.
DWORD dwFrameSize; // reqested size in bytes. (if non zero)		DWORD dwFrameSize; // reqested size in bytes. (if non zero)

DWORD dwQuality; // quality		DWORD dwQuality; // quality

// these are new fields		// these are new fields
LPBITMAPINFOHEADER lpbiPrev; // format of previous frame		LPBITMAPINFOHEADER lpbiPrev; // format of previous frame

LPVOID lpPrev; // previous frame		__field_bcount(lpbiPrev->biSizeImage) LPVOID lpPrev; // previous frame

} ICCOMPRESS;		} ICCOMPRESS;

/************************************************************************		/************************************************************************
************************************************************************/		************************************************************************/

#define ICCOMPRESSFRAMES_PADDING 0x00000001		#define ICCOMPRESSFRAMES_PADDING 0x00000001

typedef struct {		typedef struct {
DWORD dwFlags; // flags		DWORD dwFlags; // flags

skipping to change at line 385		skipping to change at line 389
LONG lQuality; // quality		LONG lQuality; // quality
LONG lDataRate; // data rate		LONG lDataRate; // data rate
LONG lKeyRate; // key frame rate		LONG lKeyRate; // key frame rate

DWORD dwRate; // frame rate, as always		DWORD dwRate; // frame rate, as always
DWORD dwScale;		DWORD dwScale;

DWORD dwOverheadPerFrame;		DWORD dwOverheadPerFrame;
DWORD dwReserved2;		DWORD dwReserved2;


LONG (CALLBACK *GetData)(LPARAM lInput, LONG lFrame, LPVOID lpBits, LONG len		LONG (CALLBACK *GetData)(__in LPARAM lInput, __in LONG lFrame, __out_bcount(
);		len) LPVOID lpBits, __in LONG len);
LONG (CALLBACK *PutData)(LPARAM lOutput, LONG lFrame, LPVOID lpBits, LONG le		LONG (CALLBACK *PutData)(__in LPARAM lOutput, __in LONG lFrame, __in_bcount(
n);		len) LPVOID lpBits, __in LONG len);
} ICCOMPRESSFRAMES;		} ICCOMPRESSFRAMES;

typedef struct {		typedef struct {
DWORD dwFlags;		DWORD dwFlags;
LPARAM lParam;		LPARAM lParam;

// messages for Status callback		// messages for Status callback
#define ICSTATUS_START 0		#define ICSTATUS_START 0
#define ICSTATUS_STATUS 1 // l == % done		#define ICSTATUS_STATUS 1 // l == % done
#define ICSTATUS_END 2		#define ICSTATUS_END 2
#define ICSTATUS_ERROR 3 // l == error string (LPSTR)		#define ICSTATUS_ERROR 3 // l == error string (LPSTR)
#define ICSTATUS_YIELD 4		#define ICSTATUS_YIELD 4
// return nonzero means abort operation in progress		// return nonzero means abort operation in progress


LONG (CALLBACK *Status) (LPARAM lParam, UINT message, LONG l);		LONG (CALLBACK *Status) (__in LPARAM lParam, __in UINT message, __in LONG l) ;
} ICSETSTATUSPROC;		} ICSETSTATUSPROC;

/************************************************************************		/************************************************************************
************************************************************************/		************************************************************************/

#define ICDECOMPRESS_HURRYUP 0x80000000L // don't draw just buffer (hurry up!)		#define ICDECOMPRESS_HURRYUP 0x80000000L // don't draw just buffer (hurry up!)
#define ICDECOMPRESS_UPDATE 0x40000000L // don't draw just update screen		#define ICDECOMPRESS_UPDATE 0x40000000L // don't draw just update screen
#define ICDECOMPRESS_PREROLL 0x20000000L // this frame is before real sta rt		#define ICDECOMPRESS_PREROLL 0x20000000L // this frame is before real sta rt
#define ICDECOMPRESS_NULLFRAME 0x10000000L // repeat last frame		#define ICDECOMPRESS_NULLFRAME 0x10000000L // repeat last frame
#define ICDECOMPRESS_NOTKEYFRAME 0x08000000L // this frame is not a key frame		#define ICDECOMPRESS_NOTKEYFRAME 0x08000000L // this frame is not a key frame

typedef struct {		typedef struct {
DWORD dwFlags; // flags (from AVI index...)		DWORD dwFlags; // flags (from AVI index...)

LPBITMAPINFOHEADER lpbiInput; // BITMAPINFO of compressed data		LPBITMAPINFOHEADER lpbiInput; // BITMAPINFO of compressed data
// biSizeImage has the chunk size		// biSizeImage has the chunk size

		__field_bcount(lpbiInput->biSizeImage)
LPVOID lpInput; // compressed data		LPVOID lpInput; // compressed data

LPBITMAPINFOHEADER lpbiOutput; // DIB to decompress to		LPBITMAPINFOHEADER lpbiOutput; // DIB to decompress to

		__field_bcount(lpbiOutput->biSizeImage)
LPVOID lpOutput;		LPVOID lpOutput;
DWORD ckid; // ckid from AVI file		DWORD ckid; // ckid from AVI file
} ICDECOMPRESS;		} ICDECOMPRESS;

typedef struct {		typedef struct {
//		//
// same as ICM_DECOMPRESS		// same as ICM_DECOMPRESS
//		//
DWORD dwFlags;		DWORD dwFlags;


skipping to change at line 535		skipping to change at line 541

/************************************************************************		/************************************************************************

ICM function declarations		ICM function declarations

************************************************************************/		************************************************************************/

BOOL		BOOL
VFWAPI		VFWAPI
ICInfo(		ICInfo(

IN DWORD fccType,		__in DWORD fccType,
IN DWORD fccHandler,		__in DWORD fccHandler,
OUT ICINFO FAR * lpicinfo		__out ICINFO FAR * lpicinfo
);		);

BOOL		BOOL
VFWAPI		VFWAPI
ICInstall(		ICInstall(

IN DWORD fccType,		__in DWORD fccType,
IN DWORD fccHandler,		__in DWORD fccHandler,
IN LPARAM lParam,		__in LPARAM lParam,
IN LPSTR szDesc,		__in LPSTR szDesc,
IN UINT wFlags		__in UINT wFlags
);		);

BOOL		BOOL
VFWAPI		VFWAPI
ICRemove(		ICRemove(

IN DWORD fccType,		__in DWORD fccType,
IN DWORD fccHandler,		__in DWORD fccHandler,
IN UINT wFlags		__in UINT wFlags
);		);


		__success(return != 0)
LRESULT		LRESULT
VFWAPI		VFWAPI
ICGetInfo(		ICGetInfo(

IN HIC hic,		__in HIC hic,
OUT ICINFO FAR *picinfo,		__out_bcount_part(cb,return) ICINFO FAR *picinfo,
IN DWORD cb		__in DWORD cb
);		);

HIC		HIC
VFWAPI		VFWAPI
ICOpen(		ICOpen(

IN DWORD fccType,		__in DWORD fccType,
IN DWORD fccHandler,		__in DWORD fccHandler,
IN UINT wMode		__in UINT wMode
);		);

HIC		HIC
VFWAPI		VFWAPI
ICOpenFunction(		ICOpenFunction(

IN DWORD fccType,		__in DWORD fccType,
IN DWORD fccHandler,		__in DWORD fccHandler,
IN UINT wMode,		__in UINT wMode,
IN FARPROC lpfnHandler		__in FARPROC lpfnHandler
);		);

LRESULT		LRESULT
VFWAPI		VFWAPI
ICClose(		ICClose(

IN HIC hic		__in HIC hic
);		);

LRESULT		LRESULT
VFWAPI		VFWAPI
ICSendMessage(		ICSendMessage(

IN HIC hic,		__in HIC hic,
IN UINT msg,		__in UINT msg,
IN DWORD_PTR dw1,		__in DWORD_PTR dw1,
IN DWORD_PTR dw2		__in DWORD_PTR dw2
);		);
#ifndef _WIN32		#ifndef _WIN32
//this function is unsupported on Win32 as it is non-portable.		//this function is unsupported on Win32 as it is non-portable.
LRESULT VFWAPIV ICMessage(HIC hic, UINT msg, UINT cb, ...);		LRESULT VFWAPIV ICMessage(HIC hic, UINT msg, UINT cb, ...);
#endif		#endif

/* Values for wFlags of ICInstall() */		/* Values for wFlags of ICInstall() */
#define ICINSTALL_UNICODE 0x8000		#define ICINSTALL_UNICODE 0x8000

#define ICINSTALL_FUNCTION 0x0001 // lParam is a DriverProc (function ptr)		#define ICINSTALL_FUNCTION 0x0001 // lParam is a DriverProc (function ptr)

skipping to change at line 681		skipping to change at line 688
************************************************************************/		************************************************************************/
/*		/*
* ICCompress()		* ICCompress()
*		*
* compress a single frame		* compress a single frame
*		*
*/		*/
DWORD		DWORD
VFWAPIV		VFWAPIV
ICCompress(		ICCompress(

IN HIC hic,		__in HIC hic,
IN DWORD dwFlags, // flags		__in DWORD dwFlags, // flags
IN LPBITMAPINFOHEADER lpbiOutput, // output format		__in LPBITMAPINFOHEADER lpbiOutput, // output format
OUT LPVOID lpData, // output data		__out_bcount(lpbiOutput->biSizeImage) LPVOID lpData,
IN LPBITMAPINFOHEADER lpbiInput, // format of frame to compress		// output data
IN LPVOID lpBits, // frame data to compress		__in LPBITMAPINFOHEADER lpbiInput, // format of frame to compres
OUT LPDWORD lpckid, // ckid for data in AVI file		s
OUT LPDWORD lpdwFlags, // flags in the AVI index.		__in_bcount(lpbiInput->biSizeImage) LPVOID lpBits,
IN LONG lFrameNum, // frame number of seq.		// frame data to compress
IN DWORD dwFrameSize, // reqested size in bytes. (if no		__out_opt LPDWORD lpckid, // ckid for data in AVI file
n zero)		__out_opt LPDWORD lpdwFlags, // flags in the AVI index.
IN DWORD dwQuality, // quality within one frame		__in LONG lFrameNum, // frame number of seq.
IN LPBITMAPINFOHEADER lpbiPrev, // format of previous frame		__in DWORD dwFrameSize, // reqested size in bytes. (i
IN LPVOID lpPrev // previous frame		f non zero)
		__in DWORD dwQuality, // quality within one frame
		__in_opt LPBITMAPINFOHEADER lpbiPrev, // format of previous frame
		__in_bcount_opt(lpbiPrev->biSizeImage) LPVOID lpPrev
		// previous frame
);		);

/*		/*
* ICCompressBegin()		* ICCompressBegin()
*		*
* start compression from a source format (lpbiInput) to a dest		* start compression from a source format (lpbiInput) to a dest
* format (lpbiOuput) is supported.		* format (lpbiOuput) is supported.
*		*
*/		*/
#define ICCompressBegin(hic, lpbiInput, lpbiOutput) \		#define ICCompressBegin(hic, lpbiInput, lpbiOutput) \

skipping to change at line 758		skipping to change at line 765
* ICDecompress()		* ICDecompress()
*		*
* decompress a single frame		* decompress a single frame
*		*
*/		*/
#define ICDECOMPRESS_HURRYUP 0x80000000L // don't draw just buffer (hurry up!)		#define ICDECOMPRESS_HURRYUP 0x80000000L // don't draw just buffer (hurry up!)

DWORD		DWORD
VFWAPIV		VFWAPIV
ICDecompress(		ICDecompress(

IN HIC hic,		__in HIC hic,
IN DWORD dwFlags, // flags (from AVI index...)		__in DWORD dwFlags, // flags (from AVI index...)
IN LPBITMAPINFOHEADER lpbiFormat, // BITMAPINFO of compressed data		__in LPBITMAPINFOHEADER lpbiFormat, // BITMAPINFO of compressed data
// biSizeImage has the chunk size		// biSizeImage has the chunk size

IN LPVOID lpData, // data		__in_bcount(lpbiFormat->biSizeImage) LPVOID lpData, // dat
IN LPBITMAPINFOHEADER lpbi, // DIB to decompress to		a
OUT LPVOID lpBits		__in LPBITMAPINFOHEADER lpbi, // DIB to decompress to
		__out_bcount(lpbi->biSizeImage) LPVOID lpBits
);		);

/*		/*
* ICDecompressBegin()		* ICDecompressBegin()
*		*
* start compression from a source format (lpbiInput) to a dest		* start compression from a source format (lpbiInput) to a dest
* format (lpbiOutput) is supported.		* format (lpbiOutput) is supported.
*		*
*/		*/
#define ICDecompressBegin(hic, lpbiInput, lpbiOutput) \		#define ICDecompressBegin(hic, lpbiInput, lpbiOutput) \

skipping to change at line 835		skipping to change at line 842
//		//

/*		/*
* ICDecompressEx()		* ICDecompressEx()
*		*
* decompress a single frame		* decompress a single frame
*		*
*/		*/
static __inline LRESULT VFWAPI_INLINE		static __inline LRESULT VFWAPI_INLINE
ICDecompressEx(		ICDecompressEx(

HIC hic,		__in HIC hic,
DWORD dwFlags,		__in DWORD dwFlags,
LPBITMAPINFOHEADER lpbiSrc,		__in LPBITMAPINFOHEADER lpbiSrc,
LPVOID lpSrc,		__in_bcount(lpbiSrc->biSizeImage) LPVOID lpSrc,
int xSrc,		__in int xSrc,
int ySrc,		__in int ySrc,
int dxSrc,		__in int dxSrc,
int dySrc,		__in int dySrc,
LPBITMAPINFOHEADER lpbiDst,		__in LPBITMAPINFOHEADER lpbiDst,
LPVOID lpDst,		__out_bcount(lpbiDst->biSizeImage) LPVOID lpDst,
int xDst,		__in int xDst,
int yDst,		__in int yDst,
int dxDst,		__in int dxDst,
int dyDst)		__in int dyDst)
{		{
ICDECOMPRESSEX ic;		ICDECOMPRESSEX ic;

ic.dwFlags = dwFlags;		ic.dwFlags = dwFlags;
ic.lpbiSrc = lpbiSrc;		ic.lpbiSrc = lpbiSrc;
ic.lpSrc = lpSrc;		ic.lpSrc = lpSrc;
ic.xSrc = xSrc;		ic.xSrc = xSrc;
ic.ySrc = ySrc;		ic.ySrc = ySrc;
ic.dxSrc = dxSrc;		ic.dxSrc = dxSrc;
ic.dySrc = dySrc;		ic.dySrc = dySrc;

skipping to change at line 880		skipping to change at line 887

/*		/*
* ICDecompressExBegin()		* ICDecompressExBegin()
*		*
* start compression from a source format (lpbiInput) to a dest		* start compression from a source format (lpbiInput) to a dest
* format (lpbiOutput) is supported.		* format (lpbiOutput) is supported.
*		*
*/		*/
static __inline LRESULT VFWAPI_INLINE		static __inline LRESULT VFWAPI_INLINE
ICDecompressExBegin(		ICDecompressExBegin(

HIC hic,		__in HIC hic,
DWORD dwFlags,		__in DWORD dwFlags,
LPBITMAPINFOHEADER lpbiSrc,		__in LPBITMAPINFOHEADER lpbiSrc,
LPVOID lpSrc,		__in_opt LPVOID lpSrc,
int xSrc,		__in int xSrc,
int ySrc,		__in int ySrc,
int dxSrc,		__in int dxSrc,
int dySrc,		__in int dySrc,
LPBITMAPINFOHEADER lpbiDst,		__in LPBITMAPINFOHEADER lpbiDst,
LPVOID lpDst,		__out_opt LPVOID lpDst,
int xDst,		__in int xDst,
int yDst,		__in int yDst,
int dxDst,		__in int dxDst,
int dyDst)		__in int dyDst)
{		{
ICDECOMPRESSEX ic;		ICDECOMPRESSEX ic;

ic.dwFlags = dwFlags;		ic.dwFlags = dwFlags;
ic.lpbiSrc = lpbiSrc;		ic.lpbiSrc = lpbiSrc;
ic.lpSrc = lpSrc;		ic.lpSrc = lpSrc;
ic.xSrc = xSrc;		ic.xSrc = xSrc;
ic.ySrc = ySrc;		ic.ySrc = ySrc;
ic.dxSrc = dxSrc;		ic.dxSrc = dxSrc;
ic.dySrc = dySrc;		ic.dySrc = dySrc;

skipping to change at line 922		skipping to change at line 929
// length in lparam2, pointer in lparam1		// length in lparam2, pointer in lparam1
return ICSendMessage(hic, ICM_DECOMPRESSEX_BEGIN, (DWORD_PTR)&ic, sizeof(ic) );		return ICSendMessage(hic, ICM_DECOMPRESSEX_BEGIN, (DWORD_PTR)&ic, sizeof(ic) );
}		}

/*		/*
* ICDecompressExQuery()		* ICDecompressExQuery()
*		*
*/		*/
static __inline LRESULT VFWAPI_INLINE		static __inline LRESULT VFWAPI_INLINE
ICDecompressExQuery(		ICDecompressExQuery(

HIC hic,		__in HIC hic,
DWORD dwFlags,		__in DWORD dwFlags,
LPBITMAPINFOHEADER lpbiSrc,		__in LPBITMAPINFOHEADER lpbiSrc,
LPVOID lpSrc,		__reserved LPVOID lpSrc,
int xSrc,		__in int xSrc,
int ySrc,		__in int ySrc,
int dxSrc,		__in int dxSrc,
int dySrc,		__in int dySrc,
LPBITMAPINFOHEADER lpbiDst,		__in_opt LPBITMAPINFOHEADER lpbiDst,
LPVOID lpDst,		__out_opt LPVOID lpDst,
int xDst,		__in int xDst,
int yDst,		__in int yDst,
int dxDst,		__in int dxDst,
int dyDst)		__in int dyDst)
{		{
ICDECOMPRESSEX ic;		ICDECOMPRESSEX ic;

ic.dwFlags = dwFlags;		ic.dwFlags = dwFlags;
ic.lpbiSrc = lpbiSrc;		ic.lpbiSrc = lpbiSrc;
ic.lpSrc = lpSrc;		ic.lpSrc = lpSrc;
ic.xSrc = xSrc;		ic.xSrc = xSrc;
ic.ySrc = ySrc;		ic.ySrc = ySrc;
ic.dxSrc = dxSrc;		ic.dxSrc = dxSrc;
ic.dySrc = dySrc;		ic.dySrc = dySrc;

skipping to change at line 983		skipping to change at line 990
*		*
*/		*/

#define ICDRAW_QUERY 0x00000001L // test for support		#define ICDRAW_QUERY 0x00000001L // test for support
#define ICDRAW_FULLSCREEN 0x00000002L // draw to full screen		#define ICDRAW_FULLSCREEN 0x00000002L // draw to full screen
#define ICDRAW_HDC 0x00000004L // draw to a HDC/HWND		#define ICDRAW_HDC 0x00000004L // draw to a HDC/HWND

DWORD		DWORD
VFWAPIV		VFWAPIV
ICDrawBegin(		ICDrawBegin(

IN HIC hic,		__in HIC hic,
IN DWORD dwFlags, // flags		__in DWORD dwFlags, // flags
IN HPALETTE hpal, // palette to draw with		__in_opt HPALETTE hpal, // palette to draw with
IN HWND hwnd, // window to draw to		__in_opt HWND hwnd, // window to draw to
IN HDC hdc, // HDC to draw to		__in_opt HDC hdc, // HDC to draw to
IN int xDst, // destination rectangle		__in int xDst, // destination rectangle
IN int yDst,		__in int yDst,
IN int dxDst,		__in int dxDst,
IN int dyDst,		__in int dyDst,
IN LPBITMAPINFOHEADER lpbi, // format of frame to draw		__in LPBITMAPINFOHEADER lpbi, // format of frame to draw
IN int xSrc, // source rectangle		__in int xSrc, // source rectangle
IN int ySrc,		__in int ySrc,
IN int dxSrc,		__in int dxSrc,
IN int dySrc,		__in int dySrc,
IN DWORD dwRate, // frames/second = (dwRate/dwScale)		__in DWORD dwRate, // frames/second = (dwRate/dwSc
IN DWORD dwScale		ale)
		__in DWORD dwScale
);		);

/*		/*
* ICDraw()		* ICDraw()
*		*
* decompress data directly to the screen		* decompress data directly to the screen
*		*
*/		*/

#define ICDRAW_HURRYUP 0x80000000L // don't draw just buffer (hurry up!)		#define ICDRAW_HURRYUP 0x80000000L // don't draw just buffer (hurry up!)
#define ICDRAW_UPDATE 0x40000000L // don't draw just update screen		#define ICDRAW_UPDATE 0x40000000L // don't draw just update screen

DWORD		DWORD
VFWAPIV		VFWAPIV
ICDraw(		ICDraw(

IN HIC hic,		__in HIC hic,
IN DWORD dwFlags, // flags		__in DWORD dwFlags, // flags
IN LPVOID lpFormat, // format of frame to decompress		__in LPVOID lpFormat, // format of frame
IN LPVOID lpData, // frame data to decompress		to decompress
IN DWORD cbData, // size of data		__in_bcount_opt(cbData) LPVOID lpData, // frame data to d
IN LONG lTime // time to draw this frame		ecompress
		__in DWORD cbData, // size of data
		__in LONG lTime // time to draw th
		is frame
);		);

// ICMessage is not supported on Win32, so provide a static inline function		// ICMessage is not supported on Win32, so provide a static inline function
// to do the same job		// to do the same job
static __inline LRESULT VFWAPI_INLINE		static __inline LRESULT VFWAPI_INLINE
ICDrawSuggestFormat(		ICDrawSuggestFormat(

HIC hic,		__in HIC hic,
LPBITMAPINFOHEADER lpbiIn,		__in LPBITMAPINFOHEADER lpbiIn,
LPBITMAPINFOHEADER lpbiOut,		__out LPBITMAPINFOHEADER lpbiOut,
int dxSrc,		__in int dxSrc,
int dySrc,		__in int dySrc,
int dxDst,		__in int dxDst,
int dyDst,		__in int dyDst,
HIC hicDecomp)		__in HIC hicDecomp)
{		{
ICDRAWSUGGEST ic;		ICDRAWSUGGEST ic;

ic.lpbiIn = lpbiIn;		ic.lpbiIn = lpbiIn;
ic.lpbiSuggest = lpbiOut;		ic.lpbiSuggest = lpbiOut;
ic.dxSrc = dxSrc;		ic.dxSrc = dxSrc;
ic.dySrc = dySrc;		ic.dySrc = dySrc;
ic.dxDst = dxDst;		ic.dxDst = dxDst;
ic.dyDst = dyDst;		ic.dyDst = dyDst;
ic.hicDecompressor = hicDecomp;		ic.hicDecompressor = hicDecomp;

skipping to change at line 1111		skipping to change at line 1118
/*		/*
* ICSetStatusProc()		* ICSetStatusProc()
*		*
* Set the status callback function		* Set the status callback function
*		*
*/		*/

// ICMessage is not supported on NT		// ICMessage is not supported on NT
static __inline LRESULT VFWAPI_INLINE		static __inline LRESULT VFWAPI_INLINE
ICSetStatusProc(		ICSetStatusProc(

HIC hic,		__in HIC hic,
DWORD dwFlags,		__in DWORD dwFlags,
LRESULT lParam,		__in LRESULT lParam,
LONG (CALLBACK *fpfnStatus)(LPARAM, UINT, LONG) )		__in LONG (CALLBACK *fpfnStatus)(__in LPARAM, __in UINT, __in LONG)
		)
{		{
ICSETSTATUSPROC ic;		ICSETSTATUSPROC ic;

ic.dwFlags = dwFlags;		ic.dwFlags = dwFlags;
ic.lParam = lParam;		ic.lParam = lParam;
ic.Status = fpfnStatus;		ic.Status = fpfnStatus;

// note that ICM swaps round the length and pointer		// note that ICM swaps round the length and pointer
// length in lparam2, pointer in lparam1		// length in lparam2, pointer in lparam1
return ICSendMessage(hic, ICM_SET_STATUS_PROC, (DWORD_PTR)&ic, sizeof(ic));		return ICSendMessage(hic, ICM_SET_STATUS_PROC, (DWORD_PTR)&ic, sizeof(ic));

skipping to change at line 1142		skipping to change at line 1149

#define ICDecompressOpen(fccType, fccHandler, lpbiIn, lpbiOut) \		#define ICDecompressOpen(fccType, fccHandler, lpbiIn, lpbiOut) \
ICLocate(fccType, fccHandler, lpbiIn, lpbiOut, ICMODE_DECOMPRESS)		ICLocate(fccType, fccHandler, lpbiIn, lpbiOut, ICMODE_DECOMPRESS)

#define ICDrawOpen(fccType, fccHandler, lpbiIn) \		#define ICDrawOpen(fccType, fccHandler, lpbiIn) \
ICLocate(fccType, fccHandler, lpbiIn, NULL, ICMODE_DRAW)		ICLocate(fccType, fccHandler, lpbiIn, NULL, ICMODE_DRAW)

HIC		HIC
VFWAPI		VFWAPI
ICLocate(		ICLocate(

IN DWORD fccType,		__in DWORD fccType,
IN DWORD fccHandler,		__in DWORD fccHandler,
IN LPBITMAPINFOHEADER lpbiIn,		__in LPBITMAPINFOHEADER lpbiIn,
IN LPBITMAPINFOHEADER lpbiOut,		__in_opt LPBITMAPINFOHEADER lpbiOut,
IN WORD wFlags		__in WORD wFlags
);		);

HIC		HIC
VFWAPI		VFWAPI
ICGetDisplayFormat(		ICGetDisplayFormat(

IN HIC hic,		__in_opt HIC hic,
IN LPBITMAPINFOHEADER lpbiIn,		__in LPBITMAPINFOHEADER lpbiIn,
OUT LPBITMAPINFOHEADER lpbiOut,		__out LPBITMAPINFOHEADER lpbiOut,
IN int BitDepth,		__in int BitDepth,
IN int dx,		__in int dx,
IN int dy		__in int dy
);		);

/************************************************************************		/************************************************************************
Higher level functions		Higher level functions
************************************************************************/		************************************************************************/

HANDLE		HANDLE
VFWAPI		VFWAPI
ICImageCompress(		ICImageCompress(

IN HIC hic, // compressor to use		__in HIC hic, // compressor to use
IN UINT uiFlags, // flags (none yet)		__in UINT uiFlags, // flags (none yet)
IN LPBITMAPINFO lpbiIn, // format to compress from		__in LPBITMAPINFO lpbiIn, // format to compress from
IN LPVOID lpBits, // data to compress		__in LPVOID lpBits, // data to compress
IN LPBITMAPINFO lpbiOut, // compress to this (NULL ==> default)		__in_opt LPBITMAPINFO lpbiOut, // compress to this (NULL ==> d
IN LONG lQuality, // quality to use		efault)
IN OUT LONG FAR * plSize // compress to this size (0=whatever)		__in LONG lQuality, // quality to use
		__inout_opt LONG FAR * plSize // compress to this size (0=wha
		tever)
);		);

HANDLE		HANDLE
VFWAPI		VFWAPI
ICImageDecompress(		ICImageDecompress(

IN HIC hic, // compressor to use		__in_opt HIC hic, // compressor to use
IN UINT uiFlags, // flags (none yet)		__in UINT uiFlags, // flags (none yet)
IN LPBITMAPINFO lpbiIn, // format to decompress from		__in LPBITMAPINFO lpbiIn, // format to decompress from
IN LPVOID lpBits, // data to decompress		__in LPVOID lpBits, // data to decompress
IN LPBITMAPINFO lpbiOut // decompress to this (NULL ==> default)		__in_opt LPBITMAPINFO lpbiOut // decompress to this (NULL ==> def
		ault)
);		);

//		//
// Structure used by ICSeqCompressFrame and ICCompressorChoose routines		// Structure used by ICSeqCompressFrame and ICCompressorChoose routines
// Make sure this matches the autodoc in icm.c!		// Make sure this matches the autodoc in icm.c!
//		//
typedef struct {		typedef struct {
LONG cbSize; // set to sizeof(COMPVARS) before		LONG cbSize; // set to sizeof(COMPVARS) before
// calling ICCompressorChoose		// calling ICCompressorChoose
DWORD dwFlags; // see below...		DWORD dwFlags; // see below...

skipping to change at line 1221		skipping to change at line 1228
// FLAGS for dwFlags element of COMPVARS structure:		// FLAGS for dwFlags element of COMPVARS structure:
// set this flag if you initialize COMPVARS before calling ICCompressorChoose		// set this flag if you initialize COMPVARS before calling ICCompressorChoose
#define ICMF_COMPVARS_VALID 0x00000001 // COMPVARS contains valid data		#define ICMF_COMPVARS_VALID 0x00000001 // COMPVARS contains valid data

//		//
// allows user to choose compressor, quality etc...		// allows user to choose compressor, quality etc...
//		//
BOOL		BOOL
VFWAPI		VFWAPI
ICCompressorChoose(		ICCompressorChoose(

IN HWND hwnd, // parent window for dialog		__in_opt HWND hwnd, // parent window for dialog
IN UINT uiFlags, // flags		__in UINT uiFlags, // flags
IN LPVOID pvIn, // input format (optional)		__in_opt LPVOID pvIn, // input format (optional)
IN LPVOID lpData, // input data (optional)		__in_opt LPVOID lpData, // input data (optional)
IN OUT PCOMPVARS pc, // data about the compressor/dlg		__inout PCOMPVARS pc, // data about the compressor/dlg
IN LPSTR lpszTitle // dialog title (optional)		__in_opt LPSTR lpszTitle // dialog title (optional)
);		);

// defines for uiFlags		// defines for uiFlags
#define ICMF_CHOOSE_KEYFRAME 0x0001 // show KeyFrame Every box		#define ICMF_CHOOSE_KEYFRAME 0x0001 // show KeyFrame Every box
#define ICMF_CHOOSE_DATARATE 0x0002 // show DataRate box		#define ICMF_CHOOSE_DATARATE 0x0002 // show DataRate box
#define ICMF_CHOOSE_PREVIEW 0x0004 // allow expanded preview dialog		#define ICMF_CHOOSE_PREVIEW 0x0004 // allow expanded preview dialog
#define ICMF_CHOOSE_ALLCOMPRESSORS 0x0008 // don't only show those that		#define ICMF_CHOOSE_ALLCOMPRESSORS 0x0008 // don't only show those that
// can handle the input format		// can handle the input format
// or input data		// or input data

BOOL		BOOL
VFWAPI		VFWAPI
ICSeqCompressFrameStart(		ICSeqCompressFrameStart(

IN PCOMPVARS pc,		__in PCOMPVARS pc,
IN LPBITMAPINFO lpbiIn		__in LPBITMAPINFO lpbiIn
);		);

void		void
VFWAPI		VFWAPI
ICSeqCompressFrameEnd(		ICSeqCompressFrameEnd(

IN PCOMPVARS pc		__in PCOMPVARS pc
);		);

LPVOID		LPVOID
VFWAPI		VFWAPI
ICSeqCompressFrame(		ICSeqCompressFrame(

IN PCOMPVARS pc, // set by ICCompressorChoose		__in PCOMPVARS pc, // set by ICCompressorChoose
IN UINT uiFlags, // flags		__reserved UINT uiFlags, // flags
IN LPVOID lpBits, // input DIB bits		__in LPVOID lpBits, // input DIB bits
OUT BOOL FAR *pfKey, // did it end up being a key frame?		__out BOOL FAR *pfKey, // did it end up being a key
IN OUT LONG FAR *plSize // size to compress to/of returned i		frame?
mage		__inout_opt LONG FAR *plSize // size to compress to/of ret
		urned image
);		);

void		void
VFWAPI		VFWAPI
ICCompressorFree(		ICCompressorFree(
IN PCOMPVARS pc		IN PCOMPVARS pc
);		);

#endif /* NOCOMPMAN */		#endif /* NOCOMPMAN */


skipping to change at line 1327		skipping to change at line 1334
extern HDRAWDIB VFWAPI DrawDibOpen(void);		extern HDRAWDIB VFWAPI DrawDibOpen(void);

/*		/*
** DrawDibClose()		** DrawDibClose()
**		**
*/		*/
extern		extern
BOOL		BOOL
VFWAPI		VFWAPI
DrawDibClose(		DrawDibClose(

IN HDRAWDIB hdd		__in HDRAWDIB hdd
);		);

/*		/*
** DrawDibGetBuffer()		** DrawDibGetBuffer()
**		**
*/		*/
extern		extern
LPVOID		LPVOID
VFWAPI		VFWAPI
DrawDibGetBuffer(		DrawDibGetBuffer(

IN HDRAWDIB hdd,		__in HDRAWDIB hdd,
OUT LPBITMAPINFOHEADER lpbi,		__out LPBITMAPINFOHEADER lpbi,
IN DWORD dwSize,		__in DWORD dwSize,
IN DWORD dwFlags		__in DWORD dwFlags
);		);

/* // ;Internal		/* // ;Internal
** DrawDibError() // ;Internal		** DrawDibError() // ;Internal
*/ // ;Internal		*/ // ;Internal
extern UINT VFWAPI DrawDibError(HDRAWDIB hdd); // ;Internal		extern UINT VFWAPI DrawDibError(HDRAWDIB hdd); // ;Internal
// ;Internal		// ;Internal
/*		/*
** DrawDibGetPalette()		** DrawDibGetPalette()
**		**
** get the palette used for drawing DIBs		** get the palette used for drawing DIBs
**		**
*/		*/
extern		extern
HPALETTE		HPALETTE
VFWAPI		VFWAPI
DrawDibGetPalette(		DrawDibGetPalette(

IN HDRAWDIB hdd		__in HDRAWDIB hdd
);		);

/*		/*
** DrawDibSetPalette()		** DrawDibSetPalette()
**		**
** get the palette used for drawing DIBs		** get the palette used for drawing DIBs
**		**
*/		*/
extern		extern
BOOL		BOOL
VFWAPI		VFWAPI
DrawDibSetPalette(		DrawDibSetPalette(

IN HDRAWDIB hdd,		__in HDRAWDIB hdd,
IN HPALETTE hpal		__in_opt HPALETTE hpal
);		);

/*		/*
** DrawDibChangePalette()		** DrawDibChangePalette()
*/		*/
extern		extern
BOOL		BOOL
VFWAPI		VFWAPI
DrawDibChangePalette(		DrawDibChangePalette(

IN HDRAWDIB hdd,		__in HDRAWDIB hdd,
IN int iStart,		__in int iStart,
IN int iLen,		__in int iLen,
IN LPPALETTEENTRY lppe		__in_ecount(iLen) LPPALETTEENTRY lppe
);		);

/*		/*
** DrawDibRealize()		** DrawDibRealize()
**		**
** realize the palette in a HDD		** realize the palette in a HDD
**		**
*/		*/
extern		extern
UINT		UINT
VFWAPI		VFWAPI
DrawDibRealize(		DrawDibRealize(

IN HDRAWDIB hdd,		__in HDRAWDIB hdd,
IN HDC hdc,		__in HDC hdc,
IN BOOL fBackground		__in BOOL fBackground
);		);

/*		/*
** DrawDibStart()		** DrawDibStart()
**		**
** start of streaming playback		** start of streaming playback
**		**
*/		*/
extern		extern
BOOL		BOOL
VFWAPI		VFWAPI
DrawDibStart(		DrawDibStart(

IN HDRAWDIB hdd,		__in HDRAWDIB hdd,
IN DWORD rate		__in DWORD rate
);		);

/*		/*
** DrawDibStop()		** DrawDibStop()
**		**
** start of streaming playback		** start of streaming playback
**		**
*/		*/
extern		extern
BOOL		BOOL
VFWAPI		VFWAPI
DrawDibStop(		DrawDibStop(

IN HDRAWDIB hdd		__in HDRAWDIB hdd
);		);

/*		/*
** DrawDibBegin()		** DrawDibBegin()
**		**
** prepare to draw		** prepare to draw
**		**
*/		*/
extern		extern
BOOL		BOOL
VFWAPI		VFWAPI
DrawDibBegin(		DrawDibBegin(

IN HDRAWDIB hdd,		__in HDRAWDIB hdd,
IN HDC hdc,		__in_opt HDC hdc,
IN int dxDst,		__in int dxDst,
IN int dyDst,		__in int dyDst,
IN LPBITMAPINFOHEADER lpbi,		__in LPBITMAPINFOHEADER lpbi,
IN int dxSrc,		__in int dxSrc,
IN int dySrc,		__in int dySrc,
IN UINT wFlags		__in UINT wFlags
);		);

/*		/*
** DrawDibDraw()		** DrawDibDraw()
**		**
** actualy draw a DIB to the screen.		** actualy draw a DIB to the screen.
**		**
*/		*/
extern		extern
BOOL		BOOL
VFWAPI		VFWAPI
DrawDibDraw(		DrawDibDraw(

IN HDRAWDIB hdd,		__in HDRAWDIB hdd,
IN HDC hdc,		__in HDC hdc,
IN int xDst,		__in int xDst,
IN int yDst,		__in int yDst,
IN int dxDst,		__in int dxDst,
IN int dyDst,		__in int dyDst,
IN LPBITMAPINFOHEADER lpbi,		__in_opt LPBITMAPINFOHEADER lpbi,
IN LPVOID lpBits,		__in_opt LPVOID lpBits,
IN int xSrc,		__in int xSrc,
IN int ySrc,		__in int ySrc,
IN int dxSrc,		__in int dxSrc,
IN int dySrc,		__in int dySrc,
IN UINT wFlags		__in UINT wFlags
);		);

/*		/*
** DrawDibUpdate()		** DrawDibUpdate()
**		**
** redraw the last image (may only be valid with DDF_BUFFER)		** redraw the last image (may only be valid with DDF_BUFFER)
*/		*/
#define DrawDibUpdate(hdd, hdc, x, y) \		#define DrawDibUpdate(hdd, hdc, x, y) \
DrawDibDraw(hdd, hdc, x, y, 0, 0, NULL, NULL, 0, 0, 0, 0, DDF_UPDATE)		DrawDibDraw(hdd, hdc, x, y, 0, 0, NULL, NULL, 0, 0, 0, 0, DDF_UPDATE)

/*		/*
** DrawDibEnd()		** DrawDibEnd()
*/		*/
extern		extern
BOOL		BOOL
VFWAPI		VFWAPI
DrawDibEnd(		DrawDibEnd(

IN HDRAWDIB hdd		__in HDRAWDIB hdd
);		);

/*		/*
** DrawDibTime() [for debugging purposes only]		** DrawDibTime() [for debugging purposes only]
*/		*/
typedef struct {		typedef struct {
LONG timeCount;		LONG timeCount;
LONG timeDraw;		LONG timeDraw;
LONG timeDecompress;		LONG timeDecompress;
LONG timeDither;		LONG timeDither;
LONG timeStretch;		LONG timeStretch;
LONG timeBlt;		LONG timeBlt;
LONG timeSetDIBits;		LONG timeSetDIBits;
} DRAWDIBTIME, FAR *LPDRAWDIBTIME;		} DRAWDIBTIME, FAR *LPDRAWDIBTIME;

BOOL		BOOL
VFWAPI		VFWAPI
DrawDibTime(		DrawDibTime(

IN HDRAWDIB hdd,		__in HDRAWDIB hdd,
OUT LPDRAWDIBTIME lpddtime		__out LPDRAWDIBTIME lpddtime
);		);

/* display profiling */		/* display profiling */
#define PD_CAN_DRAW_DIB 0x0001 /* if you can draw at all */		#define PD_CAN_DRAW_DIB 0x0001 /* if you can draw at all */
#define PD_CAN_STRETCHDIB 0x0002 /* basicly RC_STRETCHDIB */		#define PD_CAN_STRETCHDIB 0x0002 /* basicly RC_STRETCHDIB */
#define PD_STRETCHDIB_1_1_OK 0x0004 /* is it fast? */		#define PD_STRETCHDIB_1_1_OK 0x0004 /* is it fast? */
#define PD_STRETCHDIB_1_2_OK 0x0008 /* ... */		#define PD_STRETCHDIB_1_2_OK 0x0008 /* ... */
#define PD_STRETCHDIB_1_N_OK 0x0010 /* ... */		#define PD_STRETCHDIB_1_N_OK 0x0010 /* ... */

LRESULT		LRESULT
VFWAPI		VFWAPI
DrawDibProfileDisplay(		DrawDibProfileDisplay(

IN LPBITMAPINFOHEADER lpbi		__in LPBITMAPINFOHEADER lpbi
);		);

#ifdef DRAWDIB_INCLUDE_STRETCHDIB		#ifdef DRAWDIB_INCLUDE_STRETCHDIB
void WINAPI StretchDIB(		void WINAPI StretchDIB(

LPBITMAPINFOHEADER biDst,		__in LPBITMAPINFOHEADER biDst,
LPVOID lpDst,		__out LPVOID lpDst,
int DstX,		__in int DstX,
int DstY,		__in int DstY,
int DstXE,		__in int DstXE,
int DstYE,		__in int DstYE,
LPBITMAPINFOHEADER biSrc,		__in LPBITMAPINFOHEADER biSrc,
LPVOID lpSrc,		__in LPVOID lpSrc,
int SrcX,		__in int SrcX,
int SrcY,		__in int SrcY,
int SrcXE,		__in int SrcXE,
int SrcYE);		__in int SrcYE);
#endif		#endif

#endif /* NODRAWDIB */		#endif /* NODRAWDIB */

/****************************************************************************		/****************************************************************************
*		*
* AVIFMT - AVI file format definitions		* AVIFMT - AVI file format definitions
*		*
****************************************************************************/		****************************************************************************/


skipping to change at line 2033		skipping to change at line 2040
/* - - - - - - - - */		/* - - - - - - - - */

/**** AVI Stream Interface *****************************************/		/**** AVI Stream Interface *****************************************/

#undef INTERFACE		#undef INTERFACE
#define INTERFACE IAVIStream		#define INTERFACE IAVIStream

DECLARE_INTERFACE_(IAVIStream, IUnknown)		DECLARE_INTERFACE_(IAVIStream, IUnknown)
{		{
// * IUnknown methods *		// * IUnknown methods *

STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE;		STDMETHOD(QueryInterface) (THIS_ REFIID riid, __deref_out LPVOID FAR* ppvObj ) PURE;
STDMETHOD_(ULONG,AddRef) (THIS) PURE;		STDMETHOD_(ULONG,AddRef) (THIS) PURE;
STDMETHOD_(ULONG,Release) (THIS) PURE;		STDMETHOD_(ULONG,Release) (THIS) PURE;

// * IAVIStream methods *		// * IAVIStream methods *
STDMETHOD(Create) (THIS_ LPARAM lParam1, LPARAM lParam2) PURE ;		STDMETHOD(Create) (THIS_ LPARAM lParam1, LPARAM lParam2) PURE ;

STDMETHOD(Info) (THIS_ AVISTREAMINFOW FAR * psi, LONG lSize) PURE ;		STDMETHOD(Info) (THIS_ __out_bcount(lSize) AVISTREAMINFOW FAR * psi,
STDMETHOD_(LONG, FindSample)(THIS_ LONG lPos, LONG lFlags) PURE ;		__in LONG lSize) PURE ;
STDMETHOD(ReadFormat) (THIS_ LONG lPos,		STDMETHOD_(LONG, FindSample)(THIS_ __in LONG lPos, __in LONG lFlags) PURE ;
LPVOID lpFormat, LONG FAR *lpcbFormat) PURE ;		STDMETHOD(ReadFormat) (THIS_ __in LONG lPos,
STDMETHOD(SetFormat) (THIS_ LONG lPos,		__out_bcount_part_opt(lpcbFormat, lpcbFormat) LPVOI
LPVOID lpFormat, LONG cbFormat) PURE ;		D lpFormat, __inout LONG FAR *lpcbFormat) PURE ;
STDMETHOD(Read) (THIS_ LONG lStart, LONG lSamples,		STDMETHOD(SetFormat) (THIS_ __in LONG lPos,
LPVOID lpBuffer, LONG cbBuffer,		__in_bcount(cbFormat) LPVOID lpFormat, __in LONG cbFo
LONG FAR * plBytes, LONG FAR * plSamples) PURE ;		rmat) PURE ;
STDMETHOD(Write) (THIS_ LONG lStart, LONG lSamples,		STDMETHOD(Read) (THIS_ __in LONG lStart, __in LONG lSamples,
LPVOID lpBuffer, LONG cbBuffer,		__out_bcount_opt(cbBuffer) LPVOID lpBuffer, __in LONG
DWORD dwFlags,		cbBuffer,
LONG FAR *plSampWritten,		__out_opt LONG FAR * plBytes, __out_opt LONG FAR * pl
LONG FAR *plBytesWritten) PURE ;		Samples) PURE ;
STDMETHOD(Delete) (THIS_ LONG lStart, LONG lSamples) PURE;		STDMETHOD(Write) (THIS_ __in LONG lStart, __in LONG lSamples,
STDMETHOD(ReadData) (THIS_ DWORD fcc, LPVOID lp, LONG FAR *lpcb) PURE ;		__in_bcount(cbBuffer) LPVOID lpBuffer, __in LONG cbBu
STDMETHOD(WriteData) (THIS_ DWORD fcc, LPVOID lp, LONG cb) PURE ;		ffer,
		__in DWORD dwFlags,
		__out_opt LONG FAR *plSampWritten,
		__out_opt LONG FAR *plBytesWritten) PURE ;
		STDMETHOD(Delete) (THIS_ __in LONG lStart, __in LONG lSamples) PURE;
		STDMETHOD(ReadData) (THIS_ __in DWORD fcc, __out_bcount_part_opt(lpcb,
		lpcb) LPVOID lp, __inout LONG FAR *lpcb) PURE ;
		STDMETHOD(WriteData) (THIS_ __in DWORD fcc, __in_bcount(cb) LPVOID lp, __i
		n LONG cb) PURE ;
#ifdef _WIN32		#ifdef _WIN32

STDMETHOD(SetInfo) (THIS_ AVISTREAMINFOW FAR * lpInfo,		STDMETHOD(SetInfo) (THIS_ __in_bcount(cbInfo) AVISTREAMINFOW FAR * lpInfo,
LONG cbInfo) PURE;		__in LONG cbInfo) PURE;
#else		#else
STDMETHOD(Reserved1) (THIS) PURE;		STDMETHOD(Reserved1) (THIS) PURE;
STDMETHOD(Reserved2) (THIS) PURE;		STDMETHOD(Reserved2) (THIS) PURE;
STDMETHOD(Reserved3) (THIS) PURE;		STDMETHOD(Reserved3) (THIS) PURE;
STDMETHOD(Reserved4) (THIS) PURE;		STDMETHOD(Reserved4) (THIS) PURE;
STDMETHOD(Reserved5) (THIS) PURE;		STDMETHOD(Reserved5) (THIS) PURE;
#endif		#endif
};		};

typedef IAVIStream FAR* PAVISTREAM;		typedef IAVIStream FAR* PAVISTREAM;

#undef INTERFACE		#undef INTERFACE
#define INTERFACE IAVIStreaming		#define INTERFACE IAVIStreaming

DECLARE_INTERFACE_(IAVIStreaming, IUnknown)		DECLARE_INTERFACE_(IAVIStreaming, IUnknown)
{		{
// * IUnknown methods *		// * IUnknown methods *

STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE;		STDMETHOD(QueryInterface) (THIS_ REFIID riid, __deref_out LPVOID FAR* ppvObj ) PURE;
STDMETHOD_(ULONG,AddRef) (THIS) PURE;		STDMETHOD_(ULONG,AddRef) (THIS) PURE;
STDMETHOD_(ULONG,Release) (THIS) PURE;		STDMETHOD_(ULONG,Release) (THIS) PURE;

// * IAVIStreaming methods *		// * IAVIStreaming methods *
STDMETHOD(Begin) (THIS_		STDMETHOD(Begin) (THIS_

LONG lStart, // start of what we expect		__in LONG lStart, // start of what we expect
// to play		// to play

LONG lEnd, // expected end, or -1		__in LONG lEnd, // expected end, or -1
LONG lRate) PURE; // Should this be a float?		__in LONG lRate) PURE; // Should this be a float?
STDMETHOD(End) (THIS) PURE;		STDMETHOD(End) (THIS) PURE;
};		};

typedef IAVIStreaming FAR* PAVISTREAMING;		typedef IAVIStreaming FAR* PAVISTREAMING;

#undef INTERFACE		#undef INTERFACE
#define INTERFACE IAVIEditStream		#define INTERFACE IAVIEditStream

DECLARE_INTERFACE_(IAVIEditStream, IUnknown)		DECLARE_INTERFACE_(IAVIEditStream, IUnknown)
{		{
// * IUnknown methods *		// * IUnknown methods *

STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE;		STDMETHOD(QueryInterface) (THIS_ REFIID riid, __deref_out LPVOID FAR* ppvObj ) PURE;
STDMETHOD_(ULONG,AddRef) (THIS) PURE;		STDMETHOD_(ULONG,AddRef) (THIS) PURE;
STDMETHOD_(ULONG,Release) (THIS) PURE;		STDMETHOD_(ULONG,Release) (THIS) PURE;

// * IAVIEditStream methods *		// * IAVIEditStream methods *

STDMETHOD(Cut) (THIS_ LONG FAR *plStart,		STDMETHOD(Cut) (THIS_ __inout LONG FAR *plStart,
LONG FAR *plLength,		__inout LONG FAR *plLength,
PAVISTREAM FAR * ppResult) PURE;		__deref_out PAVISTREAM FAR * ppResult) PURE;
STDMETHOD(Copy) (THIS_ LONG FAR *plStart,		STDMETHOD(Copy) (THIS_ __inout LONG FAR *plStart,
LONG FAR *plLength,		__inout LONG FAR *plLength,
PAVISTREAM FAR * ppResult) PURE;		__deref_out PAVISTREAM FAR * ppResult) PURE;
STDMETHOD(Paste) (THIS_ LONG FAR *plPos,		STDMETHOD(Paste) (THIS_ __inout LONG FAR *plPos,
LONG FAR *plLength,		__inout LONG FAR *plLength,
PAVISTREAM pstream,		__inout PAVISTREAM pstream,
LONG lStart,		__in LONG lStart,
LONG lEnd) PURE;		__in LONG lEnd) PURE;
STDMETHOD(Clone) (THIS_ PAVISTREAM FAR *ppResult) PURE;		STDMETHOD(Clone) (THIS_ __deref_out PAVISTREAM FAR *ppResult) PURE;
STDMETHOD(SetInfo) (THIS_ AVISTREAMINFOW FAR * lpInfo,		STDMETHOD(SetInfo) (THIS_ __in_bcount(cbInfo) AVISTREAMINFOW FAR * lpInfo,
LONG cbInfo) PURE;		__in LONG cbInfo) PURE;
};		};

typedef IAVIEditStream FAR* PAVIEDITSTREAM;		typedef IAVIEditStream FAR* PAVIEDITSTREAM;

/**** AVI File Interface *****************************************/		/**** AVI File Interface *****************************************/

#undef INTERFACE		#undef INTERFACE
#define INTERFACE IAVIPersistFile		#define INTERFACE IAVIPersistFile

DECLARE_INTERFACE_(IAVIPersistFile, IPersistFile)		DECLARE_INTERFACE_(IAVIPersistFile, IPersistFile)

skipping to change at line 2139		skipping to change at line 2146

typedef IAVIPersistFile FAR* PAVIPERSISTFILE;		typedef IAVIPersistFile FAR* PAVIPERSISTFILE;

#undef INTERFACE		#undef INTERFACE
#define INTERFACE IAVIFile		#define INTERFACE IAVIFile
#define PAVIFILE IAVIFile FAR*		#define PAVIFILE IAVIFile FAR*

DECLARE_INTERFACE_(IAVIFile, IUnknown)		DECLARE_INTERFACE_(IAVIFile, IUnknown)
{		{
// * IUnknown methods *		// * IUnknown methods *

STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE;		STDMETHOD(QueryInterface) (THIS_ REFIID riid, __deref_out LPVOID FAR* ppvObj ) PURE;
STDMETHOD_(ULONG,AddRef) (THIS) PURE;		STDMETHOD_(ULONG,AddRef) (THIS) PURE;
STDMETHOD_(ULONG,Release) (THIS) PURE;		STDMETHOD_(ULONG,Release) (THIS) PURE;

// * IAVIFile methods *		// * IAVIFile methods *
STDMETHOD(Info) (THIS_		STDMETHOD(Info) (THIS_

AVIFILEINFOW FAR * pfi,		__out_bcount(lSize) AVIFILEINFOW FAR * pfi,
LONG lSize) PURE;		__in LONG lSize) PURE;
STDMETHOD(GetStream) (THIS_		STDMETHOD(GetStream) (THIS_

PAVISTREAM FAR * ppStream,		__deref_out PAVISTREAM FAR * ppStream,
DWORD fccType,		__in DWORD fccType,
LONG lParam) PURE;		__in LONG lParam) PURE;
STDMETHOD(CreateStream) (THIS_		STDMETHOD(CreateStream) (THIS_

PAVISTREAM FAR * ppStream,		__deref_out PAVISTREAM FAR * ppStream,
AVISTREAMINFOW FAR * psi) PURE;		__in AVISTREAMINFOW FAR * psi) PURE;
STDMETHOD(WriteData) (THIS_		STDMETHOD(WriteData) (THIS_

DWORD ckid,		__in DWORD ckid,
LPVOID lpData,		__in_bcount(cbData) LPVOID lpData,
LONG cbData) PURE;		__in LONG cbData) PURE;
STDMETHOD(ReadData) (THIS_		STDMETHOD(ReadData) (THIS_

DWORD ckid,		__in DWORD ckid,
LPVOID lpData,		__out_bcount_part(lpcbData, lpcbData) LPV
LONG FAR *lpcbData) PURE;		OID lpData,
		__inout LONG FAR *lpcbData) PURE;
STDMETHOD(EndRecord) (THIS) PURE;		STDMETHOD(EndRecord) (THIS) PURE;
STDMETHOD(DeleteStream) (THIS_		STDMETHOD(DeleteStream) (THIS_

DWORD fccType,		__in DWORD fccType,
LONG lParam) PURE;		__in LONG lParam) PURE;
};		};

#undef PAVIFILE		#undef PAVIFILE
typedef IAVIFile FAR* PAVIFILE;		typedef IAVIFile FAR* PAVIFILE;

/**** GetFrame Interface *****************************************/		/**** GetFrame Interface *****************************************/

#undef INTERFACE		#undef INTERFACE
#define INTERFACE IGetFrame		#define INTERFACE IGetFrame
#define PGETFRAME IGetFrame FAR*		#define PGETFRAME IGetFrame FAR*

DECLARE_INTERFACE_(IGetFrame, IUnknown)		DECLARE_INTERFACE_(IGetFrame, IUnknown)
{		{
// * IUnknown methods *		// * IUnknown methods *

STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE;		STDMETHOD(QueryInterface) (THIS_ REFIID riid, __deref_out LPVOID FAR* ppvObj ) PURE;
STDMETHOD_(ULONG,AddRef) (THIS) PURE;		STDMETHOD_(ULONG,AddRef) (THIS) PURE;
STDMETHOD_(ULONG,Release) (THIS) PURE;		STDMETHOD_(ULONG,Release) (THIS) PURE;

// * IGetFrame methods *		// * IGetFrame methods *


STDMETHOD_(LPVOID,GetFrame) (THIS_ LONG lPos) PURE;		STDMETHOD_(LPVOID,GetFrame) (THIS_ __in LONG lPos) PURE;
// STDMETHOD_(LPVOID,GetFrameData) (THIS_ LONG lPos) PURE;		// STDMETHOD_(LPVOID,GetFrameData) (THIS_ __in LONG lPos) PURE;


STDMETHOD(Begin) (THIS_ LONG lStart, LONG lEnd, LONG lRate) PURE;		STDMETHOD(Begin) (THIS_ __in LONG lStart, __in LONG lEnd, __in LONG lRate) P URE;
STDMETHOD(End) (THIS) PURE;		STDMETHOD(End) (THIS) PURE;


STDMETHOD(SetFormat) (THIS_ LPBITMAPINFOHEADER lpbi, LPVOID lpBits, int x, i nt y, int dx, int dy) PURE;		STDMETHOD(SetFormat) (THIS_ __in LPBITMAPINFOHEADER lpbi, __in_opt LPVOID lp Bits, __in int x, __in int y, __in int dx, __in int dy) PURE;

// STDMETHOD(DrawFrameStart) (THIS) PURE;		// STDMETHOD(DrawFrameStart) (THIS) PURE;

// STDMETHOD(DrawFrame) (THIS_ LONG lPos, HDC hdc, int x, int y, int dx, int dy ) PURE;		// STDMETHOD(DrawFrame) (THIS_ __in LONG lPos, HDC hdc, __in int x, __in int y, __in int dx, __in int dy) PURE;
// STDMETHOD(DrawFrameEnd) (THIS) PURE;		// STDMETHOD(DrawFrameEnd) (THIS) PURE;
};		};

#undef PGETFRAME		#undef PGETFRAME
typedef IGetFrame FAR* PGETFRAME;		typedef IGetFrame FAR* PGETFRAME;

/**** GUIDs *****************************************/		/**** GUIDs *****************************************/

#define DEFINE_AVIGUID(name, l, w1, w2) \		#define DEFINE_AVIGUID(name, l, w1, w2) \
DEFINE_GUID(name, l, w1, w2, 0xC0,0,0,0,0,0,0,0x46)		DEFINE_GUID(name, l, w1, w2, 0xC0,0,0,0,0,0,0,0x46)

skipping to change at line 2234		skipping to change at line 2241
// functions		// functions
//		//

STDAPI_(void) AVIFileInit(void); // Call this first!		STDAPI_(void) AVIFileInit(void); // Call this first!
STDAPI_(void) AVIFileExit(void);		STDAPI_(void) AVIFileExit(void);

STDAPI_(ULONG) AVIFileAddRef (PAVIFILE pfile);		STDAPI_(ULONG) AVIFileAddRef (PAVIFILE pfile);
STDAPI_(ULONG) AVIFileRelease (PAVIFILE pfile);		STDAPI_(ULONG) AVIFileRelease (PAVIFILE pfile);

#ifdef _WIN32		#ifdef _WIN32

STDAPI AVIFileOpenA (PAVIFILE FAR * ppfile, LPCSTR szFile,		STDAPI AVIFileOpenA (__deref_out PAVIFILE FAR * ppfile, __in LPCSTR szFile
UINT uMode, LPCLSID lpHandler);		,
STDAPI AVIFileOpenW (PAVIFILE FAR * ppfile, LPCWSTR szFile,		UINT uMode, __in_opt LPCLSID lpHandler);
UINT uMode, LPCLSID lpHandler);		STDAPI AVIFileOpenW (__deref_out PAVIFILE FAR * ppfile, __in LPCWSTR szFil
		e,
		UINT uMode, __in_opt LPCLSID lpHandler);
#ifdef UNICODE		#ifdef UNICODE
#define AVIFileOpen AVIFileOpenW		#define AVIFileOpen AVIFileOpenW
#else		#else
#define AVIFileOpen AVIFileOpenA		#define AVIFileOpen AVIFileOpenA
#endif		#endif
#else // win16		#else // win16
STDAPI AVIFileOpen (PAVIFILE FAR * ppfile, LPCSTR szFile,		STDAPI AVIFileOpen (PAVIFILE FAR * ppfile, LPCSTR szFile,
UINT uMode, LPCLSID lpHandler);		UINT uMode, LPCLSID lpHandler);
#define AVIFileOpenW AVIFileOpen /* ;Internal */		#define AVIFileOpenW AVIFileOpen /* ;Internal */
#endif		#endif

#ifdef _WIN32		#ifdef _WIN32

STDAPI AVIFileInfoW (PAVIFILE pfile, LPAVIFILEINFOW pfi, LONG lSize);		STDAPI AVIFileInfoW (__in PAVIFILE pfile, __out_bcount(lSize) LPAVIFILEINFOW pfi
STDAPI AVIFileInfoA (PAVIFILE pfile, LPAVIFILEINFOA pfi, LONG lSize);		, __in LONG lSize);
		STDAPI AVIFileInfoA (__in PAVIFILE pfile, __out_bcount(lSize) LPAVIFILEINFOA pfi
		, __in LONG lSize);
#ifdef UNICODE		#ifdef UNICODE
#define AVIFileInfo AVIFileInfoW		#define AVIFileInfo AVIFileInfoW
#else		#else
#define AVIFileInfo AVIFileInfoA		#define AVIFileInfo AVIFileInfoA
#endif		#endif
#else //win16 version		#else //win16 version
STDAPI AVIFileInfo (PAVIFILE pfile, LPAVIFILEINFO pfi, LONG lSize);		STDAPI AVIFileInfo (PAVIFILE pfile, LPAVIFILEINFO pfi, LONG lSize);
#define AVIFileInfoW AVIFileInfo /* ;Internal */		#define AVIFileInfoW AVIFileInfo /* ;Internal */
#endif		#endif


STDAPI AVIFileGetStream (PAVIFILE pfile, PAVISTREAM FAR * ppavi, DWORD fccTy pe, LONG lParam);		STDAPI AVIFileGetStream (__in PAVIFILE pfile, __deref_out PAVISTREAM FAR * p pavi, __in DWORD fccType, __in LONG lParam);

#ifdef _WIN32		#ifdef _WIN32

STDAPI AVIFileCreateStreamW (PAVIFILE pfile, PAVISTREAM FAR *ppavi, AVISTREAMINF		STDAPI AVIFileCreateStreamW (__in PAVIFILE pfile, __deref_out PAVISTREAM FAR *pp
OW FAR * psi);		avi, __in AVISTREAMINFOW FAR * psi);
STDAPI AVIFileCreateStreamA (PAVIFILE pfile, PAVISTREAM FAR *ppavi, AVISTREAMINF		STDAPI AVIFileCreateStreamA (__in PAVIFILE pfile, __deref_out PAVISTREAM FAR *pp
OA FAR * psi);		avi, __in AVISTREAMINFOA FAR * psi);
#ifdef UNICODE		#ifdef UNICODE
#define AVIFileCreateStream AVIFileCreateStreamW		#define AVIFileCreateStream AVIFileCreateStreamW
#else		#else
#define AVIFileCreateStream AVIFileCreateStreamA		#define AVIFileCreateStream AVIFileCreateStreamA
#endif		#endif
#else //win16 version		#else //win16 version
STDAPI AVIFileCreateStream(PAVIFILE pfile, PAVISTREAM FAR ppavi, AVISTREAMINFO FAR psi);		STDAPI AVIFileCreateStream(PAVIFILE pfile, PAVISTREAM FAR ppavi, AVISTREAMINFO FAR psi);
#define AVIFileCreateStreamW AVIFileCreateStream /* ;Internal */		#define AVIFileCreateStreamW AVIFileCreateStream /* ;Internal */
#endif		#endif


STDAPI AVIFileWriteData (PAVIFILE pfile,		STDAPI AVIFileWriteData (__in PAVIFILE pfile,
DWORD ckid,		__in DWORD ckid,
LPVOID lpData,		__in_bcount(cbData) LPVOID lpData,
LONG cbData);		__in LONG cbData);
STDAPI AVIFileReadData (PAVIFILE pfile,		STDAPI AVIFileReadData (__in PAVIFILE pfile,
DWORD ckid,		__in DWORD ckid,
LPVOID lpData,		__out_bcount_part(lpcbData, lpcbData)
LONG FAR *lpcbData);		LPVOID lpData,
STDAPI AVIFileEndRecord (PAVIFILE pfile);		__inout LONG FAR *lpcbData);
		STDAPI AVIFileEndRecord (__in PAVIFILE pfile);

STDAPI_(ULONG) AVIStreamAddRef (PAVISTREAM pavi);		STDAPI_(ULONG) AVIStreamAddRef (PAVISTREAM pavi);
STDAPI_(ULONG) AVIStreamRelease (PAVISTREAM pavi);		STDAPI_(ULONG) AVIStreamRelease (PAVISTREAM pavi);


STDAPI AVIStreamInfoW (PAVISTREAM pavi, LPAVISTREAMINFOW psi, LONG lSize);		STDAPI AVIStreamInfoW (__in PAVISTREAM pavi, __out_bcount(lSize) LPAVISTREAMINFO
STDAPI AVIStreamInfoA (PAVISTREAM pavi, LPAVISTREAMINFOA psi, LONG lSize);		W psi, __in LONG lSize);
		STDAPI AVIStreamInfoA (__in PAVISTREAM pavi, __out_bcount(lSize) LPAVISTREAMINFO
		A psi, __in LONG lSize);
#ifdef UNICODE		#ifdef UNICODE
#define AVIStreamInfo AVIStreamInfoW		#define AVIStreamInfo AVIStreamInfoW
#else		#else
#define AVIStreamInfo AVIStreamInfoA		#define AVIStreamInfo AVIStreamInfoA
#endif		#endif


STDAPI_(LONG) AVIStreamFindSample(PAVISTREAM pavi, LONG lPos, LONG lFlags);		STDAPI_(LONG) AVIStreamFindSample(__in PAVISTREAM pavi, __in LONG lPos, __in LON
STDAPI AVIStreamReadFormat (PAVISTREAM pavi, LONG lPos,LPVOID lpFormat,LONG FA		G lFlags);
R *lpcbFormat);		STDAPI AVIStreamReadFormat (__in PAVISTREAM pavi, __in LONG lPos,__out_bcount_
STDAPI AVIStreamSetFormat (PAVISTREAM pavi, LONG lPos,LPVOID lpFormat,LONG cb		part_opt(lpcbFormat,lpcbFormat) LPVOID lpFormat,__inout LONG FAR *lpcbFormat);
Format);		STDAPI AVIStreamSetFormat (__in PAVISTREAM pavi, __in LONG lPos,__in_bcount(c
STDAPI AVIStreamReadData (PAVISTREAM pavi, DWORD fcc, LPVOID lp, LONG FAR *l		bFormat) LPVOID lpFormat, __in LONG cbFormat);
pcb);		STDAPI AVIStreamReadData (__in PAVISTREAM pavi, __in DWORD fcc, __out_bcount
STDAPI AVIStreamWriteData (PAVISTREAM pavi, DWORD fcc, LPVOID lp, LONG cb);		_part_opt(lpcb, lpcb) LPVOID lp, __inout LONG FAR *lpcb);
		STDAPI AVIStreamWriteData (__in PAVISTREAM pavi, __in DWORD fcc, __in_bcount(
		cb) LPVOID lp, __in LONG cb);


STDAPI AVIStreamRead (PAVISTREAM pavi,		STDAPI AVIStreamRead (__in PAVISTREAM pavi,
LONG lStart,		__in LONG lStart,
LONG lSamples,		__in LONG lSamples,
LPVOID lpBuffer,		__out_bcount_opt(cbBuffer) LPVOID lpBuffer,
LONG cbBuffer,		__in LONG cbBuffer,
LONG FAR * plBytes,		__out_opt LONG FAR * plBytes,
LONG FAR * plSamples);		__out_opt LONG FAR * plSamples);
#define AVISTREAMREAD_CONVENIENT (-1L)		#define AVISTREAMREAD_CONVENIENT (-1L)


STDAPI AVIStreamWrite (PAVISTREAM pavi,		STDAPI AVIStreamWrite (__in PAVISTREAM pavi,
LONG lStart, LONG lSamples,		__in LONG lStart, __in LONG lSamples,
LPVOID lpBuffer, LONG cbBuffer, DWORD dwFlags,		__in_bcount(cbBuffer) LPVOID lpBuffer, __in LONG cb
LONG FAR *plSampWritten,		Buffer, __in DWORD dwFlags,
LONG FAR *plBytesWritten);		__out_opt LONG FAR *plSampWritten,
		__out_opt LONG FAR *plBytesWritten);

// Right now, these just use AVIStreamInfo() to get information, then		// Right now, these just use AVIStreamInfo() to get information, then
// return some of it. Can they be more efficient?		// return some of it. Can they be more efficient?

STDAPI_(LONG) AVIStreamStart (PAVISTREAM pavi);		STDAPI_(LONG) AVIStreamStart (__in PAVISTREAM pavi);
STDAPI_(LONG) AVIStreamLength (PAVISTREAM pavi);		STDAPI_(LONG) AVIStreamLength (__in PAVISTREAM pavi);
STDAPI_(LONG) AVIStreamTimeToSample (PAVISTREAM pavi, LONG lTime);		STDAPI_(LONG) AVIStreamTimeToSample (__in PAVISTREAM pavi, __in LONG lTime);
STDAPI_(LONG) AVIStreamSampleToTime (PAVISTREAM pavi, LONG lSample);		STDAPI_(LONG) AVIStreamSampleToTime (__in PAVISTREAM pavi, __in LONG lSample);


STDAPI AVIStreamBeginStreaming(PAVISTREAM pavi, LONG lStart, LONG lEnd, LONG lRa		STDAPI AVIStreamBeginStreaming(__in PAVISTREAM pavi, __in LONG lStart, __in LONG
te);		lEnd, __in LONG lRate);
STDAPI AVIStreamEndStreaming(PAVISTREAM pavi);		STDAPI AVIStreamEndStreaming(__in PAVISTREAM pavi);

//		//
// helper functions for using IGetFrame		// helper functions for using IGetFrame
//		//

STDAPI_(PGETFRAME) AVIStreamGetFrameOpen(PAVISTREAM pavi,		STDAPI_(PGETFRAME) AVIStreamGetFrameOpen(__in PAVISTREAM pavi,
LPBITMAPINFOHEADER lpbiWanted);		__in_opt LPBITMAPINFOHEADER lpbiWanted);
STDAPI_(LPVOID) AVIStreamGetFrame(PGETFRAME pg, LONG lPos);		STDAPI_(LPVOID) AVIStreamGetFrame(__in PGETFRAME pg, __in LONG lPos);
STDAPI AVIStreamGetFrameClose(PGETFRAME pg);		STDAPI AVIStreamGetFrameClose(__in PGETFRAME pg);

// !!! We need some way to place an advise on a stream....		// !!! We need some way to place an advise on a stream....
// STDAPI AVIStreamHasChanged (PAVISTREAM pavi);		// STDAPI AVIStreamHasChanged (PAVISTREAM pavi);

// Shortcut function		// Shortcut function

STDAPI AVIStreamOpenFromFileA(PAVISTREAM FAR *ppavi, LPCSTR szFile,		STDAPI AVIStreamOpenFromFileA(__deref_out PAVISTREAM FAR *ppavi, __in LPCSTR szF
DWORD fccType, LONG lParam,		ile,
UINT mode, CLSID FAR *pclsidHandler);		__in DWORD fccType, __in LONG lParam,
STDAPI AVIStreamOpenFromFileW(PAVISTREAM FAR *ppavi, LPCWSTR szFile,		__in UINT mode, __in_opt CLSID FAR *pclsidHandler);
DWORD fccType, LONG lParam,		STDAPI AVIStreamOpenFromFileW(__deref_out PAVISTREAM FAR *ppavi, LPCWSTR szFile,
UINT mode, CLSID FAR *pclsidHandler);		__in DWORD fccType, __in LONG lParam,
		__in UINT mode, __in_opt CLSID FAR *pclsidHandler);
#ifdef UNICODE		#ifdef UNICODE
#define AVIStreamOpenFromFile AVIStreamOpenFromFileW		#define AVIStreamOpenFromFile AVIStreamOpenFromFileW
#else		#else
#define AVIStreamOpenFromFile AVIStreamOpenFromFileA		#define AVIStreamOpenFromFile AVIStreamOpenFromFileA
#endif		#endif

// Use to create disembodied streams		// Use to create disembodied streams

STDAPI AVIStreamCreate(PAVISTREAM FAR *ppavi, LONG lParam1, LONG lParam2,		STDAPI AVIStreamCreate(__deref_out PAVISTREAM FAR *ppavi, __in LONG lParam1, __i
CLSID FAR *pclsidHandler);		n LONG lParam2,
		__in_opt CLSID FAR *pclsidHandler);

// PHANDLER AVIAPI AVIGetHandler (PAVISTREAM pavi, PAVISTREAMHANDLER psh);		// PHANDLER AVIAPI AVIGetHandler (PAVISTREAM pavi, PAVISTREAMHANDLER psh);
// PAVISTREAM AVIAPI AVIGetStream (PHANDLER p);		// PAVISTREAM AVIAPI AVIGetStream (PHANDLER p);

//		//
// flags for AVIStreamFindSample		// flags for AVIStreamFindSample
//		//
#define FIND_DIR 0x0000000FL // direction		#define FIND_DIR 0x0000000FL // direction
#define FIND_NEXT 0x00000001L // go forward		#define FIND_NEXT 0x00000001L // go forward
#define FIND_PREV 0x00000004L // go backward		#define FIND_PREV 0x00000004L // go backward

skipping to change at line 2474		skipping to change at line 2481
*		*
* AVISave routines and structures		* AVISave routines and structures
*		*
***************************************************************************/		***************************************************************************/

#ifndef comptypeDIB		#ifndef comptypeDIB
#define comptypeDIB mmioFOURCC('D', 'I', 'B', ' ')		#define comptypeDIB mmioFOURCC('D', 'I', 'B', ' ')
#endif		#endif

STDAPI AVIMakeCompressedStream(		STDAPI AVIMakeCompressedStream(

PAVISTREAM FAR * ppsCompressed,		__deref_out PAVISTREAM FAR * ppsCompressed,
PAVISTREAM ppsSource,		__in PAVISTREAM ppsSource,
AVICOMPRESSOPTIONS FAR * lpOptions,		__in AVICOMPRESSOPTIONS FAR * lpOptions,
CLSID FAR *pclsidHandler);		__in_opt CLSID FAR *pclsidHandler);

EXTERN_C HRESULT CDECL AVISaveA (LPCSTR szFile,		EXTERN_C HRESULT CDECL AVISaveA (LPCSTR szFile,

CLSID FAR *pclsidHandler,		__in_opt CLSID FAR *pclsidHandler,
AVISAVECALLBACK lpfnCallback,		__in AVISAVECALLBACK lpfnCallback,
int nStreams,		__in int nStreams,
PAVISTREAM pfile,		__in PAVISTREAM pfile,
LPAVICOMPRESSOPTIONS lpOptions,		__in LPAVICOMPRESSOPTIONS lpOptions,
...);		...);

STDAPI AVISaveVA(LPCSTR szFile,		STDAPI AVISaveVA(LPCSTR szFile,

CLSID FAR *pclsidHandler,		__in_opt CLSID FAR *pclsidHandler,
AVISAVECALLBACK lpfnCallback,		__in AVISAVECALLBACK lpfnCallback,
int nStreams,		__in int nStreams,
PAVISTREAM FAR * ppavi,		__in_ecount(nStreams) PAVISTREAM FAR * ppavi,
LPAVICOMPRESSOPTIONS FAR *plpOptions);		__in_ecount(nStreams) LPAVICOMPRESSOPTIONS FAR *plpOptions);
EXTERN_C HRESULT CDECL AVISaveW (LPCWSTR szFile,		EXTERN_C HRESULT CDECL AVISaveW (LPCWSTR szFile,

CLSID FAR *pclsidHandler,		__in_opt CLSID FAR *pclsidHandler,
AVISAVECALLBACK lpfnCallback,		__in AVISAVECALLBACK lpfnCallback,
int nStreams,		__in int nStreams,
PAVISTREAM pfile,		__in PAVISTREAM pfile,
LPAVICOMPRESSOPTIONS lpOptions,		__in LPAVICOMPRESSOPTIONS lpOptions,
...);		...);

STDAPI AVISaveVW(LPCWSTR szFile,		STDAPI AVISaveVW(LPCWSTR szFile,

CLSID FAR *pclsidHandler,		__in_opt CLSID FAR *pclsidHandler,
AVISAVECALLBACK lpfnCallback,		__in AVISAVECALLBACK lpfnCallback,
int nStreams,		__in int nStreams,
PAVISTREAM FAR * ppavi,		__in_ecount(nStreams) PAVISTREAM FAR * ppavi,
LPAVICOMPRESSOPTIONS FAR *plpOptions);		__in_ecount(nStreams) LPAVICOMPRESSOPTIONS FAR *plpOptions);
#ifdef UNICODE		#ifdef UNICODE
#define AVISave AVISaveW		#define AVISave AVISaveW
#define AVISaveV AVISaveVW		#define AVISaveV AVISaveVW
#else		#else
#define AVISave AVISaveA		#define AVISave AVISaveA
#define AVISaveV AVISaveVA		#define AVISaveV AVISaveVA
#endif		#endif


STDAPI_(INT_PTR) AVISaveOptions(HWND hwnd,		STDAPI_(INT_PTR) AVISaveOptions(__in HWND hwnd,
UINT uiFlags,		__in UINT uiFlags,
int nStreams,		__in int nStreams,
PAVISTREAM FAR *ppavi,		__in_ecount(nStreams) PAVISTREAM FAR *ppavi,
LPAVICOMPRESSOPTIONS FAR *plpOptions);		__inout_ecount(nStreams) LPAVICOMPRESSOPTIONS FAR *p
		lpOptions);

STDAPI AVISaveOptionsFree(int nStreams,		STDAPI AVISaveOptionsFree(int nStreams,

LPAVICOMPRESSOPTIONS FAR *plpOptions);		__in_ecount(nStreams) LPAVICOMPRESSOPTIONS FAR *plpO ptions);

// FLAGS FOR uiFlags:		// FLAGS FOR uiFlags:
//		//
// Same as the flags for ICCompressorChoose (see compman.h)		// Same as the flags for ICCompressorChoose (see compman.h)
// These determine what the compression options dialog for video streams		// These determine what the compression options dialog for video streams
// will look like.		// will look like.


STDAPI AVIBuildFilterW(LPWSTR lpszFilter, LONG cbFilter, BOOL fSaving);		STDAPI AVIBuildFilterW(__out_ecount(cbFilter) LPWSTR lpszFilter, __in LONG cbFil
STDAPI AVIBuildFilterA(LPSTR lpszFilter, LONG cbFilter, BOOL fSaving);		ter, __in BOOL fSaving);
		STDAPI AVIBuildFilterA(__out_ecount(cbFilter) LPSTR lpszFilter, __in LONG cbFilt
		er, __in BOOL fSaving);
#ifdef UNICODE		#ifdef UNICODE
#define AVIBuildFilter AVIBuildFilterW		#define AVIBuildFilter AVIBuildFilterW
#else		#else
#define AVIBuildFilter AVIBuildFilterA		#define AVIBuildFilter AVIBuildFilterA
#endif		#endif

STDAPI AVIMakeFileFromStreams(PAVIFILE FAR * ppfile,		STDAPI AVIMakeFileFromStreams(__deref_out PAVIFILE FAR * ppfile,
int nStreams,		__in int nStreams,
PAVISTREAM FAR * papStreams);		__in_ecount(nStreams) PAVISTREAM FAR * papStream
		s);


STDAPI AVIMakeStreamFromClipboard(UINT cfFormat, HANDLE hGlobal, PAVISTREAM FAR *ppstream);		STDAPI AVIMakeStreamFromClipboard(UINT cfFormat, __in HANDLE hGlobal, __deref_ou t PAVISTREAM FAR *ppstream);

/****************************************************************************		/****************************************************************************
*		*
* Clipboard routines		* Clipboard routines
*		*
***************************************************************************/		***************************************************************************/


STDAPI AVIPutFileOnClipboard(PAVIFILE pf);		STDAPI AVIPutFileOnClipboard(__in PAVIFILE pf);


STDAPI AVIGetFromClipboard(PAVIFILE FAR * lppf);		STDAPI AVIGetFromClipboard(__deref_out PAVIFILE FAR * lppf);

STDAPI AVIClearClipboard(void);		STDAPI AVIClearClipboard(void);

/****************************************************************************		/****************************************************************************
*		*
* Editing routines		* Editing routines
*		*
***************************************************************************/		***************************************************************************/
STDAPI CreateEditableStream(		STDAPI CreateEditableStream(

PAVISTREAM FAR * ppsEditable,		__deref_out PAVISTREAM FAR * ppsEditable,
PAVISTREAM psSource);		__in PAVISTREAM psSource);


STDAPI EditStreamCut(PAVISTREAM pavi, LONG FAR plStart, LONG FAR plLength, PAV ISTREAM FAR * ppResult);		STDAPI EditStreamCut(__in PAVISTREAM pavi, __inout LONG FAR plStart, __inout LO NG FAR plLength, __deref_out PAVISTREAM FAR * ppResult);


STDAPI EditStreamCopy(PAVISTREAM pavi, LONG FAR plStart, LONG FAR plLength, PA VISTREAM FAR * ppResult);		STDAPI EditStreamCopy(__in PAVISTREAM pavi, __inout LONG FAR plStart, __inout L ONG FAR plLength, __deref_out PAVISTREAM FAR * ppResult);


STDAPI EditStreamPaste(PAVISTREAM pavi, LONG FAR plPos, LONG FAR plLength, PAV ISTREAM pstream, LONG lStart, LONG lEnd);		STDAPI EditStreamPaste(__in PAVISTREAM pavi, __inout LONG FAR plPos, __inout LO NG FAR plLength, __in PAVISTREAM pstream, __in LONG lStart, __in LONG lEnd);


STDAPI EditStreamClone(PAVISTREAM pavi, PAVISTREAM FAR *ppResult);		STDAPI EditStreamClone(__in PAVISTREAM pavi, __deref_out PAVISTREAM FAR *ppResul t);


STDAPI EditStreamSetNameA(PAVISTREAM pavi, LPCSTR lpszName);		STDAPI EditStreamSetNameA(__in PAVISTREAM pavi, __in LPCSTR lpszName);
STDAPI EditStreamSetNameW(PAVISTREAM pavi, LPCWSTR lpszName);		STDAPI EditStreamSetNameW(__in PAVISTREAM pavi, __in LPCWSTR lpszName);
STDAPI EditStreamSetInfoW(PAVISTREAM pavi, LPAVISTREAMINFOW lpInfo, LONG cbInfo)		STDAPI EditStreamSetInfoW(__in PAVISTREAM pavi, __in_bcount(cbInfo) LPAVISTREAMI
;		NFOW lpInfo, __in LONG cbInfo);
STDAPI EditStreamSetInfoA(PAVISTREAM pavi, LPAVISTREAMINFOA lpInfo, LONG cbInfo)		STDAPI EditStreamSetInfoA(__in PAVISTREAM pavi, __in_bcount(cbInfo) LPAVISTREAMI
;		NFOA lpInfo, __in LONG cbInfo);
#ifdef UNICODE		#ifdef UNICODE
#define EditStreamSetInfo EditStreamSetInfoW		#define EditStreamSetInfo EditStreamSetInfoW
#define EditStreamSetName EditStreamSetNameW		#define EditStreamSetName EditStreamSetNameW
#else		#else
#define EditStreamSetInfo EditStreamSetInfoA		#define EditStreamSetInfo EditStreamSetInfoA
#define EditStreamSetName EditStreamSetNameA		#define EditStreamSetName EditStreamSetNameA
#endif		#endif

/* - - - - - - - - */		/* - - - - - - - - */


skipping to change at line 2707		skipping to change at line 2714
#ifdef __cplusplus		#ifdef __cplusplus
// MFC Redefines SendMessage, so make sure we get the global one....		// MFC Redefines SendMessage, so make sure we get the global one....
#define MCIWndSM ::SendMessage /* SendMessage in C++*/		#define MCIWndSM ::SendMessage /* SendMessage in C++*/
#else		#else
#define MCIWndSM SendMessage /* SendMessage in C */		#define MCIWndSM SendMessage /* SendMessage in C */
#endif /* __cplusplus */		#endif /* __cplusplus */
#define MCIWND_WINDOW_CLASS TEXT("MCIWndClass")		#define MCIWND_WINDOW_CLASS TEXT("MCIWndClass")
HWND		HWND
VFWAPIV		VFWAPIV
MCIWndCreateA(		MCIWndCreateA(

IN HWND hwndParent,		__in_opt HWND hwndParent,
IN HINSTANCE hInstance,		__in_opt HINSTANCE hInstance,
IN DWORD dwStyle,		__in DWORD dwStyle,
IN LPCSTR szFile		__in_opt LPCSTR szFile
);		);

HWND		HWND
VFWAPIV		VFWAPIV
MCIWndCreateW(		MCIWndCreateW(

IN HWND hwndParent,		__in_opt HWND hwndParent,
IN HINSTANCE hInstance,		__in_opt HINSTANCE hInstance,
IN DWORD dwStyle,		__in DWORD dwStyle,
IN LPCWSTR szFile		__in_opt LPCWSTR szFile
);		);

#ifdef UNICODE		#ifdef UNICODE
#define MCIWndCreate MCIWndCreateW		#define MCIWndCreate MCIWndCreateW
#else		#else
#define MCIWndCreate MCIWndCreateA		#define MCIWndCreate MCIWndCreateA
#endif		#endif
BOOL VFWAPIV MCIWndRegisterClass(void);		BOOL VFWAPIV MCIWndRegisterClass(void);

// Flags for the MCIWndOpen command		// Flags for the MCIWndOpen command

skipping to change at line 3548		skipping to change at line 3555
typedef struct tagCapInfoChunk {		typedef struct tagCapInfoChunk {
FOURCC fccInfoID; // Chunk ID, "ICOP" for copyright		FOURCC fccInfoID; // Chunk ID, "ICOP" for copyright
LPVOID lpData; // pointer to data		LPVOID lpData; // pointer to data
LONG cbData; // size of lpData		LONG cbData; // size of lpData
} CAPINFOCHUNK, PCAPINFOCHUNK, FAR LPCAPINFOCHUNK;		} CAPINFOCHUNK, PCAPINFOCHUNK, FAR LPCAPINFOCHUNK;

// ------------------------------------------------------------------		// ------------------------------------------------------------------
// Callback Definitions		// Callback Definitions
// ------------------------------------------------------------------		// ------------------------------------------------------------------


typedef LRESULT (CALLBACK* CAPYIELDCALLBACK) (HWND hWnd);		typedef LRESULT (CALLBACK* CAPYIELDCALLBACK) (__in HWND hWnd);
typedef LRESULT (CALLBACK* CAPSTATUSCALLBACKW) (HWND hWnd, int nID, LPCWSTR lpsz		typedef LRESULT (CALLBACK* CAPSTATUSCALLBACKW) (__in HWND hWnd, __in int nID, LP
);		CWSTR lpsz);
typedef LRESULT (CALLBACK* CAPERRORCALLBACKW) (HWND hWnd, int nID, LPCWSTR lpsz		typedef LRESULT (CALLBACK* CAPERRORCALLBACKW) (__in HWND hWnd, __in int nID, LP
);		CWSTR lpsz);
typedef LRESULT (CALLBACK* CAPSTATUSCALLBACKA) (HWND hWnd, int nID, LPCSTR lpsz)		typedef LRESULT (CALLBACK* CAPSTATUSCALLBACKA) (__in HWND hWnd, __in int nID, LP
;		CSTR lpsz);
typedef LRESULT (CALLBACK* CAPERRORCALLBACKA) (HWND hWnd, int nID, LPCSTR lpsz)		typedef LRESULT (CALLBACK* CAPERRORCALLBACKA) (__in HWND hWnd, __in int nID, LP
;		CSTR lpsz);
#ifdef UNICODE		#ifdef UNICODE
#define CAPSTATUSCALLBACK CAPSTATUSCALLBACKW		#define CAPSTATUSCALLBACK CAPSTATUSCALLBACKW
#define CAPERRORCALLBACK CAPERRORCALLBACKW		#define CAPERRORCALLBACK CAPERRORCALLBACKW
#else		#else
#define CAPSTATUSCALLBACK CAPSTATUSCALLBACKA		#define CAPSTATUSCALLBACK CAPSTATUSCALLBACKA
#define CAPERRORCALLBACK CAPERRORCALLBACKA		#define CAPERRORCALLBACK CAPERRORCALLBACKA
#endif		#endif

typedef LRESULT (CALLBACK* CAPVIDEOCALLBACK) (HWND hWnd, LPVIDEOHDR lpVHdr);		typedef LRESULT (CALLBACK* CAPVIDEOCALLBACK) (__in HWND hWnd, __in LPVIDEOHDR l
typedef LRESULT (CALLBACK* CAPWAVECALLBACK) (HWND hWnd, LPWAVEHDR lpWHdr);		pVHdr);
typedef LRESULT (CALLBACK* CAPCONTROLCALLBACK)(HWND hWnd, int nState);		typedef LRESULT (CALLBACK* CAPWAVECALLBACK) (__in HWND hWnd, __in LPWAVEHDR lp
		WHdr);
		typedef LRESULT (CALLBACK* CAPCONTROLCALLBACK)(__in HWND hWnd, __in int nState);

// ------------------------------------------------------------------		// ------------------------------------------------------------------
// CapControlCallback states		// CapControlCallback states
// ------------------------------------------------------------------		// ------------------------------------------------------------------
#define CONTROLCALLBACK_PREROLL 1 /* Waiting to start capture */		#define CONTROLCALLBACK_PREROLL 1 /* Waiting to start capture */
#define CONTROLCALLBACK_CAPTURING 2 /* Now capturing */		#define CONTROLCALLBACK_CAPTURING 2 /* Now capturing */

// ------------------------------------------------------------------		// ------------------------------------------------------------------
// The only exported functions from AVICAP.DLL		// The only exported functions from AVICAP.DLL
// ------------------------------------------------------------------		// ------------------------------------------------------------------

HWND VFWAPI capCreateCaptureWindowA (		HWND VFWAPI capCreateCaptureWindowA (
LPCSTR lpszWindowName,		LPCSTR lpszWindowName,

DWORD dwStyle,		__in DWORD dwStyle,
int x, int y, int nWidth, int nHeight,		__in int x, __in int y, __in int nWidth, __in int nHeight,
HWND hwndParent, int nID);		__in_opt HWND hwndParent, __in int nID);

BOOL VFWAPI capGetDriverDescriptionA (UINT wDriverIndex,		BOOL VFWAPI capGetDriverDescriptionA (UINT wDriverIndex,

LPSTR lpszName, int cbName,		__out_ecount(cbName) LPSTR lpszName, __in int cbName,
LPSTR lpszVer, int cbVer);		__out_ecount(cbVer) LPSTR lpszVer, __in int cbVer);

HWND VFWAPI capCreateCaptureWindowW (		HWND VFWAPI capCreateCaptureWindowW (
LPCWSTR lpszWindowName,		LPCWSTR lpszWindowName,
DWORD dwStyle,		DWORD dwStyle,

int x, int y, int nWidth, int nHeight,		__in int x, __in int y, __in int nWidth, __in int nHeight,
HWND hwndParent, int nID);		__in_opt HWND hwndParent, __in int nID);

BOOL VFWAPI capGetDriverDescriptionW (UINT wDriverIndex,		BOOL VFWAPI capGetDriverDescriptionW (UINT wDriverIndex,

LPWSTR lpszName, int cbName,		__out_ecount(cbName) LPWSTR lpszName, __in int cbName,
LPWSTR lpszVer, int cbVer);		__out_ecount(cbVer) LPWSTR lpszVer, __in int cbVer);
#ifdef UNICODE		#ifdef UNICODE
#define capCreateCaptureWindow capCreateCaptureWindowW		#define capCreateCaptureWindow capCreateCaptureWindowW
#define capGetDriverDescription capGetDriverDescriptionW		#define capGetDriverDescription capGetDriverDescriptionW
#else		#else
#define capCreateCaptureWindow capCreateCaptureWindowA		#define capCreateCaptureWindow capCreateCaptureWindowA
#define capGetDriverDescription capGetDriverDescriptionA		#define capGetDriverDescription capGetDriverDescriptionA
#endif		#endif

#endif /* RC_INVOKED */		#endif /* RC_INVOKED */


skipping to change at line 3709		skipping to change at line 3716
/****************************************************************************		/****************************************************************************
*		*
* FilePreview dialog.		* FilePreview dialog.
*		*
***************************************************************************/		***************************************************************************/
#ifdef OFN_READONLY		#ifdef OFN_READONLY

BOOL		BOOL
VFWAPI		VFWAPI
GetOpenFileNamePreviewA(		GetOpenFileNamePreviewA(

IN OUT LPOPENFILENAMEA lpofn		__inout LPOPENFILENAMEA lpofn
);		);

BOOL		BOOL
VFWAPI		VFWAPI
GetSaveFileNamePreviewA(		GetSaveFileNamePreviewA(

IN OUT LPOPENFILENAMEA lpofn		__inout LPOPENFILENAMEA lpofn
);		);

BOOL		BOOL
VFWAPI		VFWAPI
GetOpenFileNamePreviewW(		GetOpenFileNamePreviewW(

IN OUT LPOPENFILENAMEW lpofn		__inout LPOPENFILENAMEW lpofn
);		);

BOOL		BOOL
VFWAPI		VFWAPI
GetSaveFileNamePreviewW(		GetSaveFileNamePreviewW(

IN OUT LPOPENFILENAMEW lpofn		__inout LPOPENFILENAMEW lpofn
);		);

#ifdef UNICODE		#ifdef UNICODE
#define GetOpenFileNamePreview GetOpenFileNamePreviewW		#define GetOpenFileNamePreview GetOpenFileNamePreviewW
#define GetSaveFileNamePreview GetSaveFileNamePreviewW		#define GetSaveFileNamePreview GetSaveFileNamePreviewW
#else		#else
#define GetOpenFileNamePreview GetOpenFileNamePreviewA		#define GetOpenFileNamePreview GetOpenFileNamePreviewA
#define GetSaveFileNamePreview GetSaveFileNamePreviewA		#define GetSaveFileNamePreview GetSaveFileNamePreviewA
#endif		#endif


End of changes. 114 change blocks.
428 lines changed or deleted		476 lines changed or added

This html diff was produced by rfcdiff 1.41.