Hi,
More headers for the work I am doing on DirectShow. The file amvideo.idl
doesn't exist in the DirectShow SDK (version 8), but I hope this is an
appropriate extension.
Rob
Changelog:
- Add amvideo.{idl,h} and aviriff.hIndex: wine/include/Makefile.in
===================================================================
RCS file: /home/wine/wine/include/Makefile.in,v
retrieving revision 1.108
diff -u -r1.108 Makefile.in
--- wine/include/Makefile.in 4 Oct 2003 03:48:11 -0000 1.108
+++ wine/include/Makefile.in 21 Oct 2003 21:24:04 -0000
@@ -5,6 +5,7 @@
MODULE = none
IDL_SRCS = \
+ amvideo.idl \
comcat.idl \
docobj.idl \
exdisp.idl \
@@ -29,6 +30,7 @@
WINDOWS_INCLUDES = \
accctrl.h \
audevcod.h \
+ aviriff.h \
basetsd.h \
cderr.h \
cguid.h \
--- /dev/null Mon Jun 24 01:53:01 2002
+++ wine/include/amvideo.idl Tue Oct 21 22:33:55 2003
@@ -0,0 +1,232 @@
+/*
+ * Copyright (C) 2003 Robert Shearman
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+import "objidl.idl";
+
+/* trick widl into thinking that it knows the DirectDraw types
+ * as there is no IDL file for them (yet) */
+cpp_quote("#if 0")
+typedef void * LPDIRECTDRAW;
+typedef void DDSURFACEDESC,DDCAPS;
+typedef DWORD RGBQUAD;
+typedef LONGLONG REFERENCE_TIME;
+typedef struct
+{
+ DWORD biSize;
+ LONG biWidth;
+ LONG biHeight;
+ WORD biPlanes;
+ WORD biBitCount;
+ DWORD biCompression;
+ DWORD biSizeImage;
+ LONG biXPelsPerMeter;
+ LONG biYPelsPerMeter;
+ DWORD biClrUsed;
+ DWORD biClrImportant;
+} BITMAPINFOHEADER, *PBITMAPINFOHEADER, *LPBITMAPINFOHEADER;
+cpp_quote("#endif")
+
+cpp_quote("#include <ddraw.h>")
+
+cpp_quote("#define AMDDS_NONE 0x00")
+cpp_quote("#define AMDDS_DCIPS 0x01")
+cpp_quote("#define AMDDS_PS 0x02")
+cpp_quote("#define AMDDS_RGBOVR 0x04")
+cpp_quote("#define AMDDS_YUVOVR 0x08")
+cpp_quote("#define AMDDS_RGBOFF 0x10")
+cpp_quote("#define AMDDS_YUVOFF 0x20")
+cpp_quote("#define AMDDS_RGBFLP 0x40")
+cpp_quote("#define AMDDS_YUVFLP 0x80")
+cpp_quote("#define AMDDS_ALL 0xFF")
+cpp_quote("#define AMDDS_DEFAULT AMDDS_ALL")
+
+cpp_quote("#define AMDDS_YUV (AMDDS_YUVOFF | AMDDS_YUVOVR | AMDDS_YUVFLP)")
+cpp_quote("#define AMDDS_RGB (AMDDS_RGBOFF | AMDDS_RGBOVR | AMDDS_RGBFLP)")
+cpp_quote("#define AMDSS_PRIMARY (AMDDS_DCIPS | AMDDS_PS)")
+
+[
+ object,
+ pointer_default(unique)
+]
+interface IDirectDrawVideo : IUnknown
+{
+ HRESULT GetSwitches([out] DWORD * pSwitches);
+ HRESULT SetSwitches([in] DWORD Switches);
+ HRESULT GetCaps([out] DDCAPS * pCaps);
+ HRESULT GetEmulatedCaps([out] DDCAPS *pCaps);
+ HRESULT GetSurfaceDesc([out] DDSURFACEDESC * pSurfaceDesc);
+ HRESULT GetFourCCCodes([out] DWORD * pCount, [out] DWORD * pCodes);
+ HRESULT SetDirectDraw([in] LPDIRECTDRAW pDirectDraw);
+ HRESULT GetDirectDraw([out] LPDIRECTDRAW * ppDirectDraw);
+ HRESULT GetSurfaceType([out] DWORD * pSurfaceType);
+ HRESULT SetDefault();
+ HRESULT UseScanLine([in] long UseScanLine);
+ HRESULT CanUseScanLine([out] long * UseScanLine);
+ HRESULT UseOverlayStretch([in] long UseOverlayStretch);
+ HRESULT CanUseOverlayStretch([out] long * UseOverlayStretch);
+ HRESULT UseWhenFullScreen([in] long UseWhenFullScreen);
+ HRESULT WillUseFullScreen([out] long * UseWhenFullScreen);
+}
+
+[
+ object,
+ pointer_default(unique)
+]
+interface IQualProp : IUnknown
+{
+ HRESULT get_FramesDroppedInRenderer([out] int * pcFrames);
+ HRESULT get_FramesDrawn([out] int * pcFramesDrawn);
+ HRESULT get_AvgFrameRate([out] int * piAvgFrameRate);
+ HRESULT get_Jitter([out] int * iJitter);
+ HRESULT get_AvgSyncOffset([out] int * piAvg);
+ HRESULT get_DevSyncOffset([out] int * piDev);
+}
+
+[
+ object,
+ pointer_default(unique)
+]
+interface IFullScreenVideo : IUnknown
+{
+ HRESULT CountModes([out] long * pModes);
+ HRESULT GetModeInfo([in] long Mode, [out] long * pWidth, [out] long * pHeight, [out] long * pDepth);
+ HRESULT GetCurrentMode([out] long * pMode);
+ HRESULT IsModeAvailable([in] long Mode);
+ HRESULT IsModeEnabled([in] long Mode);
+ HRESULT SetEnabled([in] long Mode, [in] long bEnabled);
+ HRESULT GetClipFactor([out] long * pClipFactor);
+ HRESULT SetClipFactor([in] long ClipFactor);
+ HRESULT SetMessageDrain([in] HWND hwnd);
+ HRESULT GetMessageDrain([out] HWND * hwnd);
+ HRESULT SetMonitor([in] long Monitor);
+ HRESULT GetMonitor([out] long * Monitor);
+ HRESULT HideOnDeactivate([in] long Hide);
+ HRESULT IsHideOnDeactivate();
+ HRESULT SetCaption([in] BSTR strCaption);
+ HRESULT GetCaption([out] BSTR * pstrCaption);
+ HRESULT SetDefault();
+}
+
+[
+ object,
+ pointer_default(unique)
+]
+interface IFullScreenVideoEx : IFullScreenVideo
+{
+ HRESULT SetAcceleratorTable([in] HWND hwnd, [in] HACCEL hAccel);
+ HRESULT GetAcceleratorTable([out] HWND * phwnd, [out] HACCEL * phAccel);
+ HRESULT KeepPixelAspectRatio([in] long KeepAspect);
+ /* FIXME: not sure is this next method is an [out] */
+ HRESULT IsKeepPixelAspectRatio([out] long * pKeepAspect);
+}
+
+[
+ object,
+ pointer_default(unique)
+]
+interface IBaseVideoMixer : IUnknown
+{
+ HRESULT SetLeadPin([in] int iPin);
+ HRESULT GetLeadPin([out] int * piPin);
+ HRESULT GetInputPinCount([out] int * piPinCount);
+ HRESULT IsUsingClock([out] int * pbValue);
+ HRESULT SetUsingClock([in] int bValue);
+ HRESULT GetClockPeriod([out] int * pbValue);
+ HRESULT SetClockPeriod([in] int bValue);
+}
+
+#define iPALETTE_COLORS 256
+#define iMASK_COLORS 3
+
+cpp_quote("#define iPALETTE_COLORS 256")
+cpp_quote("#define iEGA_COLORS 16")
+cpp_quote("#define iMASK_COLORS 3")
+cpp_quote("#define iTRUECOLOR 16")
+cpp_quote("#define iRED 0")
+cpp_quote("#define iGREEN 1")
+cpp_quote("#define iBLUE 2")
+cpp_quote("#define iPALETTE 8")
+cpp_quote("#define iMAXBITS 8")
+
+typedef struct tag_TRUECOLORINFO
+{
+ DWORD dwBitMasks[iMASK_COLORS];
+ RGBQUAD bmiColors[iPALETTE_COLORS];
+} TRUECOLORINFO;
+
+typedef struct tagVIDEOINFOHEADER
+{
+ RECT rcSource;
+ RECT rcTarget;
+ DWORD dwBitRate;
+ DWORD dwBitErrorRate;
+ REFERENCE_TIME AvgTimePerFrame;
+
+ BITMAPINFOHEADER bmiHeader;
+} VIDEOINFOHEADER;
+
+typedef struct tagVIDEOINFO
+{
+ RECT rcSource;
+ RECT rcTarget;
+ DWORD dwBitRate;
+ DWORD dwBitErrorRate;
+ REFERENCE_TIME AvgTimePerFrame;
+
+ BITMAPINFOHEADER bmiHeader;
+
+ union
+ {
+ RGBQUAD bmiColors[iPALETTE_COLORS];
+ DWORD dwBitMasks[iMASK_COLORS];
+ TRUECOLORINFO TrueColorInfo;
+ };
+} VIDEOINFO;
+
+typedef struct tagMPEG1VIDEOINFO
+{
+ VIDEOINFOHEADER hdr;
+ DWORD dwStartTimeCode;
+ DWORD cbSequenceHeader;
+ BYTE bSequenceHeader[1];
+} MPEG1VIDEOINFO;
+
+cpp_quote("#define MAX_SIZE_MPEG1_SEQUENCE_INFO 140")
+cpp_quote("#define MPEG1_SEQUENCE_INFO(pv) ((const BYTE *)(pv)->bSequenceHeader)")
+
+typedef struct tagAnalogVideoInfo
+{
+ RECT rcSource;
+ RECT rcTarget;
+ DWORD dwActiveWidth;
+ DWORD dwActiveHeight;
+ REFERENCE_TIME AvgTimePerFrame;
+} ANALOGVIDEOINFO;
+
+typedef enum
+{
+ AM_PROPERTY_FRAMESTEP_STEP = 0x01,
+ AM_PROPERTY_FRAMESTEP_CANCEL = 0x02,
+ AM_PROPERTY_FRAMESTEP_CANSTEP = 0x03,
+ AM_PROPERTY_FRAMESTEP_CANSTEPMULTIPLE = 0x04
+} AM_PROPERTY_FRAMESTEP;
+
+typedef struct _AM_FRAMESTEP_STEP
+{
+ DWORD dwFramesToStep;
+} AM_FRAMESTEP_STEP;
--- /dev/null Mon Jun 24 01:53:01 2002
+++ wine/include/aviriff.h Tue Oct 21 22:33:58 2003
@@ -0,0 +1,164 @@
+/*
+ * Copyright (C) 2003 Robert Shearman
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+typedef struct _riffchunk
+{
+ FOURCC fcc;
+ DWORD cb;
+} RIFFCHUNK, * LPRIFFCHUNK;
+
+typedef struct _rifflist
+{
+ FOURCC fcc;
+ DWORD cb;
+ FOURCC fccListType;
+} RIFFLIST, * LPRIFFLIST;
+
+#define RIFFROUND(cb) ((cb) + ((cb)&1))
+#define RIFFNEXT(pChunk) (LPRIFFCHUNK)((LPBYTE)(pChunk)+sizeof(RIFFCHUNK)+RIFFROUND(((LPRIFFCHUNK)pChunk)->cb))
+
+/* flags for dwFlags member of AVIMAINHEADER */
+#define AVIF_HASINDEX 0x00000010
+#define AVIF_MUSTUSEINDEX 0x00000020
+#define AVIF_ISINTERLEAVED 0x00000100
+#define AVIF_TRUSTCKTYPE 0x00000800
+#define AVIF_WASCAPTUREFILE 0x00010000
+#define AVIF_COPYRIGHTED 0x00020000
+
+typedef struct _avimainheader
+{
+ FOURCC fcc;
+ DWORD cb;
+ DWORD dwMicroSecPerFrame;
+ DWORD dwMaxBytesPerSec;
+ DWORD dwPaddingGranularity;
+ DWORD dwFlags;
+ DWORD dwTotalFrames;
+ DWORD dwInitialFrames;
+ DWORD dwStreams;
+ DWORD dwSuggestedBufferSize;
+ DWORD dwWidth;
+ DWORD dwHeight;
+ DWORD dwReserved[4];
+} AVIMAINHEADER;
+
+typedef struct _aviextheader
+{
+ FOURCC fcc;
+ DWORD cb;
+ DWORD dwGrandFrames;
+ DWORD dwFuture[61];
+} AVIEXTHEADER;
+
+
+/* flags for dwFlags member of AVISTREAMHEADER */
+#define AVISF_DISABLED 0x00000001
+#define AVISF_VIDEO_PALCHANGES 0x00010000
+
+typedef struct _avistreamheader
+{
+ FOURCC fcc;
+ DWORD cb;
+ FOURCC fccType;
+ FOURCC fccHandler;
+ DWORD dwFlags;
+ WORD wPriority;
+ WORD wLanguage;
+ DWORD dwInitialFrames;
+ DWORD dwScale;
+ DWORD dwRate;
+ DWORD dwStart;
+ DWORD dwLength;
+ DWORD dwSuggestedBufferSize;
+ DWORD dwQuality;
+ DWORD dwSampleSize;
+ struct
+ {
+ short int left;
+ short int top;
+ short int right;
+ short int bottom;
+ } rcFrame;
+} AVISTREAMHEADER;
+
+/* flags for dwFlags member of _avioldindex_entry */
+#define AVIIF_LIST 0x00000001
+#define AVIIF_KEYFRAME 0x00000010
+#define AVIIF_NO_TIME 0x00000100
+#define AVIIF_COMPRESSOR 0x0FFF0000
+
+typedef struct _avioldindex
+{
+ FOURCC fcc;
+ DWORD cb;
+ struct _avioldindex_entry
+ {
+ DWORD dwChunkId;
+ DWORD dwFlags;
+ DWORD dwOffset;
+ DWORD dwSize;
+ } aIndex[0];
+} AVIOLDINDEX;
+
+typedef union _timecode
+{
+ struct
+ {
+ WORD wFrameRate;
+ WORD wFrameFract;
+ LONG cFrames;
+ } DUMMYSTRUCTNAME;
+ DWORDLONG qw;
+} TIMECODE;
+
+#define TIMECODE_RATE_30DROP 0
+
+/* flags for dwSMPTEflags member of TIMECODEDATA */
+#define TIMECODE_SMPTE_BINARY_GROUP 0x07
+#define TIMECODE_SMPTE_COLOR_FRAME 0x08
+
+typedef struct _timecodedata
+{
+ TIMECODE time;
+ DWORD dwSMPTEflags;
+ DWORD dwUser;
+} TIMECODEDATA;
+
+#define AVI_INDEX_OF_INDEXES 0x00
+#define AVI_INDEX_OF_CHUNKS 0x01
+#define AVI_INDEX_OF_TIMED_CHUNKS 0x02
+#define AVI_INDEX_OF_SUB_2FIELD 0x03
+#define AVI_INDEX_IS_DATA 0x80
+
+#define AVI_INDEX_SUB_DEFAULT 0x00
+#define AVI_INDEX_SUB_2FIELD 0x01
+
+typedef struct _avimetaindex
+{
+ FOURCC fcc;
+ UINT cb;
+ WORD wLongsPerEntry;
+ BYTE bIndexSubType;
+ BYTE bIndexType;
+ DWORD nEntriesInUse;
+ DWORD dwChunkId;
+ DWORD dwReserved[3];
+ DWORD adwIndex[0];
+} AVIMETAINDEX;
+
+/* FIXME: index structures missing */
--- /dev/null Mon Jun 24 01:53:01 2002
+++ wine/include/amvideo.h Tue Oct 21 22:34:01 2003
@@ -0,0 +1,1375 @@
+/*** Autogenerated by WIDL 0.1 from amvideo.idl - Do not edit ***/
+#include <rpc.h>
+#include <rpcndr.h>
+
+#ifndef __WIDL_AMVIDEO_H
+#define __WIDL_AMVIDEO_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include <objidl.h>
+#if 0
+typedef void *LPDIRECTDRAW;
+
+typedef void DDSURFACEDESC, DDCAPS;
+
+typedef DWORD RGBQUAD;
+
+typedef LONGLONG REFERENCE_TIME;
+
+typedef struct {
+ DWORD biSize;
+ LONG biWidth;
+ LONG biHeight;
+ WORD biPlanes;
+ WORD biBitCount;
+ DWORD biCompression;
+ DWORD biSizeImage;
+ LONG biXPelsPerMeter;
+ LONG biYPelsPerMeter;
+ DWORD biClrUsed;
+ DWORD biClrImportant;
+} BITMAPINFOHEADER, *PBITMAPINFOHEADER, *LPBITMAPINFOHEADER;
+
+#endif
+#include <ddraw.h>
+#define AMDDS_NONE 0x00
+#define AMDDS_DCIPS 0x01
+#define AMDDS_PS 0x02
+#define AMDDS_RGBOVR 0x04
+#define AMDDS_YUVOVR 0x08
+#define AMDDS_RGBOFF 0x10
+#define AMDDS_YUVOFF 0x20
+#define AMDDS_RGBFLP 0x40
+#define AMDDS_YUVFLP 0x80
+#define AMDDS_ALL 0xFF
+#define AMDDS_DEFAULT AMDDS_ALL
+#define AMDDS_YUV (AMDDS_YUVOFF | AMDDS_YUVOVR | AMDDS_YUVFLP)
+#define AMDDS_RGB (AMDDS_RGBOFF | AMDDS_RGBOVR | AMDDS_RGBFLP)
+#define AMDSS_PRIMARY (AMDDS_DCIPS | AMDDS_PS)
+#ifndef __IDirectDrawVideo_FWD_DEFINED__
+#define __IDirectDrawVideo_FWD_DEFINED__
+typedef struct IDirectDrawVideo IDirectDrawVideo;
+#endif
+
+/*****************************************************************************
+ * IDirectDrawVideo interface
+ */
+#ifndef __IDirectDrawVideo_INTERFACE_DEFINED__
+#define __IDirectDrawVideo_INTERFACE_DEFINED__
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IDirectDrawVideo : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE GetSwitches(
+ DWORD* pSwitches) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE SetSwitches(
+ DWORD Switches) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetCaps(
+ DDCAPS* pCaps) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetEmulatedCaps(
+ DDCAPS* pCaps) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetSurfaceDesc(
+ DDSURFACEDESC* pSurfaceDesc) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetFourCCCodes(
+ DWORD* pCount,
+ DWORD* pCodes) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE SetDirectDraw(
+ LPDIRECTDRAW pDirectDraw) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetDirectDraw(
+ LPDIRECTDRAW* ppDirectDraw) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetSurfaceType(
+ DWORD* pSurfaceType) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE SetDefault(
+ ) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE UseScanLine(
+ long UseScanLine) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE CanUseScanLine(
+ long* UseScanLine) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE UseOverlayStretch(
+ long UseOverlayStretch) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE CanUseOverlayStretch(
+ long* UseOverlayStretch) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE UseWhenFullScreen(
+ long UseWhenFullScreen) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE WillUseFullScreen(
+ long* UseWhenFullScreen) = 0;
+
+};
+#else
+typedef struct IDirectDrawVideoVtbl IDirectDrawVideoVtbl;
+struct IDirectDrawVideo {
+ const IDirectDrawVideoVtbl* lpVtbl;
+};
+struct IDirectDrawVideoVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IDirectDrawVideo* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IDirectDrawVideo* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IDirectDrawVideo* This);
+
+ /*** IDirectDrawVideo methods ***/
+ HRESULT (STDMETHODCALLTYPE *GetSwitches)(
+ IDirectDrawVideo* This,
+ DWORD* pSwitches);
+
+ HRESULT (STDMETHODCALLTYPE *SetSwitches)(
+ IDirectDrawVideo* This,
+ DWORD Switches);
+
+ HRESULT (STDMETHODCALLTYPE *GetCaps)(
+ IDirectDrawVideo* This,
+ DDCAPS* pCaps);
+
+ HRESULT (STDMETHODCALLTYPE *GetEmulatedCaps)(
+ IDirectDrawVideo* This,
+ DDCAPS* pCaps);
+
+ HRESULT (STDMETHODCALLTYPE *GetSurfaceDesc)(
+ IDirectDrawVideo* This,
+ DDSURFACEDESC* pSurfaceDesc);
+
+ HRESULT (STDMETHODCALLTYPE *GetFourCCCodes)(
+ IDirectDrawVideo* This,
+ DWORD* pCount,
+ DWORD* pCodes);
+
+ HRESULT (STDMETHODCALLTYPE *SetDirectDraw)(
+ IDirectDrawVideo* This,
+ LPDIRECTDRAW pDirectDraw);
+
+ HRESULT (STDMETHODCALLTYPE *GetDirectDraw)(
+ IDirectDrawVideo* This,
+ LPDIRECTDRAW* ppDirectDraw);
+
+ HRESULT (STDMETHODCALLTYPE *GetSurfaceType)(
+ IDirectDrawVideo* This,
+ DWORD* pSurfaceType);
+
+ HRESULT (STDMETHODCALLTYPE *SetDefault)(
+ IDirectDrawVideo* This);
+
+ HRESULT (STDMETHODCALLTYPE *UseScanLine)(
+ IDirectDrawVideo* This,
+ long UseScanLine);
+
+ HRESULT (STDMETHODCALLTYPE *CanUseScanLine)(
+ IDirectDrawVideo* This,
+ long* UseScanLine);
+
+ HRESULT (STDMETHODCALLTYPE *UseOverlayStretch)(
+ IDirectDrawVideo* This,
+ long UseOverlayStretch);
+
+ HRESULT (STDMETHODCALLTYPE *CanUseOverlayStretch)(
+ IDirectDrawVideo* This,
+ long* UseOverlayStretch);
+
+ HRESULT (STDMETHODCALLTYPE *UseWhenFullScreen)(
+ IDirectDrawVideo* This,
+ long UseWhenFullScreen);
+
+ HRESULT (STDMETHODCALLTYPE *WillUseFullScreen)(
+ IDirectDrawVideo* This,
+ long* UseWhenFullScreen);
+
+};
+
+/*** IUnknown methods ***/
+#define IDirectDrawVideo_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IDirectDrawVideo_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IDirectDrawVideo_Release(p) (p)->lpVtbl->Release(p)
+/*** IDirectDrawVideo methods ***/
+#define IDirectDrawVideo_GetSwitches(p,a) (p)->lpVtbl->GetSwitches(p,a)
+#define IDirectDrawVideo_SetSwitches(p,a) (p)->lpVtbl->SetSwitches(p,a)
+#define IDirectDrawVideo_GetCaps(p,a) (p)->lpVtbl->GetCaps(p,a)
+#define IDirectDrawVideo_GetEmulatedCaps(p,a) (p)->lpVtbl->GetEmulatedCaps(p,a)
+#define IDirectDrawVideo_GetSurfaceDesc(p,a) (p)->lpVtbl->GetSurfaceDesc(p,a)
+#define IDirectDrawVideo_GetFourCCCodes(p,a,b) (p)->lpVtbl->GetFourCCCodes(p,a,b)
+#define IDirectDrawVideo_SetDirectDraw(p,a) (p)->lpVtbl->SetDirectDraw(p,a)
+#define IDirectDrawVideo_GetDirectDraw(p,a) (p)->lpVtbl->GetDirectDraw(p,a)
+#define IDirectDrawVideo_GetSurfaceType(p,a) (p)->lpVtbl->GetSurfaceType(p,a)
+#define IDirectDrawVideo_SetDefault(p) (p)->lpVtbl->SetDefault(p)
+#define IDirectDrawVideo_UseScanLine(p,a) (p)->lpVtbl->UseScanLine(p,a)
+#define IDirectDrawVideo_CanUseScanLine(p,a) (p)->lpVtbl->CanUseScanLine(p,a)
+#define IDirectDrawVideo_UseOverlayStretch(p,a) (p)->lpVtbl->UseOverlayStretch(p,a)
+#define IDirectDrawVideo_CanUseOverlayStretch(p,a) (p)->lpVtbl->CanUseOverlayStretch(p,a)
+#define IDirectDrawVideo_UseWhenFullScreen(p,a) (p)->lpVtbl->UseWhenFullScreen(p,a)
+#define IDirectDrawVideo_WillUseFullScreen(p,a) (p)->lpVtbl->WillUseFullScreen(p,a)
+
+#endif
+
+#define IDirectDrawVideo_METHODS \
+ ICOM_MSVTABLE_COMPAT_FIELDS \
+ /*** IUnknown methods ***/ \
+ STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \
+ STDMETHOD_(ULONG,AddRef)(THIS) PURE; \
+ STDMETHOD_(ULONG,Release)(THIS) PURE; \
+ /*** IDirectDrawVideo methods ***/ \
+ STDMETHOD_(HRESULT,GetSwitches)(THIS_ DWORD* pSwitches) PURE; \
+ STDMETHOD_(HRESULT,SetSwitches)(THIS_ DWORD Switches) PURE; \
+ STDMETHOD_(HRESULT,GetCaps)(THIS_ DDCAPS* pCaps) PURE; \
+ STDMETHOD_(HRESULT,GetEmulatedCaps)(THIS_ DDCAPS* pCaps) PURE; \
+ STDMETHOD_(HRESULT,GetSurfaceDesc)(THIS_ DDSURFACEDESC* pSurfaceDesc) PURE; \
+ STDMETHOD_(HRESULT,GetFourCCCodes)(THIS_ DWORD* pCount, DWORD* pCodes) PURE; \
+ STDMETHOD_(HRESULT,SetDirectDraw)(THIS_ LPDIRECTDRAW pDirectDraw) PURE; \
+ STDMETHOD_(HRESULT,GetDirectDraw)(THIS_ LPDIRECTDRAW* ppDirectDraw) PURE; \
+ STDMETHOD_(HRESULT,GetSurfaceType)(THIS_ DWORD* pSurfaceType) PURE; \
+ STDMETHOD_(HRESULT,SetDefault)(THIS) PURE; \
+ STDMETHOD_(HRESULT,UseScanLine)(THIS_ long UseScanLine) PURE; \
+ STDMETHOD_(HRESULT,CanUseScanLine)(THIS_ long* UseScanLine) PURE; \
+ STDMETHOD_(HRESULT,UseOverlayStretch)(THIS_ long UseOverlayStretch) PURE; \
+ STDMETHOD_(HRESULT,CanUseOverlayStretch)(THIS_ long* UseOverlayStretch) PURE; \
+ STDMETHOD_(HRESULT,UseWhenFullScreen)(THIS_ long UseWhenFullScreen) PURE; \
+ STDMETHOD_(HRESULT,WillUseFullScreen)(THIS_ long* UseWhenFullScreen) PURE;
+
+HRESULT CALLBACK IDirectDrawVideo_GetSwitches_Proxy(
+ IDirectDrawVideo* This,
+ DWORD* pSwitches);
+void __RPC_STUB IDirectDrawVideo_GetSwitches_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IDirectDrawVideo_SetSwitches_Proxy(
+ IDirectDrawVideo* This,
+ DWORD Switches);
+void __RPC_STUB IDirectDrawVideo_SetSwitches_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IDirectDrawVideo_GetCaps_Proxy(
+ IDirectDrawVideo* This,
+ DDCAPS* pCaps);
+void __RPC_STUB IDirectDrawVideo_GetCaps_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IDirectDrawVideo_GetEmulatedCaps_Proxy(
+ IDirectDrawVideo* This,
+ DDCAPS* pCaps);
+void __RPC_STUB IDirectDrawVideo_GetEmulatedCaps_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IDirectDrawVideo_GetSurfaceDesc_Proxy(
+ IDirectDrawVideo* This,
+ DDSURFACEDESC* pSurfaceDesc);
+void __RPC_STUB IDirectDrawVideo_GetSurfaceDesc_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IDirectDrawVideo_GetFourCCCodes_Proxy(
+ IDirectDrawVideo* This,
+ DWORD* pCount,
+ DWORD* pCodes);
+void __RPC_STUB IDirectDrawVideo_GetFourCCCodes_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IDirectDrawVideo_SetDirectDraw_Proxy(
+ IDirectDrawVideo* This,
+ LPDIRECTDRAW pDirectDraw);
+void __RPC_STUB IDirectDrawVideo_SetDirectDraw_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IDirectDrawVideo_GetDirectDraw_Proxy(
+ IDirectDrawVideo* This,
+ LPDIRECTDRAW* ppDirectDraw);
+void __RPC_STUB IDirectDrawVideo_GetDirectDraw_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IDirectDrawVideo_GetSurfaceType_Proxy(
+ IDirectDrawVideo* This,
+ DWORD* pSurfaceType);
+void __RPC_STUB IDirectDrawVideo_GetSurfaceType_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IDirectDrawVideo_SetDefault_Proxy(
+ IDirectDrawVideo* This);
+void __RPC_STUB IDirectDrawVideo_SetDefault_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IDirectDrawVideo_UseScanLine_Proxy(
+ IDirectDrawVideo* This,
+ long UseScanLine);
+void __RPC_STUB IDirectDrawVideo_UseScanLine_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IDirectDrawVideo_CanUseScanLine_Proxy(
+ IDirectDrawVideo* This,
+ long* UseScanLine);
+void __RPC_STUB IDirectDrawVideo_CanUseScanLine_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IDirectDrawVideo_UseOverlayStretch_Proxy(
+ IDirectDrawVideo* This,
+ long UseOverlayStretch);
+void __RPC_STUB IDirectDrawVideo_UseOverlayStretch_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IDirectDrawVideo_CanUseOverlayStretch_Proxy(
+ IDirectDrawVideo* This,
+ long* UseOverlayStretch);
+void __RPC_STUB IDirectDrawVideo_CanUseOverlayStretch_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IDirectDrawVideo_UseWhenFullScreen_Proxy(
+ IDirectDrawVideo* This,
+ long UseWhenFullScreen);
+void __RPC_STUB IDirectDrawVideo_UseWhenFullScreen_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IDirectDrawVideo_WillUseFullScreen_Proxy(
+ IDirectDrawVideo* This,
+ long* UseWhenFullScreen);
+void __RPC_STUB IDirectDrawVideo_WillUseFullScreen_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+#endif /* __IDirectDrawVideo_INTERFACE_DEFINED__ */
+
+#ifndef __IQualProp_FWD_DEFINED__
+#define __IQualProp_FWD_DEFINED__
+typedef struct IQualProp IQualProp;
+#endif
+
+/*****************************************************************************
+ * IQualProp interface
+ */
+#ifndef __IQualProp_INTERFACE_DEFINED__
+#define __IQualProp_INTERFACE_DEFINED__
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IQualProp : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE get_FramesDroppedInRenderer(
+ int* pcFrames) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_FramesDrawn(
+ int* pcFramesDrawn) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_AvgFrameRate(
+ int* piAvgFrameRate) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_Jitter(
+ int* iJitter) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_AvgSyncOffset(
+ int* piAvg) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_DevSyncOffset(
+ int* piDev) = 0;
+
+};
+#else
+typedef struct IQualPropVtbl IQualPropVtbl;
+struct IQualProp {
+ const IQualPropVtbl* lpVtbl;
+};
+struct IQualPropVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IQualProp* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IQualProp* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IQualProp* This);
+
+ /*** IQualProp methods ***/
+ HRESULT (STDMETHODCALLTYPE *get_FramesDroppedInRenderer)(
+ IQualProp* This,
+ int* pcFrames);
+
+ HRESULT (STDMETHODCALLTYPE *get_FramesDrawn)(
+ IQualProp* This,
+ int* pcFramesDrawn);
+
+ HRESULT (STDMETHODCALLTYPE *get_AvgFrameRate)(
+ IQualProp* This,
+ int* piAvgFrameRate);
+
+ HRESULT (STDMETHODCALLTYPE *get_Jitter)(
+ IQualProp* This,
+ int* iJitter);
+
+ HRESULT (STDMETHODCALLTYPE *get_AvgSyncOffset)(
+ IQualProp* This,
+ int* piAvg);
+
+ HRESULT (STDMETHODCALLTYPE *get_DevSyncOffset)(
+ IQualProp* This,
+ int* piDev);
+
+};
+
+/*** IUnknown methods ***/
+#define IQualProp_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IQualProp_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IQualProp_Release(p) (p)->lpVtbl->Release(p)
+/*** IQualProp methods ***/
+#define IQualProp_get_FramesDroppedInRenderer(p,a) (p)->lpVtbl->get_FramesDroppedInRenderer(p,a)
+#define IQualProp_get_FramesDrawn(p,a) (p)->lpVtbl->get_FramesDrawn(p,a)
+#define IQualProp_get_AvgFrameRate(p,a) (p)->lpVtbl->get_AvgFrameRate(p,a)
+#define IQualProp_get_Jitter(p,a) (p)->lpVtbl->get_Jitter(p,a)
+#define IQualProp_get_AvgSyncOffset(p,a) (p)->lpVtbl->get_AvgSyncOffset(p,a)
+#define IQualProp_get_DevSyncOffset(p,a) (p)->lpVtbl->get_DevSyncOffset(p,a)
+
+#endif
+
+#define IQualProp_METHODS \
+ ICOM_MSVTABLE_COMPAT_FIELDS \
+ /*** IUnknown methods ***/ \
+ STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \
+ STDMETHOD_(ULONG,AddRef)(THIS) PURE; \
+ STDMETHOD_(ULONG,Release)(THIS) PURE; \
+ /*** IQualProp methods ***/ \
+ STDMETHOD_(HRESULT,get_FramesDroppedInRenderer)(THIS_ int* pcFrames) PURE; \
+ STDMETHOD_(HRESULT,get_FramesDrawn)(THIS_ int* pcFramesDrawn) PURE; \
+ STDMETHOD_(HRESULT,get_AvgFrameRate)(THIS_ int* piAvgFrameRate) PURE; \
+ STDMETHOD_(HRESULT,get_Jitter)(THIS_ int* iJitter) PURE; \
+ STDMETHOD_(HRESULT,get_AvgSyncOffset)(THIS_ int* piAvg) PURE; \
+ STDMETHOD_(HRESULT,get_DevSyncOffset)(THIS_ int* piDev) PURE;
+
+HRESULT CALLBACK IQualProp_get_FramesDroppedInRenderer_Proxy(
+ IQualProp* This,
+ int* pcFrames);
+void __RPC_STUB IQualProp_get_FramesDroppedInRenderer_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IQualProp_get_FramesDrawn_Proxy(
+ IQualProp* This,
+ int* pcFramesDrawn);
+void __RPC_STUB IQualProp_get_FramesDrawn_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IQualProp_get_AvgFrameRate_Proxy(
+ IQualProp* This,
+ int* piAvgFrameRate);
+void __RPC_STUB IQualProp_get_AvgFrameRate_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IQualProp_get_Jitter_Proxy(
+ IQualProp* This,
+ int* iJitter);
+void __RPC_STUB IQualProp_get_Jitter_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IQualProp_get_AvgSyncOffset_Proxy(
+ IQualProp* This,
+ int* piAvg);
+void __RPC_STUB IQualProp_get_AvgSyncOffset_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IQualProp_get_DevSyncOffset_Proxy(
+ IQualProp* This,
+ int* piDev);
+void __RPC_STUB IQualProp_get_DevSyncOffset_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+#endif /* __IQualProp_INTERFACE_DEFINED__ */
+
+#ifndef __IFullScreenVideo_FWD_DEFINED__
+#define __IFullScreenVideo_FWD_DEFINED__
+typedef struct IFullScreenVideo IFullScreenVideo;
+#endif
+
+/*****************************************************************************
+ * IFullScreenVideo interface
+ */
+#ifndef __IFullScreenVideo_INTERFACE_DEFINED__
+#define __IFullScreenVideo_INTERFACE_DEFINED__
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IFullScreenVideo : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE CountModes(
+ long* pModes) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetModeInfo(
+ long Mode,
+ long* pWidth,
+ long* pHeight,
+ long* pDepth) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetCurrentMode(
+ long* pMode) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE IsModeAvailable(
+ long Mode) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE IsModeEnabled(
+ long Mode) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE SetEnabled(
+ long Mode,
+ long bEnabled) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetClipFactor(
+ long* pClipFactor) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE SetClipFactor(
+ long ClipFactor) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE SetMessageDrain(
+ HWND hwnd) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetMessageDrain(
+ HWND* hwnd) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE SetMonitor(
+ long Monitor) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetMonitor(
+ long* Monitor) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE HideOnDeactivate(
+ long Hide) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE IsHideOnDeactivate(
+ ) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE SetCaption(
+ BSTR strCaption) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetCaption(
+ BSTR* pstrCaption) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE SetDefault(
+ ) = 0;
+
+};
+#else
+typedef struct IFullScreenVideoVtbl IFullScreenVideoVtbl;
+struct IFullScreenVideo {
+ const IFullScreenVideoVtbl* lpVtbl;
+};
+struct IFullScreenVideoVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IFullScreenVideo* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IFullScreenVideo* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IFullScreenVideo* This);
+
+ /*** IFullScreenVideo methods ***/
+ HRESULT (STDMETHODCALLTYPE *CountModes)(
+ IFullScreenVideo* This,
+ long* pModes);
+
+ HRESULT (STDMETHODCALLTYPE *GetModeInfo)(
+ IFullScreenVideo* This,
+ long Mode,
+ long* pWidth,
+ long* pHeight,
+ long* pDepth);
+
+ HRESULT (STDMETHODCALLTYPE *GetCurrentMode)(
+ IFullScreenVideo* This,
+ long* pMode);
+
+ HRESULT (STDMETHODCALLTYPE *IsModeAvailable)(
+ IFullScreenVideo* This,
+ long Mode);
+
+ HRESULT (STDMETHODCALLTYPE *IsModeEnabled)(
+ IFullScreenVideo* This,
+ long Mode);
+
+ HRESULT (STDMETHODCALLTYPE *SetEnabled)(
+ IFullScreenVideo* This,
+ long Mode,
+ long bEnabled);
+
+ HRESULT (STDMETHODCALLTYPE *GetClipFactor)(
+ IFullScreenVideo* This,
+ long* pClipFactor);
+
+ HRESULT (STDMETHODCALLTYPE *SetClipFactor)(
+ IFullScreenVideo* This,
+ long ClipFactor);
+
+ HRESULT (STDMETHODCALLTYPE *SetMessageDrain)(
+ IFullScreenVideo* This,
+ HWND hwnd);
+
+ HRESULT (STDMETHODCALLTYPE *GetMessageDrain)(
+ IFullScreenVideo* This,
+ HWND* hwnd);
+
+ HRESULT (STDMETHODCALLTYPE *SetMonitor)(
+ IFullScreenVideo* This,
+ long Monitor);
+
+ HRESULT (STDMETHODCALLTYPE *GetMonitor)(
+ IFullScreenVideo* This,
+ long* Monitor);
+
+ HRESULT (STDMETHODCALLTYPE *HideOnDeactivate)(
+ IFullScreenVideo* This,
+ long Hide);
+
+ HRESULT (STDMETHODCALLTYPE *IsHideOnDeactivate)(
+ IFullScreenVideo* This);
+
+ HRESULT (STDMETHODCALLTYPE *SetCaption)(
+ IFullScreenVideo* This,
+ BSTR strCaption);
+
+ HRESULT (STDMETHODCALLTYPE *GetCaption)(
+ IFullScreenVideo* This,
+ BSTR* pstrCaption);
+
+ HRESULT (STDMETHODCALLTYPE *SetDefault)(
+ IFullScreenVideo* This);
+
+};
+
+/*** IUnknown methods ***/
+#define IFullScreenVideo_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IFullScreenVideo_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IFullScreenVideo_Release(p) (p)->lpVtbl->Release(p)
+/*** IFullScreenVideo methods ***/
+#define IFullScreenVideo_CountModes(p,a) (p)->lpVtbl->CountModes(p,a)
+#define IFullScreenVideo_GetModeInfo(p,a,b,c,d) (p)->lpVtbl->GetModeInfo(p,a,b,c,d)
+#define IFullScreenVideo_GetCurrentMode(p,a) (p)->lpVtbl->GetCurrentMode(p,a)
+#define IFullScreenVideo_IsModeAvailable(p,a) (p)->lpVtbl->IsModeAvailable(p,a)
+#define IFullScreenVideo_IsModeEnabled(p,a) (p)->lpVtbl->IsModeEnabled(p,a)
+#define IFullScreenVideo_SetEnabled(p,a,b) (p)->lpVtbl->SetEnabled(p,a,b)
+#define IFullScreenVideo_GetClipFactor(p,a) (p)->lpVtbl->GetClipFactor(p,a)
+#define IFullScreenVideo_SetClipFactor(p,a) (p)->lpVtbl->SetClipFactor(p,a)
+#define IFullScreenVideo_SetMessageDrain(p,a) (p)->lpVtbl->SetMessageDrain(p,a)
+#define IFullScreenVideo_GetMessageDrain(p,a) (p)->lpVtbl->GetMessageDrain(p,a)
+#define IFullScreenVideo_SetMonitor(p,a) (p)->lpVtbl->SetMonitor(p,a)
+#define IFullScreenVideo_GetMonitor(p,a) (p)->lpVtbl->GetMonitor(p,a)
+#define IFullScreenVideo_HideOnDeactivate(p,a) (p)->lpVtbl->HideOnDeactivate(p,a)
+#define IFullScreenVideo_IsHideOnDeactivate(p) (p)->lpVtbl->IsHideOnDeactivate(p)
+#define IFullScreenVideo_SetCaption(p,a) (p)->lpVtbl->SetCaption(p,a)
+#define IFullScreenVideo_GetCaption(p,a) (p)->lpVtbl->GetCaption(p,a)
+#define IFullScreenVideo_SetDefault(p) (p)->lpVtbl->SetDefault(p)
+
+#endif
+
+#define IFullScreenVideo_METHODS \
+ ICOM_MSVTABLE_COMPAT_FIELDS \
+ /*** IUnknown methods ***/ \
+ STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \
+ STDMETHOD_(ULONG,AddRef)(THIS) PURE; \
+ STDMETHOD_(ULONG,Release)(THIS) PURE; \
+ /*** IFullScreenVideo methods ***/ \
+ STDMETHOD_(HRESULT,CountModes)(THIS_ long* pModes) PURE; \
+ STDMETHOD_(HRESULT,GetModeInfo)(THIS_ long Mode, long* pWidth, long* pHeight, long* pDepth) PURE; \
+ STDMETHOD_(HRESULT,GetCurrentMode)(THIS_ long* pMode) PURE; \
+ STDMETHOD_(HRESULT,IsModeAvailable)(THIS_ long Mode) PURE; \
+ STDMETHOD_(HRESULT,IsModeEnabled)(THIS_ long Mode) PURE; \
+ STDMETHOD_(HRESULT,SetEnabled)(THIS_ long Mode, long bEnabled) PURE; \
+ STDMETHOD_(HRESULT,GetClipFactor)(THIS_ long* pClipFactor) PURE; \
+ STDMETHOD_(HRESULT,SetClipFactor)(THIS_ long ClipFactor) PURE; \
+ STDMETHOD_(HRESULT,SetMessageDrain)(THIS_ HWND hwnd) PURE; \
+ STDMETHOD_(HRESULT,GetMessageDrain)(THIS_ HWND* hwnd) PURE; \
+ STDMETHOD_(HRESULT,SetMonitor)(THIS_ long Monitor) PURE; \
+ STDMETHOD_(HRESULT,GetMonitor)(THIS_ long* Monitor) PURE; \
+ STDMETHOD_(HRESULT,HideOnDeactivate)(THIS_ long Hide) PURE; \
+ STDMETHOD_(HRESULT,IsHideOnDeactivate)(THIS) PURE; \
+ STDMETHOD_(HRESULT,SetCaption)(THIS_ BSTR strCaption) PURE; \
+ STDMETHOD_(HRESULT,GetCaption)(THIS_ BSTR* pstrCaption) PURE; \
+ STDMETHOD_(HRESULT,SetDefault)(THIS) PURE;
+
+HRESULT CALLBACK IFullScreenVideo_CountModes_Proxy(
+ IFullScreenVideo* This,
+ long* pModes);
+void __RPC_STUB IFullScreenVideo_CountModes_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFullScreenVideo_GetModeInfo_Proxy(
+ IFullScreenVideo* This,
+ long Mode,
+ long* pWidth,
+ long* pHeight,
+ long* pDepth);
+void __RPC_STUB IFullScreenVideo_GetModeInfo_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFullScreenVideo_GetCurrentMode_Proxy(
+ IFullScreenVideo* This,
+ long* pMode);
+void __RPC_STUB IFullScreenVideo_GetCurrentMode_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFullScreenVideo_IsModeAvailable_Proxy(
+ IFullScreenVideo* This,
+ long Mode);
+void __RPC_STUB IFullScreenVideo_IsModeAvailable_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFullScreenVideo_IsModeEnabled_Proxy(
+ IFullScreenVideo* This,
+ long Mode);
+void __RPC_STUB IFullScreenVideo_IsModeEnabled_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFullScreenVideo_SetEnabled_Proxy(
+ IFullScreenVideo* This,
+ long Mode,
+ long bEnabled);
+void __RPC_STUB IFullScreenVideo_SetEnabled_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFullScreenVideo_GetClipFactor_Proxy(
+ IFullScreenVideo* This,
+ long* pClipFactor);
+void __RPC_STUB IFullScreenVideo_GetClipFactor_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFullScreenVideo_SetClipFactor_Proxy(
+ IFullScreenVideo* This,
+ long ClipFactor);
+void __RPC_STUB IFullScreenVideo_SetClipFactor_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFullScreenVideo_SetMessageDrain_Proxy(
+ IFullScreenVideo* This,
+ HWND hwnd);
+void __RPC_STUB IFullScreenVideo_SetMessageDrain_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFullScreenVideo_GetMessageDrain_Proxy(
+ IFullScreenVideo* This,
+ HWND* hwnd);
+void __RPC_STUB IFullScreenVideo_GetMessageDrain_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFullScreenVideo_SetMonitor_Proxy(
+ IFullScreenVideo* This,
+ long Monitor);
+void __RPC_STUB IFullScreenVideo_SetMonitor_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFullScreenVideo_GetMonitor_Proxy(
+ IFullScreenVideo* This,
+ long* Monitor);
+void __RPC_STUB IFullScreenVideo_GetMonitor_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFullScreenVideo_HideOnDeactivate_Proxy(
+ IFullScreenVideo* This,
+ long Hide);
+void __RPC_STUB IFullScreenVideo_HideOnDeactivate_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFullScreenVideo_IsHideOnDeactivate_Proxy(
+ IFullScreenVideo* This);
+void __RPC_STUB IFullScreenVideo_IsHideOnDeactivate_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFullScreenVideo_SetCaption_Proxy(
+ IFullScreenVideo* This,
+ BSTR strCaption);
+void __RPC_STUB IFullScreenVideo_SetCaption_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFullScreenVideo_GetCaption_Proxy(
+ IFullScreenVideo* This,
+ BSTR* pstrCaption);
+void __RPC_STUB IFullScreenVideo_GetCaption_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFullScreenVideo_SetDefault_Proxy(
+ IFullScreenVideo* This);
+void __RPC_STUB IFullScreenVideo_SetDefault_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+#endif /* __IFullScreenVideo_INTERFACE_DEFINED__ */
+
+#ifndef __IFullScreenVideoEx_FWD_DEFINED__
+#define __IFullScreenVideoEx_FWD_DEFINED__
+typedef struct IFullScreenVideoEx IFullScreenVideoEx;
+#endif
+
+/*****************************************************************************
+ * IFullScreenVideoEx interface
+ */
+#ifndef __IFullScreenVideoEx_INTERFACE_DEFINED__
+#define __IFullScreenVideoEx_INTERFACE_DEFINED__
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IFullScreenVideoEx : public IFullScreenVideo
+{
+ virtual HRESULT STDMETHODCALLTYPE SetAcceleratorTable(
+ HWND hwnd,
+ HACCEL hAccel) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetAcceleratorTable(
+ HWND* phwnd,
+ HACCEL* phAccel) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE KeepPixelAspectRatio(
+ long KeepAspect) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE IsKeepPixelAspectRatio(
+ long* pKeepAspect) = 0;
+
+};
+#else
+typedef struct IFullScreenVideoExVtbl IFullScreenVideoExVtbl;
+struct IFullScreenVideoEx {
+ const IFullScreenVideoExVtbl* lpVtbl;
+};
+struct IFullScreenVideoExVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IFullScreenVideoEx* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IFullScreenVideoEx* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IFullScreenVideoEx* This);
+
+ /*** IFullScreenVideo methods ***/
+ HRESULT (STDMETHODCALLTYPE *CountModes)(
+ IFullScreenVideoEx* This,
+ long* pModes);
+
+ HRESULT (STDMETHODCALLTYPE *GetModeInfo)(
+ IFullScreenVideoEx* This,
+ long Mode,
+ long* pWidth,
+ long* pHeight,
+ long* pDepth);
+
+ HRESULT (STDMETHODCALLTYPE *GetCurrentMode)(
+ IFullScreenVideoEx* This,
+ long* pMode);
+
+ HRESULT (STDMETHODCALLTYPE *IsModeAvailable)(
+ IFullScreenVideoEx* This,
+ long Mode);
+
+ HRESULT (STDMETHODCALLTYPE *IsModeEnabled)(
+ IFullScreenVideoEx* This,
+ long Mode);
+
+ HRESULT (STDMETHODCALLTYPE *SetEnabled)(
+ IFullScreenVideoEx* This,
+ long Mode,
+ long bEnabled);
+
+ HRESULT (STDMETHODCALLTYPE *GetClipFactor)(
+ IFullScreenVideoEx* This,
+ long* pClipFactor);
+
+ HRESULT (STDMETHODCALLTYPE *SetClipFactor)(
+ IFullScreenVideoEx* This,
+ long ClipFactor);
+
+ HRESULT (STDMETHODCALLTYPE *SetMessageDrain)(
+ IFullScreenVideoEx* This,
+ HWND hwnd);
+
+ HRESULT (STDMETHODCALLTYPE *GetMessageDrain)(
+ IFullScreenVideoEx* This,
+ HWND* hwnd);
+
+ HRESULT (STDMETHODCALLTYPE *SetMonitor)(
+ IFullScreenVideoEx* This,
+ long Monitor);
+
+ HRESULT (STDMETHODCALLTYPE *GetMonitor)(
+ IFullScreenVideoEx* This,
+ long* Monitor);
+
+ HRESULT (STDMETHODCALLTYPE *HideOnDeactivate)(
+ IFullScreenVideoEx* This,
+ long Hide);
+
+ HRESULT (STDMETHODCALLTYPE *IsHideOnDeactivate)(
+ IFullScreenVideoEx* This);
+
+ HRESULT (STDMETHODCALLTYPE *SetCaption)(
+ IFullScreenVideoEx* This,
+ BSTR strCaption);
+
+ HRESULT (STDMETHODCALLTYPE *GetCaption)(
+ IFullScreenVideoEx* This,
+ BSTR* pstrCaption);
+
+ HRESULT (STDMETHODCALLTYPE *SetDefault)(
+ IFullScreenVideoEx* This);
+
+ /*** IFullScreenVideoEx methods ***/
+ HRESULT (STDMETHODCALLTYPE *SetAcceleratorTable)(
+ IFullScreenVideoEx* This,
+ HWND hwnd,
+ HACCEL hAccel);
+
+ HRESULT (STDMETHODCALLTYPE *GetAcceleratorTable)(
+ IFullScreenVideoEx* This,
+ HWND* phwnd,
+ HACCEL* phAccel);
+
+ HRESULT (STDMETHODCALLTYPE *KeepPixelAspectRatio)(
+ IFullScreenVideoEx* This,
+ long KeepAspect);
+
+ HRESULT (STDMETHODCALLTYPE *IsKeepPixelAspectRatio)(
+ IFullScreenVideoEx* This,
+ long* pKeepAspect);
+
+};
+
+/*** IUnknown methods ***/
+#define IFullScreenVideoEx_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IFullScreenVideoEx_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IFullScreenVideoEx_Release(p) (p)->lpVtbl->Release(p)
+/*** IFullScreenVideo methods ***/
+#define IFullScreenVideoEx_CountModes(p,a) (p)->lpVtbl->CountModes(p,a)
+#define IFullScreenVideoEx_GetModeInfo(p,a,b,c,d) (p)->lpVtbl->GetModeInfo(p,a,b,c,d)
+#define IFullScreenVideoEx_GetCurrentMode(p,a) (p)->lpVtbl->GetCurrentMode(p,a)
+#define IFullScreenVideoEx_IsModeAvailable(p,a) (p)->lpVtbl->IsModeAvailable(p,a)
+#define IFullScreenVideoEx_IsModeEnabled(p,a) (p)->lpVtbl->IsModeEnabled(p,a)
+#define IFullScreenVideoEx_SetEnabled(p,a,b) (p)->lpVtbl->SetEnabled(p,a,b)
+#define IFullScreenVideoEx_GetClipFactor(p,a) (p)->lpVtbl->GetClipFactor(p,a)
+#define IFullScreenVideoEx_SetClipFactor(p,a) (p)->lpVtbl->SetClipFactor(p,a)
+#define IFullScreenVideoEx_SetMessageDrain(p,a) (p)->lpVtbl->SetMessageDrain(p,a)
+#define IFullScreenVideoEx_GetMessageDrain(p,a) (p)->lpVtbl->GetMessageDrain(p,a)
+#define IFullScreenVideoEx_SetMonitor(p,a) (p)->lpVtbl->SetMonitor(p,a)
+#define IFullScreenVideoEx_GetMonitor(p,a) (p)->lpVtbl->GetMonitor(p,a)
+#define IFullScreenVideoEx_HideOnDeactivate(p,a) (p)->lpVtbl->HideOnDeactivate(p,a)
+#define IFullScreenVideoEx_IsHideOnDeactivate(p) (p)->lpVtbl->IsHideOnDeactivate(p)
+#define IFullScreenVideoEx_SetCaption(p,a) (p)->lpVtbl->SetCaption(p,a)
+#define IFullScreenVideoEx_GetCaption(p,a) (p)->lpVtbl->GetCaption(p,a)
+#define IFullScreenVideoEx_SetDefault(p) (p)->lpVtbl->SetDefault(p)
+/*** IFullScreenVideoEx methods ***/
+#define IFullScreenVideoEx_SetAcceleratorTable(p,a,b) (p)->lpVtbl->SetAcceleratorTable(p,a,b)
+#define IFullScreenVideoEx_GetAcceleratorTable(p,a,b) (p)->lpVtbl->GetAcceleratorTable(p,a,b)
+#define IFullScreenVideoEx_KeepPixelAspectRatio(p,a) (p)->lpVtbl->KeepPixelAspectRatio(p,a)
+#define IFullScreenVideoEx_IsKeepPixelAspectRatio(p,a) (p)->lpVtbl->IsKeepPixelAspectRatio(p,a)
+
+#endif
+
+#define IFullScreenVideoEx_METHODS \
+ ICOM_MSVTABLE_COMPAT_FIELDS \
+ /*** IUnknown methods ***/ \
+ STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \
+ STDMETHOD_(ULONG,AddRef)(THIS) PURE; \
+ STDMETHOD_(ULONG,Release)(THIS) PURE; \
+ /*** IFullScreenVideo methods ***/ \
+ STDMETHOD_(HRESULT,CountModes)(THIS_ long* pModes) PURE; \
+ STDMETHOD_(HRESULT,GetModeInfo)(THIS_ long Mode, long* pWidth, long* pHeight, long* pDepth) PURE; \
+ STDMETHOD_(HRESULT,GetCurrentMode)(THIS_ long* pMode) PURE; \
+ STDMETHOD_(HRESULT,IsModeAvailable)(THIS_ long Mode) PURE; \
+ STDMETHOD_(HRESULT,IsModeEnabled)(THIS_ long Mode) PURE; \
+ STDMETHOD_(HRESULT,SetEnabled)(THIS_ long Mode, long bEnabled) PURE; \
+ STDMETHOD_(HRESULT,GetClipFactor)(THIS_ long* pClipFactor) PURE; \
+ STDMETHOD_(HRESULT,SetClipFactor)(THIS_ long ClipFactor) PURE; \
+ STDMETHOD_(HRESULT,SetMessageDrain)(THIS_ HWND hwnd) PURE; \
+ STDMETHOD_(HRESULT,GetMessageDrain)(THIS_ HWND* hwnd) PURE; \
+ STDMETHOD_(HRESULT,SetMonitor)(THIS_ long Monitor) PURE; \
+ STDMETHOD_(HRESULT,GetMonitor)(THIS_ long* Monitor) PURE; \
+ STDMETHOD_(HRESULT,HideOnDeactivate)(THIS_ long Hide) PURE; \
+ STDMETHOD_(HRESULT,IsHideOnDeactivate)(THIS) PURE; \
+ STDMETHOD_(HRESULT,SetCaption)(THIS_ BSTR strCaption) PURE; \
+ STDMETHOD_(HRESULT,GetCaption)(THIS_ BSTR* pstrCaption) PURE; \
+ STDMETHOD_(HRESULT,SetDefault)(THIS) PURE; \
+ /*** IFullScreenVideoEx methods ***/ \
+ STDMETHOD_(HRESULT,SetAcceleratorTable)(THIS_ HWND hwnd, HACCEL hAccel) PURE; \
+ STDMETHOD_(HRESULT,GetAcceleratorTable)(THIS_ HWND* phwnd, HACCEL* phAccel) PURE; \
+ STDMETHOD_(HRESULT,KeepPixelAspectRatio)(THIS_ long KeepAspect) PURE; \
+ STDMETHOD_(HRESULT,IsKeepPixelAspectRatio)(THIS_ long* pKeepAspect) PURE;
+
+HRESULT CALLBACK IFullScreenVideoEx_SetAcceleratorTable_Proxy(
+ IFullScreenVideoEx* This,
+ HWND hwnd,
+ HACCEL hAccel);
+void __RPC_STUB IFullScreenVideoEx_SetAcceleratorTable_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFullScreenVideoEx_GetAcceleratorTable_Proxy(
+ IFullScreenVideoEx* This,
+ HWND* phwnd,
+ HACCEL* phAccel);
+void __RPC_STUB IFullScreenVideoEx_GetAcceleratorTable_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFullScreenVideoEx_KeepPixelAspectRatio_Proxy(
+ IFullScreenVideoEx* This,
+ long KeepAspect);
+void __RPC_STUB IFullScreenVideoEx_KeepPixelAspectRatio_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFullScreenVideoEx_IsKeepPixelAspectRatio_Proxy(
+ IFullScreenVideoEx* This,
+ long* pKeepAspect);
+void __RPC_STUB IFullScreenVideoEx_IsKeepPixelAspectRatio_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+#endif /* __IFullScreenVideoEx_INTERFACE_DEFINED__ */
+
+#ifndef __IBaseVideoMixer_FWD_DEFINED__
+#define __IBaseVideoMixer_FWD_DEFINED__
+typedef struct IBaseVideoMixer IBaseVideoMixer;
+#endif
+
+/*****************************************************************************
+ * IBaseVideoMixer interface
+ */
+#ifndef __IBaseVideoMixer_INTERFACE_DEFINED__
+#define __IBaseVideoMixer_INTERFACE_DEFINED__
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IBaseVideoMixer : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE SetLeadPin(
+ int iPin) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetLeadPin(
+ int* piPin) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetInputPinCount(
+ int* piPinCount) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE IsUsingClock(
+ int* pbValue) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE SetUsingClock(
+ int bValue) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetClockPeriod(
+ int* pbValue) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE SetClockPeriod(
+ int bValue) = 0;
+
+};
+#else
+typedef struct IBaseVideoMixerVtbl IBaseVideoMixerVtbl;
+struct IBaseVideoMixer {
+ const IBaseVideoMixerVtbl* lpVtbl;
+};
+struct IBaseVideoMixerVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IBaseVideoMixer* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IBaseVideoMixer* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IBaseVideoMixer* This);
+
+ /*** IBaseVideoMixer methods ***/
+ HRESULT (STDMETHODCALLTYPE *SetLeadPin)(
+ IBaseVideoMixer* This,
+ int iPin);
+
+ HRESULT (STDMETHODCALLTYPE *GetLeadPin)(
+ IBaseVideoMixer* This,
+ int* piPin);
+
+ HRESULT (STDMETHODCALLTYPE *GetInputPinCount)(
+ IBaseVideoMixer* This,
+ int* piPinCount);
+
+ HRESULT (STDMETHODCALLTYPE *IsUsingClock)(
+ IBaseVideoMixer* This,
+ int* pbValue);
+
+ HRESULT (STDMETHODCALLTYPE *SetUsingClock)(
+ IBaseVideoMixer* This,
+ int bValue);
+
+ HRESULT (STDMETHODCALLTYPE *GetClockPeriod)(
+ IBaseVideoMixer* This,
+ int* pbValue);
+
+ HRESULT (STDMETHODCALLTYPE *SetClockPeriod)(
+ IBaseVideoMixer* This,
+ int bValue);
+
+};
+
+/*** IUnknown methods ***/
+#define IBaseVideoMixer_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IBaseVideoMixer_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IBaseVideoMixer_Release(p) (p)->lpVtbl->Release(p)
+/*** IBaseVideoMixer methods ***/
+#define IBaseVideoMixer_SetLeadPin(p,a) (p)->lpVtbl->SetLeadPin(p,a)
+#define IBaseVideoMixer_GetLeadPin(p,a) (p)->lpVtbl->GetLeadPin(p,a)
+#define IBaseVideoMixer_GetInputPinCount(p,a) (p)->lpVtbl->GetInputPinCount(p,a)
+#define IBaseVideoMixer_IsUsingClock(p,a) (p)->lpVtbl->IsUsingClock(p,a)
+#define IBaseVideoMixer_SetUsingClock(p,a) (p)->lpVtbl->SetUsingClock(p,a)
+#define IBaseVideoMixer_GetClockPeriod(p,a) (p)->lpVtbl->GetClockPeriod(p,a)
+#define IBaseVideoMixer_SetClockPeriod(p,a) (p)->lpVtbl->SetClockPeriod(p,a)
+
+#endif
+
+#define IBaseVideoMixer_METHODS \
+ ICOM_MSVTABLE_COMPAT_FIELDS \
+ /*** IUnknown methods ***/ \
+ STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \
+ STDMETHOD_(ULONG,AddRef)(THIS) PURE; \
+ STDMETHOD_(ULONG,Release)(THIS) PURE; \
+ /*** IBaseVideoMixer methods ***/ \
+ STDMETHOD_(HRESULT,SetLeadPin)(THIS_ int iPin) PURE; \
+ STDMETHOD_(HRESULT,GetLeadPin)(THIS_ int* piPin) PURE; \
+ STDMETHOD_(HRESULT,GetInputPinCount)(THIS_ int* piPinCount) PURE; \
+ STDMETHOD_(HRESULT,IsUsingClock)(THIS_ int* pbValue) PURE; \
+ STDMETHOD_(HRESULT,SetUsingClock)(THIS_ int bValue) PURE; \
+ STDMETHOD_(HRESULT,GetClockPeriod)(THIS_ int* pbValue) PURE; \
+ STDMETHOD_(HRESULT,SetClockPeriod)(THIS_ int bValue) PURE;
+
+HRESULT CALLBACK IBaseVideoMixer_SetLeadPin_Proxy(
+ IBaseVideoMixer* This,
+ int iPin);
+void __RPC_STUB IBaseVideoMixer_SetLeadPin_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IBaseVideoMixer_GetLeadPin_Proxy(
+ IBaseVideoMixer* This,
+ int* piPin);
+void __RPC_STUB IBaseVideoMixer_GetLeadPin_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IBaseVideoMixer_GetInputPinCount_Proxy(
+ IBaseVideoMixer* This,
+ int* piPinCount);
+void __RPC_STUB IBaseVideoMixer_GetInputPinCount_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IBaseVideoMixer_IsUsingClock_Proxy(
+ IBaseVideoMixer* This,
+ int* pbValue);
+void __RPC_STUB IBaseVideoMixer_IsUsingClock_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IBaseVideoMixer_SetUsingClock_Proxy(
+ IBaseVideoMixer* This,
+ int bValue);
+void __RPC_STUB IBaseVideoMixer_SetUsingClock_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IBaseVideoMixer_GetClockPeriod_Proxy(
+ IBaseVideoMixer* This,
+ int* pbValue);
+void __RPC_STUB IBaseVideoMixer_GetClockPeriod_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IBaseVideoMixer_SetClockPeriod_Proxy(
+ IBaseVideoMixer* This,
+ int bValue);
+void __RPC_STUB IBaseVideoMixer_SetClockPeriod_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+#endif /* __IBaseVideoMixer_INTERFACE_DEFINED__ */
+
+#define iPALETTE_COLORS 256
+#define iEGA_COLORS 16
+#define iMASK_COLORS 3
+#define iTRUECOLOR 16
+#define iRED 0
+#define iGREEN 1
+#define iBLUE 2
+#define iPALETTE 8
+#define iMAXBITS 8
+typedef struct tag_TRUECOLORINFO {
+ DWORD dwBitMasks[3];
+ RGBQUAD bmiColors[256];
+} TRUECOLORINFO;
+
+typedef struct tagVIDEOINFOHEADER {
+ RECT rcSource;
+ RECT rcTarget;
+ DWORD dwBitRate;
+ DWORD dwBitErrorRate;
+ REFERENCE_TIME AvgTimePerFrame;
+ BITMAPINFOHEADER bmiHeader;
+} VIDEOINFOHEADER;
+
+typedef struct tagVIDEOINFO {
+ RECT rcSource;
+ RECT rcTarget;
+ DWORD dwBitRate;
+ DWORD dwBitErrorRate;
+ REFERENCE_TIME AvgTimePerFrame;
+ BITMAPINFOHEADER bmiHeader;
+ union {
+ RGBQUAD bmiColors[256];
+ DWORD dwBitMasks[3];
+ TRUECOLORINFO TrueColorInfo;
+ } DUMMYUNIONNAME;
+} VIDEOINFO;
+
+typedef struct tagMPEG1VIDEOINFO {
+ VIDEOINFOHEADER hdr;
+ DWORD dwStartTimeCode;
+ DWORD cbSequenceHeader;
+ BYTE bSequenceHeader[1];
+} MPEG1VIDEOINFO;
+
+#define MAX_SIZE_MPEG1_SEQUENCE_INFO 140
+#define MPEG1_SEQUENCE_INFO(pv) ((const BYTE *)(pv)->bSequenceHeader)
+typedef struct tagAnalogVideoInfo {
+ RECT rcSource;
+ RECT rcTarget;
+ DWORD dwActiveWidth;
+ DWORD dwActiveHeight;
+ REFERENCE_TIME AvgTimePerFrame;
+} ANALOGVIDEOINFO;
+
+typedef enum {
+ AM_PROPERTY_FRAMESTEP_STEP = 0x1,
+ AM_PROPERTY_FRAMESTEP_CANCEL = 0x2,
+ AM_PROPERTY_FRAMESTEP_CANSTEP = 0x3,
+ AM_PROPERTY_FRAMESTEP_CANSTEPMULTIPLE = 0x4
+} AM_PROPERTY_FRAMESTEP;
+
+typedef struct _AM_FRAMESTEP_STEP {
+ DWORD dwFramesToStep;
+} AM_FRAMESTEP_STEP;
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* __WIDL_AMVIDEO_H */
