| /* |
| * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
| */ |
| |
| interface IAMAnalogVideoDecoder; |
| interface IAMAnalogVideoEncoder; |
| interface IAMAudioInputMixer; |
| interface IAMAudioRendererStats; |
| interface IAMBufferNegotiation; |
| interface IAMCameraControl; |
| interface IAMCertifiedOutputProtection; |
| interface IAMClockSlave; |
| 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 IAMGraphBuilderCallback; |
| 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; |
| |
| #include <axextendenums.h> |
| |
| typedef struct |
| { |
| CLSID Clsid; |
| LPWSTR Name; |
| } REGFILTER; |
| |
| typedef enum tagTVAudioMode { |
| AMTVAUDIO_MODE_MONO = 0x0001, |
| AMTVAUDIO_MODE_STEREO = 0x0002, |
| AMTVAUDIO_MODE_LANG_A = 0x0010, |
| AMTVAUDIO_MODE_LANG_B = 0x0020, |
| AMTVAUDIO_MODE_LANG_C = 0x0040, |
| AMTVAUDIO_PRESET_STEREO = 0x0200, |
| AMTVAUDIO_PRESET_LANG_A = 0x1000, |
| AMTVAUDIO_PRESET_LANG_B = 0x2000, |
| AMTVAUDIO_PRESET_LANG_C = 0x4000 |
| } TVAudioMode; |
| |
| [ |
| 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 bOutputNeeded, |
| [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; |
| }; |
| |
| [case(2)] |
| struct |
| { |
| ULONG cPins2; |
| [size_is(cPins2)] const REGFILTERPINS2 *rgPins2; |
| }; |
| |
| [default] |
| ; |
| }; |
| |
| } 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] LPCOLESTR szInstance, |
| [in] REFCLSID Filter |
| ); |
| |
| HRESULT RegisterFilter |
| ( [in] REFCLSID clsidFilter, |
| [in] LPCWSTR Name, |
| [in, out] IMoniker **ppMoniker, |
| [in] const CLSID *pclsidCategory, |
| [in] LPCOLESTR 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); |
| } |
| |
| [ |
| local, |
| object, |
| uuid(5acd6aa0-f482-11ce-8b67-00aa00a3f1a6), |
| pointer_default(unique) |
| ] |
| interface IConfigAviMux : IUnknown |
| { |
| HRESULT SetMasterStream( |
| [in] LONG iStream); |
| |
| HRESULT GetMasterStream( |
| [out] LONG *pStream); |
| |
| HRESULT SetOutputCompatibilityIndex( |
| [in] BOOL fOldIndex); |
| |
| HRESULT GetOutputCompatibilityIndex( |
| [out] BOOL *pfOldIndex); |
| } |
| |
| [ |
| local, |
| object, |
| uuid(bee3d220-157b-11d0-bd23-00a0c911ce86), |
| pointer_default(unique) |
| ] |
| interface IConfigInterleaving : IUnknown |
| { |
| typedef enum InterleavingMode { |
| INTERLEAVE_NONE, |
| INTERLEAVE_CAPTURE, |
| INTERLEAVE_FULL, |
| INTERLEAVE_NONE_BUFFERED |
| } InterleavingMode; |
| |
| HRESULT put_Mode( |
| [in] InterleavingMode mode); |
| |
| HRESULT get_Mode( |
| [out] InterleavingMode *pMode); |
| |
| HRESULT put_Interleaving( |
| [in] const REFERENCE_TIME *prtInterleave, |
| [in] const REFERENCE_TIME *prtPreroll); |
| |
| HRESULT get_Interleaving( |
| [out] REFERENCE_TIME *prtInterleave, |
| [out] REFERENCE_TIME *prtPreroll); |
| } |
| |
| [ |
| local, |
| object, |
| uuid(9fd52741-176d-4b36-8f51-ca8f933223be), |
| pointer_default(unique) |
| ] |
| interface IAMClockSlave : IUnknown |
| { |
| HRESULT SetErrorTolerance( |
| [in] DWORD dwTolerance); |
| |
| HRESULT GetErrorTolerance( |
| [out] DWORD *pdwTolerance); |
| } |
| |
| typedef struct _AMCOPPSignature { |
| BYTE Signature[256]; |
| } AMCOPPSignature; |
| |
| typedef struct _AMCOPPCommand { |
| GUID macKDI; |
| GUID guidCommandID; |
| DWORD dwSequence; |
| DWORD bSizeData; |
| BYTE CommandData[4056]; |
| } AMCOPPCommand, *LPAMCOPPCommand; |
| |
| typedef struct _AMCOPPStatusInput { |
| GUID rApp; |
| GUID guidStatusRequestID; |
| DWORD dwSequence; |
| DWORD cbSizeData; |
| BYTE StatusData[4056]; |
| } AMCOPPStatusInput, *LPAMCOPPStatusInput; |
| |
| typedef struct _AMCOPPStatusOutput { |
| GUID macKDI; |
| DWORD cbSizeData; |
| BYTE COPPStatus[4076]; |
| } AMCOPPStatusOutput, *LPAMCOPPStatusOutput; |
| |
| [ |
| local, |
| object, |
| uuid(6feded3e-0ff1-4901-a2f1-43f7012c8515), |
| pointer_default(unique) |
| ] |
| interface IAMCertifiedOutputProtection : IUnknown |
| { |
| HRESULT KeyExchange ( |
| [out] GUID* pRandom, |
| [out] BYTE** VarLenCertGH, |
| [out] DWORD* pdwLengthCertGH); |
| |
| HRESULT SessionSequenceStart( |
| [in] AMCOPPSignature* pSig); |
| |
| HRESULT ProtectionCommand( |
| [in] const AMCOPPCommand* cmd); |
| |
| HRESULT ProtectionStatus( |
| [in] const AMCOPPStatusInput* pStatusInput, |
| [out] AMCOPPStatusOutput* pStatusOutput); |
| }; |
| |
| 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 |
| ); |
| } |
| |
| |
| /***************************************************************************** |
| * IAMStreamConfig interface |
| */ |
| [ |
| object, |
| uuid(c6e13340-30ac-11d0-a18c-00a0c9118956), |
| pointer_default(unique) |
| ] |
| interface IAMStreamConfig : IUnknown |
| { |
| typedef struct _VIDEO_STREAM_CONFIG_CAPS { |
| GUID guid; |
| ULONG VideoStandard; |
| SIZE InputSize; |
| SIZE MinCroppingSize; |
| SIZE MaxCroppingSize; |
| int CropGranularityX; |
| int CropGranularityY; |
| int CropAlignX; |
| int CropAlignY; |
| SIZE MinOutputSize; |
| SIZE MaxOutputSize; |
| int OutputGranularityX; |
| int OutputGranularityY; |
| int StretchTapsX; |
| int StretchTapsY; |
| int ShrinkTapsX; |
| int ShrinkTapsY; |
| LONGLONG MinFrameInterval; |
| LONGLONG MaxFrameInterval; |
| LONG MinBitsPerSecond; |
| LONG MaxBitsPerSecond; |
| } VIDEO_STREAM_CONFIG_CAPS; |
| |
| typedef struct _AUDIO_STREAM_CONFIG_CAPS { |
| GUID guid; |
| ULONG MinimumChannels; |
| ULONG MaximumChannels; |
| ULONG ChannelsGranularity; |
| ULONG MinimumBitsPerSample; |
| ULONG MaximumBitsPerSample; |
| ULONG BitsPerSampleGranularity; |
| ULONG MinimumSampleFrequency; |
| ULONG MaximumSampleFrequency; |
| ULONG SampleFrequencyGranularity; |
| } AUDIO_STREAM_CONFIG_CAPS; |
| |
| HRESULT SetFormat( [in] AM_MEDIA_TYPE *pmt); |
| HRESULT GetFormat( [in] AM_MEDIA_TYPE **pmt); |
| HRESULT GetNumberOfCapabilities( [out] int *piCount, [out] int *piSize); |
| HRESULT GetStreamCaps( [in] int iIndex, [out] AM_MEDIA_TYPE **pmt, |
| [out] BYTE *pSCC); |
| } |
| |
| |
| typedef enum tagVideoProcAmpProperty |
| { |
| VideoProcAmp_Brightness, |
| VideoProcAmp_Contrast, |
| VideoProcAmp_Hue, |
| VideoProcAmp_Saturation, |
| VideoProcAmp_Sharpness, |
| VideoProcAmp_Gamma, |
| VideoProcAmp_ColorEnable, |
| VideoProcAmp_WhiteBalance, |
| VideoProcAmp_BacklightCompensation, |
| VideoProcAmp_Gain |
| } VideoProcAmpProperty; |
| |
| typedef enum tagVideoProcAmpFlags |
| { |
| VideoProcAmp_Flags_Auto = 0x0001, |
| VideoProcAmp_Flags_Manual = 0x0002, |
| } VideoProcAmpFlags; |
| |
| /***************************************************************************** |
| * IAMVideoProcAmp interface |
| */ |
| [ |
| object, |
| uuid(c6e13360-30ac-11d0-a18c-00a0c9118956), |
| pointer_default(unique) |
| ] |
| interface IAMVideoProcAmp : IUnknown |
| { |
| HRESULT GetRange( [in] LONG Property, [out] LONG *pMin, [out] LONG *pMax, |
| [out] LONG *pSteppingDelta, [out] LONG *pDefault, |
| [out] LONG *pCapsFlags); |
| HRESULT Set( [in] LONG Property, [in] LONG lValue, [in] LONG Flags); |
| HRESULT Get( [in] LONG Property, [out] LONG *lValue, [out] LONG *Flags); |
| } |
| |
| |
| [ |
| 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); |
| |
| } |
| |
| typedef enum AM_STREAM_INFO_FLAGS |
| { |
| AM_STREAM_INFO_START_DEFINED = 0x01, |
| AM_STREAM_INFO_STOP_DEFINED = 0x02, |
| AM_STREAM_INFO_DISCARDING = 0x04, |
| AM_STREAM_INFO_STOP_SEND_EXTRA = 0x10 |
| } AM_STREAM_INFO_FLAGS; |
| |
| typedef struct AM_STREAM_INFO |
| { |
| REFERENCE_TIME tStart; |
| REFERENCE_TIME tStop; |
| DWORD dwStartCookie; |
| DWORD dwStopCookie; |
| DWORD dwFlags; |
| } AM_STREAM_INFO; |
| |
| [ |
| local, |
| object, |
| uuid(36b73881-c2c8-11cf-8b46-00805f6cef60), |
| pointer_default(unique) |
| ] |
| interface IAMStreamControl : IUnknown |
| { |
| HRESULT StartAt( |
| [in] const REFERENCE_TIME *ptStart, |
| [in] DWORD dwCookie); |
| |
| HRESULT StopAt( |
| [in] const REFERENCE_TIME *ptStop, |
| [in] BOOL bSendExtra, |
| [in] DWORD dwCookie); |
| |
| HRESULT GetInfo( |
| [out] AM_STREAM_INFO *pInfo); |
| } |
| |
| cpp_quote("#ifndef _IKsPropertySet_") |
| cpp_quote("#define _IKsPropertySet_") |
| cpp_quote("#define KSPROPERTY_SUPPORT_GET 1") |
| cpp_quote("#define KSPROPERTY_SUPPORT_SET 2") |
| |
| typedef enum AMPROPERTY_PIN |
| { |
| AMPROPERTY_PIN_CATEGORY, |
| AMPROPERTY_PIN_MEDIUM, |
| } AMPROPERTY_PIN; |
| |
| [ |
| object, |
| uuid(31efac30-515c-11d0-a9aa-00aa0061be93), |
| pointer_default(unique), |
| local |
| ] |
| interface IKsPropertySet : IUnknown |
| { |
| HRESULT Set( [in] REFGUID guidPropSet, |
| [in] DWORD dwPropID, |
| [in, size_is(cbInstanceData)] LPVOID pInstanceData, |
| [in] DWORD cbInstanceData, |
| [in, size_is(cbPropData)] LPVOID pPropData, |
| [in] DWORD cbPropData ); |
| |
| HRESULT Get( [in] REFGUID guidPropSet, |
| [in] DWORD dwPropID, |
| [in, size_is(cbInstanceData)] LPVOID pInstanceData, |
| [in] DWORD cbInstanceData, |
| [out, size_is(cbPropData)] LPVOID pPropData, |
| [in] DWORD cbPropData, |
| [out] DWORD *pcbReturned ); |
| |
| HRESULT QuerySupported( [in] REFGUID guidPropSet, |
| [in] DWORD dwPropID, |
| [out] DWORD *pTypeSupport); |
| } |
| cpp_quote("#endif /* _IKsPropertySet_ */") |
| |
| [ |
| local, |
| object, |
| uuid(6025a880-c0d5-11d0-bd4e-00a0c911ce86), |
| pointer_default(unique) |
| ] |
| interface IMediaPropertyBag : IPropertyBag |
| { |
| typedef IMediaPropertyBag *LPMEDIAPROPERTYBAG; |
| |
| HRESULT EnumProperty( |
| [in] ULONG iProperty, |
| [in, out] VARIANT *pvarPropertyName, |
| [in, out] VARIANT *pvarPropertyValue); |
| } |
| |
| |
| [ |
| local, |
| object, |
| uuid(5738e040-b67f-11d0-bd4d-00a0c911ce86), |
| pointer_default(unique) |
| ] |
| interface IPersistMediaPropertyBag : IPersist |
| { |
| HRESULT InitNew(void); |
| |
| HRESULT Load( |
| [in] IMediaPropertyBag *pPropBag, |
| [in] IErrorLog *pErrorLog); |
| |
| HRESULT Save( |
| [in] IMediaPropertyBag *pPropBag, |
| [in] BOOL fClearDirty, |
| [in] BOOL fSaveAllProperties); |
| |
| typedef IPersistMediaPropertyBag *LPPERSISTMEDIAPROPERTYBAG; |
| } |
| |
| [ |
| object, |
| uuid(36b73883-c2c8-11cf-8b46-00805f6cef60), |
| pointer_default(unique) |
| ] |
| interface ISeekingPassThru : IUnknown |
| { |
| HRESULT Init( [in] BOOL bSupportRendering, [in] IPin *pPin); |
| } |
| |
| enum _AM_FILTER_MISC_FLAGS |
| { |
| AM_FILTER_MISC_FLAGS_IS_RENDERER = 0x1, |
| AM_FILTER_MISC_FLAGS_IS_SOURCE = 0x2 |
| }; |
| |
| [ |
| local, |
| object, |
| uuid(2dd74950-a890-11d1-abe8-00a0c905f375), |
| pointer_default(unique) |
| ] |
| interface IAMFilterMiscFlags : IUnknown |
| { |
| ULONG GetMiscFlags(); |
| } |
| |
| [ |
| local, |
| object, |
| uuid(4995f511-9ddb-4f12-bd3b-f04611807b79), |
| pointer_default(unique) |
| ] |
| interface IAMGraphBuilderCallback : IUnknown |
| { |
| HRESULT SelectedFilter( |
| [in] IMoniker *pMon); |
| |
| HRESULT CreatedFilter( |
| [in] IBaseFilter *pFil); |
| } |
| |
| [ |
| local, |
| object, |
| uuid(d8d715a0-6e5e-11d0-b3f0-00aa003761c5), |
| pointer_default(unique) |
| ] |
| interface IAMVfwCaptureDialogs : IUnknown |
| { |
| HRESULT HasDialog( |
| [in] int dialog); |
| HRESULT ShowDialog( |
| [in] int dialog, |
| [in] HWND hwnd); |
| HRESULT SendDriverMessage( |
| [in] int dialog, |
| [in] int msg, |
| [in] long data1, |
| [in] long data2); |
| } |
| |
| [ |
| local, |
| object, |
| uuid(c6e13370-30ac-11d0-a18c-00a0c9118956), |
| pointer_default(unique) |
| ] |
| interface IAMCameraControl : IUnknown |
| { |
| HRESULT GetRange([in] long property, [out] long *min, [out] long *max, |
| [out] long *stepping_delta, [out] long *default_value, [out] long *flags); |
| HRESULT Set([in] long property, [in] long property_value, [in] long flags); |
| HRESULT Get([in] long property, [out] long *property_value, [out] long *flags); |
| } |
| |
| [ |
| local, |
| object, |
| uuid(6a2e0670-28e4-11d0-a18c-00a0c9118956), |
| pointer_default(unique) |
| ] |
| interface IAMVideoControl : IUnknown |
| { |
| HRESULT GetCaps([in] IPin *pin, [out] long *flags); |
| HRESULT SetMode([in] IPin *pin, long mode); |
| HRESULT GetMode([in] IPin *pin, [out] long *mode); |
| HRESULT GetCurrentActualFrameRate([in] IPin *pin, [out] LONGLONG *frame_rate); |
| HRESULT GetMaxAvailableFrameRate([in] IPin *pin, [in] long index, |
| [in] SIZE dimensions, [out] LONGLONG *frame_rate); |
| HRESULT GetFrameRateList([in] IPin *pin, [in] long index, [in] SIZE dimensions, |
| [out] long *list_size, [out] LONGLONG **frame_rate); |
| } |
| |
| [ |
| local, |
| object, |
| uuid(56ed71a0-af5f-11d0-b3f0-00aa003761c5), |
| pointer_default(unique) |
| ] |
| interface IAMBufferNegotiation : IUnknown |
| { |
| HRESULT SuggestAllocatorProperties([in] const ALLOCATOR_PROPERTIES *prop); |
| HRESULT GetAllocatorProperties([out] ALLOCATOR_PROPERTIES *prop); |
| } |
| |
| [ |
| local, |
| object, |
| uuid(c6e13344-30ac-11d0-a18c-00a0c9118956), |
| pointer_default(unique) |
| ] |
| interface IAMDroppedFrames : IUnknown |
| { |
| HRESULT GetNumDropped([out] long *number); |
| HRESULT GetNumNotDropped([out] long *number); |
| HRESULT GetDroppedInfo([in] long size, [out] long *array, [out] long *copied); |
| HRESULT GetAverageFrameSize([out] long *size); |
| } |
| |
| [ |
| local, |
| object, |
| uuid(62ea93ba-ec62-11d2-b770-00c04fb6bd3d), |
| pointer_default(unique) |
| ] |
| interface IAMLatency : IUnknown |
| { |
| HRESULT GetLatency([in, out] REFERENCE_TIME *latency); |
| } |
| |
| [ |
| local, |
| object, |
| uuid(f185fe76-e64e-11d2-b76e-00c04fb6bd3d), |
| pointer_default(unique) |
| ] |
| interface IAMPushSource : IAMLatency |
| { |
| HRESULT GetPushSourceFlags([out] ULONG *flags); |
| HRESULT SetPushSourceFlags([in] ULONG flags); |
| HRESULT SetStreamOffset([in] REFERENCE_TIME offset); |
| HRESULT GetStreamOffset([out] REFERENCE_TIME *offset); |
| HRESULT GetMaxStreamOffset([out] REFERENCE_TIME *offset); |
| HRESULT SetMaxStreamOffset([in] REFERENCE_TIME offset); |
| } |
| |
| [ |
| local, |
| object, |
| uuid(c6e13343-30ac-11d0-a18c-00a0c9118956), |
| pointer_default(unique) |
| ] |
| interface IAMVideoCompression : IUnknown |
| { |
| HRESULT put_KeyFrameRate([in] long frame_rate); |
| HRESULT get_KeyFrameRate([out] long *frame_rate); |
| HRESULT put_PFramesPerKeyFrame([in] long frame); |
| HRESULT get_PFramesPerKeyFrame([out] long *frame); |
| HRESULT put_Quality([in] double quality); |
| HRESULT get_Quality([out] double *quality); |
| HRESULT put_WindowSize([in] DWORDLONG size); |
| HRESULT get_WindowSize([out] DWORDLONG *size); |
| HRESULT GetInfo([out, size_is(*version_size)] LPWSTR version, [in, out] int *version_size, |
| [out, size_is(*description_size)] LPWSTR description, [in, out] int *description_size, |
| [out] long *frame_rate, [out] long *key, [out] double *quality, [out] long *capabilities); |
| HRESULT OverrideKeyFrame([in] long number); |
| HRESULT OverrideFrameSize([in] long number, [in] long size); |
| } |
| |
| [ |
| local, |
| object, |
| uuid(c6e13380-30ac-11d0-a18c-00a0c9118956), |
| pointer_default(unique) |
| ] |
| interface IAMCrossbar : IUnknown |
| { |
| HRESULT get_PinCounts([out] long *output, [out] long *intput); |
| HRESULT CanRoute([in] long output, [in] long input); |
| HRESULT Route([in] long output, [in] long input); |
| HRESULT get_IsRoutedTo([in] long output, [out] long *input); |
| HRESULT get_CrossbarPinInfo([in] BOOL is_input, [in] long index, |
| [out] long *related, [out] long *type); |
| } |
| |
| typedef enum tagAMTunerEventType |
| { |
| AMTUNER_EVENT_CHANGED = 0x0001, |
| } AMTunerEventType; |
| |
| [ |
| local, |
| object, |
| uuid(211a8760-03ac-11d1-8d13-00aa00bd8339), |
| pointer_default(unique) |
| ] |
| interface IAMTunerNotification : IUnknown |
| { |
| HRESULT OnEvent([in] AMTunerEventType event); |
| } |
| |
| typedef enum tagAMTunerModeType |
| { |
| AMTUNER_MODE_DEFAULT = 0x0000, |
| AMTUNER_MODE_TV = 0x0001, |
| AMTUNER_MODE_FM_RADIO = 0x0002, |
| AMTUNER_MODE_AM_RADIO = 0x0004, |
| AMTUNER_MODE_DSS = 0x0008, |
| } AMTunerModeType; |
| |
| [ |
| local, |
| object, |
| uuid(211a8761-03ac-11d1-8d13-00aa00bd8339), |
| pointer_default(unique) |
| ] |
| interface IAMTuner : IUnknown |
| { |
| HRESULT put_Channel([in] long channel, [in] long video, [in] long audio); |
| HRESULT get_Channel([out] long *channel, [out] long *video, [out] long *audio); |
| HRESULT ChannelMinMax([out] long *min, [out] long *max); |
| HRESULT put_CountryCode([in] long country); |
| HRESULT get_CountryCode([out] long *country); |
| HRESULT put_TuningSpace([in] long tuning_space); |
| HRESULT get_TuningSpace([out] long *tuning_space); |
| [local] HRESULT Logon([in] HANDLE user); |
| HRESULT Logout(); |
| HRESULT SignalPresent([out] long *signal_strength); |
| HRESULT put_Mode([in] AMTunerModeType mode); |
| HRESULT get_Mode([out] AMTunerModeType *mode); |
| HRESULT GetAvailableModes([out] long *modes); |
| HRESULT RegisterNotificationCallBack([in] IAMTunerNotification *notify, [in] long events); |
| HRESULT UnRegisterNotificationCallBack([in] IAMTunerNotification *notify); |
| } |
| |
| [ |
| local, |
| object, |
| uuid(211a8766-03ac-11d1-8d13-00aa00bd8339), |
| pointer_default(unique) |
| ] |
| interface IAMTVTuner : IAMTuner |
| { |
| HRESULT get_AvailableTVFormats([out] long *standard); |
| HRESULT get_TVFormat([out] long *standard); |
| HRESULT AutoTune([in] long channel, [out] long *signal); |
| HRESULT StoreAutoTune(); |
| HRESULT get_NumInputConnections([out] long *number); |
| HRESULT put_InputType([in] long index, [in] TunerInputType type); |
| HRESULT get_InputType([in] long index, [out] TunerInputType *type); |
| HRESULT put_ConnectInput([in] long index); |
| HRESULT get_ConnectInput([out] long *index); |
| HRESULT get_VideoFrequency([out] long *freq); |
| HRESULT get_AudioFrequency([out] long *freq); |
| } |
| |
| [ |
| local, |
| object, |
| uuid(e46a9787-2b71-444d-a4b5-1fab7b708d6a), |
| pointer_default(unique), |
| ] |
| interface IVideoFrameStep : IUnknown |
| { |
| HRESULT Step(DWORD frame_count, [in] IUnknown *filter); |
| HRESULT CanStep(long multiple, [in] IUnknown *filter); |
| HRESULT CancelStep(); |
| } |
| |
| cpp_quote("#if (_WIN32_WINNT >= 0x0601)") |
| [ |
| local, |
| object, |
| uuid(cf7b26fc-9a00-485b-8147-3e789d5e8f67), |
| pointer_default(unique) |
| ] |
| interface IAMAsyncReaderTimestampScaling : IUnknown |
| { |
| HRESULT GetTimestampMode( |
| [out] BOOL *pfRaw); |
| HRESULT SetTimestampMode( |
| [in] BOOL fRaw); |
| } |
| |
| [ |
| local, |
| object, |
| uuid(0e26a181-f40c-4635-8786-976284b52981), |
| pointer_default(unique) |
| ] |
| interface IAMPluginControl : IUnknown |
| { |
| HRESULT GetPreferredClsid( |
| [in] REFGUID subType, |
| [out] CLSID *clsid); |
| HRESULT GetPreferredClsidByIndex( |
| [in] DWORD index, |
| [out] GUID *subType, |
| [out] CLSID *clsid); |
| HRESULT SetPreferredClsid( |
| [in] REFGUID subType, |
| [in] const CLSID *clsid); |
| HRESULT IsDisabled( |
| [in] REFCLSID clsid); |
| HRESULT GetDisabledByIndex( |
| [in] DWORD index, |
| [out] CLSID *clsid); |
| HRESULT SetDisabled( |
| [in] REFCLSID clsid, |
| [in] BOOL disabled); |
| HRESULT IsLegacyDisabled( |
| [in] LPCWSTR dllName); |
| } |
| cpp_quote("#endif /*(_WIN32_WINNT >= 0x0601)*/") |
