1 files changed, 5169 insertions, 0 deletions

diff --git a/sdk/dx8sdk/Include/DShowIDL/axextend.idl b/sdk/dx8sdk/Include/DShowIDL/axextend.idl
new file mode 100644
index 00000000..257fb19a
--- /dev/null
+++ b/sdk/dx8sdk/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
+};
+