From 7c8b85a2222554e05dac9a5a2635e7d1411ca565 Mon Sep 17 00:00:00 2001 From: Robert Shearman Date: Mon, 30 Jun 2003 20:24:52 +0000 Subject: [PATCH] - Added DShow headers. - Added needed const's in FilterGraph implementation. --- dlls/quartz/filtergraph.c | 10 +- include/Makefile.in | 8 + include/axcore.idl | 647 ++++ include/axextend.idl | 895 +++++ include/devenum.idl | 38 + include/dyngraph.idl | 150 + include/strmif.h | 7493 +++++++++++++++++++++++++++++++++++-- include/strmif.idl | 27 + 8 files changed, 8914 insertions(+), 354 deletions(-) create mode 100644 include/axcore.idl create mode 100644 include/axextend.idl create mode 100644 include/devenum.idl create mode 100644 include/dyngraph.idl create mode 100644 include/strmif.idl diff --git a/dlls/quartz/filtergraph.c b/dlls/quartz/filtergraph.c index 78719f55e3b..8b1cc539167 100644 --- a/dlls/quartz/filtergraph.c +++ b/dlls/quartz/filtergraph.c @@ -505,7 +505,7 @@ static HRESULT WINAPI Mediaseeking_CheckCapabilities(IMediaSeeking *iface, } 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_GetTimeFormat(IMediaSeeking *iface, } 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_IsUsingTimeFormat(IMediaSeeking *iface, } 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_GetCurrentPosition(IMediaSeeking *iface, 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 8a221f501f7..ade9121e89b 100644 --- a/include/Makefile.in +++ b/include/Makefile.in @@ -7,9 +7,16 @@ MODULE = none 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 @@ WINDOWS_INCLUDES = \ 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 00000000000..ecac8930ba2 --- /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 00000000000..9466e992c8f --- /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 00000000000..5022a78dc2c --- /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 00000000000..0138c107179 --- /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 66dd8b57960..4c7b9821445 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; + + 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); + +}; -#ifdef COBJMACROS /*** 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; + +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); + +}; -#ifdef COBJMACROS /*** 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; + +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); + +}; -#ifdef COBJMACROS /*** 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; + +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); + +}; -#ifdef COBJMACROS /*** 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 00000000000..c2ef913c8a5 --- /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"