summaryrefslogtreecommitdiffstats
path: root/dxsdk/Include/DShowIDL/axextend.idl
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--dxsdk/Include/DShowIDL/axextend.idl5169
1 files changed, 5169 insertions, 0 deletions
diff --git a/dxsdk/Include/DShowIDL/axextend.idl b/dxsdk/Include/DShowIDL/axextend.idl
new file mode 100644
index 00000000..257fb19a
--- /dev/null
+++ b/dxsdk/Include/DShowIDL/axextend.idl
@@ -0,0 +1,5169 @@
+//------------------------------------------------------------------------------
+// File: AXExtend.idl
+//
+// Desc: Extended streaming interface definitions for the ActiveMovie
+// streaming and synchronization architecture. Core streaming
+// interfaces are in AXCore.idl, and control interfaces for the
+// type library are in Control.odl.
+//
+// Copyright (c) 1992 - 2000, Microsoft Corporation. All rights reserved.
+//------------------------------------------------------------------------------
+
+
+// include after unknwn.idl, objidl.idl and axcore.idl
+
+
+// forward declarations - these are the interfaces declared in this file
+
+interface IEnumRegFilters;
+interface IFileSourceFilter;
+interface IFileSinkFilter;
+interface IFileSinkFilter2;
+interface IGraphBuilder;
+interface ICaptureGraphBuilder;
+interface ICaptureGraphBuilder2;
+interface IAMCopyCaptureFileProgress;
+interface IFilterMapper;
+interface IFilterMapper2;
+interface IMediaEventSink;
+interface IOverlay;
+interface IOverlayNotify;
+interface IOverlayNotify2;
+interface IQualityControl;
+interface ISeekingPassThru;
+interface IAMStreamConfig;
+interface IAMDevMemoryAllocator;
+interface IAMDevMemoryControl;
+interface IConfigInterleaving;
+interface IConfigAviMux;
+interface IAMVideoCompression;
+interface IAMVfwCaptureDialogs;
+interface IAMVfwCompressDialogs;
+interface IAMDroppedFrames;
+interface IAMAudioInputMixer;
+interface IAMBufferNegotiation;
+interface IAMAnalogVideoDecoder;
+interface IAMVideoProcAmp;
+interface IAMAnalogVideoEncoder;
+interface IAMCameraControl;
+interface IAMCrossbar;
+interface IAMTVTuner;
+interface IKsPropertySet;
+interface IAMPhysicalPinInfo;
+interface IAMExtDevice;
+interface IAMExtTransport;
+interface IAMTimecodeReader;
+interface IAMTimecodeGenerator;
+interface IAMTimecodeDisplay;
+interface IDrawVideoImage;
+interface IDecimateVideoImage;
+interface IAMVideoDecimationProperties;
+interface IAMPushSource;
+interface IAMAudioRendererStats;
+interface IAMLatency;
+interface IAMGraphStreams;
+interface IAMOverlayFX;
+interface IAMOpenProgress;
+interface IMpeg2Demultiplexer ;
+interface IMPEG2StreamIdMap ;
+interface IEnumStreamIdMap ;
+interface IAMClockSlave ;
+interface IEncoderAPI;
+interface IVideoEncoder;
+interface IAMGraphBuilderCallback;
+interface IAMCertifiedOutputProtection;
+
+//==========================================================================
+//==========================================================================
+// IEnumRegFilters interface -- enumerates registered filters.
+// enumerator interface returned from IFilterMapper::EnumMatchingFilters().
+// based on IEnum pseudo-template
+//==========================================================================
+//==========================================================================
+
+typedef struct {
+ CLSID Clsid; // class id of the filter
+ LPWSTR Name; // name of filter
+} REGFILTER;
+
+[
+object,
+uuid(56a868a4-0ad4-11ce-b03a-0020af0ba770),
+pointer_default(unique)
+]
+
+// The point of the mapper is to avoid loading filters. By looking in the
+// registry we can reduce the number of filters which must be loaded and tried.
+// This enumerator returns descriptors of filters (including the GUIDs that
+// CoCreateInstance can instantiate). The filters themselves are not loaded.
+
+interface IEnumRegFilters : IUnknown {
+ import "unknwn.idl";
+
+ // The caller must use CoTaskMemFree to free each REGFILTER* returned
+ // in the array.
+ HRESULT Next
+ ( [in] ULONG cFilters, // place this many filters...
+ [out] REGFILTER ** apRegFilter, // ...in this array of REGFILTER*
+ [out] ULONG * pcFetched // actual count passed returned here
+ );
+
+ // I can't think why anyone would want to skip, so it's not implemented.
+ // (anyone who thinks they know what they would be skipping over is probably
+ // missing some piece of the jigsaw). This ALWAYS returns E_NOTIMPL.
+
+ HRESULT Skip(
+ [in] ULONG cFilters
+ );
+
+ HRESULT Reset(void);
+
+ // No cloning either - also ALWAYS returns E_NOTIMPL.
+
+ HRESULT Clone(
+ [out] IEnumRegFilters **ppEnum
+ );
+}
+
+
+typedef IEnumRegFilters *PENUMREGFILTERS;
+
+//========================================================================
+//========================================================================
+// abstraction representing the registered information about filters.
+// This allows properties of filters to be looked up without loading them.
+//========================================================================
+//========================================================================
+
+[
+object,
+uuid(56a868a3-0ad4-11ce-b03a-0020af0ba770),
+pointer_default(unique)
+]
+interface IFilterMapper : IUnknown {
+ import "unknwn.idl";
+
+ //==========================================================================
+ // Registration functions.
+ // A filter should be registered before any other use.
+ // The registration can be NON_VOLATILE (i.e. permanent, do once ever)
+ // or VOLATILE (once per boot of the system).
+ // UnregisterFilter (obviously) removes the registration.
+ // The action of any of the other calls on unregistered filters is undefined.
+ // it will either work or you'll get an error, but I'm not saying which.
+ //==========================================================================
+
+ // Four predefined values controling the order in which filters are tried
+ // for intelligent graph building. Intermediate values are legal.
+ // Any value <=MERIT_DO_NOT_USE will mean that the filter will never
+ // be tried by the filtergrah to automatically complete a connection.
+
+ enum { MERIT_PREFERRED = 0x800000,
+ MERIT_NORMAL = 0x600000,
+ MERIT_UNLIKELY = 0x400000,
+ MERIT_DO_NOT_USE = 0x200000,
+ MERIT_SW_COMPRESSOR = 0x100000,
+ MERIT_HW_COMPRESSOR = 0x100050
+ };
+
+ // Register a filter
+
+ HRESULT RegisterFilter
+ ( [in] CLSID clsid, // GUID of the filter
+ [in] LPCWSTR Name, // Descriptive name for the filter
+ [in] DWORD dwMerit // DO_NOT_USE, UNLIKELY, NORMAL or PREFERRED.
+ );
+
+
+ // Register an identifiable instance of a filter. This deals with cases
+ // such as two similar sound cards which are driven by the same driver,
+ // but we want to choose which oif these cards the sound will come out of.
+ // This is not needed if there is only one instance of the filter
+ // (e.g. there is only one sound card in the machine) or if all instances
+ // of the filter are equivalent.
+
+ // The filter itself must have already been registered // ??? Is that true?
+ HRESULT RegisterFilterInstance
+ ( [in] CLSID clsid, // GUID of the filter
+ [in] LPCWSTR Name, // Descriptive name of instance.
+ [out] CLSID *MRId // Returned Media Resource Id. A
+ // locally unique id for this instance
+ // of this filter
+ );
+
+
+ HRESULT RegisterPin
+ ( [in] CLSID Filter, // GUID of filter
+ [in] LPCWSTR Name, // Name of the pin
+ [in] BOOL bRendered, // The filter renders this input
+ [in] BOOL bOutput, // TRUE if this is an Output pin
+ [in] BOOL bZero, // TRUE if OK for zero instances of pin
+ // In this case you will have to Create
+ // a pin to have even one instance
+ [in] BOOL bMany, // TRUE if OK for many instances of pin
+ [in] CLSID ConnectsToFilter, // Filter it connects to if it has
+ // subterranean connection, else NULL
+ [in] LPCWSTR ConnectsToPin // Name of pin it connects to
+ // NULL for output pins
+ );
+
+ HRESULT RegisterPinType
+ ( [in] CLSID clsFilter, // GUID of filter
+ [in] LPCWSTR strName, // Descriptive name of the pin
+ [in] CLSID clsMajorType, // Major type of the data stream
+ [in] CLSID clsSubType // Sub type of the data stream
+ );
+
+
+ HRESULT UnregisterFilter
+ ( [in] CLSID Filter // GUID of filter
+ );
+
+
+ HRESULT UnregisterFilterInstance
+ ( [in] CLSID MRId // Media Resource Id of this instance
+ );
+
+
+ HRESULT UnregisterPin
+ ( [in] CLSID Filter, // GUID of filter
+ [in] LPCWSTR Name // Name of the pin
+ );
+
+
+ // Set *ppEnum to be an enumerator for filters matching the requirements.
+
+ HRESULT EnumMatchingFilters
+ ( [out] IEnumRegFilters **ppEnum // enumerator returned
+ , [in] DWORD dwMerit // at least this merit needed
+ , [in] BOOL bInputNeeded // need at least one input pin
+ , [in] CLSID clsInMaj // input major type
+ , [in] CLSID clsInSub // input sub type
+ , [in] BOOL bRender // must the input be rendered?
+ , [in] BOOL bOututNeeded // need at least one output pin
+ , [in] CLSID clsOutMaj // output major type
+ , [in] CLSID clsOutSub // output sub type
+ );
+
+}
+
+// structure used to identify media types a pin handles. Used for
+// registration through IFilterMapper and IFilterMapper2
+//
+typedef struct
+{
+ const CLSID * clsMajorType;
+ const CLSID * clsMinorType;
+} REGPINTYPES;
+
+// describes pin for filter registration. Used for registration
+// through IFilterMapper and IFilterMapper2
+//
+typedef struct
+{
+ LPWSTR strName;
+
+ // The filter renders this input
+ BOOL bRendered;
+
+ // This is an Output pin
+ BOOL bOutput;
+
+ // OK to have zero instances of pin In this case you will have to
+ // Create a pin to have even one instance
+ BOOL bZero;
+
+ // OK to create many instance of pin
+ BOOL bMany;
+
+ const CLSID * clsConnectsToFilter;
+ const WCHAR * strConnectsToPin;
+
+ UINT nMediaTypes;
+ const REGPINTYPES * lpMediaType;
+} REGFILTERPINS;
+
+// mediums (as defined in the Windows NT DDK) for registration with
+// IFilterMapper2
+//
+typedef struct
+{
+ CLSID clsMedium;
+ DWORD dw1;
+ DWORD dw2;
+} REGPINMEDIUM;
+
+// flags for dwFlags in REFILTERPINS2
+enum
+{
+ // OK to have zero instances of pin In this case you will have to
+ // Create a pin to have even one instance
+ REG_PINFLAG_B_ZERO = 0x1,
+
+ // The filter renders this input
+ REG_PINFLAG_B_RENDERER = 0x2,
+
+ // OK to create many instance of pin
+ REG_PINFLAG_B_MANY = 0x4,
+
+ // This is an Output pin
+ REG_PINFLAG_B_OUTPUT = 0x8
+};
+
+
+// describes pin for filter registration through IFilterMapper2
+typedef struct
+{
+ // combination of REG_PINFLAG flags
+ DWORD dwFlags;
+
+ // number of instances of the pin if known
+ UINT cInstances;
+
+ UINT nMediaTypes;
+ [size_is(nMediaTypes)] const REGPINTYPES * lpMediaType;
+
+ UINT nMediums;
+ [size_is(nMediums)] const REGPINMEDIUM *lpMedium;
+
+ // pin category (for Kernel Streaming pins) as defined in the
+ // Windows NT DDK
+ const CLSID *clsPinCategory;
+
+} REGFILTERPINS2;
+
+// describes filter for registration through IFilterMapper2
+typedef struct
+{
+ DWORD dwVersion; // 1 or 2
+ DWORD dwMerit;
+
+ /* unnamed union */
+ [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 {
+ import "unknwn.idl";
+
+ // create or rename ActiveMovie category
+ HRESULT CreateCategory
+ ( [in] REFCLSID clsidCategory,
+ [in] DWORD dwCategoryMerit,
+ [in] LPCWSTR Description
+ );
+
+ HRESULT UnregisterFilter
+ ( [in] const CLSID *pclsidCategory,
+ [in] const OLECHAR *szInstance,
+ [in] REFCLSID Filter // GUID of filter
+ );
+
+ // Register a filter, pins, and media types under a category.
+ HRESULT RegisterFilter
+ ( [in] REFCLSID clsidFilter, // GUID of the filter
+ [in] LPCWSTR Name, // Descriptive name for the filter
+
+ // ppMoniker can be null. or *ppMoniker can contain the
+ // moniker where this filter data will be written;
+ // *ppMoniker will be set to null on return. or *ppMoniker
+ // can be null in which case the moniker will be returned
+ // with refcount.
+ [in, out] IMoniker **ppMoniker,
+
+ // can be null
+ [in] const CLSID *pclsidCategory,
+
+ // cannot be null
+ [in] const OLECHAR *szInstance,
+
+ // rest of filter and pin registration
+ [in] const REGFILTER2 *prf2
+ );
+
+ // Set *ppEnum to be an enumerator for filters matching the
+ // requirements.
+ HRESULT EnumMatchingFilters
+ ( [out] IEnumMoniker **ppEnum // enumerator returned
+ , [in] DWORD dwFlags // 0
+ , [in] BOOL bExactMatch // don't match wildcards
+ , [in] DWORD dwMerit // at least this merit needed
+ , [in] BOOL bInputNeeded // need at least one input pin
+ , [in] DWORD cInputTypes // Number of input types to match
+ // Any match is OK
+ , [size_is(cInputTypes*2)] const GUID *pInputTypes // input major+subtype pair array
+ , [in] const REGPINMEDIUM *pMedIn // input medium
+ , [in] const CLSID *pPinCategoryIn // input pin category
+ , [in] BOOL bRender // must the input be rendered?
+ , [in] BOOL bOutputNeeded // need at least one output pin
+ , [in] DWORD cOutputTypes // Number of output types to match
+ // Any match is OK
+ , [size_is(cOutputTypes*2)] const GUID *pOutputTypes // output major+subtype pair array
+ , [in] const REGPINMEDIUM *pMedOut // output medium
+ , [in] const CLSID *pPinCategoryOut // output pin category
+ );
+}
+
+[
+object,
+uuid(b79bb0b1-33c1-11d1-abe1-00a0c905f375),
+pointer_default(unique)
+]
+interface IFilterMapper3 : IFilterMapper2 {
+ // new interface to allow creating filters using the mapper's devenum instance
+ // primarily needed for out-of-proc access to a graph
+ HRESULT GetICreateDevEnum( [out] ICreateDevEnum **ppEnum );
+}
+
+//========================================================================
+//========================================================================
+// Defines IQualityControl interface
+//
+// Defines quality messages and allows a quality manager to install itself
+// as the sink for quality messages.
+//========================================================================
+//========================================================================
+
+typedef enum tagQualityMessageType {
+ Famine,
+ Flood
+} QualityMessageType;
+
+typedef struct tagQuality {
+ QualityMessageType Type;
+ long Proportion; // milli-units. 1000 = no change
+ // for Flood:
+ // What proportion of the media samples currently
+ // coming through are required in the future.
+ // 800 means please drop another 20%
+ // For Famine:
+ // How much to "keep in" e.g. 800 means send me
+ // 20% less e.g. by dropping 20% of the samples.
+ // 1100 would mean "I'm coping, send me more".
+ REFERENCE_TIME Late;
+ // How much you need to catch up by
+ REFERENCE_TIME TimeStamp;
+ // The stream time when this was generated (probably
+ // corresponds to the start time on some sample).
+} Quality;
+
+typedef IQualityControl *PQUALITYCONTROL;
+
+
+[
+object,
+uuid(56a868a5-0ad4-11ce-b03a-0020af0ba770),
+pointer_default(unique)
+]
+interface IQualityControl : IUnknown {
+
+ // Notify the recipient that a quality change is requested.
+ // pSelf is the IBaseFilter* of the sender.
+ // this is sent from a filter
+ // to (the quality manager or) an upstream peer.
+ HRESULT Notify
+ ( [in] IBaseFilter * pSelf,
+ [in] Quality q
+ );
+
+ // Notify the recipient that future quality messages are to be sent
+ // to iqc. If piqc is NULL then quality messages are to default back to
+ // the upstream peer.
+ // This is sent from the quality manager to a filter.
+ // The recipient should hold piqc as a WEAK reference,
+ // i.e. do not AddRef it, do not Release it.
+ HRESULT SetSink
+ ( [in] IQualityControl * piqc
+ );
+}
+
+//=====================================================================
+//=====================================================================
+// Definitions required for overlay transport
+//=====================================================================
+//=====================================================================
+
+
+// Used to communicate the colour that the IOverlay client wants the window
+// painted in so that it can draw directly to the correct clipping region
+// A colour key can be described in two alternate ways, the first is by a
+// range of one or more (system) palette indices. The second is by defining
+// a colour cube with two RGB values, any of which would be acceptable.
+//
+// The CK values are consistent with GDI PALETTEINDEX and PALETTERGB macros
+
+
+enum { CK_NOCOLORKEY = 0x0, // No color key is required
+ CK_INDEX = 0x1, // Index into the current system palette
+ CK_RGB = 0x2 }; // Color key is an RGB value (or range)
+
+typedef struct tagCOLORKEY {
+
+ DWORD KeyType; // Explains meaning of the structure
+ DWORD PaletteIndex; // Palette index if available
+ COLORREF LowColorValue; // Low colour space RGB value
+ COLORREF HighColorValue; // Defines the high RGB value
+
+} COLORKEY;
+
+// When a filter sets up an advise link it can ask that only certain types
+// of notifications be sent, for example just palette changes. While this
+// doesn't mean that the other notification call backs won't ever be called
+// the IOverlay implementation may use this as an efficiency optimisation
+
+enum { ADVISE_NONE = 0x0, // No notifications required
+ ADVISE_CLIPPING = 0x1, // Synchronous clip information
+ ADVISE_PALETTE = 0x2, // Palette change notifications
+ ADVISE_COLORKEY = 0x4, // Called when colour key changes
+ ADVISE_POSITION = 0x8, // Likewise when window moves etc
+ ADVISE_DISPLAY_CHANGE = 0x10 // Called on WM_DISPLAYCHANGE
+ };
+
+const DWORD ADVISE_ALL = ADVISE_CLIPPING |
+ ADVISE_PALETTE |
+ ADVISE_COLORKEY |
+ ADVISE_POSITION;
+
+const DWORD ADVISE_ALL2 = ADVISE_ALL |
+ ADVISE_DISPLAY_CHANGE;
+
+// This isn't defined when you run IDL
+
+cpp_quote("#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;
+
+cpp_quote("#endif")
+
+
+//=====================================================================
+//=====================================================================
+// Defines IOverlayNotify interface
+//
+// This interface gives asynchronous notifications of changes to the
+// rendering window - such as changes to the exposed window area
+//=====================================================================
+//=====================================================================
+
+[
+object,
+local,
+uuid(56a868a0-0ad4-11ce-b03a-0020af0ba770),
+pointer_default(unique)
+]
+interface IOverlayNotify : IUnknown {
+
+ // IOverlayNotify methods
+
+ // This notifies the filter of palette changes, the filter should copy
+ // the array of RGBQUADs if it needs to use them after returning. This
+ // is not called when the palette is actually changed in the display
+ // but at a short time after (in sync with WM_PALETTECHANGED messages)
+
+ HRESULT OnPaletteChange(
+ [in] DWORD dwColors, // Number of colours present
+ [in] const PALETTEENTRY *pPalette); // Array of palette colours
+
+ // This provides synchronous clip changes so that the client is called
+ // before the window is moved to freeze the video, and then when the
+ // window has stabilised it is called again to start playback again.
+ // If the window rect is all zero then the window is invisible, the
+ // filter must take a copy of the information if it wants to keep it
+
+ HRESULT OnClipChange(
+ [in] const RECT *pSourceRect, // Region of video to use
+ [in] const RECT *pDestinationRect, // Where video goes
+ [in] const RGNDATA *pRgnData); // Defines clipping information
+
+ HRESULT OnColorKeyChange([in] const COLORKEY *pColorKey);
+
+ // The calls to OnClipChange happen in sync with the window. So it is
+ // called with an empty clip list before the window moves to freeze
+ // the video, and then when the window has stabilised it is called
+ // again with the new clip list. The OnPositionChange callback is for
+ // overlay cards that don't want the expense of synchronous clipping
+ // updates and just want to know when the source or destination video
+ // positions change. They will NOT be called in sync with the window
+ // but at some point after the window has changed (basicly in time
+ // with WM_SIZE etc messages received). This is therefore suitable
+ // for overlay cards that don't inlay their data to the frame buffer
+ // NOTE the destination is NOT clipped to the visible display area
+
+ HRESULT OnPositionChange([in] const RECT *pSourceRect,
+ [in] const RECT *pDestinationRect);
+}
+
+typedef IOverlayNotify *POVERLAYNOTIFY;
+
+
+//=====================================================================
+//=====================================================================
+// Defines IOverlayNotify2 interface
+//
+// This interface gives asynchronous notifications of changes to the
+// rendering window - such as changes to the exposed window area
+// This is optionally supported by the advise sink for the purposes
+// of accepting OnDisplayChange notification.
+//=====================================================================
+//=====================================================================
+
+cpp_quote("#if !defined(HMONITOR_DECLARED) && !defined(HMONITOR) && (WINVER < 0x0500)")
+cpp_quote("#define HMONITOR_DECLARED")
+cpp_quote("#if 0")
+typedef HANDLE HMONITOR;
+cpp_quote("#endif")
+cpp_quote("DECLARE_HANDLE(HMONITOR);")
+cpp_quote("#endif")
+
+[
+object,
+local,
+uuid(680EFA10-D535-11D1-87C8-00A0C9223196),
+pointer_default(unique)
+]
+interface IOverlayNotify2 : IOverlayNotify {
+
+ // IOverlayNotify2 methods
+
+ HRESULT OnDisplayChange( // ADVISE_DISPLAY_CHANGE
+ HMONITOR hMonitor);
+}
+
+typedef IOverlayNotify2 *POVERLAYNOTIFY2;
+
+
+//=====================================================================
+//=====================================================================
+// Defines IOverlay interface
+//
+// This interface provides information so that a filter can write direct to
+// the frame buffer while placing the video in the correct window position
+//=====================================================================
+//=====================================================================
+
+[
+object,
+local,
+uuid(56a868a1-0ad4-11ce-b03a-0020af0ba770),
+pointer_default(unique)
+]
+interface IOverlay : IUnknown {
+
+ // IOverlay methods
+
+ HRESULT GetPalette(
+ [out] DWORD *pdwColors, // Number of colours present
+ [out] PALETTEENTRY **ppPalette); // Where to put palette data
+
+ HRESULT SetPalette(
+ [in] DWORD dwColors, // Number of colours present
+ [in] PALETTEENTRY *pPalette); // Colours to use for palette
+
+ // If you change the colour key through SetColorKey then all the advise
+ // links will receive an OnColorKeyChange callback with the new colour
+
+ HRESULT GetDefaultColorKey([out] COLORKEY *pColorKey);
+ HRESULT GetColorKey([out] COLORKEY *pColorKey);
+ HRESULT SetColorKey([in,out] COLORKEY *pColorKey);
+ HRESULT GetWindowHandle([out] HWND *pHwnd);
+
+ // The IOverlay implementation allocates the memory for the clipping
+ // rectangles as it can be variable in length. The filter calling
+ // this method should free the memory when it is finished with it
+
+ HRESULT GetClipList([out] RECT *pSourceRect,
+ [out] RECT *pDestinationRect,
+ [out] RGNDATA **ppRgnData);
+
+ // Returns the current video source and destination
+
+ HRESULT GetVideoPosition([out] RECT *pSourceRect,
+ [out] RECT *pDestinationRect);
+
+ HRESULT Advise(
+ [in] IOverlayNotify *pOverlayNotify, // Notification interface
+ [in] DWORD dwInterests); // Callbacks interested in
+
+ HRESULT Unadvise(); // Stop the callbacks now
+}
+
+typedef IOverlay *POVERLAY;
+
+
+//=====================================================================
+//=====================================================================
+// control related interfaces (others are defined in control.odl)
+//=====================================================================
+//=====================================================================
+
+
+//=====================================================================
+//=====================================================================
+// Defines IMediaEventSink interface
+//
+// Exposed by filtergraph. Called by filters to notify events. Will be
+// passed on to application by the IMediaControl event methods.
+//=====================================================================
+//=====================================================================
+
+[
+ object,
+ uuid(56a868a2-0ad4-11ce-b03a-0020af0ba770),
+ pointer_default(unique)
+]
+interface IMediaEventSink : IUnknown {
+
+ // notify an event. will be queued, but not delivered to
+ // the application on this thread.
+ HRESULT Notify(
+ [in] long EventCode,
+ [in] LONG_PTR EventParam1,
+ [in] LONG_PTR EventParam2
+ );
+}
+
+typedef IMediaEventSink *PMEDIAEVENTSINK;
+
+//=====================================================================
+//=====================================================================
+// Defines IFileSourceFilter interface
+//
+// Exposed by source filters to set the file name and media type.
+//=====================================================================
+//=====================================================================
+
+[
+ object,
+ uuid(56a868a6-0ad4-11ce-b03a-0020af0ba770),
+ pointer_default(unique)
+]
+interface IFileSourceFilter : IUnknown {
+
+ // Load a file and assign it the given media type
+ HRESULT Load(
+ [in] LPCOLESTR pszFileName, // Pointer to absolute path of file to open
+ [in, unique] const AM_MEDIA_TYPE *pmt // Media type of file - can be NULL
+ );
+ // Get the currently loaded file name
+ HRESULT GetCurFile(
+ [out] LPOLESTR *ppszFileName, // Pointer to the path for the current file
+ [out] AM_MEDIA_TYPE *pmt // Pointer to the media type
+ );
+}
+
+typedef IFileSourceFilter *PFILTERFILESOURCE;
+
+//=====================================================================
+//=====================================================================
+// Defines IFileSinkFilter interface
+//
+// Exposed by renderers to set the output file name.
+//=====================================================================
+//=====================================================================
+
+[
+ object,
+ uuid(a2104830-7c70-11cf-8bce-00aa00a3f1a6),
+ pointer_default(unique)
+]
+interface IFileSinkFilter : IUnknown {
+
+ // Output to this file. default is to open the existing file
+ HRESULT SetFileName(
+ [in] LPCOLESTR pszFileName, // Pointer to absolute path of output file
+ [in, unique] const AM_MEDIA_TYPE *pmt // Media type of file - can be NULL
+ );
+ // Get the current file name
+ HRESULT GetCurFile(
+ [out] LPOLESTR *ppszFileName, // Pointer to the path for the current file
+ [out] AM_MEDIA_TYPE *pmt // Pointer to the media type
+ );
+}
+
+typedef IFileSinkFilter *PFILTERFILESINK;
+
+[
+ object,
+ uuid(00855B90-CE1B-11d0-BD4F-00A0C911CE86),
+ pointer_default(unique)
+]
+interface IFileSinkFilter2 : IFileSinkFilter {
+
+ HRESULT SetMode(
+ [in] DWORD dwFlags // AM_FILESINK_FLAGS
+ );
+
+ HRESULT GetMode(
+ [out] DWORD *pdwFlags // AM_FILESINK_FLAGS
+ );
+}
+
+typedef IFileSinkFilter2 *PFILESINKFILTER2;
+
+typedef enum {
+
+ // create a new file
+ AM_FILE_OVERWRITE = 0x00000001,
+
+} AM_FILESINK_FLAGS;
+
+
+//
+// Intelligent connectivity for filters - an interface supported by
+// filter graphs (since it is an extension to IFilterGraph) that supports
+// building of graphs by automatic selection and connection of appropriate
+// filters
+
+[
+ object,
+ uuid(56a868a9-0ad4-11ce-b03a-0020af0ba770),
+ pointer_default(unique)
+]
+interface IGraphBuilder : IFilterGraph {
+ // Connect these two pins directly or indirectly, using transform filters
+ // if necessary.
+
+ HRESULT Connect
+ ( [in] IPin * ppinOut, // the output pin
+ [in] IPin * ppinIn // the input pin
+ );
+
+
+ // Connect this output pin directly or indirectly, using transform filters
+ // if necessary to something that will render it.
+
+ HRESULT Render
+ ( [in] IPin * ppinOut // the output pin
+ );
+
+
+ // Build a filter graph that will render this file using this play list.
+ // If lpwstrPlayList is NULL then it will use the default play list
+ // which will typically render the whole file.
+
+ HRESULT RenderFile
+ ( [in] LPCWSTR lpcwstrFile,
+ [in, unique] LPCWSTR lpcwstrPlayList
+ );
+
+
+ // Add to the filter graph a source filter for this file. This would
+ // be the same source filter that would be added by calling Render.
+ // This call gives you more control over building
+ // the rest of the graph, e.g. AddFilter(<a renderer of your choice>)
+ // and then Connect the two.
+ // The IBaseFilter* interface exposed by the source filter is returned
+ // in ppFilter, addrefed already for you
+ // The filter will be known by the name lpcwstrFIlterName
+ // nn this filter graph,
+ HRESULT AddSourceFilter
+ ( [in] LPCWSTR lpcwstrFileName,
+ [in, unique] LPCWSTR lpcwstrFilterName,
+ [out] IBaseFilter* *ppFilter
+ );
+
+
+ // If this call is made then trace information will be written to the
+ // file showing the actions taken in attempting to perform an operation.
+ HRESULT SetLogFile
+ ( [in] DWORD_PTR hFile // open file handle e.g. from CreateFile
+ );
+
+
+ // Request that the graph builder should return as soon as possible from
+ // its current task.
+ // Note that it is possible fot the following to occur in the following
+ // sequence:
+ // Operation begins; Abort is requested; Operation completes normally.
+ // This would be normal whenever the quickest way to finish an operation
+ // was to simply continue to the end.
+ HRESULT Abort();
+
+ // Return S_OK if the curent operation is to continue,
+ // return S_FALSE if the current operation is to be aborted.
+ // This method can be called as a callback from a filter which is doing
+ // some operation at the request of the graph.
+ HRESULT ShouldOperationContinue();
+
+}
+
+
+//
+// New capture graph builder
+
+[
+ object,
+ uuid(bf87b6e0-8c27-11d0-b3f0-00aa003761c5),
+ pointer_default(unique)
+]
+interface ICaptureGraphBuilder : IUnknown {
+
+ // Use this filtergraph
+ HRESULT SetFiltergraph(
+ [in] IGraphBuilder *pfg);
+
+ // what filtergraph are you using?
+ // *ppfg->Release() when you're done with it
+ HRESULT GetFiltergraph(
+ [out] IGraphBuilder **ppfg);
+
+ // creates a rendering section in the filtergraph consisting of a MUX
+ // of some filetype, and a file writer (and connects them together)
+ // *ppf->Release() when you're done with it
+ // *ppSink->Release() when you're done with it
+ HRESULT SetOutputFileName(
+ [in] const GUID *pType, // type of file to write, eg. MEDIASUBTYPE_Avi
+ [in] LPCOLESTR lpstrFile, // filename given to file writer
+ [out] IBaseFilter **ppf, // returns pointer to the MUX
+ [out] IFileSinkFilter **ppSink);// queried from file writer
+
+ // Looks for an interface on the filter and on the output pin of the given
+ // category. (Categories: CAPTURE/PREVIEW/VIDEOPORT/VBI etc. or
+ // NULL for "don't care".
+ // It will also look upstream and downstream of
+ // the pin for the interface, to find interfaces on renderers, MUXES, TV
+ // Tuners, etc.
+ // Call *ppint->Release() when you're done with it
+ [local] HRESULT FindInterface(
+ [in, unique] const GUID *pCategory, // can be NULL for all pins
+ [in] IBaseFilter *pf,
+ [in] REFIID riid,
+ [out] void **ppint);
+ [call_as(FindInterface)] HRESULT RemoteFindInterface(
+ [in, unique] const GUID *pCategory, // can be NULL for all pins
+ [in] IBaseFilter *pf,
+ [in] REFIID riid,
+ [out] IUnknown **ppint);
+
+ // Connects the pin of the given category of the source filter to the
+ // rendering filter, optionally through another filter (compressor?)
+ // For a non-NULL category, it will instantiate and connect additional
+ // required filters upstream too, like TV Tuners and Crossbars.
+ // If there is only one output pin on the source, use a NULL
+ // category. You can also have pSource be a pin
+ HRESULT RenderStream(
+ [in] const GUID *pCategory, // can be NULL if only one output pin
+ [in] IUnknown *pSource, // filter or pin
+ [in] IBaseFilter *pfCompressor,
+ [in] IBaseFilter *pfRenderer); // can be NULL
+
+ // Sends IAMStreamControl messages to the pin of the desired category, eg.
+ // "capture" or "preview"
+ // REFERENCE_TIME=NULL means NOW
+ // REFERENCE_TIME=MAX_TIME means never, or cancel previous request
+ // NULL controls all capture filters in the graph - you will get one
+ // notification for each filter with a pin of that category found
+ // returns S_FALSE if stop will be signalled before last sample is
+ // rendered.
+ // return a FAILURE code if the filter does not support IAMStreamControl
+ HRESULT ControlStream(
+ [in] const GUID *pCategory,
+ [in] IBaseFilter *pFilter,
+ [in] REFERENCE_TIME *pstart,
+ [in] REFERENCE_TIME *pstop,
+ [in] WORD wStartCookie, // high word reserved
+ [in] WORD wStopCookie); // high word reserved
+
+ // creates a pre-allocated file of a given size in bytes
+ HRESULT AllocCapFile(
+ [in] LPCOLESTR lpstr,
+ [in] DWORDLONG dwlSize);
+
+ // Copies the valid file data out of the old, possibly huge old capture
+ // file into a shorter new file.
+ // Return S_FALSE from your progress function to abort capture, S_OK to
+ // continue
+ HRESULT CopyCaptureFile(
+ [in] LPOLESTR lpwstrOld,
+ [in] LPOLESTR lpwstrNew,
+ [in] int fAllowEscAbort, // pressing ESC will abort?
+ [in] IAMCopyCaptureFileProgress *pCallback); // implement this to
+ // get progress
+}
+
+
+//
+// Capture graph builder "CopyCapturedFile" progress callback
+
+[
+ object,
+ uuid(670d1d20-a068-11d0-b3f0-00aa003761c5),
+ pointer_default(unique)
+]
+interface IAMCopyCaptureFileProgress : IUnknown {
+
+ // If you support this interface somewhere, this function will be called
+ // periodically while ICaptureGraphBuilder::CopyCaptureFile is executing
+ // to let you know the progress
+ //
+ // Return S_OK from this function to continue. Return S_FALSE to abort the
+ // copy
+ HRESULT Progress(
+ [in] int iProgress); // a number between 0 and 100 (%)
+}
+
+
+//
+// Capture graph builder that can deal with a single filter having more than
+// one pin of each category... some new devices can capture both audio and
+// video, for example
+//
+
+[
+ object,
+ uuid(93E5A4E0-2D50-11d2-ABFA-00A0C9C6E38D),
+ pointer_default(unique)
+]
+interface ICaptureGraphBuilder2 : IUnknown {
+
+ // Use this filtergraph
+ HRESULT SetFiltergraph(
+ [in] IGraphBuilder *pfg);
+
+ // what filtergraph are you using?
+ // *ppfg->Release() when you're done with it
+ HRESULT GetFiltergraph(
+ [out] IGraphBuilder **ppfg);
+
+ // creates a rendering section in the filtergraph consisting of a MUX
+ // of some filetype, and a file writer (and connects them together)
+ // *ppf->Release() when you're done with it
+ // *ppSink->Release() when you're done with it
+ HRESULT SetOutputFileName(
+ [in] const GUID *pType, // GUID of MUX filter to use
+ [in] LPCOLESTR lpstrFile, // filename given to file writer
+ [out] IBaseFilter **ppf, // returns pointer to the MUX
+ [out] IFileSinkFilter **ppSink);// queried from file writer
+
+ // Looks for an interface on the filter and on the output pin of the given
+ // category and type. (Categories: CAPTURE/PREVIEW/VIDEOPORT/VBI etc. or
+ // NULL for "don't care". Type: MAJORTYPE_Video/Audio etc or NULL)
+ // !!! Will some filters have >1 capture pin? ie RGB and MPEG?
+ // It will also look upstream and downstream of
+ // the pin for the interface, to find interfaces on renderers, MUXES, TV
+ // Tuners, etc.
+ // Call *ppint->Release() when you're done with it
+ [local] HRESULT FindInterface(
+ [in] const GUID *pCategory, // can be NULL for all pins
+ [in] const GUID *pType, // Audio/Video/??? or NULL (don't care)
+ [in] IBaseFilter *pf,
+ [in] REFIID riid,
+ [out] void **ppint);
+ [call_as(FindInterface)] HRESULT RemoteFindInterface(
+ [in] const GUID *pCategory, // can be NULL for all pins
+ [in] const GUID *pType, // Audio/Video/??? or NULL (don't care)
+ [in] IBaseFilter *pf,
+ [in] REFIID riid,
+ [out] IUnknown **ppint);
+
+ // Connects the pin of the given category and type of the source filter to
+ // the rendering filter, optionally through another filter (compressor?)
+ // (Type is a Majortype, like Video or Audio)
+ // For a non-NULL category, it will instantiate and connect additional
+ // required filters upstream too, like TV Tuners and Crossbars.
+ // If there is only one output pin on the source, use a NULL category
+ // and type. You can also have pSource be a pin
+ HRESULT RenderStream(
+ [in] const GUID *pCategory, // can be NULL if only one output pin
+ [in] const GUID *pType, // Major type (Video/Audio/etc)
+ [in] IUnknown *pSource, // filter or pin
+ [in] IBaseFilter *pfCompressor,
+ [in] IBaseFilter *pfRenderer); // can be NULL
+
+ // Sends IAMStreamControl messages to the pin of the desired category,
+ // (eg. "capture" or "preview") and of the desired type (eg. VIDEO or AUDIO)
+ // A category MUST be given. If a filter is given, a type must be too.
+ // REFERENCE_TIME=NULL means NOW
+ // REFERENCE_TIME=MAX_TIME means never, or cancel previous request
+ // NULL controls all capture filters in the graph - you will get one
+ // notification for each filter with a pin of that category found
+ // returns S_FALSE if stop will be signalled before last sample is
+ // rendered.
+ // return a FAILURE code if the filter does not support IAMStreamControl
+ HRESULT ControlStream(
+ [in] const GUID *pCategory,
+ [in] const GUID *pType, // Major type (Video/Audio/etc)
+ [in] IBaseFilter *pFilter,
+ [in] REFERENCE_TIME *pstart,
+ [in] REFERENCE_TIME *pstop,
+ [in] WORD wStartCookie, // high word reserved
+ [in] WORD wStopCookie); // high word reserved
+
+ // creates a pre-allocated file of a given size in bytes
+ HRESULT AllocCapFile(
+ [in] LPCOLESTR lpstr,
+ [in] DWORDLONG dwlSize);
+
+ // Copies the valid file data out of the old, possibly huge old capture
+ // file into a shorter new file.
+ // Return S_FALSE from your progress function to abort capture, S_OK to
+ // continue
+ HRESULT CopyCaptureFile(
+ [in] LPOLESTR lpwstrOld,
+ [in] LPOLESTR lpwstrNew,
+ [in] int fAllowEscAbort, // pressing ESC will abort?
+ [in] IAMCopyCaptureFileProgress *pCallback); // implement this to
+ // get progress
+ // Helper fn to find a certain pin on a filter.
+ HRESULT FindPin(
+ [in] IUnknown *pSource,
+ [in] PIN_DIRECTION pindir, // input or output?
+ [in] const GUID *pCategory, // what category? (or NULL)
+ [in] const GUID *pType, // what Major type (or NULL)
+ [in] BOOL fUnconnected, // must it be unconnected?
+ [in] int num, // which pin matching this? (0 based)
+ [out] IPin **ppPin);
+}
+
+enum _AM_RENSDEREXFLAGS {
+ AM_RENDEREX_RENDERTOEXISTINGRENDERERS = 0x01 // Dont add any renderers
+};
+
+//
+// IFilterGraph2
+//
+// New methods on for IFilterGraph and IGraphBuilder will have to go here.
+//
+
+[
+ object,
+ uuid(36b73882-c2c8-11cf-8b46-00805f6cef60),
+ pointer_default(unique)
+]
+interface IFilterGraph2: IGraphBuilder {
+
+ // Add a Moniker source moniker
+ HRESULT AddSourceFilterForMoniker(
+ [in] IMoniker *pMoniker,
+ [in] IBindCtx *pCtx,
+ [in, unique] LPCWSTR lpcwstrFilterName,
+ [out] IBaseFilter **ppFilter
+ );
+
+ // Specify the type for a reconnect
+ // This is better than Reconnect as sometime the parties to a
+ // reconnection can't remember what type they'd agreed (!)
+ HRESULT ReconnectEx
+ ( [in] IPin * ppin, // the pin to disconnect and reconnect
+ [in, unique] const AM_MEDIA_TYPE *pmt // the type to reconnect with - can be NULL
+ );
+
+ // Render a pin without adding any new renderers
+ HRESULT RenderEx( [in] IPin *pPinOut, // Pin to render
+ [in] DWORD dwFlags, // flags
+ [in, out] DWORD *pvContext // Unused - set to NULL
+ );
+
+#if 0
+ // Method looks for a filter which supports the specified interface. If such
+ // a filter exists, an AddRef()'ed pointer to the requested interface is placed
+ // in *ppInterface.
+ //
+ // *ppInterface will be NULL on return if such a filter could not be found, and
+ // the method will return E_NOINTERFACE.
+ //
+ // pdwIndex is an internal index that is used for obtaining subsequent interfaces.
+ // *pdwIndex should be initialized to zero. It is set on return to a value that
+ // allows the implementation of FindFilterInterface to search for further interfaces
+ // if called again. If no more such interfaces exist, the method will return E_NOINTERFACE.
+ //
+ // If pdwIndex is NULL, FindFilterInterface returns an interface only if there is just
+ // a single filter in the graph that supports the interface. Otherwise it returns
+ // E_NOINTERFACE.
+ //
+ HRESULT FindFilterInterface( [in] REFIID iid, [out] void ** ppInterface, [in,out] LPDWORD pdwIndex );
+
+ // Tries to obtain the interface from the filter graph itself. If this fails,
+ // it attempts to find the unique filter that supports the interface.
+ // On failure the method will return E_NOINTERFACE. On success, it returns
+ // S_OK and an AddRef()'ed pointer to the requested interface in *ppInterface.
+ //
+ HRESULT FindInterface( [in] REFIID iid, [out] void ** ppInterface );
+
+#endif
+}
+
+//
+// StreamBuilder
+// aka Graph building with constraints
+// aka convergent graphs
+// aka Closed captioning
+
+[
+ object,
+ local,
+ uuid(56a868bf-0ad4-11ce-b03a-0020af0ba770),
+ pointer_default(unique)
+]
+interface IStreamBuilder : IUnknown {
+
+ // Connect this output pin directly or indirectly, using transform filters
+ // if necessary to thing(s) that will render it, within this graph
+ // Move from Initial state to Rendered state.
+
+ HRESULT Render
+ ( [in] IPin * ppinOut, // the output pin
+ [in] IGraphBuilder * pGraph // the graph
+ );
+
+ // Undo what you did in Render. Return to Initial state.
+ HRESULT Backout
+ ( [in] IPin * ppinOut, // the output pin
+ [in] IGraphBuilder * pGraph // the graph
+ );
+}
+
+
+// async reader interface - supported by file source filters. Allows
+// multiple overlapped reads from different positions
+
+
+[
+ object,
+ uuid(56a868aa-0ad4-11ce-b03a-0020af0ba770),
+ pointer_default(unique)
+]
+interface IAsyncReader : IUnknown
+{
+ // pass in your preferred allocator and your preferred properties.
+ // method returns the actual allocator to be used. Call GetProperties
+ // on returned allocator to learn alignment and prefix etc chosen.
+ // this allocator will be not be committed and decommitted by
+ // the async reader, only by the consumer.
+ // Must call this before calling Request.
+ HRESULT RequestAllocator(
+ [in] IMemAllocator* pPreferred,
+ [in] ALLOCATOR_PROPERTIES* pProps,
+ [out] IMemAllocator ** ppActual);
+
+ // queue a request for data.
+ // media sample start and stop times contain the requested absolute
+ // byte position (start inclusive, stop exclusive).
+ // may fail if sample not obtained from agreed allocator.
+ // may fail if start/stop position does not match agreed alignment.
+ // samples allocated from source pin's allocator may fail
+ // GetPointer until after returning from WaitForNext.
+ // Stop position must be aligned - this means it may exceed duration.
+ // on completion, stop position will be corrected to unaligned
+ // actual data.
+ HRESULT Request(
+ [in] IMediaSample* pSample,
+ [in] DWORD_PTR dwUser); // user context
+
+ // block until the next sample is completed or the timeout occurs.
+ // timeout (millisecs) may be 0 or INFINITE. Samples may not
+ // be delivered in order. If there is a read error of any sort, a
+ // notification will already have been sent by the source filter,
+ // and HRESULT will be an error.
+ // If ppSample is not null, then a Request completed with the result
+ // code returned.
+ HRESULT WaitForNext(
+ [in] DWORD dwTimeout,
+ [out] IMediaSample** ppSample, // completed sample
+ [out] DWORD_PTR * pdwUser); // user context
+
+ // sync read of data. Sample passed in must have been acquired from
+ // the agreed allocator. Start and stop position must be aligned.
+ // equivalent to a Request/WaitForNext pair, but may avoid the
+ // need for a thread on the source filter.
+ HRESULT SyncReadAligned(
+ [in] IMediaSample* pSample);
+
+
+ // sync read. works in stopped state as well as run state.
+ // need not be aligned. Will fail if read is beyond actual total
+ // length.
+ HRESULT SyncRead(
+ [in] LONGLONG llPosition, // absolute file position
+ [in] LONG lLength, // nr bytes required
+ [out, size_is(lLength)]
+ BYTE* pBuffer); // write data here
+
+ // return total length of stream, and currently available length.
+ // reads for beyond the available length but within the total length will
+ // normally succeed but may block for a long period.
+ HRESULT Length(
+ [out] LONGLONG* pTotal,
+ [out] LONGLONG* pAvailable);
+
+ // cause all outstanding reads to return, possibly with a failure code
+ //(VFW_E_TIMEOUT) indicating they were cancelled.
+ // Between BeginFlush and EndFlush calls, Request calls will fail and
+ // WaitForNext calls will always complete immediately.
+ HRESULT BeginFlush(void);
+ HRESULT EndFlush(void);
+}
+
+
+// interface provided by the filtergraph itself to let other objects
+// (especially plug-in distributors, but also apps like graphedt) know
+// when the graph has changed.
+[
+ object,
+ uuid(56a868ab-0ad4-11ce-b03a-0020af0ba770),
+ pointer_default(unique)
+]
+interface IGraphVersion : IUnknown
+{
+ // returns the current graph version number
+ // this is incremented every time there is a change in the
+ // set of filters in the graph or in their connections
+ //
+ // if this is changed since your last enumeration, then re-enumerate
+ // the graph
+ HRESULT QueryVersion(LONG* pVersion);
+}
+
+
+
+
+//
+// interface describing an object that uses resources.
+//
+// implement if: you request resources using IResourceManager. You will
+// need to pass your implementation of this pointer as an in param.
+//
+// use if: you are a resource manager who implements IResourceManager
+[
+ object,
+ uuid(56a868ad-0ad4-11ce-b03a-0020af0ba770),
+ pointer_default(unique)
+]
+interface IResourceConsumer : IUnknown
+{
+ // you may acquire the resource specified.
+ // return values:
+ // S_OK -- I have successfully acquired it
+ // S_FALSE -- I will acquire it and call NotifyAcquire afterwards
+ // VFW_S_NOT_NEEDED: I no longer need the resource
+ // FAILED(hr)-I tried to acquire it and failed.
+
+ HRESULT
+ AcquireResource(
+ [in] LONG idResource);
+
+
+
+ // Please release the resource.
+ // return values:
+ // S_OK -- I have released it (and want it again when available)
+ // S_FALSE -- I will call NotifyRelease when I have released it
+ // other something went wrong.
+ HRESULT
+ ReleaseResource(
+ [in] LONG idResource);
+}
+
+
+
+// interface describing a resource manager that will resolve contention for
+// named resources.
+//
+// implement if: you are a resource manager. The filtergraph will be a resource
+// manager, internally delegating to the system wide resource manager
+// (when there is one)
+//
+// use if: you need resources that are limited. Use the resource manager to
+// resolve contention by registering the resource with this interface,
+// and requesting it from this interface whenever needed.
+//
+// or use if: you detect focus changes which should affect resource usage.
+// Notifying change of focus to the resource manager will cause the resource
+// manager to switch contended resources to the objects that have the user's
+// focus
+[
+ object,
+ uuid(56a868ac-0ad4-11ce-b03a-0020af0ba770),
+ pointer_default(unique)
+]
+interface IResourceManager : IUnknown
+{
+ // tell the manager how many there are of a resource.
+ // ok if already registered. will take new count. if new count
+ // is lower, will de-allocate resources to new count.
+ //
+ // You get back a token that will be used in further calls.
+ //
+ // Passing a count of 0 will eliminate this resource. There is currently
+ // no defined way to find the id without knowing the count.
+ //
+ HRESULT
+ Register(
+ [in] LPCWSTR pName, // this named resource
+ [in] LONG cResource, // has this many instances
+ [out] LONG* plToken // token placed here on return
+ );
+
+ HRESULT
+ RegisterGroup(
+ [in] LPCWSTR pName, // this named resource group
+ [in] LONG cResource, // has this many resources
+ [in, size_is(cResource)]
+ LONG* palTokens, // these are the contained resources
+ [out] LONG* plToken // group resource id put here on return
+ );
+
+ // request the use of a given, registered resource.
+ // possible return values:
+ // S_OK == yes you can use it now
+ // S_FALSE == you will be called back when the resource is available
+ // other - there is an error.
+ //
+ // The priority of this request should be affected by the associated
+ // focus object -- that is, when SetFocus is called for that focus
+ // object (or a 'related' object) then my request should be put through.
+ //
+ // A filter should pass the filter's IUnknown here. The filtergraph
+ // will match filters to the filtergraph, and will attempt to trace
+ // filters to common source filters when checking focus objects.
+ // The Focus object must be valid for the entire lifetime of the request
+ // -- until you call CancelRequest or NotifyRelease(id, p, FALSE)
+ HRESULT
+ RequestResource(
+ [in] LONG idResource,
+ [in] IUnknown* pFocusObject,
+ [in] IResourceConsumer* pConsumer
+ );
+
+
+ // notify the resource manager that an acquisition attempt completed.
+ // Call this method after an AcquireResource method returned
+ // S_FALSE to indicate asynchronous acquisition.
+ // HR should be S_OK if the resource was successfully acquired, or a
+ // failure code if the resource could not be acquired.
+ HRESULT
+ NotifyAcquire(
+ [in] LONG idResource,
+ [in] IResourceConsumer* pConsumer,
+ [in] HRESULT hr);
+
+ // Notify the resource manager that you have released a resource. Call
+ // this in response to a ReleaseResource method, or when you have finished
+ // with the resource. bStillWant should be TRUE if you still want the
+ // resource when it is next available, or FALSE if you no longer want
+ // the resource.
+ HRESULT
+ NotifyRelease(
+ [in] LONG idResource,
+ [in] IResourceConsumer* pConsumer,
+ [in] BOOL bStillWant);
+
+ // I don't currently have the resource, and I no longer need it.
+ HRESULT
+ CancelRequest(
+ [in] LONG idResource,
+ [in] IResourceConsumer* pConsumer);
+
+ // Notify the resource manager that a given object has been given the
+ // user's focus. In ActiveMovie, this will normally be a video renderer
+ // whose window has received the focus. The filter graph will switch
+ // contended resources to (in order):
+ // requests made with this same focus object
+ // requests whose focus object shares a common source with this
+ // requests whose focus object shares a common filter graph
+ // After calling this, you *must* call ReleaseFocus before the IUnknown
+ // becomes invalid, unless you can guarantee that another SetFocus
+ // of a different object is done in the meantime. No addref is held.
+ //
+ // The resource manager will hold this pointer until replaced or cancelled,
+ // and will use it to resolve resource contention. It will call
+ // QueryInterface for IBaseFilter at least and if found will call methods on
+ // that interface.
+ HRESULT
+ SetFocus(
+ [in] IUnknown* pFocusObject);
+
+ // Sets the focus to NULL if the current focus object is still
+ // pFocusObject. Call this when
+ // the focus object is about to be destroyed to ensure that no-one is
+ // still referencing the object.
+ HRESULT
+ ReleaseFocus(
+ [in] IUnknown* pFocusObject);
+
+
+
+// !!! still need
+// -- app override (some form of SetPriority)
+// -- enumeration and description of resources
+
+}
+
+
+//
+// Interface representing an object that can be notified about state
+// and other changes within a filter graph. The filtergraph will call plug-in
+// distributors that expose this optional interface so that they can
+// respond to appropriate changes.
+//
+// Implement if: you are a plug-in distributor (your class id is found
+// under HKCR\Interface\<IID>\Distributor= for some interface).
+//
+// Use if: you are the filtergraph.
+[
+ object,
+ uuid(56a868af-0ad4-11ce-b03a-0020af0ba770),
+ pointer_default(unique)
+]
+interface IDistributorNotify : IUnknown
+{
+ // called when graph is entering stop state. Called before
+ // filters are stopped.
+ HRESULT Stop(void);
+
+ // called when graph is entering paused state, before filters are
+ // notified
+ HRESULT Pause(void);
+
+ // called when graph is entering running state, before filters are
+ // notified. tStart is the stream-time offset parameter that will be
+ // given to each filter's IBaseFilter::Run method.
+ HRESULT Run(REFERENCE_TIME tStart);
+
+ // called when the graph's clock is changing, with the new clock. Addref
+ // the clock if you hold it beyond this method. Called before
+ // the filters are notified.
+ HRESULT SetSyncSource(
+ [in] IReferenceClock * pClock);
+
+ // called when the set of filters or their connections has changed.
+ // Called on every AddFilter, RemoveFilter or ConnectDirect (or anything
+ // that will lead to one of these).
+ // You don't need to rebuild your list of interesting filters at this point
+ // but you should release any refcounts you hold on any filters that
+ // have been removed.
+ HRESULT NotifyGraphChange(void);
+}
+
+typedef enum {
+ AM_STREAM_INFO_START_DEFINED = 0x00000001,
+ AM_STREAM_INFO_STOP_DEFINED = 0x00000002,
+ AM_STREAM_INFO_DISCARDING = 0x00000004,
+ AM_STREAM_INFO_STOP_SEND_EXTRA = 0x00000010
+} AM_STREAM_INFO_FLAGS;
+
+// Stream information
+typedef struct {
+ REFERENCE_TIME tStart;
+ REFERENCE_TIME tStop;
+ DWORD dwStartCookie;
+ DWORD dwStopCookie;
+ DWORD dwFlags;
+} AM_STREAM_INFO;
+
+//
+// IAMStreamControl
+//
+
+[
+ object,
+ uuid(36b73881-c2c8-11cf-8b46-00805f6cef60),
+ pointer_default(unique)
+]
+interface IAMStreamControl : IUnknown
+{
+ // The REFERENCE_TIME pointers may be null, which
+ // indicates immediately. If the pointer is non-NULL
+ // and dwCookie is non-zero, then pins should send
+ // EC_STREAM_CONTROL_STOPPED / EC_STREAM_CONTROL_STARTED
+ // with an IPin pointer and the cookie, thus allowing
+ // apps to tie the events back to their requests.
+ // If either dwCookies is zero, or the pointer is null,
+ // then no event is sent.
+
+ // If you have a capture pin hooked up to a MUX input pin and they
+ // both support IAMStreamControl, you'll want the MUX to signal the
+ // stop so you know the last frame was written out. In order for the
+ // MUX to know it's finished, the capture pin will have to send one
+ // extra sample after it was supposed to stop, so the MUX can trigger
+ // off that. So you would set bSendExtra to TRUE for the capture pin
+ // Leave it FALSE in all other cases.
+
+ 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);
+}
+
+
+
+//
+// ISeekingPassThru
+//
+
+[
+ object,
+ uuid(36b73883-c2c8-11cf-8b46-00805f6cef60),
+ pointer_default(unique)
+]
+interface ISeekingPassThru : IUnknown
+{
+ HRESULT Init( [in] BOOL bSupportRendering,
+ [in] IPin *pPin);
+}
+
+
+
+//
+// IAMStreamConfig - pin interface
+//
+
+// A capture filter or compression filter's output pin
+// supports this interface - no matter what data type you produce.
+
+// This interface can be used to set the output format of a pin (as an
+// alternative to connecting the pin using a specific media type).
+// After setting an output format, the pin will use that format
+// the next time it connects to somebody, so you can just Render that
+// pin and get a desired format without using Connect(CMediaType)
+// Your pin should do that by ONLY OFFERING the media type set in SetFormat
+// in its enumeration of media types, and no others. This will ensure that
+// that format is indeed used for connection (or at least offer it first).
+// An application interested in enumerating accepted mediatypes may have to
+// do so BEFORE calling SetFormat.
+
+// But this interface's GetStreamCaps function can get more information
+// about accepted media types than the traditional way of enumerating a pin's
+// media types, so it should typically be used instead.
+// GetStreamCaps gets information about the kinds of formats allowed... how
+// it can stretch and crop, and the frame rate and data rates allowed (for
+// video)
+
+// VIDEO EXAMPLE
+//
+// GetStreamCaps returns a whole array of {MediaType, Capabilities}.
+// Let's say your capture card supports JPEG anywhere between 160x120 and
+// 320x240, and also the size 640x480. Also, say it supports RGB24 at
+// resolutions between 160x120 and 320x240 but only multiples of 8. You would
+// expose these properties by offering a media type of 320 x 240 JPEG
+// (if that is your default or preferred size) coupled with
+// capabilities saying minimum 160x120 and maximum 320x240 with granularity of
+// 1. The next pair you expose is a media type of 640x480 JPEG coupled with
+// capabilities of min 640x480 max 640x480. The third pair is media type
+// 320x240 RGB24 with capabilities min 160x120 max 320x240 granularity 8.
+// In this way you can expose almost every quirk your card might have.
+// An application interested in knowing what compression formats you provide
+// can get all the pairs and make a list of all the unique sub types of the
+// media types.
+//
+// If a filter's output pin is connected with a media type that has rcSource
+// and rcTarget not empty, it means the filter is being asked to stretch the
+// rcSource sub-rectangle of its InputSize (the format of the input pin for
+// a compressor, and the largest bitmap a capture filter can generate with
+// every pixel unique) into the rcTarget sub-rectangle of its output format.
+// For instance, if a video compressor has as input 160x120 RGB, and as output
+// 320x240 MPEG with an rcSource of (10,10,20,20) and rcTarget of (0,0,100,100)
+// this means the compressor is being asked to take a 10x10 piece of the 160x120
+// RGB bitmap, and make it fill the top 100x100 area of a 320x240 bitmap,
+// leaving the rest of the 320x240 bitmap untouched.
+// A filter does not have to support this and can fail to connect with a
+// media type where rcSource and rcTarget are not empty.
+//
+// Your output pin is connected to the next filter with a certain media
+// type (either directly or using the media type passed by SetFormat),
+// and you need to look at the AvgBytesPerSecond field of the format
+// of that mediatype to see what data rate you are being asked to compress
+// the video to, and use that data rate. Using the number of frames per
+// second in AvgTimePerFrame, you can figure out how many bytes each frame
+// is supposed to be. You can make it smaller, but NEVER EVER make a bigger
+// data rate. For a video compressor, your input pin's media type tells you
+// the frame rate (use that AvgTimePerFrame). For a capture filter, the
+// output media type tells you, so use that AvgTimePerFrame.
+//
+// The cropping rectangle described below is the same as the rcSrc of the
+// output pin's media type.
+//
+// The output rectangle described below is the same of the width and height
+// of the BITMAPINFOHEADER of the media type of the output pin's media type
+
+
+// AUDIO EXAMPLE
+//
+// This API can return an array of pairs of (media type, capabilities).
+// This can be used to expose all kinds of wierd capabilities. Let's say you
+// do any PCM frequency from 11,025 to 44,100 at 8 or 16 bit mono or
+// stereo, and you also do 48,000 16bit stereo as a special combination.
+// You would expose 3 pairs. The first pair would have Min Freq of 11025 and
+// Max Freq of 44100, with MaxChannels=2 and MinBits=8 and MaxBits=8 for the
+// capabilites structure, and a media type of anything you like, maybe
+// 22kHz, 8bit stereo as a default.
+// The 2nd pair would be the same except for MinBits=16 and MaxBits=16 in
+// the capabilities structure and the media type could be something like
+// 44kHz, 16bit stereo as a default (the media type in the pair should always
+// be something legal as described by the capabilities structure... the
+// structure tells you how you can change the media type to produce other
+// legal media types... for instance changing 44kHz to 29010Hz would be legal,
+// but changing bits from 16 to 14 would not be.)
+// The 3rd pair would be MinFreq=48000 MaxFreq=48000 MaxChannels=2
+// MinBits=16 and MaxBits=16, and the media type would be 48kHz 16bit stereo.
+// You can also use the Granularity elements of the structure (like the example
+// for video) if you support values that multiples of n, eg. you could say
+// minimum bits per sample 8, max 16, and granularity 8 to describe doing
+// either 8 or 16 bit all in one structure
+//
+// If you support non-PCM formats, the media type returned in GetStreamCaps
+// can show which non-PCM formats you support (with a default sample rate,
+// bit rate and channels) and the capabilities structure going with that
+// media type can describe which other sample rates, bit rates and channels
+// you support.
+
+[
+ object,
+ uuid(C6E13340-30AC-11d0-A18C-00A0C9118956),
+ pointer_default(unique)
+]
+interface IAMStreamConfig : IUnknown
+{
+
+ // this is the structure returned by a VIDEO filter
+ //
+ typedef struct _VIDEO_STREAM_CONFIG_CAPS {
+
+ GUID guid; // will be MEDIATYPE_Video
+
+ // the logical or of all the AnalogVideoStandard's supported
+ // typically zero if not supported
+ ULONG VideoStandard;
+
+ // the inherent size of the incoming signal... taken from the input
+ // pin for a compressor, or the largest size a capture filter can
+ // digitize the signal with every pixel still unique
+ SIZE InputSize;
+
+ // The input of a compressor filter may have to be connected for these
+ // to be known
+
+ // smallest rcSrc cropping rect allowed
+ SIZE MinCroppingSize;
+ // largest rcSrc cropping rect allowed
+ SIZE MaxCroppingSize;
+ // granularity of cropping size - eg only widths a multiple of 4 allowed
+ int CropGranularityX;
+ int CropGranularityY;
+ // alignment of cropping rect - eg rect must start on multiple of 4
+ int CropAlignX;
+ int CropAlignY;
+
+ // The input of a compressor filter may have to be connected for these
+ // to be known
+
+ // smallest bitmap this pin can produce
+ SIZE MinOutputSize;
+ // largest bitmap this pin can produce
+ SIZE MaxOutputSize;
+ // granularity of output bitmap size
+ int OutputGranularityX;
+ int OutputGranularityY;
+ // !!! what about alignment of rcTarget inside BIH if different?
+
+ // how well can you stretch in the x direction? 0==not at all
+ // 1=pixel doubling 2=interpolation(2 taps) 3=better interpolation
+ // etc.
+ int StretchTapsX;
+ int StretchTapsY;
+ // how well can you shrink in the x direction? 0==not at all
+ // 1=pixel doubling 2=interpolation(2 taps) 3=better interpolation
+ // etc.
+ int ShrinkTapsX;
+ int ShrinkTapsY;
+
+ // CAPTURE filter only - what frame rates are allowed?
+ LONGLONG MinFrameInterval;
+ LONGLONG MaxFrameInterval;
+
+ // what data rates can this pin produce?
+ LONG MinBitsPerSecond;
+ LONG MaxBitsPerSecond;
+ } VIDEO_STREAM_CONFIG_CAPS;
+
+
+ // this is the structure returned by an AUDIO filter
+ //
+ typedef struct _AUDIO_STREAM_CONFIG_CAPS {
+
+ GUID guid; // will be MEDIATYPE_Audio
+ ULONG MinimumChannels;
+ ULONG MaximumChannels;
+ ULONG ChannelsGranularity;
+ ULONG MinimumBitsPerSample;
+ ULONG MaximumBitsPerSample;
+ ULONG BitsPerSampleGranularity;
+ ULONG MinimumSampleFrequency;
+ ULONG MaximumSampleFrequency;
+ ULONG SampleFrequencyGranularity;
+ } AUDIO_STREAM_CONFIG_CAPS;
+
+ // - only allowed when pin is not streaming, else the call will FAIL
+ // - If your output pin is not yet connected, and you can
+ // connect your output pin with this media type, you should
+ // succeed the call, and start offering it first (enumerate as format#0)
+ // from GetMediaType so that this format will be used to connect with
+ // when you do connect to somebody
+ // - if your output pin is already connected, and you can provide this
+ // type, reconnect your pin. If the other pin can't accept it, FAIL
+ // this call and leave your connection alone.
+ HRESULT SetFormat(
+ [in] AM_MEDIA_TYPE *pmt);
+
+ // the format it's connected with, or will connect with
+ // the application is responsible for calling DeleteMediaType(*ppmt);
+ HRESULT GetFormat(
+ [out] AM_MEDIA_TYPE **ppmt);
+
+ // how many different Stream Caps structures are there?
+ // also, how big is the stream caps structure?
+ HRESULT GetNumberOfCapabilities(
+ [out] int *piCount,
+ [out] int *piSize); // pSCC of GetStreamCaps needs to be this big
+
+ // - gets one of the pairs of {Mediatype, Caps}
+ // - return S_FALSE if iIndex is too high
+ // - the application is responsible for calling DeleteMediaType(*ppmt);
+ // - the first thing pSCC points to is a GUID saying MEDIATYPE_Video
+ // or MEDIATYPE_Audio, so you can tell if you have a pointer to a
+ // VIDEO_STREAM_CONFIG_CAPS or an AUDIO_STREAM_CONFIG_CAPS structure
+ // There could potentially be many more possibilities other than video
+ // or audio.
+ HRESULT GetStreamCaps(
+ [in] int iIndex, // 0 to #caps-1
+ [out] AM_MEDIA_TYPE **ppmt,
+ [out] BYTE *pSCC);
+
+}
+
+
+
+// Interface to control interleaving of different streams in one file
+[
+object,
+uuid(BEE3D220-157B-11d0-BD23-00A0C911CE86),
+pointer_default(unique)
+]
+interface IConfigInterleaving : IUnknown
+{
+ import "unknwn.idl";
+
+ typedef enum
+ {
+ // uninterleaved - samples written out in the order they
+ // arrive.
+ INTERLEAVE_NONE,
+
+ // approximate interleaving with less overhead for video
+ // capture
+ INTERLEAVE_CAPTURE,
+
+ // full, precise interleaving. slower.
+ INTERLEAVE_FULL,
+
+ // samples written out in the order they arrive. writes are
+ // buffered
+ 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
+ );
+}
+
+// Interface to control the AVI mux
+[
+object,
+uuid(5ACD6AA0-F482-11ce-8B67-00AA00A3F1A6),
+pointer_default(unique)
+]
+interface IConfigAviMux : IUnknown
+{
+ import "unknwn.idl";
+
+ // control whether the AVI mux adjusts the frame rate or audio
+ // sampling rate for drift when the file is closed. -1 to disables
+ // this behavior.
+ HRESULT SetMasterStream([in] LONG iStream);
+ HRESULT GetMasterStream([out] LONG *pStream);
+
+ // control whether the AVI mux writes out an idx1 index chunk for
+ // compatibility with older AVI players.
+ HRESULT SetOutputCompatibilityIndex([in] BOOL fOldIndex);
+ HRESULT GetOutputCompatibilityIndex([out] BOOL *pfOldIndex);
+}
+
+ //---------------------------------------------------------------------
+ // CompressionCaps enum
+ //---------------------------------------------------------------------
+
+ // This tells you which features of IAMVideoCompression are supported
+
+ // CanCrunch means that it can compress video to a specified data rate
+ // If so, then the output pin's media type will contain that data rate
+ // in the format's AvgBytesPerSecond field, and that should be used.
+
+ typedef enum
+ {
+ CompressionCaps_CanQuality = 0x01,
+ CompressionCaps_CanCrunch = 0x02,
+ CompressionCaps_CanKeyFrame = 0x04,
+ CompressionCaps_CanBFrame = 0x08,
+ CompressionCaps_CanWindow = 0x10
+ } CompressionCaps;
+
+
+
+ //---------------------------------------------------------------------
+ // IAMVideoCompression interface
+ //
+ // Control compression parameters - pin interface
+ //---------------------------------------------------------------------
+
+ // This interface is implemented by the output pin of a video capture
+ // filter or video compressor that provides video data
+
+ // You use this interface to control how video is compressed... how
+ // many keyframes, etc., and to find information like capabilities and
+ // the description of this compressor
+
+ [
+ object,
+ uuid(C6E13343-30AC-11d0-A18C-00A0C9118956),
+ pointer_default(unique)
+ ]
+ interface IAMVideoCompression : IUnknown
+ {
+ // - Only valid if GetInfo's pCapabilities sets
+ // CompressionCaps_CanKeyFrame
+ // - KeyFrameRate < 0 means use the compressor default
+ // - KeyFrames == 0 means only the first frame is a key
+ HRESULT put_KeyFrameRate (
+ [in] long KeyFrameRate);
+
+ HRESULT get_KeyFrameRate (
+ [out] long * pKeyFrameRate);
+
+ // - Only valid if GetInfo's pCapabilities sets
+ // CompressionCaps_CanBFrame
+ // - If keyframes are every 10, and there are 3 P Frames per key,
+ // they will be spaced evenly between the key frames and the other
+ // 6 frames will be B frames
+ // - PFramesPerKeyFrame < 0 means use the compressor default
+ HRESULT put_PFramesPerKeyFrame (
+ [in] long PFramesPerKeyFrame);
+
+ HRESULT get_PFramesPerKeyFrame (
+ [out] long * pPFramesPerKeyFrame);
+
+ // - Only valid if GetInfo's pCapabilities sets
+ // CompressionCaps_CanQuality
+ // - Controls image quality
+ // - If you are compressing to a fixed data rate, a high quality
+ // means try and use all of the data rate, and a low quality means
+ // feel free to use much lower than the data rate if you want to.
+ // - Quality < 0 means use the compressor default
+ HRESULT put_Quality (
+ [in] double Quality);
+
+ HRESULT get_Quality (
+ [out] double * pQuality);
+
+ // If you have set a data rate of 100K/sec on a 10fps movie, that
+ // will normally mean each frame must be <=10K. But a window size
+ // means every consecutive n frames must average to the data rate,
+ // but an individual frame (if n > 1) is allowed to exceed the
+ // frame size suggested by the data rate
+ HRESULT put_WindowSize (
+ [in] DWORDLONG WindowSize);
+
+ HRESULT get_WindowSize (
+ [out] DWORDLONG * pWindowSize);
+
+ // - pszVersion might be "Version 2.1.0"
+ // - pszDescription might be "Danny's awesome video compressor"
+ // - pcbVersion and pcbDescription will be filled in with the
+ // required length if they are too short
+ // - *pCapabilities is a logical OR of some CompressionCaps flags
+ HRESULT GetInfo(
+ [out, size_is(*pcbVersion)] WCHAR * pszVersion,
+ [in,out] int *pcbVersion,
+ [out, size_is(*pcbDescription)] LPWSTR pszDescription,
+ [in,out] int *pcbDescription,
+ [out] long *pDefaultKeyFrameRate,
+ [out] long *pDefaultPFramesPerKey,
+ [out] double *pDefaultQuality,
+ [out] long *pCapabilities //CompressionCaps
+ );
+
+ // - this means when this frame number comes along after the graph
+ // is running, make it a keyframe even if you weren't going to
+ HRESULT OverrideKeyFrame(
+ [in] long FrameNumber
+ );
+
+ // - Only valid if GetInfo's pCapabilities sets
+ // CompressionCaps_CanCrunch
+ // - this means when this frame number comes along after the graph
+ // is running, make it this many bytes big instead of whatever size
+ // you were going to make it.
+ HRESULT OverrideFrameSize(
+ [in] long FrameNumber,
+ [in] long Size
+ );
+
+ }
+
+ //---------------------------------------------------------------------
+ // VfwCaptureDialogs enum
+ //---------------------------------------------------------------------
+
+ typedef enum
+ {
+ VfwCaptureDialog_Source = 0x01,
+ VfwCaptureDialog_Format = 0x02,
+ VfwCaptureDialog_Display = 0x04
+ } VfwCaptureDialogs;
+
+
+ //---------------------------------------------------------------------
+ // VfwCompressDialogs enum
+ //---------------------------------------------------------------------
+
+ typedef enum
+ {
+ VfwCompressDialog_Config = 0x01,
+ VfwCompressDialog_About = 0x02,
+ // returns S_OK if the dialog exists and can be shown, else S_FALSE
+ VfwCompressDialog_QueryConfig = 0x04,
+ VfwCompressDialog_QueryAbout = 0x08
+ } VfwCompressDialogs;
+
+
+ //---------------------------------------------------------------------
+ // IAMVfwCaptureDialogs - filter interface
+ //
+ // Show a VfW capture driver dialog - SOURCE, FORMAT, or DISPLAY
+ //---------------------------------------------------------------------
+
+ // This interface is supported only by Microsoft's Video For Windows
+ // capture driver Capture Filter. It allows an application to bring up
+ // one of the 3 driver dialogs that VfW capture drivers have.
+
+ [
+ object,
+ local,
+ uuid(D8D715A0-6E5E-11D0-B3F0-00AA003761C5),
+ pointer_default(unique)
+ ]
+ interface IAMVfwCaptureDialogs : IUnknown
+ {
+ HRESULT HasDialog(
+ [in] int iDialog // VfwCaptureDialogs enum
+ );
+
+ HRESULT ShowDialog(
+ [in] int iDialog, // VfwCaptureDialogs enum
+ [in] HWND hwnd
+ );
+
+ HRESULT SendDriverMessage(
+ [in] int iDialog, // VfwCaptureDialogs enum
+ [in] int uMsg,
+ [in] long dw1,
+ [in] long dw2
+ );
+
+ // - iDialog can be one of the VfwCaptureDialogs enums
+ // - HasDialog returns S_OK if it has the dialog, else S_FALSE
+ // - ShowDialog can only be called when not streaming or when another
+ // dialog is not already up
+ // - SendDriverMessage can send a private message to the capture driver.
+ // USE IT AT YOUR OWN RISK!
+ }
+
+ //---------------------------------------------------------------------
+ // IAMVfwCompressDialogs - filter interface
+ //
+ // Show a VfW codec driver dialog - CONFIG or ABOUT
+ //---------------------------------------------------------------------
+
+ // This interface is supported only by Microsoft's ICM Compressor filter
+ // (Co). It allows an application to bring up either the Configure or
+ // About dialogs for the ICM codec that it is currently using.
+
+ [
+ object,
+ local,
+ uuid(D8D715A3-6E5E-11D0-B3F0-00AA003761C5),
+ pointer_default(unique)
+ ]
+ interface IAMVfwCompressDialogs : IUnknown
+ {
+
+ // Bring up a dialog for this codec
+ HRESULT ShowDialog(
+ [in] int iDialog, // VfwCompressDialogs enum
+ [in] HWND hwnd
+ );
+
+ // Calls ICGetState and gives you the result
+ HRESULT GetState(
+ [out, size_is(*pcbState)] LPVOID pState,
+ [in, out] int *pcbState
+ );
+
+ // Calls ICSetState
+ HRESULT SetState(
+ [in, size_is(cbState)] LPVOID pState,
+ [in] int cbState
+ );
+
+ // Send a codec specific message
+ HRESULT SendDriverMessage(
+ [in] int uMsg,
+ [in] long dw1,
+ [in] long dw2
+ );
+
+ // - iDialog can be one of the VfwCaptureDialogs enums
+ // - ShowDialog can only be called when not streaming or when no other
+ // dialog is up already
+ // - an application can call GetState after ShowDialog(CONFIG) to
+ // see how the compressor was configured and next time the graph
+ // is used, it can call SetState with the data it saved to return
+ // the codec to the state configured by the dialog box from last time
+ // - GetState with a NULL pointer returns the size needed
+ // - SendDriverMessage can send a private message to the codec.
+ // USE IT AT YOUR OWN RISK!
+ }
+
+
+ //---------------------------------------------------------------------
+ // IAMDroppedFrames interface
+ //
+ // Report status of capture - pin interface
+ //---------------------------------------------------------------------
+
+ // A capture filter's video output pin supports this. It reports
+ // how many frames were not sent (dropped), etc.
+
+ // Every time your filter goes from STOPPED-->PAUSED, you reset all your
+ // counts to zero.
+
+ // An app may call this all the time while you are capturing to see how
+ // capturing is going. MAKE SURE you always return as current information
+ // as possible while you are running.
+
+ // When your capture filter starts running, it starts by sending frame 0,
+ // then 1, 2, 3, etc. The time stamp of each frame sent should correspond
+ // to the graph clock's time when the image was digitized. The end time
+ // is the start time plus the duration of the video frame.
+ // You should also set the MediaTime of each sample (SetMediaTime) as well.
+ // This should be the frame number ie (0,1) (1,2) (2,3).
+ // If a frame is dropped, a downstream filter will be able to tell easily
+ // not by looking for gaps in the regular time stamps, but by noticing a
+ // frame number is missing (eg. (1,2) (2,3) (4,5) (5,6) means frame 3
+ // was dropped.
+
+ // Using the info provided by this interface, an application can figure out
+ // the number of frames dropped, the frame rate achieved (the length of
+ // time the graph was running divided by the number of frames not dropped),
+ // and the data rate acheived (the length of time the graph was running
+ // divided by the average frame size).
+
+ // If your filter is running, then paused, and then run again, you need
+ // to continue to deliver frames as if it was never paused. The first
+ // frame after the second RUN cannot be time stamped earlier than the last
+ // frame sent before the pause.
+
+ // Your filter must always increment the MediaTime of each sample sent.
+ // Never send the same frame # twice, and never go back in time. The
+ // regular time stamp of a sample can also never go back in time.
+
+ [
+ object,
+ uuid(C6E13344-30AC-11d0-A18C-00A0C9118956),
+ pointer_default(unique)
+ ]
+ interface IAMDroppedFrames : IUnknown
+ {
+ // Get the number of dropped frames
+ HRESULT GetNumDropped(
+ [out] long * plDropped
+
+ );
+
+ //Get the number of non-dropped frames
+ HRESULT GetNumNotDropped(
+ [out] long * plNotDropped
+
+ );
+
+ // - plArray points to an array of lSize longs. The filter will
+ // fill it with the frame number of the first lSize frames dropped.
+ // A filter may not have bothered to remember as many as you asked
+ // for, so it will set *plNumCopied to the number of frames it filled
+ // in.
+ HRESULT GetDroppedInfo(
+ [in] long lSize,
+ [out] long * plArray,
+ [out] long * plNumCopied
+ );
+
+ // - This is the average size of the frames it didn't drop (in bytes)
+ HRESULT GetAverageFrameSize(
+ [out] long * plAverageSize
+
+ );
+
+ }
+
+
+
+ cpp_quote("#define AMF_AUTOMATICGAIN -1.0")
+
+ //---------------------------------------------------------------------
+ // IAMAudioInputMixer interface
+ //
+ // Sets the recording levels, pan and EQ for the audio card inputs
+ //---------------------------------------------------------------------
+
+ // This interface is implemented by each input pin of an audio capture
+ // filter, to tell it what level, panning, and EQ to use for each input.
+ // The name of each pin will reflect the type of input, eg. "Line input 1"
+ // or "Mic". An application uses the pin names to decide how it wants to
+ // set the recording levels
+
+ // This interface can also be supported by the audio capture filter itself
+ // to control to overall record level and panning after the mix
+
+ [
+ object,
+ uuid(54C39221-8380-11d0-B3F0-00AA003761C5),
+ pointer_default(unique)
+ ]
+ interface IAMAudioInputMixer : IUnknown
+ {
+ // This interface is only supported by the input pins, not the filter
+ // If disabled, this channel will not be mixed in as part of the
+ // recorded signal.
+ HRESULT put_Enable (
+ [in] BOOL fEnable); // TRUE=enable FALSE=disable
+
+ //Is this channel enabled?
+ HRESULT get_Enable (
+ [out] BOOL *pfEnable);
+
+ // When set to mono mode, making a stereo recording of this channel
+ // will have both channels contain the same data... a mixture of the
+ // left and right signals
+ HRESULT put_Mono (
+ [in] BOOL fMono); // TRUE=mono FALSE=multi channel
+
+ //all channels combined into a mono signal?
+ HRESULT get_Mono (
+ [out] BOOL *pfMono);
+
+ // !!! WILL CARDS BE ABLE TO BOOST THE GAIN?
+ //Set the record level for this channel
+ HRESULT put_MixLevel (
+ [in] double Level); // 0 = off, 1 = full (unity?) volume
+ // AMF_AUTOMATICGAIN, if supported,
+ // means automatic
+
+ //Get the record level for this channel
+ HRESULT get_MixLevel (
+ [out] double *pLevel);
+
+ // For instance, when panned full left, and you make a stereo recording
+ // of this channel, you will record a silent right channel.
+ HRESULT put_Pan (
+ [in] double Pan); // -1 = full left, 0 = centre, 1 = right
+
+ //Get the pan for this channel
+ HRESULT get_Pan (
+ [out] double *pPan);
+
+ // Boosts the bass of low volume signals before they are recorded
+ // to compensate for the fact that your ear has trouble hearing quiet
+ // bass sounds
+ HRESULT put_Loudness (
+ [in] BOOL fLoudness);// TRUE=on FALSE=off
+
+ HRESULT get_Loudness (
+ [out] BOOL *pfLoudness);
+
+ // boosts or cuts the treble of the signal before it's recorded by
+ // a certain amount of dB
+ HRESULT put_Treble (
+ [in] double Treble); // gain in dB (-ve = attenuate)
+
+ //Get the treble EQ for this channel
+ HRESULT get_Treble (
+ [out] double *pTreble);
+
+ // This is the maximum value allowed in put_Treble. ie 6.0 means
+ // any value between -6.0 and 6.0 is allowed
+ HRESULT get_TrebleRange (
+ [out] double *pRange); // largest value allowed
+
+ // boosts or cuts the bass of the signal before it's recorded by
+ // a certain amount of dB
+ HRESULT put_Bass (
+ [in] double Bass); // gain in dB (-ve = attenuate)
+
+ // Get the bass EQ for this channel
+ HRESULT get_Bass (
+ [out] double *pBass);
+
+ // This is the maximum value allowed in put_Bass. ie 6.0 means
+ // any value between -6.0 and 6.0 is allowed
+ HRESULT get_BassRange (
+ [out] double *pRange); // largest value allowed
+
+ }
+
+
+ //---------------------------------------------------------------------
+ // IAMBufferNegotiation interface
+ //
+ // Tells a pin what kinds of buffers to use when connected
+ //---------------------------------------------------------------------
+
+ // This interface can be implemented by any pin that will connect to
+ // another pin using IMemInputPin. All capture filters should support
+ // this interface.
+
+ // SuggestAllocatorProperties is a way for an application to get
+ // in on the buffer negotiation process for a pin. This pin will use
+ // the numbers given to it by the application as its request to the
+ // allocator. An application can use a negative number for any element
+ // in the ALLOCATOR_PROPERTIES to mean "don't care". An application must
+ // call this function before the pin is connected, or it will be too late
+ // To ensure that an application gets what it wants, it would be wise to
+ // call this method on both pins being connected together, so the other
+ // pin doesn't overrule the application's request.
+
+ // GetAllocatorProperties can only be called after a pin is connected and
+ // it returns the properties of the current allocator being used
+
+ [
+ object,
+ uuid(56ED71A0-AF5F-11D0-B3F0-00AA003761C5),
+ pointer_default(unique)
+ ]
+ interface IAMBufferNegotiation : IUnknown
+ {
+ HRESULT SuggestAllocatorProperties (
+ [in] const ALLOCATOR_PROPERTIES *pprop);
+
+ HRESULT GetAllocatorProperties (
+ [out] ALLOCATOR_PROPERTIES *pprop);
+
+ }
+
+
+ //---------------------------------------------------------------------
+ // AnalogVideoStandard enum
+ //---------------------------------------------------------------------
+
+ typedef enum tagAnalogVideoStandard
+ {
+ AnalogVideo_None = 0x00000000, // This is a digital sensor
+ AnalogVideo_NTSC_M = 0x00000001, // 75 IRE Setup
+ AnalogVideo_NTSC_M_J = 0x00000002, // Japan, 0 IRE Setup
+ AnalogVideo_NTSC_433 = 0x00000004,
+
+ AnalogVideo_PAL_B = 0x00000010,
+ AnalogVideo_PAL_D = 0x00000020,
+ AnalogVideo_PAL_G = 0x00000040,
+ AnalogVideo_PAL_H = 0x00000080,
+ AnalogVideo_PAL_I = 0x00000100,
+ AnalogVideo_PAL_M = 0x00000200,
+ AnalogVideo_PAL_N = 0x00000400,
+
+ AnalogVideo_PAL_60 = 0x00000800,
+
+ AnalogVideo_SECAM_B = 0x00001000,
+ AnalogVideo_SECAM_D = 0x00002000,
+ AnalogVideo_SECAM_G = 0x00004000,
+ AnalogVideo_SECAM_H = 0x00008000,
+ AnalogVideo_SECAM_K = 0x00010000,
+ AnalogVideo_SECAM_K1 = 0x00020000,
+ AnalogVideo_SECAM_L = 0x00040000,
+ AnalogVideo_SECAM_L1 = 0x00080000,
+
+ AnalogVideo_PAL_N_COMBO // Argentina
+ = 0x00100000
+ } AnalogVideoStandard;
+
+ cpp_quote("#define AnalogVideo_NTSC_Mask 0x00000007")
+ cpp_quote("#define AnalogVideo_PAL_Mask 0x00100FF0")
+ cpp_quote("#define AnalogVideo_SECAM_Mask 0x000FF000")
+
+
+ //---------------------------------------------------------------------
+ // TunerInputType enum
+ //---------------------------------------------------------------------
+
+ typedef enum tagTunerInputType
+ {
+ TunerInputCable,
+ TunerInputAntenna
+ } TunerInputType;
+
+ //---------------------------------------------------------------------
+ // VideoCopyProtectionType enum
+ //---------------------------------------------------------------------
+
+ typedef enum
+ {
+ VideoCopyProtectionMacrovisionBasic,
+ VideoCopyProtectionMacrovisionCBI
+ } VideoCopyProtectionType;
+
+ //---------------------------------------------------------------------
+ // PhysicalConnectorType enum
+ //---------------------------------------------------------------------
+
+ typedef enum tagPhysicalConnectorType
+ {
+ PhysConn_Video_Tuner = 1,
+ PhysConn_Video_Composite,
+ PhysConn_Video_SVideo,
+ PhysConn_Video_RGB,
+ PhysConn_Video_YRYBY,
+ PhysConn_Video_SerialDigital,
+ PhysConn_Video_ParallelDigital,
+ PhysConn_Video_SCSI,
+ PhysConn_Video_AUX,
+ PhysConn_Video_1394,
+ PhysConn_Video_USB,
+ PhysConn_Video_VideoDecoder,
+ PhysConn_Video_VideoEncoder,
+ PhysConn_Video_SCART,
+ PhysConn_Video_Black,
+
+
+ PhysConn_Audio_Tuner = 0x1000,
+ PhysConn_Audio_Line,
+ PhysConn_Audio_Mic,
+ PhysConn_Audio_AESDigital,
+ PhysConn_Audio_SPDIFDigital,
+ PhysConn_Audio_SCSI,
+ PhysConn_Audio_AUX,
+ PhysConn_Audio_1394,
+ PhysConn_Audio_USB,
+ PhysConn_Audio_AudioDecoder,
+ } PhysicalConnectorType;
+
+
+
+
+ //---------------------------------------------------------------------
+ // IAMAnalogVideoDecoder interface
+ //---------------------------------------------------------------------
+
+ [
+ object,
+ uuid(C6E13350-30AC-11d0-A18C-00A0C9118956),
+ pointer_default(unique)
+ ]
+ interface IAMAnalogVideoDecoder : IUnknown
+ {
+
+ //Gets the supported analog video standards (NTSC/M, PAL/B, SECAM/K1...
+ HRESULT get_AvailableTVFormats(
+ [out] long *lAnalogVideoStandard
+ );
+
+ //Sets or gets the current analog video standard (NTSC/M, PAL/B, SECAM/K1, ...
+ HRESULT put_TVFormat(
+ [in] long lAnalogVideoStandard
+ );
+
+ // Sets or gets the current analog video standard (NTSC/M, PAL/B, SECAM/K1, ...
+ HRESULT get_TVFormat(
+ [out] long * plAnalogVideoStandard
+ );
+
+ // True if horizontal sync is locked
+ HRESULT get_HorizontalLocked (
+ [out] long * plLocked);
+
+ // True if connected to a VCR (changes PLL timing)
+ HRESULT put_VCRHorizontalLocking (
+ [in] long lVCRHorizontalLocking);
+
+ HRESULT get_VCRHorizontalLocking (
+ [out] long * plVCRHorizontalLocking);
+
+ // Returns the number of lines in the video signal")]
+ HRESULT get_NumberOfLines (
+ [out] long *plNumberOfLines);
+
+ // Enables or disables the output bus
+ HRESULT put_OutputEnable (
+ [in] long lOutputEnable);
+
+ HRESULT get_OutputEnable (
+ [out] long *plOutputEnable);
+
+ }
+
+
+ //---------------------------------------------------------------------
+ // VideoProcAmp Property enum
+ //---------------------------------------------------------------------
+
+ typedef enum tagVideoProcAmpProperty
+ {
+ VideoProcAmp_Brightness,
+ VideoProcAmp_Contrast,
+ VideoProcAmp_Hue,
+ VideoProcAmp_Saturation,
+ VideoProcAmp_Sharpness,
+ VideoProcAmp_Gamma,
+ VideoProcAmp_ColorEnable,
+ VideoProcAmp_WhiteBalance,
+ VideoProcAmp_BacklightCompensation,
+ VideoProcAmp_Gain
+ } VideoProcAmpProperty;
+
+ //---------------------------------------------------------------------
+ // VideoProcAmp Flags enum
+ //---------------------------------------------------------------------
+
+ typedef enum tagVideoProcAmpFlags
+ {
+ VideoProcAmp_Flags_Auto = 0x0001,
+ VideoProcAmp_Flags_Manual = 0x0002
+ } VideoProcAmpFlags;
+
+ //---------------------------------------------------------------------
+ // IAMVideoProcAmp interface
+ //
+ // Adjusts video quality in either the analog or digital domain.
+ //
+ //---------------------------------------------------------------------
+
+ [
+ object,
+ uuid(C6E13360-30AC-11d0-A18C-00A0C9118956),
+ pointer_default(unique)
+ ]
+ interface IAMVideoProcAmp : IUnknown
+ {
+ // Returns min, max, step size, and default values
+ HRESULT GetRange(
+ [in] long Property, // Which property to query
+ [out] long * pMin, // Range minimum
+ [out] long * pMax, // Range maxumum
+ [out] long * pSteppingDelta,// Step size
+ [out] long * pDefault, // Default value
+ [out] long * pCapsFlags // VideoProcAmpFlags
+
+ );
+
+ // Set a VideoProcAmp property
+ HRESULT Set(
+ [in] long Property, // VideoProcAmpProperty
+ [in] long lValue, // Value to set
+ [in] long Flags // VideoProcAmp_Flags_*
+
+ );
+
+ // Get a VideoProcAmp property
+ HRESULT Get(
+ [in] long Property, // VideoProcAmpProperty
+ [out] long * lValue, // Current value
+ [out] long * Flags // VideoProcAmp_Flags_*
+ );
+ }
+
+
+ //---------------------------------------------------------------------
+ // CameraControl Property enum
+ //---------------------------------------------------------------------
+
+ typedef enum tagCameraControlProperty
+ {
+ CameraControl_Pan,
+ CameraControl_Tilt,
+ CameraControl_Roll,
+ CameraControl_Zoom,
+ CameraControl_Exposure,
+ CameraControl_Iris,
+ CameraControl_Focus
+ } CameraControlProperty;
+
+ //---------------------------------------------------------------------
+ // CameraControl Flags enum
+ //---------------------------------------------------------------------
+
+ typedef enum tagCameraControlFlags
+ {
+ CameraControl_Flags_Auto = 0x0001,
+ CameraControl_Flags_Manual = 0x0002
+ } CameraControlFlags;
+
+ //---------------------------------------------------------------------
+ // IAMCameraControl interface
+ //
+ // Control of local or remote cameras
+ //---------------------------------------------------------------------
+
+ [
+ object,
+ uuid(C6E13370-30AC-11d0-A18C-00A0C9118956),
+ pointer_default(unique)
+ ]
+ interface IAMCameraControl : IUnknown
+ {
+ // Returns min, max, step size, and default values
+ HRESULT GetRange(
+ [in] long Property, // Which property to query
+ [out] long * pMin, // Range minimum
+ [out] long * pMax, // Range maxumum
+ [out] long * pSteppingDelta,// Step size
+ [out] long * pDefault, // Default value
+ [out] long * pCapsFlags // CamaeraControlFlags
+
+ );
+
+ // Set a CameraControl property
+ HRESULT Set(
+ [in] long Property, // CameraControlProperty
+ [in] long lValue, // Value to set
+ [in] long Flags // CameraControl_Flags_*
+
+ );
+
+ // Get a CameraControl property
+ HRESULT Get(
+ [in] long Property, // CameraControlProperty
+ [out] long * lValue, // Current value
+ [out] long * Flags // CameraControl_Flags_*
+ );
+ }
+
+ //---------------------------------------------------------------------
+ // VideoControl Flags enum
+ //---------------------------------------------------------------------
+
+ typedef enum tagVideoControlFlags
+ {
+ VideoControlFlag_FlipHorizontal = 0x0001,
+ VideoControlFlag_FlipVertical = 0x0002,
+ VideoControlFlag_ExternalTriggerEnable = 0x0004,
+ VideoControlFlag_Trigger = 0x0008
+
+ } VideoControlFlags;
+
+ //---------------------------------------------------------------------
+ // IAMVideoControl interface
+ //
+ // Control of horizontal & vertical flip, external trigger,
+ // and listing available frame rates
+ //---------------------------------------------------------------------
+
+ [
+ object,
+ uuid(6a2e0670-28e4-11d0-a18c-00a0c9118956),
+ pointer_default(unique)
+ ]
+ interface IAMVideoControl : IUnknown
+ {
+ // What can the underlying hardware do?
+ HRESULT GetCaps(
+ [in] IPin * pPin, // the pin to query or control
+ [out] long * pCapsFlags // VideoControlFlag_*
+
+ );
+
+ // Set the mode of operation
+ HRESULT SetMode(
+ [in] IPin * pPin, // the pin to query or control
+ [in] long Mode // VideoControlFlag_*
+
+ );
+
+ // Get the mode of operation
+ HRESULT GetMode(
+ [in] IPin * pPin, // the pin to query or control
+ [out] long * Mode // VideoControlFlag_*
+ );
+
+ // Get actual frame rate info for USB and 1394
+ // This is only available when streaming
+ HRESULT GetCurrentActualFrameRate(
+ [in] IPin * pPin, // the pin to query or control
+ [out] LONGLONG * ActualFrameRate // 100 nS units
+ );
+
+ // Get max available frame rate info for USB and 1394
+ // Returns the max frame rate currently available based on bus bandwidth usage
+ HRESULT GetMaxAvailableFrameRate(
+ [in] IPin * pPin, // the pin to query or control
+ [in] long iIndex, // 0 to IAMStreamConfig->GetNumberOfCapabilities-1
+ [in] SIZE Dimensions, // width and height
+ [out] LONGLONG * MaxAvailableFrameRate // 100 nS units
+ );
+
+ // Get List of available frame rates
+ HRESULT GetFrameRateList(
+ [in] IPin * pPin, // the pin to query or control
+ [in] long iIndex, // 0 to IAMStreamConfig->GetNumberOfCapabilities-1
+ [in] SIZE Dimensions, // width and height
+ [out] long * ListSize, // Number of elements in the list
+ [out] LONGLONG ** FrameRates // Array of framerates in 100 nS units
+ // or NULL to just get ListSize
+ );
+
+ }
+
+
+ //---------------------------------------------------------------------
+ // IAMCrossbar interface
+ //
+ // Controls a routing matrix for analog or digital video or audio
+ //---------------------------------------------------------------------
+
+ [
+ object,
+ uuid(C6E13380-30AC-11d0-A18C-00A0C9118956),
+ pointer_default(unique)
+ ]
+ interface IAMCrossbar : IUnknown
+ {
+
+ // How many pins are there?
+ HRESULT get_PinCounts(
+ [out] long * OutputPinCount, // count of output pins
+ [out] long * InputPinCount); // count of input pins
+
+ // True if routing is possible
+ HRESULT CanRoute (
+ [in] long OutputPinIndex, // the output pin
+ [in] long InputPinIndex); // the input pin
+
+ // Routes an input pin to an output pin
+ HRESULT Route (
+ [in] long OutputPinIndex, // the output pin
+ [in] long InputPinIndex); // the input pin
+
+ // Returns the input pin connected to a given output pin
+ HRESULT get_IsRoutedTo (
+ [in] long OutputPinIndex, // the output pin
+ [out] long * InputPinIndex); // the connected input pin
+
+ // Returns a pin which is related to a given pin
+ // (ie. this audio pin is related to a video pin)
+ HRESULT get_CrossbarPinInfo (
+ [in] BOOL IsInputPin, // TRUE for input pins
+ [in] long PinIndex, // a pin
+ [out] long * PinIndexRelated, // Index of related pin
+ [out] long * PhysicalType); // Physical type of pin
+
+ }
+
+
+ //---------------------------------------------------------------------
+ // IAMTuner interface
+ //
+ // base tuner device
+ //---------------------------------------------------------------------
+
+ // predefined subchannel values
+ typedef enum tagAMTunerSubChannel
+ {
+ AMTUNER_SUBCHAN_NO_TUNE = -2, // don't tune
+ AMTUNER_SUBCHAN_DEFAULT = -1 // use default sub chan
+ } AMTunerSubChannel;
+
+ // predefined signal strength values
+ typedef enum tagAMTunerSignalStrength
+ {
+ AMTUNER_HASNOSIGNALSTRENGTH = -1, // cannot indicate signal strength
+ AMTUNER_NOSIGNAL = 0, // no signal available
+ AMTUNER_SIGNALPRESENT = 1 // signal present
+ } AMTunerSignalStrength;
+
+ // specifies the mode of operation of the tuner
+ typedef enum tagAMTunerModeType
+ {
+ AMTUNER_MODE_DEFAULT = 0x0000, // default tuner mode
+ AMTUNER_MODE_TV = 0x0001, // tv
+ AMTUNER_MODE_FM_RADIO = 0x0002, // fm radio
+ AMTUNER_MODE_AM_RADIO = 0x0004, // am radio
+ AMTUNER_MODE_DSS = 0x0008, // dss
+ } AMTunerModeType;
+
+ // Events reported by IAMTunerNotification
+ typedef enum tagAMTunerEventType{
+ AMTUNER_EVENT_CHANGED = 0x0001, // status changed
+ } AMTunerEventType;
+
+ interface IAMTunerNotification;
+
+ [
+ object,
+ uuid(211A8761-03AC-11d1-8D13-00AA00BD8339),
+ pointer_default(unique)
+ ]
+ interface IAMTuner : IUnknown
+ {
+ // Sets and gets the Channel
+ HRESULT put_Channel(
+ [in] long lChannel,
+ [in] long lVideoSubChannel,
+ [in] long lAudioSubChannel
+ );
+ HRESULT get_Channel(
+ [out] long *plChannel,
+ [out] long *plVideoSubChannel,
+ [out] long *plAudioSubChannel
+ );
+
+ // Gets the minimum and maximum channel available
+ HRESULT ChannelMinMax(
+ [out] long *lChannelMin,
+ [out] long *lChannelMax
+ );
+
+ // CountryCode is the same as the international
+ // long distance telephone dialing prefix
+
+ HRESULT put_CountryCode(
+ [in] long lCountryCode
+ );
+ HRESULT get_CountryCode(
+ [out] long *plCountryCode
+ );
+
+ HRESULT put_TuningSpace(
+ [in] long lTuningSpace
+ );
+ HRESULT get_TuningSpace(
+ [out] long *plTuningSpace
+ );
+
+ [local] HRESULT Logon(
+ [in] HANDLE hCurrentUser
+ );
+ HRESULT Logout();
+
+ // Signal status for current channel
+ // signal strength == TUNER_NOSIGNAL, or strength value
+ HRESULT SignalPresent(
+ [out] long * plSignalStrength // AMTunerSignalStrength
+ );
+
+ // allow multifunction tuner to be switch between modes
+ HRESULT put_Mode(
+ [in] AMTunerModeType lMode // AMTunerModeType
+ );
+ HRESULT get_Mode(
+ [out] AMTunerModeType *plMode // AMTunerModeType
+ );
+
+ // retrieve a bitmask of the possible modes
+ HRESULT GetAvailableModes(
+ [out] long *plModes // AMTunerModeType
+ );
+
+ // allow IAMTuner clients to receive event notification
+ HRESULT RegisterNotificationCallBack(
+ [in] IAMTunerNotification *pNotify,
+ [in] long lEvents // bitmask from AMTunerEventType enumeration
+ );
+ HRESULT UnRegisterNotificationCallBack(
+ [in] IAMTunerNotification *pNotify
+ );
+ }
+
+ //---------------------------------------------------------------------
+ // IAMTunerNotification interface
+ //
+ // Provided to IAMTuner if notification callbacks are desired
+ //---------------------------------------------------------------------
+
+ [
+ object,
+ uuid(211A8760-03AC-11d1-8D13-00AA00BD8339),
+ pointer_default(unique)
+ ]
+ interface IAMTunerNotification : IUnknown
+ {
+ HRESULT OnEvent([in] AMTunerEventType Event);
+ }
+
+
+ //---------------------------------------------------------------------
+ // IAMTVTuner interface
+ //
+ // Controls an analog TV tuner device
+ //---------------------------------------------------------------------
+
+ [
+ object,
+ uuid(211A8766-03AC-11d1-8D13-00AA00BD8339),
+ pointer_default(unique)
+ ]
+ interface IAMTVTuner : IAMTuner
+ {
+ // Gets the supported analog video standards (NTSC/M, PAL/B, SECAM/K1, ...
+ HRESULT get_AvailableTVFormats(
+ [out] long *lAnalogVideoStandard
+ );
+
+ // Gets the current analog video standard (NTSC/M, PAL/B, SECAM/K1, ...)
+ HRESULT get_TVFormat(
+ [out] long * plAnalogVideoStandard
+ );
+
+ // Scans for a signal on a given channel
+ // NOTE: this is equivalent to put_Channel(), SignalStrength()
+ HRESULT AutoTune(
+ [in] long lChannel,
+ [out] long * plFoundSignal
+ );
+
+ // Saves the fine tuning information for all channels")]
+ HRESULT StoreAutoTune();
+
+ // The number of TV sources plugged into the tuner
+ HRESULT get_NumInputConnections(
+ [out] long * plNumInputConnections
+ );
+
+ // Sets or gets the tuner input type (Cable or Antenna)
+ HRESULT put_InputType(
+ [in] long lIndex,
+ [in] TunerInputType InputType
+ );
+ HRESULT get_InputType(
+ [in] long lIndex,
+ [out] TunerInputType * pInputType
+ );
+
+ // Sets or gets the tuner input
+ HRESULT put_ConnectInput(
+ [in] long lIndex
+ );
+ HRESULT get_ConnectInput(
+ [out] long *plIndex
+ );
+
+ // Gets the video and audio carrier frequencies
+ HRESULT get_VideoFrequency(
+ [out] long *lFreq
+ );
+ HRESULT get_AudioFrequency(
+ [out] long *lFreq
+ );
+ }
+
+
+ //---------------------------------------------------------------------
+ // IBPCSatelliteTuner interface
+ //
+ // An interface supporting Satellite tuning-related functions
+ //---------------------------------------------------------------------
+ [
+ object,
+ local,
+ uuid(211A8765-03AC-11d1-8D13-00AA00BD8339),
+ pointer_default(unique)
+ ]
+ interface IBPCSatelliteTuner : IAMTuner
+ {
+ HRESULT get_DefaultSubChannelTypes(
+ [out] long *plDefaultVideoType, // Provider-specific service type
+ [out] long *plDefaultAudioType // Provider-specific service type
+ );
+
+ HRESULT put_DefaultSubChannelTypes(
+ [in] long lDefaultVideoType, // Provider-specific service type
+ [in] long lDefaultAudioType // Provider-specific service type
+ );
+
+ HRESULT IsTapingPermitted(); // S_OK yes, S_FALSE no
+ }
+
+
+
+ //---------------------------------------------------------------------
+ // IAMTVAudio interface
+ //
+ // TV Audio control
+ //---------------------------------------------------------------------
+
+ typedef enum tagTVAudioMode
+ {
+ AMTVAUDIO_MODE_MONO = 0x0001, // Mono
+ AMTVAUDIO_MODE_STEREO = 0x0002, // Stereo
+ AMTVAUDIO_MODE_LANG_A = 0x0010, // Primary language
+ AMTVAUDIO_MODE_LANG_B = 0x0020, // 2nd avail language
+ AMTVAUDIO_MODE_LANG_C = 0x0040, // 3rd avail language
+ } TVAudioMode;
+
+ // Events reported by IAMTVAudioNotification
+ typedef enum tagAMTVAudioEventType
+ {
+ AMTVAUDIO_EVENT_CHANGED = 0x0001, // mode changed
+ } AMTVAudioEventType;
+
+ interface IAMTVAudioNotification;
+
+ [
+ object,
+ local,
+ uuid(83EC1C30-23D1-11d1-99E6-00A0C9560266),
+ pointer_default(unique)
+ ]
+ interface IAMTVAudio : IUnknown
+ {
+ // retrieve a bitmask of the formats available in the hardware
+ HRESULT GetHardwareSupportedTVAudioModes(
+ [out] long *plModes // TVAudioMode
+ );
+
+ // retrieve a bitmask of the possible modes
+ HRESULT GetAvailableTVAudioModes(
+ [out] long *plModes // TVAudioMode
+ );
+
+ HRESULT get_TVAudioMode(
+ [out] long *plMode // TVAudioMode
+ );
+ HRESULT put_TVAudioMode(
+ [in] long lMode // TVAudioMode
+ );
+
+ // allow IAMTVAudio clients to receive event notification
+ HRESULT RegisterNotificationCallBack(
+ [in] IAMTunerNotification *pNotify,
+ [in] long lEvents // bitmask from AMTVAudioEventType enumeration
+ );
+ HRESULT UnRegisterNotificationCallBack(
+ IAMTunerNotification *pNotify
+ );
+ }
+
+ //---------------------------------------------------------------------
+ // IAMTVAudioNotification interface
+ //
+ // Provided to IAMTVAudio clients if notification callbacks are desired
+ //---------------------------------------------------------------------
+
+ [
+ object,
+ local,
+ uuid(83EC1C33-23D1-11d1-99E6-00A0C9560266),
+ pointer_default(unique)
+ ]
+ interface IAMTVAudioNotification : IUnknown
+ {
+ HRESULT OnEvent([in] AMTVAudioEventType Event);
+ }
+
+
+
+
+ //---------------------------------------------------------------------
+ // IAMAnalogVideoEncoder interface
+ //---------------------------------------------------------------------
+
+ [
+ object,
+ uuid(C6E133B0-30AC-11d0-A18C-00A0C9118956),
+ pointer_default(unique)
+ ]
+ interface IAMAnalogVideoEncoder : IUnknown
+ {
+ // Gets the supported analog video standards (NTSC/M, PAL/B, SECAM/K1, ...)
+ HRESULT get_AvailableTVFormats(
+ [out] long *lAnalogVideoStandard
+ );
+
+ // Sets or gets the current analog video standard (NTSC/M, PAL/B, SECAM/K1, ...)
+ HRESULT put_TVFormat(
+ [in] long lAnalogVideoStandard
+ );
+
+ HRESULT get_TVFormat(
+ [out] long * plAnalogVideoStandard
+ );
+
+ // Sets or gets the copy protection
+ HRESULT put_CopyProtection (
+ [in] long lVideoCopyProtection); // VideoCopyProtectionType
+
+ HRESULT get_CopyProtection (
+ [out] long *lVideoCopyProtection); // VideoCopyProtectionType
+
+
+ // Enables and disables close captioning
+ HRESULT put_CCEnable (
+ [in] long lCCEnable);
+
+ HRESULT get_CCEnable (
+ [out] long *lCCEnable);
+
+ }
+
+ // used by IKsPropertySet set AMPROPSETID_Pin
+ typedef enum {
+ AMPROPERTY_PIN_CATEGORY,
+ AMPROPERTY_PIN_MEDIUM
+ } AMPROPERTY_PIN;
+
+ //---------------------------------------------------------------------
+ // IKsPropertySet interface
+ //
+ // Sets or gets a property identified by a property set GUID and a
+ // property ID.
+ //
+ // Return codes for all 3 methods:
+ // E_PROP_SET_UNSUPPORTED the property set is not supported
+ // E_PROP_ID_UNSUPPORTED the property ID is not supported
+ // for the specified property set
+ //---------------------------------------------------------------------
+
+cpp_quote("#ifndef _IKsPropertySet_")
+cpp_quote("#define _IKsPropertySet_")
+
+ //---------------------------------------------------------------------
+ // #defines for IKsPropertySet::QuerySupported return result in pTypeSupport
+ //---------------------------------------------------------------------
+
+cpp_quote("#define KSPROPERTY_SUPPORT_GET 1")
+cpp_quote("#define KSPROPERTY_SUPPORT_SET 2")
+
+
+ [
+ object,
+ uuid(31EFAC30-515C-11d0-A9AA-00AA0061BE93),
+ pointer_default(unique)
+ ]
+ interface IKsPropertySet : IUnknown
+ {
+ [local] 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);
+
+ [call_as(Set)] HRESULT RemoteSet(
+ [in] REFGUID guidPropSet,
+ [in] DWORD dwPropID,
+ [in, size_is(cbInstanceData)] byte * pInstanceData,
+ [in] DWORD cbInstanceData,
+ [in, size_is(cbPropData)] byte * pPropData,
+ [in] DWORD cbPropData);
+
+ // To get a property, the caller allocates a buffer which the called
+ // function fills in. To determine necessary buffer size, call Get with
+ // pPropData=NULL and cbPropData=0.
+ [local] 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);
+
+ [call_as(Get)] HRESULT RemoteGet(
+ [in] REFGUID guidPropSet,
+ [in] DWORD dwPropID,
+ [in, size_is(cbInstanceData)] byte * pInstanceData,
+ [in] DWORD cbInstanceData,
+ [out, size_is(cbPropData)] byte * pPropData,
+ [in] DWORD cbPropData,
+ [out] DWORD * pcbReturned);
+ // QuerySupported must either return E_NOTIMPL or correctly indicate
+ // if getting or setting the property set and property is supported.
+ // S_OK indicates the property set and property ID combination is
+ HRESULT QuerySupported(
+ [in] REFGUID guidPropSet,
+ [in] DWORD dwPropID,
+ [out] DWORD *pTypeSupport);
+ }
+cpp_quote("#endif // _IKsPropertySet_")
+
+[
+object,
+uuid(6025A880-C0D5-11d0-BD4E-00A0C911CE86),
+pointer_default(unique)
+]
+interface IMediaPropertyBag : IPropertyBag
+{
+ import "ocidl.idl";
+
+ typedef IMediaPropertyBag *LPMEDIAPROPERTYBAG;
+
+ // return the i'th element in the property bag
+ HRESULT EnumProperty(
+ [in] ULONG iProperty,
+ [in, out] VARIANT * pvarPropertyName,
+ [in, out] VARIANT * pvarPropertyValue
+ );
+
+}
+
+
+[
+object,
+uuid(5738E040-B67F-11d0-BD4D-00A0C911CE86),
+pointer_default(unique)
+]
+interface IPersistMediaPropertyBag : IPersist
+{
+ import "ocidl.idl";
+ import "unknwn.idl";
+
+ 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;
+}
+
+
+ //---------------------------------------------------------------------
+ //
+ // Defines IAMPhysicalPinInfo Interface
+ //
+ // Returns an enum and string that describes an input pin's physical type.
+ //
+ // Implement if: you have physical input pins such as video or audio (like
+ // on a video capture card or a VCR)
+ //
+ // Use if: you want to communicate to a user available physical input pins
+ // and allow them to select the active one if there is more than one
+ //---------------------------------------------------------------------
+
+
+[
+ object,
+ uuid(F938C991-3029-11cf-8C44-00AA006B6814),
+ pointer_default(unique)
+ ]
+interface IAMPhysicalPinInfo : IUnknown {
+
+ // Returns VFW_E_NO_ACCEPTABLE_TYPES if not a physical pin
+ HRESULT GetPhysicalType(
+ [out] long *pType, // the enum representing the Physical Type
+ [out] LPOLESTR *ppszType // a friendly name
+ );
+}
+typedef IAMPhysicalPinInfo *PAMPHYSICALPININFO;
+
+ //---------------------------------------------------------------------
+ // Defines IAMExtDevice Interface
+ //
+ // Base interface for external professional devices
+ //
+ // Implement if: the filter controls an external device such as a VCR,
+ // timecode reader/generator, etc. The intent is to build a object from
+ // this implementation plus another that specifically describes the device,
+ // such as IAMExtTransport.
+ //
+ // Use if: you want to control and external device such as a VCR
+ //
+ // See edevdefs.h for the enumerated parameter list
+ //---------------------------------------------------------------------
+ [
+ object,
+ uuid(B5730A90-1A2C-11cf-8C23-00AA006B6814),
+ pointer_default(unique)
+ ]
+ interface IAMExtDevice : IUnknown
+ {
+ // General device capabilities property. See edevdefs.h for supported
+ // values
+ HRESULT GetCapability(
+ [in] long Capability, // identify the property
+ [out] long *pValue, // return value
+ [out] double *pdblValue // return value
+ );
+
+ // Get external device identification string. Usually the model #
+ // of the device
+ HRESULT get_ExternalDeviceID(
+ [out] LPOLESTR *ppszData // ID string
+ );
+
+ HRESULT get_ExternalDeviceVersion(
+ [out] LPOLESTR *ppszData // revision string
+ );
+
+ // Controls the external device's power mode
+ HRESULT put_DevicePower([in] long PowerMode
+ );
+ HRESULT get_DevicePower([out] long *pPowerMode
+ );
+
+ // Some devices need to be reset in some way, i.e., rewinding a VCR
+ // to the beginning of the tape and resetting the counter to zero.
+ HRESULT Calibrate(
+ [in] HEVENT hEvent,
+ [in] long Mode,
+ [out] long *pStatus // OATRUE is active, OAFALSE is inactive
+ );
+
+ // Selects the device's communications port, i.e.,COM1, IEEE1394, etc.
+ // See edevdefs.h for enums
+ HRESULT put_DevicePort([in] long DevicePort
+ );
+ HRESULT get_DevicePort([out] long *pDevicePort
+ );
+
+}
+typedef IAMExtDevice *PEXTDEVICE;
+
+ //---------------------------------------------------------------------
+ // Defines IAMExtTransport Interface
+ //
+ // Contains properties and methods that control behavior of an external
+ // transport device such as a VTR
+ //
+ // Implement if: you control such a device. Intended to be agregated
+ // with IAMExtDevice.
+ //
+ // Use if: you want to control such a device
+ //
+ // See edevdefs.h for the parameter lists
+ //---------------------------------------------------------------------
+[
+ object,
+ uuid(A03CD5F0-3045-11cf-8C44-00AA006B6814),
+ pointer_default(unique)
+ ]
+interface IAMExtTransport : IUnknown {
+
+ // General transport capabilities property. See edevdefs.h for enums
+ HRESULT GetCapability(
+ [in] long Capability, // identify the property
+ [out] long *pValue, // return value
+ [out] double *pdblValue // return value
+ );
+
+ // For disc-based devices: spinning, or not spinning.
+ // For tape-based device: threaded, unthreaded or ejected
+ HRESULT put_MediaState([in] long State
+ );
+ HRESULT get_MediaState([out] long *pState // see edevdefs.h
+ );
+
+ // Determines state of unit's front panel
+ HRESULT put_LocalControl([in] long State
+ );
+ HRESULT get_LocalControl([out] long *pState // OATRUE or OAFALSE
+ );
+
+ // Transport status such as Play, Stop, etc. More extensive
+ // than AM states.
+ HRESULT GetStatus(
+ [in] long StatusItem, // see edevdefs.h
+ [out] long *pValue
+ );
+
+ // Parameters such as recording speed, servo reference, ballistics, etc.
+ HRESULT GetTransportBasicParameters(
+ [in] long Param,
+ [out] long *pValue,
+ [out] LPOLESTR *ppszData
+ );
+
+ HRESULT SetTransportBasicParameters(
+ [in] long Param,
+ [in] long Value,
+ [in] LPCOLESTR pszData
+ );
+
+ // Parameters such as video output mode
+ HRESULT GetTransportVideoParameters(
+ [in] long Param,
+ [out] long *pValue
+ );
+
+ HRESULT SetTransportVideoParameters(
+ [in] long Param,
+ [in] long Value
+ );
+
+ // Parameters such as audio channel enable
+ HRESULT GetTransportAudioParameters(
+ [in] long Param,
+ [out] long *pValue
+ );
+
+ HRESULT SetTransportAudioParameters(
+ [in] long Param,
+ [in] long Value
+ );
+
+ // Mode is the movement of the transport, i.e., Play, Stop,
+ // Record, Edit, etc.
+ HRESULT put_Mode([in] long Mode
+ );
+ HRESULT get_Mode([out] long *pMode
+ );
+
+ // Rate is for variable speed control of the the device. This
+ // can be linked to IMediaControl::Rate() in the implementation
+ // if desired.
+ HRESULT put_Rate([in] double dblRate
+ );
+ HRESULT get_Rate([out] double *pdblRate
+ );
+
+ // This is a lengthy method, that is, it is in effect until canceled or complete and
+ // requires housekeeping by the filter. It puts transport in play mode and maintains
+ // fixed relationship between master time reference and transport position.
+ HRESULT GetChase(
+ [out] long *pEnabled, // OATRUE | OAFALSE
+ [out] long *pOffset, // offset in current time format
+ [out] HEVENT *phEvent // completion notification
+ );
+ HRESULT SetChase(
+ [in] long Enable, // OATRUE | OAFALSE
+ [in] long Offset, // offset in current time format
+ [in] HEVENT hEvent // completion notification
+ );
+
+ // Also a lengthy method: temporarily change transport speed (for synchronizing).
+ HRESULT GetBump(
+ [out] long *pSpeed,
+ [out] long *pDuration // in current time format
+ );
+ HRESULT SetBump(
+ [in] long Speed,
+ [in] long Duration // in current time format
+ );
+
+ // Enable/Disable transport anti-headclog control.
+ HRESULT get_AntiClogControl([out] long *pEnabled // OATRUE | OAFALSE
+ );
+ HRESULT put_AntiClogControl([in] long Enable // OATRUE | OAFALSE
+ );
+
+ // The following group of properties describes edit events. An edit event can be a
+ // standard insert or assemble edit or a memorized position called a bookmark.
+ // A NOTE ABOUT EVENTS: as with all lengthy commands, event objects must be created to
+ // signal completion or error.
+
+ // Intended usage: an edit event is prepared for use by:
+ // 1. Registering an edit property set and getting an EditID
+ // 2. Setting the necessary edit properties
+ // 3. Setting the edit property set active
+
+ // Please see edevdefs.h for properties and values
+
+ // The reference clock's advance is the mechanism that puts an edit in motion (see
+ // ED_EDIT_REC_INPOINT).
+
+ // Property set methods
+ HRESULT GetEditPropertySet(
+ [in] long EditID,
+ [out] long *pState // ED_SET_ACTIVE | ED_SET_INACTIVE | ED_SET_INVALID
+ // | ED_SET_EXECUTING
+ );
+
+ HRESULT SetEditPropertySet(
+ [in, out] long *pEditID,
+ [in] long State // ED_SET_REGISTER | ED_SET_DELETE | ED_SET_ACTIVE |
+ ); // ED_SET_INACTIVE
+
+ // the following properties define an edit event such as a bookmark, seek point, or
+ // actual edit
+ HRESULT GetEditProperty(
+ [in] long EditID,
+ [in] long Param,
+ [out] long *pValue
+ );
+ HRESULT SetEditProperty(
+ [in] long EditID,
+ [in] long Param,
+ [in] long Value
+ );
+
+ // Activates a capable transport's edit control (typically used for "on the fly" editing).
+ HRESULT get_EditStart([out] long *pValue // OATRUE or OAFALSE
+ );
+ HRESULT put_EditStart([in] long Value // OATRUE or OAFALSE
+ );
+}
+typedef IAMExtTransport *PIAMEXTTRANSPORT;
+
+ //---------------------------------------------------------------------
+ // Defines IAMTimecodeReader Interface
+ //
+ // Contains properties and methods that define behavior of a
+ // SMPTE/MIDI Timecode Reader. It is expected that this interface
+ // will be combined (aggregated) with IAMExtTransport to "build" a pro
+ // VCR.
+ //
+ // Implement if: you control such a device
+ //
+ // Use if: you want to control such a device
+ //
+ // See edevdefs.h for the parameter lists
+ //=====================================================================
+
+
+// timecode structures
+cpp_quote("#if 0")
+cpp_quote("/* the following is what MIDL knows how to remote */")
+typedef struct tagTIMECODE {
+ WORD wFrameRate; // will be replaced by AM defs, but see ED_FORMAT_SMPTE for now
+ WORD wFrameFract; // fractional frame. full scale is always 0x1000
+ DWORD dwFrames;
+}TIMECODE;
+cpp_quote("#else /* 0 */")
+cpp_quote("#ifndef TIMECODE_DEFINED")
+cpp_quote("#define TIMECODE_DEFINED")
+cpp_quote("typedef union _timecode {")
+cpp_quote(" struct {")
+cpp_quote(" WORD wFrameRate;")
+cpp_quote(" WORD wFrameFract;")
+cpp_quote(" DWORD dwFrames;")
+cpp_quote(" };")
+cpp_quote(" DWORDLONG qw;")
+cpp_quote(" } TIMECODE;")
+cpp_quote("")
+cpp_quote("#endif /* TIMECODE_DEFINED */")
+cpp_quote("#endif /* 0 */")
+
+typedef TIMECODE *PTIMECODE;
+
+typedef struct tagTIMECODE_SAMPLE {
+ LONGLONG qwTick; // ActiveMovie 100ns timestamp
+ TIMECODE timecode; // timecode
+ DWORD dwUser; // timecode user data (aka user bits)
+ DWORD dwFlags; // timecode flags - see below
+} TIMECODE_SAMPLE;
+typedef TIMECODE_SAMPLE *PTIMECODE_SAMPLE;
+
+
+[
+ object,
+ uuid(9B496CE1-811B-11cf-8C77-00AA006B6814),
+ pointer_default(unique)
+]
+interface IAMTimecodeReader : IUnknown
+{
+ // Timecode Reader Mode - gets/sets the following properties
+ // ED_TCR_SOURCE - timecode gen (readback), LTC, VITC, or Control Track
+ HRESULT GetTCRMode(
+ [in] long Param,
+ [out] long *pValue);
+ HRESULT SetTCRMode(
+ [in] long Param,
+ [in] long Value);
+
+ // Select which line of the vertical interval timecode will be read from (if VITC).
+ // To read VITC on specific multiple lines, the caller would make successive calls to
+ // put_VITCLine(), once for each line desired.
+ HRESULT put_VITCLine(
+ [in] long Line ); // valid lines are 11-20, 0 means autoselect,
+ // hi bit set means add to list of lines (for
+ // readers that test across multiple lines)
+ HRESULT get_VITCLine(
+ [out] long *pLine ); // hi bit set means multiple lines are used,
+ // and successive calls will cycle through the
+ // line numbers (like an enumerator, only simpler)
+
+ // GetTimecode can be used to obtain the most recent timecode value available in the
+ // stream. The client can use this to monitor the timecode, parse duplicates and
+ // discontinuities. The source filter supplying the timecode or possibly a down stream
+ // filter might want to parse for discontinuities or errors since you have to look at
+ // every sample to do this properly.
+ //
+
+ HRESULT GetTimecode(
+ [out] PTIMECODE_SAMPLE pTimecodeSample) ;
+
+}
+typedef IAMTimecodeReader *PIAMTIMECODEREADER;
+
+ //---------------------------------------------------------------------
+ //=====================================================================
+ // Defines IAMTimecodeGenerator Interface
+ //
+ // Contains properties and methods that define behavior of an external
+ // SMPTE/MIDI Timecode Generator. It is expected that this interface
+ // will be combined (aggregated) with IAMExtTransport to "build" a pro
+ // VCR.
+ //
+ // Implement if: you control such a device
+ //
+ // Use if: you want to control such a device
+ //
+ // See edevdefs.h for the parameter lists
+ //---------------------------------------------------------------------
+[
+ object,
+ uuid(9B496CE0-811B-11cf-8C77-00AA006B6814),
+ pointer_default(unique)
+ ]
+interface IAMTimecodeGenerator : IUnknown {
+
+ // Timecode Generator Mode - gets/sets the following properties (see
+ // vcrdefss.h for detailed values):
+ // ED_TCG_TIMECODE_TYPE - LTC, VITC, or MIDI
+ // ED_TCG_FRAMERATE - 24, 25, 30 drop or 30 nondrop
+ // ED_TCG_SYNC_SOURCE - what is driving the bitclock
+ // ED_TCG_REFERENCE_SOURCE - what is driving the count value
+ HRESULT GetTCGMode(
+ [in] long Param,
+ [out] long *pValue);
+
+ HRESULT SetTCGMode(
+ [in] long Param,
+ [in] long Value);
+
+ // Select into which line(s) of the vertical interval timecode will be inserted (if VITC).
+ // Hi bit set means add this line to any previously set lines.
+ // To generate VITC on specific multiple lines, the caller would make successive calls to
+ // put_VITCLine(), once for each line desired.
+ HRESULT put_VITCLine(
+ [in] long Line // valid lines are 11-20, 0 means autoselect(this setting
+ ); // is for TC readers that decode from multiple lines)
+ HRESULT get_VITCLine(
+ [out] long *pLine
+ );
+
+ // Sets timecode and/or userbit value. If generator is running, takes effect
+ // immediately. If caller wants to set only timecode, set userbit value to -1L (and
+ // same for setting userbits only)
+ //
+
+ HRESULT SetTimecode(
+ [in] PTIMECODE_SAMPLE pTimecodeSample) ;
+
+
+ // GetTimecode can be used to obtain the most recent timecode value available in the
+ // stream. The client can use this to monitor the timecode and verify the generator is
+ // working properly
+ //
+
+ HRESULT GetTimecode(
+ [out] PTIMECODE_SAMPLE pTimecodeSample) ;
+
+}
+typedef IAMTimecodeGenerator *PIAMTIMECODEGENERATOR;
+
+ //---------------------------------------------------------------------
+ // Defines IAMTimecodeDisplay Interface
+ //
+ // Contains properties and methods that define behavior of an external
+ // SMPTE/MIDI Timecode Display device (aka "character generator" for
+ // making "burn-ins" or "window dubs"). It is expected that this interface
+ // will be combined (aggregated) with IAMExtTransport and the timecode
+ // interfaces to "build" a pro VCR.
+ //
+ // Implement if: you control such a device
+ //
+ // Use if: you want to control such a device
+ //
+ // See edevdefs.h for the parameter lists
+ //---------------------------------------------------------------------
+[
+ object,
+ uuid(9B496CE2-811B-11cf-8C77-00AA006B6814),
+ pointer_default(unique)
+ ]
+interface IAMTimecodeDisplay : IUnknown
+{
+ // Enable/disable external device's timecode reader's character generator output. Some
+ // readers have this feature - this is not intended for rendering inside the PC!
+ HRESULT GetTCDisplayEnable(
+ [out] long *pState); // OATRUE | OAFALSE
+ HRESULT SetTCDisplayEnable(
+ [in] long State); // OATRUE | OAFALSE
+ // Timecode reader's character generator output
+ // characteristics (size, position, intensity, etc.).
+ HRESULT GetTCDisplay(
+ [in] long Param,
+ [out] long *pValue);
+ HRESULT SetTCDisplay(
+ [in] long Param,
+ [in] long Value);
+
+ /* Allowable params and values (see edevdefs.h for details):
+ ED_TCD_SOURCE
+ ED_TCR | ED_TCG
+ ED_TCD_SIZE
+ ED_SMALL | ED_MED | ED_LARGE
+ ED_TCD_POSITION
+ ED_TOP | ED_MIDDLE | ED_BOTTOM or'd with
+ ED_LEFT | ED_CENTER | ED_RIGHT
+ ED_TCD_INTENSITY
+ ED_HIGH | ED_LOW
+ ED_TCD_TRANSPARENCY // set from 0 to 4, 0 being completely opaque
+ ED_TCD_INVERT // white on black or black on white
+ OATRUE | OAFALSE
+ ED_TCD_BORDER // white border for black chars, black border for white letters
+ OATRUE | OAFALSE
+ */
+}
+typedef IAMTimecodeDisplay *PIAMTIMECODEDISPLAY;
+
+
+[
+ object,
+ uuid(c6545bf0-e76b-11d0-bd52-00a0c911ce86),
+ pointer_default(unique)
+]
+interface IAMDevMemoryAllocator : IUnknown
+{
+ HRESULT GetInfo(
+ [out] DWORD *pdwcbTotalFree,
+ [out] DWORD *pdwcbLargestFree,
+ [out] DWORD *pdwcbTotalMemory,
+ [out] DWORD *pdwcbMinimumChunk);
+
+ HRESULT CheckMemory(
+ [in] const BYTE *pBuffer);
+
+ HRESULT Alloc(
+ [out] BYTE **ppBuffer,
+ [in, out] DWORD *pdwcbBuffer);
+
+ HRESULT Free(
+ [in] BYTE *pBuffer);
+
+ HRESULT GetDevMemoryObject(
+ [out] IUnknown **ppUnkInnner,
+ [in] IUnknown *pUnkOuter);
+}
+typedef IAMDevMemoryAllocator *PAMDEVMEMORYALLOCATOR;
+
+
+[
+ object,
+ uuid(c6545bf1-e76b-11d0-bd52-00a0c911ce86),
+ pointer_default(unique)
+]
+interface IAMDevMemoryControl : IUnknown
+{
+ HRESULT QueryWriteSync();
+
+ HRESULT WriteSync();
+
+ HRESULT GetDevId(
+ [out] DWORD *pdwDevId);
+
+}
+typedef IAMDevMemoryControl *PAMDEVMEMORYCONTROL;
+
+// Flags for IAMStreamSelection::Info
+enum _AMSTREAMSELECTINFOFLAGS {
+ AMSTREAMSELECTINFO_ENABLED = 0x01, // Enable - off for disable
+ AMSTREAMSELECTINFO_EXCLUSIVE = 0x02 // Turns off the others in the group
+ // when enabling this one
+};
+// Flags for IAMStreamSelection::Enable
+enum _AMSTREAMSELECTENABLEFLAGS {
+ // Currently valid values are :
+ // 0 - disable all streams in the group containing this stream
+ // ..._ENABLE - enable only this stream with in the given group
+ // and disable all others
+ // ..._ENABLEALL - send out all streams
+ AMSTREAMSELECTENABLE_ENABLE = 0x01, // Enable
+ AMSTREAMSELECTENABLE_ENABLEALL = 0x02 // Enable all streams in the group
+ // containing this stream
+};
+
+// Control which logical streams are played and find out information about
+// them
+// Normally supported by a filter
+[
+ object,
+ uuid(c1960960-17f5-11d1-abe1-00a0c905f375),
+ pointer_default(unique)
+]
+interface IAMStreamSelect : IUnknown
+{
+ // Returns total count of streams
+ HRESULT Count(
+ [out] DWORD *pcStreams); // Count of logical streams
+
+ // Return info for a given stream - S_FALSE if iIndex out of range
+ // The first steam in each group is the default
+ HRESULT Info(
+ [in] long lIndex, // 0-based index
+ [out] AM_MEDIA_TYPE **ppmt, // Media type - optional
+ // Use DeleteMediaType to free
+ [out] DWORD *pdwFlags, // flags - optional
+ [out] LCID *plcid, // LCID (returns 0 if none) - optional
+ [out] DWORD *pdwGroup, // Logical group - optional
+ [out] WCHAR **ppszName, // Name - optional - free with CoTaskMemFree
+ // optional
+ [out] IUnknown **ppObject, // Associated object - optional
+ // Object may change if Enable is
+ // called on this interface
+ // - returns NULL if no associated object
+ // Returns pin or filter for DShow
+ [out] IUnknown **ppUnk); // Stream specific interface
+
+ // Enable or disable a given stream
+ HRESULT Enable(
+ [in] long lIndex,
+ [in] DWORD dwFlags);
+}
+typedef IAMStreamSelect *PAMSTREAMSELECT;
+
+enum _AMRESCTL_RESERVEFLAGS
+{
+ AMRESCTL_RESERVEFLAGS_RESERVE = 0x00, // Increment reserve count
+ AMRESCTL_RESERVEFLAGS_UNRESERVE = 0x01 // Decrement reserve count
+};
+
+// Reserve resources now so that playback can be subsequently
+// guaranteed
+//
+// Normally supported by a filter
+//
+[
+ object,
+ uuid(8389d2d0-77d7-11d1-abe6-00a0c905f375),
+ pointer_default(unique),
+ local
+]
+interface IAMResourceControl : IUnknown
+{
+ // The reserve count is incremented/decremented if and only if
+ // S_OK is returned
+ // Unreserve once for every Reserve call
+ HRESULT Reserve(
+ [in] DWORD dwFlags, // From _AMRESCTL_RESERVEFLAGS enum
+ [in] PVOID pvReserved // Must be NULL
+ );
+}
+
+
+// Set clock adjustments - supported by some clocks
+[
+ object,
+ uuid(4d5466b0-a49c-11d1-abe8-00a0c905f375),
+ pointer_default(unique),
+ local
+]
+interface IAMClockAdjust : IUnknown
+{
+ // Set the following delta to clock times
+ // The clock will add adjust its times by the given delta
+ HRESULT SetClockDelta(
+ [in] REFERENCE_TIME rtDelta
+ );
+};
+
+// Filter miscellaneous status flags
+
+enum _AM_FILTER_MISC_FLAGS {
+ AM_FILTER_MISC_FLAGS_IS_RENDERER = 0x00000001, /* Will deliver EC_COMPLETE
+ at end of media */
+ AM_FILTER_MISC_FLAGS_IS_SOURCE = 0x00000002 /* Filter sources data */
+};
+
+[
+ object,
+ uuid(2dd74950-a890-11d1-abe8-00a0c905f375),
+ pointer_default(unique),
+ local
+]
+interface IAMFilterMiscFlags : IUnknown
+{
+ // Get miscellaneous property flags
+ ULONG GetMiscFlags(void);
+};
+
+
+// Video Image drawing interface
+[
+ object,
+ local,
+ uuid(48efb120-ab49-11d2-aed2-00a0c995e8d5),
+ pointer_default(unique),
+]
+interface IDrawVideoImage : IUnknown
+{
+ HRESULT DrawVideoImageBegin();
+
+ HRESULT DrawVideoImageEnd();
+
+ HRESULT DrawVideoImageDraw(
+ [in] HDC hdc,
+ [in] LPRECT lprcSrc,
+ [in] LPRECT lprcDst
+ );
+}
+
+//
+// Video Image decimation interface
+//
+// The aim of this interface is to enable a video renderer filter to
+// control the decimation properties of a video decoder connected to
+// the video renderer
+//
+// This interface should only be supported by decoders that are capable of
+// decimating their output image by an arbitary amount.
+//
+//
+[
+ object,
+ local,
+ uuid(2e5ea3e0-e924-11d2-b6da-00a0c995e8df),
+ pointer_default(unique),
+]
+interface IDecimateVideoImage : IUnknown
+{
+ //
+ // Informs the decoder that it should decimate its output
+ // image to the specified width and height. If the decoder can
+ // decimate to this size it should return S_OK.
+ // If the decoder can't perform the requested decimation
+ // or wants to stop performing the decimation that it is
+ // currently doing it should return E_FAIL.
+ //
+ HRESULT SetDecimationImageSize(
+ [in] long lWidth,
+ [in] long lHeight);
+
+ //
+ // Informs the decoder that it should stop decimating its output image
+ // and resume normal output.
+ //
+ HRESULT ResetDecimationImageSize();
+}
+
+typedef enum _DECIMATION_USAGE {
+ DECIMATION_LEGACY, // decimate at ovly then video port then crop
+ DECIMATION_USE_DECODER_ONLY, // decimate image at the decoder only
+ DECIMATION_USE_VIDEOPORT_ONLY, // decimate at the video port only
+ DECIMATION_USE_OVERLAY_ONLY, // decimate at the overlay only
+ DECIMATION_DEFAULT // decimate at decoder then ovly the vide port then crop
+} DECIMATION_USAGE;
+
+[
+ object,
+ local,
+ uuid(60d32930-13da-11d3-9ec6-c4fcaef5c7be),
+ pointer_default(unique),
+]
+interface IAMVideoDecimationProperties: IUnknown
+{
+ //
+ // Queries the current usage of the above IDecimateVideoImage
+ // interface.
+ //
+ HRESULT QueryDecimationUsage(
+ [out] DECIMATION_USAGE* lpUsage); // from DECIMATION_USAGE enum
+
+ //
+ // Sets the current usage of the above IDecimateVideoImage
+ // interface.
+ //
+ HRESULT SetDecimationUsage(
+ [in] DECIMATION_USAGE Usage); // from DECIMATION_USAGE enum
+}
+
+//---------------------------------------------------------------------
+//
+// IVideoFrameStep interface
+//
+//---------------------------------------------------------------------
+
+[
+ object,
+ uuid(e46a9787-2b71-444d-a4b5-1fab7b708d6a),
+ pointer_default(unique),
+]
+interface IVideoFrameStep : IUnknown
+{
+ //
+ // Stop(), Pause(), Run() all cancel Step as does any seeking
+ // request.
+ //
+ // The Step() and CancelStep() methods of this interface
+ // Cancel any previous step.
+ //
+ // When stepping is complete EC_STEP_COMPLETE is signalled.
+ //
+ // When the filter graph gets EC_STEP_COMPLETE it automatically
+ // sets the filter graph into paused state and forwards the
+ // notification to the application
+ //
+ // Returns S_OK if stepping initiated.
+ //
+ // dwFrames
+ // 1 means step 1 frame forward
+ // 0 is invalid
+ // n (n > 1) means skip n - 1 frames and show the nth
+ //
+ // pStepObject
+ // NULL - default step object (filter) picked
+ // non-NULL - use this object for stepping
+ //
+ HRESULT Step(DWORD dwFrames, [unique] IUnknown *pStepObject);
+
+ // Can step?
+ // Returns S_OK if it can, S_FALSE if it can't or error code.
+ // bMultiple - if TRUE return whether can step n > 1
+ HRESULT CanStep(long bMultiple, [unique] IUnknown *pStepObject);
+
+ // Cancel stepping
+ HRESULT CancelStep();
+}
+
+
+
+
+//---------------------------------------------------------------------
+//
+// IAMPushSource interface
+//
+// Provides a means for source filters to describe information about the
+// data that they source, such as whether the data is live or not, and
+// what type of clock was used for timestamps. This information may be
+// needed by other clocks in the graph in order to provide accurate
+// synchronization. Also provides a way to specify an offset value for
+// the filter to use when timestamping the streams it sources. Provides
+// support for the IAMLatency interface as well.
+//
+//---------------------------------------------------------------------
+
+enum _AM_PUSHSOURCE_FLAGS {
+
+ //
+ // The default assumption is that the data is from a live source,
+ // time stamped with the graph clock, and the source does not
+ // attempt to rate match the data it delivers.
+ // The following flags can be used to override this assumption.
+ //
+
+ // capability flags
+ AM_PUSHSOURCECAPS_INTERNAL_RM = 0x00000001, // source provides internal support for rate matching
+ AM_PUSHSOURCECAPS_NOT_LIVE = 0x00000002, // don't treat source data as live
+ AM_PUSHSOURCECAPS_PRIVATE_CLOCK = 0x00000004, // source data timestamped with clock not
+ // exposed to the graph
+
+ // request flags, set by user via SetPushSourceFlags method
+ AM_PUSHSOURCEREQS_USE_STREAM_CLOCK = 0x00010000, // source was requested to timestamp
+ // using a clock that isn't the graph clock
+
+ AM_PUSHSOURCEREQS_USE_CLOCK_CHAIN = 0x00020000, // source requests reference clock chaining
+};
+
+//
+// Used to set a source filter to run in a "live" mode.
+//
+[
+object,
+ uuid(F185FE76-E64E-11d2-B76E-00C04FB6BD3D),
+ pointer_default(unique)
+]
+interface IAMPushSource : IAMLatency
+{
+ // used to discover push source's capabilities.
+ // may be any combination of the AM_PUSHSOURCE_FLAGS flags.
+ HRESULT GetPushSourceFlags (
+ [out] ULONG *pFlags
+ );
+
+ // used to set request flags for a push source.
+ // may be a combination of the AM_PUSHSOURCE_REQS_xxx flags.
+ HRESULT SetPushSourceFlags (
+ [in] ULONG Flags
+ );
+
+ // specify an offset for push source time stamps
+ HRESULT SetStreamOffset (
+ [in] REFERENCE_TIME rtOffset
+ );
+
+ // retrieve the offset this push source is using
+ HRESULT GetStreamOffset (
+ [out] REFERENCE_TIME *prtOffset
+ );
+
+ // retrieve the maximum stream offset this push source thinks it can support
+ HRESULT GetMaxStreamOffset (
+ [out] REFERENCE_TIME *prtMaxOffset
+ );
+
+ // allows the filter graph to tell a push source the maximum latency allowed on the graph
+ // this allows pins like the video capture preview pin to be more efficient with the amount
+ // of buffering required to support the maximum graph latency
+ HRESULT SetMaxStreamOffset (
+ [in] REFERENCE_TIME rtMaxOffset
+ );
+};
+
+
+// ------------------------------------------------------------------------
+//
+// IAMDeviceRemoval interface
+//
+// Implemented by filters to request and receive WM_DEVICECHANGE
+// notifications
+//
+// ------------------------------------------------------------------------
+
+[
+ object,
+ uuid(f90a6130-b658-11d2-ae49-0000f8754b99),
+ pointer_default(unique)
+]
+interface IAMDeviceRemoval : IUnknown
+{
+
+ HRESULT DeviceInfo(
+ [out] CLSID *pclsidInterfaceClass,
+ [out] WCHAR **pwszSymbolicLink);
+
+ HRESULT Reassociate();
+
+ HRESULT Disassociate();
+}
+
+//
+// for DV
+//
+typedef struct {
+ //for 1st 5/6 DIF seq.
+ DWORD dwDVAAuxSrc;
+ DWORD dwDVAAuxCtl;
+ //for 2nd 5/6 DIF seq.
+ DWORD dwDVAAuxSrc1;
+ DWORD dwDVAAuxCtl1;
+ //for video information
+ DWORD dwDVVAuxSrc;
+ DWORD dwDVVAuxCtl;
+ DWORD dwDVReserved[2];
+
+} DVINFO, *PDVINFO;
+
+// ------------------------------------------------------------------------
+//
+// IDVEnc interface
+//
+// Implemented by DV encoder filters to set Encoder format
+//
+// ------------------------------------------------------------------------
+enum _DVENCODERRESOLUTION { //resolution
+ DVENCODERRESOLUTION_720x480 = 2012,
+ DVENCODERRESOLUTION_360x240 = 2013,
+ DVENCODERRESOLUTION_180x120 = 2014,
+ DVENCODERRESOLUTION_88x60 = 2015
+};
+enum _DVENCODERVIDEOFORMAT { //PAL/ntsc
+ DVENCODERVIDEOFORMAT_NTSC = 2000,
+ DVENCODERVIDEOFORMAT_PAL = 2001
+};
+enum _DVENCODERFORMAT { // dvsd/dvhd/dvsl
+ DVENCODERFORMAT_DVSD = 2007,
+ DVENCODERFORMAT_DVHD = 2008,
+ DVENCODERFORMAT_DVSL = 2009
+};
+[
+ object,
+ uuid(d18e17a0-aacb-11d0-afb0-00aa00b67a42),
+ pointer_default(unique)
+]
+interface IDVEnc : IUnknown
+{
+
+ HRESULT get_IFormatResolution (
+ [out] int *VideoFormat, //pal or ntsc
+ [out] int *DVFormat, //dvsd dvhd dvsl
+ [out] int *Resolution, //720, 360, 180,88
+ [in] BYTE fDVInfo, //TRUE: DVINFO structure exist, FALSE: Do not care DVINFO
+ [out] DVINFO *sDVInfo //NULL if fDVInfo=FALSE,
+ );
+
+ HRESULT put_IFormatResolution (
+ [in] int VideoFormat,
+ [in] int DVFormat,
+ [in] int Resolution,
+ [in] BYTE fDVInfo, //TRUE: DVINFO structure exist, FALSE: Do not care DVINFO
+ [in] DVINFO *sDVInfo //NULL if fDVInfo=FALSE,
+ );
+
+}
+
+// ------------------------------------------------------------------------
+//
+// IDVDec interface
+//
+// Implemented by DV decoder filters to set decoder size
+//
+// ------------------------------------------------------------------------
+enum _DVDECODERRESOLUTION {
+ DVDECODERRESOLUTION_720x480 = 1000,
+ DVDECODERRESOLUTION_360x240 = 1001,
+ DVDECODERRESOLUTION_180x120 = 1002,
+ DVDECODERRESOLUTION_88x60 = 1003
+};
+enum _DVRESOLUTION {
+ DVRESOLUTION_FULL = 1000,
+ DVRESOLUTION_HALF = 1001,
+ DVRESOLUTION_QUARTER = 1002,
+ DVRESOLUTION_DC = 1003
+};
+[
+ object,
+ uuid(b8e8bd60-0bfe-11d0-af91-00aa00b67a42),
+ pointer_default(unique)
+]
+interface IIPDVDec : IUnknown
+{
+ HRESULT get_IPDisplay (
+ [out] int *displayPix // The display pixels arrage
+ );
+
+ HRESULT put_IPDisplay (
+ [in] int displayPix // Change to this display pixel arrage
+ ) ;
+}
+
+//------------------------------------------------------------------------
+//
+// IDVRGB219 interface
+//
+// Implemented by both the DV encoder and decoder filters
+// Used for enabling the 219 mode in which the Range of RGB24 either received
+// by the encoder or produced by the decoder becomes (16,16,16)--(235,235,235)
+// instead of (0,0,0)--(255,255,255).
+// The interface's method has no effect in case of any other color space than
+// RGB 24
+//
+//------------------------------------------------------------------------
+
+[
+ object,
+ uuid(58473A19-2BC8-4663-8012-25F81BABDDD1),
+ pointer_default(unique)
+]
+interface IDVRGB219 : IUnknown
+{
+ HRESULT SetRGB219 ([in] BOOL bState); // State = True Turn 219 mode on else turn it off.
+}
+
+
+// ------------------------------------------------------------------------
+//
+// IDVSplitter interface
+//
+// Implemented by DV splitter filters
+//
+// ------------------------------------------------------------------------
+[
+ object,
+ uuid(92a3a302-da7c-4a1f-ba7e-1802bb5d2d02)
+]
+interface IDVSplitter : IUnknown
+{
+ HRESULT DiscardAlternateVideoFrames(
+ [in] int nDiscard
+ ) ;
+}
+
+// Audio Renderer statistics params for IAMAudioRendererStats interface
+enum _AM_AUDIO_RENDERER_STAT_PARAM {
+ AM_AUDREND_STAT_PARAM_BREAK_COUNT = 1, // audio breaks
+ AM_AUDREND_STAT_PARAM_SLAVE_MODE, // current slave mode, see AM_AUDREND_SLAVE_MODEs
+ AM_AUDREND_STAT_PARAM_SILENCE_DUR, // silence inserted due to gaps (ms)
+ AM_AUDREND_STAT_PARAM_LAST_BUFFER_DUR, // duration of the last buffer received
+ AM_AUDREND_STAT_PARAM_DISCONTINUITIES, // discontinuities seen since running
+ AM_AUDREND_STAT_PARAM_SLAVE_RATE, // what rate are we currently slaving at? S_FALSE if not slaving
+ AM_AUDREND_STAT_PARAM_SLAVE_DROPWRITE_DUR, // for waveOut slaving - data dropped or added to stay in-sync
+ // dwParam1 - dropped duration(ms)
+ // dwParam2 - paused duration(ms)
+ AM_AUDREND_STAT_PARAM_SLAVE_HIGHLOWERROR, // highest & lowest clock differences seen
+ // dwParam1 - high err
+ // dwParam2 - low err
+ AM_AUDREND_STAT_PARAM_SLAVE_LASTHIGHLOWERROR, // last high and low errs seen
+ // dwParam1 - last high err
+ // dwParam2 - last low err
+ AM_AUDREND_STAT_PARAM_SLAVE_ACCUMERROR, // error between master/slave clocks
+ AM_AUDREND_STAT_PARAM_BUFFERFULLNESS, // percent audio buffer fullness
+ AM_AUDREND_STAT_PARAM_JITTER // input buffer jitter
+};
+
+//---------------------------------------------------------------------
+//
+// IAMAudioRendererStats interface
+//
+// Interface to get at statistical information that is optionally stored
+// in an audio renderer filter. Supported on the filter interface (although
+// this might be better for ksproxy if we define it as a pin interface?)
+//
+//---------------------------------------------------------------------
+
+[
+object,
+ uuid(22320CB2-D41A-11d2-BF7C-D7CB9DF0BF93),
+ pointer_default(unique)
+]
+interface IAMAudioRendererStats : IUnknown
+{
+ // Get value corresponding to the passed in parameter id
+ HRESULT GetStatParam(
+ [in] DWORD dwParam,
+ [out] DWORD *pdwParam1,
+ [out] DWORD *pdwParam2
+ );
+}
+
+//---------------------------------------------------------------------
+//
+// IAMLatency interface
+//
+// Allows a filter to report the expected latency associated with a data
+// stream flowing from its input to output pin. Supported on output pins.
+//
+//---------------------------------------------------------------------
+
+[
+object,
+ uuid(62EA93BA-EC62-11d2-B770-00C04FB6BD3D),
+ pointer_default(unique)
+]
+interface IAMLatency : IUnknown
+{
+ HRESULT GetLatency(
+ [in] REFERENCE_TIME *prtLatency
+ );
+}
+
+
+enum _AM_INTF_SEARCH_FLAGS {
+ AM_INTF_SEARCH_INPUT_PIN = 0x00000001, // search input pins
+ AM_INTF_SEARCH_OUTPUT_PIN = 0x00000002, // search output pins
+ AM_INTF_SEARCH_FILTER = 0x00000004 // search filters
+};
+
+//---------------------------------------------------------------------
+//
+// IAMGraphStreams interface
+//
+// Interface used to control or search over connected streams of data
+// flow within a filter graph.
+//
+//---------------------------------------------------------------------
+
+[
+object,
+ uuid(632105FA-072E-11d3-8AF9-00C04FB6BD3D),
+ pointer_default(unique)
+]
+interface IAMGraphStreams : IUnknown
+{
+ // Search upstream from the current pin, for the specified interface.
+ // dwFlags can be any combination of the AM_INTF_SEARCH_FLAGS, and allows
+ // control over what objects to search. A value of 0 means to search all.
+ HRESULT FindUpstreamInterface(
+ [in] IPin *pPin,
+ [in] REFIID riid,
+ [out, iid_is(riid)] void **ppvInterface,
+ [in] DWORD dwFlags );
+
+ // Enable or disable the graph's setting of a timestamp offset
+ // on push sources.
+ HRESULT SyncUsingStreamOffset( [in] BOOL bUseStreamOffset );
+
+ // allow an app to set the maximum offset used on push source filters
+ HRESULT SetMaxGraphLatency( [in] REFERENCE_TIME rtMaxGraphLatency );
+}
+
+
+//
+// IAMOverlayFX
+//
+// This interface is exposed by the overlay mixer filter and allows
+// an application to apply various "effects" to the overlay surface
+// used by the overlay mixer.
+//
+// The effects that can be applied are described by the AMOVERLAYFX
+// enumeration.
+//
+enum AMOVERLAYFX {
+ // Normal (ie. top down, left to right) video
+ AMOVERFX_NOFX = 0x00000000,
+
+ // Mirror the overlay across the vertical axis
+ AMOVERFX_MIRRORLEFTRIGHT = 0x00000002,
+
+ // Mirror the overlay across the horizontal axis
+ AMOVERFX_MIRRORUPDOWN = 0x00000004,
+
+ // Deinterlace the overlay, if possible
+ AMOVERFX_DEINTERLACE = 0x00000008
+};
+
+[
+object,
+ uuid(62fae250-7e65-4460-bfc9-6398b322073c),
+ pointer_default(unique)
+]
+interface IAMOverlayFX : IUnknown
+{
+ // Use this method to determine what overlay effects are currently available
+ // for the overlay surface used by the overlay mixer filter.
+ //
+ HRESULT QueryOverlayFXCaps(
+ [out] DWORD *lpdwOverlayFXCaps
+ );
+
+ // Use this method to apply a new overlay effect to the overlay surface
+ // used by the overlay mixer filter. This method can be called while the
+ // filter graph is running, the effect is applied immediately
+ //
+ HRESULT SetOverlayFX(
+ [in] DWORD dwOverlayFX
+ );
+
+ // Use this method to determine what effect (if any) is currently being
+ // applied to the overlay surface by the overlay mixer filter.
+ //
+ HRESULT GetOverlayFX(
+ [out] DWORD *lpdwOverlayFX
+ );
+}
+
+
+
+// IAMOpenProgress interface provides information about current progress through
+// a download
+
+[
+object,
+uuid(8E1C39A1-DE53-11cf-AA63-0080C744528D),
+pointer_default(unique)
+]
+
+interface IAMOpenProgress : IUnknown
+{
+ // QueryProgress can be used to query the source filter which supports this interface
+ // for progress information during a renderfile operation.
+ HRESULT QueryProgress(
+ [out] LONGLONG* pllTotal,
+ [out] LONGLONG* pllCurrent
+ );
+
+ // AbortOperation can be used to request an abort of RenderFile operation
+ // causing it to stop downloading. This methods instructs the exporter of
+ // the IAMOpenProgress interface to hold up their internal abort flag until
+ // further notice.
+ HRESULT AbortOperation(
+ );
+}
+
+
+/*++
+ IMpeg2Demultiplexer
+
+ This interface is implemented by the MPEG-2 Demultiplexer filter,
+ irrespective of program vs. transport stream splitting functionality.
+--*/
+[
+ object,
+ local,
+ uuid (436eee9c-264f-4242-90e1-4e330c107512),
+ pointer_default(unique)
+]
+interface IMpeg2Demultiplexer : IUnknown
+{
+ /*++
+ ------------------------------------------------------------------------
+ purpose: Creates an output pin of the specified media type.
+
+ pMediaType media type specifier for the new pin
+ pszPinName pin name; cannot be a duplicate of an existing pin
+ ppIPin IPin interface pointer to the newly created pin
+ --*/
+ HRESULT
+ CreateOutputPin (
+ [in] AM_MEDIA_TYPE * pMediaType,
+ [in] LPWSTR pszPinName,
+ [out] IPin ** ppIPin
+ ) ;
+
+ /*++
+ ------------------------------------------------------------------------
+ purpose: Updates the media type of the specified output pin. If no
+ connection exists, the media type is updated always. If
+ the pin is connected, the success/failure of the call will
+ depend on downstream input pin's accetance/rejection of
+ the specified media type, and subsequent success/failure
+ of a reconnect.
+
+ pszPinName pin name
+ pMediaType new media type specifier
+ --*/
+ HRESULT
+ SetOutputPinMediaType (
+ [in] LPWSTR pszPinName,
+ [in] AM_MEDIA_TYPE * pMediaType
+ ) ;
+
+ /*++
+ ------------------------------------------------------------------------
+ purpose: Deletes the specified output pin.
+
+ pszPinName pin name
+ --*/
+ HRESULT
+ DeleteOutputPin (
+ [in] LPWSTR pszPinName
+ ) ;
+} ;
+
+//---------------------------------------------------------------------
+// IEnumStreamIdMap interface
+//---------------------------------------------------------------------
+
+cpp_quote("#define MPEG2_PROGRAM_STREAM_MAP 0x00000000")
+cpp_quote("#define MPEG2_PROGRAM_ELEMENTARY_STREAM 0x00000001")
+cpp_quote("#define MPEG2_PROGRAM_DIRECTORY_PES_PACKET 0x00000002")
+cpp_quote("#define MPEG2_PROGRAM_PACK_HEADER 0x00000003")
+cpp_quote("#define MPEG2_PROGRAM_PES_STREAM 0x00000004")
+cpp_quote("#define MPEG2_PROGRAM_SYSTEM_HEADER 0x00000005")
+
+cpp_quote("#define SUBSTREAM_FILTER_VAL_NONE 0x10000000")
+
+typedef struct {
+ ULONG stream_id ; // mpeg-2 stream_id
+ DWORD dwMediaSampleContent ; // #define'd above
+ ULONG ulSubstreamFilterValue ; // filtering value
+ int iDataOffset ; // offset to elementary stream
+} STREAM_ID_MAP ;
+
+/*++
+ Enumerates the StreamIds mapped on a pin
+--*/
+[
+ object,
+ local,
+ uuid (945C1566-6202-46fc-96C7-D87F289C6534),
+ pointer_default(unique)
+]
+interface IEnumStreamIdMap : IUnknown
+{
+ HRESULT
+ Next (
+ [in] ULONG cRequest,
+ [in, out, size_is (cRequest)] STREAM_ID_MAP * pStreamIdMap,
+ [out] ULONG * pcReceived
+ ) ;
+
+ HRESULT
+ Skip (
+ [in] ULONG cRecords
+ ) ;
+
+ HRESULT
+ Reset (
+ ) ;
+
+ HRESULT
+ Clone (
+ [out] IEnumStreamIdMap ** ppIEnumStreamIdMap
+ ) ;
+} ;
+
+/*++
+ Implemented on the output pin.
+
+ Provides the ability to map/unmap a stream_id to/from an output pin.
+--*/
+[
+ object,
+ local,
+ uuid (D0E04C47-25B8-4369-925A-362A01D95444),
+ pointer_default(unique)
+]
+interface IMPEG2StreamIdMap : IUnknown
+{
+ HRESULT
+ MapStreamId (
+ [in] ULONG ulStreamId, // mpeg-2 stream_id
+ [in] DWORD MediaSampleContent, // #define'd above IEnumStreamIdMap
+ [in] ULONG ulSubstreamFilterValue, // filter value
+ [in] int iDataOffset // elementary stream offset
+ ) ;
+
+ HRESULT
+ UnmapStreamId (
+ [in] ULONG culStreamId, // number of stream_id's in pulStreamId
+ [in] ULONG * pulStreamId // array of stream_id's to unmap
+ ) ;
+
+ HRESULT
+ EnumStreamIdMap (
+ [out] IEnumStreamIdMap ** ppIEnumStreamIdMap
+ ) ;
+} ;
+
+
+// Register a service provider with the filter graph
+[
+ object,
+ local,
+ uuid(7B3A2F01-0751-48DD-B556-004785171C54),
+ pointer_default(unique)
+]
+interface IRegisterServiceProvider : IUnknown
+{
+ // registers one service into it's internal table.. Object is refcounted.
+ // register a NULL value to remove the service
+ HRESULT RegisterService([in] REFGUID guidService, [in] IUnknown *pUnkObject);
+};
+
+
+
+//---------------------------------------------------------------------
+//
+// IAMClockSlave interface
+//
+// When the audio renderer is slaving to a separate graph clock this
+// interface provides a way for an app to specify how closely in sync
+// the slaving renderer should try to stay to the graph clock. Note that
+// using a larger tolerance for a video & audio playback graph will likely
+// result in looser a/v sync, so it recommended not to change this setting
+// except under special circumstances.
+//
+//---------------------------------------------------------------------
+
+//
+// Used to set/get the error tolerance used by a slaving audio renderer
+//
+[
+object,
+ uuid(9FD52741-176D-4b36-8F51-CA8F933223BE),
+ pointer_default(unique)
+]
+interface IAMClockSlave : IUnknown
+{
+ // set millisecond value to use for slaving tolerance
+ // the allowed range is 1 to 1000ms
+ HRESULT SetErrorTolerance (
+ [in] DWORD dwTolerance
+ );
+
+ // get millisecond value currently being used for slaving tolerance
+ HRESULT GetErrorTolerance (
+ [out] DWORD *pdwTolerance
+ );
+};
+
+
+
+//---------------------------------------------------------------------
+//
+// IAMGraphBuilderCallback interface
+//
+// Interface which gives the app a chance to configure filters
+// before a connection is attempted.
+//
+// If this interface is supported by the site passed in to the graph
+// via IObjectWithSite::SetSite, the graph will call back with each
+// filter it creates as part of the Render or Connect process. Does
+// not call back for source filters. Filter may be discarded and not
+// used in graph or may be connected and disconnected more than once
+//
+// The callback occurs with the graph lock held, so do not call into
+// the graph again and do not wait on other threads calling into the
+// graph.
+//
+//---------------------------------------------------------------------
+
+[
+ object,
+ uuid(4995f511-9ddb-4f12-bd3b-f04611807b79),
+ local,
+ pointer_default(unique)
+]
+interface IAMGraphBuilderCallback : IUnknown
+{
+ // graph builder selected a filter to create and attempt to
+ // connect. failure indicates filter should be rejected.
+ HRESULT SelectedFilter(
+ [in] IMoniker *pMon
+ );
+
+ // app configures filter during this call. failure indicates
+ // filter should be rejected.
+ HRESULT CreatedFilter(
+ [in] IBaseFilter *pFil
+ );
+};
+
+cpp_quote("#ifdef __cplusplus")
+cpp_quote("#ifndef _IAMFilterGraphCallback_")
+cpp_quote("#define _IAMFilterGraphCallback_")
+cpp_quote("// Note: Because this interface was not defined as a proper interface it is")
+cpp_quote("// supported under C++ only. Methods aren't stdcall.")
+cpp_quote("EXTERN_GUID(IID_IAMFilterGraphCallback,0x56a868fd,0x0ad4,0x11ce,0xb0,0xa3,0x0,0x20,0xaf,0x0b,0xa7,0x70);")
+cpp_quote("interface IAMFilterGraphCallback : public IUnknown")
+cpp_quote("{")
+cpp_quote(" // S_OK means rendering complete, S_FALSE means retry now.")
+cpp_quote(" virtual HRESULT UnableToRender(IPin *pPin) = 0;")
+cpp_quote(" ")
+cpp_quote("};")
+cpp_quote("#endif // _IAMFilterGraphCallback_")
+cpp_quote("#endif")
+
+//------------------------------------------------------------------------------
+// File: EncAPI.idl
+//
+// Desc: Encoder (and future decoder) interface definitions.
+//
+// Copyright (c) 1992 - 2002, Microsoft Corporation. All rights reserved.
+//------------------------------------------------------------------------------
+
+struct CodecAPIEventData
+{
+ GUID guid;
+ DWORD dataLength;
+ DWORD reserved[3];
+ // BYTE data[dataLength];
+};
+
+interface IStream; // forward declaration
+//
+// Applications can pass the CODECAPI_VIDEO_ENCODER to IsSupported to test for video encoders
+// Similarly, the GUIDs for audio encoders, video decoders, audio decoders and muxes can be
+// used to test for the codec classification
+//
+// See uuids.h for a more detailed list.
+//
+[
+ object,
+ uuid(901db4c7-31ce-41a2-85dc-8fa0bf41b8da),
+ pointer_default(unique)
+]
+interface ICodecAPI : IUnknown
+{
+ //
+ // IsSupported():
+ //
+ // Query whether a given parameter is supported.
+ //
+ HRESULT
+ IsSupported (
+ [in] const GUID *Api
+ );
+
+ //
+ // IsModifiable
+ //
+ // Query whether a given parameter can be changed given the codec selection
+ // and other parameter selections.
+ //
+ HRESULT
+ IsModifiable (
+ [in] const GUID *Api
+ );
+
+ //
+ // GetParameterRange():
+ //
+ // Returns the valid range of values that the parameter supports should
+ // the parameter support a stepped range as opposed to a list of specific
+ // values. The support is [ValueMin .. ValueMax] by SteppingDelta.
+ //
+ // Ranged variant types must fall into one of the below types. Each
+ // parameter will, by definition, return a specific type.
+ //
+ // If the range has no stepping delta (any delta will do), the Stepping
+ // delta will be empty (VT_EMPTY).
+ //
+ HRESULT
+ GetParameterRange (
+ [in] const GUID *Api,
+ [out] VARIANT *ValueMin,
+ [out] VARIANT *ValueMax,
+ [out] VARIANT *SteppingDelta
+ );
+
+ //
+ // GetParameterValues():
+ //
+ // Returns the list of values supported by the given parameter as a
+ // COM allocated array. The total number of values will be placed in
+ // the ValuesCount parameter and the Values array will contain the
+ // individual values. This array must be freed by the caller through
+ // CoTaskMemFree().
+ //
+ HRESULT
+ GetParameterValues (
+ [in] const GUID *Api,
+ [out, size_is(,*ValuesCount)] VARIANT **Values,
+ [out] ULONG *ValuesCount
+ );
+
+ //
+ // GetDefaultValue():
+ //
+ // Get the default value for a parameter, if one exists. Otherwise,
+ // an error will be returned.
+ //
+ HRESULT
+ GetDefaultValue (
+ [in] const GUID *Api,
+ [out] VARIANT *Value
+ );
+
+ //
+ // GetValue():
+ //
+ // Get the current value of a parameter.
+ //
+ HRESULT
+ GetValue (
+ [in] const GUID *Api,
+ [out] VARIANT *Value
+ );
+
+ //
+ // SetValue():
+ //
+ // Set the current value of a parameter.
+ //
+ HRESULT
+ SetValue (
+ [in] const GUID *Api,
+ [in] VARIANT *Value
+ );
+
+ // new methods beyond IEncoderAPI
+
+ //
+ // RegisterForEvent():
+ //
+ // Enable events to be reported for the given event GUID. For DShow
+ // events, the event is returned as
+ // (EC_CODECAPI_EVENT, lParam=userData, lParam2=CodecAPIEventData* Data)
+ // where
+ // - the CodecAPIEventData is COM allocated memory and must be handled and freed
+ // by the application using CoTaskMemFree().
+ // - the userData is the same pointer passed to RegisterForEvent
+ //
+ // Each data block starts with the following structure:
+ // struct CodecAPIEventData
+ // {
+ // GUID guid;
+ // DWORD dataLength;
+ // DWORD reserved[3]; // pad to 16 byte alignment
+ // BYTE data[dataLength];
+ // }
+ // The guid parameter identifies the event. The data associated with the event follows the
+ // structure (represented by the variable length BYTE data[dataLength] array).
+ //
+ // If guid is equal to CODECAPI_CHANGELISTS, then data is an array of GUIDs that changed as
+ // a result of setting the parameter, as follows:
+ // GUID changedGuids[ header.dataLength / sizeof(GUID) ]
+ //
+ // The current array is limited, so a driver may send multiple messages if the array size is
+ // exceeded.
+ //
+ HRESULT
+ RegisterForEvent (
+ [in] const GUID *Api,
+ [in] LONG_PTR userData
+ );
+
+ //
+ // UnregisterForEvent():
+ //
+ // Disable event reporting for the given event GUID.
+ //
+ HRESULT
+ UnregisterForEvent (
+ [in] const GUID *Api
+ );
+
+ //
+ // SetAllDefaults
+ //
+ HRESULT SetAllDefaults(void);
+
+ //
+ // Extended SetValue & SetAllDefaults:
+ //
+ // Changes the current value of a parameter and returns back an alteration list
+ //
+ // The secondary arguments return back a list of other settings
+ // that changed as a result of the SetValue() call (for UI updates etc)
+ // The client must free the buffer.
+ //
+ HRESULT
+ SetValueWithNotify (
+ [in] const GUID *Api,
+ [in] VARIANT *Value,
+ [out, size_is(,*ChangedParamCount)] GUID **ChangedParam,
+ [out] ULONG *ChangedParamCount
+ );
+
+ //
+ // SetAllDefaultsWithNotify
+ //
+ HRESULT SetAllDefaultsWithNotify(
+ [out, size_is(,*ChangedParamCount)] GUID **ChangedParam,
+ [out] ULONG *ChangedParamCount
+ );
+ //
+ // GetAllSettings
+ // Load the current settings from a stream
+ //
+ HRESULT GetAllSettings( [in] IStream* );
+
+ //
+ // SetAllSettings
+ // Save the current settings to a stream
+ //
+ HRESULT SetAllSettings( [in] IStream* );
+
+ //
+ // SetAllSettingsWithNotify
+ //
+ HRESULT SetAllSettingsWithNotify( IStream*,
+ [out, size_is(,*ChangedParamCount)] GUID **ChangedParam,
+ [out] ULONG *ChangedParamCount );
+}
+
+[
+ object,
+ local,
+ uuid(a8809222-07bb-48ea-951c-33158100625b),
+ pointer_default(unique)
+]
+interface IGetCapabilitiesKey : IUnknown
+{
+ HRESULT GetCapabilitiesKey( [out] HKEY* pHKey );
+};
+
+// -----------------------------------------------------------------------------------------
+// From this point on, this is retained for backwards compatiblity only
+// Do not use this for future encoders
+// -----------------------------------------------------------------------------------------
+[
+ object,
+ uuid(70423839-6ACC-4b23-B079-21DBF08156A5),
+ pointer_default(unique)
+]
+interface IEncoderAPI : IUnknown
+{
+ HRESULT IsSupported ( [in] const GUID *Api );
+ HRESULT IsAvailable ( [in] const GUID *Api );
+ HRESULT GetParameterRange ( [in] const GUID *Api,
+ [out] VARIANT *ValueMin, [out] VARIANT *ValueMax,
+ [out] VARIANT *SteppingDelta );
+ HRESULT GetParameterValues ( [in] const GUID *Api,
+ [out, size_is(,*ValuesCount)] VARIANT **Values,
+ [out] ULONG *ValuesCount );
+ HRESULT GetDefaultValue ( [in] const GUID *Api, [out] VARIANT *Value );
+ HRESULT GetValue ( [in] const GUID *Api, [out] VARIANT *Value );
+ HRESULT SetValue ( [in] const GUID *Api, [in] VARIANT *Value );
+}
+
+[
+ object,
+ uuid(02997C3B-8E1B-460e-9270-545E0DE9563E),
+ pointer_default(unique)
+]
+interface IVideoEncoder : IEncoderAPI
+{
+}
+//---------------------------------------------------------------------
+//
+// Old Encoder API Interfaces
+//
+//---------------------------------------------------------------------
+
+cpp_quote ("#ifndef __ENCODER_API_DEFINES__")
+cpp_quote ("#define __ENCODER_API_DEFINES__")
+
+typedef enum {
+
+ //
+ // Bit rate used for encoding is constant
+ //
+ ConstantBitRate = 0,
+
+ //
+ // Bit rate used for encoding is variable with the specified bitrate used
+ // as a guaranteed average over a specified window. The default window
+ // size is considered to be 5 minutes.
+ //
+ VariableBitRateAverage,
+
+ //
+ // Bit rate used for encoding is variable with the specified bitrate used
+ // as a peak rate over a specified window. The default window size
+ // is considered to be 500ms (classically one GOP).
+ //
+ VariableBitRatePeak
+
+} VIDEOENCODER_BITRATE_MODE;
+
+cpp_quote ("#endif // __ENCODER_API_DEFINES__")
+
+cpp_quote("#define AM_GETDECODERCAP_QUERY_VMR_SUPPORT 0x00000001")
+cpp_quote("#define VMR_NOTSUPPORTED 0x00000000")
+cpp_quote("#define VMR_SUPPORTED 0x00000001")
+
+cpp_quote("#define AM_QUERY_DECODER_VMR_SUPPORT 0x00000001")
+cpp_quote("#define AM_QUERY_DECODER_DXVA_1_SUPPORT 0x00000002")
+
+cpp_quote("#define AM_QUERY_DECODER_DVD_SUPPORT 0x00000003")
+cpp_quote("#define AM_QUERY_DECODER_ATSC_SD_SUPPORT 0x00000004")
+cpp_quote("#define AM_QUERY_DECODER_ATSC_HD_SUPPORT 0x00000005")
+cpp_quote("#define AM_GETDECODERCAP_QUERY_VMR9_SUPPORT 0x00000006")
+
+cpp_quote("#define DECODER_CAP_NOTSUPPORTED 0x00000000")
+cpp_quote("#define DECODER_CAP_SUPPORTED 0x00000001")
+
+[
+ object,
+ local,
+ uuid(c0dff467-d499-4986-972b-e1d9090fa941),
+ pointer_default(unique)
+]
+interface IAMDecoderCaps : IUnknown
+{
+ HRESULT GetDecoderCaps([in] DWORD dwCapIndex, [out] DWORD* lpdwCap);
+};
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// IAMCertifiedOutputProtection
+//
+///////////////////////////////////////////////////////////////////////////////
+typedef struct _AMCOPPSignature {
+ BYTE Signature[256];
+} AMCOPPSignature;
+
+typedef struct _AMCOPPCommand {
+ GUID macKDI; // 16 bytes
+ GUID guidCommandID; // 16 bytes
+ DWORD dwSequence; // 4 bytes
+ DWORD cbSizeData; // 4 bytes
+ BYTE CommandData[4056]; // 4056 bytes (4056+4+4+16+16 = 4096)
+} AMCOPPCommand, *LPAMCOPPCommand;
+
+typedef struct _AMCOPPStatusInput {
+ GUID rApp; // 16 bytes
+ GUID guidStatusRequestID;// 16 bytes
+ DWORD dwSequence; // 4 bytes
+ DWORD cbSizeData; // 4 bytes
+ BYTE StatusData[4056]; // 4056 bytes (4056+4+4+16+16 = 4096)
+} AMCOPPStatusInput, *LPAMCOPPStatusInput;
+
+typedef struct _AMCOPPStatusOutput {
+ GUID macKDI; // 16 bytes
+ DWORD cbSizeData; // 4 bytes
+ BYTE COPPStatus[4076]; // 4076 bytes (4076+16+4 = 4096)
+} AMCOPPStatusOutput, *LPAMCOPPStatusOutput;
+
+
+[
+ object,
+ local,
+ uuid(6feded3e-0ff1-4901-a2f1-43f7012c8515),
+ pointer_default(unique)
+]
+interface IAMCertifiedOutputProtection : IUnknown
+{
+ HRESULT KeyExchange (
+ [out] GUID* pRandom, // 128-bit random number generated by Graphics Driver
+ [out] BYTE** VarLenCertGH, // Graphics Hardware certificate, memory released by CoTaskMemFree
+ [out] DWORD* pdwLengthCertGH); // Length of Graphics Hardware certificate
+
+ HRESULT SessionSequenceStart(
+ [in] AMCOPPSignature*pSig); // Concatenation of 128-bit random data security session key,
+ // 128-bit random data integrity session key, 32-bit random
+ // starting status sequence number and 32-bit random starting
+ // command sequence number encrypted with the public key of
+ // the graphic hardware. This value is 2048 bits long.
+
+ HRESULT ProtectionCommand(
+ [in] const AMCOPPCommand* cmd); // Encrypted command
+
+ HRESULT ProtectionStatus(
+ [in] const AMCOPPStatusInput* pStatusInput, // Encrypted Status request
+ [out] AMCOPPStatusOutput* pStatusOutput); // Encrypted Status results
+};
+