- Added DShow headers.
- Added needed const's in FilterGraph implementation.
diff --git a/dlls/quartz/filtergraph.c b/dlls/quartz/filtergraph.c
index 78719f5..8b1cc53 100644
--- a/dlls/quartz/filtergraph.c
+++ b/dlls/quartz/filtergraph.c
@@ -505,7 +505,7 @@
}
static HRESULT WINAPI Mediaseeking_IsFormatSupported(IMediaSeeking *iface,
- GUID *pFormat) {
+ const GUID *pFormat) {
ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pFormat);
@@ -532,7 +532,7 @@
}
static HRESULT WINAPI Mediaseeking_IsUsingTimeFormat(IMediaSeeking *iface,
- GUID *pFormat) {
+ const GUID *pFormat) {
ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pFormat);
@@ -541,7 +541,7 @@
}
static HRESULT WINAPI Mediaseeking_SetTimeFormat(IMediaSeeking *iface,
- GUID *pFormat) {
+ const GUID *pFormat) {
ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pFormat);
@@ -578,9 +578,9 @@
static HRESULT WINAPI Mediaseeking_ConvertTimeFormat(IMediaSeeking *iface,
LONGLONG *pTarget,
- GUID *pTargetFormat,
+ const GUID *pTargetFormat,
LONGLONG Source,
- GUID *pSourceFormat) {
+ const GUID *pSourceFormat) {
ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface);
TRACE("(%p/%p)->(%p, %p, %lld, %p): stub !!!\n", This, iface, pTarget, pTargetFormat, Source, pSourceFormat);
diff --git a/include/Makefile.in b/include/Makefile.in
index 8a221f5..ade9121 100644
--- a/include/Makefile.in
+++ b/include/Makefile.in
@@ -7,9 +7,16 @@
IDL_SRCS = \
oaidl.idl \
objidl.idl \
+ strmif.idl \
unknwn.idl \
wtypes.idl
+IDL_INCLUDES = \
+ axcore.idl \
+ axextend.idl \
+ devenum.idl \
+ dyngraph.idl
+
WINDOWS_INCLUDES = \
accctrl.h \
audevcod.h \
@@ -188,6 +195,7 @@
wshisotp.h \
wsipx.h \
zmouse.h \
+ $(IDL_INCLUDES) \
$(IDL_SRCS) \
$(IDL_SRCS:.idl=.h)
diff --git a/include/axcore.idl b/include/axcore.idl
new file mode 100644
index 0000000..ecac893
--- /dev/null
+++ b/include/axcore.idl
@@ -0,0 +1,647 @@
+/*
+ * Copyright (C) 2002 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
+ */
+
+#define CHARS_IN_GUID 39
+cpp_quote("#define CHARS_IN_GUID 39")
+
+/* GetTimeFormat is defined in winnls.h as
+ * either the W or A suffixed version */
+cpp_quote("#undef GetTimeFormat")
+
+typedef struct _AMMediaType
+{
+ GUID majortype;
+ GUID subtype;
+ BOOL bFixedSizeSamples;
+ BOOL bTemporalCompression;
+ ULONG lSampleSize;
+ GUID formattype;
+ IUnknown * pUnk;
+ ULONG cbFormat;
+ [size_is(cbFormat)] BYTE * pbFormat;
+} AM_MEDIA_TYPE;
+
+typedef enum _PinDirection
+{
+ PINDIR_INPUT,
+ PINDIR_OUTPUT
+} PIN_DIRECTION;
+
+#define MAX_PIN_NAME 128
+#define MAX_FILTER_NAME 128
+cpp_quote("#define MAX_PIN_NAME 128")
+cpp_quote("#define MAX_FILTER_NAME 128")
+
+typedef LONGLONG REFERENCE_TIME;
+typedef double REFTIME;
+
+typedef DWORD_PTR HSEMAPHORE;
+typedef DWORD_PTR HEVENT;
+
+typedef struct _AllocatorProperties
+{
+ long cBuffers;
+ long cbBuffer;
+ long cbAlign;
+ long cbPrefix;
+} ALLOCATOR_PROPERTIES;
+
+interface IAMovieSetup;
+interface IEnumFilters;
+interface IEnumMediaTypes;
+interface IEnumPins;
+interface IBaseFilter;
+interface IFilterGraph;
+interface IMediaFilter;
+interface IMediaSample;
+interface IMemAllocator;
+interface IMemAllocatorCallbackTemp;
+interface IMemAllocatorNotifyCallbackTemp;
+interface IMemInputPin;
+interface IPin;
+interface IReferenceClock;
+
+[
+object,
+uuid(56a86891-0ad4-11ce-b03a-0020af0ba770),
+pointer_default(unique)
+]
+interface IPin : IUnknown
+{
+ typedef struct _PinInfo
+ {
+ IBaseFilter *pFilter;
+ PIN_DIRECTION dir;
+ WCHAR achName[MAX_PIN_NAME];
+ } PIN_INFO;
+
+ HRESULT Connect(
+ [in] IPin * pReceivePin,
+ [in] const AM_MEDIA_TYPE * pmt);
+
+ HRESULT ReceiveConnection(
+ [in] IPin * pConnector,
+ [in] const AM_MEDIA_TYPE *pmt);
+
+ HRESULT Disconnect(void);
+
+ HRESULT ConnectedTo(
+ [out] IPin **pPin);
+
+ HRESULT ConnectionMediaType(
+ [out] AM_MEDIA_TYPE *pmt);
+
+ HRESULT QueryPinInfo(
+ [out] PIN_INFO * pInfo);
+
+ HRESULT QueryDirection(
+ [out] PIN_DIRECTION *pPinDir);
+
+ HRESULT QueryId(
+ [out] LPWSTR * Id);
+
+ HRESULT QueryAccept(
+ [in] const AM_MEDIA_TYPE *pmt);
+
+ HRESULT EnumMediaTypes(
+ [out] IEnumMediaTypes **ppEnum);
+
+ HRESULT QueryInternalConnections(
+ [out] IPin* *apPin,
+ [in, out] ULONG *nPin);
+
+ HRESULT EndOfStream(void);
+
+ HRESULT BeginFlush(void);
+
+ HRESULT EndFlush(void);
+ HRESULT NewSegment(
+ [in] REFERENCE_TIME tStart,
+ [in] REFERENCE_TIME tStop,
+ [in] double dRate);
+}
+
+typedef IPin *PPIN;
+
+[
+object,
+uuid(56a86892-0ad4-11ce-b03a-0020af0ba770),
+pointer_default(unique)
+]
+interface IEnumPins : IUnknown
+{
+
+ HRESULT Next(
+ [in] ULONG cPins,
+ [out, size_is(cPins)] IPin ** ppPins,
+ [out] ULONG * pcFetched);
+
+ HRESULT Skip(
+ [in] ULONG cPins);
+
+ HRESULT Reset(void);
+
+ HRESULT Clone(
+ [out] IEnumPins **ppEnum);
+}
+
+typedef IEnumPins *PENUMPINS;
+
+[
+object,
+uuid(89c31040-846b-11ce-97d3-00aa0055595a),
+pointer_default(unique)
+]
+interface IEnumMediaTypes : IUnknown
+{
+ HRESULT Next(
+ [in] ULONG cMediaTypes,
+ [out, size_is(cMediaTypes)]
+ AM_MEDIA_TYPE ** ppMediaTypes,
+ [out] ULONG * pcFetched
+ );
+
+ HRESULT Skip(
+ [in] ULONG cMediaTypes);
+
+ HRESULT Reset(void);
+
+ HRESULT Clone(
+ [out] IEnumMediaTypes **ppEnum
+ );
+}
+
+typedef IEnumMediaTypes *PENUMMEDIATYPES;
+
+[
+object,
+uuid(56a8689f-0ad4-11ce-b03a-0020af0ba770),
+pointer_default(unique)
+]
+interface IFilterGraph : IUnknown
+{
+ HRESULT AddFilter(
+ [in] IBaseFilter * pFilter,
+ [in, string] LPCWSTR pName);
+
+ HRESULT RemoveFilter(
+ [in] IBaseFilter * pFilter);
+
+ HRESULT EnumFilters(
+ [out] IEnumFilters **ppEnum);
+
+ HRESULT FindFilterByName(
+ [in, string] LPCWSTR pName,
+ [out] IBaseFilter ** ppFilter);
+
+ HRESULT ConnectDirect(
+ [in] IPin * ppinOut,
+ [in] IPin * ppinIn,
+ [in, unique] const AM_MEDIA_TYPE* pmt);
+
+ HRESULT Reconnect(
+ [in] IPin * ppin);
+
+ HRESULT Disconnect(
+ [in] IPin * ppin);
+
+ HRESULT SetDefaultSyncSource(void);
+}
+
+typedef IFilterGraph *PFILTERGRAPH;
+
+[
+object,
+uuid(56a86893-0ad4-11ce-b03a-0020af0ba770),
+pointer_default(unique)
+]
+interface IEnumFilters : IUnknown
+{
+ HRESULT Next(
+ [in] ULONG cFilters,
+ [out] IBaseFilter ** ppFilter,
+ [out] ULONG * pcFetched);
+
+
+ HRESULT Skip(
+ [in] ULONG cFilters);
+
+
+ HRESULT Reset(void);
+
+
+ HRESULT Clone(
+ [out] IEnumFilters **ppEnum);
+}
+
+typedef IEnumFilters *PENUMFILTERS;
+
+[
+object,
+uuid(56a86899-0ad4-11ce-b03a-0020af0ba770),
+pointer_default(unique)
+]
+interface IMediaFilter : IPersist
+{
+ typedef enum _FilterState
+ {
+ State_Stopped,
+ State_Paused,
+ State_Running
+ } FILTER_STATE;
+
+ HRESULT Stop(void);
+ HRESULT Pause(void);
+
+ HRESULT Run(REFERENCE_TIME tStart);
+
+ HRESULT GetState(
+ [in] DWORD dwMilliSecsTimeout,
+ [out] FILTER_STATE *State);
+
+ HRESULT SetSyncSource(
+ [in] IReferenceClock * pClock);
+
+ HRESULT GetSyncSource(
+ [out] IReferenceClock ** pClock);
+}
+
+typedef IMediaFilter *PMEDIAFILTER;
+
+[
+object,
+uuid(56a86895-0ad4-11ce-b03a-0020af0ba770),
+pointer_default(unique)
+]
+interface IBaseFilter : IMediaFilter
+{
+ typedef struct _FilterInfo
+ {
+ WCHAR achName[MAX_FILTER_NAME];
+ IFilterGraph * pGraph;
+ } FILTER_INFO;
+
+ HRESULT EnumPins(
+ [out] IEnumPins ** ppEnum);
+
+ HRESULT FindPin(
+ [in, string] LPCWSTR Id,
+ [out] IPin ** ppPin);
+
+ HRESULT QueryFilterInfo(
+ [out] FILTER_INFO * pInfo);
+
+ HRESULT JoinFilterGraph(
+ [in] IFilterGraph * pGraph,
+ [in, string] LPCWSTR pName);
+
+ HRESULT QueryVendorInfo(
+ [out, string] LPWSTR* pVendorInfo);
+}
+
+typedef IBaseFilter *PFILTER;
+
+[
+object,
+uuid(56a86897-0ad4-11ce-b03a-0020af0ba770),
+pointer_default(unique)
+]
+interface IReferenceClock : IUnknown
+{
+ HRESULT GetTime(
+ [out] REFERENCE_TIME *pTime);
+
+ HRESULT AdviseTime(
+ [in] REFERENCE_TIME baseTime,
+ [in] REFERENCE_TIME streamTime,
+ [in] HEVENT hEvent,
+ [out] DWORD_PTR * pdwAdviseCookie);
+
+ HRESULT AdvisePeriodic(
+ [in] REFERENCE_TIME startTime,
+ [in] REFERENCE_TIME periodTime,
+ [in] HSEMAPHORE hSemaphore,
+ [out] DWORD_PTR * pdwAdviseCookie);
+
+ HRESULT Unadvise(
+ [in] DWORD_PTR dwAdviseCookie);
+}
+
+typedef IReferenceClock *PREFERENCECLOCK;
+
+/*
+[
+object,
+uuid(36b73885-c2c8-11cf-8b46-00805f6cef60),
+pointer_default(unique)
+]
+interface IReferenceClock2 : IReferenceClock
+{
+}
+
+typedef IReferenceClock2 *PREFERENCECLOCK2;
+
+*/
+
+[
+local,
+object,
+uuid(56a8689a-0ad4-11ce-b03a-0020af0ba770),
+pointer_default(unique)
+]
+interface IMediaSample : IUnknown
+{
+ HRESULT GetPointer([out] BYTE ** ppBuffer);
+
+ long GetSize(void);
+
+ HRESULT GetTime(
+ [out] REFERENCE_TIME * pTimeStart,
+ [out] REFERENCE_TIME * pTimeEnd);
+
+ HRESULT SetTime(
+ [in] REFERENCE_TIME * pTimeStart,
+ [in] REFERENCE_TIME * pTimeEnd);
+
+ HRESULT IsSyncPoint(void);
+
+ HRESULT SetSyncPoint(BOOL bIsSyncPoint);
+
+ HRESULT IsPreroll(void);
+
+ HRESULT SetPreroll(BOOL bIsPreroll);
+
+ long GetActualDataLength(void);
+
+ HRESULT SetActualDataLength(long length);
+
+ HRESULT GetMediaType(AM_MEDIA_TYPE **ppMediaType);
+
+ HRESULT SetMediaType(AM_MEDIA_TYPE *pMediaType);
+
+ HRESULT IsDiscontinuity(void);
+
+ HRESULT SetDiscontinuity(BOOL bDiscontinuity);
+
+ HRESULT GetMediaTime(
+ [out] LONGLONG * pTimeStart,
+ [out] LONGLONG * pTimeEnd);
+
+ HRESULT SetMediaTime(
+ [in] LONGLONG * pTimeStart,
+ [in] LONGLONG * pTimeEnd);
+}
+
+typedef IMediaSample *PMEDIASAMPLE;
+
+enum tagAM_SAMPLE_PROPERTY_FLAGS
+{
+ AM_SAMPLE_SPLICEPOINT = 0x01,
+ AM_SAMPLE_PREROLL = 0x02,
+ AM_SAMPLE_DATADISCONTINUITY = 0x04,
+ AM_SAMPLE_TYPECHANGED = 0x08,
+ AM_SAMPLE_TIMEVALID = 0x10,
+ AM_SAMPLE_TIMEDISCONTINUITY = 0x40,
+ AM_SAMPLE_FLUSH_ON_PAUSE = 0x80,
+ AM_SAMPLE_STOPVALID = 0x100,
+ AM_SAMPLE_ENDOFSTREAM = 0x200,
+ AM_STREAM_MEDIA = 0,
+ AM_STREAM_CONTROL = 1
+};
+
+typedef struct tagAM_SAMPLE2_PROPERTIES
+{
+ DWORD cbData;
+ DWORD dwTypeSpecificFlags;
+ DWORD dwSampleFlags;
+ LONG lActual;
+ REFERENCE_TIME tStart;
+ REFERENCE_TIME tStop;
+ DWORD dwStreamId;
+ AM_MEDIA_TYPE *pMediaType;
+ BYTE *pbBuffer;
+ LONG cbBuffer;
+} AM_SAMPLE2_PROPERTIES;
+
+[
+ local,
+ object,
+ uuid(36b73884-c2c8-11cf-8b46-00805f6cef60),
+ pointer_default(unique)
+]
+interface IMediaSample2 : IMediaSample
+{
+ HRESULT GetProperties(
+ [in] DWORD cbProperties,
+ [out, size_is(cbProperties)] BYTE * pbProperties
+ );
+
+ HRESULT SetProperties(
+ [in] DWORD cbProperties,
+ [in, size_is(cbProperties)] const BYTE * pbProperties
+ );
+}
+
+typedef IMediaSample2 *PMEDIASAMPLE2;
+
+#define AM_GBF_PREVFRAMESKIPPED 1
+#define AM_GBF_NOTASYNCPOINT 2
+cpp_quote("#define AM_GBF_PREVFRAMESKIPPED 1")
+cpp_quote("#define AM_GBF_NOTASYNCPOINT 2")
+
+cpp_quote("#define AM_GBF_NOWAIT 4")
+
+[
+object,
+uuid(56a8689c-0ad4-11ce-b03a-0020af0ba770),
+pointer_default(unique)
+]
+interface IMemAllocator : IUnknown
+{
+ HRESULT SetProperties(
+ [in] ALLOCATOR_PROPERTIES* pRequest,
+ [out] ALLOCATOR_PROPERTIES* pActual);
+
+ HRESULT GetProperties(
+ [out] ALLOCATOR_PROPERTIES* pProps);
+
+ HRESULT Commit(void);
+
+ HRESULT Decommit(void);
+
+ HRESULT GetBuffer(
+ [out] IMediaSample **ppBuffer,
+ [in] REFERENCE_TIME * pStartTime,
+ [in] REFERENCE_TIME * pEndTime,
+ [in] DWORD dwFlags);
+
+ HRESULT ReleaseBuffer(
+ [in] IMediaSample *pBuffer);
+}
+
+typedef IMemAllocator *PMEMALLOCATOR;
+
+[
+object,
+uuid(379a0cf0-c1de-11d2-abf5-00a0c905f375),
+pointer_default(unique)
+]
+interface IMemAllocatorCallbackTemp : IMemAllocator
+{
+ HRESULT SetNotify(
+ [in] IMemAllocatorNotifyCallbackTemp *pNotify);
+
+ HRESULT GetFreeCount(
+ [out] LONG *plBuffersFree);
+}
+
+[
+object,
+uuid(92980b30-c1de-11d2-abf5-00a0c905f375),
+pointer_default(unique)
+]
+interface IMemAllocatorNotifyCallbackTemp : IUnknown
+{
+ HRESULT NotifyRelease();
+}
+
+[
+object,
+uuid(56a8689d-0ad4-11ce-b03a-0020af0ba770),
+pointer_default(unique)
+]
+interface IMemInputPin : IUnknown
+{
+ HRESULT GetAllocator(
+ [out] IMemAllocator ** ppAllocator);
+
+ HRESULT NotifyAllocator(
+ [in] IMemAllocator * pAllocator,
+ [in] BOOL bReadOnly);
+
+ HRESULT GetAllocatorRequirements( [out] ALLOCATOR_PROPERTIES*pProps );
+
+ HRESULT Receive(
+ [in] IMediaSample * pSample);
+
+ HRESULT ReceiveMultiple(
+ [in, size_is(nSamples)] IMediaSample **pSamples,
+ [in] long nSamples,
+ [out] long *nSamplesProcessed);
+
+ HRESULT ReceiveCanBlock();
+}
+
+typedef IMemInputPin *PMEMINPUTPIN;
+
+[
+object,
+uuid(a3d8cec0-7e5a-11cf-bbc5-00805f6cef20),
+pointer_default(unique)
+]
+interface IAMovieSetup : IUnknown
+{
+ HRESULT Register( );
+ HRESULT Unregister( );
+}
+
+typedef IAMovieSetup *PAMOVIESETUP;
+
+typedef enum AM_SEEKING_SeekingFlags
+{
+ AM_SEEKING_NoPositioning = 0x00,
+ AM_SEEKING_AbsolutePositioning = 0x01,
+ AM_SEEKING_RelativePositioning = 0x02,
+ AM_SEEKING_IncrementalPositioning = 0x03,
+ AM_SEEKING_PositioningBitsMask = 0x03,
+ AM_SEEKING_SeekToKeyFrame = 0x04,
+ AM_SEEKING_ReturnTime = 0x08,
+ AM_SEEKING_Segment = 0x10,
+ AM_SEEKING_NoFlush = 0x20
+} AM_SEEKING_SEEKING_FLAGS;
+
+typedef enum AM_SEEKING_SeekingCapabilities
+{
+ AM_SEEKING_CanSeekAbsolute = 0x001,
+ AM_SEEKING_CanSeekForwards = 0x002,
+ AM_SEEKING_CanSeekBackwards = 0x004,
+ AM_SEEKING_CanGetCurrentPos = 0x008,
+ AM_SEEKING_CanGetStopPos = 0x010,
+ AM_SEEKING_CanGetDuration = 0x020,
+ AM_SEEKING_CanPlayBackwards = 0x040,
+ AM_SEEKING_CanDoSegments = 0x080,
+ AM_SEEKING_Source = 0x100
+} AM_SEEKING_SEEKING_CAPABILITIES;
+
+[
+object,
+uuid(36b73880-c2c8-11cf-8b46-00805f6cef60),
+pointer_default(unique)
+]
+interface IMediaSeeking : IUnknown
+{
+ HRESULT GetCapabilities( [out] DWORD * pCapabilities );
+
+ HRESULT CheckCapabilities( [in,out] DWORD * pCapabilities );
+
+ HRESULT IsFormatSupported([in] const GUID * pFormat);
+
+ HRESULT QueryPreferredFormat([out] GUID * pFormat);
+
+ HRESULT GetTimeFormat([out] GUID *pFormat);
+
+ HRESULT IsUsingTimeFormat([in] const GUID * pFormat);
+
+ HRESULT SetTimeFormat([in] const GUID * pFormat);
+
+ HRESULT GetDuration([out] LONGLONG *pDuration);
+
+ HRESULT GetStopPosition([out] LONGLONG *pStop);
+
+ HRESULT GetCurrentPosition([out] LONGLONG *pCurrent);
+
+ HRESULT ConvertTimeFormat([out] LONGLONG * pTarget, [in] const GUID * pTargetFormat,
+ [in] LONGLONG Source, [in] const GUID * pSourceFormat );
+
+ HRESULT SetPositions(
+ [in,out] LONGLONG * pCurrent,
+ [in] DWORD dwCurrentFlags,
+ [in,out] LONGLONG * pStop,
+ [in] DWORD dwStopFlags);
+
+ HRESULT GetPositions(
+ [out] LONGLONG * pCurrent,
+ [out] LONGLONG * pStop);
+
+ HRESULT GetAvailable(
+ [out] LONGLONG * pEarliest,
+ [out] LONGLONG * pLatest);
+
+ HRESULT SetRate([in] double dRate);
+
+ HRESULT GetRate([out] double * pdRate);
+
+ HRESULT GetPreroll([out] LONGLONG * pllPreroll);
+}
+
+typedef IMediaSeeking *PMEDIASEEKING;
+
+enum tagAM_MEDIAEVENT_FLAGS
+{
+ AM_MEDIAEVENT_NONOTIFY = 0x01
+};
diff --git a/include/axextend.idl b/include/axextend.idl
new file mode 100644
index 0000000..9466e99
--- /dev/null
+++ b/include/axextend.idl
@@ -0,0 +1,895 @@
+/*
+ * Copyright (C) 2002 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
+ */
+
+interface IAMAnalogVideoDecoder;
+interface IAMAnalogVideoEncoder;
+interface IAMAudioInputMixer;
+interface IAMAudioRendererStats;
+interface IAMBufferNegotiation;
+interface IAMCameraControl;
+interface IAMCopyCaptureFileProgress;
+interface IAMCrossbar;
+interface IAMDevMemoryAllocator;
+interface IAMDevMemoryControl;
+interface IAMDroppedFrames;
+interface IAMExtDevice;
+interface IAMExtTransport;
+interface IAMGraphStreams;
+interface IAMLatency;
+interface IAMOpenProgress;
+interface IAMOverlayFX;
+interface IAMPhysicalPinInfo;
+interface IAMPushSource;
+interface IAMStreamConfig;
+interface IAMTimecodeDisplay;
+interface IAMTimecodeGenerator;
+interface IAMTimecodeReader;
+interface IAMTVTuner;
+interface IAMVfwCaptureDialogs;
+interface IAMVfwCompressDialogs;
+interface IAMVideoCompression;
+interface IAMVideoDecimationProperties;
+interface IAMVideoProcAmp;
+interface ICaptureGraphBuilder;
+interface ICaptureGraphBuilder2;
+interface IConfigAviMux;
+interface IConfigInterleaving;
+interface IDecimateVideoImage;
+interface IDrawVideoImage;
+interface IEnumRegFilters;
+interface IEnumStreamIdMap;
+interface IFileSourceFilter;
+interface IFileSinkFilter;
+interface IFileSinkFilter2;
+interface IFilterMapper;
+interface IFilterMapper2;
+interface IGraphBuilder;
+interface IKsPropertySet;
+interface IMediaEventSink;
+interface IMpeg2Demultiplexer;
+interface IMPEG2StreamIdMap;
+interface IOverlay;
+interface IOverlayNotify;
+interface IOverlayNotify2;
+interface IQualityControl;
+interface ISeekingPassThru;
+
+typedef struct
+{
+ CLSID Clsid;
+ LPWSTR Name;
+} REGFILTER;
+
+[
+object,
+uuid(56a868a4-0ad4-11ce-b03a-0020af0ba770),
+pointer_default(unique)
+]
+interface IEnumRegFilters : IUnknown
+{
+ HRESULT Next
+ ( [in] ULONG cFilters,
+ [out] REGFILTER ** apRegFilter,
+ [out] ULONG * pcFetched
+ );
+
+ HRESULT Skip(
+ [in] ULONG cFilters
+ );
+
+ HRESULT Reset(void);
+
+ HRESULT Clone(
+ [out] IEnumRegFilters **ppEnum
+ );
+}
+
+
+typedef IEnumRegFilters *PENUMREGFILTERS;
+
+[
+object,
+uuid(56a868a3-0ad4-11ce-b03a-0020af0ba770),
+pointer_default(unique)
+]
+interface IFilterMapper : IUnknown
+{
+ enum { MERIT_PREFERRED = 0x800000,
+ MERIT_NORMAL = 0x600000,
+ MERIT_UNLIKELY = 0x400000,
+ MERIT_DO_NOT_USE = 0x200000,
+ MERIT_SW_COMPRESSOR = 0x100000,
+ MERIT_HW_COMPRESSOR = 0x100050
+ };
+
+ HRESULT RegisterFilter
+ ( [in] CLSID clsid,
+ [in] LPCWSTR Name,
+ [in] DWORD dwMerit
+ );
+
+ HRESULT RegisterFilterInstance
+ ( [in] CLSID clsid,
+ [in] LPCWSTR Name,
+ [out] CLSID *MRId
+ );
+
+
+ HRESULT RegisterPin
+ ( [in] CLSID Filter,
+ [in] LPCWSTR Name,
+ [in] BOOL bRendered,
+ [in] BOOL bOutput,
+ [in] BOOL bZero,
+ [in] BOOL bMany,
+ [in] CLSID ConnectsToFilter,
+ [in] LPCWSTR ConnectsToPin
+ );
+
+ HRESULT RegisterPinType
+ ( [in] CLSID clsFilter,
+ [in] LPCWSTR strName,
+ [in] CLSID clsMajorType,
+ [in] CLSID clsSubType
+ );
+
+
+ HRESULT UnregisterFilter
+ ( [in] CLSID Filter
+ );
+
+
+ HRESULT UnregisterFilterInstance
+ ( [in] CLSID MRId
+ );
+
+
+ HRESULT UnregisterPin
+ ( [in] CLSID Filter,
+ [in] LPCWSTR Name
+ );
+
+ HRESULT EnumMatchingFilters
+ ( [out] IEnumRegFilters **ppEnum,
+ [in] DWORD dwMerit,
+ [in] BOOL bInputNeeded,
+ [in] CLSID clsInMaj,
+ [in] CLSID clsInSub,
+ [in] BOOL bRender,
+ [in] BOOL bOututNeeded,
+ [in] CLSID clsOutMaj,
+ [in] CLSID clsOutSub
+ );
+
+}
+
+typedef struct
+{
+ const CLSID * clsMajorType;
+ const CLSID * clsMinorType;
+} REGPINTYPES;
+
+typedef struct
+{
+ LPWSTR strName;
+ BOOL bRendered;
+ BOOL bOutput;
+ BOOL bZero;
+ BOOL bMany;
+ const CLSID * clsConnectsToFilter;
+ const WCHAR * strConnectsToPin;
+ UINT nMediaTypes;
+ const REGPINTYPES * lpMediaType;
+} REGFILTERPINS;
+
+typedef struct
+{
+ CLSID clsMedium;
+ DWORD dw1;
+ DWORD dw2;
+} REGPINMEDIUM;
+
+enum
+{
+ REG_PINFLAG_B_ZERO = 0x1,
+ REG_PINFLAG_B_RENDERER = 0x2,
+ REG_PINFLAG_B_MANY = 0x4,
+ REG_PINFLAG_B_OUTPUT = 0x8
+};
+
+
+typedef struct
+{
+ DWORD dwFlags;
+ UINT cInstances;
+ UINT nMediaTypes;
+ [size_is(nMediaTypes)] const REGPINTYPES * lpMediaType;
+ UINT nMediums;
+ [size_is(nMediums)] const REGPINMEDIUM *lpMedium;
+ const CLSID *clsPinCategory;
+} REGFILTERPINS2;
+
+typedef struct
+{
+ DWORD dwVersion;
+ DWORD dwMerit;
+ [switch_is(dwVersion)] [switch_type(DWORD)] union
+ {
+ [case(1)]
+ struct
+ {
+ ULONG cPins;
+ [size_is(cPins)] const REGFILTERPINS *rgPins;
+ } DUMMYSTRUCTNAME;
+
+ [case(2)]
+ struct
+ {
+ ULONG cPins2;
+ [size_is(cPins2)] const REGFILTERPINS2 *rgPins2;
+ } DUMMYSTRUCTNAME1;
+
+ [default]
+ ;
+ } DUMMYUNIONNAME;
+
+} REGFILTER2;
+
+
+[
+object,
+uuid(b79bb0b0-33c1-11d1-abe1-00a0c905f375),
+pointer_default(unique)
+]
+interface IFilterMapper2 : IUnknown
+{
+ HRESULT CreateCategory
+ ( [in] REFCLSID clsidCategory,
+ [in] DWORD dwCategoryMerit,
+ [in] LPCWSTR Description
+ );
+
+ HRESULT UnregisterFilter
+ ( [in] const CLSID *pclsidCategory,
+ [in] const OLECHAR *szInstance,
+ [in] REFCLSID Filter
+ );
+
+ HRESULT RegisterFilter
+ ( [in] REFCLSID clsidFilter,
+ [in] LPCWSTR Name,
+ [in, out] IMoniker **ppMoniker,
+ [in] const CLSID *pclsidCategory,
+ [in] const OLECHAR *szInstance,
+ [in] const REGFILTER2 *prf2
+ );
+
+ HRESULT EnumMatchingFilters
+ ( [out] IEnumMoniker **ppEnum,
+ [in] DWORD dwFlags,
+ [in] BOOL bExactMatch,
+ [in] DWORD dwMerit,
+ [in] BOOL bInputNeeded,
+ [in] DWORD cInputTypes,
+ [size_is(cInputTypes*2)] const GUID *pInputTypes,
+ [in] const REGPINMEDIUM *pMedIn,
+ [in] const CLSID *pPinCategoryIn,
+ [in] BOOL bRender,
+ [in] BOOL bOutputNeeded,
+ [in] DWORD cOutputTypes,
+ [size_is(cOutputTypes*2)] const GUID *pOutputTypes,
+ [in] const REGPINMEDIUM *pMedOut,
+ [in] const CLSID *pPinCategoryOut
+ );
+}
+
+[
+object,
+uuid(b79bb0b1-33c1-11d1-abe1-00a0c905f375),
+pointer_default(unique)
+]
+interface IFilterMapper3 : IFilterMapper2
+{
+ HRESULT GetICreateDevEnum( [out] ICreateDevEnum **ppEnum );
+}
+
+typedef enum tagQualityMessageType
+{
+ Famine,
+ Flood
+} QualityMessageType;
+
+typedef struct tagQuality
+{
+ QualityMessageType Type;
+ long Proportion;
+ REFERENCE_TIME Late;
+ REFERENCE_TIME TimeStamp;
+} Quality;
+
+typedef IQualityControl *PQUALITYCONTROL;
+
+[
+object,
+uuid(56a868a5-0ad4-11ce-b03a-0020af0ba770),
+pointer_default(unique)
+]
+interface IQualityControl : IUnknown
+{
+ HRESULT Notify
+ ( [in] IBaseFilter * pSelf,
+ [in] Quality q
+ );
+
+ HRESULT SetSink
+ ( [in] IQualityControl * piqc
+ );
+}
+
+enum
+{
+ CK_NOCOLORKEY = 0x0,
+ CK_INDEX = 0x1,
+ CK_RGB = 0x2
+};
+
+typedef struct tagCOLORKEY
+{
+ DWORD KeyType;
+ DWORD PaletteIndex;
+ COLORREF LowColorValue;
+ COLORREF HighColorValue;
+} COLORKEY;
+
+enum
+{
+ ADVISE_NONE = 0x0,
+ ADVISE_CLIPPING = 0x1,
+ ADVISE_PALETTE = 0x2,
+ ADVISE_COLORKEY = 0x4,
+ ADVISE_POSITION = 0x8,
+ ADVISE_DISPLAY_CHANGE = 0x10
+};
+
+const DWORD ADVISE_ALL = ADVISE_CLIPPING |
+ ADVISE_PALETTE |
+ ADVISE_COLORKEY |
+ ADVISE_POSITION;
+
+const DWORD ADVISE_ALL2 = ADVISE_ALL |
+ ADVISE_DISPLAY_CHANGE;
+
+cpp_quote("#ifndef _WINGDI_")
+
+/* already defined in wingdi.h, but needed for WIDL */
+
+typedef struct _RGNDATAHEADER
+{
+ DWORD dwSize;
+ DWORD iType;
+ DWORD nCount;
+ DWORD nRgnSize;
+ RECT rcBound;
+} RGNDATAHEADER;
+
+typedef struct _RGNDATA
+{
+ RGNDATAHEADER rdh;
+ char Buffer[1];
+} RGNDATA;
+
+cpp_quote("#endif /* _WINGDI_ */")
+
+[
+object,
+local,
+uuid(56a868a0-0ad4-11ce-b03a-0020af0ba770),
+pointer_default(unique)
+]
+interface IOverlayNotify : IUnknown
+{
+ HRESULT OnPaletteChange(
+ [in] DWORD dwColors,
+ [in] const PALETTEENTRY *pPalette);
+
+ HRESULT OnClipChange(
+ [in] const RECT *pSourceRect,
+ [in] const RECT *pDestinationRect,
+ [in] const RGNDATA *pRgnData);
+
+ HRESULT OnColorKeyChange([in] const COLORKEY *pColorKey);
+
+ HRESULT OnPositionChange([in] const RECT *pSourceRect,
+ [in] const RECT *pDestinationRect);
+}
+
+typedef IOverlayNotify *POVERLAYNOTIFY;
+
+cpp_quote("#if 0")
+typedef HANDLE HMONITOR;
+cpp_quote("#endif /* 0 */")
+
+[
+object,
+local,
+uuid(680EFA10-D535-11D1-87C8-00A0C9223196),
+pointer_default(unique)
+]
+interface IOverlayNotify2 : IOverlayNotify
+{
+ HRESULT OnDisplayChange(
+ HMONITOR hMonitor);
+}
+
+typedef IOverlayNotify2 *POVERLAYNOTIFY2;
+
+[
+object,
+local,
+uuid(56a868a1-0ad4-11ce-b03a-0020af0ba770),
+pointer_default(unique)
+]
+interface IOverlay : IUnknown
+{
+ HRESULT GetPalette(
+ [out] DWORD *pdwColors,
+ [out] PALETTEENTRY **ppPalette);
+
+ HRESULT SetPalette(
+ [in] DWORD dwColors,
+ [in] PALETTEENTRY *pPalette);
+
+ HRESULT GetDefaultColorKey([out] COLORKEY *pColorKey);
+
+ HRESULT GetColorKey([out] COLORKEY *pColorKey);
+
+ HRESULT SetColorKey([in,out] COLORKEY *pColorKey);
+
+ HRESULT GetWindowHandle([out] HWND *pHwnd);
+
+ HRESULT GetClipList([out] RECT *pSourceRect,
+ [out] RECT *pDestinationRect,
+ [out] RGNDATA **ppRgnData);
+
+ HRESULT GetVideoPosition([out] RECT *pSourceRect,
+ [out] RECT *pDestinationRect);
+
+ HRESULT Advise(
+ [in] IOverlayNotify *pOverlayNotify,
+ [in] DWORD dwInterests);
+
+ HRESULT Unadvise();
+}
+
+typedef IOverlay *POVERLAY;
+
+[
+object,
+uuid(56a868a2-0ad4-11ce-b03a-0020af0ba770),
+pointer_default(unique)
+]
+interface IMediaEventSink : IUnknown
+{
+ HRESULT Notify(
+ [in] long EventCode,
+ [in] LONG_PTR EventParam1,
+ [in] LONG_PTR EventParam2
+ );
+}
+
+typedef IMediaEventSink *PMEDIAEVENTSINK;
+
+[
+object,
+uuid(56a868a6-0ad4-11ce-b03a-0020af0ba770),
+pointer_default(unique)
+]
+interface IFileSourceFilter : IUnknown
+{
+ HRESULT Load(
+ [in] LPCOLESTR pszFileName,
+ [in, unique] const AM_MEDIA_TYPE *pmt
+ );
+
+ HRESULT GetCurFile(
+ [out] LPOLESTR *ppszFileName,
+ [out] AM_MEDIA_TYPE *pmt
+ );
+}
+
+typedef IFileSourceFilter *PFILTERFILESOURCE;
+
+[
+object,
+uuid(a2104830-7c70-11cf-8bce-00aa00a3f1a6),
+pointer_default(unique)
+]
+interface IFileSinkFilter : IUnknown
+{
+ HRESULT SetFileName(
+ [in] LPCOLESTR pszFileName,
+ [in, unique] const AM_MEDIA_TYPE *pmt
+ );
+
+ HRESULT GetCurFile(
+ [out] LPOLESTR *ppszFileName,
+ [out] AM_MEDIA_TYPE *pmt
+ );
+}
+
+typedef IFileSinkFilter *PFILTERFILESINK;
+
+[
+ object,
+ uuid(00855B90-CE1B-11d0-BD4F-00A0C911CE86),
+ pointer_default(unique)
+]
+interface IFileSinkFilter2 : IFileSinkFilter
+{
+ HRESULT SetMode(
+ [in] DWORD dwFlags
+ );
+
+ HRESULT GetMode(
+ [out] DWORD *pdwFlags
+ );
+}
+
+typedef IFileSinkFilter2 *PFILESINKFILTER2;
+
+typedef enum
+{
+ AM_FILE_OVERWRITE = 0x00000001,
+} AM_FILESINK_FLAGS;
+
+[
+object,
+uuid(56a868a9-0ad4-11ce-b03a-0020af0ba770),
+pointer_default(unique)
+]
+interface IGraphBuilder : IFilterGraph
+{
+ HRESULT Connect
+ ( [in] IPin * ppinOut,
+ [in] IPin * ppinIn
+ );
+
+ HRESULT Render
+ ( [in] IPin * ppinOut
+ );
+
+ HRESULT RenderFile
+ ( [in] LPCWSTR lpcwstrFile,
+ [in, unique] LPCWSTR lpcwstrPlayList
+ );
+
+ HRESULT AddSourceFilter
+ ( [in] LPCWSTR lpcwstrFileName,
+ [in, unique] LPCWSTR lpcwstrFilterName,
+ [out] IBaseFilter* *ppFilter
+ );
+
+ HRESULT SetLogFile
+ ( [in] DWORD_PTR hFile
+ );
+
+ HRESULT Abort();
+
+ HRESULT ShouldOperationContinue();
+}
+
+
+[
+ object,
+ uuid(bf87b6e0-8c27-11d0-b3f0-00aa003761c5),
+ pointer_default(unique)
+]
+interface ICaptureGraphBuilder : IUnknown {
+
+ HRESULT SetFiltergraph(
+ [in] IGraphBuilder *pfg);
+
+ HRESULT GetFiltergraph(
+ [out] IGraphBuilder **ppfg);
+
+ HRESULT SetOutputFileName(
+ [in] const GUID *pType,
+ [in] LPCOLESTR lpstrFile,
+ [out] IBaseFilter **ppf,
+ [out] IFileSinkFilter **ppSink);
+
+ [local] HRESULT FindInterface(
+ [in, unique] const GUID *pCategory,
+ [in] IBaseFilter *pf,
+ [in] REFIID riid,
+ [out] void **ppint);
+
+ [call_as(FindInterface)] HRESULT RemoteFindInterface(
+ [in, unique] const GUID *pCategory,
+ [in] IBaseFilter *pf,
+ [in] REFIID riid,
+ [out] IUnknown **ppint);
+
+ HRESULT RenderStream(
+ [in] const GUID *pCategory,
+ [in] IUnknown *pSource,
+ [in] IBaseFilter *pfCompressor,
+ [in] IBaseFilter *pfRenderer);
+
+ HRESULT ControlStream(
+ [in] const GUID *pCategory,
+ [in] IBaseFilter *pFilter,
+ [in] REFERENCE_TIME *pstart,
+ [in] REFERENCE_TIME *pstop,
+ [in] WORD wStartCookie,
+ [in] WORD wStopCookie);
+
+ HRESULT AllocCapFile(
+ [in] LPCOLESTR lpstr,
+ [in] DWORDLONG dwlSize);
+
+ HRESULT CopyCaptureFile(
+ [in] LPOLESTR lpwstrOld,
+ [in] LPOLESTR lpwstrNew,
+ [in] int fAllowEscAbort,
+ [in] IAMCopyCaptureFileProgress *pCallback);
+}
+
+[
+object,
+uuid(670d1d20-a068-11d0-b3f0-00aa003761c5),
+pointer_default(unique)
+]
+interface IAMCopyCaptureFileProgress : IUnknown
+{
+ HRESULT Progress(
+ [in] int iProgress);
+}
+
+[
+ object,
+ uuid(93E5A4E0-2D50-11d2-ABFA-00A0C9C6E38D),
+ pointer_default(unique)
+]
+interface ICaptureGraphBuilder2 : IUnknown
+{
+ HRESULT SetFiltergraph(
+ [in] IGraphBuilder *pfg);
+
+ HRESULT GetFiltergraph(
+ [out] IGraphBuilder **ppfg);
+
+ HRESULT SetOutputFileName(
+ [in] const GUID *pType,
+ [in] LPCOLESTR lpstrFile,
+ [out] IBaseFilter **ppf,
+ [out] IFileSinkFilter **ppSink);
+
+ [local] HRESULT FindInterface(
+ [in] const GUID *pCategory,
+ [in] const GUID *pType,
+ [in] IBaseFilter *pf,
+ [in] REFIID riid,
+ [out] void **ppint);
+
+ [call_as(FindInterface)] HRESULT RemoteFindInterface(
+ [in] const GUID *pCategory,
+ [in] const GUID *pType,
+ [in] IBaseFilter *pf,
+ [in] REFIID riid,
+ [out] IUnknown **ppint);
+
+ HRESULT RenderStream(
+ [in] const GUID *pCategory,
+ [in] const GUID *pType,
+ [in] IUnknown *pSource,
+ [in] IBaseFilter *pfCompressor,
+ [in] IBaseFilter *pfRenderer);
+
+ HRESULT ControlStream(
+ [in] const GUID *pCategory,
+ [in] const GUID *pType,
+ [in] IBaseFilter *pFilter,
+ [in] REFERENCE_TIME *pstart,
+ [in] REFERENCE_TIME *pstop,
+ [in] WORD wStartCookie,
+ [in] WORD wStopCookie);
+
+ HRESULT AllocCapFile(
+ [in] LPCOLESTR lpstr,
+ [in] DWORDLONG dwlSize);
+
+ HRESULT CopyCaptureFile(
+ [in] LPOLESTR lpwstrOld,
+ [in] LPOLESTR lpwstrNew,
+ [in] int fAllowEscAbort,
+ [in] IAMCopyCaptureFileProgress *pCallback);
+
+ HRESULT FindPin(
+ [in] IUnknown *pSource,
+ [in] PIN_DIRECTION pindir,
+ [in] const GUID *pCategory,
+ [in] const GUID *pType,
+ [in] BOOL fUnconnected,
+ [in] int num,
+ [out] IPin **ppPin);
+}
+
+enum _AM_RENSDEREXFLAGS
+{
+ AM_RENDEREX_RENDERTOEXISTINGRENDERERS = 0x01
+};
+
+[
+ object,
+ uuid(36b73882-c2c8-11cf-8b46-00805f6cef60),
+ pointer_default(unique)
+]
+interface IFilterGraph2: IGraphBuilder
+{
+ HRESULT AddSourceFilterForMoniker(
+ [in] IMoniker *pMoniker,
+ [in] IBindCtx *pCtx,
+ [in, unique] LPCWSTR lpcwstrFilterName,
+ [out] IBaseFilter **ppFilter
+ );
+
+ HRESULT ReconnectEx
+ ( [in] IPin * ppin,
+ [in, unique] const AM_MEDIA_TYPE *pmt
+ );
+
+ HRESULT RenderEx( [in] IPin *pPinOut,
+ [in] DWORD dwFlags,
+ [in, out] DWORD *pvContext
+ );
+}
+
+[
+ object,
+ local,
+ uuid(56a868bf-0ad4-11ce-b03a-0020af0ba770),
+ pointer_default(unique)
+]
+interface IStreamBuilder : IUnknown
+{
+ HRESULT Render
+ ( [in] IPin * ppinOut,
+ [in] IGraphBuilder * pGraph
+ );
+
+ HRESULT Backout
+ ( [in] IPin * ppinOut,
+ [in] IGraphBuilder * pGraph
+ );
+}
+
+
+[
+ object,
+ uuid(56a868aa-0ad4-11ce-b03a-0020af0ba770),
+ pointer_default(unique)
+]
+interface IAsyncReader : IUnknown
+{
+ HRESULT RequestAllocator(
+ [in] IMemAllocator* pPreferred,
+ [in] ALLOCATOR_PROPERTIES* pProps,
+ [out] IMemAllocator ** ppActual);
+
+ HRESULT Request(
+ [in] IMediaSample* pSample,
+ [in] DWORD_PTR dwUser);
+
+ HRESULT WaitForNext(
+ [in] DWORD dwTimeout,
+ [out] IMediaSample** ppSample,
+ [out] DWORD_PTR * pdwUser);
+
+ HRESULT SyncReadAligned(
+ [in] IMediaSample* pSample);
+
+ HRESULT SyncRead(
+ [in] LONGLONG llPosition,
+ [in] LONG lLength,
+ [out, size_is(lLength)]
+ BYTE* pBuffer);
+
+ HRESULT Length(
+ [out] LONGLONG* pTotal,
+ [out] LONGLONG* pAvailable);
+
+ HRESULT BeginFlush(void);
+
+ HRESULT EndFlush(void);
+}
+
+
+[
+ object,
+ uuid(56a868ab-0ad4-11ce-b03a-0020af0ba770),
+ pointer_default(unique)
+]
+interface IGraphVersion : IUnknown
+{
+ HRESULT QueryVersion(LONG* pVersion);
+}
+
+[
+ object,
+ uuid(56a868ad-0ad4-11ce-b03a-0020af0ba770),
+ pointer_default(unique)
+]
+interface IResourceConsumer : IUnknown
+{
+ HRESULT AcquireResource(
+ [in] LONG idResource);
+
+ HRESULT ReleaseResource(
+ [in] LONG idResource);
+}
+
+
+[
+ object,
+ uuid(56a868ac-0ad4-11ce-b03a-0020af0ba770),
+ pointer_default(unique)
+]
+interface IResourceManager : IUnknown
+{
+ HRESULT Register(
+ [in] LPCWSTR pName,
+ [in] LONG cResource,
+ [out] LONG* plToken
+ );
+
+ HRESULT RegisterGroup(
+ [in] LPCWSTR pName,
+ [in] LONG cResource,
+ [in, size_is(cResource)]
+ LONG* palTokens,
+ [out] LONG* plToken
+ );
+
+ HRESULT RequestResource(
+ [in] LONG idResource,
+ [in] IUnknown* pFocusObject,
+ [in] IResourceConsumer* pConsumer
+ );
+
+ HRESULT NotifyAcquire(
+ [in] LONG idResource,
+ [in] IResourceConsumer* pConsumer,
+ [in] HRESULT hr);
+
+ HRESULT NotifyRelease(
+ [in] LONG idResource,
+ [in] IResourceConsumer* pConsumer,
+ [in] BOOL bStillWant);
+
+ HRESULT CancelRequest(
+ [in] LONG idResource,
+ [in] IResourceConsumer* pConsumer);
+
+ HRESULT SetFocus(
+ [in] IUnknown* pFocusObject);
+
+ HRESULT ReleaseFocus(
+ [in] IUnknown* pFocusObject);
+
+}
diff --git a/include/devenum.idl b/include/devenum.idl
new file mode 100644
index 0000000..5022a78
--- /dev/null
+++ b/include/devenum.idl
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2002 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 "guiddef.h";
+import "oaidl.idl";
+
+cpp_quote("#define CDEF_CLASS_DEFAULT 0x0001")
+cpp_quote("#define CDEF_BYPASS_CLASS_MANAGER 0x0002")
+cpp_quote("#define CDEF_CLASS_LEGACY 0x0004")
+cpp_quote("#define CDEF_MERIT_ABOVE_DO_NOT_USE 0x0008")
+
+[
+ object,
+ uuid(29840822-5B84-11D0-BD3B-00A0C911CE86),
+ pointer_default(unique)
+]
+interface ICreateDevEnum : IUnknown
+{
+ HRESULT CreateClassEnumerator(
+ [in] REFCLSID clsidDeviceClass,
+ [out] IEnumMoniker ** ppEnumMoniker,
+ [in] DWORD dwFlags);
+}
diff --git a/include/dyngraph.idl b/include/dyngraph.idl
new file mode 100644
index 0000000..0138c10
--- /dev/null
+++ b/include/dyngraph.idl
@@ -0,0 +1,150 @@
+/*
+ * Copyright (C) 2002 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
+ */
+
+interface IPinConnection;
+interface IPinFlowControl;
+interface IGraphConfig;
+interface IGraphConfigCallback;
+
+[
+ local,
+ object,
+ uuid(4a9a62d3-27d4-403d-91e9-89f540e55534),
+ pointer_default(unique)
+]
+interface IPinConnection : IUnknown
+{
+ HRESULT DynamicQueryAccept([in] const AM_MEDIA_TYPE *pmt);
+
+ HRESULT NotifyEndOfStream([in] HANDLE hNotifyEvent);
+
+ HRESULT IsEndPin();
+
+ HRESULT DynamicDisconnect();
+};
+
+[
+ local,
+ object,
+ uuid(c56e9858-dbf3-4f6b-8119-384af2060deb),
+ pointer_default(unique)
+]
+interface IPinFlowControl : IUnknown
+{
+ HRESULT Block([in] DWORD dwBlockFlags, [in] HANDLE hEvent);
+}
+
+enum _AM_PIN_FLOW_CONTROL_BLOCK_FLAGS
+{
+ AM_PIN_FLOW_CONTROL_BLOCK = 0x00000001,
+};
+
+typedef enum _AM_GRAPH_CONFIG_RECONNECT_FLAGS
+{
+ AM_GRAPH_CONFIG_RECONNECT_DIRECTCONNECT = 0x00000001,
+ AM_GRAPH_CONFIG_RECONNECT_CACHE_REMOVED_FILTERS = 0x00000002,
+ AM_GRAPH_CONFIG_RECONNECT_USE_ONLY_CACHED_FILTERS = 0x00000004
+} AM_GRAPH_CONFIG_RECONNECT_FLAGS;
+
+enum _REM_FILTER_FLAGS
+{
+ REMFILTERF_LEAVECONNECTED = 0x00000001
+};
+
+typedef enum _AM_FILTER_FLAGS
+{
+ AM_FILTER_FLAGS_REMOVABLE = 0x00000001
+} AM_FILTER_FLAGS;
+
+[
+ local,
+ object,
+ uuid(03A1EB8E-32BF-4245-8502-114D08A9CB88),
+ pointer_default(unique)
+]
+interface IGraphConfig : IUnknown
+{
+ HRESULT Reconnect(
+ [in] IPin *pOutputPin,
+ [in] IPin *pInputPin,
+ [in] const AM_MEDIA_TYPE *pmtFirstConnection,
+ [in] IBaseFilter *pUsingFilter,
+ [in] HANDLE hAbortEvent,
+ [in] DWORD dwFlags);
+
+ HRESULT Reconfigure(
+ [in] IGraphConfigCallback *pCallback,
+ [in] PVOID pvContext,
+ [in] DWORD dwFlags,
+ [in] HANDLE hAbortEvent);
+
+ HRESULT AddFilterToCache([in] IBaseFilter *pFilter);
+
+ HRESULT EnumCacheFilter([out] IEnumFilters **pEnum);
+
+ HRESULT RemoveFilterFromCache([in]IBaseFilter *pFilter);
+
+ HRESULT GetStartTime([out] REFERENCE_TIME *prtStart);
+
+ HRESULT PushThroughData(
+ [in] IPin *pOutputPin,
+ [in] IPinConnection *pConnection,
+ [in] HANDLE hEventAbort);
+
+ HRESULT SetFilterFlags([in] IBaseFilter *pFilter, [in] DWORD dwFlags);
+
+ HRESULT GetFilterFlags([in] IBaseFilter *pFilter, [out] DWORD *pdwFlags);
+
+ HRESULT RemoveFilterEx([in] IBaseFilter *pFilter, DWORD Flags);
+}
+
+[
+ local,
+ object,
+ uuid(ade0fd60-d19d-11d2-abf6-00a0c905f375),
+ pointer_default(unique)
+]
+interface IGraphConfigCallback : IUnknown
+{
+ HRESULT Reconfigure(PVOID pvContext, DWORD dwFlags);
+}
+
+[
+ local,
+ object,
+ uuid(DCFBDCF6-0DC2-45f5-9AB2-7C330EA09C29),
+ pointer_default(unique)
+]
+interface IFilterChain : IUnknown
+{
+ HRESULT StartChain(
+ [in] IBaseFilter *pStartFilter,
+ [in] IBaseFilter *pEndFilter);
+
+ HRESULT PauseChain(
+ [in] IBaseFilter *pStartFilter,
+ [in] IBaseFilter *pEndFilter);
+
+ HRESULT StopChain(
+ [in] IBaseFilter *pStartFilter,
+ [in] IBaseFilter *pEndFilter);
+
+ HRESULT RemoveChain(
+ [in] IBaseFilter *pStartFilter,
+ [in] IBaseFilter *pEndFilter);
+}
diff --git a/include/strmif.h b/include/strmif.h
index 66dd8b5..4c7b982 100644
--- a/include/strmif.h
+++ b/include/strmif.h
@@ -1,388 +1,7183 @@
-/*
- * Copyright (C) 2002 Lionel Ulmer
- *
- * 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
+/*** Autogenerated by WIDL 0.1 from strmif.idl - Do not edit ***/
+#include "rpc.h"
+#include "rpcndr.h"
+
+#ifndef __WIDL_STRMIF_H
+#define __WIDL_STRMIF_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "objidl.h"
+#include "guiddef.h"
+#include "oaidl.h"
+#define CDEF_CLASS_DEFAULT 0x0001
+#define CDEF_BYPASS_CLASS_MANAGER 0x0002
+#define CDEF_CLASS_LEGACY 0x0004
+#define CDEF_MERIT_ABOVE_DO_NOT_USE 0x0008
+typedef struct ICreateDevEnum ICreateDevEnum;
+/*****************************************************************************
+ * ICreateDevEnum interface
*/
+DEFINE_GUID(IID_ICreateDevEnum, 0x29840822, 0x5b84, 0x11d0, 0xbd,0x3b, 0x00,0xa0,0xc9,0x11,0xce,0x86);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct ICreateDevEnum : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE CreateClassEnumerator(
+ REFCLSID clsidDeviceClass,
+ IEnumMoniker** ppEnumMoniker,
+ DWORD dwFlags) = 0;
-#ifndef __STRMIF_INCLUDED__
-#define __STRMIF_INCLUDED__
+};
+#else
+typedef struct ICreateDevEnumVtbl ICreateDevEnumVtbl;
+struct ICreateDevEnum {
+ const ICreateDevEnumVtbl* lpVtbl;
+};
+struct ICreateDevEnumVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
-#include "windef.h"
-#include "wingdi.h"
-#include "objbase.h"
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ ICreateDevEnum* This,
+ REFIID riid,
+ void** ppvObject);
-/* FilterGraph object / interface */
-typedef struct IFilterGraph IFilterGraph;
-typedef struct IBaseFilter IBaseFilter;
-typedef struct IEnumFilters IEnumFilters;
-typedef struct IPin IPin;
-typedef struct IEnumPins IEnumPins;
-typedef struct IEnumMediaTypes IEnumMediaTypes;
-typedef struct IMediaFilter IMediaFilter;
-typedef struct IReferenceClock IReferenceClock;
-typedef struct IGraphBuilder IGraphBuilder;
-typedef struct IMediaSeeking IMediaSeeking;
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ ICreateDevEnum* This);
-typedef LONGLONG REFERENCE_TIME;
-typedef double REFTIME;
+ ULONG (STDMETHODCALLTYPE *Release)(
+ ICreateDevEnum* This);
-typedef struct _MediaType {
- GUID majortype;
- GUID subtype;
- BOOL bFixedSizeSamples;
- BOOL bTemporalCompression;
- ULONG lSampleSize;
- GUID formattype;
- IUnknown *pUnk;
- ULONG cbFormat;
- /* [size_is] */ BYTE *pbFormat;
+ /*** ICreateDevEnum methods ***/
+ HRESULT (STDMETHODCALLTYPE *CreateClassEnumerator)(
+ ICreateDevEnum* This,
+ REFCLSID clsidDeviceClass,
+ IEnumMoniker** ppEnumMoniker,
+ DWORD dwFlags);
+
+};
+
+/*** IUnknown methods ***/
+#define ICreateDevEnum_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define ICreateDevEnum_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define ICreateDevEnum_Release(p) (p)->lpVtbl->Release(p)
+/*** ICreateDevEnum methods ***/
+#define ICreateDevEnum_CreateClassEnumerator(p,a,b,c) (p)->lpVtbl->CreateClassEnumerator(p,a,b,c)
+
+#endif
+
+#define ICreateDevEnum_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; \
+ /*** ICreateDevEnum methods ***/ \
+ STDMETHOD_(HRESULT,CreateClassEnumerator)(THIS_ REFCLSID clsidDeviceClass, IEnumMoniker** ppEnumMoniker, DWORD dwFlags) PURE;
+
+HRESULT CALLBACK ICreateDevEnum_CreateClassEnumerator_Proxy(
+ ICreateDevEnum* This,
+ REFCLSID clsidDeviceClass,
+ IEnumMoniker** ppEnumMoniker,
+ DWORD dwFlags);
+void __RPC_STUB ICreateDevEnum_CreateClassEnumerator_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+#define CHARS_IN_GUID 39
+#undef GetTimeFormat
+typedef struct _AMMediaType {
+ GUID majortype;
+ GUID subtype;
+ BOOL bFixedSizeSamples;
+ BOOL bTemporalCompression;
+ ULONG lSampleSize;
+ GUID formattype;
+ IUnknown *pUnk;
+ ULONG cbFormat;
+ BYTE *pbFormat;
} AM_MEDIA_TYPE;
-#define MAX_FILTER_NAME 128
-typedef struct _FilterInfo {
- WCHAR achName[MAX_FILTER_NAME];
- IFilterGraph *pGraph;
-} FILTER_INFO;
-
-typedef enum _FilterState {
- State_Stopped = 0,
- State_Paused = 1,
- State_Running = 2
-} FILTER_STATE;
-
-typedef enum _PinDirection {
- PINDIR_INPUT = 0,
- PINDIR_OUTPUT = 1
+typedef enum _PinDirection {
+ PINDIR_INPUT,
+ PINDIR_OUTPUT
} PIN_DIRECTION;
-#define MAX_PIN_NAME 128
+#define MAX_PIN_NAME 128
+#define MAX_FILTER_NAME 128
+typedef LONGLONG REFERENCE_TIME;
+
+typedef double REFTIME;
+
+typedef DWORD_PTR HSEMAPHORE;
+
+typedef DWORD_PTR HEVENT;
+
+typedef struct _AllocatorProperties {
+ long cBuffers;
+ long cbBuffer;
+ long cbAlign;
+ long cbPrefix;
+} ALLOCATOR_PROPERTIES;
+
+typedef struct IAMovieSetup IAMovieSetup;
+typedef struct IEnumFilters IEnumFilters;
+typedef struct IEnumMediaTypes IEnumMediaTypes;
+typedef struct IEnumPins IEnumPins;
+typedef struct IBaseFilter IBaseFilter;
+typedef struct IFilterGraph IFilterGraph;
+typedef struct IMediaFilter IMediaFilter;
+typedef struct IMediaSample IMediaSample;
+typedef struct IMemAllocator IMemAllocator;
+typedef struct IMemAllocatorCallbackTemp IMemAllocatorCallbackTemp;
+typedef struct IMemAllocatorNotifyCallbackTemp IMemAllocatorNotifyCallbackTemp;
+typedef struct IMemInputPin IMemInputPin;
+typedef struct IPin IPin;
+typedef struct IReferenceClock IReferenceClock;
typedef struct _PinInfo {
IBaseFilter *pFilter;
PIN_DIRECTION dir;
- WCHAR achName[MAX_PIN_NAME];
+ WCHAR achName[128];
} PIN_INFO;
-typedef DWORD_PTR HSEMAPHORE;
-typedef DWORD_PTR HEVENT;
+/*****************************************************************************
+ * IPin interface
+ */
+DEFINE_GUID(IID_IPin, 0x56a86891, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IPin : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE Connect(
+ IPin* pReceivePin,
+ const AM_MEDIA_TYPE* pmt) = 0;
-#define INTERFACE IPin
-#define IPin_METHODS \
- IUnknown_METHODS \
- STDMETHOD(Connect)(THIS_ IPin * pReceivePin, AM_MEDIA_TYPE * pmt) PURE; \
- STDMETHOD(ReceiveConnection)(THIS_ IPin * pConnector, AM_MEDIA_TYPE * pmt) PURE; \
- STDMETHOD(Disconnect)(THIS) PURE; \
- STDMETHOD(ConnectedTo)(THIS_ IPin ** pPin) PURE; \
- STDMETHOD(ConnectionMediaType)(THIS_ AM_MEDIA_TYPE * pmt) PURE; \
- STDMETHOD(QueryPinInfo)(THIS_ PIN_INFO * pInfo) PURE; \
- STDMETHOD(QueryDirection)(THIS_ PIN_DIRECTION * pPinDir) PURE; \
- STDMETHOD(QueryId)(THIS_ LPWSTR * Id) PURE; \
- STDMETHOD(QueryAccept)(THIS_ AM_MEDIA_TYPE * pmt) PURE; \
- STDMETHOD(EnumMediaTypes)(THIS_ IEnumMediaTypes ** ppEnum) PURE; \
- STDMETHOD(QueryInternalConnections)(THIS_ IPin ** apPin, ULONG * nPin) PURE; \
- STDMETHOD(EndOfStream)(THIS) PURE; \
- STDMETHOD(BeginFlush)(THIS) PURE; \
- STDMETHOD(EndFlush)(THIS) PURE; \
- STDMETHOD(NewSegment)(THIS_ REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate) PURE;
-ICOM_DEFINE(IPin,IUnknown)
-#undef INTERFACE
+ virtual HRESULT STDMETHODCALLTYPE ReceiveConnection(
+ IPin* pConnector,
+ const AM_MEDIA_TYPE* pmt) = 0;
-#ifdef COBJMACROS
+ virtual HRESULT STDMETHODCALLTYPE Disconnect(
+ ) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE ConnectedTo(
+ IPin** pPin) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE ConnectionMediaType(
+ AM_MEDIA_TYPE* pmt) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE QueryPinInfo(
+ PIN_INFO* pInfo) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE QueryDirection(
+ PIN_DIRECTION* pPinDir) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE QueryId(
+ LPWSTR* Id) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE QueryAccept(
+ const AM_MEDIA_TYPE* pmt) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE EnumMediaTypes(
+ IEnumMediaTypes** ppEnum) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE QueryInternalConnections(
+ IPin** apPin,
+ ULONG* nPin) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE EndOfStream(
+ ) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE BeginFlush(
+ ) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE EndFlush(
+ ) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE NewSegment(
+ REFERENCE_TIME tStart,
+ REFERENCE_TIME tStop,
+ double dRate) = 0;
+
+};
+#else
+typedef struct IPinVtbl IPinVtbl;
+struct IPin {
+ const IPinVtbl* lpVtbl;
+};
+struct IPinVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IPin* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IPin* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IPin* This);
+
+ /*** IPin methods ***/
+ HRESULT (STDMETHODCALLTYPE *Connect)(
+ IPin* This,
+ IPin* pReceivePin,
+ const AM_MEDIA_TYPE* pmt);
+
+ HRESULT (STDMETHODCALLTYPE *ReceiveConnection)(
+ IPin* This,
+ IPin* pConnector,
+ const AM_MEDIA_TYPE* pmt);
+
+ HRESULT (STDMETHODCALLTYPE *Disconnect)(
+ IPin* This);
+
+ HRESULT (STDMETHODCALLTYPE *ConnectedTo)(
+ IPin* This,
+ IPin** pPin);
+
+ HRESULT (STDMETHODCALLTYPE *ConnectionMediaType)(
+ IPin* This,
+ AM_MEDIA_TYPE* pmt);
+
+ HRESULT (STDMETHODCALLTYPE *QueryPinInfo)(
+ IPin* This,
+ PIN_INFO* pInfo);
+
+ HRESULT (STDMETHODCALLTYPE *QueryDirection)(
+ IPin* This,
+ PIN_DIRECTION* pPinDir);
+
+ HRESULT (STDMETHODCALLTYPE *QueryId)(
+ IPin* This,
+ LPWSTR* Id);
+
+ HRESULT (STDMETHODCALLTYPE *QueryAccept)(
+ IPin* This,
+ const AM_MEDIA_TYPE* pmt);
+
+ HRESULT (STDMETHODCALLTYPE *EnumMediaTypes)(
+ IPin* This,
+ IEnumMediaTypes** ppEnum);
+
+ HRESULT (STDMETHODCALLTYPE *QueryInternalConnections)(
+ IPin* This,
+ IPin** apPin,
+ ULONG* nPin);
+
+ HRESULT (STDMETHODCALLTYPE *EndOfStream)(
+ IPin* This);
+
+ HRESULT (STDMETHODCALLTYPE *BeginFlush)(
+ IPin* This);
+
+ HRESULT (STDMETHODCALLTYPE *EndFlush)(
+ IPin* This);
+
+ HRESULT (STDMETHODCALLTYPE *NewSegment)(
+ IPin* This,
+ REFERENCE_TIME tStart,
+ REFERENCE_TIME tStop,
+ double dRate);
+
+};
+
/*** IUnknown methods ***/
-#define IPin_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
-#define IPin_AddRef(p) (p)->lpVtbl->AddRef(p)
-#define IPin_Release(p) (p)->lpVtbl->Release(p)
+#define IPin_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IPin_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IPin_Release(p) (p)->lpVtbl->Release(p)
/*** IPin methods ***/
-#define IPin_Connect(p,a,b) (p)->lpVtbl->Connect(p,a,b)
-#define IPin_ReceiveConnection(p,a,b) (p)->lpVtbl->ReceiveConnection(p,a,b)
-#define IPin_Disconnect(p) (p)->lpVtbl->Disconnect(p)
-#define IPin_ConnectedTo(p,a) (p)->lpVtbl->ConnectedTo(p,a)
-#define IPin_ConnectionMediaType(p,a) (p)->lpVtbl->ConnectionMediaType(p,a)
-#define IPin_QueryPinInfo(p,a) (p)->lpVtbl->QueryPinInfo(p,a)
-#define IPin_QueryDirection(p,a) (p)->lpVtbl->QueryDirection(p,a)
-#define IPin_QueryId(p,a) (p)->lpVtbl->QueryId(p,a)
-#define IPin_QueryAccept(p,a) (p)->lpVtbl->QueryAccept(p,a)
-#define IPin_EnumMediaTypes(p,a) (p)->lpVtbl->EnumMediaTypes(p,a)
-#define IPin_QueryInternalConnections(p,a,b) (p)->lpVtbl->QueryInternalConnections(p,a,b)
-#define IPin_EndOfStream(p) (p)->lpVtbl->EndOfStream(p)
-#define IPin_BeginFlush(p) (p)->lpVtbl->BeginFlush(p)
-#define IPin_EndFlush(p) (p)->lpVtbl->EndFlush(p)
-#define IPin_NewSegment(p,a,b,c) (p)->lpVtbl->NewSegment(p,a,b,c)
+#define IPin_Connect(p,a,b) (p)->lpVtbl->Connect(p,a,b)
+#define IPin_ReceiveConnection(p,a,b) (p)->lpVtbl->ReceiveConnection(p,a,b)
+#define IPin_Disconnect(p) (p)->lpVtbl->Disconnect(p)
+#define IPin_ConnectedTo(p,a) (p)->lpVtbl->ConnectedTo(p,a)
+#define IPin_ConnectionMediaType(p,a) (p)->lpVtbl->ConnectionMediaType(p,a)
+#define IPin_QueryPinInfo(p,a) (p)->lpVtbl->QueryPinInfo(p,a)
+#define IPin_QueryDirection(p,a) (p)->lpVtbl->QueryDirection(p,a)
+#define IPin_QueryId(p,a) (p)->lpVtbl->QueryId(p,a)
+#define IPin_QueryAccept(p,a) (p)->lpVtbl->QueryAccept(p,a)
+#define IPin_EnumMediaTypes(p,a) (p)->lpVtbl->EnumMediaTypes(p,a)
+#define IPin_QueryInternalConnections(p,a,b) (p)->lpVtbl->QueryInternalConnections(p,a,b)
+#define IPin_EndOfStream(p) (p)->lpVtbl->EndOfStream(p)
+#define IPin_BeginFlush(p) (p)->lpVtbl->BeginFlush(p)
+#define IPin_EndFlush(p) (p)->lpVtbl->EndFlush(p)
+#define IPin_NewSegment(p,a,b,c) (p)->lpVtbl->NewSegment(p,a,b,c)
+
#endif
-#define INTERFACE IEnumPins
-#define IEnumPins_METHODS \
- IUnknown_METHODS \
- STDMETHOD(Next)(THIS_ ULONG cPins, IPin ** ppPins, ULONG * pcFetched) PURE; \
- STDMETHOD(Skip)(THIS_ ULONG cPins) PURE; \
- STDMETHOD(Reset)(THIS) PURE; \
- STDMETHOD(Clone)(THIS_ IEnumPins ** ppEnum) PURE;
-ICOM_DEFINE(IEnumPins,IUnknown)
-#undef INTERFACE
+#define IPin_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; \
+ /*** IPin methods ***/ \
+ STDMETHOD_(HRESULT,Connect)(THIS_ IPin* pReceivePin, const AM_MEDIA_TYPE* pmt) PURE; \
+ STDMETHOD_(HRESULT,ReceiveConnection)(THIS_ IPin* pConnector, const AM_MEDIA_TYPE* pmt) PURE; \
+ STDMETHOD_(HRESULT,Disconnect)(THIS) PURE; \
+ STDMETHOD_(HRESULT,ConnectedTo)(THIS_ IPin** pPin) PURE; \
+ STDMETHOD_(HRESULT,ConnectionMediaType)(THIS_ AM_MEDIA_TYPE* pmt) PURE; \
+ STDMETHOD_(HRESULT,QueryPinInfo)(THIS_ PIN_INFO* pInfo) PURE; \
+ STDMETHOD_(HRESULT,QueryDirection)(THIS_ PIN_DIRECTION* pPinDir) PURE; \
+ STDMETHOD_(HRESULT,QueryId)(THIS_ LPWSTR* Id) PURE; \
+ STDMETHOD_(HRESULT,QueryAccept)(THIS_ const AM_MEDIA_TYPE* pmt) PURE; \
+ STDMETHOD_(HRESULT,EnumMediaTypes)(THIS_ IEnumMediaTypes** ppEnum) PURE; \
+ STDMETHOD_(HRESULT,QueryInternalConnections)(THIS_ IPin** apPin, ULONG* nPin) PURE; \
+ STDMETHOD_(HRESULT,EndOfStream)(THIS) PURE; \
+ STDMETHOD_(HRESULT,BeginFlush)(THIS) PURE; \
+ STDMETHOD_(HRESULT,EndFlush)(THIS) PURE; \
+ STDMETHOD_(HRESULT,NewSegment)(THIS_ REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate) PURE;
-#ifdef COBJMACROS
+HRESULT CALLBACK IPin_Connect_Proxy(
+ IPin* This,
+ IPin* pReceivePin,
+ const AM_MEDIA_TYPE* pmt);
+void __RPC_STUB IPin_Connect_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IPin_ReceiveConnection_Proxy(
+ IPin* This,
+ IPin* pConnector,
+ const AM_MEDIA_TYPE* pmt);
+void __RPC_STUB IPin_ReceiveConnection_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IPin_Disconnect_Proxy(
+ IPin* This);
+void __RPC_STUB IPin_Disconnect_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IPin_ConnectedTo_Proxy(
+ IPin* This,
+ IPin** pPin);
+void __RPC_STUB IPin_ConnectedTo_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IPin_ConnectionMediaType_Proxy(
+ IPin* This,
+ AM_MEDIA_TYPE* pmt);
+void __RPC_STUB IPin_ConnectionMediaType_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IPin_QueryPinInfo_Proxy(
+ IPin* This,
+ PIN_INFO* pInfo);
+void __RPC_STUB IPin_QueryPinInfo_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IPin_QueryDirection_Proxy(
+ IPin* This,
+ PIN_DIRECTION* pPinDir);
+void __RPC_STUB IPin_QueryDirection_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IPin_QueryId_Proxy(
+ IPin* This,
+ LPWSTR* Id);
+void __RPC_STUB IPin_QueryId_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IPin_QueryAccept_Proxy(
+ IPin* This,
+ const AM_MEDIA_TYPE* pmt);
+void __RPC_STUB IPin_QueryAccept_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IPin_EnumMediaTypes_Proxy(
+ IPin* This,
+ IEnumMediaTypes** ppEnum);
+void __RPC_STUB IPin_EnumMediaTypes_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IPin_QueryInternalConnections_Proxy(
+ IPin* This,
+ IPin** apPin,
+ ULONG* nPin);
+void __RPC_STUB IPin_QueryInternalConnections_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IPin_EndOfStream_Proxy(
+ IPin* This);
+void __RPC_STUB IPin_EndOfStream_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IPin_BeginFlush_Proxy(
+ IPin* This);
+void __RPC_STUB IPin_BeginFlush_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IPin_EndFlush_Proxy(
+ IPin* This);
+void __RPC_STUB IPin_EndFlush_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IPin_NewSegment_Proxy(
+ IPin* This,
+ REFERENCE_TIME tStart,
+ REFERENCE_TIME tStop,
+ double dRate);
+void __RPC_STUB IPin_NewSegment_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+typedef IPin *PPIN;
+
+/*****************************************************************************
+ * IEnumPins interface
+ */
+DEFINE_GUID(IID_IEnumPins, 0x56a86892, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IEnumPins : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE Next(
+ ULONG cPins,
+ IPin** ppPins,
+ ULONG* pcFetched) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE Skip(
+ ULONG cPins) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE Reset(
+ ) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE Clone(
+ IEnumPins** ppEnum) = 0;
+
+};
+#else
+typedef struct IEnumPinsVtbl IEnumPinsVtbl;
+struct IEnumPins {
+ const IEnumPinsVtbl* lpVtbl;
+};
+struct IEnumPinsVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IEnumPins* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IEnumPins* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IEnumPins* This);
+
+ /*** IEnumPins methods ***/
+ HRESULT (STDMETHODCALLTYPE *Next)(
+ IEnumPins* This,
+ ULONG cPins,
+ IPin** ppPins,
+ ULONG* pcFetched);
+
+ HRESULT (STDMETHODCALLTYPE *Skip)(
+ IEnumPins* This,
+ ULONG cPins);
+
+ HRESULT (STDMETHODCALLTYPE *Reset)(
+ IEnumPins* This);
+
+ HRESULT (STDMETHODCALLTYPE *Clone)(
+ IEnumPins* This,
+ IEnumPins** ppEnum);
+
+};
+
/*** IUnknown methods ***/
-#define IEnumPins_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
-#define IEnumPins_AddRef(p) (p)->lpVtbl->AddRef(p)
-#define IEnumPins_Release(p) (p)->lpVtbl->Release(p)
+#define IEnumPins_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IEnumPins_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IEnumPins_Release(p) (p)->lpVtbl->Release(p)
/*** IEnumPins methods ***/
-#define IEnumPins_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c)
-#define IEnumPins_Skip(p,a) (p)->lpVtbl->Skip(p,a)
-#define IEnumPins_Reset(p) (p)->lpVtbl->Reset(p)
-#define IEnumPins_Clone(p,a) (p)->lpVtbl->Clone(p,a)
+#define IEnumPins_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c)
+#define IEnumPins_Skip(p,a) (p)->lpVtbl->Skip(p,a)
+#define IEnumPins_Reset(p) (p)->lpVtbl->Reset(p)
+#define IEnumPins_Clone(p,a) (p)->lpVtbl->Clone(p,a)
+
#endif
-#define INTERFACE IMediaFilter
-#define IMediaFilter_METHODS \
- IPersist_METHODS \
- STDMETHOD(Stop)(THIS) PURE; \
- STDMETHOD(Pause)(THIS) PURE; \
- STDMETHOD(Run)(THIS_ REFERENCE_TIME tStart) PURE; \
- STDMETHOD(GetState)(THIS_ DWORD dwMilliSecsTimeout, FILTER_STATE * State) PURE; \
- STDMETHOD(SetSyncSource)(THIS_ IReferenceClock * pClock) PURE; \
- STDMETHOD(GetSyncSource)(THIS_ IReferenceClock ** pClock) PURE;
-ICOM_DEFINE(IMediaFilter,IPersist)
-#undef INTERFACE
+#define IEnumPins_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; \
+ /*** IEnumPins methods ***/ \
+ STDMETHOD_(HRESULT,Next)(THIS_ ULONG cPins, IPin** ppPins, ULONG* pcFetched) PURE; \
+ STDMETHOD_(HRESULT,Skip)(THIS_ ULONG cPins) PURE; \
+ STDMETHOD_(HRESULT,Reset)(THIS) PURE; \
+ STDMETHOD_(HRESULT,Clone)(THIS_ IEnumPins** ppEnum) PURE;
-#ifdef COBJMACROS
+HRESULT CALLBACK IEnumPins_Next_Proxy(
+ IEnumPins* This,
+ ULONG cPins,
+ IPin** ppPins,
+ ULONG* pcFetched);
+void __RPC_STUB IEnumPins_Next_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumPins_Skip_Proxy(
+ IEnumPins* This,
+ ULONG cPins);
+void __RPC_STUB IEnumPins_Skip_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumPins_Reset_Proxy(
+ IEnumPins* This);
+void __RPC_STUB IEnumPins_Reset_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumPins_Clone_Proxy(
+ IEnumPins* This,
+ IEnumPins** ppEnum);
+void __RPC_STUB IEnumPins_Clone_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+typedef IEnumPins *PENUMPINS;
+
+/*****************************************************************************
+ * IEnumMediaTypes interface
+ */
+DEFINE_GUID(IID_IEnumMediaTypes, 0x89c31040, 0x846b, 0x11ce, 0x97,0xd3, 0x00,0xaa,0x00,0x55,0x59,0x5a);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IEnumMediaTypes : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE Next(
+ ULONG cMediaTypes,
+ AM_MEDIA_TYPE** ppMediaTypes,
+ ULONG* pcFetched) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE Skip(
+ ULONG cMediaTypes) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE Reset(
+ ) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE Clone(
+ IEnumMediaTypes** ppEnum) = 0;
+
+};
+#else
+typedef struct IEnumMediaTypesVtbl IEnumMediaTypesVtbl;
+struct IEnumMediaTypes {
+ const IEnumMediaTypesVtbl* lpVtbl;
+};
+struct IEnumMediaTypesVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IEnumMediaTypes* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IEnumMediaTypes* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IEnumMediaTypes* This);
+
+ /*** IEnumMediaTypes methods ***/
+ HRESULT (STDMETHODCALLTYPE *Next)(
+ IEnumMediaTypes* This,
+ ULONG cMediaTypes,
+ AM_MEDIA_TYPE** ppMediaTypes,
+ ULONG* pcFetched);
+
+ HRESULT (STDMETHODCALLTYPE *Skip)(
+ IEnumMediaTypes* This,
+ ULONG cMediaTypes);
+
+ HRESULT (STDMETHODCALLTYPE *Reset)(
+ IEnumMediaTypes* This);
+
+ HRESULT (STDMETHODCALLTYPE *Clone)(
+ IEnumMediaTypes* This,
+ IEnumMediaTypes** ppEnum);
+
+};
+
/*** IUnknown methods ***/
-#define IMediaFilter_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
-#define IMediaFilter_AddRef(p) (p)->lpVtbl->AddRef(p)
-#define IMediaFilter_Release(p) (p)->lpVtbl->Release(p)
-/*** IPersist methods ***/
-#define IMediaFilter_GetClassID(p,a) (p)->lpVtbl->GetClassID(p,a)
-/*** IMediaFilter methods ***/
-#define IMediaFilter_Stop(p) (p)->lpVtbl->Stop(p)
-#define IMediaFilter_Pause(p) (p)->lpVtbl->Pause(p)
-#define IMediaFilter_Run(p,a) (p)->lpVtbl->Run(p,a)
-#define IMediaFilter_GetState(p,a,b) (p)->lpVtbl->GetState(p,a,b)
-#define IMediaFilter_SetSyncSource(p,a) (p)->lpVtbl->SetSyncSource(p,a)
-#define IMediaFilter_GetSyncSource(p,a) (p)->lpVtbl->GetSyncSource(p,a)
-#endif
-
-#define INTERFACE IBaseFilter
-#define IBaseFilter_METHODS \
- IMediaFilter_METHODS \
- STDMETHOD(EnumPins)(THIS_ IEnumPins ** ppEnum) PURE; \
- STDMETHOD(FindPin)(THIS_ LPCWSTR Id, IPin ** ppPin) PURE; \
- STDMETHOD(QueryFilterInfo)(THIS_ FILTER_INFO * pInfo) PURE; \
- STDMETHOD(JoinFilterGraph)(THIS_ IFilterGraph * pGraph, LPCWSTR pName) PURE; \
- STDMETHOD(QueryVendorInfo)(THIS_ LPWSTR * pVendorInfo) PURE;
-ICOM_DEFINE(IBaseFilter,IMediaFilter)
-#undef INTERFACE
-
-#ifdef COBJMACROS
-/*** IUnknown methods ***/
-#define IBaseFilter_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
-#define IBaseFilter_AddRef(p) (p)->lpVtbl->AddRef(p)
-#define IBaseFilter_Release(p) (p)->lpVtbl->Release(p)
-/*** IPersist methods ***/
-#define IBaseFilter_GetClassID(p,a) (p)->lpVtbl->GetClassID(p,a)
-/*** IMediaFilter methods ***/
-#define IBaseFilter_Stop(p) (p)->lpVtbl->Stop(p)
-#define IBaseFilter_Pause(p) (p)->lpVtbl->Pause(p)
-#define IBaseFilter_Run(p,a) (p)->lpVtbl->Run(p,a)
-#define IBaseFilter_GetState(p,a,b) (p)->lpVtbl->GetState(p,a,b)
-#define IBaseFilter_SetSyncSource(p,a) (p)->lpVtbl->SetSyncSource(p,a)
-#define IBaseFilter_GetSyncSource(p,a) (p)->lpVtbl->GetSyncSource(p,a)
-/*** IBaseFilter methods ***/
-#define IBaseFilter_EnumPins(p,a) (p)->lpVtbl->EnumPins(p,a)
-#define IBaseFilter_FindPin(p,a,b) (p)->lpVtbl->FindPin(p,a,b)
-#define IBaseFilter_QueryFilterInfo(p,a) (p)->lpVtbl->QueryFilterInfo(p,a)
-#define IBaseFilter_JoinFilterGraph(p,a,b) (p)->lpVtbl->JoinFilterGraph(p,a,b)
-#define IBaseFilter_QueryVendorInfo(p,a) (p)->lpVtbl->QueryVendorInfo(p,a)
-#endif
-
-#define INTERFACE IFilterGraph
-#define IFilterGraph_METHODS \
- IUnknown_METHODS \
- STDMETHOD(AddFilter)(THIS_ IBaseFilter * pFilter, LPCWSTR pName) PURE; \
- STDMETHOD(RemoveFilter)(THIS_ IBaseFilter * pFilter) PURE; \
- STDMETHOD(EnumFilter)(THIS_ IEnumFilters ** ppEnum) PURE; \
- STDMETHOD(FindFilterByName)(THIS_ LPCWSTR pName, IBaseFilter ** ppFilter) PURE; \
- STDMETHOD(ConnectDirect)(THIS_ IPin * ppinIn, IPin * ppinOut, const AM_MEDIA_TYPE * pmt) PURE; \
- STDMETHOD(Reconnect)(THIS_ IPin * ppin) PURE; \
- STDMETHOD(Disconnect)(THIS_ IPin * ppin) PURE; \
- STDMETHOD(SetDefaultSyncSource)(THIS) PURE;
-ICOM_DEFINE(IFilterGraph,IUnknown)
-#undef INTERFACE
-
-#ifdef COBJMACROS
-/*** IUnknown methods ***/
-#define IFilterGraph_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
-#define IFilterGraph_AddRef(p) (p)->lpVtbl->AddRef(p)
-#define IFilterGraph_Release(p) (p)->lpVtbl->Release(p)
-/*** IFilterGraph methods ***/
-#define IFilterGraph_AddFilter(p,a,b) (p)->lpVtbl->AddFilter(p,a,b)
-#define IFilterGraph_RemoveFilter(p,a) (p)->lpVtbl->RemoveFilter(p,a)
-#define IFilterGraph_EnumFilter(p,a) (p)->lpVtbl->EnumFilter(p,a)
-#define IFilterGraph_FindFilterByName(p,a,b) (p)->lpVtbl->FindFilterByName(p,a,b)
-#define IFilterGraph_ConnectDirect(p,a,b,c) (p)->lpVtbl->ConnectDirect(p,a,b,c)
-#define IFilterGraph_Reconnect(p,a) (p)->lpVtbl->Reconnect(p,a)
-#define IFilterGraph_Disconnect(p,a) (p)->lpVtbl->Disconnect(p,a)
-#define IFilterGraph_SetDefaultSyncSource(p) (p)->lpVtbl->SetDefaultSyncSource(p)
-#endif
-
-#define INTERFACE IEnumFilters
-#define IEnumFilters_METHODS \
- IUnknown_METHODS \
- STDMETHOD(Next)(THIS_ ULONG cFilters, IBaseFilter ** ppFilter, ULONG * pcFetched) PURE; \
- STDMETHOD(Skip)(THIS_ ULONG cFilters) PURE; \
- STDMETHOD(Reset)(THIS) PURE; \
- STDMETHOD(Clone)(THIS_ IEnumFilters ** ppEnum) PURE;
-ICOM_DEFINE(IEnumFilters,IUnknown)
-#undef INTERFACE
-
-#ifdef COBJMACROS
-/*** IUnknown methods ***/
-#define IEnumFilters_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
-#define IEnumFilters_AddRef(p) (p)->lpVtbl->AddRef(p)
-#define IEnumFilters_Release(p) (p)->lpVtbl->Release(p)
-/*** IEnumFilters methods ***/
-#define IEnumFilters_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c)
-#define IEnumFilters_Skip(p,a) (p)->lpVtbl->Skip(p,a)
-#define IEnumFilters_Reset(p) (p)->lpVtbl->Reset(p)
-#define IEnumFilters_Clone(p,a) (p)->lpVtbl->Clone(p,a)
-#endif
-
-#define INTERFACE IEnumMediaTypes
-#define IEnumMediaTypes_METHODS \
- IUnknown_METHODS \
- STDMETHOD(Next)(THIS_ ULONG cMediaTypes, AM_MEDIA_TYPE ** ppMediaTypes, ULONG * pcFetched) PURE; \
- STDMETHOD(Skip)(THIS_ ULONG cMediaTypes) PURE; \
- STDMETHOD(Reset)(THIS) PURE; \
- STDMETHOD(Clone)(THIS_ IEnumMediaTypes ** ppEnum) PURE;
-ICOM_DEFINE(IEnumMediaTypes,IUnknown)
-#undef INTERFACE
-
-#ifdef COBJMACROS
-/*** IUnknown methods ***/
-#define IEnumMediaTypes_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
-#define IEnumMediaTypes_AddRef(p) (p)->lpVtbl->AddRef(p)
-#define IEnumMediaTypes_Release(p) (p)->lpVtbl->Release(p)
+#define IEnumMediaTypes_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IEnumMediaTypes_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IEnumMediaTypes_Release(p) (p)->lpVtbl->Release(p)
/*** IEnumMediaTypes methods ***/
-#define IEnumMediaTypes_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c)
-#define IEnumMediaTypes_Skip(p,a) (p)->lpVtbl->Skip(p,a)
-#define IEnumMediaTypes_Reset(p) (p)->lpVtbl->Reset(p)
-#define IEnumMediaTypes_Clone(p,a) (p)->lpVtbl->Clone(p,a)
-#endif
-
-#define INTERFACE IReferenceClock
-#define IReferenceClock_METHODS \
- IUnknown_METHODS \
- STDMETHOD(GetTime)(THIS_ REFERENCE_TIME * pTime) PURE; \
- STDMETHOD(AdviseTime)(THIS_ REFERENCE_TIME baseTime, REFERENCE_TIME streamTime, HEVENT hEvent, DWORD_PTR * pdwAdviseCookie) PURE; \
- STDMETHOD(AdvisePeriodic)(THIS_ REFERENCE_TIME startTime, REFERENCE_TIME periodTime, HSEMAPHORE hSemaphore, DWORD_PTR * pdwAdviseCookie) PURE; \
- STDMETHOD(Unadvise)(THIS_ DWORD_PTR dwAdviseCookie) PURE;
-ICOM_DEFINE(IReferenceClock,IUnknown)
-#undef INTERFACE
+#define IEnumMediaTypes_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c)
+#define IEnumMediaTypes_Skip(p,a) (p)->lpVtbl->Skip(p,a)
+#define IEnumMediaTypes_Reset(p) (p)->lpVtbl->Reset(p)
+#define IEnumMediaTypes_Clone(p,a) (p)->lpVtbl->Clone(p,a)
-#ifdef COBJMACROS
-/*** IUnknown methods ***/
-#define IReferenceClock_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
-#define IReferenceClock_AddRef(p) (p)->lpVtbl->AddRef(p)
-#define IReferenceClock_Release(p) (p)->lpVtbl->Release(p)
-/*** IReferenceClock methods ***/
-#define IReferenceClock_GetTime(p,a) (p)->lpVtbl->GetTime(p,a)
-#define IReferenceClock_AdviseTime(p,a,b,c,d) (p)->lpVtbl->AdviseTime(p,a,b,c,d)
-#define IReferenceClock_AdvisePeriodic(p,a,b,c,d) (p)->lpVtbl->AdvisePeriodic(p,a,b,c,d)
-#define IReferenceClock_Unadvise(p,a) (p)->lpVtbl->Unadvise(p,a)
#endif
-
-#define INTERFACE IGraphBuilder
-#define IGraphBuilder_METHODS \
- IFilterGraph_METHODS \
- STDMETHOD(Connect)(THIS_ IPin * ppinOut, IPin * ppinIn) PURE; \
- STDMETHOD(Render)(THIS_ IPin * ppinOut) PURE; \
- STDMETHOD(RenderFile)(THIS_ LPCWSTR lpcwstrFile, LPCWSTR lpcwstrPlayList) PURE; \
- STDMETHOD(AddSourceFilter)(THIS_ LPCWSTR lpcwstrFileName, LPCWSTR lpcwstrFilterName, IBaseFilter ** ppFilter) PURE; \
- STDMETHOD(SetLogFile)(THIS_ DWORD_PTR hFile) PURE; \
- STDMETHOD(Abort)(THIS) PURE; \
- STDMETHOD(ShouldOperationContinue)(THIS) PURE;
-ICOM_DEFINE(IGraphBuilder,IFilterGraph)
-#undef INTERFACE
-#ifdef COBJMACROS
+#define IEnumMediaTypes_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; \
+ /*** IEnumMediaTypes methods ***/ \
+ STDMETHOD_(HRESULT,Next)(THIS_ ULONG cMediaTypes, AM_MEDIA_TYPE** ppMediaTypes, ULONG* pcFetched) PURE; \
+ STDMETHOD_(HRESULT,Skip)(THIS_ ULONG cMediaTypes) PURE; \
+ STDMETHOD_(HRESULT,Reset)(THIS) PURE; \
+ STDMETHOD_(HRESULT,Clone)(THIS_ IEnumMediaTypes** ppEnum) PURE;
+
+HRESULT CALLBACK IEnumMediaTypes_Next_Proxy(
+ IEnumMediaTypes* This,
+ ULONG cMediaTypes,
+ AM_MEDIA_TYPE** ppMediaTypes,
+ ULONG* pcFetched);
+void __RPC_STUB IEnumMediaTypes_Next_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumMediaTypes_Skip_Proxy(
+ IEnumMediaTypes* This,
+ ULONG cMediaTypes);
+void __RPC_STUB IEnumMediaTypes_Skip_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumMediaTypes_Reset_Proxy(
+ IEnumMediaTypes* This);
+void __RPC_STUB IEnumMediaTypes_Reset_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumMediaTypes_Clone_Proxy(
+ IEnumMediaTypes* This,
+ IEnumMediaTypes** ppEnum);
+void __RPC_STUB IEnumMediaTypes_Clone_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+typedef IEnumMediaTypes *PENUMMEDIATYPES;
+
+/*****************************************************************************
+ * IFilterGraph interface
+ */
+DEFINE_GUID(IID_IFilterGraph, 0x56a8689f, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IFilterGraph : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE AddFilter(
+ IBaseFilter* pFilter,
+ LPCWSTR pName) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE RemoveFilter(
+ IBaseFilter* pFilter) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE EnumFilters(
+ IEnumFilters** ppEnum) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE FindFilterByName(
+ LPCWSTR pName,
+ IBaseFilter** ppFilter) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE ConnectDirect(
+ IPin* ppinOut,
+ IPin* ppinIn,
+ const AM_MEDIA_TYPE* pmt) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE Reconnect(
+ IPin* ppin) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE Disconnect(
+ IPin* ppin) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE SetDefaultSyncSource(
+ ) = 0;
+
+};
+#else
+typedef struct IFilterGraphVtbl IFilterGraphVtbl;
+struct IFilterGraph {
+ const IFilterGraphVtbl* lpVtbl;
+};
+struct IFilterGraphVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IFilterGraph* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IFilterGraph* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IFilterGraph* This);
+
+ /*** IFilterGraph methods ***/
+ HRESULT (STDMETHODCALLTYPE *AddFilter)(
+ IFilterGraph* This,
+ IBaseFilter* pFilter,
+ LPCWSTR pName);
+
+ HRESULT (STDMETHODCALLTYPE *RemoveFilter)(
+ IFilterGraph* This,
+ IBaseFilter* pFilter);
+
+ HRESULT (STDMETHODCALLTYPE *EnumFilters)(
+ IFilterGraph* This,
+ IEnumFilters** ppEnum);
+
+ HRESULT (STDMETHODCALLTYPE *FindFilterByName)(
+ IFilterGraph* This,
+ LPCWSTR pName,
+ IBaseFilter** ppFilter);
+
+ HRESULT (STDMETHODCALLTYPE *ConnectDirect)(
+ IFilterGraph* This,
+ IPin* ppinOut,
+ IPin* ppinIn,
+ const AM_MEDIA_TYPE* pmt);
+
+ HRESULT (STDMETHODCALLTYPE *Reconnect)(
+ IFilterGraph* This,
+ IPin* ppin);
+
+ HRESULT (STDMETHODCALLTYPE *Disconnect)(
+ IFilterGraph* This,
+ IPin* ppin);
+
+ HRESULT (STDMETHODCALLTYPE *SetDefaultSyncSource)(
+ IFilterGraph* This);
+
+};
+
/*** IUnknown methods ***/
-#define IGraphBuilder_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
-#define IGraphBuilder_AddRef(p) (p)->lpVtbl->AddRef(p)
-#define IGraphBuilder_Release(p) (p)->lpVtbl->Release(p)
+#define IFilterGraph_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IFilterGraph_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IFilterGraph_Release(p) (p)->lpVtbl->Release(p)
/*** IFilterGraph methods ***/
-#define IGraphBuilder_AddFilter(p,a,b) (p)->lpVtbl->AddFilter(p,a,b)
-#define IGraphBuilder_RemoveFilter(p,a) (p)->lpVtbl->RemoveFilter(p,a)
-#define IGraphBuilder_EnumFilter(p,a) (p)->lpVtbl->EnumFilter(p,a)
-#define IGraphBuilder_FindFilterByName(p,a,b) (p)->lpVtbl->FindFilterByName(p,a,b)
-#define IGraphBuilder_ConnectDirect(p,a,b,c) (p)->lpVtbl->ConnectDirect(p,a,b,c)
-#define IGraphBuilder_Reconnect(p,a) (p)->lpVtbl->Reconnect(p,a)
-#define IGraphBuilder_Disconnect(p,a) (p)->lpVtbl->Disconnect(p,a)
-#define IGraphBuilder_SetDefaultSyncSource(p) (p)->lpVtbl->SetDefaultSyncSource(p)
-/*** IGraphBuilder methods ***/
-#define IGraphBuilder_Connect(p,a,b) (p)->lpVtbl->Connect(p,a,b)
-#define IGraphBuilder_Render(p,a) (p)->lpVtbl->Render(p,a)
-#define IGraphBuilder_RenderFile(p,a,b) (p)->lpVtbl->RenderFile(p,a,b)
-#define IGraphBuilder_AddSourceFilter(p,a,b,c) (p)->lpVtbl->AddSourceFilter(p,a,b,c)
-#define IGraphBuilder_SetLogFile(p,a) (p)->lpVtbl->SetLogFile(p,a)
-#define IGraphBuilder_Abort(p) (p)->lpVtbl->Abort(p)
-#define IGraphBuilder_ShouldOperationContinue(p) (p)->lpVtbl->ShouldOperationContinue(p)
+#define IFilterGraph_AddFilter(p,a,b) (p)->lpVtbl->AddFilter(p,a,b)
+#define IFilterGraph_RemoveFilter(p,a) (p)->lpVtbl->RemoveFilter(p,a)
+#define IFilterGraph_EnumFilters(p,a) (p)->lpVtbl->EnumFilters(p,a)
+#define IFilterGraph_FindFilterByName(p,a,b) (p)->lpVtbl->FindFilterByName(p,a,b)
+#define IFilterGraph_ConnectDirect(p,a,b,c) (p)->lpVtbl->ConnectDirect(p,a,b,c)
+#define IFilterGraph_Reconnect(p,a) (p)->lpVtbl->Reconnect(p,a)
+#define IFilterGraph_Disconnect(p,a) (p)->lpVtbl->Disconnect(p,a)
+#define IFilterGraph_SetDefaultSyncSource(p) (p)->lpVtbl->SetDefaultSyncSource(p)
+
#endif
-#define INTERFACE IMediaSeeking
-#define IMediaSeeking_METHODS \
- IUnknown_METHODS \
- STDMETHOD(GetCapabilities)(THIS_ DWORD * pCapabilities) PURE; \
- STDMETHOD(CheckCapabilities)(THIS_ DWORD * pCapabilities) PURE; \
- STDMETHOD(IsFormatSupported)(THIS_ GUID * pFormat) PURE; \
- STDMETHOD(QueryPreferredFormat)(THIS_ GUID * pFormat) PURE; \
- STDMETHOD(GetTimeFormat)(THIS_ GUID * pFormat) PURE; \
- STDMETHOD(IsUsingTimeFormat)(THIS_ GUID * pFormat) PURE; \
- STDMETHOD(SetTimeFormat)(THIS_ GUID * pFormat) PURE; \
- STDMETHOD(GetDuration)(THIS_ LONGLONG * pDuration) PURE; \
- STDMETHOD(GetStopPosition)(THIS_ LONGLONG * pStop) PURE; \
- STDMETHOD(GetCurrentPosition)(THIS_ LONGLONG * pCurrent) PURE; \
- STDMETHOD(ConvertTimeFormat)(THIS_ LONGLONG * pTarget, GUID * pTargetFormat, LONGLONG Source, GUID * pSourceFormat) PURE; \
- STDMETHOD(SetPositions)(THIS_ LONGLONG * pCurrent, DWORD dwCurrentFlags, LONGLONG * pStop, DWORD dwStopFlags) PURE; \
- STDMETHOD(GetPositions)(THIS_ LONGLONG * pCurrent, LONGLONG * pStop) PURE; \
- STDMETHOD(GetAvailable)(THIS_ LONGLONG * pEarliest, LONGLONG * pLatest) PURE; \
- STDMETHOD(SetRate)(THIS_ double dRate) PURE; \
- STDMETHOD(GetRate)(THIS_ double * pdRate) PURE; \
- STDMETHOD(GetPreroll)(THIS_ LONGLONG * pllPreroll) PURE;
-ICOM_DEFINE(IMediaSeeking,IUnknown)
-#undef INTERFACE
+#define IFilterGraph_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; \
+ /*** IFilterGraph methods ***/ \
+ STDMETHOD_(HRESULT,AddFilter)(THIS_ IBaseFilter* pFilter, LPCWSTR pName) PURE; \
+ STDMETHOD_(HRESULT,RemoveFilter)(THIS_ IBaseFilter* pFilter) PURE; \
+ STDMETHOD_(HRESULT,EnumFilters)(THIS_ IEnumFilters** ppEnum) PURE; \
+ STDMETHOD_(HRESULT,FindFilterByName)(THIS_ LPCWSTR pName, IBaseFilter** ppFilter) PURE; \
+ STDMETHOD_(HRESULT,ConnectDirect)(THIS_ IPin* ppinOut, IPin* ppinIn, const AM_MEDIA_TYPE* pmt) PURE; \
+ STDMETHOD_(HRESULT,Reconnect)(THIS_ IPin* ppin) PURE; \
+ STDMETHOD_(HRESULT,Disconnect)(THIS_ IPin* ppin) PURE; \
+ STDMETHOD_(HRESULT,SetDefaultSyncSource)(THIS) PURE;
-#ifdef COBJMACROS
+HRESULT CALLBACK IFilterGraph_AddFilter_Proxy(
+ IFilterGraph* This,
+ IBaseFilter* pFilter,
+ LPCWSTR pName);
+void __RPC_STUB IFilterGraph_AddFilter_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFilterGraph_RemoveFilter_Proxy(
+ IFilterGraph* This,
+ IBaseFilter* pFilter);
+void __RPC_STUB IFilterGraph_RemoveFilter_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFilterGraph_EnumFilters_Proxy(
+ IFilterGraph* This,
+ IEnumFilters** ppEnum);
+void __RPC_STUB IFilterGraph_EnumFilters_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFilterGraph_FindFilterByName_Proxy(
+ IFilterGraph* This,
+ LPCWSTR pName,
+ IBaseFilter** ppFilter);
+void __RPC_STUB IFilterGraph_FindFilterByName_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFilterGraph_ConnectDirect_Proxy(
+ IFilterGraph* This,
+ IPin* ppinOut,
+ IPin* ppinIn,
+ const AM_MEDIA_TYPE* pmt);
+void __RPC_STUB IFilterGraph_ConnectDirect_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFilterGraph_Reconnect_Proxy(
+ IFilterGraph* This,
+ IPin* ppin);
+void __RPC_STUB IFilterGraph_Reconnect_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFilterGraph_Disconnect_Proxy(
+ IFilterGraph* This,
+ IPin* ppin);
+void __RPC_STUB IFilterGraph_Disconnect_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFilterGraph_SetDefaultSyncSource_Proxy(
+ IFilterGraph* This);
+void __RPC_STUB IFilterGraph_SetDefaultSyncSource_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+typedef IFilterGraph *PFILTERGRAPH;
+
+/*****************************************************************************
+ * IEnumFilters interface
+ */
+DEFINE_GUID(IID_IEnumFilters, 0x56a86893, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IEnumFilters : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE Next(
+ ULONG cFilters,
+ IBaseFilter** ppFilter,
+ ULONG* pcFetched) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE Skip(
+ ULONG cFilters) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE Reset(
+ ) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE Clone(
+ IEnumFilters** ppEnum) = 0;
+
+};
+#else
+typedef struct IEnumFiltersVtbl IEnumFiltersVtbl;
+struct IEnumFilters {
+ const IEnumFiltersVtbl* lpVtbl;
+};
+struct IEnumFiltersVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IEnumFilters* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IEnumFilters* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IEnumFilters* This);
+
+ /*** IEnumFilters methods ***/
+ HRESULT (STDMETHODCALLTYPE *Next)(
+ IEnumFilters* This,
+ ULONG cFilters,
+ IBaseFilter** ppFilter,
+ ULONG* pcFetched);
+
+ HRESULT (STDMETHODCALLTYPE *Skip)(
+ IEnumFilters* This,
+ ULONG cFilters);
+
+ HRESULT (STDMETHODCALLTYPE *Reset)(
+ IEnumFilters* This);
+
+ HRESULT (STDMETHODCALLTYPE *Clone)(
+ IEnumFilters* This,
+ IEnumFilters** ppEnum);
+
+};
+
/*** IUnknown methods ***/
-#define IMediaSeeking_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
-#define IMediaSeeking_AddRef(p) (p)->lpVtbl->AddRef(p)
-#define IMediaSeeking_Release(p) (p)->lpVtbl->Release(p)
-/*** IMediaSeeking methods ***/
-#define IMediaSeeking_GetCapabilities(p,a) (p)->lpVtbl->GetCapabilities(p,a)
-#define IMediaSeeking_CheckCapabilities(p,a) (p)->lpVtbl->CheckCapabilities(p,a)
-#define IMediaSeeking_IsFormatSupported(p,a) (p)->lpVtbl->IsFormatSupported(p,a)
-#define IMediaSeeking_QueryPreferredFormat(p,a) (p)->lpVtbl->QueryPreferredFormat(p,a)
-#define IMediaSeeking_GetTimeFormat(p,a) (p)->lpVtbl->GetTimeFormat(p,a)
-#define IMediaSeeking_IsUsingTimeFormat(p,a) (p)->lpVtbl->IsUsingTimeFormat(p,a)
-#define IMediaSeeking_SetTimeFormat(p,a) (p)->lpVtbl->SetTimeFormat(p,a)
-#define IMediaSeeking_GetDuration(p,a) (p)->lpVtbl->GetDuration(p,a)
-#define IMediaSeeking_GetStopPosition(p,a) (p)->lpVtbl->GetStopPosition(p,a)
-#define IMediaSeeking_GetCurrentPosition(p,a) (p)->lpVtbl->GetCurrentPosition(p,a)
-#define IMediaSeeking_ConvertTimeFormat(p,a,b,c,d) (p)->lpVtbl->ConvertTimeFormat(p,a,b,c,d)
-#define IMediaSeeking_SetPositions(p,a,b,c,d) (p)->lpVtbl->SetPositions(p,a,b,c,d)
-#define IMediaSeeking_GetPositions(p,a,b) (p)->lpVtbl->GetPositions(p,a,b)
-#define IMediaSeeking_GetAvailable(p,a,b) (p)->lpVtbl->GetAvailable(p,a,b)
-#define IMediaSeeking_SetRate(p,a) (p)->lpVtbl->SetRate(p,a)
-#define IMediaSeeking_GetRate(p,a) (p)->lpVtbl->GetRate(p,a)
-#define IMediaSeeking_GetPreroll(p,a) (p)->lpVtbl->GetPreroll(p,a)
+#define IEnumFilters_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IEnumFilters_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IEnumFilters_Release(p) (p)->lpVtbl->Release(p)
+/*** IEnumFilters methods ***/
+#define IEnumFilters_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c)
+#define IEnumFilters_Skip(p,a) (p)->lpVtbl->Skip(p,a)
+#define IEnumFilters_Reset(p) (p)->lpVtbl->Reset(p)
+#define IEnumFilters_Clone(p,a) (p)->lpVtbl->Clone(p,a)
+
#endif
-
-#endif /* __STRMIF_INCLUDED__ */
+
+#define IEnumFilters_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; \
+ /*** IEnumFilters methods ***/ \
+ STDMETHOD_(HRESULT,Next)(THIS_ ULONG cFilters, IBaseFilter** ppFilter, ULONG* pcFetched) PURE; \
+ STDMETHOD_(HRESULT,Skip)(THIS_ ULONG cFilters) PURE; \
+ STDMETHOD_(HRESULT,Reset)(THIS) PURE; \
+ STDMETHOD_(HRESULT,Clone)(THIS_ IEnumFilters** ppEnum) PURE;
+
+HRESULT CALLBACK IEnumFilters_Next_Proxy(
+ IEnumFilters* This,
+ ULONG cFilters,
+ IBaseFilter** ppFilter,
+ ULONG* pcFetched);
+void __RPC_STUB IEnumFilters_Next_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumFilters_Skip_Proxy(
+ IEnumFilters* This,
+ ULONG cFilters);
+void __RPC_STUB IEnumFilters_Skip_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumFilters_Reset_Proxy(
+ IEnumFilters* This);
+void __RPC_STUB IEnumFilters_Reset_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumFilters_Clone_Proxy(
+ IEnumFilters* This,
+ IEnumFilters** ppEnum);
+void __RPC_STUB IEnumFilters_Clone_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+typedef IEnumFilters *PENUMFILTERS;
+
+typedef enum _FilterState {
+ State_Stopped,
+ State_Paused,
+ State_Running
+} FILTER_STATE;
+
+/*****************************************************************************
+ * IMediaFilter interface
+ */
+DEFINE_GUID(IID_IMediaFilter, 0x56a86899, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IMediaFilter : public IPersist
+{
+ virtual HRESULT STDMETHODCALLTYPE Stop(
+ ) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE Pause(
+ ) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE Run(
+ REFERENCE_TIME tStart) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetState(
+ DWORD dwMilliSecsTimeout,
+ FILTER_STATE* State) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE SetSyncSource(
+ IReferenceClock* pClock) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetSyncSource(
+ IReferenceClock** pClock) = 0;
+
+};
+#else
+typedef struct IMediaFilterVtbl IMediaFilterVtbl;
+struct IMediaFilter {
+ const IMediaFilterVtbl* lpVtbl;
+};
+struct IMediaFilterVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IMediaFilter* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IMediaFilter* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IMediaFilter* This);
+
+ /*** IPersist methods ***/
+ HRESULT (STDMETHODCALLTYPE *GetClassID)(
+ IMediaFilter* This,
+ CLSID* pClassID);
+
+ /*** IMediaFilter methods ***/
+ HRESULT (STDMETHODCALLTYPE *Stop)(
+ IMediaFilter* This);
+
+ HRESULT (STDMETHODCALLTYPE *Pause)(
+ IMediaFilter* This);
+
+ HRESULT (STDMETHODCALLTYPE *Run)(
+ IMediaFilter* This,
+ REFERENCE_TIME tStart);
+
+ HRESULT (STDMETHODCALLTYPE *GetState)(
+ IMediaFilter* This,
+ DWORD dwMilliSecsTimeout,
+ FILTER_STATE* State);
+
+ HRESULT (STDMETHODCALLTYPE *SetSyncSource)(
+ IMediaFilter* This,
+ IReferenceClock* pClock);
+
+ HRESULT (STDMETHODCALLTYPE *GetSyncSource)(
+ IMediaFilter* This,
+ IReferenceClock** pClock);
+
+};
+
+/*** IUnknown methods ***/
+#define IMediaFilter_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IMediaFilter_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IMediaFilter_Release(p) (p)->lpVtbl->Release(p)
+/*** IPersist methods ***/
+#define IMediaFilter_GetClassID(p,a) (p)->lpVtbl->GetClassID(p,a)
+/*** IMediaFilter methods ***/
+#define IMediaFilter_Stop(p) (p)->lpVtbl->Stop(p)
+#define IMediaFilter_Pause(p) (p)->lpVtbl->Pause(p)
+#define IMediaFilter_Run(p,a) (p)->lpVtbl->Run(p,a)
+#define IMediaFilter_GetState(p,a,b) (p)->lpVtbl->GetState(p,a,b)
+#define IMediaFilter_SetSyncSource(p,a) (p)->lpVtbl->SetSyncSource(p,a)
+#define IMediaFilter_GetSyncSource(p,a) (p)->lpVtbl->GetSyncSource(p,a)
+
+#endif
+
+#define IMediaFilter_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; \
+ /*** IPersist methods ***/ \
+ STDMETHOD_(HRESULT,GetClassID)(THIS_ CLSID* pClassID) PURE; \
+ /*** IMediaFilter methods ***/ \
+ STDMETHOD_(HRESULT,Stop)(THIS) PURE; \
+ STDMETHOD_(HRESULT,Pause)(THIS) PURE; \
+ STDMETHOD_(HRESULT,Run)(THIS_ REFERENCE_TIME tStart) PURE; \
+ STDMETHOD_(HRESULT,GetState)(THIS_ DWORD dwMilliSecsTimeout, FILTER_STATE* State) PURE; \
+ STDMETHOD_(HRESULT,SetSyncSource)(THIS_ IReferenceClock* pClock) PURE; \
+ STDMETHOD_(HRESULT,GetSyncSource)(THIS_ IReferenceClock** pClock) PURE;
+
+HRESULT CALLBACK IMediaFilter_Stop_Proxy(
+ IMediaFilter* This);
+void __RPC_STUB IMediaFilter_Stop_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMediaFilter_Pause_Proxy(
+ IMediaFilter* This);
+void __RPC_STUB IMediaFilter_Pause_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMediaFilter_Run_Proxy(
+ IMediaFilter* This,
+ REFERENCE_TIME tStart);
+void __RPC_STUB IMediaFilter_Run_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMediaFilter_GetState_Proxy(
+ IMediaFilter* This,
+ DWORD dwMilliSecsTimeout,
+ FILTER_STATE* State);
+void __RPC_STUB IMediaFilter_GetState_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMediaFilter_SetSyncSource_Proxy(
+ IMediaFilter* This,
+ IReferenceClock* pClock);
+void __RPC_STUB IMediaFilter_SetSyncSource_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMediaFilter_GetSyncSource_Proxy(
+ IMediaFilter* This,
+ IReferenceClock** pClock);
+void __RPC_STUB IMediaFilter_GetSyncSource_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+typedef IMediaFilter *PMEDIAFILTER;
+
+typedef struct _FilterInfo {
+ WCHAR achName[128];
+ IFilterGraph *pGraph;
+} FILTER_INFO;
+
+/*****************************************************************************
+ * IBaseFilter interface
+ */
+DEFINE_GUID(IID_IBaseFilter, 0x56a86895, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IBaseFilter : public IMediaFilter
+{
+ virtual HRESULT STDMETHODCALLTYPE EnumPins(
+ IEnumPins** ppEnum) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE FindPin(
+ LPCWSTR Id,
+ IPin** ppPin) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE QueryFilterInfo(
+ FILTER_INFO* pInfo) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE JoinFilterGraph(
+ IFilterGraph* pGraph,
+ LPCWSTR pName) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE QueryVendorInfo(
+ LPWSTR* pVendorInfo) = 0;
+
+};
+#else
+typedef struct IBaseFilterVtbl IBaseFilterVtbl;
+struct IBaseFilter {
+ const IBaseFilterVtbl* lpVtbl;
+};
+struct IBaseFilterVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IBaseFilter* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IBaseFilter* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IBaseFilter* This);
+
+ /*** IPersist methods ***/
+ HRESULT (STDMETHODCALLTYPE *GetClassID)(
+ IBaseFilter* This,
+ CLSID* pClassID);
+
+ /*** IMediaFilter methods ***/
+ HRESULT (STDMETHODCALLTYPE *Stop)(
+ IBaseFilter* This);
+
+ HRESULT (STDMETHODCALLTYPE *Pause)(
+ IBaseFilter* This);
+
+ HRESULT (STDMETHODCALLTYPE *Run)(
+ IBaseFilter* This,
+ REFERENCE_TIME tStart);
+
+ HRESULT (STDMETHODCALLTYPE *GetState)(
+ IBaseFilter* This,
+ DWORD dwMilliSecsTimeout,
+ FILTER_STATE* State);
+
+ HRESULT (STDMETHODCALLTYPE *SetSyncSource)(
+ IBaseFilter* This,
+ IReferenceClock* pClock);
+
+ HRESULT (STDMETHODCALLTYPE *GetSyncSource)(
+ IBaseFilter* This,
+ IReferenceClock** pClock);
+
+ /*** IBaseFilter methods ***/
+ HRESULT (STDMETHODCALLTYPE *EnumPins)(
+ IBaseFilter* This,
+ IEnumPins** ppEnum);
+
+ HRESULT (STDMETHODCALLTYPE *FindPin)(
+ IBaseFilter* This,
+ LPCWSTR Id,
+ IPin** ppPin);
+
+ HRESULT (STDMETHODCALLTYPE *QueryFilterInfo)(
+ IBaseFilter* This,
+ FILTER_INFO* pInfo);
+
+ HRESULT (STDMETHODCALLTYPE *JoinFilterGraph)(
+ IBaseFilter* This,
+ IFilterGraph* pGraph,
+ LPCWSTR pName);
+
+ HRESULT (STDMETHODCALLTYPE *QueryVendorInfo)(
+ IBaseFilter* This,
+ LPWSTR* pVendorInfo);
+
+};
+
+/*** IUnknown methods ***/
+#define IBaseFilter_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IBaseFilter_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IBaseFilter_Release(p) (p)->lpVtbl->Release(p)
+/*** IPersist methods ***/
+#define IBaseFilter_GetClassID(p,a) (p)->lpVtbl->GetClassID(p,a)
+/*** IMediaFilter methods ***/
+#define IBaseFilter_Stop(p) (p)->lpVtbl->Stop(p)
+#define IBaseFilter_Pause(p) (p)->lpVtbl->Pause(p)
+#define IBaseFilter_Run(p,a) (p)->lpVtbl->Run(p,a)
+#define IBaseFilter_GetState(p,a,b) (p)->lpVtbl->GetState(p,a,b)
+#define IBaseFilter_SetSyncSource(p,a) (p)->lpVtbl->SetSyncSource(p,a)
+#define IBaseFilter_GetSyncSource(p,a) (p)->lpVtbl->GetSyncSource(p,a)
+/*** IBaseFilter methods ***/
+#define IBaseFilter_EnumPins(p,a) (p)->lpVtbl->EnumPins(p,a)
+#define IBaseFilter_FindPin(p,a,b) (p)->lpVtbl->FindPin(p,a,b)
+#define IBaseFilter_QueryFilterInfo(p,a) (p)->lpVtbl->QueryFilterInfo(p,a)
+#define IBaseFilter_JoinFilterGraph(p,a,b) (p)->lpVtbl->JoinFilterGraph(p,a,b)
+#define IBaseFilter_QueryVendorInfo(p,a) (p)->lpVtbl->QueryVendorInfo(p,a)
+
+#endif
+
+#define IBaseFilter_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; \
+ /*** IPersist methods ***/ \
+ STDMETHOD_(HRESULT,GetClassID)(THIS_ CLSID* pClassID) PURE; \
+ /*** IMediaFilter methods ***/ \
+ STDMETHOD_(HRESULT,Stop)(THIS) PURE; \
+ STDMETHOD_(HRESULT,Pause)(THIS) PURE; \
+ STDMETHOD_(HRESULT,Run)(THIS_ REFERENCE_TIME tStart) PURE; \
+ STDMETHOD_(HRESULT,GetState)(THIS_ DWORD dwMilliSecsTimeout, FILTER_STATE* State) PURE; \
+ STDMETHOD_(HRESULT,SetSyncSource)(THIS_ IReferenceClock* pClock) PURE; \
+ STDMETHOD_(HRESULT,GetSyncSource)(THIS_ IReferenceClock** pClock) PURE; \
+ /*** IBaseFilter methods ***/ \
+ STDMETHOD_(HRESULT,EnumPins)(THIS_ IEnumPins** ppEnum) PURE; \
+ STDMETHOD_(HRESULT,FindPin)(THIS_ LPCWSTR Id, IPin** ppPin) PURE; \
+ STDMETHOD_(HRESULT,QueryFilterInfo)(THIS_ FILTER_INFO* pInfo) PURE; \
+ STDMETHOD_(HRESULT,JoinFilterGraph)(THIS_ IFilterGraph* pGraph, LPCWSTR pName) PURE; \
+ STDMETHOD_(HRESULT,QueryVendorInfo)(THIS_ LPWSTR* pVendorInfo) PURE;
+
+HRESULT CALLBACK IBaseFilter_EnumPins_Proxy(
+ IBaseFilter* This,
+ IEnumPins** ppEnum);
+void __RPC_STUB IBaseFilter_EnumPins_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IBaseFilter_FindPin_Proxy(
+ IBaseFilter* This,
+ LPCWSTR Id,
+ IPin** ppPin);
+void __RPC_STUB IBaseFilter_FindPin_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IBaseFilter_QueryFilterInfo_Proxy(
+ IBaseFilter* This,
+ FILTER_INFO* pInfo);
+void __RPC_STUB IBaseFilter_QueryFilterInfo_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IBaseFilter_JoinFilterGraph_Proxy(
+ IBaseFilter* This,
+ IFilterGraph* pGraph,
+ LPCWSTR pName);
+void __RPC_STUB IBaseFilter_JoinFilterGraph_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IBaseFilter_QueryVendorInfo_Proxy(
+ IBaseFilter* This,
+ LPWSTR* pVendorInfo);
+void __RPC_STUB IBaseFilter_QueryVendorInfo_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+typedef IBaseFilter *PFILTER;
+
+/*****************************************************************************
+ * IReferenceClock interface
+ */
+DEFINE_GUID(IID_IReferenceClock, 0x56a86897, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IReferenceClock : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE GetTime(
+ REFERENCE_TIME* pTime) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE AdviseTime(
+ REFERENCE_TIME baseTime,
+ REFERENCE_TIME streamTime,
+ HEVENT hEvent,
+ DWORD_PTR* pdwAdviseCookie) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE AdvisePeriodic(
+ REFERENCE_TIME startTime,
+ REFERENCE_TIME periodTime,
+ HSEMAPHORE hSemaphore,
+ DWORD_PTR* pdwAdviseCookie) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE Unadvise(
+ DWORD_PTR dwAdviseCookie) = 0;
+
+};
+#else
+typedef struct IReferenceClockVtbl IReferenceClockVtbl;
+struct IReferenceClock {
+ const IReferenceClockVtbl* lpVtbl;
+};
+struct IReferenceClockVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IReferenceClock* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IReferenceClock* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IReferenceClock* This);
+
+ /*** IReferenceClock methods ***/
+ HRESULT (STDMETHODCALLTYPE *GetTime)(
+ IReferenceClock* This,
+ REFERENCE_TIME* pTime);
+
+ HRESULT (STDMETHODCALLTYPE *AdviseTime)(
+ IReferenceClock* This,
+ REFERENCE_TIME baseTime,
+ REFERENCE_TIME streamTime,
+ HEVENT hEvent,
+ DWORD_PTR* pdwAdviseCookie);
+
+ HRESULT (STDMETHODCALLTYPE *AdvisePeriodic)(
+ IReferenceClock* This,
+ REFERENCE_TIME startTime,
+ REFERENCE_TIME periodTime,
+ HSEMAPHORE hSemaphore,
+ DWORD_PTR* pdwAdviseCookie);
+
+ HRESULT (STDMETHODCALLTYPE *Unadvise)(
+ IReferenceClock* This,
+ DWORD_PTR dwAdviseCookie);
+
+};
+
+/*** IUnknown methods ***/
+#define IReferenceClock_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IReferenceClock_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IReferenceClock_Release(p) (p)->lpVtbl->Release(p)
+/*** IReferenceClock methods ***/
+#define IReferenceClock_GetTime(p,a) (p)->lpVtbl->GetTime(p,a)
+#define IReferenceClock_AdviseTime(p,a,b,c,d) (p)->lpVtbl->AdviseTime(p,a,b,c,d)
+#define IReferenceClock_AdvisePeriodic(p,a,b,c,d) (p)->lpVtbl->AdvisePeriodic(p,a,b,c,d)
+#define IReferenceClock_Unadvise(p,a) (p)->lpVtbl->Unadvise(p,a)
+
+#endif
+
+#define IReferenceClock_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; \
+ /*** IReferenceClock methods ***/ \
+ STDMETHOD_(HRESULT,GetTime)(THIS_ REFERENCE_TIME* pTime) PURE; \
+ STDMETHOD_(HRESULT,AdviseTime)(THIS_ REFERENCE_TIME baseTime, REFERENCE_TIME streamTime, HEVENT hEvent, DWORD_PTR* pdwAdviseCookie) PURE; \
+ STDMETHOD_(HRESULT,AdvisePeriodic)(THIS_ REFERENCE_TIME startTime, REFERENCE_TIME periodTime, HSEMAPHORE hSemaphore, DWORD_PTR* pdwAdviseCookie) PURE; \
+ STDMETHOD_(HRESULT,Unadvise)(THIS_ DWORD_PTR dwAdviseCookie) PURE;
+
+HRESULT CALLBACK IReferenceClock_GetTime_Proxy(
+ IReferenceClock* This,
+ REFERENCE_TIME* pTime);
+void __RPC_STUB IReferenceClock_GetTime_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IReferenceClock_AdviseTime_Proxy(
+ IReferenceClock* This,
+ REFERENCE_TIME baseTime,
+ REFERENCE_TIME streamTime,
+ HEVENT hEvent,
+ DWORD_PTR* pdwAdviseCookie);
+void __RPC_STUB IReferenceClock_AdviseTime_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IReferenceClock_AdvisePeriodic_Proxy(
+ IReferenceClock* This,
+ REFERENCE_TIME startTime,
+ REFERENCE_TIME periodTime,
+ HSEMAPHORE hSemaphore,
+ DWORD_PTR* pdwAdviseCookie);
+void __RPC_STUB IReferenceClock_AdvisePeriodic_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IReferenceClock_Unadvise_Proxy(
+ IReferenceClock* This,
+ DWORD_PTR dwAdviseCookie);
+void __RPC_STUB IReferenceClock_Unadvise_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+typedef IReferenceClock *PREFERENCECLOCK;
+
+/*****************************************************************************
+ * IMediaSample interface
+ */
+DEFINE_GUID(IID_IMediaSample, 0x56a8689a, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IMediaSample : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE GetPointer(
+ BYTE** ppBuffer) = 0;
+
+ virtual long STDMETHODCALLTYPE GetSize(
+ ) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetTime(
+ REFERENCE_TIME* pTimeStart,
+ REFERENCE_TIME* pTimeEnd) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE SetTime(
+ REFERENCE_TIME* pTimeStart,
+ REFERENCE_TIME* pTimeEnd) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE IsSyncPoint(
+ ) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE SetSyncPoint(
+ BOOL bIsSyncPoint) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE IsPreroll(
+ ) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE SetPreroll(
+ BOOL bIsPreroll) = 0;
+
+ virtual long STDMETHODCALLTYPE GetActualDataLength(
+ ) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE SetActualDataLength(
+ long length) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetMediaType(
+ AM_MEDIA_TYPE** ppMediaType) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE SetMediaType(
+ AM_MEDIA_TYPE* pMediaType) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE IsDiscontinuity(
+ ) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE SetDiscontinuity(
+ BOOL bDiscontinuity) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetMediaTime(
+ LONGLONG* pTimeStart,
+ LONGLONG* pTimeEnd) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE SetMediaTime(
+ LONGLONG* pTimeStart,
+ LONGLONG* pTimeEnd) = 0;
+
+};
+#else
+typedef struct IMediaSampleVtbl IMediaSampleVtbl;
+struct IMediaSample {
+ const IMediaSampleVtbl* lpVtbl;
+};
+struct IMediaSampleVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IMediaSample* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IMediaSample* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IMediaSample* This);
+
+ /*** IMediaSample methods ***/
+ HRESULT (STDMETHODCALLTYPE *GetPointer)(
+ IMediaSample* This,
+ BYTE** ppBuffer);
+
+ long (STDMETHODCALLTYPE *GetSize)(
+ IMediaSample* This);
+
+ HRESULT (STDMETHODCALLTYPE *GetTime)(
+ IMediaSample* This,
+ REFERENCE_TIME* pTimeStart,
+ REFERENCE_TIME* pTimeEnd);
+
+ HRESULT (STDMETHODCALLTYPE *SetTime)(
+ IMediaSample* This,
+ REFERENCE_TIME* pTimeStart,
+ REFERENCE_TIME* pTimeEnd);
+
+ HRESULT (STDMETHODCALLTYPE *IsSyncPoint)(
+ IMediaSample* This);
+
+ HRESULT (STDMETHODCALLTYPE *SetSyncPoint)(
+ IMediaSample* This,
+ BOOL bIsSyncPoint);
+
+ HRESULT (STDMETHODCALLTYPE *IsPreroll)(
+ IMediaSample* This);
+
+ HRESULT (STDMETHODCALLTYPE *SetPreroll)(
+ IMediaSample* This,
+ BOOL bIsPreroll);
+
+ long (STDMETHODCALLTYPE *GetActualDataLength)(
+ IMediaSample* This);
+
+ HRESULT (STDMETHODCALLTYPE *SetActualDataLength)(
+ IMediaSample* This,
+ long length);
+
+ HRESULT (STDMETHODCALLTYPE *GetMediaType)(
+ IMediaSample* This,
+ AM_MEDIA_TYPE** ppMediaType);
+
+ HRESULT (STDMETHODCALLTYPE *SetMediaType)(
+ IMediaSample* This,
+ AM_MEDIA_TYPE* pMediaType);
+
+ HRESULT (STDMETHODCALLTYPE *IsDiscontinuity)(
+ IMediaSample* This);
+
+ HRESULT (STDMETHODCALLTYPE *SetDiscontinuity)(
+ IMediaSample* This,
+ BOOL bDiscontinuity);
+
+ HRESULT (STDMETHODCALLTYPE *GetMediaTime)(
+ IMediaSample* This,
+ LONGLONG* pTimeStart,
+ LONGLONG* pTimeEnd);
+
+ HRESULT (STDMETHODCALLTYPE *SetMediaTime)(
+ IMediaSample* This,
+ LONGLONG* pTimeStart,
+ LONGLONG* pTimeEnd);
+
+};
+
+/*** IUnknown methods ***/
+#define IMediaSample_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IMediaSample_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IMediaSample_Release(p) (p)->lpVtbl->Release(p)
+/*** IMediaSample methods ***/
+#define IMediaSample_GetPointer(p,a) (p)->lpVtbl->GetPointer(p,a)
+#define IMediaSample_GetSize(p) (p)->lpVtbl->GetSize(p)
+#define IMediaSample_GetTime(p,a,b) (p)->lpVtbl->GetTime(p,a,b)
+#define IMediaSample_SetTime(p,a,b) (p)->lpVtbl->SetTime(p,a,b)
+#define IMediaSample_IsSyncPoint(p) (p)->lpVtbl->IsSyncPoint(p)
+#define IMediaSample_SetSyncPoint(p,a) (p)->lpVtbl->SetSyncPoint(p,a)
+#define IMediaSample_IsPreroll(p) (p)->lpVtbl->IsPreroll(p)
+#define IMediaSample_SetPreroll(p,a) (p)->lpVtbl->SetPreroll(p,a)
+#define IMediaSample_GetActualDataLength(p) (p)->lpVtbl->GetActualDataLength(p)
+#define IMediaSample_SetActualDataLength(p,a) (p)->lpVtbl->SetActualDataLength(p,a)
+#define IMediaSample_GetMediaType(p,a) (p)->lpVtbl->GetMediaType(p,a)
+#define IMediaSample_SetMediaType(p,a) (p)->lpVtbl->SetMediaType(p,a)
+#define IMediaSample_IsDiscontinuity(p) (p)->lpVtbl->IsDiscontinuity(p)
+#define IMediaSample_SetDiscontinuity(p,a) (p)->lpVtbl->SetDiscontinuity(p,a)
+#define IMediaSample_GetMediaTime(p,a,b) (p)->lpVtbl->GetMediaTime(p,a,b)
+#define IMediaSample_SetMediaTime(p,a,b) (p)->lpVtbl->SetMediaTime(p,a,b)
+
+#endif
+
+#define IMediaSample_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; \
+ /*** IMediaSample methods ***/ \
+ STDMETHOD_(HRESULT,GetPointer)(THIS_ BYTE** ppBuffer) PURE; \
+ STDMETHOD_(long,GetSize)(THIS) PURE; \
+ STDMETHOD_(HRESULT,GetTime)(THIS_ REFERENCE_TIME* pTimeStart, REFERENCE_TIME* pTimeEnd) PURE; \
+ STDMETHOD_(HRESULT,SetTime)(THIS_ REFERENCE_TIME* pTimeStart, REFERENCE_TIME* pTimeEnd) PURE; \
+ STDMETHOD_(HRESULT,IsSyncPoint)(THIS) PURE; \
+ STDMETHOD_(HRESULT,SetSyncPoint)(THIS_ BOOL bIsSyncPoint) PURE; \
+ STDMETHOD_(HRESULT,IsPreroll)(THIS) PURE; \
+ STDMETHOD_(HRESULT,SetPreroll)(THIS_ BOOL bIsPreroll) PURE; \
+ STDMETHOD_(long,GetActualDataLength)(THIS) PURE; \
+ STDMETHOD_(HRESULT,SetActualDataLength)(THIS_ long length) PURE; \
+ STDMETHOD_(HRESULT,GetMediaType)(THIS_ AM_MEDIA_TYPE** ppMediaType) PURE; \
+ STDMETHOD_(HRESULT,SetMediaType)(THIS_ AM_MEDIA_TYPE* pMediaType) PURE; \
+ STDMETHOD_(HRESULT,IsDiscontinuity)(THIS) PURE; \
+ STDMETHOD_(HRESULT,SetDiscontinuity)(THIS_ BOOL bDiscontinuity) PURE; \
+ STDMETHOD_(HRESULT,GetMediaTime)(THIS_ LONGLONG* pTimeStart, LONGLONG* pTimeEnd) PURE; \
+ STDMETHOD_(HRESULT,SetMediaTime)(THIS_ LONGLONG* pTimeStart, LONGLONG* pTimeEnd) PURE;
+
+HRESULT CALLBACK IMediaSample_GetPointer_Proxy(
+ IMediaSample* This,
+ BYTE** ppBuffer);
+void __RPC_STUB IMediaSample_GetPointer_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+long CALLBACK IMediaSample_GetSize_Proxy(
+ IMediaSample* This);
+void __RPC_STUB IMediaSample_GetSize_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMediaSample_GetTime_Proxy(
+ IMediaSample* This,
+ REFERENCE_TIME* pTimeStart,
+ REFERENCE_TIME* pTimeEnd);
+void __RPC_STUB IMediaSample_GetTime_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMediaSample_SetTime_Proxy(
+ IMediaSample* This,
+ REFERENCE_TIME* pTimeStart,
+ REFERENCE_TIME* pTimeEnd);
+void __RPC_STUB IMediaSample_SetTime_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMediaSample_IsSyncPoint_Proxy(
+ IMediaSample* This);
+void __RPC_STUB IMediaSample_IsSyncPoint_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMediaSample_SetSyncPoint_Proxy(
+ IMediaSample* This,
+ BOOL bIsSyncPoint);
+void __RPC_STUB IMediaSample_SetSyncPoint_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMediaSample_IsPreroll_Proxy(
+ IMediaSample* This);
+void __RPC_STUB IMediaSample_IsPreroll_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMediaSample_SetPreroll_Proxy(
+ IMediaSample* This,
+ BOOL bIsPreroll);
+void __RPC_STUB IMediaSample_SetPreroll_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+long CALLBACK IMediaSample_GetActualDataLength_Proxy(
+ IMediaSample* This);
+void __RPC_STUB IMediaSample_GetActualDataLength_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMediaSample_SetActualDataLength_Proxy(
+ IMediaSample* This,
+ long length);
+void __RPC_STUB IMediaSample_SetActualDataLength_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMediaSample_GetMediaType_Proxy(
+ IMediaSample* This,
+ AM_MEDIA_TYPE** ppMediaType);
+void __RPC_STUB IMediaSample_GetMediaType_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMediaSample_SetMediaType_Proxy(
+ IMediaSample* This,
+ AM_MEDIA_TYPE* pMediaType);
+void __RPC_STUB IMediaSample_SetMediaType_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMediaSample_IsDiscontinuity_Proxy(
+ IMediaSample* This);
+void __RPC_STUB IMediaSample_IsDiscontinuity_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMediaSample_SetDiscontinuity_Proxy(
+ IMediaSample* This,
+ BOOL bDiscontinuity);
+void __RPC_STUB IMediaSample_SetDiscontinuity_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMediaSample_GetMediaTime_Proxy(
+ IMediaSample* This,
+ LONGLONG* pTimeStart,
+ LONGLONG* pTimeEnd);
+void __RPC_STUB IMediaSample_GetMediaTime_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMediaSample_SetMediaTime_Proxy(
+ IMediaSample* This,
+ LONGLONG* pTimeStart,
+ LONGLONG* pTimeEnd);
+void __RPC_STUB IMediaSample_SetMediaTime_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+typedef IMediaSample *PMEDIASAMPLE;
+
+enum tagAM_SAMPLE_PROPERTY_FLAGS {
+ AM_SAMPLE_SPLICEPOINT = 0x1,
+ AM_SAMPLE_PREROLL = 0x2,
+ AM_SAMPLE_DATADISCONTINUITY = 0x4,
+ AM_SAMPLE_TYPECHANGED = 0x8,
+ AM_SAMPLE_TIMEVALID = 0x10,
+ AM_SAMPLE_TIMEDISCONTINUITY = 0x40,
+ AM_SAMPLE_FLUSH_ON_PAUSE = 0x80,
+ AM_SAMPLE_STOPVALID = 0x100,
+ AM_SAMPLE_ENDOFSTREAM = 0x200,
+ AM_STREAM_MEDIA = 0,
+ AM_STREAM_CONTROL = 1
+};
+
+typedef struct tagAM_SAMPLE2_PROPERTIES {
+ DWORD cbData;
+ DWORD dwTypeSpecificFlags;
+ DWORD dwSampleFlags;
+ LONG lActual;
+ REFERENCE_TIME tStart;
+ REFERENCE_TIME tStop;
+ DWORD dwStreamId;
+ AM_MEDIA_TYPE *pMediaType;
+ BYTE *pbBuffer;
+ LONG cbBuffer;
+} AM_SAMPLE2_PROPERTIES;
+
+typedef struct IMediaSample2 IMediaSample2;
+/*****************************************************************************
+ * IMediaSample2 interface
+ */
+DEFINE_GUID(IID_IMediaSample2, 0x36b73884, 0xc2c8, 0x11cf, 0x8b,0x46, 0x00,0x80,0x5f,0x6c,0xef,0x60);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IMediaSample2 : public IMediaSample
+{
+ virtual HRESULT STDMETHODCALLTYPE GetProperties(
+ DWORD cbProperties,
+ BYTE* pbProperties) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE SetProperties(
+ DWORD cbProperties,
+ const BYTE* pbProperties) = 0;
+
+};
+#else
+typedef struct IMediaSample2Vtbl IMediaSample2Vtbl;
+struct IMediaSample2 {
+ const IMediaSample2Vtbl* lpVtbl;
+};
+struct IMediaSample2Vtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IMediaSample2* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IMediaSample2* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IMediaSample2* This);
+
+ /*** IMediaSample methods ***/
+ HRESULT (STDMETHODCALLTYPE *GetPointer)(
+ IMediaSample2* This,
+ BYTE** ppBuffer);
+
+ long (STDMETHODCALLTYPE *GetSize)(
+ IMediaSample2* This);
+
+ HRESULT (STDMETHODCALLTYPE *GetTime)(
+ IMediaSample2* This,
+ REFERENCE_TIME* pTimeStart,
+ REFERENCE_TIME* pTimeEnd);
+
+ HRESULT (STDMETHODCALLTYPE *SetTime)(
+ IMediaSample2* This,
+ REFERENCE_TIME* pTimeStart,
+ REFERENCE_TIME* pTimeEnd);
+
+ HRESULT (STDMETHODCALLTYPE *IsSyncPoint)(
+ IMediaSample2* This);
+
+ HRESULT (STDMETHODCALLTYPE *SetSyncPoint)(
+ IMediaSample2* This,
+ BOOL bIsSyncPoint);
+
+ HRESULT (STDMETHODCALLTYPE *IsPreroll)(
+ IMediaSample2* This);
+
+ HRESULT (STDMETHODCALLTYPE *SetPreroll)(
+ IMediaSample2* This,
+ BOOL bIsPreroll);
+
+ long (STDMETHODCALLTYPE *GetActualDataLength)(
+ IMediaSample2* This);
+
+ HRESULT (STDMETHODCALLTYPE *SetActualDataLength)(
+ IMediaSample2* This,
+ long length);
+
+ HRESULT (STDMETHODCALLTYPE *GetMediaType)(
+ IMediaSample2* This,
+ AM_MEDIA_TYPE** ppMediaType);
+
+ HRESULT (STDMETHODCALLTYPE *SetMediaType)(
+ IMediaSample2* This,
+ AM_MEDIA_TYPE* pMediaType);
+
+ HRESULT (STDMETHODCALLTYPE *IsDiscontinuity)(
+ IMediaSample2* This);
+
+ HRESULT (STDMETHODCALLTYPE *SetDiscontinuity)(
+ IMediaSample2* This,
+ BOOL bDiscontinuity);
+
+ HRESULT (STDMETHODCALLTYPE *GetMediaTime)(
+ IMediaSample2* This,
+ LONGLONG* pTimeStart,
+ LONGLONG* pTimeEnd);
+
+ HRESULT (STDMETHODCALLTYPE *SetMediaTime)(
+ IMediaSample2* This,
+ LONGLONG* pTimeStart,
+ LONGLONG* pTimeEnd);
+
+ /*** IMediaSample2 methods ***/
+ HRESULT (STDMETHODCALLTYPE *GetProperties)(
+ IMediaSample2* This,
+ DWORD cbProperties,
+ BYTE* pbProperties);
+
+ HRESULT (STDMETHODCALLTYPE *SetProperties)(
+ IMediaSample2* This,
+ DWORD cbProperties,
+ const BYTE* pbProperties);
+
+};
+
+/*** IUnknown methods ***/
+#define IMediaSample2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IMediaSample2_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IMediaSample2_Release(p) (p)->lpVtbl->Release(p)
+/*** IMediaSample methods ***/
+#define IMediaSample2_GetPointer(p,a) (p)->lpVtbl->GetPointer(p,a)
+#define IMediaSample2_GetSize(p) (p)->lpVtbl->GetSize(p)
+#define IMediaSample2_GetTime(p,a,b) (p)->lpVtbl->GetTime(p,a,b)
+#define IMediaSample2_SetTime(p,a,b) (p)->lpVtbl->SetTime(p,a,b)
+#define IMediaSample2_IsSyncPoint(p) (p)->lpVtbl->IsSyncPoint(p)
+#define IMediaSample2_SetSyncPoint(p,a) (p)->lpVtbl->SetSyncPoint(p,a)
+#define IMediaSample2_IsPreroll(p) (p)->lpVtbl->IsPreroll(p)
+#define IMediaSample2_SetPreroll(p,a) (p)->lpVtbl->SetPreroll(p,a)
+#define IMediaSample2_GetActualDataLength(p) (p)->lpVtbl->GetActualDataLength(p)
+#define IMediaSample2_SetActualDataLength(p,a) (p)->lpVtbl->SetActualDataLength(p,a)
+#define IMediaSample2_GetMediaType(p,a) (p)->lpVtbl->GetMediaType(p,a)
+#define IMediaSample2_SetMediaType(p,a) (p)->lpVtbl->SetMediaType(p,a)
+#define IMediaSample2_IsDiscontinuity(p) (p)->lpVtbl->IsDiscontinuity(p)
+#define IMediaSample2_SetDiscontinuity(p,a) (p)->lpVtbl->SetDiscontinuity(p,a)
+#define IMediaSample2_GetMediaTime(p,a,b) (p)->lpVtbl->GetMediaTime(p,a,b)
+#define IMediaSample2_SetMediaTime(p,a,b) (p)->lpVtbl->SetMediaTime(p,a,b)
+/*** IMediaSample2 methods ***/
+#define IMediaSample2_GetProperties(p,a,b) (p)->lpVtbl->GetProperties(p,a,b)
+#define IMediaSample2_SetProperties(p,a,b) (p)->lpVtbl->SetProperties(p,a,b)
+
+#endif
+
+#define IMediaSample2_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; \
+ /*** IMediaSample methods ***/ \
+ STDMETHOD_(HRESULT,GetPointer)(THIS_ BYTE** ppBuffer) PURE; \
+ STDMETHOD_(long,GetSize)(THIS) PURE; \
+ STDMETHOD_(HRESULT,GetTime)(THIS_ REFERENCE_TIME* pTimeStart, REFERENCE_TIME* pTimeEnd) PURE; \
+ STDMETHOD_(HRESULT,SetTime)(THIS_ REFERENCE_TIME* pTimeStart, REFERENCE_TIME* pTimeEnd) PURE; \
+ STDMETHOD_(HRESULT,IsSyncPoint)(THIS) PURE; \
+ STDMETHOD_(HRESULT,SetSyncPoint)(THIS_ BOOL bIsSyncPoint) PURE; \
+ STDMETHOD_(HRESULT,IsPreroll)(THIS) PURE; \
+ STDMETHOD_(HRESULT,SetPreroll)(THIS_ BOOL bIsPreroll) PURE; \
+ STDMETHOD_(long,GetActualDataLength)(THIS) PURE; \
+ STDMETHOD_(HRESULT,SetActualDataLength)(THIS_ long length) PURE; \
+ STDMETHOD_(HRESULT,GetMediaType)(THIS_ AM_MEDIA_TYPE** ppMediaType) PURE; \
+ STDMETHOD_(HRESULT,SetMediaType)(THIS_ AM_MEDIA_TYPE* pMediaType) PURE; \
+ STDMETHOD_(HRESULT,IsDiscontinuity)(THIS) PURE; \
+ STDMETHOD_(HRESULT,SetDiscontinuity)(THIS_ BOOL bDiscontinuity) PURE; \
+ STDMETHOD_(HRESULT,GetMediaTime)(THIS_ LONGLONG* pTimeStart, LONGLONG* pTimeEnd) PURE; \
+ STDMETHOD_(HRESULT,SetMediaTime)(THIS_ LONGLONG* pTimeStart, LONGLONG* pTimeEnd) PURE; \
+ /*** IMediaSample2 methods ***/ \
+ STDMETHOD_(HRESULT,GetProperties)(THIS_ DWORD cbProperties, BYTE* pbProperties) PURE; \
+ STDMETHOD_(HRESULT,SetProperties)(THIS_ DWORD cbProperties, const BYTE* pbProperties) PURE;
+
+HRESULT CALLBACK IMediaSample2_GetProperties_Proxy(
+ IMediaSample2* This,
+ DWORD cbProperties,
+ BYTE* pbProperties);
+void __RPC_STUB IMediaSample2_GetProperties_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMediaSample2_SetProperties_Proxy(
+ IMediaSample2* This,
+ DWORD cbProperties,
+ const BYTE* pbProperties);
+void __RPC_STUB IMediaSample2_SetProperties_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+typedef IMediaSample2 *PMEDIASAMPLE2;
+
+#define AM_GBF_PREVFRAMESKIPPED 1
+#define AM_GBF_NOTASYNCPOINT 2
+#define AM_GBF_NOWAIT 4
+/*****************************************************************************
+ * IMemAllocator interface
+ */
+DEFINE_GUID(IID_IMemAllocator, 0x56a8689c, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IMemAllocator : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE SetProperties(
+ ALLOCATOR_PROPERTIES* pRequest,
+ ALLOCATOR_PROPERTIES* pActual) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetProperties(
+ ALLOCATOR_PROPERTIES* pProps) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE Commit(
+ ) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE Decommit(
+ ) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetBuffer(
+ IMediaSample** ppBuffer,
+ REFERENCE_TIME* pStartTime,
+ REFERENCE_TIME* pEndTime,
+ DWORD dwFlags) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE ReleaseBuffer(
+ IMediaSample* pBuffer) = 0;
+
+};
+#else
+typedef struct IMemAllocatorVtbl IMemAllocatorVtbl;
+struct IMemAllocator {
+ const IMemAllocatorVtbl* lpVtbl;
+};
+struct IMemAllocatorVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IMemAllocator* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IMemAllocator* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IMemAllocator* This);
+
+ /*** IMemAllocator methods ***/
+ HRESULT (STDMETHODCALLTYPE *SetProperties)(
+ IMemAllocator* This,
+ ALLOCATOR_PROPERTIES* pRequest,
+ ALLOCATOR_PROPERTIES* pActual);
+
+ HRESULT (STDMETHODCALLTYPE *GetProperties)(
+ IMemAllocator* This,
+ ALLOCATOR_PROPERTIES* pProps);
+
+ HRESULT (STDMETHODCALLTYPE *Commit)(
+ IMemAllocator* This);
+
+ HRESULT (STDMETHODCALLTYPE *Decommit)(
+ IMemAllocator* This);
+
+ HRESULT (STDMETHODCALLTYPE *GetBuffer)(
+ IMemAllocator* This,
+ IMediaSample** ppBuffer,
+ REFERENCE_TIME* pStartTime,
+ REFERENCE_TIME* pEndTime,
+ DWORD dwFlags);
+
+ HRESULT (STDMETHODCALLTYPE *ReleaseBuffer)(
+ IMemAllocator* This,
+ IMediaSample* pBuffer);
+
+};
+
+/*** IUnknown methods ***/
+#define IMemAllocator_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IMemAllocator_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IMemAllocator_Release(p) (p)->lpVtbl->Release(p)
+/*** IMemAllocator methods ***/
+#define IMemAllocator_SetProperties(p,a,b) (p)->lpVtbl->SetProperties(p,a,b)
+#define IMemAllocator_GetProperties(p,a) (p)->lpVtbl->GetProperties(p,a)
+#define IMemAllocator_Commit(p) (p)->lpVtbl->Commit(p)
+#define IMemAllocator_Decommit(p) (p)->lpVtbl->Decommit(p)
+#define IMemAllocator_GetBuffer(p,a,b,c,d) (p)->lpVtbl->GetBuffer(p,a,b,c,d)
+#define IMemAllocator_ReleaseBuffer(p,a) (p)->lpVtbl->ReleaseBuffer(p,a)
+
+#endif
+
+#define IMemAllocator_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; \
+ /*** IMemAllocator methods ***/ \
+ STDMETHOD_(HRESULT,SetProperties)(THIS_ ALLOCATOR_PROPERTIES* pRequest, ALLOCATOR_PROPERTIES* pActual) PURE; \
+ STDMETHOD_(HRESULT,GetProperties)(THIS_ ALLOCATOR_PROPERTIES* pProps) PURE; \
+ STDMETHOD_(HRESULT,Commit)(THIS) PURE; \
+ STDMETHOD_(HRESULT,Decommit)(THIS) PURE; \
+ STDMETHOD_(HRESULT,GetBuffer)(THIS_ IMediaSample** ppBuffer, REFERENCE_TIME* pStartTime, REFERENCE_TIME* pEndTime, DWORD dwFlags) PURE; \
+ STDMETHOD_(HRESULT,ReleaseBuffer)(THIS_ IMediaSample* pBuffer) PURE;
+
+HRESULT CALLBACK IMemAllocator_SetProperties_Proxy(
+ IMemAllocator* This,
+ ALLOCATOR_PROPERTIES* pRequest,
+ ALLOCATOR_PROPERTIES* pActual);
+void __RPC_STUB IMemAllocator_SetProperties_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMemAllocator_GetProperties_Proxy(
+ IMemAllocator* This,
+ ALLOCATOR_PROPERTIES* pProps);
+void __RPC_STUB IMemAllocator_GetProperties_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMemAllocator_Commit_Proxy(
+ IMemAllocator* This);
+void __RPC_STUB IMemAllocator_Commit_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMemAllocator_Decommit_Proxy(
+ IMemAllocator* This);
+void __RPC_STUB IMemAllocator_Decommit_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMemAllocator_GetBuffer_Proxy(
+ IMemAllocator* This,
+ IMediaSample** ppBuffer,
+ REFERENCE_TIME* pStartTime,
+ REFERENCE_TIME* pEndTime,
+ DWORD dwFlags);
+void __RPC_STUB IMemAllocator_GetBuffer_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMemAllocator_ReleaseBuffer_Proxy(
+ IMemAllocator* This,
+ IMediaSample* pBuffer);
+void __RPC_STUB IMemAllocator_ReleaseBuffer_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+typedef IMemAllocator *PMEMALLOCATOR;
+
+/*****************************************************************************
+ * IMemAllocatorCallbackTemp interface
+ */
+DEFINE_GUID(IID_IMemAllocatorCallbackTemp, 0x379a0cf0, 0xc1de, 0x11d2, 0xab,0xf5, 0x00,0xa0,0xc9,0x05,0xf3,0x75);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IMemAllocatorCallbackTemp : public IMemAllocator
+{
+ virtual HRESULT STDMETHODCALLTYPE SetNotify(
+ IMemAllocatorNotifyCallbackTemp* pNotify) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetFreeCount(
+ LONG* plBuffersFree) = 0;
+
+};
+#else
+typedef struct IMemAllocatorCallbackTempVtbl IMemAllocatorCallbackTempVtbl;
+struct IMemAllocatorCallbackTemp {
+ const IMemAllocatorCallbackTempVtbl* lpVtbl;
+};
+struct IMemAllocatorCallbackTempVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IMemAllocatorCallbackTemp* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IMemAllocatorCallbackTemp* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IMemAllocatorCallbackTemp* This);
+
+ /*** IMemAllocator methods ***/
+ HRESULT (STDMETHODCALLTYPE *SetProperties)(
+ IMemAllocatorCallbackTemp* This,
+ ALLOCATOR_PROPERTIES* pRequest,
+ ALLOCATOR_PROPERTIES* pActual);
+
+ HRESULT (STDMETHODCALLTYPE *GetProperties)(
+ IMemAllocatorCallbackTemp* This,
+ ALLOCATOR_PROPERTIES* pProps);
+
+ HRESULT (STDMETHODCALLTYPE *Commit)(
+ IMemAllocatorCallbackTemp* This);
+
+ HRESULT (STDMETHODCALLTYPE *Decommit)(
+ IMemAllocatorCallbackTemp* This);
+
+ HRESULT (STDMETHODCALLTYPE *GetBuffer)(
+ IMemAllocatorCallbackTemp* This,
+ IMediaSample** ppBuffer,
+ REFERENCE_TIME* pStartTime,
+ REFERENCE_TIME* pEndTime,
+ DWORD dwFlags);
+
+ HRESULT (STDMETHODCALLTYPE *ReleaseBuffer)(
+ IMemAllocatorCallbackTemp* This,
+ IMediaSample* pBuffer);
+
+ /*** IMemAllocatorCallbackTemp methods ***/
+ HRESULT (STDMETHODCALLTYPE *SetNotify)(
+ IMemAllocatorCallbackTemp* This,
+ IMemAllocatorNotifyCallbackTemp* pNotify);
+
+ HRESULT (STDMETHODCALLTYPE *GetFreeCount)(
+ IMemAllocatorCallbackTemp* This,
+ LONG* plBuffersFree);
+
+};
+
+/*** IUnknown methods ***/
+#define IMemAllocatorCallbackTemp_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IMemAllocatorCallbackTemp_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IMemAllocatorCallbackTemp_Release(p) (p)->lpVtbl->Release(p)
+/*** IMemAllocator methods ***/
+#define IMemAllocatorCallbackTemp_SetProperties(p,a,b) (p)->lpVtbl->SetProperties(p,a,b)
+#define IMemAllocatorCallbackTemp_GetProperties(p,a) (p)->lpVtbl->GetProperties(p,a)
+#define IMemAllocatorCallbackTemp_Commit(p) (p)->lpVtbl->Commit(p)
+#define IMemAllocatorCallbackTemp_Decommit(p) (p)->lpVtbl->Decommit(p)
+#define IMemAllocatorCallbackTemp_GetBuffer(p,a,b,c,d) (p)->lpVtbl->GetBuffer(p,a,b,c,d)
+#define IMemAllocatorCallbackTemp_ReleaseBuffer(p,a) (p)->lpVtbl->ReleaseBuffer(p,a)
+/*** IMemAllocatorCallbackTemp methods ***/
+#define IMemAllocatorCallbackTemp_SetNotify(p,a) (p)->lpVtbl->SetNotify(p,a)
+#define IMemAllocatorCallbackTemp_GetFreeCount(p,a) (p)->lpVtbl->GetFreeCount(p,a)
+
+#endif
+
+#define IMemAllocatorCallbackTemp_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; \
+ /*** IMemAllocator methods ***/ \
+ STDMETHOD_(HRESULT,SetProperties)(THIS_ ALLOCATOR_PROPERTIES* pRequest, ALLOCATOR_PROPERTIES* pActual) PURE; \
+ STDMETHOD_(HRESULT,GetProperties)(THIS_ ALLOCATOR_PROPERTIES* pProps) PURE; \
+ STDMETHOD_(HRESULT,Commit)(THIS) PURE; \
+ STDMETHOD_(HRESULT,Decommit)(THIS) PURE; \
+ STDMETHOD_(HRESULT,GetBuffer)(THIS_ IMediaSample** ppBuffer, REFERENCE_TIME* pStartTime, REFERENCE_TIME* pEndTime, DWORD dwFlags) PURE; \
+ STDMETHOD_(HRESULT,ReleaseBuffer)(THIS_ IMediaSample* pBuffer) PURE; \
+ /*** IMemAllocatorCallbackTemp methods ***/ \
+ STDMETHOD_(HRESULT,SetNotify)(THIS_ IMemAllocatorNotifyCallbackTemp* pNotify) PURE; \
+ STDMETHOD_(HRESULT,GetFreeCount)(THIS_ LONG* plBuffersFree) PURE;
+
+HRESULT CALLBACK IMemAllocatorCallbackTemp_SetNotify_Proxy(
+ IMemAllocatorCallbackTemp* This,
+ IMemAllocatorNotifyCallbackTemp* pNotify);
+void __RPC_STUB IMemAllocatorCallbackTemp_SetNotify_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMemAllocatorCallbackTemp_GetFreeCount_Proxy(
+ IMemAllocatorCallbackTemp* This,
+ LONG* plBuffersFree);
+void __RPC_STUB IMemAllocatorCallbackTemp_GetFreeCount_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+/*****************************************************************************
+ * IMemAllocatorNotifyCallbackTemp interface
+ */
+DEFINE_GUID(IID_IMemAllocatorNotifyCallbackTemp, 0x92980b30, 0xc1de, 0x11d2, 0xab,0xf5, 0x00,0xa0,0xc9,0x05,0xf3,0x75);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IMemAllocatorNotifyCallbackTemp : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE NotifyRelease(
+ ) = 0;
+
+};
+#else
+typedef struct IMemAllocatorNotifyCallbackTempVtbl IMemAllocatorNotifyCallbackTempVtbl;
+struct IMemAllocatorNotifyCallbackTemp {
+ const IMemAllocatorNotifyCallbackTempVtbl* lpVtbl;
+};
+struct IMemAllocatorNotifyCallbackTempVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IMemAllocatorNotifyCallbackTemp* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IMemAllocatorNotifyCallbackTemp* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IMemAllocatorNotifyCallbackTemp* This);
+
+ /*** IMemAllocatorNotifyCallbackTemp methods ***/
+ HRESULT (STDMETHODCALLTYPE *NotifyRelease)(
+ IMemAllocatorNotifyCallbackTemp* This);
+
+};
+
+/*** IUnknown methods ***/
+#define IMemAllocatorNotifyCallbackTemp_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IMemAllocatorNotifyCallbackTemp_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IMemAllocatorNotifyCallbackTemp_Release(p) (p)->lpVtbl->Release(p)
+/*** IMemAllocatorNotifyCallbackTemp methods ***/
+#define IMemAllocatorNotifyCallbackTemp_NotifyRelease(p) (p)->lpVtbl->NotifyRelease(p)
+
+#endif
+
+#define IMemAllocatorNotifyCallbackTemp_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; \
+ /*** IMemAllocatorNotifyCallbackTemp methods ***/ \
+ STDMETHOD_(HRESULT,NotifyRelease)(THIS) PURE;
+
+HRESULT CALLBACK IMemAllocatorNotifyCallbackTemp_NotifyRelease_Proxy(
+ IMemAllocatorNotifyCallbackTemp* This);
+void __RPC_STUB IMemAllocatorNotifyCallbackTemp_NotifyRelease_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+/*****************************************************************************
+ * IMemInputPin interface
+ */
+DEFINE_GUID(IID_IMemInputPin, 0x56a8689d, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IMemInputPin : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE GetAllocator(
+ IMemAllocator** ppAllocator) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE NotifyAllocator(
+ IMemAllocator* pAllocator,
+ BOOL bReadOnly) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetAllocatorRequirements(
+ ALLOCATOR_PROPERTIES* pProps) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE Receive(
+ IMediaSample* pSample) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE ReceiveMultiple(
+ IMediaSample** pSamples,
+ long nSamples,
+ long* nSamplesProcessed) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE ReceiveCanBlock(
+ ) = 0;
+
+};
+#else
+typedef struct IMemInputPinVtbl IMemInputPinVtbl;
+struct IMemInputPin {
+ const IMemInputPinVtbl* lpVtbl;
+};
+struct IMemInputPinVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IMemInputPin* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IMemInputPin* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IMemInputPin* This);
+
+ /*** IMemInputPin methods ***/
+ HRESULT (STDMETHODCALLTYPE *GetAllocator)(
+ IMemInputPin* This,
+ IMemAllocator** ppAllocator);
+
+ HRESULT (STDMETHODCALLTYPE *NotifyAllocator)(
+ IMemInputPin* This,
+ IMemAllocator* pAllocator,
+ BOOL bReadOnly);
+
+ HRESULT (STDMETHODCALLTYPE *GetAllocatorRequirements)(
+ IMemInputPin* This,
+ ALLOCATOR_PROPERTIES* pProps);
+
+ HRESULT (STDMETHODCALLTYPE *Receive)(
+ IMemInputPin* This,
+ IMediaSample* pSample);
+
+ HRESULT (STDMETHODCALLTYPE *ReceiveMultiple)(
+ IMemInputPin* This,
+ IMediaSample** pSamples,
+ long nSamples,
+ long* nSamplesProcessed);
+
+ HRESULT (STDMETHODCALLTYPE *ReceiveCanBlock)(
+ IMemInputPin* This);
+
+};
+
+/*** IUnknown methods ***/
+#define IMemInputPin_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IMemInputPin_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IMemInputPin_Release(p) (p)->lpVtbl->Release(p)
+/*** IMemInputPin methods ***/
+#define IMemInputPin_GetAllocator(p,a) (p)->lpVtbl->GetAllocator(p,a)
+#define IMemInputPin_NotifyAllocator(p,a,b) (p)->lpVtbl->NotifyAllocator(p,a,b)
+#define IMemInputPin_GetAllocatorRequirements(p,a) (p)->lpVtbl->GetAllocatorRequirements(p,a)
+#define IMemInputPin_Receive(p,a) (p)->lpVtbl->Receive(p,a)
+#define IMemInputPin_ReceiveMultiple(p,a,b,c) (p)->lpVtbl->ReceiveMultiple(p,a,b,c)
+#define IMemInputPin_ReceiveCanBlock(p) (p)->lpVtbl->ReceiveCanBlock(p)
+
+#endif
+
+#define IMemInputPin_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; \
+ /*** IMemInputPin methods ***/ \
+ STDMETHOD_(HRESULT,GetAllocator)(THIS_ IMemAllocator** ppAllocator) PURE; \
+ STDMETHOD_(HRESULT,NotifyAllocator)(THIS_ IMemAllocator* pAllocator, BOOL bReadOnly) PURE; \
+ STDMETHOD_(HRESULT,GetAllocatorRequirements)(THIS_ ALLOCATOR_PROPERTIES* pProps) PURE; \
+ STDMETHOD_(HRESULT,Receive)(THIS_ IMediaSample* pSample) PURE; \
+ STDMETHOD_(HRESULT,ReceiveMultiple)(THIS_ IMediaSample** pSamples, long nSamples, long* nSamplesProcessed) PURE; \
+ STDMETHOD_(HRESULT,ReceiveCanBlock)(THIS) PURE;
+
+HRESULT CALLBACK IMemInputPin_GetAllocator_Proxy(
+ IMemInputPin* This,
+ IMemAllocator** ppAllocator);
+void __RPC_STUB IMemInputPin_GetAllocator_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMemInputPin_NotifyAllocator_Proxy(
+ IMemInputPin* This,
+ IMemAllocator* pAllocator,
+ BOOL bReadOnly);
+void __RPC_STUB IMemInputPin_NotifyAllocator_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMemInputPin_GetAllocatorRequirements_Proxy(
+ IMemInputPin* This,
+ ALLOCATOR_PROPERTIES* pProps);
+void __RPC_STUB IMemInputPin_GetAllocatorRequirements_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMemInputPin_Receive_Proxy(
+ IMemInputPin* This,
+ IMediaSample* pSample);
+void __RPC_STUB IMemInputPin_Receive_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMemInputPin_ReceiveMultiple_Proxy(
+ IMemInputPin* This,
+ IMediaSample** pSamples,
+ long nSamples,
+ long* nSamplesProcessed);
+void __RPC_STUB IMemInputPin_ReceiveMultiple_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMemInputPin_ReceiveCanBlock_Proxy(
+ IMemInputPin* This);
+void __RPC_STUB IMemInputPin_ReceiveCanBlock_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+typedef IMemInputPin *PMEMINPUTPIN;
+
+/*****************************************************************************
+ * IAMovieSetup interface
+ */
+DEFINE_GUID(IID_IAMovieSetup, 0xa3d8cec0, 0x7e5a, 0x11cf, 0xbb,0xc5, 0x00,0x80,0x5f,0x6c,0xef,0x20);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IAMovieSetup : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE Register(
+ ) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE Unregister(
+ ) = 0;
+
+};
+#else
+typedef struct IAMovieSetupVtbl IAMovieSetupVtbl;
+struct IAMovieSetup {
+ const IAMovieSetupVtbl* lpVtbl;
+};
+struct IAMovieSetupVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IAMovieSetup* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IAMovieSetup* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IAMovieSetup* This);
+
+ /*** IAMovieSetup methods ***/
+ HRESULT (STDMETHODCALLTYPE *Register)(
+ IAMovieSetup* This);
+
+ HRESULT (STDMETHODCALLTYPE *Unregister)(
+ IAMovieSetup* This);
+
+};
+
+/*** IUnknown methods ***/
+#define IAMovieSetup_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IAMovieSetup_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IAMovieSetup_Release(p) (p)->lpVtbl->Release(p)
+/*** IAMovieSetup methods ***/
+#define IAMovieSetup_Register(p) (p)->lpVtbl->Register(p)
+#define IAMovieSetup_Unregister(p) (p)->lpVtbl->Unregister(p)
+
+#endif
+
+#define IAMovieSetup_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; \
+ /*** IAMovieSetup methods ***/ \
+ STDMETHOD_(HRESULT,Register)(THIS) PURE; \
+ STDMETHOD_(HRESULT,Unregister)(THIS) PURE;
+
+HRESULT CALLBACK IAMovieSetup_Register_Proxy(
+ IAMovieSetup* This);
+void __RPC_STUB IAMovieSetup_Register_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IAMovieSetup_Unregister_Proxy(
+ IAMovieSetup* This);
+void __RPC_STUB IAMovieSetup_Unregister_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+typedef IAMovieSetup *PAMOVIESETUP;
+
+typedef enum AM_SEEKING_SeekingFlags {
+ AM_SEEKING_NoPositioning = 0x0,
+ AM_SEEKING_AbsolutePositioning = 0x1,
+ AM_SEEKING_RelativePositioning = 0x2,
+ AM_SEEKING_IncrementalPositioning = 0x3,
+ AM_SEEKING_PositioningBitsMask = 0x3,
+ AM_SEEKING_SeekToKeyFrame = 0x4,
+ AM_SEEKING_ReturnTime = 0x8,
+ AM_SEEKING_Segment = 0x10,
+ AM_SEEKING_NoFlush = 0x20
+} AM_SEEKING_SEEKING_FLAGS;
+
+typedef enum AM_SEEKING_SeekingCapabilities {
+ AM_SEEKING_CanSeekAbsolute = 0x1,
+ AM_SEEKING_CanSeekForwards = 0x2,
+ AM_SEEKING_CanSeekBackwards = 0x4,
+ AM_SEEKING_CanGetCurrentPos = 0x8,
+ AM_SEEKING_CanGetStopPos = 0x10,
+ AM_SEEKING_CanGetDuration = 0x20,
+ AM_SEEKING_CanPlayBackwards = 0x40,
+ AM_SEEKING_CanDoSegments = 0x80,
+ AM_SEEKING_Source = 0x100
+} AM_SEEKING_SEEKING_CAPABILITIES;
+
+typedef struct IMediaSeeking IMediaSeeking;
+/*****************************************************************************
+ * IMediaSeeking interface
+ */
+DEFINE_GUID(IID_IMediaSeeking, 0x36b73880, 0xc2c8, 0x11cf, 0x8b,0x46, 0x00,0x80,0x5f,0x6c,0xef,0x60);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IMediaSeeking : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE GetCapabilities(
+ DWORD* pCapabilities) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE CheckCapabilities(
+ DWORD* pCapabilities) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE IsFormatSupported(
+ const GUID* pFormat) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE QueryPreferredFormat(
+ GUID* pFormat) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetTimeFormat(
+ GUID* pFormat) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE IsUsingTimeFormat(
+ const GUID* pFormat) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE SetTimeFormat(
+ const GUID* pFormat) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetDuration(
+ LONGLONG* pDuration) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetStopPosition(
+ LONGLONG* pStop) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetCurrentPosition(
+ LONGLONG* pCurrent) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE ConvertTimeFormat(
+ LONGLONG* pTarget,
+ const GUID* pTargetFormat,
+ LONGLONG Source,
+ const GUID* pSourceFormat) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE SetPositions(
+ LONGLONG* pCurrent,
+ DWORD dwCurrentFlags,
+ LONGLONG* pStop,
+ DWORD dwStopFlags) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetPositions(
+ LONGLONG* pCurrent,
+ LONGLONG* pStop) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetAvailable(
+ LONGLONG* pEarliest,
+ LONGLONG* pLatest) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE SetRate(
+ double dRate) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetRate(
+ double* pdRate) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetPreroll(
+ LONGLONG* pllPreroll) = 0;
+
+};
+#else
+typedef struct IMediaSeekingVtbl IMediaSeekingVtbl;
+struct IMediaSeeking {
+ const IMediaSeekingVtbl* lpVtbl;
+};
+struct IMediaSeekingVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IMediaSeeking* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IMediaSeeking* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IMediaSeeking* This);
+
+ /*** IMediaSeeking methods ***/
+ HRESULT (STDMETHODCALLTYPE *GetCapabilities)(
+ IMediaSeeking* This,
+ DWORD* pCapabilities);
+
+ HRESULT (STDMETHODCALLTYPE *CheckCapabilities)(
+ IMediaSeeking* This,
+ DWORD* pCapabilities);
+
+ HRESULT (STDMETHODCALLTYPE *IsFormatSupported)(
+ IMediaSeeking* This,
+ const GUID* pFormat);
+
+ HRESULT (STDMETHODCALLTYPE *QueryPreferredFormat)(
+ IMediaSeeking* This,
+ GUID* pFormat);
+
+ HRESULT (STDMETHODCALLTYPE *GetTimeFormat)(
+ IMediaSeeking* This,
+ GUID* pFormat);
+
+ HRESULT (STDMETHODCALLTYPE *IsUsingTimeFormat)(
+ IMediaSeeking* This,
+ const GUID* pFormat);
+
+ HRESULT (STDMETHODCALLTYPE *SetTimeFormat)(
+ IMediaSeeking* This,
+ const GUID* pFormat);
+
+ HRESULT (STDMETHODCALLTYPE *GetDuration)(
+ IMediaSeeking* This,
+ LONGLONG* pDuration);
+
+ HRESULT (STDMETHODCALLTYPE *GetStopPosition)(
+ IMediaSeeking* This,
+ LONGLONG* pStop);
+
+ HRESULT (STDMETHODCALLTYPE *GetCurrentPosition)(
+ IMediaSeeking* This,
+ LONGLONG* pCurrent);
+
+ HRESULT (STDMETHODCALLTYPE *ConvertTimeFormat)(
+ IMediaSeeking* This,
+ LONGLONG* pTarget,
+ const GUID* pTargetFormat,
+ LONGLONG Source,
+ const GUID* pSourceFormat);
+
+ HRESULT (STDMETHODCALLTYPE *SetPositions)(
+ IMediaSeeking* This,
+ LONGLONG* pCurrent,
+ DWORD dwCurrentFlags,
+ LONGLONG* pStop,
+ DWORD dwStopFlags);
+
+ HRESULT (STDMETHODCALLTYPE *GetPositions)(
+ IMediaSeeking* This,
+ LONGLONG* pCurrent,
+ LONGLONG* pStop);
+
+ HRESULT (STDMETHODCALLTYPE *GetAvailable)(
+ IMediaSeeking* This,
+ LONGLONG* pEarliest,
+ LONGLONG* pLatest);
+
+ HRESULT (STDMETHODCALLTYPE *SetRate)(
+ IMediaSeeking* This,
+ double dRate);
+
+ HRESULT (STDMETHODCALLTYPE *GetRate)(
+ IMediaSeeking* This,
+ double* pdRate);
+
+ HRESULT (STDMETHODCALLTYPE *GetPreroll)(
+ IMediaSeeking* This,
+ LONGLONG* pllPreroll);
+
+};
+
+/*** IUnknown methods ***/
+#define IMediaSeeking_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IMediaSeeking_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IMediaSeeking_Release(p) (p)->lpVtbl->Release(p)
+/*** IMediaSeeking methods ***/
+#define IMediaSeeking_GetCapabilities(p,a) (p)->lpVtbl->GetCapabilities(p,a)
+#define IMediaSeeking_CheckCapabilities(p,a) (p)->lpVtbl->CheckCapabilities(p,a)
+#define IMediaSeeking_IsFormatSupported(p,a) (p)->lpVtbl->IsFormatSupported(p,a)
+#define IMediaSeeking_QueryPreferredFormat(p,a) (p)->lpVtbl->QueryPreferredFormat(p,a)
+#define IMediaSeeking_GetTimeFormat(p,a) (p)->lpVtbl->GetTimeFormat(p,a)
+#define IMediaSeeking_IsUsingTimeFormat(p,a) (p)->lpVtbl->IsUsingTimeFormat(p,a)
+#define IMediaSeeking_SetTimeFormat(p,a) (p)->lpVtbl->SetTimeFormat(p,a)
+#define IMediaSeeking_GetDuration(p,a) (p)->lpVtbl->GetDuration(p,a)
+#define IMediaSeeking_GetStopPosition(p,a) (p)->lpVtbl->GetStopPosition(p,a)
+#define IMediaSeeking_GetCurrentPosition(p,a) (p)->lpVtbl->GetCurrentPosition(p,a)
+#define IMediaSeeking_ConvertTimeFormat(p,a,b,c,d) (p)->lpVtbl->ConvertTimeFormat(p,a,b,c,d)
+#define IMediaSeeking_SetPositions(p,a,b,c,d) (p)->lpVtbl->SetPositions(p,a,b,c,d)
+#define IMediaSeeking_GetPositions(p,a,b) (p)->lpVtbl->GetPositions(p,a,b)
+#define IMediaSeeking_GetAvailable(p,a,b) (p)->lpVtbl->GetAvailable(p,a,b)
+#define IMediaSeeking_SetRate(p,a) (p)->lpVtbl->SetRate(p,a)
+#define IMediaSeeking_GetRate(p,a) (p)->lpVtbl->GetRate(p,a)
+#define IMediaSeeking_GetPreroll(p,a) (p)->lpVtbl->GetPreroll(p,a)
+
+#endif
+
+#define IMediaSeeking_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; \
+ /*** IMediaSeeking methods ***/ \
+ STDMETHOD_(HRESULT,GetCapabilities)(THIS_ DWORD* pCapabilities) PURE; \
+ STDMETHOD_(HRESULT,CheckCapabilities)(THIS_ DWORD* pCapabilities) PURE; \
+ STDMETHOD_(HRESULT,IsFormatSupported)(THIS_ const GUID* pFormat) PURE; \
+ STDMETHOD_(HRESULT,QueryPreferredFormat)(THIS_ GUID* pFormat) PURE; \
+ STDMETHOD_(HRESULT,GetTimeFormat)(THIS_ GUID* pFormat) PURE; \
+ STDMETHOD_(HRESULT,IsUsingTimeFormat)(THIS_ const GUID* pFormat) PURE; \
+ STDMETHOD_(HRESULT,SetTimeFormat)(THIS_ const GUID* pFormat) PURE; \
+ STDMETHOD_(HRESULT,GetDuration)(THIS_ LONGLONG* pDuration) PURE; \
+ STDMETHOD_(HRESULT,GetStopPosition)(THIS_ LONGLONG* pStop) PURE; \
+ STDMETHOD_(HRESULT,GetCurrentPosition)(THIS_ LONGLONG* pCurrent) PURE; \
+ STDMETHOD_(HRESULT,ConvertTimeFormat)(THIS_ LONGLONG* pTarget, const GUID* pTargetFormat, LONGLONG Source, const GUID* pSourceFormat) PURE; \
+ STDMETHOD_(HRESULT,SetPositions)(THIS_ LONGLONG* pCurrent, DWORD dwCurrentFlags, LONGLONG* pStop, DWORD dwStopFlags) PURE; \
+ STDMETHOD_(HRESULT,GetPositions)(THIS_ LONGLONG* pCurrent, LONGLONG* pStop) PURE; \
+ STDMETHOD_(HRESULT,GetAvailable)(THIS_ LONGLONG* pEarliest, LONGLONG* pLatest) PURE; \
+ STDMETHOD_(HRESULT,SetRate)(THIS_ double dRate) PURE; \
+ STDMETHOD_(HRESULT,GetRate)(THIS_ double* pdRate) PURE; \
+ STDMETHOD_(HRESULT,GetPreroll)(THIS_ LONGLONG* pllPreroll) PURE;
+
+HRESULT CALLBACK IMediaSeeking_GetCapabilities_Proxy(
+ IMediaSeeking* This,
+ DWORD* pCapabilities);
+void __RPC_STUB IMediaSeeking_GetCapabilities_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMediaSeeking_CheckCapabilities_Proxy(
+ IMediaSeeking* This,
+ DWORD* pCapabilities);
+void __RPC_STUB IMediaSeeking_CheckCapabilities_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMediaSeeking_IsFormatSupported_Proxy(
+ IMediaSeeking* This,
+ const GUID* pFormat);
+void __RPC_STUB IMediaSeeking_IsFormatSupported_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMediaSeeking_QueryPreferredFormat_Proxy(
+ IMediaSeeking* This,
+ GUID* pFormat);
+void __RPC_STUB IMediaSeeking_QueryPreferredFormat_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMediaSeeking_GetTimeFormat_Proxy(
+ IMediaSeeking* This,
+ GUID* pFormat);
+void __RPC_STUB IMediaSeeking_GetTimeFormat_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMediaSeeking_IsUsingTimeFormat_Proxy(
+ IMediaSeeking* This,
+ const GUID* pFormat);
+void __RPC_STUB IMediaSeeking_IsUsingTimeFormat_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMediaSeeking_SetTimeFormat_Proxy(
+ IMediaSeeking* This,
+ const GUID* pFormat);
+void __RPC_STUB IMediaSeeking_SetTimeFormat_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMediaSeeking_GetDuration_Proxy(
+ IMediaSeeking* This,
+ LONGLONG* pDuration);
+void __RPC_STUB IMediaSeeking_GetDuration_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMediaSeeking_GetStopPosition_Proxy(
+ IMediaSeeking* This,
+ LONGLONG* pStop);
+void __RPC_STUB IMediaSeeking_GetStopPosition_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMediaSeeking_GetCurrentPosition_Proxy(
+ IMediaSeeking* This,
+ LONGLONG* pCurrent);
+void __RPC_STUB IMediaSeeking_GetCurrentPosition_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMediaSeeking_ConvertTimeFormat_Proxy(
+ IMediaSeeking* This,
+ LONGLONG* pTarget,
+ const GUID* pTargetFormat,
+ LONGLONG Source,
+ const GUID* pSourceFormat);
+void __RPC_STUB IMediaSeeking_ConvertTimeFormat_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMediaSeeking_SetPositions_Proxy(
+ IMediaSeeking* This,
+ LONGLONG* pCurrent,
+ DWORD dwCurrentFlags,
+ LONGLONG* pStop,
+ DWORD dwStopFlags);
+void __RPC_STUB IMediaSeeking_SetPositions_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMediaSeeking_GetPositions_Proxy(
+ IMediaSeeking* This,
+ LONGLONG* pCurrent,
+ LONGLONG* pStop);
+void __RPC_STUB IMediaSeeking_GetPositions_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMediaSeeking_GetAvailable_Proxy(
+ IMediaSeeking* This,
+ LONGLONG* pEarliest,
+ LONGLONG* pLatest);
+void __RPC_STUB IMediaSeeking_GetAvailable_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMediaSeeking_SetRate_Proxy(
+ IMediaSeeking* This,
+ double dRate);
+void __RPC_STUB IMediaSeeking_SetRate_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMediaSeeking_GetRate_Proxy(
+ IMediaSeeking* This,
+ double* pdRate);
+void __RPC_STUB IMediaSeeking_GetRate_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IMediaSeeking_GetPreroll_Proxy(
+ IMediaSeeking* This,
+ LONGLONG* pllPreroll);
+void __RPC_STUB IMediaSeeking_GetPreroll_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+typedef IMediaSeeking *PMEDIASEEKING;
+
+enum tagAM_MEDIAEVENT_FLAGS {
+ AM_MEDIAEVENT_NONOTIFY = 0x1
+};
+
+typedef struct IAMAnalogVideoDecoder IAMAnalogVideoDecoder;
+typedef struct IAMAnalogVideoEncoder IAMAnalogVideoEncoder;
+typedef struct IAMAudioInputMixer IAMAudioInputMixer;
+typedef struct IAMAudioRendererStats IAMAudioRendererStats;
+typedef struct IAMBufferNegotiation IAMBufferNegotiation;
+typedef struct IAMCameraControl IAMCameraControl;
+typedef struct IAMCopyCaptureFileProgress IAMCopyCaptureFileProgress;
+typedef struct IAMCrossbar IAMCrossbar;
+typedef struct IAMDevMemoryAllocator IAMDevMemoryAllocator;
+typedef struct IAMDevMemoryControl IAMDevMemoryControl;
+typedef struct IAMDroppedFrames IAMDroppedFrames;
+typedef struct IAMExtDevice IAMExtDevice;
+typedef struct IAMExtTransport IAMExtTransport;
+typedef struct IAMGraphStreams IAMGraphStreams;
+typedef struct IAMLatency IAMLatency;
+typedef struct IAMOpenProgress IAMOpenProgress;
+typedef struct IAMOverlayFX IAMOverlayFX;
+typedef struct IAMPhysicalPinInfo IAMPhysicalPinInfo;
+typedef struct IAMPushSource IAMPushSource;
+typedef struct IAMStreamConfig IAMStreamConfig;
+typedef struct IAMTimecodeDisplay IAMTimecodeDisplay;
+typedef struct IAMTimecodeGenerator IAMTimecodeGenerator;
+typedef struct IAMTimecodeReader IAMTimecodeReader;
+typedef struct IAMTVTuner IAMTVTuner;
+typedef struct IAMVfwCaptureDialogs IAMVfwCaptureDialogs;
+typedef struct IAMVfwCompressDialogs IAMVfwCompressDialogs;
+typedef struct IAMVideoCompression IAMVideoCompression;
+typedef struct IAMVideoDecimationProperties IAMVideoDecimationProperties;
+typedef struct IAMVideoProcAmp IAMVideoProcAmp;
+typedef struct ICaptureGraphBuilder ICaptureGraphBuilder;
+typedef struct ICaptureGraphBuilder2 ICaptureGraphBuilder2;
+typedef struct IConfigAviMux IConfigAviMux;
+typedef struct IConfigInterleaving IConfigInterleaving;
+typedef struct IDecimateVideoImage IDecimateVideoImage;
+typedef struct IDrawVideoImage IDrawVideoImage;
+typedef struct IEnumRegFilters IEnumRegFilters;
+typedef struct IEnumStreamIdMap IEnumStreamIdMap;
+typedef struct IFileSourceFilter IFileSourceFilter;
+typedef struct IFileSinkFilter IFileSinkFilter;
+typedef struct IFileSinkFilter2 IFileSinkFilter2;
+typedef struct IFilterMapper IFilterMapper;
+typedef struct IFilterMapper2 IFilterMapper2;
+typedef struct IGraphBuilder IGraphBuilder;
+typedef struct IKsPropertySet IKsPropertySet;
+typedef struct IMediaEventSink IMediaEventSink;
+typedef struct IMpeg2Demultiplexer IMpeg2Demultiplexer;
+typedef struct IMPEG2StreamIdMap IMPEG2StreamIdMap;
+typedef struct IOverlay IOverlay;
+typedef struct IOverlayNotify IOverlayNotify;
+typedef struct IOverlayNotify2 IOverlayNotify2;
+typedef struct IQualityControl IQualityControl;
+typedef struct ISeekingPassThru ISeekingPassThru;
+typedef struct {
+ CLSID Clsid;
+ LPWSTR Name;
+} REGFILTER;
+
+/*****************************************************************************
+ * IEnumRegFilters interface
+ */
+DEFINE_GUID(IID_IEnumRegFilters, 0x56a868a4, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IEnumRegFilters : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE Next(
+ ULONG cFilters,
+ REGFILTER** apRegFilter,
+ ULONG* pcFetched) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE Skip(
+ ULONG cFilters) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE Reset(
+ ) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE Clone(
+ IEnumRegFilters** ppEnum) = 0;
+
+};
+#else
+typedef struct IEnumRegFiltersVtbl IEnumRegFiltersVtbl;
+struct IEnumRegFilters {
+ const IEnumRegFiltersVtbl* lpVtbl;
+};
+struct IEnumRegFiltersVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IEnumRegFilters* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IEnumRegFilters* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IEnumRegFilters* This);
+
+ /*** IEnumRegFilters methods ***/
+ HRESULT (STDMETHODCALLTYPE *Next)(
+ IEnumRegFilters* This,
+ ULONG cFilters,
+ REGFILTER** apRegFilter,
+ ULONG* pcFetched);
+
+ HRESULT (STDMETHODCALLTYPE *Skip)(
+ IEnumRegFilters* This,
+ ULONG cFilters);
+
+ HRESULT (STDMETHODCALLTYPE *Reset)(
+ IEnumRegFilters* This);
+
+ HRESULT (STDMETHODCALLTYPE *Clone)(
+ IEnumRegFilters* This,
+ IEnumRegFilters** ppEnum);
+
+};
+
+/*** IUnknown methods ***/
+#define IEnumRegFilters_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IEnumRegFilters_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IEnumRegFilters_Release(p) (p)->lpVtbl->Release(p)
+/*** IEnumRegFilters methods ***/
+#define IEnumRegFilters_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c)
+#define IEnumRegFilters_Skip(p,a) (p)->lpVtbl->Skip(p,a)
+#define IEnumRegFilters_Reset(p) (p)->lpVtbl->Reset(p)
+#define IEnumRegFilters_Clone(p,a) (p)->lpVtbl->Clone(p,a)
+
+#endif
+
+#define IEnumRegFilters_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; \
+ /*** IEnumRegFilters methods ***/ \
+ STDMETHOD_(HRESULT,Next)(THIS_ ULONG cFilters, REGFILTER** apRegFilter, ULONG* pcFetched) PURE; \
+ STDMETHOD_(HRESULT,Skip)(THIS_ ULONG cFilters) PURE; \
+ STDMETHOD_(HRESULT,Reset)(THIS) PURE; \
+ STDMETHOD_(HRESULT,Clone)(THIS_ IEnumRegFilters** ppEnum) PURE;
+
+HRESULT CALLBACK IEnumRegFilters_Next_Proxy(
+ IEnumRegFilters* This,
+ ULONG cFilters,
+ REGFILTER** apRegFilter,
+ ULONG* pcFetched);
+void __RPC_STUB IEnumRegFilters_Next_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumRegFilters_Skip_Proxy(
+ IEnumRegFilters* This,
+ ULONG cFilters);
+void __RPC_STUB IEnumRegFilters_Skip_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumRegFilters_Reset_Proxy(
+ IEnumRegFilters* This);
+void __RPC_STUB IEnumRegFilters_Reset_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumRegFilters_Clone_Proxy(
+ IEnumRegFilters* This,
+ IEnumRegFilters** ppEnum);
+void __RPC_STUB IEnumRegFilters_Clone_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+typedef IEnumRegFilters *PENUMREGFILTERS;
+
+enum {
+ MERIT_PREFERRED = 0x800000,
+ MERIT_NORMAL = 0x600000,
+ MERIT_UNLIKELY = 0x400000,
+ MERIT_DO_NOT_USE = 0x200000,
+ MERIT_SW_COMPRESSOR = 0x100000,
+ MERIT_HW_COMPRESSOR = 0x100050
+};
+
+/*****************************************************************************
+ * IFilterMapper interface
+ */
+DEFINE_GUID(IID_IFilterMapper, 0x56a868a3, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IFilterMapper : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE RegisterFilter(
+ CLSID clsid,
+ LPCWSTR Name,
+ DWORD dwMerit) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE RegisterFilterInstance(
+ CLSID clsid,
+ LPCWSTR Name,
+ CLSID* MRId) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE RegisterPin(
+ CLSID Filter,
+ LPCWSTR Name,
+ BOOL bRendered,
+ BOOL bOutput,
+ BOOL bZero,
+ BOOL bMany,
+ CLSID ConnectsToFilter,
+ LPCWSTR ConnectsToPin) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE RegisterPinType(
+ CLSID clsFilter,
+ LPCWSTR strName,
+ CLSID clsMajorType,
+ CLSID clsSubType) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE UnregisterFilter(
+ CLSID Filter) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE UnregisterFilterInstance(
+ CLSID MRId) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE UnregisterPin(
+ CLSID Filter,
+ LPCWSTR Name) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE EnumMatchingFilters(
+ IEnumRegFilters** ppEnum,
+ DWORD dwMerit,
+ BOOL bInputNeeded,
+ CLSID clsInMaj,
+ CLSID clsInSub,
+ BOOL bRender,
+ BOOL bOututNeeded,
+ CLSID clsOutMaj,
+ CLSID clsOutSub) = 0;
+
+};
+#else
+typedef struct IFilterMapperVtbl IFilterMapperVtbl;
+struct IFilterMapper {
+ const IFilterMapperVtbl* lpVtbl;
+};
+struct IFilterMapperVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IFilterMapper* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IFilterMapper* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IFilterMapper* This);
+
+ /*** IFilterMapper methods ***/
+ HRESULT (STDMETHODCALLTYPE *RegisterFilter)(
+ IFilterMapper* This,
+ CLSID clsid,
+ LPCWSTR Name,
+ DWORD dwMerit);
+
+ HRESULT (STDMETHODCALLTYPE *RegisterFilterInstance)(
+ IFilterMapper* This,
+ CLSID clsid,
+ LPCWSTR Name,
+ CLSID* MRId);
+
+ HRESULT (STDMETHODCALLTYPE *RegisterPin)(
+ IFilterMapper* This,
+ CLSID Filter,
+ LPCWSTR Name,
+ BOOL bRendered,
+ BOOL bOutput,
+ BOOL bZero,
+ BOOL bMany,
+ CLSID ConnectsToFilter,
+ LPCWSTR ConnectsToPin);
+
+ HRESULT (STDMETHODCALLTYPE *RegisterPinType)(
+ IFilterMapper* This,
+ CLSID clsFilter,
+ LPCWSTR strName,
+ CLSID clsMajorType,
+ CLSID clsSubType);
+
+ HRESULT (STDMETHODCALLTYPE *UnregisterFilter)(
+ IFilterMapper* This,
+ CLSID Filter);
+
+ HRESULT (STDMETHODCALLTYPE *UnregisterFilterInstance)(
+ IFilterMapper* This,
+ CLSID MRId);
+
+ HRESULT (STDMETHODCALLTYPE *UnregisterPin)(
+ IFilterMapper* This,
+ CLSID Filter,
+ LPCWSTR Name);
+
+ HRESULT (STDMETHODCALLTYPE *EnumMatchingFilters)(
+ IFilterMapper* This,
+ IEnumRegFilters** ppEnum,
+ DWORD dwMerit,
+ BOOL bInputNeeded,
+ CLSID clsInMaj,
+ CLSID clsInSub,
+ BOOL bRender,
+ BOOL bOututNeeded,
+ CLSID clsOutMaj,
+ CLSID clsOutSub);
+
+};
+
+/*** IUnknown methods ***/
+#define IFilterMapper_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IFilterMapper_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IFilterMapper_Release(p) (p)->lpVtbl->Release(p)
+/*** IFilterMapper methods ***/
+#define IFilterMapper_RegisterFilter(p,a,b,c) (p)->lpVtbl->RegisterFilter(p,a,b,c)
+#define IFilterMapper_RegisterFilterInstance(p,a,b,c) (p)->lpVtbl->RegisterFilterInstance(p,a,b,c)
+#define IFilterMapper_RegisterPin(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->RegisterPin(p,a,b,c,d,e,f,g,h)
+#define IFilterMapper_RegisterPinType(p,a,b,c,d) (p)->lpVtbl->RegisterPinType(p,a,b,c,d)
+#define IFilterMapper_UnregisterFilter(p,a) (p)->lpVtbl->UnregisterFilter(p,a)
+#define IFilterMapper_UnregisterFilterInstance(p,a) (p)->lpVtbl->UnregisterFilterInstance(p,a)
+#define IFilterMapper_UnregisterPin(p,a,b) (p)->lpVtbl->UnregisterPin(p,a,b)
+#define IFilterMapper_EnumMatchingFilters(p,a,b,c,d,e,f,g,h,i) (p)->lpVtbl->EnumMatchingFilters(p,a,b,c,d,e,f,g,h,i)
+
+#endif
+
+#define IFilterMapper_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; \
+ /*** IFilterMapper methods ***/ \
+ STDMETHOD_(HRESULT,RegisterFilter)(THIS_ CLSID clsid, LPCWSTR Name, DWORD dwMerit) PURE; \
+ STDMETHOD_(HRESULT,RegisterFilterInstance)(THIS_ CLSID clsid, LPCWSTR Name, CLSID* MRId) PURE; \
+ STDMETHOD_(HRESULT,RegisterPin)(THIS_ CLSID Filter, LPCWSTR Name, BOOL bRendered, BOOL bOutput, BOOL bZero, BOOL bMany, CLSID ConnectsToFilter, LPCWSTR ConnectsToPin) PURE; \
+ STDMETHOD_(HRESULT,RegisterPinType)(THIS_ CLSID clsFilter, LPCWSTR strName, CLSID clsMajorType, CLSID clsSubType) PURE; \
+ STDMETHOD_(HRESULT,UnregisterFilter)(THIS_ CLSID Filter) PURE; \
+ STDMETHOD_(HRESULT,UnregisterFilterInstance)(THIS_ CLSID MRId) PURE; \
+ STDMETHOD_(HRESULT,UnregisterPin)(THIS_ CLSID Filter, LPCWSTR Name) PURE; \
+ STDMETHOD_(HRESULT,EnumMatchingFilters)(THIS_ IEnumRegFilters** ppEnum, DWORD dwMerit, BOOL bInputNeeded, CLSID clsInMaj, CLSID clsInSub, BOOL bRender, BOOL bOututNeeded, CLSID clsOutMaj, CLSID clsOutSub) PURE;
+
+HRESULT CALLBACK IFilterMapper_RegisterFilter_Proxy(
+ IFilterMapper* This,
+ CLSID clsid,
+ LPCWSTR Name,
+ DWORD dwMerit);
+void __RPC_STUB IFilterMapper_RegisterFilter_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFilterMapper_RegisterFilterInstance_Proxy(
+ IFilterMapper* This,
+ CLSID clsid,
+ LPCWSTR Name,
+ CLSID* MRId);
+void __RPC_STUB IFilterMapper_RegisterFilterInstance_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFilterMapper_RegisterPin_Proxy(
+ IFilterMapper* This,
+ CLSID Filter,
+ LPCWSTR Name,
+ BOOL bRendered,
+ BOOL bOutput,
+ BOOL bZero,
+ BOOL bMany,
+ CLSID ConnectsToFilter,
+ LPCWSTR ConnectsToPin);
+void __RPC_STUB IFilterMapper_RegisterPin_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFilterMapper_RegisterPinType_Proxy(
+ IFilterMapper* This,
+ CLSID clsFilter,
+ LPCWSTR strName,
+ CLSID clsMajorType,
+ CLSID clsSubType);
+void __RPC_STUB IFilterMapper_RegisterPinType_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFilterMapper_UnregisterFilter_Proxy(
+ IFilterMapper* This,
+ CLSID Filter);
+void __RPC_STUB IFilterMapper_UnregisterFilter_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFilterMapper_UnregisterFilterInstance_Proxy(
+ IFilterMapper* This,
+ CLSID MRId);
+void __RPC_STUB IFilterMapper_UnregisterFilterInstance_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFilterMapper_UnregisterPin_Proxy(
+ IFilterMapper* This,
+ CLSID Filter,
+ LPCWSTR Name);
+void __RPC_STUB IFilterMapper_UnregisterPin_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFilterMapper_EnumMatchingFilters_Proxy(
+ IFilterMapper* This,
+ IEnumRegFilters** ppEnum,
+ DWORD dwMerit,
+ BOOL bInputNeeded,
+ CLSID clsInMaj,
+ CLSID clsInSub,
+ BOOL bRender,
+ BOOL bOututNeeded,
+ CLSID clsOutMaj,
+ CLSID clsOutSub);
+void __RPC_STUB IFilterMapper_EnumMatchingFilters_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+typedef struct {
+ const CLSID *clsMajorType;
+ const CLSID *clsMinorType;
+} REGPINTYPES;
+
+typedef struct {
+ LPWSTR strName;
+ BOOL bRendered;
+ BOOL bOutput;
+ BOOL bZero;
+ BOOL bMany;
+ const CLSID *clsConnectsToFilter;
+ const WCHAR *strConnectsToPin;
+ UINT nMediaTypes;
+ const REGPINTYPES *lpMediaType;
+} REGFILTERPINS;
+
+typedef struct {
+ CLSID clsMedium;
+ DWORD dw1;
+ DWORD dw2;
+} REGPINMEDIUM;
+
+enum {
+ REG_PINFLAG_B_ZERO = 0x1,
+ REG_PINFLAG_B_RENDERER = 0x2,
+ REG_PINFLAG_B_MANY = 0x4,
+ REG_PINFLAG_B_OUTPUT = 0x8
+};
+
+typedef struct {
+ DWORD dwFlags;
+ UINT cInstances;
+ UINT nMediaTypes;
+ const REGPINTYPES *lpMediaType;
+ UINT nMediums;
+ const REGPINMEDIUM *lpMedium;
+ const CLSID *clsPinCategory;
+} REGFILTERPINS2;
+
+typedef struct {
+ DWORD dwVersion;
+ DWORD dwMerit;
+ union {
+ struct {
+ ULONG cPins;
+ const REGFILTERPINS *rgPins;
+ } DUMMYSTRUCTNAME;
+ struct {
+ ULONG cPins2;
+ const REGFILTERPINS2 *rgPins2;
+ } DUMMYSTRUCTNAME1;
+ } DUMMYUNIONNAME;
+} REGFILTER2;
+
+/*****************************************************************************
+ * IFilterMapper2 interface
+ */
+DEFINE_GUID(IID_IFilterMapper2, 0xb79bb0b0, 0x33c1, 0x11d1, 0xab,0xe1, 0x00,0xa0,0xc9,0x05,0xf3,0x75);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IFilterMapper2 : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE CreateCategory(
+ REFCLSID clsidCategory,
+ DWORD dwCategoryMerit,
+ LPCWSTR Description) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE UnregisterFilter(
+ const CLSID* pclsidCategory,
+ const OLECHAR* szInstance,
+ REFCLSID Filter) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE RegisterFilter(
+ REFCLSID clsidFilter,
+ LPCWSTR Name,
+ IMoniker** ppMoniker,
+ const CLSID* pclsidCategory,
+ const OLECHAR* szInstance,
+ const REGFILTER2* prf2) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE EnumMatchingFilters(
+ IEnumMoniker** ppEnum,
+ DWORD dwFlags,
+ BOOL bExactMatch,
+ DWORD dwMerit,
+ BOOL bInputNeeded,
+ DWORD cInputTypes,
+ const GUID* pInputTypes,
+ const REGPINMEDIUM* pMedIn,
+ const CLSID* pPinCategoryIn,
+ BOOL bRender,
+ BOOL bOutputNeeded,
+ DWORD cOutputTypes,
+ const GUID* pOutputTypes,
+ const REGPINMEDIUM* pMedOut,
+ const CLSID* pPinCategoryOut) = 0;
+
+};
+#else
+typedef struct IFilterMapper2Vtbl IFilterMapper2Vtbl;
+struct IFilterMapper2 {
+ const IFilterMapper2Vtbl* lpVtbl;
+};
+struct IFilterMapper2Vtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IFilterMapper2* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IFilterMapper2* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IFilterMapper2* This);
+
+ /*** IFilterMapper2 methods ***/
+ HRESULT (STDMETHODCALLTYPE *CreateCategory)(
+ IFilterMapper2* This,
+ REFCLSID clsidCategory,
+ DWORD dwCategoryMerit,
+ LPCWSTR Description);
+
+ HRESULT (STDMETHODCALLTYPE *UnregisterFilter)(
+ IFilterMapper2* This,
+ const CLSID* pclsidCategory,
+ const OLECHAR* szInstance,
+ REFCLSID Filter);
+
+ HRESULT (STDMETHODCALLTYPE *RegisterFilter)(
+ IFilterMapper2* This,
+ REFCLSID clsidFilter,
+ LPCWSTR Name,
+ IMoniker** ppMoniker,
+ const CLSID* pclsidCategory,
+ const OLECHAR* szInstance,
+ const REGFILTER2* prf2);
+
+ HRESULT (STDMETHODCALLTYPE *EnumMatchingFilters)(
+ IFilterMapper2* This,
+ IEnumMoniker** ppEnum,
+ DWORD dwFlags,
+ BOOL bExactMatch,
+ DWORD dwMerit,
+ BOOL bInputNeeded,
+ DWORD cInputTypes,
+ const GUID* pInputTypes,
+ const REGPINMEDIUM* pMedIn,
+ const CLSID* pPinCategoryIn,
+ BOOL bRender,
+ BOOL bOutputNeeded,
+ DWORD cOutputTypes,
+ const GUID* pOutputTypes,
+ const REGPINMEDIUM* pMedOut,
+ const CLSID* pPinCategoryOut);
+
+};
+
+/*** IUnknown methods ***/
+#define IFilterMapper2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IFilterMapper2_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IFilterMapper2_Release(p) (p)->lpVtbl->Release(p)
+/*** IFilterMapper2 methods ***/
+#define IFilterMapper2_CreateCategory(p,a,b,c) (p)->lpVtbl->CreateCategory(p,a,b,c)
+#define IFilterMapper2_UnregisterFilter(p,a,b,c) (p)->lpVtbl->UnregisterFilter(p,a,b,c)
+#define IFilterMapper2_RegisterFilter(p,a,b,c,d,e,f) (p)->lpVtbl->RegisterFilter(p,a,b,c,d,e,f)
+#define IFilterMapper2_EnumMatchingFilters(p,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) (p)->lpVtbl->EnumMatchingFilters(p,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o)
+
+#endif
+
+#define IFilterMapper2_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; \
+ /*** IFilterMapper2 methods ***/ \
+ STDMETHOD_(HRESULT,CreateCategory)(THIS_ REFCLSID clsidCategory, DWORD dwCategoryMerit, LPCWSTR Description) PURE; \
+ STDMETHOD_(HRESULT,UnregisterFilter)(THIS_ const CLSID* pclsidCategory, const OLECHAR* szInstance, REFCLSID Filter) PURE; \
+ STDMETHOD_(HRESULT,RegisterFilter)(THIS_ REFCLSID clsidFilter, LPCWSTR Name, IMoniker** ppMoniker, const CLSID* pclsidCategory, const OLECHAR* szInstance, const REGFILTER2* prf2) PURE; \
+ STDMETHOD_(HRESULT,EnumMatchingFilters)(THIS_ IEnumMoniker** ppEnum, DWORD dwFlags, BOOL bExactMatch, DWORD dwMerit, BOOL bInputNeeded, DWORD cInputTypes, const GUID* pInputTypes, const REGPINMEDIUM* pMedIn, const CLSID* pPinCategoryIn, BOOL bRender, BOOL bOutputNeeded, DWORD cOutputTypes, const GUID* pOutputTypes, const REGPINMEDIUM* pMedOut, const CLSID* pPinCategoryOut) PURE;
+
+HRESULT CALLBACK IFilterMapper2_CreateCategory_Proxy(
+ IFilterMapper2* This,
+ REFCLSID clsidCategory,
+ DWORD dwCategoryMerit,
+ LPCWSTR Description);
+void __RPC_STUB IFilterMapper2_CreateCategory_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFilterMapper2_UnregisterFilter_Proxy(
+ IFilterMapper2* This,
+ const CLSID* pclsidCategory,
+ const OLECHAR* szInstance,
+ REFCLSID Filter);
+void __RPC_STUB IFilterMapper2_UnregisterFilter_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFilterMapper2_RegisterFilter_Proxy(
+ IFilterMapper2* This,
+ REFCLSID clsidFilter,
+ LPCWSTR Name,
+ IMoniker** ppMoniker,
+ const CLSID* pclsidCategory,
+ const OLECHAR* szInstance,
+ const REGFILTER2* prf2);
+void __RPC_STUB IFilterMapper2_RegisterFilter_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFilterMapper2_EnumMatchingFilters_Proxy(
+ IFilterMapper2* This,
+ IEnumMoniker** ppEnum,
+ DWORD dwFlags,
+ BOOL bExactMatch,
+ DWORD dwMerit,
+ BOOL bInputNeeded,
+ DWORD cInputTypes,
+ const GUID* pInputTypes,
+ const REGPINMEDIUM* pMedIn,
+ const CLSID* pPinCategoryIn,
+ BOOL bRender,
+ BOOL bOutputNeeded,
+ DWORD cOutputTypes,
+ const GUID* pOutputTypes,
+ const REGPINMEDIUM* pMedOut,
+ const CLSID* pPinCategoryOut);
+void __RPC_STUB IFilterMapper2_EnumMatchingFilters_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+typedef struct IFilterMapper3 IFilterMapper3;
+/*****************************************************************************
+ * IFilterMapper3 interface
+ */
+DEFINE_GUID(IID_IFilterMapper3, 0xb79bb0b1, 0x33c1, 0x11d1, 0xab,0xe1, 0x00,0xa0,0xc9,0x05,0xf3,0x75);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IFilterMapper3 : public IFilterMapper2
+{
+ virtual HRESULT STDMETHODCALLTYPE GetICreateDevEnum(
+ ICreateDevEnum** ppEnum) = 0;
+
+};
+#else
+typedef struct IFilterMapper3Vtbl IFilterMapper3Vtbl;
+struct IFilterMapper3 {
+ const IFilterMapper3Vtbl* lpVtbl;
+};
+struct IFilterMapper3Vtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IFilterMapper3* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IFilterMapper3* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IFilterMapper3* This);
+
+ /*** IFilterMapper2 methods ***/
+ HRESULT (STDMETHODCALLTYPE *CreateCategory)(
+ IFilterMapper3* This,
+ REFCLSID clsidCategory,
+ DWORD dwCategoryMerit,
+ LPCWSTR Description);
+
+ HRESULT (STDMETHODCALLTYPE *UnregisterFilter)(
+ IFilterMapper3* This,
+ const CLSID* pclsidCategory,
+ const OLECHAR* szInstance,
+ REFCLSID Filter);
+
+ HRESULT (STDMETHODCALLTYPE *RegisterFilter)(
+ IFilterMapper3* This,
+ REFCLSID clsidFilter,
+ LPCWSTR Name,
+ IMoniker** ppMoniker,
+ const CLSID* pclsidCategory,
+ const OLECHAR* szInstance,
+ const REGFILTER2* prf2);
+
+ HRESULT (STDMETHODCALLTYPE *EnumMatchingFilters)(
+ IFilterMapper3* This,
+ IEnumMoniker** ppEnum,
+ DWORD dwFlags,
+ BOOL bExactMatch,
+ DWORD dwMerit,
+ BOOL bInputNeeded,
+ DWORD cInputTypes,
+ const GUID* pInputTypes,
+ const REGPINMEDIUM* pMedIn,
+ const CLSID* pPinCategoryIn,
+ BOOL bRender,
+ BOOL bOutputNeeded,
+ DWORD cOutputTypes,
+ const GUID* pOutputTypes,
+ const REGPINMEDIUM* pMedOut,
+ const CLSID* pPinCategoryOut);
+
+ /*** IFilterMapper3 methods ***/
+ HRESULT (STDMETHODCALLTYPE *GetICreateDevEnum)(
+ IFilterMapper3* This,
+ ICreateDevEnum** ppEnum);
+
+};
+
+/*** IUnknown methods ***/
+#define IFilterMapper3_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IFilterMapper3_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IFilterMapper3_Release(p) (p)->lpVtbl->Release(p)
+/*** IFilterMapper2 methods ***/
+#define IFilterMapper3_CreateCategory(p,a,b,c) (p)->lpVtbl->CreateCategory(p,a,b,c)
+#define IFilterMapper3_UnregisterFilter(p,a,b,c) (p)->lpVtbl->UnregisterFilter(p,a,b,c)
+#define IFilterMapper3_RegisterFilter(p,a,b,c,d,e,f) (p)->lpVtbl->RegisterFilter(p,a,b,c,d,e,f)
+#define IFilterMapper3_EnumMatchingFilters(p,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) (p)->lpVtbl->EnumMatchingFilters(p,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o)
+/*** IFilterMapper3 methods ***/
+#define IFilterMapper3_GetICreateDevEnum(p,a) (p)->lpVtbl->GetICreateDevEnum(p,a)
+
+#endif
+
+#define IFilterMapper3_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; \
+ /*** IFilterMapper2 methods ***/ \
+ STDMETHOD_(HRESULT,CreateCategory)(THIS_ REFCLSID clsidCategory, DWORD dwCategoryMerit, LPCWSTR Description) PURE; \
+ STDMETHOD_(HRESULT,UnregisterFilter)(THIS_ const CLSID* pclsidCategory, const OLECHAR* szInstance, REFCLSID Filter) PURE; \
+ STDMETHOD_(HRESULT,RegisterFilter)(THIS_ REFCLSID clsidFilter, LPCWSTR Name, IMoniker** ppMoniker, const CLSID* pclsidCategory, const OLECHAR* szInstance, const REGFILTER2* prf2) PURE; \
+ STDMETHOD_(HRESULT,EnumMatchingFilters)(THIS_ IEnumMoniker** ppEnum, DWORD dwFlags, BOOL bExactMatch, DWORD dwMerit, BOOL bInputNeeded, DWORD cInputTypes, const GUID* pInputTypes, const REGPINMEDIUM* pMedIn, const CLSID* pPinCategoryIn, BOOL bRender, BOOL bOutputNeeded, DWORD cOutputTypes, const GUID* pOutputTypes, const REGPINMEDIUM* pMedOut, const CLSID* pPinCategoryOut) PURE; \
+ /*** IFilterMapper3 methods ***/ \
+ STDMETHOD_(HRESULT,GetICreateDevEnum)(THIS_ ICreateDevEnum** ppEnum) PURE;
+
+HRESULT CALLBACK IFilterMapper3_GetICreateDevEnum_Proxy(
+ IFilterMapper3* This,
+ ICreateDevEnum** ppEnum);
+void __RPC_STUB IFilterMapper3_GetICreateDevEnum_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+typedef enum tagQualityMessageType {
+ Famine,
+ Flood
+} QualityMessageType;
+
+typedef struct tagQuality {
+ QualityMessageType Type;
+ long Proportion;
+ REFERENCE_TIME Late;
+ REFERENCE_TIME TimeStamp;
+} Quality;
+
+typedef IQualityControl *PQUALITYCONTROL;
+
+/*****************************************************************************
+ * IQualityControl interface
+ */
+DEFINE_GUID(IID_IQualityControl, 0x56a868a5, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IQualityControl : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE Notify(
+ IBaseFilter* pSelf,
+ Quality q) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE SetSink(
+ IQualityControl* piqc) = 0;
+
+};
+#else
+typedef struct IQualityControlVtbl IQualityControlVtbl;
+struct IQualityControl {
+ const IQualityControlVtbl* lpVtbl;
+};
+struct IQualityControlVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IQualityControl* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IQualityControl* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IQualityControl* This);
+
+ /*** IQualityControl methods ***/
+ HRESULT (STDMETHODCALLTYPE *Notify)(
+ IQualityControl* This,
+ IBaseFilter* pSelf,
+ Quality q);
+
+ HRESULT (STDMETHODCALLTYPE *SetSink)(
+ IQualityControl* This,
+ IQualityControl* piqc);
+
+};
+
+/*** IUnknown methods ***/
+#define IQualityControl_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IQualityControl_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IQualityControl_Release(p) (p)->lpVtbl->Release(p)
+/*** IQualityControl methods ***/
+#define IQualityControl_Notify(p,a,b) (p)->lpVtbl->Notify(p,a,b)
+#define IQualityControl_SetSink(p,a) (p)->lpVtbl->SetSink(p,a)
+
+#endif
+
+#define IQualityControl_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; \
+ /*** IQualityControl methods ***/ \
+ STDMETHOD_(HRESULT,Notify)(THIS_ IBaseFilter* pSelf, Quality q) PURE; \
+ STDMETHOD_(HRESULT,SetSink)(THIS_ IQualityControl* piqc) PURE;
+
+HRESULT CALLBACK IQualityControl_Notify_Proxy(
+ IQualityControl* This,
+ IBaseFilter* pSelf,
+ Quality q);
+void __RPC_STUB IQualityControl_Notify_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IQualityControl_SetSink_Proxy(
+ IQualityControl* This,
+ IQualityControl* piqc);
+void __RPC_STUB IQualityControl_SetSink_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+enum {
+ CK_NOCOLORKEY = 0x0,
+ CK_INDEX = 0x1,
+ CK_RGB = 0x2
+};
+
+typedef struct tagCOLORKEY {
+ DWORD KeyType;
+ DWORD PaletteIndex;
+ COLORREF LowColorValue;
+ COLORREF HighColorValue;
+} COLORKEY;
+
+enum {
+ ADVISE_NONE = 0x0,
+ ADVISE_CLIPPING = 0x1,
+ ADVISE_PALETTE = 0x2,
+ ADVISE_COLORKEY = 0x4,
+ ADVISE_POSITION = 0x8,
+ ADVISE_DISPLAY_CHANGE = 0x10
+};
+
+#define ADVISE_ALL (((ADVISE_CLIPPING | ADVISE_PALETTE) | ADVISE_COLORKEY) | ADVISE_POSITION)
+
+#define ADVISE_ALL2 (ADVISE_ALL | ADVISE_DISPLAY_CHANGE)
+
+#ifndef _WINGDI_
+typedef struct _RGNDATAHEADER {
+ DWORD dwSize;
+ DWORD iType;
+ DWORD nCount;
+ DWORD nRgnSize;
+ RECT rcBound;
+} RGNDATAHEADER;
+
+typedef struct _RGNDATA {
+ RGNDATAHEADER rdh;
+ char Buffer[1];
+} RGNDATA;
+
+#endif /* _WINGDI_ */
+/*****************************************************************************
+ * IOverlayNotify interface
+ */
+DEFINE_GUID(IID_IOverlayNotify, 0x56a868a0, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IOverlayNotify : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE OnPaletteChange(
+ DWORD dwColors,
+ const PALETTEENTRY* pPalette) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE OnClipChange(
+ const RECT* pSourceRect,
+ const RECT* pDestinationRect,
+ const RGNDATA* pRgnData) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE OnColorKeyChange(
+ const COLORKEY* pColorKey) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE OnPositionChange(
+ const RECT* pSourceRect,
+ const RECT* pDestinationRect) = 0;
+
+};
+#else
+typedef struct IOverlayNotifyVtbl IOverlayNotifyVtbl;
+struct IOverlayNotify {
+ const IOverlayNotifyVtbl* lpVtbl;
+};
+struct IOverlayNotifyVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IOverlayNotify* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IOverlayNotify* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IOverlayNotify* This);
+
+ /*** IOverlayNotify methods ***/
+ HRESULT (STDMETHODCALLTYPE *OnPaletteChange)(
+ IOverlayNotify* This,
+ DWORD dwColors,
+ const PALETTEENTRY* pPalette);
+
+ HRESULT (STDMETHODCALLTYPE *OnClipChange)(
+ IOverlayNotify* This,
+ const RECT* pSourceRect,
+ const RECT* pDestinationRect,
+ const RGNDATA* pRgnData);
+
+ HRESULT (STDMETHODCALLTYPE *OnColorKeyChange)(
+ IOverlayNotify* This,
+ const COLORKEY* pColorKey);
+
+ HRESULT (STDMETHODCALLTYPE *OnPositionChange)(
+ IOverlayNotify* This,
+ const RECT* pSourceRect,
+ const RECT* pDestinationRect);
+
+};
+
+/*** IUnknown methods ***/
+#define IOverlayNotify_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IOverlayNotify_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IOverlayNotify_Release(p) (p)->lpVtbl->Release(p)
+/*** IOverlayNotify methods ***/
+#define IOverlayNotify_OnPaletteChange(p,a,b) (p)->lpVtbl->OnPaletteChange(p,a,b)
+#define IOverlayNotify_OnClipChange(p,a,b,c) (p)->lpVtbl->OnClipChange(p,a,b,c)
+#define IOverlayNotify_OnColorKeyChange(p,a) (p)->lpVtbl->OnColorKeyChange(p,a)
+#define IOverlayNotify_OnPositionChange(p,a,b) (p)->lpVtbl->OnPositionChange(p,a,b)
+
+#endif
+
+#define IOverlayNotify_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; \
+ /*** IOverlayNotify methods ***/ \
+ STDMETHOD_(HRESULT,OnPaletteChange)(THIS_ DWORD dwColors, const PALETTEENTRY* pPalette) PURE; \
+ STDMETHOD_(HRESULT,OnClipChange)(THIS_ const RECT* pSourceRect, const RECT* pDestinationRect, const RGNDATA* pRgnData) PURE; \
+ STDMETHOD_(HRESULT,OnColorKeyChange)(THIS_ const COLORKEY* pColorKey) PURE; \
+ STDMETHOD_(HRESULT,OnPositionChange)(THIS_ const RECT* pSourceRect, const RECT* pDestinationRect) PURE;
+
+HRESULT CALLBACK IOverlayNotify_OnPaletteChange_Proxy(
+ IOverlayNotify* This,
+ DWORD dwColors,
+ const PALETTEENTRY* pPalette);
+void __RPC_STUB IOverlayNotify_OnPaletteChange_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IOverlayNotify_OnClipChange_Proxy(
+ IOverlayNotify* This,
+ const RECT* pSourceRect,
+ const RECT* pDestinationRect,
+ const RGNDATA* pRgnData);
+void __RPC_STUB IOverlayNotify_OnClipChange_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IOverlayNotify_OnColorKeyChange_Proxy(
+ IOverlayNotify* This,
+ const COLORKEY* pColorKey);
+void __RPC_STUB IOverlayNotify_OnColorKeyChange_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IOverlayNotify_OnPositionChange_Proxy(
+ IOverlayNotify* This,
+ const RECT* pSourceRect,
+ const RECT* pDestinationRect);
+void __RPC_STUB IOverlayNotify_OnPositionChange_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+typedef IOverlayNotify *POVERLAYNOTIFY;
+
+#if 0
+typedef HANDLE HMONITOR;
+
+#endif /* 0 */
+/*****************************************************************************
+ * IOverlayNotify2 interface
+ */
+DEFINE_GUID(IID_IOverlayNotify2, 0x680efa10, 0xd535, 0x11d1, 0x87,0xc8, 0x00,0xa0,0xc9,0x22,0x31,0x96);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IOverlayNotify2 : public IOverlayNotify
+{
+ virtual HRESULT STDMETHODCALLTYPE OnDisplayChange(
+ HMONITOR hMonitor) = 0;
+
+};
+#else
+typedef struct IOverlayNotify2Vtbl IOverlayNotify2Vtbl;
+struct IOverlayNotify2 {
+ const IOverlayNotify2Vtbl* lpVtbl;
+};
+struct IOverlayNotify2Vtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IOverlayNotify2* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IOverlayNotify2* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IOverlayNotify2* This);
+
+ /*** IOverlayNotify methods ***/
+ HRESULT (STDMETHODCALLTYPE *OnPaletteChange)(
+ IOverlayNotify2* This,
+ DWORD dwColors,
+ const PALETTEENTRY* pPalette);
+
+ HRESULT (STDMETHODCALLTYPE *OnClipChange)(
+ IOverlayNotify2* This,
+ const RECT* pSourceRect,
+ const RECT* pDestinationRect,
+ const RGNDATA* pRgnData);
+
+ HRESULT (STDMETHODCALLTYPE *OnColorKeyChange)(
+ IOverlayNotify2* This,
+ const COLORKEY* pColorKey);
+
+ HRESULT (STDMETHODCALLTYPE *OnPositionChange)(
+ IOverlayNotify2* This,
+ const RECT* pSourceRect,
+ const RECT* pDestinationRect);
+
+ /*** IOverlayNotify2 methods ***/
+ HRESULT (STDMETHODCALLTYPE *OnDisplayChange)(
+ IOverlayNotify2* This,
+ HMONITOR hMonitor);
+
+};
+
+/*** IUnknown methods ***/
+#define IOverlayNotify2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IOverlayNotify2_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IOverlayNotify2_Release(p) (p)->lpVtbl->Release(p)
+/*** IOverlayNotify methods ***/
+#define IOverlayNotify2_OnPaletteChange(p,a,b) (p)->lpVtbl->OnPaletteChange(p,a,b)
+#define IOverlayNotify2_OnClipChange(p,a,b,c) (p)->lpVtbl->OnClipChange(p,a,b,c)
+#define IOverlayNotify2_OnColorKeyChange(p,a) (p)->lpVtbl->OnColorKeyChange(p,a)
+#define IOverlayNotify2_OnPositionChange(p,a,b) (p)->lpVtbl->OnPositionChange(p,a,b)
+/*** IOverlayNotify2 methods ***/
+#define IOverlayNotify2_OnDisplayChange(p,a) (p)->lpVtbl->OnDisplayChange(p,a)
+
+#endif
+
+#define IOverlayNotify2_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; \
+ /*** IOverlayNotify methods ***/ \
+ STDMETHOD_(HRESULT,OnPaletteChange)(THIS_ DWORD dwColors, const PALETTEENTRY* pPalette) PURE; \
+ STDMETHOD_(HRESULT,OnClipChange)(THIS_ const RECT* pSourceRect, const RECT* pDestinationRect, const RGNDATA* pRgnData) PURE; \
+ STDMETHOD_(HRESULT,OnColorKeyChange)(THIS_ const COLORKEY* pColorKey) PURE; \
+ STDMETHOD_(HRESULT,OnPositionChange)(THIS_ const RECT* pSourceRect, const RECT* pDestinationRect) PURE; \
+ /*** IOverlayNotify2 methods ***/ \
+ STDMETHOD_(HRESULT,OnDisplayChange)(THIS_ HMONITOR hMonitor) PURE;
+
+HRESULT CALLBACK IOverlayNotify2_OnDisplayChange_Proxy(
+ IOverlayNotify2* This,
+ HMONITOR hMonitor);
+void __RPC_STUB IOverlayNotify2_OnDisplayChange_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+typedef IOverlayNotify2 *POVERLAYNOTIFY2;
+
+/*****************************************************************************
+ * IOverlay interface
+ */
+DEFINE_GUID(IID_IOverlay, 0x56a868a1, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IOverlay : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE GetPalette(
+ DWORD* pdwColors,
+ PALETTEENTRY** ppPalette) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE SetPalette(
+ DWORD dwColors,
+ PALETTEENTRY* pPalette) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetDefaultColorKey(
+ COLORKEY* pColorKey) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetColorKey(
+ COLORKEY* pColorKey) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE SetColorKey(
+ COLORKEY* pColorKey) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetWindowHandle(
+ HWND* pHwnd) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetClipList(
+ RECT* pSourceRect,
+ RECT* pDestinationRect,
+ RGNDATA** ppRgnData) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetVideoPosition(
+ RECT* pSourceRect,
+ RECT* pDestinationRect) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE Advise(
+ IOverlayNotify* pOverlayNotify,
+ DWORD dwInterests) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE Unadvise(
+ ) = 0;
+
+};
+#else
+typedef struct IOverlayVtbl IOverlayVtbl;
+struct IOverlay {
+ const IOverlayVtbl* lpVtbl;
+};
+struct IOverlayVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IOverlay* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IOverlay* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IOverlay* This);
+
+ /*** IOverlay methods ***/
+ HRESULT (STDMETHODCALLTYPE *GetPalette)(
+ IOverlay* This,
+ DWORD* pdwColors,
+ PALETTEENTRY** ppPalette);
+
+ HRESULT (STDMETHODCALLTYPE *SetPalette)(
+ IOverlay* This,
+ DWORD dwColors,
+ PALETTEENTRY* pPalette);
+
+ HRESULT (STDMETHODCALLTYPE *GetDefaultColorKey)(
+ IOverlay* This,
+ COLORKEY* pColorKey);
+
+ HRESULT (STDMETHODCALLTYPE *GetColorKey)(
+ IOverlay* This,
+ COLORKEY* pColorKey);
+
+ HRESULT (STDMETHODCALLTYPE *SetColorKey)(
+ IOverlay* This,
+ COLORKEY* pColorKey);
+
+ HRESULT (STDMETHODCALLTYPE *GetWindowHandle)(
+ IOverlay* This,
+ HWND* pHwnd);
+
+ HRESULT (STDMETHODCALLTYPE *GetClipList)(
+ IOverlay* This,
+ RECT* pSourceRect,
+ RECT* pDestinationRect,
+ RGNDATA** ppRgnData);
+
+ HRESULT (STDMETHODCALLTYPE *GetVideoPosition)(
+ IOverlay* This,
+ RECT* pSourceRect,
+ RECT* pDestinationRect);
+
+ HRESULT (STDMETHODCALLTYPE *Advise)(
+ IOverlay* This,
+ IOverlayNotify* pOverlayNotify,
+ DWORD dwInterests);
+
+ HRESULT (STDMETHODCALLTYPE *Unadvise)(
+ IOverlay* This);
+
+};
+
+/*** IUnknown methods ***/
+#define IOverlay_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IOverlay_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IOverlay_Release(p) (p)->lpVtbl->Release(p)
+/*** IOverlay methods ***/
+#define IOverlay_GetPalette(p,a,b) (p)->lpVtbl->GetPalette(p,a,b)
+#define IOverlay_SetPalette(p,a,b) (p)->lpVtbl->SetPalette(p,a,b)
+#define IOverlay_GetDefaultColorKey(p,a) (p)->lpVtbl->GetDefaultColorKey(p,a)
+#define IOverlay_GetColorKey(p,a) (p)->lpVtbl->GetColorKey(p,a)
+#define IOverlay_SetColorKey(p,a) (p)->lpVtbl->SetColorKey(p,a)
+#define IOverlay_GetWindowHandle(p,a) (p)->lpVtbl->GetWindowHandle(p,a)
+#define IOverlay_GetClipList(p,a,b,c) (p)->lpVtbl->GetClipList(p,a,b,c)
+#define IOverlay_GetVideoPosition(p,a,b) (p)->lpVtbl->GetVideoPosition(p,a,b)
+#define IOverlay_Advise(p,a,b) (p)->lpVtbl->Advise(p,a,b)
+#define IOverlay_Unadvise(p) (p)->lpVtbl->Unadvise(p)
+
+#endif
+
+#define IOverlay_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; \
+ /*** IOverlay methods ***/ \
+ STDMETHOD_(HRESULT,GetPalette)(THIS_ DWORD* pdwColors, PALETTEENTRY** ppPalette) PURE; \
+ STDMETHOD_(HRESULT,SetPalette)(THIS_ DWORD dwColors, PALETTEENTRY* pPalette) PURE; \
+ STDMETHOD_(HRESULT,GetDefaultColorKey)(THIS_ COLORKEY* pColorKey) PURE; \
+ STDMETHOD_(HRESULT,GetColorKey)(THIS_ COLORKEY* pColorKey) PURE; \
+ STDMETHOD_(HRESULT,SetColorKey)(THIS_ COLORKEY* pColorKey) PURE; \
+ STDMETHOD_(HRESULT,GetWindowHandle)(THIS_ HWND* pHwnd) PURE; \
+ STDMETHOD_(HRESULT,GetClipList)(THIS_ RECT* pSourceRect, RECT* pDestinationRect, RGNDATA** ppRgnData) PURE; \
+ STDMETHOD_(HRESULT,GetVideoPosition)(THIS_ RECT* pSourceRect, RECT* pDestinationRect) PURE; \
+ STDMETHOD_(HRESULT,Advise)(THIS_ IOverlayNotify* pOverlayNotify, DWORD dwInterests) PURE; \
+ STDMETHOD_(HRESULT,Unadvise)(THIS) PURE;
+
+HRESULT CALLBACK IOverlay_GetPalette_Proxy(
+ IOverlay* This,
+ DWORD* pdwColors,
+ PALETTEENTRY** ppPalette);
+void __RPC_STUB IOverlay_GetPalette_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IOverlay_SetPalette_Proxy(
+ IOverlay* This,
+ DWORD dwColors,
+ PALETTEENTRY* pPalette);
+void __RPC_STUB IOverlay_SetPalette_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IOverlay_GetDefaultColorKey_Proxy(
+ IOverlay* This,
+ COLORKEY* pColorKey);
+void __RPC_STUB IOverlay_GetDefaultColorKey_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IOverlay_GetColorKey_Proxy(
+ IOverlay* This,
+ COLORKEY* pColorKey);
+void __RPC_STUB IOverlay_GetColorKey_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IOverlay_SetColorKey_Proxy(
+ IOverlay* This,
+ COLORKEY* pColorKey);
+void __RPC_STUB IOverlay_SetColorKey_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IOverlay_GetWindowHandle_Proxy(
+ IOverlay* This,
+ HWND* pHwnd);
+void __RPC_STUB IOverlay_GetWindowHandle_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IOverlay_GetClipList_Proxy(
+ IOverlay* This,
+ RECT* pSourceRect,
+ RECT* pDestinationRect,
+ RGNDATA** ppRgnData);
+void __RPC_STUB IOverlay_GetClipList_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IOverlay_GetVideoPosition_Proxy(
+ IOverlay* This,
+ RECT* pSourceRect,
+ RECT* pDestinationRect);
+void __RPC_STUB IOverlay_GetVideoPosition_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IOverlay_Advise_Proxy(
+ IOverlay* This,
+ IOverlayNotify* pOverlayNotify,
+ DWORD dwInterests);
+void __RPC_STUB IOverlay_Advise_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IOverlay_Unadvise_Proxy(
+ IOverlay* This);
+void __RPC_STUB IOverlay_Unadvise_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+typedef IOverlay *POVERLAY;
+
+/*****************************************************************************
+ * IMediaEventSink interface
+ */
+DEFINE_GUID(IID_IMediaEventSink, 0x56a868a2, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IMediaEventSink : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE Notify(
+ long EventCode,
+ LONG_PTR EventParam1,
+ LONG_PTR EventParam2) = 0;
+
+};
+#else
+typedef struct IMediaEventSinkVtbl IMediaEventSinkVtbl;
+struct IMediaEventSink {
+ const IMediaEventSinkVtbl* lpVtbl;
+};
+struct IMediaEventSinkVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IMediaEventSink* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IMediaEventSink* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IMediaEventSink* This);
+
+ /*** IMediaEventSink methods ***/
+ HRESULT (STDMETHODCALLTYPE *Notify)(
+ IMediaEventSink* This,
+ long EventCode,
+ LONG_PTR EventParam1,
+ LONG_PTR EventParam2);
+
+};
+
+/*** IUnknown methods ***/
+#define IMediaEventSink_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IMediaEventSink_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IMediaEventSink_Release(p) (p)->lpVtbl->Release(p)
+/*** IMediaEventSink methods ***/
+#define IMediaEventSink_Notify(p,a,b,c) (p)->lpVtbl->Notify(p,a,b,c)
+
+#endif
+
+#define IMediaEventSink_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; \
+ /*** IMediaEventSink methods ***/ \
+ STDMETHOD_(HRESULT,Notify)(THIS_ long EventCode, LONG_PTR EventParam1, LONG_PTR EventParam2) PURE;
+
+HRESULT CALLBACK IMediaEventSink_Notify_Proxy(
+ IMediaEventSink* This,
+ long EventCode,
+ LONG_PTR EventParam1,
+ LONG_PTR EventParam2);
+void __RPC_STUB IMediaEventSink_Notify_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+typedef IMediaEventSink *PMEDIAEVENTSINK;
+
+/*****************************************************************************
+ * IFileSourceFilter interface
+ */
+DEFINE_GUID(IID_IFileSourceFilter, 0x56a868a6, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IFileSourceFilter : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE Load(
+ LPCOLESTR pszFileName,
+ const AM_MEDIA_TYPE* pmt) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetCurFile(
+ LPOLESTR* ppszFileName,
+ AM_MEDIA_TYPE* pmt) = 0;
+
+};
+#else
+typedef struct IFileSourceFilterVtbl IFileSourceFilterVtbl;
+struct IFileSourceFilter {
+ const IFileSourceFilterVtbl* lpVtbl;
+};
+struct IFileSourceFilterVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IFileSourceFilter* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IFileSourceFilter* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IFileSourceFilter* This);
+
+ /*** IFileSourceFilter methods ***/
+ HRESULT (STDMETHODCALLTYPE *Load)(
+ IFileSourceFilter* This,
+ LPCOLESTR pszFileName,
+ const AM_MEDIA_TYPE* pmt);
+
+ HRESULT (STDMETHODCALLTYPE *GetCurFile)(
+ IFileSourceFilter* This,
+ LPOLESTR* ppszFileName,
+ AM_MEDIA_TYPE* pmt);
+
+};
+
+/*** IUnknown methods ***/
+#define IFileSourceFilter_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IFileSourceFilter_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IFileSourceFilter_Release(p) (p)->lpVtbl->Release(p)
+/*** IFileSourceFilter methods ***/
+#define IFileSourceFilter_Load(p,a,b) (p)->lpVtbl->Load(p,a,b)
+#define IFileSourceFilter_GetCurFile(p,a,b) (p)->lpVtbl->GetCurFile(p,a,b)
+
+#endif
+
+#define IFileSourceFilter_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; \
+ /*** IFileSourceFilter methods ***/ \
+ STDMETHOD_(HRESULT,Load)(THIS_ LPCOLESTR pszFileName, const AM_MEDIA_TYPE* pmt) PURE; \
+ STDMETHOD_(HRESULT,GetCurFile)(THIS_ LPOLESTR* ppszFileName, AM_MEDIA_TYPE* pmt) PURE;
+
+HRESULT CALLBACK IFileSourceFilter_Load_Proxy(
+ IFileSourceFilter* This,
+ LPCOLESTR pszFileName,
+ const AM_MEDIA_TYPE* pmt);
+void __RPC_STUB IFileSourceFilter_Load_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFileSourceFilter_GetCurFile_Proxy(
+ IFileSourceFilter* This,
+ LPOLESTR* ppszFileName,
+ AM_MEDIA_TYPE* pmt);
+void __RPC_STUB IFileSourceFilter_GetCurFile_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+typedef IFileSourceFilter *PFILTERFILESOURCE;
+
+/*****************************************************************************
+ * IFileSinkFilter interface
+ */
+DEFINE_GUID(IID_IFileSinkFilter, 0xa2104830, 0x7c70, 0x11cf, 0x8b,0xce, 0x00,0xaa,0x00,0xa3,0xf1,0xa6);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IFileSinkFilter : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE SetFileName(
+ LPCOLESTR pszFileName,
+ const AM_MEDIA_TYPE* pmt) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetCurFile(
+ LPOLESTR* ppszFileName,
+ AM_MEDIA_TYPE* pmt) = 0;
+
+};
+#else
+typedef struct IFileSinkFilterVtbl IFileSinkFilterVtbl;
+struct IFileSinkFilter {
+ const IFileSinkFilterVtbl* lpVtbl;
+};
+struct IFileSinkFilterVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IFileSinkFilter* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IFileSinkFilter* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IFileSinkFilter* This);
+
+ /*** IFileSinkFilter methods ***/
+ HRESULT (STDMETHODCALLTYPE *SetFileName)(
+ IFileSinkFilter* This,
+ LPCOLESTR pszFileName,
+ const AM_MEDIA_TYPE* pmt);
+
+ HRESULT (STDMETHODCALLTYPE *GetCurFile)(
+ IFileSinkFilter* This,
+ LPOLESTR* ppszFileName,
+ AM_MEDIA_TYPE* pmt);
+
+};
+
+/*** IUnknown methods ***/
+#define IFileSinkFilter_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IFileSinkFilter_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IFileSinkFilter_Release(p) (p)->lpVtbl->Release(p)
+/*** IFileSinkFilter methods ***/
+#define IFileSinkFilter_SetFileName(p,a,b) (p)->lpVtbl->SetFileName(p,a,b)
+#define IFileSinkFilter_GetCurFile(p,a,b) (p)->lpVtbl->GetCurFile(p,a,b)
+
+#endif
+
+#define IFileSinkFilter_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; \
+ /*** IFileSinkFilter methods ***/ \
+ STDMETHOD_(HRESULT,SetFileName)(THIS_ LPCOLESTR pszFileName, const AM_MEDIA_TYPE* pmt) PURE; \
+ STDMETHOD_(HRESULT,GetCurFile)(THIS_ LPOLESTR* ppszFileName, AM_MEDIA_TYPE* pmt) PURE;
+
+HRESULT CALLBACK IFileSinkFilter_SetFileName_Proxy(
+ IFileSinkFilter* This,
+ LPCOLESTR pszFileName,
+ const AM_MEDIA_TYPE* pmt);
+void __RPC_STUB IFileSinkFilter_SetFileName_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFileSinkFilter_GetCurFile_Proxy(
+ IFileSinkFilter* This,
+ LPOLESTR* ppszFileName,
+ AM_MEDIA_TYPE* pmt);
+void __RPC_STUB IFileSinkFilter_GetCurFile_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+typedef IFileSinkFilter *PFILTERFILESINK;
+
+/*****************************************************************************
+ * IFileSinkFilter2 interface
+ */
+DEFINE_GUID(IID_IFileSinkFilter2, 0x00855b90, 0xce1b, 0x11d0, 0xbd,0x4f, 0x00,0xa0,0xc9,0x11,0xce,0x86);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IFileSinkFilter2 : public IFileSinkFilter
+{
+ virtual HRESULT STDMETHODCALLTYPE SetMode(
+ DWORD dwFlags) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetMode(
+ DWORD* pdwFlags) = 0;
+
+};
+#else
+typedef struct IFileSinkFilter2Vtbl IFileSinkFilter2Vtbl;
+struct IFileSinkFilter2 {
+ const IFileSinkFilter2Vtbl* lpVtbl;
+};
+struct IFileSinkFilter2Vtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IFileSinkFilter2* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IFileSinkFilter2* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IFileSinkFilter2* This);
+
+ /*** IFileSinkFilter methods ***/
+ HRESULT (STDMETHODCALLTYPE *SetFileName)(
+ IFileSinkFilter2* This,
+ LPCOLESTR pszFileName,
+ const AM_MEDIA_TYPE* pmt);
+
+ HRESULT (STDMETHODCALLTYPE *GetCurFile)(
+ IFileSinkFilter2* This,
+ LPOLESTR* ppszFileName,
+ AM_MEDIA_TYPE* pmt);
+
+ /*** IFileSinkFilter2 methods ***/
+ HRESULT (STDMETHODCALLTYPE *SetMode)(
+ IFileSinkFilter2* This,
+ DWORD dwFlags);
+
+ HRESULT (STDMETHODCALLTYPE *GetMode)(
+ IFileSinkFilter2* This,
+ DWORD* pdwFlags);
+
+};
+
+/*** IUnknown methods ***/
+#define IFileSinkFilter2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IFileSinkFilter2_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IFileSinkFilter2_Release(p) (p)->lpVtbl->Release(p)
+/*** IFileSinkFilter methods ***/
+#define IFileSinkFilter2_SetFileName(p,a,b) (p)->lpVtbl->SetFileName(p,a,b)
+#define IFileSinkFilter2_GetCurFile(p,a,b) (p)->lpVtbl->GetCurFile(p,a,b)
+/*** IFileSinkFilter2 methods ***/
+#define IFileSinkFilter2_SetMode(p,a) (p)->lpVtbl->SetMode(p,a)
+#define IFileSinkFilter2_GetMode(p,a) (p)->lpVtbl->GetMode(p,a)
+
+#endif
+
+#define IFileSinkFilter2_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; \
+ /*** IFileSinkFilter methods ***/ \
+ STDMETHOD_(HRESULT,SetFileName)(THIS_ LPCOLESTR pszFileName, const AM_MEDIA_TYPE* pmt) PURE; \
+ STDMETHOD_(HRESULT,GetCurFile)(THIS_ LPOLESTR* ppszFileName, AM_MEDIA_TYPE* pmt) PURE; \
+ /*** IFileSinkFilter2 methods ***/ \
+ STDMETHOD_(HRESULT,SetMode)(THIS_ DWORD dwFlags) PURE; \
+ STDMETHOD_(HRESULT,GetMode)(THIS_ DWORD* pdwFlags) PURE;
+
+HRESULT CALLBACK IFileSinkFilter2_SetMode_Proxy(
+ IFileSinkFilter2* This,
+ DWORD dwFlags);
+void __RPC_STUB IFileSinkFilter2_SetMode_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFileSinkFilter2_GetMode_Proxy(
+ IFileSinkFilter2* This,
+ DWORD* pdwFlags);
+void __RPC_STUB IFileSinkFilter2_GetMode_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+typedef IFileSinkFilter2 *PFILESINKFILTER2;
+
+typedef enum {
+ AM_FILE_OVERWRITE = 0x1
+} AM_FILESINK_FLAGS;
+
+/*****************************************************************************
+ * IGraphBuilder interface
+ */
+DEFINE_GUID(IID_IGraphBuilder, 0x56a868a9, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IGraphBuilder : public IFilterGraph
+{
+ virtual HRESULT STDMETHODCALLTYPE Connect(
+ IPin* ppinOut,
+ IPin* ppinIn) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE Render(
+ IPin* ppinOut) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE RenderFile(
+ LPCWSTR lpcwstrFile,
+ LPCWSTR lpcwstrPlayList) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE AddSourceFilter(
+ LPCWSTR lpcwstrFileName,
+ LPCWSTR lpcwstrFilterName,
+ IBaseFilter** ppFilter) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE SetLogFile(
+ DWORD_PTR hFile) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE Abort(
+ ) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE ShouldOperationContinue(
+ ) = 0;
+
+};
+#else
+typedef struct IGraphBuilderVtbl IGraphBuilderVtbl;
+struct IGraphBuilder {
+ const IGraphBuilderVtbl* lpVtbl;
+};
+struct IGraphBuilderVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IGraphBuilder* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IGraphBuilder* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IGraphBuilder* This);
+
+ /*** IFilterGraph methods ***/
+ HRESULT (STDMETHODCALLTYPE *AddFilter)(
+ IGraphBuilder* This,
+ IBaseFilter* pFilter,
+ LPCWSTR pName);
+
+ HRESULT (STDMETHODCALLTYPE *RemoveFilter)(
+ IGraphBuilder* This,
+ IBaseFilter* pFilter);
+
+ HRESULT (STDMETHODCALLTYPE *EnumFilters)(
+ IGraphBuilder* This,
+ IEnumFilters** ppEnum);
+
+ HRESULT (STDMETHODCALLTYPE *FindFilterByName)(
+ IGraphBuilder* This,
+ LPCWSTR pName,
+ IBaseFilter** ppFilter);
+
+ HRESULT (STDMETHODCALLTYPE *ConnectDirect)(
+ IGraphBuilder* This,
+ IPin* ppinOut,
+ IPin* ppinIn,
+ const AM_MEDIA_TYPE* pmt);
+
+ HRESULT (STDMETHODCALLTYPE *Reconnect)(
+ IGraphBuilder* This,
+ IPin* ppin);
+
+ HRESULT (STDMETHODCALLTYPE *Disconnect)(
+ IGraphBuilder* This,
+ IPin* ppin);
+
+ HRESULT (STDMETHODCALLTYPE *SetDefaultSyncSource)(
+ IGraphBuilder* This);
+
+ /*** IGraphBuilder methods ***/
+ HRESULT (STDMETHODCALLTYPE *Connect)(
+ IGraphBuilder* This,
+ IPin* ppinOut,
+ IPin* ppinIn);
+
+ HRESULT (STDMETHODCALLTYPE *Render)(
+ IGraphBuilder* This,
+ IPin* ppinOut);
+
+ HRESULT (STDMETHODCALLTYPE *RenderFile)(
+ IGraphBuilder* This,
+ LPCWSTR lpcwstrFile,
+ LPCWSTR lpcwstrPlayList);
+
+ HRESULT (STDMETHODCALLTYPE *AddSourceFilter)(
+ IGraphBuilder* This,
+ LPCWSTR lpcwstrFileName,
+ LPCWSTR lpcwstrFilterName,
+ IBaseFilter** ppFilter);
+
+ HRESULT (STDMETHODCALLTYPE *SetLogFile)(
+ IGraphBuilder* This,
+ DWORD_PTR hFile);
+
+ HRESULT (STDMETHODCALLTYPE *Abort)(
+ IGraphBuilder* This);
+
+ HRESULT (STDMETHODCALLTYPE *ShouldOperationContinue)(
+ IGraphBuilder* This);
+
+};
+
+/*** IUnknown methods ***/
+#define IGraphBuilder_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IGraphBuilder_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IGraphBuilder_Release(p) (p)->lpVtbl->Release(p)
+/*** IFilterGraph methods ***/
+#define IGraphBuilder_AddFilter(p,a,b) (p)->lpVtbl->AddFilter(p,a,b)
+#define IGraphBuilder_RemoveFilter(p,a) (p)->lpVtbl->RemoveFilter(p,a)
+#define IGraphBuilder_EnumFilters(p,a) (p)->lpVtbl->EnumFilters(p,a)
+#define IGraphBuilder_FindFilterByName(p,a,b) (p)->lpVtbl->FindFilterByName(p,a,b)
+#define IGraphBuilder_ConnectDirect(p,a,b,c) (p)->lpVtbl->ConnectDirect(p,a,b,c)
+#define IGraphBuilder_Reconnect(p,a) (p)->lpVtbl->Reconnect(p,a)
+#define IGraphBuilder_Disconnect(p,a) (p)->lpVtbl->Disconnect(p,a)
+#define IGraphBuilder_SetDefaultSyncSource(p) (p)->lpVtbl->SetDefaultSyncSource(p)
+/*** IGraphBuilder methods ***/
+#define IGraphBuilder_Connect(p,a,b) (p)->lpVtbl->Connect(p,a,b)
+#define IGraphBuilder_Render(p,a) (p)->lpVtbl->Render(p,a)
+#define IGraphBuilder_RenderFile(p,a,b) (p)->lpVtbl->RenderFile(p,a,b)
+#define IGraphBuilder_AddSourceFilter(p,a,b,c) (p)->lpVtbl->AddSourceFilter(p,a,b,c)
+#define IGraphBuilder_SetLogFile(p,a) (p)->lpVtbl->SetLogFile(p,a)
+#define IGraphBuilder_Abort(p) (p)->lpVtbl->Abort(p)
+#define IGraphBuilder_ShouldOperationContinue(p) (p)->lpVtbl->ShouldOperationContinue(p)
+
+#endif
+
+#define IGraphBuilder_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; \
+ /*** IFilterGraph methods ***/ \
+ STDMETHOD_(HRESULT,AddFilter)(THIS_ IBaseFilter* pFilter, LPCWSTR pName) PURE; \
+ STDMETHOD_(HRESULT,RemoveFilter)(THIS_ IBaseFilter* pFilter) PURE; \
+ STDMETHOD_(HRESULT,EnumFilters)(THIS_ IEnumFilters** ppEnum) PURE; \
+ STDMETHOD_(HRESULT,FindFilterByName)(THIS_ LPCWSTR pName, IBaseFilter** ppFilter) PURE; \
+ STDMETHOD_(HRESULT,ConnectDirect)(THIS_ IPin* ppinOut, IPin* ppinIn, const AM_MEDIA_TYPE* pmt) PURE; \
+ STDMETHOD_(HRESULT,Reconnect)(THIS_ IPin* ppin) PURE; \
+ STDMETHOD_(HRESULT,Disconnect)(THIS_ IPin* ppin) PURE; \
+ STDMETHOD_(HRESULT,SetDefaultSyncSource)(THIS) PURE; \
+ /*** IGraphBuilder methods ***/ \
+ STDMETHOD_(HRESULT,Connect)(THIS_ IPin* ppinOut, IPin* ppinIn) PURE; \
+ STDMETHOD_(HRESULT,Render)(THIS_ IPin* ppinOut) PURE; \
+ STDMETHOD_(HRESULT,RenderFile)(THIS_ LPCWSTR lpcwstrFile, LPCWSTR lpcwstrPlayList) PURE; \
+ STDMETHOD_(HRESULT,AddSourceFilter)(THIS_ LPCWSTR lpcwstrFileName, LPCWSTR lpcwstrFilterName, IBaseFilter** ppFilter) PURE; \
+ STDMETHOD_(HRESULT,SetLogFile)(THIS_ DWORD_PTR hFile) PURE; \
+ STDMETHOD_(HRESULT,Abort)(THIS) PURE; \
+ STDMETHOD_(HRESULT,ShouldOperationContinue)(THIS) PURE;
+
+HRESULT CALLBACK IGraphBuilder_Connect_Proxy(
+ IGraphBuilder* This,
+ IPin* ppinOut,
+ IPin* ppinIn);
+void __RPC_STUB IGraphBuilder_Connect_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IGraphBuilder_Render_Proxy(
+ IGraphBuilder* This,
+ IPin* ppinOut);
+void __RPC_STUB IGraphBuilder_Render_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IGraphBuilder_RenderFile_Proxy(
+ IGraphBuilder* This,
+ LPCWSTR lpcwstrFile,
+ LPCWSTR lpcwstrPlayList);
+void __RPC_STUB IGraphBuilder_RenderFile_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IGraphBuilder_AddSourceFilter_Proxy(
+ IGraphBuilder* This,
+ LPCWSTR lpcwstrFileName,
+ LPCWSTR lpcwstrFilterName,
+ IBaseFilter** ppFilter);
+void __RPC_STUB IGraphBuilder_AddSourceFilter_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IGraphBuilder_SetLogFile_Proxy(
+ IGraphBuilder* This,
+ DWORD_PTR hFile);
+void __RPC_STUB IGraphBuilder_SetLogFile_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IGraphBuilder_Abort_Proxy(
+ IGraphBuilder* This);
+void __RPC_STUB IGraphBuilder_Abort_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IGraphBuilder_ShouldOperationContinue_Proxy(
+ IGraphBuilder* This);
+void __RPC_STUB IGraphBuilder_ShouldOperationContinue_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+/*****************************************************************************
+ * ICaptureGraphBuilder interface
+ */
+DEFINE_GUID(IID_ICaptureGraphBuilder, 0xbf87b6e0, 0x8c27, 0x11d0, 0xb3,0xf0, 0x00,0xaa,0x00,0x37,0x61,0xc5);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct ICaptureGraphBuilder : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE SetFiltergraph(
+ IGraphBuilder* pfg) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetFiltergraph(
+ IGraphBuilder** ppfg) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE SetOutputFileName(
+ const GUID* pType,
+ LPCOLESTR lpstrFile,
+ IBaseFilter** ppf,
+ IFileSinkFilter** ppSink) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE FindInterface(
+ const GUID* pCategory,
+ IBaseFilter* pf,
+ REFIID riid,
+ void** ppint) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE RenderStream(
+ const GUID* pCategory,
+ IUnknown* pSource,
+ IBaseFilter* pfCompressor,
+ IBaseFilter* pfRenderer) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE ControlStream(
+ const GUID* pCategory,
+ IBaseFilter* pFilter,
+ REFERENCE_TIME* pstart,
+ REFERENCE_TIME* pstop,
+ WORD wStartCookie,
+ WORD wStopCookie) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE AllocCapFile(
+ LPCOLESTR lpstr,
+ DWORDLONG dwlSize) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE CopyCaptureFile(
+ LPOLESTR lpwstrOld,
+ LPOLESTR lpwstrNew,
+ int fAllowEscAbort,
+ IAMCopyCaptureFileProgress* pCallback) = 0;
+
+};
+#else
+typedef struct ICaptureGraphBuilderVtbl ICaptureGraphBuilderVtbl;
+struct ICaptureGraphBuilder {
+ const ICaptureGraphBuilderVtbl* lpVtbl;
+};
+struct ICaptureGraphBuilderVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ ICaptureGraphBuilder* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ ICaptureGraphBuilder* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ ICaptureGraphBuilder* This);
+
+ /*** ICaptureGraphBuilder methods ***/
+ HRESULT (STDMETHODCALLTYPE *SetFiltergraph)(
+ ICaptureGraphBuilder* This,
+ IGraphBuilder* pfg);
+
+ HRESULT (STDMETHODCALLTYPE *GetFiltergraph)(
+ ICaptureGraphBuilder* This,
+ IGraphBuilder** ppfg);
+
+ HRESULT (STDMETHODCALLTYPE *SetOutputFileName)(
+ ICaptureGraphBuilder* This,
+ const GUID* pType,
+ LPCOLESTR lpstrFile,
+ IBaseFilter** ppf,
+ IFileSinkFilter** ppSink);
+
+ HRESULT (STDMETHODCALLTYPE *FindInterface)(
+ ICaptureGraphBuilder* This,
+ const GUID* pCategory,
+ IBaseFilter* pf,
+ REFIID riid,
+ void** ppint);
+
+ HRESULT (STDMETHODCALLTYPE *RenderStream)(
+ ICaptureGraphBuilder* This,
+ const GUID* pCategory,
+ IUnknown* pSource,
+ IBaseFilter* pfCompressor,
+ IBaseFilter* pfRenderer);
+
+ HRESULT (STDMETHODCALLTYPE *ControlStream)(
+ ICaptureGraphBuilder* This,
+ const GUID* pCategory,
+ IBaseFilter* pFilter,
+ REFERENCE_TIME* pstart,
+ REFERENCE_TIME* pstop,
+ WORD wStartCookie,
+ WORD wStopCookie);
+
+ HRESULT (STDMETHODCALLTYPE *AllocCapFile)(
+ ICaptureGraphBuilder* This,
+ LPCOLESTR lpstr,
+ DWORDLONG dwlSize);
+
+ HRESULT (STDMETHODCALLTYPE *CopyCaptureFile)(
+ ICaptureGraphBuilder* This,
+ LPOLESTR lpwstrOld,
+ LPOLESTR lpwstrNew,
+ int fAllowEscAbort,
+ IAMCopyCaptureFileProgress* pCallback);
+
+};
+
+/*** IUnknown methods ***/
+#define ICaptureGraphBuilder_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define ICaptureGraphBuilder_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define ICaptureGraphBuilder_Release(p) (p)->lpVtbl->Release(p)
+/*** ICaptureGraphBuilder methods ***/
+#define ICaptureGraphBuilder_SetFiltergraph(p,a) (p)->lpVtbl->SetFiltergraph(p,a)
+#define ICaptureGraphBuilder_GetFiltergraph(p,a) (p)->lpVtbl->GetFiltergraph(p,a)
+#define ICaptureGraphBuilder_SetOutputFileName(p,a,b,c,d) (p)->lpVtbl->SetOutputFileName(p,a,b,c,d)
+#define ICaptureGraphBuilder_FindInterface(p,a,b,c,d) (p)->lpVtbl->FindInterface(p,a,b,c,d)
+#define ICaptureGraphBuilder_RenderStream(p,a,b,c,d) (p)->lpVtbl->RenderStream(p,a,b,c,d)
+#define ICaptureGraphBuilder_ControlStream(p,a,b,c,d,e,f) (p)->lpVtbl->ControlStream(p,a,b,c,d,e,f)
+#define ICaptureGraphBuilder_AllocCapFile(p,a,b) (p)->lpVtbl->AllocCapFile(p,a,b)
+#define ICaptureGraphBuilder_CopyCaptureFile(p,a,b,c,d) (p)->lpVtbl->CopyCaptureFile(p,a,b,c,d)
+
+#endif
+
+#define ICaptureGraphBuilder_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; \
+ /*** ICaptureGraphBuilder methods ***/ \
+ STDMETHOD_(HRESULT,SetFiltergraph)(THIS_ IGraphBuilder* pfg) PURE; \
+ STDMETHOD_(HRESULT,GetFiltergraph)(THIS_ IGraphBuilder** ppfg) PURE; \
+ STDMETHOD_(HRESULT,SetOutputFileName)(THIS_ const GUID* pType, LPCOLESTR lpstrFile, IBaseFilter** ppf, IFileSinkFilter** ppSink) PURE; \
+ STDMETHOD_(HRESULT,FindInterface)(THIS_ const GUID* pCategory, IBaseFilter* pf, REFIID riid, void** ppint) PURE; \
+ STDMETHOD_(HRESULT,RenderStream)(THIS_ const GUID* pCategory, IUnknown* pSource, IBaseFilter* pfCompressor, IBaseFilter* pfRenderer) PURE; \
+ STDMETHOD_(HRESULT,ControlStream)(THIS_ const GUID* pCategory, IBaseFilter* pFilter, REFERENCE_TIME* pstart, REFERENCE_TIME* pstop, WORD wStartCookie, WORD wStopCookie) PURE; \
+ STDMETHOD_(HRESULT,AllocCapFile)(THIS_ LPCOLESTR lpstr, DWORDLONG dwlSize) PURE; \
+ STDMETHOD_(HRESULT,CopyCaptureFile)(THIS_ LPOLESTR lpwstrOld, LPOLESTR lpwstrNew, int fAllowEscAbort, IAMCopyCaptureFileProgress* pCallback) PURE;
+
+HRESULT CALLBACK ICaptureGraphBuilder_SetFiltergraph_Proxy(
+ ICaptureGraphBuilder* This,
+ IGraphBuilder* pfg);
+void __RPC_STUB ICaptureGraphBuilder_SetFiltergraph_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK ICaptureGraphBuilder_GetFiltergraph_Proxy(
+ ICaptureGraphBuilder* This,
+ IGraphBuilder** ppfg);
+void __RPC_STUB ICaptureGraphBuilder_GetFiltergraph_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK ICaptureGraphBuilder_SetOutputFileName_Proxy(
+ ICaptureGraphBuilder* This,
+ const GUID* pType,
+ LPCOLESTR lpstrFile,
+ IBaseFilter** ppf,
+ IFileSinkFilter** ppSink);
+void __RPC_STUB ICaptureGraphBuilder_SetOutputFileName_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK ICaptureGraphBuilder_RemoteFindInterface_Proxy(
+ ICaptureGraphBuilder* This,
+ const GUID* pCategory,
+ IBaseFilter* pf,
+ REFIID riid,
+ IUnknown** ppint);
+void __RPC_STUB ICaptureGraphBuilder_RemoteFindInterface_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK ICaptureGraphBuilder_FindInterface_Proxy(
+ ICaptureGraphBuilder* This,
+ const GUID* pCategory,
+ IBaseFilter* pf,
+ REFIID riid,
+ void** ppint);
+HRESULT __RPC_STUB ICaptureGraphBuilder_FindInterface_Stub(
+ ICaptureGraphBuilder* This,
+ const GUID* pCategory,
+ IBaseFilter* pf,
+ REFIID riid,
+ IUnknown** ppint);
+HRESULT CALLBACK ICaptureGraphBuilder_RenderStream_Proxy(
+ ICaptureGraphBuilder* This,
+ const GUID* pCategory,
+ IUnknown* pSource,
+ IBaseFilter* pfCompressor,
+ IBaseFilter* pfRenderer);
+void __RPC_STUB ICaptureGraphBuilder_RenderStream_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK ICaptureGraphBuilder_ControlStream_Proxy(
+ ICaptureGraphBuilder* This,
+ const GUID* pCategory,
+ IBaseFilter* pFilter,
+ REFERENCE_TIME* pstart,
+ REFERENCE_TIME* pstop,
+ WORD wStartCookie,
+ WORD wStopCookie);
+void __RPC_STUB ICaptureGraphBuilder_ControlStream_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK ICaptureGraphBuilder_AllocCapFile_Proxy(
+ ICaptureGraphBuilder* This,
+ LPCOLESTR lpstr,
+ DWORDLONG dwlSize);
+void __RPC_STUB ICaptureGraphBuilder_AllocCapFile_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK ICaptureGraphBuilder_CopyCaptureFile_Proxy(
+ ICaptureGraphBuilder* This,
+ LPOLESTR lpwstrOld,
+ LPOLESTR lpwstrNew,
+ int fAllowEscAbort,
+ IAMCopyCaptureFileProgress* pCallback);
+void __RPC_STUB ICaptureGraphBuilder_CopyCaptureFile_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+/*****************************************************************************
+ * IAMCopyCaptureFileProgress interface
+ */
+DEFINE_GUID(IID_IAMCopyCaptureFileProgress, 0x670d1d20, 0xa068, 0x11d0, 0xb3,0xf0, 0x00,0xaa,0x00,0x37,0x61,0xc5);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IAMCopyCaptureFileProgress : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE Progress(
+ int iProgress) = 0;
+
+};
+#else
+typedef struct IAMCopyCaptureFileProgressVtbl IAMCopyCaptureFileProgressVtbl;
+struct IAMCopyCaptureFileProgress {
+ const IAMCopyCaptureFileProgressVtbl* lpVtbl;
+};
+struct IAMCopyCaptureFileProgressVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IAMCopyCaptureFileProgress* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IAMCopyCaptureFileProgress* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IAMCopyCaptureFileProgress* This);
+
+ /*** IAMCopyCaptureFileProgress methods ***/
+ HRESULT (STDMETHODCALLTYPE *Progress)(
+ IAMCopyCaptureFileProgress* This,
+ int iProgress);
+
+};
+
+/*** IUnknown methods ***/
+#define IAMCopyCaptureFileProgress_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IAMCopyCaptureFileProgress_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IAMCopyCaptureFileProgress_Release(p) (p)->lpVtbl->Release(p)
+/*** IAMCopyCaptureFileProgress methods ***/
+#define IAMCopyCaptureFileProgress_Progress(p,a) (p)->lpVtbl->Progress(p,a)
+
+#endif
+
+#define IAMCopyCaptureFileProgress_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; \
+ /*** IAMCopyCaptureFileProgress methods ***/ \
+ STDMETHOD_(HRESULT,Progress)(THIS_ int iProgress) PURE;
+
+HRESULT CALLBACK IAMCopyCaptureFileProgress_Progress_Proxy(
+ IAMCopyCaptureFileProgress* This,
+ int iProgress);
+void __RPC_STUB IAMCopyCaptureFileProgress_Progress_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+/*****************************************************************************
+ * ICaptureGraphBuilder2 interface
+ */
+DEFINE_GUID(IID_ICaptureGraphBuilder2, 0x93e5a4e0, 0x2d50, 0x11d2, 0xab,0xfa, 0x00,0xa0,0xc9,0xc6,0xe3,0x8d);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct ICaptureGraphBuilder2 : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE SetFiltergraph(
+ IGraphBuilder* pfg) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetFiltergraph(
+ IGraphBuilder** ppfg) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE SetOutputFileName(
+ const GUID* pType,
+ LPCOLESTR lpstrFile,
+ IBaseFilter** ppf,
+ IFileSinkFilter** ppSink) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE FindInterface(
+ const GUID* pCategory,
+ const GUID* pType,
+ IBaseFilter* pf,
+ REFIID riid,
+ void** ppint) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE RenderStream(
+ const GUID* pCategory,
+ const GUID* pType,
+ IUnknown* pSource,
+ IBaseFilter* pfCompressor,
+ IBaseFilter* pfRenderer) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE ControlStream(
+ const GUID* pCategory,
+ const GUID* pType,
+ IBaseFilter* pFilter,
+ REFERENCE_TIME* pstart,
+ REFERENCE_TIME* pstop,
+ WORD wStartCookie,
+ WORD wStopCookie) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE AllocCapFile(
+ LPCOLESTR lpstr,
+ DWORDLONG dwlSize) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE CopyCaptureFile(
+ LPOLESTR lpwstrOld,
+ LPOLESTR lpwstrNew,
+ int fAllowEscAbort,
+ IAMCopyCaptureFileProgress* pCallback) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE FindPin(
+ IUnknown* pSource,
+ PIN_DIRECTION pindir,
+ const GUID* pCategory,
+ const GUID* pType,
+ BOOL fUnconnected,
+ int num,
+ IPin** ppPin) = 0;
+
+};
+#else
+typedef struct ICaptureGraphBuilder2Vtbl ICaptureGraphBuilder2Vtbl;
+struct ICaptureGraphBuilder2 {
+ const ICaptureGraphBuilder2Vtbl* lpVtbl;
+};
+struct ICaptureGraphBuilder2Vtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ ICaptureGraphBuilder2* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ ICaptureGraphBuilder2* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ ICaptureGraphBuilder2* This);
+
+ /*** ICaptureGraphBuilder2 methods ***/
+ HRESULT (STDMETHODCALLTYPE *SetFiltergraph)(
+ ICaptureGraphBuilder2* This,
+ IGraphBuilder* pfg);
+
+ HRESULT (STDMETHODCALLTYPE *GetFiltergraph)(
+ ICaptureGraphBuilder2* This,
+ IGraphBuilder** ppfg);
+
+ HRESULT (STDMETHODCALLTYPE *SetOutputFileName)(
+ ICaptureGraphBuilder2* This,
+ const GUID* pType,
+ LPCOLESTR lpstrFile,
+ IBaseFilter** ppf,
+ IFileSinkFilter** ppSink);
+
+ HRESULT (STDMETHODCALLTYPE *FindInterface)(
+ ICaptureGraphBuilder2* This,
+ const GUID* pCategory,
+ const GUID* pType,
+ IBaseFilter* pf,
+ REFIID riid,
+ void** ppint);
+
+ HRESULT (STDMETHODCALLTYPE *RenderStream)(
+ ICaptureGraphBuilder2* This,
+ const GUID* pCategory,
+ const GUID* pType,
+ IUnknown* pSource,
+ IBaseFilter* pfCompressor,
+ IBaseFilter* pfRenderer);
+
+ HRESULT (STDMETHODCALLTYPE *ControlStream)(
+ ICaptureGraphBuilder2* This,
+ const GUID* pCategory,
+ const GUID* pType,
+ IBaseFilter* pFilter,
+ REFERENCE_TIME* pstart,
+ REFERENCE_TIME* pstop,
+ WORD wStartCookie,
+ WORD wStopCookie);
+
+ HRESULT (STDMETHODCALLTYPE *AllocCapFile)(
+ ICaptureGraphBuilder2* This,
+ LPCOLESTR lpstr,
+ DWORDLONG dwlSize);
+
+ HRESULT (STDMETHODCALLTYPE *CopyCaptureFile)(
+ ICaptureGraphBuilder2* This,
+ LPOLESTR lpwstrOld,
+ LPOLESTR lpwstrNew,
+ int fAllowEscAbort,
+ IAMCopyCaptureFileProgress* pCallback);
+
+ HRESULT (STDMETHODCALLTYPE *FindPin)(
+ ICaptureGraphBuilder2* This,
+ IUnknown* pSource,
+ PIN_DIRECTION pindir,
+ const GUID* pCategory,
+ const GUID* pType,
+ BOOL fUnconnected,
+ int num,
+ IPin** ppPin);
+
+};
+
+/*** IUnknown methods ***/
+#define ICaptureGraphBuilder2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define ICaptureGraphBuilder2_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define ICaptureGraphBuilder2_Release(p) (p)->lpVtbl->Release(p)
+/*** ICaptureGraphBuilder2 methods ***/
+#define ICaptureGraphBuilder2_SetFiltergraph(p,a) (p)->lpVtbl->SetFiltergraph(p,a)
+#define ICaptureGraphBuilder2_GetFiltergraph(p,a) (p)->lpVtbl->GetFiltergraph(p,a)
+#define ICaptureGraphBuilder2_SetOutputFileName(p,a,b,c,d) (p)->lpVtbl->SetOutputFileName(p,a,b,c,d)
+#define ICaptureGraphBuilder2_FindInterface(p,a,b,c,d,e) (p)->lpVtbl->FindInterface(p,a,b,c,d,e)
+#define ICaptureGraphBuilder2_RenderStream(p,a,b,c,d,e) (p)->lpVtbl->RenderStream(p,a,b,c,d,e)
+#define ICaptureGraphBuilder2_ControlStream(p,a,b,c,d,e,f,g) (p)->lpVtbl->ControlStream(p,a,b,c,d,e,f,g)
+#define ICaptureGraphBuilder2_AllocCapFile(p,a,b) (p)->lpVtbl->AllocCapFile(p,a,b)
+#define ICaptureGraphBuilder2_CopyCaptureFile(p,a,b,c,d) (p)->lpVtbl->CopyCaptureFile(p,a,b,c,d)
+#define ICaptureGraphBuilder2_FindPin(p,a,b,c,d,e,f,g) (p)->lpVtbl->FindPin(p,a,b,c,d,e,f,g)
+
+#endif
+
+#define ICaptureGraphBuilder2_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; \
+ /*** ICaptureGraphBuilder2 methods ***/ \
+ STDMETHOD_(HRESULT,SetFiltergraph)(THIS_ IGraphBuilder* pfg) PURE; \
+ STDMETHOD_(HRESULT,GetFiltergraph)(THIS_ IGraphBuilder** ppfg) PURE; \
+ STDMETHOD_(HRESULT,SetOutputFileName)(THIS_ const GUID* pType, LPCOLESTR lpstrFile, IBaseFilter** ppf, IFileSinkFilter** ppSink) PURE; \
+ STDMETHOD_(HRESULT,FindInterface)(THIS_ const GUID* pCategory, const GUID* pType, IBaseFilter* pf, REFIID riid, void** ppint) PURE; \
+ STDMETHOD_(HRESULT,RenderStream)(THIS_ const GUID* pCategory, const GUID* pType, IUnknown* pSource, IBaseFilter* pfCompressor, IBaseFilter* pfRenderer) PURE; \
+ STDMETHOD_(HRESULT,ControlStream)(THIS_ const GUID* pCategory, const GUID* pType, IBaseFilter* pFilter, REFERENCE_TIME* pstart, REFERENCE_TIME* pstop, WORD wStartCookie, WORD wStopCookie) PURE; \
+ STDMETHOD_(HRESULT,AllocCapFile)(THIS_ LPCOLESTR lpstr, DWORDLONG dwlSize) PURE; \
+ STDMETHOD_(HRESULT,CopyCaptureFile)(THIS_ LPOLESTR lpwstrOld, LPOLESTR lpwstrNew, int fAllowEscAbort, IAMCopyCaptureFileProgress* pCallback) PURE; \
+ STDMETHOD_(HRESULT,FindPin)(THIS_ IUnknown* pSource, PIN_DIRECTION pindir, const GUID* pCategory, const GUID* pType, BOOL fUnconnected, int num, IPin** ppPin) PURE;
+
+HRESULT CALLBACK ICaptureGraphBuilder2_SetFiltergraph_Proxy(
+ ICaptureGraphBuilder2* This,
+ IGraphBuilder* pfg);
+void __RPC_STUB ICaptureGraphBuilder2_SetFiltergraph_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK ICaptureGraphBuilder2_GetFiltergraph_Proxy(
+ ICaptureGraphBuilder2* This,
+ IGraphBuilder** ppfg);
+void __RPC_STUB ICaptureGraphBuilder2_GetFiltergraph_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK ICaptureGraphBuilder2_SetOutputFileName_Proxy(
+ ICaptureGraphBuilder2* This,
+ const GUID* pType,
+ LPCOLESTR lpstrFile,
+ IBaseFilter** ppf,
+ IFileSinkFilter** ppSink);
+void __RPC_STUB ICaptureGraphBuilder2_SetOutputFileName_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK ICaptureGraphBuilder2_RemoteFindInterface_Proxy(
+ ICaptureGraphBuilder2* This,
+ const GUID* pCategory,
+ const GUID* pType,
+ IBaseFilter* pf,
+ REFIID riid,
+ IUnknown** ppint);
+void __RPC_STUB ICaptureGraphBuilder2_RemoteFindInterface_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK ICaptureGraphBuilder2_FindInterface_Proxy(
+ ICaptureGraphBuilder2* This,
+ const GUID* pCategory,
+ const GUID* pType,
+ IBaseFilter* pf,
+ REFIID riid,
+ void** ppint);
+HRESULT __RPC_STUB ICaptureGraphBuilder2_FindInterface_Stub(
+ ICaptureGraphBuilder2* This,
+ const GUID* pCategory,
+ const GUID* pType,
+ IBaseFilter* pf,
+ REFIID riid,
+ IUnknown** ppint);
+HRESULT CALLBACK ICaptureGraphBuilder2_RenderStream_Proxy(
+ ICaptureGraphBuilder2* This,
+ const GUID* pCategory,
+ const GUID* pType,
+ IUnknown* pSource,
+ IBaseFilter* pfCompressor,
+ IBaseFilter* pfRenderer);
+void __RPC_STUB ICaptureGraphBuilder2_RenderStream_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK ICaptureGraphBuilder2_ControlStream_Proxy(
+ ICaptureGraphBuilder2* This,
+ const GUID* pCategory,
+ const GUID* pType,
+ IBaseFilter* pFilter,
+ REFERENCE_TIME* pstart,
+ REFERENCE_TIME* pstop,
+ WORD wStartCookie,
+ WORD wStopCookie);
+void __RPC_STUB ICaptureGraphBuilder2_ControlStream_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK ICaptureGraphBuilder2_AllocCapFile_Proxy(
+ ICaptureGraphBuilder2* This,
+ LPCOLESTR lpstr,
+ DWORDLONG dwlSize);
+void __RPC_STUB ICaptureGraphBuilder2_AllocCapFile_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK ICaptureGraphBuilder2_CopyCaptureFile_Proxy(
+ ICaptureGraphBuilder2* This,
+ LPOLESTR lpwstrOld,
+ LPOLESTR lpwstrNew,
+ int fAllowEscAbort,
+ IAMCopyCaptureFileProgress* pCallback);
+void __RPC_STUB ICaptureGraphBuilder2_CopyCaptureFile_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK ICaptureGraphBuilder2_FindPin_Proxy(
+ ICaptureGraphBuilder2* This,
+ IUnknown* pSource,
+ PIN_DIRECTION pindir,
+ const GUID* pCategory,
+ const GUID* pType,
+ BOOL fUnconnected,
+ int num,
+ IPin** ppPin);
+void __RPC_STUB ICaptureGraphBuilder2_FindPin_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+enum _AM_RENSDEREXFLAGS {
+ AM_RENDEREX_RENDERTOEXISTINGRENDERERS = 0x1
+};
+
+typedef struct IFilterGraph2 IFilterGraph2;
+/*****************************************************************************
+ * IFilterGraph2 interface
+ */
+DEFINE_GUID(IID_IFilterGraph2, 0x36b73882, 0xc2c8, 0x11cf, 0x8b,0x46, 0x00,0x80,0x5f,0x6c,0xef,0x60);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IFilterGraph2 : public IGraphBuilder
+{
+ virtual HRESULT STDMETHODCALLTYPE AddSourceFilterForMoniker(
+ IMoniker* pMoniker,
+ IBindCtx* pCtx,
+ LPCWSTR lpcwstrFilterName,
+ IBaseFilter** ppFilter) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE ReconnectEx(
+ IPin* ppin,
+ const AM_MEDIA_TYPE* pmt) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE RenderEx(
+ IPin* pPinOut,
+ DWORD dwFlags,
+ DWORD* pvContext) = 0;
+
+};
+#else
+typedef struct IFilterGraph2Vtbl IFilterGraph2Vtbl;
+struct IFilterGraph2 {
+ const IFilterGraph2Vtbl* lpVtbl;
+};
+struct IFilterGraph2Vtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IFilterGraph2* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IFilterGraph2* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IFilterGraph2* This);
+
+ /*** IFilterGraph methods ***/
+ HRESULT (STDMETHODCALLTYPE *AddFilter)(
+ IFilterGraph2* This,
+ IBaseFilter* pFilter,
+ LPCWSTR pName);
+
+ HRESULT (STDMETHODCALLTYPE *RemoveFilter)(
+ IFilterGraph2* This,
+ IBaseFilter* pFilter);
+
+ HRESULT (STDMETHODCALLTYPE *EnumFilters)(
+ IFilterGraph2* This,
+ IEnumFilters** ppEnum);
+
+ HRESULT (STDMETHODCALLTYPE *FindFilterByName)(
+ IFilterGraph2* This,
+ LPCWSTR pName,
+ IBaseFilter** ppFilter);
+
+ HRESULT (STDMETHODCALLTYPE *ConnectDirect)(
+ IFilterGraph2* This,
+ IPin* ppinOut,
+ IPin* ppinIn,
+ const AM_MEDIA_TYPE* pmt);
+
+ HRESULT (STDMETHODCALLTYPE *Reconnect)(
+ IFilterGraph2* This,
+ IPin* ppin);
+
+ HRESULT (STDMETHODCALLTYPE *Disconnect)(
+ IFilterGraph2* This,
+ IPin* ppin);
+
+ HRESULT (STDMETHODCALLTYPE *SetDefaultSyncSource)(
+ IFilterGraph2* This);
+
+ /*** IGraphBuilder methods ***/
+ HRESULT (STDMETHODCALLTYPE *Connect)(
+ IFilterGraph2* This,
+ IPin* ppinOut,
+ IPin* ppinIn);
+
+ HRESULT (STDMETHODCALLTYPE *Render)(
+ IFilterGraph2* This,
+ IPin* ppinOut);
+
+ HRESULT (STDMETHODCALLTYPE *RenderFile)(
+ IFilterGraph2* This,
+ LPCWSTR lpcwstrFile,
+ LPCWSTR lpcwstrPlayList);
+
+ HRESULT (STDMETHODCALLTYPE *AddSourceFilter)(
+ IFilterGraph2* This,
+ LPCWSTR lpcwstrFileName,
+ LPCWSTR lpcwstrFilterName,
+ IBaseFilter** ppFilter);
+
+ HRESULT (STDMETHODCALLTYPE *SetLogFile)(
+ IFilterGraph2* This,
+ DWORD_PTR hFile);
+
+ HRESULT (STDMETHODCALLTYPE *Abort)(
+ IFilterGraph2* This);
+
+ HRESULT (STDMETHODCALLTYPE *ShouldOperationContinue)(
+ IFilterGraph2* This);
+
+ /*** IFilterGraph2 methods ***/
+ HRESULT (STDMETHODCALLTYPE *AddSourceFilterForMoniker)(
+ IFilterGraph2* This,
+ IMoniker* pMoniker,
+ IBindCtx* pCtx,
+ LPCWSTR lpcwstrFilterName,
+ IBaseFilter** ppFilter);
+
+ HRESULT (STDMETHODCALLTYPE *ReconnectEx)(
+ IFilterGraph2* This,
+ IPin* ppin,
+ const AM_MEDIA_TYPE* pmt);
+
+ HRESULT (STDMETHODCALLTYPE *RenderEx)(
+ IFilterGraph2* This,
+ IPin* pPinOut,
+ DWORD dwFlags,
+ DWORD* pvContext);
+
+};
+
+/*** IUnknown methods ***/
+#define IFilterGraph2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IFilterGraph2_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IFilterGraph2_Release(p) (p)->lpVtbl->Release(p)
+/*** IFilterGraph methods ***/
+#define IFilterGraph2_AddFilter(p,a,b) (p)->lpVtbl->AddFilter(p,a,b)
+#define IFilterGraph2_RemoveFilter(p,a) (p)->lpVtbl->RemoveFilter(p,a)
+#define IFilterGraph2_EnumFilters(p,a) (p)->lpVtbl->EnumFilters(p,a)
+#define IFilterGraph2_FindFilterByName(p,a,b) (p)->lpVtbl->FindFilterByName(p,a,b)
+#define IFilterGraph2_ConnectDirect(p,a,b,c) (p)->lpVtbl->ConnectDirect(p,a,b,c)
+#define IFilterGraph2_Reconnect(p,a) (p)->lpVtbl->Reconnect(p,a)
+#define IFilterGraph2_Disconnect(p,a) (p)->lpVtbl->Disconnect(p,a)
+#define IFilterGraph2_SetDefaultSyncSource(p) (p)->lpVtbl->SetDefaultSyncSource(p)
+/*** IGraphBuilder methods ***/
+#define IFilterGraph2_Connect(p,a,b) (p)->lpVtbl->Connect(p,a,b)
+#define IFilterGraph2_Render(p,a) (p)->lpVtbl->Render(p,a)
+#define IFilterGraph2_RenderFile(p,a,b) (p)->lpVtbl->RenderFile(p,a,b)
+#define IFilterGraph2_AddSourceFilter(p,a,b,c) (p)->lpVtbl->AddSourceFilter(p,a,b,c)
+#define IFilterGraph2_SetLogFile(p,a) (p)->lpVtbl->SetLogFile(p,a)
+#define IFilterGraph2_Abort(p) (p)->lpVtbl->Abort(p)
+#define IFilterGraph2_ShouldOperationContinue(p) (p)->lpVtbl->ShouldOperationContinue(p)
+/*** IFilterGraph2 methods ***/
+#define IFilterGraph2_AddSourceFilterForMoniker(p,a,b,c,d) (p)->lpVtbl->AddSourceFilterForMoniker(p,a,b,c,d)
+#define IFilterGraph2_ReconnectEx(p,a,b) (p)->lpVtbl->ReconnectEx(p,a,b)
+#define IFilterGraph2_RenderEx(p,a,b,c) (p)->lpVtbl->RenderEx(p,a,b,c)
+
+#endif
+
+#define IFilterGraph2_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; \
+ /*** IFilterGraph methods ***/ \
+ STDMETHOD_(HRESULT,AddFilter)(THIS_ IBaseFilter* pFilter, LPCWSTR pName) PURE; \
+ STDMETHOD_(HRESULT,RemoveFilter)(THIS_ IBaseFilter* pFilter) PURE; \
+ STDMETHOD_(HRESULT,EnumFilters)(THIS_ IEnumFilters** ppEnum) PURE; \
+ STDMETHOD_(HRESULT,FindFilterByName)(THIS_ LPCWSTR pName, IBaseFilter** ppFilter) PURE; \
+ STDMETHOD_(HRESULT,ConnectDirect)(THIS_ IPin* ppinOut, IPin* ppinIn, const AM_MEDIA_TYPE* pmt) PURE; \
+ STDMETHOD_(HRESULT,Reconnect)(THIS_ IPin* ppin) PURE; \
+ STDMETHOD_(HRESULT,Disconnect)(THIS_ IPin* ppin) PURE; \
+ STDMETHOD_(HRESULT,SetDefaultSyncSource)(THIS) PURE; \
+ /*** IGraphBuilder methods ***/ \
+ STDMETHOD_(HRESULT,Connect)(THIS_ IPin* ppinOut, IPin* ppinIn) PURE; \
+ STDMETHOD_(HRESULT,Render)(THIS_ IPin* ppinOut) PURE; \
+ STDMETHOD_(HRESULT,RenderFile)(THIS_ LPCWSTR lpcwstrFile, LPCWSTR lpcwstrPlayList) PURE; \
+ STDMETHOD_(HRESULT,AddSourceFilter)(THIS_ LPCWSTR lpcwstrFileName, LPCWSTR lpcwstrFilterName, IBaseFilter** ppFilter) PURE; \
+ STDMETHOD_(HRESULT,SetLogFile)(THIS_ DWORD_PTR hFile) PURE; \
+ STDMETHOD_(HRESULT,Abort)(THIS) PURE; \
+ STDMETHOD_(HRESULT,ShouldOperationContinue)(THIS) PURE; \
+ /*** IFilterGraph2 methods ***/ \
+ STDMETHOD_(HRESULT,AddSourceFilterForMoniker)(THIS_ IMoniker* pMoniker, IBindCtx* pCtx, LPCWSTR lpcwstrFilterName, IBaseFilter** ppFilter) PURE; \
+ STDMETHOD_(HRESULT,ReconnectEx)(THIS_ IPin* ppin, const AM_MEDIA_TYPE* pmt) PURE; \
+ STDMETHOD_(HRESULT,RenderEx)(THIS_ IPin* pPinOut, DWORD dwFlags, DWORD* pvContext) PURE;
+
+HRESULT CALLBACK IFilterGraph2_AddSourceFilterForMoniker_Proxy(
+ IFilterGraph2* This,
+ IMoniker* pMoniker,
+ IBindCtx* pCtx,
+ LPCWSTR lpcwstrFilterName,
+ IBaseFilter** ppFilter);
+void __RPC_STUB IFilterGraph2_AddSourceFilterForMoniker_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFilterGraph2_ReconnectEx_Proxy(
+ IFilterGraph2* This,
+ IPin* ppin,
+ const AM_MEDIA_TYPE* pmt);
+void __RPC_STUB IFilterGraph2_ReconnectEx_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFilterGraph2_RenderEx_Proxy(
+ IFilterGraph2* This,
+ IPin* pPinOut,
+ DWORD dwFlags,
+ DWORD* pvContext);
+void __RPC_STUB IFilterGraph2_RenderEx_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+typedef struct IStreamBuilder IStreamBuilder;
+/*****************************************************************************
+ * IStreamBuilder interface
+ */
+DEFINE_GUID(IID_IStreamBuilder, 0x56a868bf, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IStreamBuilder : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE Render(
+ IPin* ppinOut,
+ IGraphBuilder* pGraph) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE Backout(
+ IPin* ppinOut,
+ IGraphBuilder* pGraph) = 0;
+
+};
+#else
+typedef struct IStreamBuilderVtbl IStreamBuilderVtbl;
+struct IStreamBuilder {
+ const IStreamBuilderVtbl* lpVtbl;
+};
+struct IStreamBuilderVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IStreamBuilder* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IStreamBuilder* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IStreamBuilder* This);
+
+ /*** IStreamBuilder methods ***/
+ HRESULT (STDMETHODCALLTYPE *Render)(
+ IStreamBuilder* This,
+ IPin* ppinOut,
+ IGraphBuilder* pGraph);
+
+ HRESULT (STDMETHODCALLTYPE *Backout)(
+ IStreamBuilder* This,
+ IPin* ppinOut,
+ IGraphBuilder* pGraph);
+
+};
+
+/*** IUnknown methods ***/
+#define IStreamBuilder_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IStreamBuilder_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IStreamBuilder_Release(p) (p)->lpVtbl->Release(p)
+/*** IStreamBuilder methods ***/
+#define IStreamBuilder_Render(p,a,b) (p)->lpVtbl->Render(p,a,b)
+#define IStreamBuilder_Backout(p,a,b) (p)->lpVtbl->Backout(p,a,b)
+
+#endif
+
+#define IStreamBuilder_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; \
+ /*** IStreamBuilder methods ***/ \
+ STDMETHOD_(HRESULT,Render)(THIS_ IPin* ppinOut, IGraphBuilder* pGraph) PURE; \
+ STDMETHOD_(HRESULT,Backout)(THIS_ IPin* ppinOut, IGraphBuilder* pGraph) PURE;
+
+HRESULT CALLBACK IStreamBuilder_Render_Proxy(
+ IStreamBuilder* This,
+ IPin* ppinOut,
+ IGraphBuilder* pGraph);
+void __RPC_STUB IStreamBuilder_Render_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IStreamBuilder_Backout_Proxy(
+ IStreamBuilder* This,
+ IPin* ppinOut,
+ IGraphBuilder* pGraph);
+void __RPC_STUB IStreamBuilder_Backout_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+typedef struct IAsyncReader IAsyncReader;
+/*****************************************************************************
+ * IAsyncReader interface
+ */
+DEFINE_GUID(IID_IAsyncReader, 0x56a868aa, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IAsyncReader : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE RequestAllocator(
+ IMemAllocator* pPreferred,
+ ALLOCATOR_PROPERTIES* pProps,
+ IMemAllocator** ppActual) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE Request(
+ IMediaSample* pSample,
+ DWORD_PTR dwUser) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE WaitForNext(
+ DWORD dwTimeout,
+ IMediaSample** ppSample,
+ DWORD_PTR* pdwUser) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE SyncReadAligned(
+ IMediaSample* pSample) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE SyncRead(
+ LONGLONG llPosition,
+ LONG lLength,
+ BYTE* pBuffer) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE Length(
+ LONGLONG* pTotal,
+ LONGLONG* pAvailable) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE BeginFlush(
+ ) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE EndFlush(
+ ) = 0;
+
+};
+#else
+typedef struct IAsyncReaderVtbl IAsyncReaderVtbl;
+struct IAsyncReader {
+ const IAsyncReaderVtbl* lpVtbl;
+};
+struct IAsyncReaderVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IAsyncReader* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IAsyncReader* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IAsyncReader* This);
+
+ /*** IAsyncReader methods ***/
+ HRESULT (STDMETHODCALLTYPE *RequestAllocator)(
+ IAsyncReader* This,
+ IMemAllocator* pPreferred,
+ ALLOCATOR_PROPERTIES* pProps,
+ IMemAllocator** ppActual);
+
+ HRESULT (STDMETHODCALLTYPE *Request)(
+ IAsyncReader* This,
+ IMediaSample* pSample,
+ DWORD_PTR dwUser);
+
+ HRESULT (STDMETHODCALLTYPE *WaitForNext)(
+ IAsyncReader* This,
+ DWORD dwTimeout,
+ IMediaSample** ppSample,
+ DWORD_PTR* pdwUser);
+
+ HRESULT (STDMETHODCALLTYPE *SyncReadAligned)(
+ IAsyncReader* This,
+ IMediaSample* pSample);
+
+ HRESULT (STDMETHODCALLTYPE *SyncRead)(
+ IAsyncReader* This,
+ LONGLONG llPosition,
+ LONG lLength,
+ BYTE* pBuffer);
+
+ HRESULT (STDMETHODCALLTYPE *Length)(
+ IAsyncReader* This,
+ LONGLONG* pTotal,
+ LONGLONG* pAvailable);
+
+ HRESULT (STDMETHODCALLTYPE *BeginFlush)(
+ IAsyncReader* This);
+
+ HRESULT (STDMETHODCALLTYPE *EndFlush)(
+ IAsyncReader* This);
+
+};
+
+/*** IUnknown methods ***/
+#define IAsyncReader_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IAsyncReader_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IAsyncReader_Release(p) (p)->lpVtbl->Release(p)
+/*** IAsyncReader methods ***/
+#define IAsyncReader_RequestAllocator(p,a,b,c) (p)->lpVtbl->RequestAllocator(p,a,b,c)
+#define IAsyncReader_Request(p,a,b) (p)->lpVtbl->Request(p,a,b)
+#define IAsyncReader_WaitForNext(p,a,b,c) (p)->lpVtbl->WaitForNext(p,a,b,c)
+#define IAsyncReader_SyncReadAligned(p,a) (p)->lpVtbl->SyncReadAligned(p,a)
+#define IAsyncReader_SyncRead(p,a,b,c) (p)->lpVtbl->SyncRead(p,a,b,c)
+#define IAsyncReader_Length(p,a,b) (p)->lpVtbl->Length(p,a,b)
+#define IAsyncReader_BeginFlush(p) (p)->lpVtbl->BeginFlush(p)
+#define IAsyncReader_EndFlush(p) (p)->lpVtbl->EndFlush(p)
+
+#endif
+
+#define IAsyncReader_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; \
+ /*** IAsyncReader methods ***/ \
+ STDMETHOD_(HRESULT,RequestAllocator)(THIS_ IMemAllocator* pPreferred, ALLOCATOR_PROPERTIES* pProps, IMemAllocator** ppActual) PURE; \
+ STDMETHOD_(HRESULT,Request)(THIS_ IMediaSample* pSample, DWORD_PTR dwUser) PURE; \
+ STDMETHOD_(HRESULT,WaitForNext)(THIS_ DWORD dwTimeout, IMediaSample** ppSample, DWORD_PTR* pdwUser) PURE; \
+ STDMETHOD_(HRESULT,SyncReadAligned)(THIS_ IMediaSample* pSample) PURE; \
+ STDMETHOD_(HRESULT,SyncRead)(THIS_ LONGLONG llPosition, LONG lLength, BYTE* pBuffer) PURE; \
+ STDMETHOD_(HRESULT,Length)(THIS_ LONGLONG* pTotal, LONGLONG* pAvailable) PURE; \
+ STDMETHOD_(HRESULT,BeginFlush)(THIS) PURE; \
+ STDMETHOD_(HRESULT,EndFlush)(THIS) PURE;
+
+HRESULT CALLBACK IAsyncReader_RequestAllocator_Proxy(
+ IAsyncReader* This,
+ IMemAllocator* pPreferred,
+ ALLOCATOR_PROPERTIES* pProps,
+ IMemAllocator** ppActual);
+void __RPC_STUB IAsyncReader_RequestAllocator_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IAsyncReader_Request_Proxy(
+ IAsyncReader* This,
+ IMediaSample* pSample,
+ DWORD_PTR dwUser);
+void __RPC_STUB IAsyncReader_Request_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IAsyncReader_WaitForNext_Proxy(
+ IAsyncReader* This,
+ DWORD dwTimeout,
+ IMediaSample** ppSample,
+ DWORD_PTR* pdwUser);
+void __RPC_STUB IAsyncReader_WaitForNext_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IAsyncReader_SyncReadAligned_Proxy(
+ IAsyncReader* This,
+ IMediaSample* pSample);
+void __RPC_STUB IAsyncReader_SyncReadAligned_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IAsyncReader_SyncRead_Proxy(
+ IAsyncReader* This,
+ LONGLONG llPosition,
+ LONG lLength,
+ BYTE* pBuffer);
+void __RPC_STUB IAsyncReader_SyncRead_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IAsyncReader_Length_Proxy(
+ IAsyncReader* This,
+ LONGLONG* pTotal,
+ LONGLONG* pAvailable);
+void __RPC_STUB IAsyncReader_Length_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IAsyncReader_BeginFlush_Proxy(
+ IAsyncReader* This);
+void __RPC_STUB IAsyncReader_BeginFlush_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IAsyncReader_EndFlush_Proxy(
+ IAsyncReader* This);
+void __RPC_STUB IAsyncReader_EndFlush_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+typedef struct IGraphVersion IGraphVersion;
+/*****************************************************************************
+ * IGraphVersion interface
+ */
+DEFINE_GUID(IID_IGraphVersion, 0x56a868ab, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IGraphVersion : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE QueryVersion(
+ LONG* pVersion) = 0;
+
+};
+#else
+typedef struct IGraphVersionVtbl IGraphVersionVtbl;
+struct IGraphVersion {
+ const IGraphVersionVtbl* lpVtbl;
+};
+struct IGraphVersionVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IGraphVersion* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IGraphVersion* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IGraphVersion* This);
+
+ /*** IGraphVersion methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryVersion)(
+ IGraphVersion* This,
+ LONG* pVersion);
+
+};
+
+/*** IUnknown methods ***/
+#define IGraphVersion_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IGraphVersion_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IGraphVersion_Release(p) (p)->lpVtbl->Release(p)
+/*** IGraphVersion methods ***/
+#define IGraphVersion_QueryVersion(p,a) (p)->lpVtbl->QueryVersion(p,a)
+
+#endif
+
+#define IGraphVersion_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; \
+ /*** IGraphVersion methods ***/ \
+ STDMETHOD_(HRESULT,QueryVersion)(THIS_ LONG* pVersion) PURE;
+
+HRESULT CALLBACK IGraphVersion_QueryVersion_Proxy(
+ IGraphVersion* This,
+ LONG* pVersion);
+void __RPC_STUB IGraphVersion_QueryVersion_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+typedef struct IResourceConsumer IResourceConsumer;
+/*****************************************************************************
+ * IResourceConsumer interface
+ */
+DEFINE_GUID(IID_IResourceConsumer, 0x56a868ad, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IResourceConsumer : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE AcquireResource(
+ LONG idResource) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE ReleaseResource(
+ LONG idResource) = 0;
+
+};
+#else
+typedef struct IResourceConsumerVtbl IResourceConsumerVtbl;
+struct IResourceConsumer {
+ const IResourceConsumerVtbl* lpVtbl;
+};
+struct IResourceConsumerVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IResourceConsumer* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IResourceConsumer* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IResourceConsumer* This);
+
+ /*** IResourceConsumer methods ***/
+ HRESULT (STDMETHODCALLTYPE *AcquireResource)(
+ IResourceConsumer* This,
+ LONG idResource);
+
+ HRESULT (STDMETHODCALLTYPE *ReleaseResource)(
+ IResourceConsumer* This,
+ LONG idResource);
+
+};
+
+/*** IUnknown methods ***/
+#define IResourceConsumer_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IResourceConsumer_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IResourceConsumer_Release(p) (p)->lpVtbl->Release(p)
+/*** IResourceConsumer methods ***/
+#define IResourceConsumer_AcquireResource(p,a) (p)->lpVtbl->AcquireResource(p,a)
+#define IResourceConsumer_ReleaseResource(p,a) (p)->lpVtbl->ReleaseResource(p,a)
+
+#endif
+
+#define IResourceConsumer_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; \
+ /*** IResourceConsumer methods ***/ \
+ STDMETHOD_(HRESULT,AcquireResource)(THIS_ LONG idResource) PURE; \
+ STDMETHOD_(HRESULT,ReleaseResource)(THIS_ LONG idResource) PURE;
+
+HRESULT CALLBACK IResourceConsumer_AcquireResource_Proxy(
+ IResourceConsumer* This,
+ LONG idResource);
+void __RPC_STUB IResourceConsumer_AcquireResource_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IResourceConsumer_ReleaseResource_Proxy(
+ IResourceConsumer* This,
+ LONG idResource);
+void __RPC_STUB IResourceConsumer_ReleaseResource_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+typedef struct IResourceManager IResourceManager;
+/*****************************************************************************
+ * IResourceManager interface
+ */
+DEFINE_GUID(IID_IResourceManager, 0x56a868ac, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IResourceManager : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE Register(
+ LPCWSTR pName,
+ LONG cResource,
+ LONG* plToken) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE RegisterGroup(
+ LPCWSTR pName,
+ LONG cResource,
+ LONG* palTokens,
+ LONG* plToken) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE RequestResource(
+ LONG idResource,
+ IUnknown* pFocusObject,
+ IResourceConsumer* pConsumer) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE NotifyAcquire(
+ LONG idResource,
+ IResourceConsumer* pConsumer,
+ HRESULT hr) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE NotifyRelease(
+ LONG idResource,
+ IResourceConsumer* pConsumer,
+ BOOL bStillWant) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE CancelRequest(
+ LONG idResource,
+ IResourceConsumer* pConsumer) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE SetFocus(
+ IUnknown* pFocusObject) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE ReleaseFocus(
+ IUnknown* pFocusObject) = 0;
+
+};
+#else
+typedef struct IResourceManagerVtbl IResourceManagerVtbl;
+struct IResourceManager {
+ const IResourceManagerVtbl* lpVtbl;
+};
+struct IResourceManagerVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IResourceManager* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IResourceManager* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IResourceManager* This);
+
+ /*** IResourceManager methods ***/
+ HRESULT (STDMETHODCALLTYPE *Register)(
+ IResourceManager* This,
+ LPCWSTR pName,
+ LONG cResource,
+ LONG* plToken);
+
+ HRESULT (STDMETHODCALLTYPE *RegisterGroup)(
+ IResourceManager* This,
+ LPCWSTR pName,
+ LONG cResource,
+ LONG* palTokens,
+ LONG* plToken);
+
+ HRESULT (STDMETHODCALLTYPE *RequestResource)(
+ IResourceManager* This,
+ LONG idResource,
+ IUnknown* pFocusObject,
+ IResourceConsumer* pConsumer);
+
+ HRESULT (STDMETHODCALLTYPE *NotifyAcquire)(
+ IResourceManager* This,
+ LONG idResource,
+ IResourceConsumer* pConsumer,
+ HRESULT hr);
+
+ HRESULT (STDMETHODCALLTYPE *NotifyRelease)(
+ IResourceManager* This,
+ LONG idResource,
+ IResourceConsumer* pConsumer,
+ BOOL bStillWant);
+
+ HRESULT (STDMETHODCALLTYPE *CancelRequest)(
+ IResourceManager* This,
+ LONG idResource,
+ IResourceConsumer* pConsumer);
+
+ HRESULT (STDMETHODCALLTYPE *SetFocus)(
+ IResourceManager* This,
+ IUnknown* pFocusObject);
+
+ HRESULT (STDMETHODCALLTYPE *ReleaseFocus)(
+ IResourceManager* This,
+ IUnknown* pFocusObject);
+
+};
+
+/*** IUnknown methods ***/
+#define IResourceManager_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IResourceManager_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IResourceManager_Release(p) (p)->lpVtbl->Release(p)
+/*** IResourceManager methods ***/
+#define IResourceManager_Register(p,a,b,c) (p)->lpVtbl->Register(p,a,b,c)
+#define IResourceManager_RegisterGroup(p,a,b,c,d) (p)->lpVtbl->RegisterGroup(p,a,b,c,d)
+#define IResourceManager_RequestResource(p,a,b,c) (p)->lpVtbl->RequestResource(p,a,b,c)
+#define IResourceManager_NotifyAcquire(p,a,b,c) (p)->lpVtbl->NotifyAcquire(p,a,b,c)
+#define IResourceManager_NotifyRelease(p,a,b,c) (p)->lpVtbl->NotifyRelease(p,a,b,c)
+#define IResourceManager_CancelRequest(p,a,b) (p)->lpVtbl->CancelRequest(p,a,b)
+#define IResourceManager_SetFocus(p,a) (p)->lpVtbl->SetFocus(p,a)
+#define IResourceManager_ReleaseFocus(p,a) (p)->lpVtbl->ReleaseFocus(p,a)
+
+#endif
+
+#define IResourceManager_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; \
+ /*** IResourceManager methods ***/ \
+ STDMETHOD_(HRESULT,Register)(THIS_ LPCWSTR pName, LONG cResource, LONG* plToken) PURE; \
+ STDMETHOD_(HRESULT,RegisterGroup)(THIS_ LPCWSTR pName, LONG cResource, LONG* palTokens, LONG* plToken) PURE; \
+ STDMETHOD_(HRESULT,RequestResource)(THIS_ LONG idResource, IUnknown* pFocusObject, IResourceConsumer* pConsumer) PURE; \
+ STDMETHOD_(HRESULT,NotifyAcquire)(THIS_ LONG idResource, IResourceConsumer* pConsumer, HRESULT hr) PURE; \
+ STDMETHOD_(HRESULT,NotifyRelease)(THIS_ LONG idResource, IResourceConsumer* pConsumer, BOOL bStillWant) PURE; \
+ STDMETHOD_(HRESULT,CancelRequest)(THIS_ LONG idResource, IResourceConsumer* pConsumer) PURE; \
+ STDMETHOD_(HRESULT,SetFocus)(THIS_ IUnknown* pFocusObject) PURE; \
+ STDMETHOD_(HRESULT,ReleaseFocus)(THIS_ IUnknown* pFocusObject) PURE;
+
+HRESULT CALLBACK IResourceManager_Register_Proxy(
+ IResourceManager* This,
+ LPCWSTR pName,
+ LONG cResource,
+ LONG* plToken);
+void __RPC_STUB IResourceManager_Register_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IResourceManager_RegisterGroup_Proxy(
+ IResourceManager* This,
+ LPCWSTR pName,
+ LONG cResource,
+ LONG* palTokens,
+ LONG* plToken);
+void __RPC_STUB IResourceManager_RegisterGroup_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IResourceManager_RequestResource_Proxy(
+ IResourceManager* This,
+ LONG idResource,
+ IUnknown* pFocusObject,
+ IResourceConsumer* pConsumer);
+void __RPC_STUB IResourceManager_RequestResource_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IResourceManager_NotifyAcquire_Proxy(
+ IResourceManager* This,
+ LONG idResource,
+ IResourceConsumer* pConsumer,
+ HRESULT hr);
+void __RPC_STUB IResourceManager_NotifyAcquire_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IResourceManager_NotifyRelease_Proxy(
+ IResourceManager* This,
+ LONG idResource,
+ IResourceConsumer* pConsumer,
+ BOOL bStillWant);
+void __RPC_STUB IResourceManager_NotifyRelease_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IResourceManager_CancelRequest_Proxy(
+ IResourceManager* This,
+ LONG idResource,
+ IResourceConsumer* pConsumer);
+void __RPC_STUB IResourceManager_CancelRequest_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IResourceManager_SetFocus_Proxy(
+ IResourceManager* This,
+ IUnknown* pFocusObject);
+void __RPC_STUB IResourceManager_SetFocus_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IResourceManager_ReleaseFocus_Proxy(
+ IResourceManager* This,
+ IUnknown* pFocusObject);
+void __RPC_STUB IResourceManager_ReleaseFocus_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+typedef struct IPinConnection IPinConnection;
+typedef struct IPinFlowControl IPinFlowControl;
+typedef struct IGraphConfig IGraphConfig;
+typedef struct IGraphConfigCallback IGraphConfigCallback;
+/*****************************************************************************
+ * IPinConnection interface
+ */
+DEFINE_GUID(IID_IPinConnection, 0x4a9a62d3, 0x27d4, 0x403d, 0x91,0xe9, 0x89,0xf5,0x40,0xe5,0x55,0x34);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IPinConnection : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE DynamicQueryAccept(
+ const AM_MEDIA_TYPE* pmt) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE NotifyEndOfStream(
+ HANDLE hNotifyEvent) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE IsEndPin(
+ ) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE DynamicDisconnect(
+ ) = 0;
+
+};
+#else
+typedef struct IPinConnectionVtbl IPinConnectionVtbl;
+struct IPinConnection {
+ const IPinConnectionVtbl* lpVtbl;
+};
+struct IPinConnectionVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IPinConnection* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IPinConnection* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IPinConnection* This);
+
+ /*** IPinConnection methods ***/
+ HRESULT (STDMETHODCALLTYPE *DynamicQueryAccept)(
+ IPinConnection* This,
+ const AM_MEDIA_TYPE* pmt);
+
+ HRESULT (STDMETHODCALLTYPE *NotifyEndOfStream)(
+ IPinConnection* This,
+ HANDLE hNotifyEvent);
+
+ HRESULT (STDMETHODCALLTYPE *IsEndPin)(
+ IPinConnection* This);
+
+ HRESULT (STDMETHODCALLTYPE *DynamicDisconnect)(
+ IPinConnection* This);
+
+};
+
+/*** IUnknown methods ***/
+#define IPinConnection_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IPinConnection_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IPinConnection_Release(p) (p)->lpVtbl->Release(p)
+/*** IPinConnection methods ***/
+#define IPinConnection_DynamicQueryAccept(p,a) (p)->lpVtbl->DynamicQueryAccept(p,a)
+#define IPinConnection_NotifyEndOfStream(p,a) (p)->lpVtbl->NotifyEndOfStream(p,a)
+#define IPinConnection_IsEndPin(p) (p)->lpVtbl->IsEndPin(p)
+#define IPinConnection_DynamicDisconnect(p) (p)->lpVtbl->DynamicDisconnect(p)
+
+#endif
+
+#define IPinConnection_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; \
+ /*** IPinConnection methods ***/ \
+ STDMETHOD_(HRESULT,DynamicQueryAccept)(THIS_ const AM_MEDIA_TYPE* pmt) PURE; \
+ STDMETHOD_(HRESULT,NotifyEndOfStream)(THIS_ HANDLE hNotifyEvent) PURE; \
+ STDMETHOD_(HRESULT,IsEndPin)(THIS) PURE; \
+ STDMETHOD_(HRESULT,DynamicDisconnect)(THIS) PURE;
+
+HRESULT CALLBACK IPinConnection_DynamicQueryAccept_Proxy(
+ IPinConnection* This,
+ const AM_MEDIA_TYPE* pmt);
+void __RPC_STUB IPinConnection_DynamicQueryAccept_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IPinConnection_NotifyEndOfStream_Proxy(
+ IPinConnection* This,
+ HANDLE hNotifyEvent);
+void __RPC_STUB IPinConnection_NotifyEndOfStream_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IPinConnection_IsEndPin_Proxy(
+ IPinConnection* This);
+void __RPC_STUB IPinConnection_IsEndPin_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IPinConnection_DynamicDisconnect_Proxy(
+ IPinConnection* This);
+void __RPC_STUB IPinConnection_DynamicDisconnect_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+/*****************************************************************************
+ * IPinFlowControl interface
+ */
+DEFINE_GUID(IID_IPinFlowControl, 0xc56e9858, 0xdbf3, 0x4f6b, 0x81,0x19, 0x38,0x4a,0xf2,0x06,0x0d,0xeb);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IPinFlowControl : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE Block(
+ DWORD dwBlockFlags,
+ HANDLE hEvent) = 0;
+
+};
+#else
+typedef struct IPinFlowControlVtbl IPinFlowControlVtbl;
+struct IPinFlowControl {
+ const IPinFlowControlVtbl* lpVtbl;
+};
+struct IPinFlowControlVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IPinFlowControl* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IPinFlowControl* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IPinFlowControl* This);
+
+ /*** IPinFlowControl methods ***/
+ HRESULT (STDMETHODCALLTYPE *Block)(
+ IPinFlowControl* This,
+ DWORD dwBlockFlags,
+ HANDLE hEvent);
+
+};
+
+/*** IUnknown methods ***/
+#define IPinFlowControl_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IPinFlowControl_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IPinFlowControl_Release(p) (p)->lpVtbl->Release(p)
+/*** IPinFlowControl methods ***/
+#define IPinFlowControl_Block(p,a,b) (p)->lpVtbl->Block(p,a,b)
+
+#endif
+
+#define IPinFlowControl_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; \
+ /*** IPinFlowControl methods ***/ \
+ STDMETHOD_(HRESULT,Block)(THIS_ DWORD dwBlockFlags, HANDLE hEvent) PURE;
+
+HRESULT CALLBACK IPinFlowControl_Block_Proxy(
+ IPinFlowControl* This,
+ DWORD dwBlockFlags,
+ HANDLE hEvent);
+void __RPC_STUB IPinFlowControl_Block_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+enum _AM_PIN_FLOW_CONTROL_BLOCK_FLAGS {
+ AM_PIN_FLOW_CONTROL_BLOCK = 0x1
+};
+
+typedef enum _AM_GRAPH_CONFIG_RECONNECT_FLAGS {
+ AM_GRAPH_CONFIG_RECONNECT_DIRECTCONNECT = 0x1,
+ AM_GRAPH_CONFIG_RECONNECT_CACHE_REMOVED_FILTERS = 0x2,
+ AM_GRAPH_CONFIG_RECONNECT_USE_ONLY_CACHED_FILTERS = 0x4
+} AM_GRAPH_CONFIG_RECONNECT_FLAGS;
+
+enum _REM_FILTER_FLAGS {
+ REMFILTERF_LEAVECONNECTED = 0x1
+};
+
+typedef enum _AM_FILTER_FLAGS {
+ AM_FILTER_FLAGS_REMOVABLE = 0x1
+} AM_FILTER_FLAGS;
+
+/*****************************************************************************
+ * IGraphConfig interface
+ */
+DEFINE_GUID(IID_IGraphConfig, 0x03a1eb8e, 0x32bf, 0x4245, 0x85,0x02, 0x11,0x4d,0x08,0xa9,0xcb,0x88);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IGraphConfig : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE Reconnect(
+ IPin* pOutputPin,
+ IPin* pInputPin,
+ const AM_MEDIA_TYPE* pmtFirstConnection,
+ IBaseFilter* pUsingFilter,
+ HANDLE hAbortEvent,
+ DWORD dwFlags) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE Reconfigure(
+ IGraphConfigCallback* pCallback,
+ PVOID pvContext,
+ DWORD dwFlags,
+ HANDLE hAbortEvent) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE AddFilterToCache(
+ IBaseFilter* pFilter) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE EnumCacheFilter(
+ IEnumFilters** pEnum) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE RemoveFilterFromCache(
+ IBaseFilter* pFilter) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetStartTime(
+ REFERENCE_TIME* prtStart) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE PushThroughData(
+ IPin* pOutputPin,
+ IPinConnection* pConnection,
+ HANDLE hEventAbort) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE SetFilterFlags(
+ IBaseFilter* pFilter,
+ DWORD dwFlags) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetFilterFlags(
+ IBaseFilter* pFilter,
+ DWORD* pdwFlags) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE RemoveFilterEx(
+ IBaseFilter* pFilter,
+ DWORD Flags) = 0;
+
+};
+#else
+typedef struct IGraphConfigVtbl IGraphConfigVtbl;
+struct IGraphConfig {
+ const IGraphConfigVtbl* lpVtbl;
+};
+struct IGraphConfigVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IGraphConfig* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IGraphConfig* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IGraphConfig* This);
+
+ /*** IGraphConfig methods ***/
+ HRESULT (STDMETHODCALLTYPE *Reconnect)(
+ IGraphConfig* This,
+ IPin* pOutputPin,
+ IPin* pInputPin,
+ const AM_MEDIA_TYPE* pmtFirstConnection,
+ IBaseFilter* pUsingFilter,
+ HANDLE hAbortEvent,
+ DWORD dwFlags);
+
+ HRESULT (STDMETHODCALLTYPE *Reconfigure)(
+ IGraphConfig* This,
+ IGraphConfigCallback* pCallback,
+ PVOID pvContext,
+ DWORD dwFlags,
+ HANDLE hAbortEvent);
+
+ HRESULT (STDMETHODCALLTYPE *AddFilterToCache)(
+ IGraphConfig* This,
+ IBaseFilter* pFilter);
+
+ HRESULT (STDMETHODCALLTYPE *EnumCacheFilter)(
+ IGraphConfig* This,
+ IEnumFilters** pEnum);
+
+ HRESULT (STDMETHODCALLTYPE *RemoveFilterFromCache)(
+ IGraphConfig* This,
+ IBaseFilter* pFilter);
+
+ HRESULT (STDMETHODCALLTYPE *GetStartTime)(
+ IGraphConfig* This,
+ REFERENCE_TIME* prtStart);
+
+ HRESULT (STDMETHODCALLTYPE *PushThroughData)(
+ IGraphConfig* This,
+ IPin* pOutputPin,
+ IPinConnection* pConnection,
+ HANDLE hEventAbort);
+
+ HRESULT (STDMETHODCALLTYPE *SetFilterFlags)(
+ IGraphConfig* This,
+ IBaseFilter* pFilter,
+ DWORD dwFlags);
+
+ HRESULT (STDMETHODCALLTYPE *GetFilterFlags)(
+ IGraphConfig* This,
+ IBaseFilter* pFilter,
+ DWORD* pdwFlags);
+
+ HRESULT (STDMETHODCALLTYPE *RemoveFilterEx)(
+ IGraphConfig* This,
+ IBaseFilter* pFilter,
+ DWORD Flags);
+
+};
+
+/*** IUnknown methods ***/
+#define IGraphConfig_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IGraphConfig_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IGraphConfig_Release(p) (p)->lpVtbl->Release(p)
+/*** IGraphConfig methods ***/
+#define IGraphConfig_Reconnect(p,a,b,c,d,e,f) (p)->lpVtbl->Reconnect(p,a,b,c,d,e,f)
+#define IGraphConfig_Reconfigure(p,a,b,c,d) (p)->lpVtbl->Reconfigure(p,a,b,c,d)
+#define IGraphConfig_AddFilterToCache(p,a) (p)->lpVtbl->AddFilterToCache(p,a)
+#define IGraphConfig_EnumCacheFilter(p,a) (p)->lpVtbl->EnumCacheFilter(p,a)
+#define IGraphConfig_RemoveFilterFromCache(p,a) (p)->lpVtbl->RemoveFilterFromCache(p,a)
+#define IGraphConfig_GetStartTime(p,a) (p)->lpVtbl->GetStartTime(p,a)
+#define IGraphConfig_PushThroughData(p,a,b,c) (p)->lpVtbl->PushThroughData(p,a,b,c)
+#define IGraphConfig_SetFilterFlags(p,a,b) (p)->lpVtbl->SetFilterFlags(p,a,b)
+#define IGraphConfig_GetFilterFlags(p,a,b) (p)->lpVtbl->GetFilterFlags(p,a,b)
+#define IGraphConfig_RemoveFilterEx(p,a,b) (p)->lpVtbl->RemoveFilterEx(p,a,b)
+
+#endif
+
+#define IGraphConfig_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; \
+ /*** IGraphConfig methods ***/ \
+ STDMETHOD_(HRESULT,Reconnect)(THIS_ IPin* pOutputPin, IPin* pInputPin, const AM_MEDIA_TYPE* pmtFirstConnection, IBaseFilter* pUsingFilter, HANDLE hAbortEvent, DWORD dwFlags) PURE; \
+ STDMETHOD_(HRESULT,Reconfigure)(THIS_ IGraphConfigCallback* pCallback, PVOID pvContext, DWORD dwFlags, HANDLE hAbortEvent) PURE; \
+ STDMETHOD_(HRESULT,AddFilterToCache)(THIS_ IBaseFilter* pFilter) PURE; \
+ STDMETHOD_(HRESULT,EnumCacheFilter)(THIS_ IEnumFilters** pEnum) PURE; \
+ STDMETHOD_(HRESULT,RemoveFilterFromCache)(THIS_ IBaseFilter* pFilter) PURE; \
+ STDMETHOD_(HRESULT,GetStartTime)(THIS_ REFERENCE_TIME* prtStart) PURE; \
+ STDMETHOD_(HRESULT,PushThroughData)(THIS_ IPin* pOutputPin, IPinConnection* pConnection, HANDLE hEventAbort) PURE; \
+ STDMETHOD_(HRESULT,SetFilterFlags)(THIS_ IBaseFilter* pFilter, DWORD dwFlags) PURE; \
+ STDMETHOD_(HRESULT,GetFilterFlags)(THIS_ IBaseFilter* pFilter, DWORD* pdwFlags) PURE; \
+ STDMETHOD_(HRESULT,RemoveFilterEx)(THIS_ IBaseFilter* pFilter, DWORD Flags) PURE;
+
+HRESULT CALLBACK IGraphConfig_Reconnect_Proxy(
+ IGraphConfig* This,
+ IPin* pOutputPin,
+ IPin* pInputPin,
+ const AM_MEDIA_TYPE* pmtFirstConnection,
+ IBaseFilter* pUsingFilter,
+ HANDLE hAbortEvent,
+ DWORD dwFlags);
+void __RPC_STUB IGraphConfig_Reconnect_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IGraphConfig_Reconfigure_Proxy(
+ IGraphConfig* This,
+ IGraphConfigCallback* pCallback,
+ PVOID pvContext,
+ DWORD dwFlags,
+ HANDLE hAbortEvent);
+void __RPC_STUB IGraphConfig_Reconfigure_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IGraphConfig_AddFilterToCache_Proxy(
+ IGraphConfig* This,
+ IBaseFilter* pFilter);
+void __RPC_STUB IGraphConfig_AddFilterToCache_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IGraphConfig_EnumCacheFilter_Proxy(
+ IGraphConfig* This,
+ IEnumFilters** pEnum);
+void __RPC_STUB IGraphConfig_EnumCacheFilter_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IGraphConfig_RemoveFilterFromCache_Proxy(
+ IGraphConfig* This,
+ IBaseFilter* pFilter);
+void __RPC_STUB IGraphConfig_RemoveFilterFromCache_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IGraphConfig_GetStartTime_Proxy(
+ IGraphConfig* This,
+ REFERENCE_TIME* prtStart);
+void __RPC_STUB IGraphConfig_GetStartTime_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IGraphConfig_PushThroughData_Proxy(
+ IGraphConfig* This,
+ IPin* pOutputPin,
+ IPinConnection* pConnection,
+ HANDLE hEventAbort);
+void __RPC_STUB IGraphConfig_PushThroughData_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IGraphConfig_SetFilterFlags_Proxy(
+ IGraphConfig* This,
+ IBaseFilter* pFilter,
+ DWORD dwFlags);
+void __RPC_STUB IGraphConfig_SetFilterFlags_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IGraphConfig_GetFilterFlags_Proxy(
+ IGraphConfig* This,
+ IBaseFilter* pFilter,
+ DWORD* pdwFlags);
+void __RPC_STUB IGraphConfig_GetFilterFlags_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IGraphConfig_RemoveFilterEx_Proxy(
+ IGraphConfig* This,
+ IBaseFilter* pFilter,
+ DWORD Flags);
+void __RPC_STUB IGraphConfig_RemoveFilterEx_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+/*****************************************************************************
+ * IGraphConfigCallback interface
+ */
+DEFINE_GUID(IID_IGraphConfigCallback, 0xade0fd60, 0xd19d, 0x11d2, 0xab,0xf6, 0x00,0xa0,0xc9,0x05,0xf3,0x75);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IGraphConfigCallback : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE Reconfigure(
+ PVOID pvContext,
+ DWORD dwFlags) = 0;
+
+};
+#else
+typedef struct IGraphConfigCallbackVtbl IGraphConfigCallbackVtbl;
+struct IGraphConfigCallback {
+ const IGraphConfigCallbackVtbl* lpVtbl;
+};
+struct IGraphConfigCallbackVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IGraphConfigCallback* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IGraphConfigCallback* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IGraphConfigCallback* This);
+
+ /*** IGraphConfigCallback methods ***/
+ HRESULT (STDMETHODCALLTYPE *Reconfigure)(
+ IGraphConfigCallback* This,
+ PVOID pvContext,
+ DWORD dwFlags);
+
+};
+
+/*** IUnknown methods ***/
+#define IGraphConfigCallback_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IGraphConfigCallback_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IGraphConfigCallback_Release(p) (p)->lpVtbl->Release(p)
+/*** IGraphConfigCallback methods ***/
+#define IGraphConfigCallback_Reconfigure(p,a,b) (p)->lpVtbl->Reconfigure(p,a,b)
+
+#endif
+
+#define IGraphConfigCallback_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; \
+ /*** IGraphConfigCallback methods ***/ \
+ STDMETHOD_(HRESULT,Reconfigure)(THIS_ PVOID pvContext, DWORD dwFlags) PURE;
+
+HRESULT CALLBACK IGraphConfigCallback_Reconfigure_Proxy(
+ IGraphConfigCallback* This,
+ PVOID pvContext,
+ DWORD dwFlags);
+void __RPC_STUB IGraphConfigCallback_Reconfigure_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+typedef struct IFilterChain IFilterChain;
+/*****************************************************************************
+ * IFilterChain interface
+ */
+DEFINE_GUID(IID_IFilterChain, 0xdcfbdcf6, 0x0dc2, 0x45f5, 0x9a,0xb2, 0x7c,0x33,0x0e,0xa0,0x9c,0x29);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IFilterChain : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE StartChain(
+ IBaseFilter* pStartFilter,
+ IBaseFilter* pEndFilter) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE PauseChain(
+ IBaseFilter* pStartFilter,
+ IBaseFilter* pEndFilter) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE StopChain(
+ IBaseFilter* pStartFilter,
+ IBaseFilter* pEndFilter) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE RemoveChain(
+ IBaseFilter* pStartFilter,
+ IBaseFilter* pEndFilter) = 0;
+
+};
+#else
+typedef struct IFilterChainVtbl IFilterChainVtbl;
+struct IFilterChain {
+ const IFilterChainVtbl* lpVtbl;
+};
+struct IFilterChainVtbl {
+ ICOM_MSVTABLE_COMPAT_FIELDS
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IFilterChain* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IFilterChain* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IFilterChain* This);
+
+ /*** IFilterChain methods ***/
+ HRESULT (STDMETHODCALLTYPE *StartChain)(
+ IFilterChain* This,
+ IBaseFilter* pStartFilter,
+ IBaseFilter* pEndFilter);
+
+ HRESULT (STDMETHODCALLTYPE *PauseChain)(
+ IFilterChain* This,
+ IBaseFilter* pStartFilter,
+ IBaseFilter* pEndFilter);
+
+ HRESULT (STDMETHODCALLTYPE *StopChain)(
+ IFilterChain* This,
+ IBaseFilter* pStartFilter,
+ IBaseFilter* pEndFilter);
+
+ HRESULT (STDMETHODCALLTYPE *RemoveChain)(
+ IFilterChain* This,
+ IBaseFilter* pStartFilter,
+ IBaseFilter* pEndFilter);
+
+};
+
+/*** IUnknown methods ***/
+#define IFilterChain_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IFilterChain_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IFilterChain_Release(p) (p)->lpVtbl->Release(p)
+/*** IFilterChain methods ***/
+#define IFilterChain_StartChain(p,a,b) (p)->lpVtbl->StartChain(p,a,b)
+#define IFilterChain_PauseChain(p,a,b) (p)->lpVtbl->PauseChain(p,a,b)
+#define IFilterChain_StopChain(p,a,b) (p)->lpVtbl->StopChain(p,a,b)
+#define IFilterChain_RemoveChain(p,a,b) (p)->lpVtbl->RemoveChain(p,a,b)
+
+#endif
+
+#define IFilterChain_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; \
+ /*** IFilterChain methods ***/ \
+ STDMETHOD_(HRESULT,StartChain)(THIS_ IBaseFilter* pStartFilter, IBaseFilter* pEndFilter) PURE; \
+ STDMETHOD_(HRESULT,PauseChain)(THIS_ IBaseFilter* pStartFilter, IBaseFilter* pEndFilter) PURE; \
+ STDMETHOD_(HRESULT,StopChain)(THIS_ IBaseFilter* pStartFilter, IBaseFilter* pEndFilter) PURE; \
+ STDMETHOD_(HRESULT,RemoveChain)(THIS_ IBaseFilter* pStartFilter, IBaseFilter* pEndFilter) PURE;
+
+HRESULT CALLBACK IFilterChain_StartChain_Proxy(
+ IFilterChain* This,
+ IBaseFilter* pStartFilter,
+ IBaseFilter* pEndFilter);
+void __RPC_STUB IFilterChain_StartChain_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFilterChain_PauseChain_Proxy(
+ IFilterChain* This,
+ IBaseFilter* pStartFilter,
+ IBaseFilter* pEndFilter);
+void __RPC_STUB IFilterChain_PauseChain_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFilterChain_StopChain_Proxy(
+ IFilterChain* This,
+ IBaseFilter* pStartFilter,
+ IBaseFilter* pEndFilter);
+void __RPC_STUB IFilterChain_StopChain_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IFilterChain_RemoveChain_Proxy(
+ IFilterChain* This,
+ IBaseFilter* pStartFilter,
+ IBaseFilter* pEndFilter);
+void __RPC_STUB IFilterChain_RemoveChain_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* __WIDL_STRMIF_H */
diff --git a/include/strmif.idl b/include/strmif.idl
new file mode 100644
index 0000000..c2ef913
--- /dev/null
+++ b/include/strmif.idl
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2002 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";
+
+#include "devenum.idl"
+
+#include "axcore.idl"
+
+#include "axextend.idl"
+
+#include "dyngraph.idl"
