1 files changed, 1284 insertions, 0 deletions

diff --git a/sdk/dx8sdk/Include/DShowIDL/axcore.idl b/sdk/dx8sdk/Include/DShowIDL/axcore.idl
new file mode 100644
index 00000000..4aceea78
--- /dev/null
+++ b/sdk/dx8sdk/Include/DShowIDL/axcore.idl
@@ -0,0 +1,1284 @@
+//------------------------------------------------------------------------------
+// File: AXCore.idl
+//
+// Desc: Core streaming interfaces.  Other ActiveMovie-only interfaces
+//       are in AXExtend.idl.
+//
+// Copyright (c) 1992-2002, Microsoft Corporation.  All rights reserved.
+//------------------------------------------------------------------------------
+
+
+// include unknwn.idl and objidl.idl first
+
+#define CHARS_IN_GUID 39  // 128 bits, plus { - } punctuation and terminal null
+                          // chars NOT BYTES in the standard representation
+                          // e.g. {D3588AB0-0781-11ce-B03A-0020AF0BA770} + null
+
+cpp_quote("#define CHARS_IN_GUID     39")
+
+
+//=====================================================================
+//=====================================================================
+// media types & formats
+//=====================================================================
+//=====================================================================
+
+// There is a high-level media type (audio, compressed video,
+// mpeg video, midi). Within each type, there is a subtype (cinepak, pcm)
+// and a length+untyped data block defining the format in a
+// type-specific manner. EG for video/cinepak, the data block would be
+// a bitmapinfo.
+// The contents of the format block are defined by the formattype GUID.
+// For example, FORMAT_VideoInfo, FORMAT_WaveFormatEx. In the future, this
+// may be a pointer to an object supporting property style interfaces
+// in which case the GUID may be something like FORMAT_IUnknown. When
+// you are passed a media type you should check the format type, if
+// it isn't a type you recognize, then don't touch the format block
+
+typedef struct _AMMediaType {
+    GUID     majortype;
+    GUID     subtype;
+    BOOL     bFixedSizeSamples;
+    BOOL     bTemporalCompression;
+    ULONG    lSampleSize;
+    GUID     formattype;
+    IUnknown *pUnk;
+    ULONG    cbFormat;
+    [size_is(cbFormat)] BYTE * pbFormat;
+} AM_MEDIA_TYPE;
+
+//=====================================================================
+//=====================================================================
+// pin information
+//=====================================================================
+//=====================================================================
+
+// is this an input or output pin
+typedef enum _PinDirection {
+    PINDIR_INPUT,
+    PINDIR_OUTPUT
+} PIN_DIRECTION;
+
+// other types that need defining
+#define MAX_PIN_NAME     128
+cpp_quote("#define MAX_PIN_NAME     128")
+cpp_quote("#define MAX_FILTER_NAME  128")
+#define MAX_FILTER_NAME  128
+
+
+//=====================================================================
+//=====================================================================
+// time information
+//
+// This represents a time (either reference or stream) in 100ns units.
+// The class library contains a CRefTime helper class
+// that supports simple comparison and arithmetic operations
+//=====================================================================
+//=====================================================================
+
+typedef LONGLONG REFERENCE_TIME;
+typedef double REFTIME;
+
+// Win32 HANDLEs have to be cast to these as the MIDL compiler doesn't
+// like the HANDLE type or in fact anything remotely associated with
+// them. If this ever gets ported to a MAC environment then these will
+// have to become an alertable synchronisation object that it supports
+
+typedef DWORD_PTR HSEMAPHORE;
+typedef DWORD_PTR HEVENT;
+
+//=====================================================================
+//=====================================================================
+// Allocator properties
+//
+// Used to describe the actual properties of an allocator,
+// and used to request properties from an allocator or from an upstream
+// filter that could create an allocator. See IMemAllocator and
+// IMemInputPin.
+//=====================================================================
+//=====================================================================
+typedef struct _AllocatorProperties {
+        long cBuffers;  // count of buffers at this allocator
+        long cbBuffer;  // size of each buffer, excluding any prefix
+
+        // alignment of the buffer - buffer start will be aligned on a multiple of
+        // this amount
+        long cbAlign;
+
+        // prefix amount. Each buffer is immediately preceeded by cbPrefix bytes.
+        // note that GetPointer points to the beginning of the buffer proper.
+        // the prefix is aligned, i.e. (GetPointer() - cbPrefix) is aligned on cbAlign.
+        long cbPrefix;
+} ALLOCATOR_PROPERTIES;
+
+
+
+
+
+// forward declarations (in alphabetical order - we were getting duplicates)
+interface IAMovieSetup;
+interface IEnumFilters;
+interface IEnumMediaTypes;
+interface IEnumPins;
+interface IBaseFilter;
+interface IFilterGraph;
+interface IMediaFilter;
+interface IMediaSample;
+interface IMemAllocator;
+interface IMemAllocatorCallbackTemp;
+interface IMemAllocatorNotifyCallbackTemp;
+interface IMemInputPin;
+interface IPin;
+interface IReferenceClock;
+
+
+
+//=====================================================================
+//=====================================================================
+// Defines IPin interface
+//
+// interface representing a single, unidirection connection point on a
+// filter. A Pin will connect to exactly one other pin on another filter.
+// This interface represents the interface other objects can call on
+// this pin. The interface between the filter and the pin is private to
+// the implementation of a specific filter.
+//
+// During the connection process, one pin will be instructed to take
+// the lead: the connect interface on this pin will be calling, passing
+// the IPin* for the other pin. This connecting pin will call the
+// ReceiveConnection member function on the other pin, as well as presumably
+// other format-enumeration and queryinterface calls to establish whether
+// the connection is possible.
+//=====================================================================
+//=====================================================================
+
+[
+object,
+uuid(56a86891-0ad4-11ce-b03a-0020af0ba770),
+pointer_default(unique)
+]
+interface IPin : IUnknown {
+
+    // initiate a connection to another pin. calls ReceiveConnection on the
+    // other pin. Verifies that the connection is possible and may reject
+    // it.
+    // The mediatype parameter is optional. If it is not null, the pin must
+    // connect using that media type if possible. The subtype and/or format
+    // type can be GUID_NULL, meaning that the pin can fill them in as desired.
+    // This allows an application to partially specify the media type to be
+    // used for the connection, insisting on eg YUV 422 but leaving details
+    // (such as the image size) to be negotiated between the pins.
+    HRESULT Connect(
+        [in] IPin * pReceivePin,        // connect yourself to this pin
+        [in] const AM_MEDIA_TYPE * pmt  // (optional) connect using this type
+    );
+
+    // called by a connecting pin to make a connection
+    HRESULT ReceiveConnection(
+        [in] IPin * pConnector,
+        [in] const AM_MEDIA_TYPE *pmt   // this is the media type we will exchange
+    );
+
+    // break a connection - no params since there is only one connection
+    // possible on this pin
+    HRESULT Disconnect(void);
+
+    // Find the pin this pin is connected to (if any)
+    // The pointer returned is AddRef()d
+    // Fails if the pin is not connected
+    HRESULT ConnectedTo(
+        [out] IPin **pPin
+    );
+
+    // Return the media type of a connection if the pin is connected
+    HRESULT ConnectionMediaType(
+        [out] AM_MEDIA_TYPE *pmt
+    );
+
+    // get information about the pin itself
+    typedef struct _PinInfo {
+    IBaseFilter *pFilter;   // the filter this pin is on
+    PIN_DIRECTION dir;  // am I an input or output pin?
+    WCHAR achName[MAX_PIN_NAME];    // the name of this pin within this filter
+    } PIN_INFO;
+
+    HRESULT QueryPinInfo(
+        [out] PIN_INFO * pInfo
+    );
+
+    // We often want to know the direction.  Rather than use the
+    // relatively expensive QueryPinInfo, use this
+    HRESULT QueryDirection(
+        [out] PIN_DIRECTION *pPinDir
+    );
+
+    // Get an identifier for the pin (allows connections to be saved).
+    // The storage will be allocated by the filter using CoTaskMemAlloc
+    // The caller should free it using CoTaskMemFree
+    HRESULT QueryId(
+        [out] LPWSTR * Id
+    );
+
+    // will the pin accept the format type, S_OK yes, S_FALSE no
+    HRESULT QueryAccept(
+        [in] const AM_MEDIA_TYPE *pmt
+    );
+
+    // return an enumerator for this pin's preferred media types
+    HRESULT EnumMediaTypes(
+        [out] IEnumMediaTypes **ppEnum
+    );
+
+    // return an array of IPin* - the pins that this pin internally connects to
+    // All pins put in the array must be AddReffed (but no others)
+    // Errors: "Can't say" - FAIL; not enough slots - return S_FALSE
+    // Default: return E_NOTIMPL
+    // The filter graph will interpret E_NOTIMPL as any input pin connects to
+    // all visible output pins and vise versa.
+    // apPin can be NULL if nPin==0 (not otherwise).
+    HRESULT QueryInternalConnections(
+        [out] IPin* *apPin,     // array of IPin*
+        [in, out] ULONG *nPin   // on input, the number of slots
+                                // on output  the number of pins
+    );
+
+    // notify the pin that no more data is expected until a new run
+    // command is issued. End of stream should be queued and delivered after
+    // all queued data is delivered. Pass through if there is no queued data.
+    // Flush should flush any queued EOS.
+    // returns S_OK unless there is some error.
+    // input pins only: output pins will normally return E_UNEXPECTED.
+    HRESULT EndOfStream(void);
+
+    // Flush
+
+    // Enter flush state: do the following steps (in order)
+    // -- prevent any more Receives succeeding (set a flushing flag)
+    // -- discard any queued data
+    // -- free anyone blocked on Receive in your filter
+    // -- pass BeginFlush to any downstream pins
+    HRESULT BeginFlush(void);
+
+    // End flush state: do the following steps in order
+    // -- ensure no more data will be pushed by your filter
+    //    (sync with thread if you have one, stop it pushing and
+    //     discard any queued data)
+    // -- re-enable Receive (clear internal flushing flag)
+    // -- pass EndFlush to any downstream pins
+    HRESULT EndFlush(void);
+
+    // informational: all data arriving after this call is part of a segment
+    // from StartTime to StopTime, played at rate. This allows filters that
+    // process buffers containing more than one sample to clip the rendering
+    // to within the start and stop times.
+    //
+    // A source pin will call a destination pin on this method after completing
+    // delivery of any previous data, and before any Receive calls for the
+    // new data
+    HRESULT NewSegment(
+                [in] REFERENCE_TIME tStart,
+                [in] REFERENCE_TIME tStop,
+                [in] double dRate);
+}
+
+typedef IPin *PPIN;
+
+
+//=====================================================================
+//=====================================================================
+// Defines IEnumPins interface
+//
+// interface returned from IBaseFilter::EnumPins(). based on IEnumXXXX
+//=====================================================================
+//=====================================================================
+
+[
+object,
+uuid(56a86892-0ad4-11ce-b03a-0020af0ba770),
+pointer_default(unique)
+]
+interface IEnumPins : IUnknown {
+
+    HRESULT Next(
+        [in] ULONG cPins,                       // place this many pins...
+        [out, size_is(cPins)] IPin ** ppPins,   // ...in this array
+        [out] ULONG * pcFetched                 // actual count passed
+    );
+
+    HRESULT Skip(
+        [in] ULONG cPins);
+
+    HRESULT Reset(void);
+
+    HRESULT Clone(
+        [out] IEnumPins **ppEnum
+    );
+}
+
+typedef IEnumPins *PENUMPINS;
+
+
+//=====================================================================
+//=====================================================================
+// Defines IEnumMediaTypes interface
+//
+// Enumerates the preferred formats for a pin
+//=====================================================================
+//=====================================================================
+
+[
+object,
+uuid(89c31040-846b-11ce-97d3-00aa0055595a),
+pointer_default(unique)
+]
+interface IEnumMediaTypes : IUnknown {
+
+    // to call this member function pass in the address of a pointer to a
+    // media type. The interface will allocate the necessary AM_MEDIA_TYPE
+    // structures and initialise them with the variable format block
+
+    HRESULT Next(
+        [in] ULONG cMediaTypes,             // place this many types...
+        [out, size_is(cMediaTypes)]
+             AM_MEDIA_TYPE ** ppMediaTypes, // ...in this array
+        [out] ULONG * pcFetched             // actual count passed
+    );
+
+    HRESULT Skip(
+        [in] ULONG cMediaTypes);
+
+    HRESULT Reset(void);
+
+    HRESULT Clone(
+        [out] IEnumMediaTypes **ppEnum
+    );
+}
+
+typedef IEnumMediaTypes *PENUMMEDIATYPES;
+
+
+
+//========================================================================
+//========================================================================
+// Defines IFilterGraph interface
+//
+// abstraction representing a graph of filters
+// This allows filters to be joined into a graph and operated as a unit.
+//========================================================================
+//========================================================================
+
+[
+object,
+uuid(56a8689f-0ad4-11ce-b03a-0020af0ba770),
+pointer_default(unique)
+]
+interface IFilterGraph : IUnknown {
+
+    //==========================================================================
+    // Low level filter functions
+    //==========================================================================
+
+        // Add a filter to the graph and name it with *pName.
+        // If the name is not unique, The request will fail.
+        // The Filter graph will call the JoinFilterGraph
+        // member function of the filter to inform it.
+        // This must be called before attempting Connect, ConnectDirect or Render
+        // for pins of the filter.
+
+        HRESULT AddFilter
+            ( [in] IBaseFilter * pFilter,
+              [in, string] LPCWSTR pName
+            );
+
+
+        // Remove a filter from the graph. The filter graph implementation
+        // will inform the filter that it is being removed.
+
+        HRESULT RemoveFilter
+            ( [in] IBaseFilter * pFilter
+            );
+
+
+        // Set *ppEnum to be an enumerator for all filters in the graph.
+
+        HRESULT EnumFilters
+            ( [out] IEnumFilters **ppEnum
+            );
+
+
+        // Set *ppFilter to be the filter which was added with the name *pName
+        // Will fail and set *ppFilter to NULL if the name is not in this graph.
+
+        HRESULT FindFilterByName
+            ( [in, string] LPCWSTR pName,
+              [out] IBaseFilter ** ppFilter
+            );
+
+    //==========================================================================
+    // Low level connection functions
+    //==========================================================================
+
+        // Connect these two pins directly (i.e. without intervening filters)
+        // the media type is optional, and may be partially specified (that is
+        // the subtype and/or format type may be GUID_NULL). See IPin::Connect
+        // for details of the media type parameter.
+        HRESULT ConnectDirect
+            ( [in] IPin * ppinOut,              // the output pin
+              [in] IPin * ppinIn,               // the input pin
+              [in, unique] const AM_MEDIA_TYPE* pmt     // optional mediatype
+            );
+
+        // Break the connection that this pin has and reconnect it to the
+        // same other pin.
+
+        HRESULT Reconnect
+            ( [in] IPin * ppin        // the pin to disconnect and reconnect
+            );
+
+
+
+        // Disconnect this pin, if connected.  Successful no-op if not connected.
+
+        HRESULT Disconnect
+            ( [in] IPin * ppin
+            );
+
+    //==========================================================================
+    // intelligent connectivity - now in IGraphBuilder, axextend.idl
+    //==========================================================================
+
+    //==========================================================================
+    // Whole graph functions
+    //==========================================================================
+
+    // Once a graph is built, it can behave as a (composite) filter.
+    // To control this filter, QueryInterface for IMediaFilter.
+
+    // The filtergraph will by default ensure that the graph has a sync source
+    // when it is made to Run.  SetSyncSource(NULL) will prevent that and allow
+    // all the filters to run unsynchronised until further notice.
+    // SetDefaultSyncSource will set the default sync source (the same as would
+    // have been set by default on the first call to Run).
+    HRESULT SetDefaultSyncSource(void);
+
+}
+
+typedef IFilterGraph *PFILTERGRAPH;
+
+
+
+//==========================================================================
+//==========================================================================
+// Defines IEnumFilters interface
+//
+// enumerator interface returned from IFilterGraph::EnumFilters().
+// based on IEnum pseudo-template
+//==========================================================================
+//==========================================================================
+
+[
+object,
+uuid(56a86893-0ad4-11ce-b03a-0020af0ba770),
+pointer_default(unique)
+]
+interface IEnumFilters : IUnknown {
+
+    HRESULT Next
+        ( [in]  ULONG cFilters,           // place this many filters...
+          [out] IBaseFilter ** ppFilter,  // ...in this array of IBaseFilter*
+          [out] ULONG * pcFetched         // actual count passed returned here
+        );
+
+
+    HRESULT Skip
+        ( [in] ULONG cFilters
+        );
+
+
+    HRESULT Reset(void);
+
+
+    HRESULT Clone
+        ( [out] IEnumFilters **ppEnum
+        );
+}
+
+typedef IEnumFilters *PENUMFILTERS;
+
+
+//=====================================================================
+//=====================================================================
+// Defines IMediaFilter interface
+//
+// multimedia components that provide time-based data will expose this.
+// this interface abstracts an object that processes time-based data streams
+// and represents a multimedia device (possibly implemented in software).
+// it controls the active/running state of the object and its synchronization
+// to other objects in the system.
+//
+// derived from IPersist so that all filter-type objects in a graph
+// can have their class id serialised.
+//=====================================================================
+//=====================================================================
+
+[
+object,
+uuid(56a86899-0ad4-11ce-b03a-0020af0ba770),
+pointer_default(unique)
+]
+interface IMediaFilter : IPersist {
+
+    // tell the filter to transition to the new state. The state transition
+    // may not be instantaneous (external mechanical activity may be involved,
+    // for example). The state functions may return before the state
+    // transition has completed
+
+    // these functions will return S_OK if the transition is complete, S_FALSE if
+    // the transition is not complete but no error has occurred, or some error value
+    // if the transition failed.
+    HRESULT Stop(void);
+    HRESULT Pause(void);
+
+    // in order to synchronise independent streams, you must pass a time
+    // value with the Run command. This is the difference between stream
+    // time and reference time. That is, it is the amount to be added to
+    // the IMediaSample timestamp to get the time at which that sample
+    // should be rendered according to the reference clock.
+    // If we are starting at the beginning of the stream, it will thus be
+    // simply the time at which the first sample should appear. If we are
+    // restarting from Paused mode in midstream, then it will be the total
+    // time we have been paused added to the initial start time.
+
+    // the filtergraph will provide this information to its filters. If you
+    // are an app calling the filtergraph, it's ok to pass a start time of
+    // 0, in which case the filter graph will calculate a soon-as-possible
+    // time. FilterGraphs will accept 0 meaning ASAP; most filters will not.
+
+    HRESULT Run(REFERENCE_TIME tStart);
+
+
+    // possible states that the filter could be in
+    typedef enum _FilterState {
+        State_Stopped,            // not in use
+        State_Paused,             // holding resources, ready to go
+        State_Running             // actively processing media stream
+    } FILTER_STATE;
+
+    // find out what state the filter is in.
+    // If timeout is 0, will return immediately - if a state transition is
+    // not complete, it will return the state being transitioned into, and
+    // the return code will be VFW_S_STATE_INTERMEDIATE.  if no state
+    // transition is in progress the state will be returned and the return
+    // code will be S_OK.
+    //
+    // If timeout is non-zero, GetState will not return until the state
+    // transition is complete, or the timeout expires.
+    // The timeout is in milliseconds.
+    // You can also pass in INFINITE as a special value for the timeout, in
+    // which case it will block indefinitely waiting for the state transition
+    // to complete. If the timeout expires, the state returned is the
+    // state we are trying to reach, and the return code will be
+    // VFW_S_STATE_INTERMEDIATE. If no state transition is in progress
+    // the routine returns immediately with return code S_OK.
+
+    //
+    // return State is State_Running, State_Paused or State_Stopped.
+    // return code is S_OK, or VFW_S_STATE_INTERMEDIATE if state
+    // transition is not complete or an error value if the method failed.
+    HRESULT GetState(
+                [in] DWORD dwMilliSecsTimeout,
+                [out] FILTER_STATE *State);
+
+
+    // tell the filter the reference clock to which it should synchronize
+    // activity. This is most important to rendering filters and may not
+    // be of any interest to other filters.
+    HRESULT SetSyncSource(
+        [in] IReferenceClock * pClock);
+
+    // get the reference clock currently in use (it may be NULL)
+    HRESULT GetSyncSource(
+        [out] IReferenceClock ** pClock);
+}
+
+typedef IMediaFilter *PMEDIAFILTER;
+
+
+//=====================================================================
+//=====================================================================
+// Defines IBaseFilter interface
+//
+// all multimedia components will expose this interface
+// this interface abstracts an object that has typed input and output
+// connections and can be dynamically aggregated.
+//
+// IMediaFilter supports synchronisation and activity state: IBaseFilter
+// is derived from that since all filters need to support IMediaFilter,
+// whereas a few objects (plug-in control distributors for example) will
+// support IMediaFilter but not IBaseFilter.
+//
+// IMediaFilter is itself derived from IPersist so that every filter
+//supports GetClassID()
+//=====================================================================
+//=====================================================================
+
+[
+object,
+uuid(56a86895-0ad4-11ce-b03a-0020af0ba770),
+pointer_default(unique)
+]
+interface IBaseFilter : IMediaFilter {
+
+    // enumerate all the pins available on this filter
+    // allows enumeration of all pins only.
+    //
+    HRESULT EnumPins(
+        [out] IEnumPins ** ppEnum     // enum interface returned here
+    );
+
+    // Convert the external identifier of a pin to an IPin *
+    // This pin id is quite different from the pin Name in CreatePin.
+    // In CreatePin the Name is invented by the caller.  In FindPin the Id
+    // must have come from a previous call to IPin::QueryId.  Whether or not
+    // this operation would cause a pin to be created depends on the filter
+    // design, but if called twice with the same id it should certainly
+    // return the same pin both times.
+    HRESULT FindPin(
+        [in, string] LPCWSTR Id,
+        [out] IPin ** ppPin
+    );
+
+    // find out information about this filter
+    typedef struct _FilterInfo {
+    WCHAR achName[MAX_FILTER_NAME]; // maybe null if not part of graph
+        IFilterGraph * pGraph;                   // null if not part of graph
+    } FILTER_INFO;
+
+    HRESULT QueryFilterInfo(
+        [out] FILTER_INFO * pInfo
+    );
+
+    // notify a filter that it has joined a filter graph. It is permitted to
+    // refuse. The filter should addref and store this interface for later use
+    // since it may need to notify events to this interface. A null pointer indicates
+    // that the filter is no longer part of a graph.
+    HRESULT JoinFilterGraph(
+        [in] IFilterGraph * pGraph,
+        [in, string] LPCWSTR pName
+    );
+
+    // return a Vendor information string. Optional - may return E_NOTIMPL.
+    // memory returned should be freed using CoTaskMemFree
+    HRESULT QueryVendorInfo(
+        [out, string] LPWSTR* pVendorInfo
+    );
+}
+
+typedef IBaseFilter *PFILTER;
+
+
+//=====================================================================
+//=====================================================================
+// sync and state management
+//=====================================================================
+//=====================================================================
+
+
+//=====================================================================
+//=====================================================================
+// Defines IReferenceClock interface
+//=====================================================================
+//=====================================================================
+
+[
+        object,
+        uuid(56a86897-0ad4-11ce-b03a-0020af0ba770),
+        pointer_default(unique)
+]
+interface IReferenceClock : IUnknown {
+
+    // get the time now
+    HRESULT GetTime(
+        [out] REFERENCE_TIME *pTime
+    );
+
+    // ask for an async notification that a time has elapsed
+    HRESULT AdviseTime(
+        [in] REFERENCE_TIME baseTime,       // base reference time
+        [in] REFERENCE_TIME streamTime,     // stream offset time
+    [in] HEVENT hEvent,                     // advise via this event
+        [out] DWORD_PTR * pdwAdviseCookie   // where your cookie goes
+    );
+
+    // ask for an async periodic notification that a time has elapsed
+    HRESULT AdvisePeriodic(
+        [in] REFERENCE_TIME startTime,      // starting at this time
+        [in] REFERENCE_TIME periodTime,     // time between notifications
+        [in] HSEMAPHORE hSemaphore,         // advise via a semaphore
+    [out] DWORD_PTR * pdwAdviseCookie       // where your cookie goes
+    );
+
+    // cancel a request for notification
+    HRESULT Unadvise(
+        [in] DWORD_PTR dwAdviseCookie);
+}
+
+typedef IReferenceClock *PREFERENCECLOCK;
+
+//=====================================================================
+//=====================================================================
+// Defines IReferenceClock2 interface
+//=====================================================================
+//=====================================================================
+
+[
+        object,
+        uuid(36b73885-c2c8-11cf-8b46-00805f6cef60),
+        pointer_default(unique)
+]
+interface IReferenceClock2 : IReferenceClock {
+}
+
+typedef IReferenceClock2 *PREFERENCECLOCK2;
+
+
+//=====================================================================
+//=====================================================================
+// Data transport interfaces
+//=====================================================================
+//=====================================================================
+
+
+//=====================================================================
+//=====================================================================
+// Defines IMediaSample interface
+//=====================================================================
+//=====================================================================
+
+[
+        local,
+        object,
+        uuid(56a8689a-0ad4-11ce-b03a-0020af0ba770),
+        pointer_default(unique)
+]
+interface IMediaSample : IUnknown {
+
+    // get me a read/write pointer to this buffer's memory. I will actually
+    // want to use sizeUsed bytes.
+    HRESULT GetPointer([out] BYTE ** ppBuffer);
+
+    // return the size in bytes of the buffer data area
+    long GetSize(void);
+
+    // get the stream time at which this sample should start and finish.
+    HRESULT GetTime(
+        [out] REFERENCE_TIME * pTimeStart,  // put time here
+        [out] REFERENCE_TIME * pTimeEnd
+    );
+
+    // Set the stream time at which this sample should start and finish.
+    // pTimeStart==pTimeEnd==NULL will invalidate the time stamps in
+    // this sample
+    HRESULT SetTime(
+        [in] REFERENCE_TIME * pTimeStart,   // put time here
+        [in] REFERENCE_TIME * pTimeEnd
+    );
+
+    // sync-point property. If true, then the beginning of this
+    // sample is a sync-point. (note that if AM_MEDIA_TYPE.bTemporalCompression
+    // is false then all samples are sync points). A filter can start
+    // a stream at any sync point.  S_FALSE if not sync-point, S_OK if true.
+
+    HRESULT IsSyncPoint(void);
+    HRESULT SetSyncPoint(BOOL bIsSyncPoint);
+
+    // preroll property.  If true, this sample is for preroll only and
+    // shouldn't be displayed.
+    HRESULT IsPreroll(void);
+    HRESULT SetPreroll(BOOL bIsPreroll);
+
+    long GetActualDataLength(void);
+    HRESULT SetActualDataLength(long);
+
+    // these allow for limited format changes in band - if no format change
+    // has been made when you receive a sample GetMediaType will return S_FALSE
+
+    HRESULT GetMediaType(AM_MEDIA_TYPE **ppMediaType);
+    HRESULT SetMediaType(AM_MEDIA_TYPE *pMediaType);
+
+    // returns S_OK if there is a discontinuity in the data (this frame is
+    // not a continuation of the previous stream of data
+    // - there has been a seek or some dropped samples).
+    HRESULT IsDiscontinuity(void);
+    // set the discontinuity property - TRUE if this sample is not a
+    // continuation, but a new sample after a seek or a dropped sample.
+    HRESULT SetDiscontinuity(BOOL bDiscontinuity);
+
+    // get the media times for this sample
+    HRESULT GetMediaTime(
+        [out] LONGLONG * pTimeStart,
+        [out] LONGLONG * pTimeEnd
+    );
+
+    // Set the media times for this sample
+    // pTimeStart==pTimeEnd==NULL will invalidate the media time stamps in
+    // this sample
+    HRESULT SetMediaTime(
+        [in] LONGLONG * pTimeStart,
+        [in] LONGLONG * pTimeEnd
+    );
+}
+
+typedef IMediaSample *PMEDIASAMPLE;
+
+//  Values for dwFlags for AM_SAMPLE_PROPERTIES
+enum tagAM_SAMPLE_PROPERTY_FLAGS
+     { AM_SAMPLE_SPLICEPOINT        = 0x01,   /* Is this a splice point
+                                                 IE can it be decoded
+                                                 without reference to
+                                                 previous data */
+       AM_SAMPLE_PREROLL            = 0x02,   /* Is this a preroll sample */
+       AM_SAMPLE_DATADISCONTINUITY  = 0x04,   /* Set if start of new segment */
+       AM_SAMPLE_TYPECHANGED        = 0x08,   /* Has the type changed */
+       AM_SAMPLE_TIMEVALID          = 0x10,   /* Set if time is valid */
+       AM_SAMPLE_TIMEDISCONTINUITY  = 0x40,   /* time gap in data starts after
+                                                 this sample - pbBuffer can
+                                                 be NULL
+                                              */
+       AM_SAMPLE_FLUSH_ON_PAUSE     = 0x80,   /*  For live data - discard
+                                                  in paused state
+                                              */
+       AM_SAMPLE_STOPVALID          = 0x100,  /*  Stop time is valid */
+       AM_SAMPLE_ENDOFSTREAM        = 0x200,  /*  End of stream after
+                                                  this data
+                                                  This is reserved for
+                                                  kernel streaming and is
+                                                  not currently used by
+                                                  ActiveMovie
+                                              */
+       AM_STREAM_MEDIA              = 0,      /*  Normal data stream id */
+       AM_STREAM_CONTROL            = 1       /*  Control stream id */
+                                              /*  > 7FFFFFFF is application
+                                                  defined stream
+                                              */
+     };
+
+//  Media sample generic properties structure
+typedef struct tagAM_SAMPLE2_PROPERTIES {
+    DWORD    cbData;         //  Length of generic data for extensiblity
+                             //  Number of bytes INCLUDING this field
+    DWORD    dwTypeSpecificFlags; // Type specific flag data
+    DWORD    dwSampleFlags;  //  Flags bits defined by  AM_SAMPLE_xxx flags
+                             //  All undefined bits RESERVED (set to 0,
+                             //  leave on copy)
+    LONG     lActual;        //  Length of data in buffer
+    REFERENCE_TIME tStart;   //  Start time if valid
+    REFERENCE_TIME tStop;    //  Stop time if valid
+    DWORD    dwStreamId;     //  Stream 0 is normal media transport
+                             //  Stream 1 is control
+    AM_MEDIA_TYPE *pMediaType; // Copy of media type - INVALID after Release()
+    BYTE    *pbBuffer;       //  Pointer to buffer - INVALID after Release()
+    LONG     cbBuffer;       //  Length of buffer
+} AM_SAMPLE2_PROPERTIES;
+
+//=====================================================================
+//=====================================================================
+// Defines IMediaSample2 interface
+//=====================================================================
+//=====================================================================
+
+[
+        local,
+        object,
+        uuid(36b73884-c2c8-11cf-8b46-00805f6cef60),
+        pointer_default(unique)
+]
+interface IMediaSample2 : IMediaSample {
+
+    //  Get sample properties
+    //
+    //      cbProperties - length of generic data to retrieve
+    //      pbProperties - pointer to generic data buffer - can
+    //                     be NULL if cbProperties is NULL
+    //                     data conforms to AM_SAMPLE_PROPERTIES
+    //
+    HRESULT GetProperties(
+        [in] DWORD cbProperties,
+        [out, size_is(cbProperties)] BYTE * pbProperties
+    );
+    //  Set sample properties
+    //
+    //      cbProperties - length of generic data to set
+    //      pbProperties - pointer to generic data buffer - can
+    //                      be NULL if cbProperties is NULL
+    //                      data conforms to AM_SAMPLE_PROPERTIES
+    //
+    //
+    HRESULT SetProperties(
+        [in] DWORD cbProperties,
+        [in, size_is(cbProperties)] const BYTE * pbProperties
+    );
+
+
+    // //  Get the clock associated with the sample
+    // HRESULT GetClock(
+    //     [out] IReferenceClock2 **ppClock
+    // );
+
+    // //  Get a pointer to the object containing the data
+    // //
+    // //  riid      - IID of interface required on object
+    // //  ppvobject - Pointer to object containing the data
+    // //
+    // //  Returns
+    // //      S_OK - Got the object
+    // //      E_NOINTERFACE - object does not support this interface
+    // //                      if IUnknown is not supported
+    // //                      there is no backing object
+    // //      E_NOTIMPL     - samples don't have backing objects
+    // //
+    // //
+    // HRESULT GetBackingObject(
+    //     [in]  REFIID riid,
+    //     [out] void **ppvObject
+    // );
+}
+
+typedef IMediaSample2 *PMEDIASAMPLE2;
+
+
+// flags for dwFlags in IMemAllocator::GetBuffer
+// AM_GBF_PREVFRAMESKIPPED is only significant when asking for a buffer from the
+// video renderer.  It should be TRUE if and only if the previous frame
+// was skipped.  It affects quality management.
+// AM_GBF_NOTASYNCPOINT indicates to the downstream filter (most likely the
+// video renderer) that you are not going to fill this buffer with a sync point
+// (keyframe) so now would be a bad time to return a buffer with a dynamic
+// format change, because you will be unable to switch to the new format without
+// waiting for the next sync point, causing some frames to be dropped.
+#define AM_GBF_PREVFRAMESKIPPED 1
+#define AM_GBF_NOTASYNCPOINT    2
+cpp_quote("#define AM_GBF_PREVFRAMESKIPPED 1")
+cpp_quote("#define AM_GBF_NOTASYNCPOINT 2")
+
+// This may not be supported by allocators
+cpp_quote("#define AM_GBF_NOWAIT 4")
+
+// This flag is supported by the VMR's surface allocator
+// When set the DDraw surface used for the media sample
+// is returned is an un-locked state.  Calls the GetPointer on
+// the returned media sample will fail and return a NULL pointer
+//
+cpp_quote("#define AM_GBF_NODDSURFACELOCK 8")
+
+//=====================================================================
+//=====================================================================
+// Defines IMemAllocator interface
+//
+// an allocator of IMediaSample blocks to be used for data transfer between
+// pins. Can be provided by input, output or a third party. Release
+// the IMediaSample object obtained back to the pool by calling
+// IMediaSample::Release.
+//=====================================================================
+//=====================================================================
+
+[
+        object,
+        uuid(56a8689c-0ad4-11ce-b03a-0020af0ba770),
+        pointer_default(unique)
+]
+interface IMemAllocator : IUnknown {
+
+    // negotiate buffer sizes, buffer count and alignment. pRequest is filled
+    // in by the caller with the requested values. pActual will be returned
+    // by the allocator with the closest that the allocator can come to this.
+    // Cannot be called unless the allocator is decommitted.
+    // Calls to GetBuffer need not succeed until Commit is called.
+    HRESULT SetProperties(
+        [in] ALLOCATOR_PROPERTIES* pRequest,
+        [out] ALLOCATOR_PROPERTIES* pActual);
+
+    // return the properties actually being used on this allocator
+    HRESULT GetProperties(
+        [out] ALLOCATOR_PROPERTIES* pProps);
+
+
+    // commit the memory for the agreed buffers
+    HRESULT Commit(void);
+
+    // release the memory for the agreed buffers. Any threads waiting in
+    // GetBuffer will return with an error. GetBuffer calls will always fail
+    // if called before Commit or after Decommit.
+    HRESULT Decommit(void);
+
+    // get container for a sample. Blocking, synchronous call to get the
+    // next free buffer (as represented by an IMediaSample interface).
+    // on return, the time etc properties will be invalid, but the buffer
+    // pointer and size will be correct.
+    // Will only succeed if memory is committed. If GetBuffer is blocked
+    // waiting for a buffer and Decommit is called on another thread,
+    // GetBuffer will return with an error.
+    HRESULT GetBuffer(
+        [out] IMediaSample **ppBuffer,
+        [in] REFERENCE_TIME * pStartTime,
+        [in] REFERENCE_TIME * pEndTime,
+        [in] DWORD dwFlags
+    );
+
+    // put a buffer back on the allocators free list.
+    // this is typically called by the Release() method of the media
+    // sample when the reference count goes to 0
+    //
+    HRESULT ReleaseBuffer(
+        [in] IMediaSample *pBuffer
+    );
+}
+
+typedef IMemAllocator *PMEMALLOCATOR;
+
+//=====================================================================
+//=====================================================================
+// Defines IMemAllocatorCallbackTemp interface
+//
+// If the allocator supports IMemAllocator2 then callbacks are
+// available
+//
+//=====================================================================
+//=====================================================================
+[
+        object,
+        uuid(379a0cf0-c1de-11d2-abf5-00a0c905f375),
+        pointer_default(unique)
+]
+interface IMemAllocatorCallbackTemp : IMemAllocator {
+
+    //  Set notification interface.  pNotify can be NULL
+    HRESULT SetNotify(
+        [in] IMemAllocatorNotifyCallbackTemp *pNotify);
+
+    //  Get current stats
+    HRESULT GetFreeCount(
+        [out] LONG *plBuffersFree);
+}
+
+//=====================================================================
+//=====================================================================
+// Defines IMemAllocatorNotify interface
+//
+//=====================================================================
+//=====================================================================
+[
+        object,
+        uuid(92980b30-c1de-11d2-abf5-00a0c905f375),
+        pointer_default(unique)
+]
+interface IMemAllocatorNotifyCallbackTemp : IUnknown {
+
+    //  Called whenever ReleaseBuffer is called in the allocator
+    //  Note the caller may have acquired locks and this call may
+    //  occur in any context so generally the implementor of this
+    //  call will just set an event or post a message for another
+    //  thread to take action.
+    HRESULT NotifyRelease();
+}
+
+//=====================================================================
+//=====================================================================
+// Defines IMemInputPin interface
+//
+// basic shared memory transport interface.
+//=====================================================================
+//=====================================================================
+
+[
+        object,
+        uuid(56a8689d-0ad4-11ce-b03a-0020af0ba770),
+        pointer_default(unique)
+]
+interface IMemInputPin : IUnknown {
+
+    // return the allocator interface that this input pin
+    // would like the output pin to use
+    HRESULT GetAllocator(
+                [out] IMemAllocator ** ppAllocator);
+
+    // tell the input pin which allocator the output pin is actually
+    // going to use.
+    // If the readonly flag is set, then all samples from this allocator are
+    // to be treated as read-only, and should be copied before being modified.
+    HRESULT NotifyAllocator(
+                [in] IMemAllocator * pAllocator,
+                [in] BOOL bReadOnly
+                );
+
+    // this method is optional (can return E_NOTIMPL). Output pins are not obliged to call
+    // this method, nor are they obliged to fulfil the request. Input pins making such a
+    // request should check the allocator in NotifyAllocator to see if it meets their needs. If
+    // not, the input pin is responsible for any necessary data copy.
+    // Zero values will be treated as don't care: so a pin can return an alignment value
+    // and leave the other values 0.
+    HRESULT GetAllocatorRequirements( [out] ALLOCATOR_PROPERTIES*pProps);
+
+    // here's the next block of data from the stream. AddRef it if
+    // you need to hold it beyond the end of the Receive call.
+    // call pSample->Release when done with it.
+    //
+    // This is a blocking synchronous call.  Usually no blocking
+    // will occur but if a filter cannot process the sample immediately
+    // it may use the caller's thread to wait until it can.
+    HRESULT Receive(
+                [in] IMediaSample * pSample);
+
+    // Same as Receive but with multiple samples.  Useful for
+    // fragmented streams
+    HRESULT ReceiveMultiple(
+                [in, size_is(nSamples)] IMediaSample **pSamples,
+                [in] long nSamples,
+                [out] long *nSamplesProcessed);
+
+    // See if Receive might block
+    // Returns S_OK if it can block, S_FALSE if it can't or some
+    // failure code (assume it can in this case)
+    HRESULT ReceiveCanBlock();
+}
+
+typedef IMemInputPin *PMEMINPUTPIN;
+
+
+//=====================================================================
+//=====================================================================
+// Defines IAMovieSetup interface
+//
+// exported by filter to allow it to be self-registering
+//=====================================================================
+//=====================================================================
+
+[
+object,
+uuid(a3d8cec0-7e5a-11cf-bbc5-00805f6cef20),
+pointer_default(unique)
+]
+interface IAMovieSetup : IUnknown {
+
+    // methods to register and unregister filter, etc.
+
+    HRESULT Register( );
+    HRESULT Unregister( );
+}
+
+typedef IAMovieSetup *PAMOVIESETUP;
+
+
+//=====================================================================
+//=====================================================================
+// Defines IMediaSeeking interface
+//
+// Controls seeking (time, bytes, frames, fields and samples)
+//=====================================================================
+//=====================================================================
+
+typedef enum AM_SEEKING_SeekingFlags
+{
+    AM_SEEKING_NoPositioning        = 0x00,     // No change
+    AM_SEEKING_AbsolutePositioning  = 0x01,     // Position is supplied and is absolute
+    AM_SEEKING_RelativePositioning  = 0x02,     // Position is supplied and is relative
+    AM_SEEKING_IncrementalPositioning   = 0x03, // (Stop) position relative to current
+                                                // Useful for seeking when paused (use +1)
+    AM_SEEKING_PositioningBitsMask  = 0x03,     // Useful mask
+    AM_SEEKING_SeekToKeyFrame       = 0x04,     // Just seek to key frame (performance gain)
+    AM_SEEKING_ReturnTime           = 0x08,     // Plug the media time equivalents back into the supplied LONGLONGs
+
+    AM_SEEKING_Segment              = 0x10,     // At end just do EC_ENDOFSEGMENT,
+                                                // don't do EndOfStream
+    AM_SEEKING_NoFlush              = 0x20      // Don't flush
+} AM_SEEKING_SEEKING_FLAGS;
+
+typedef enum AM_SEEKING_SeekingCapabilities
+{
+    AM_SEEKING_CanSeekAbsolute     = 0x001,
+    AM_SEEKING_CanSeekForwards     = 0x002,
+    AM_SEEKING_CanSeekBackwards    = 0x004,
+    AM_SEEKING_CanGetCurrentPos    = 0x008,
+    AM_SEEKING_CanGetStopPos       = 0x010,
+    AM_SEEKING_CanGetDuration      = 0x020,
+    AM_SEEKING_CanPlayBackwards    = 0x040,
+    AM_SEEKING_CanDoSegments       = 0x080,
+    AM_SEEKING_Source              = 0x100  // Doesn't pass thru used to
+                                            // count segment ends
+} AM_SEEKING_SEEKING_CAPABILITIES;
+
+[
+        object,
+        uuid(36b73880-c2c8-11cf-8b46-00805f6cef60),
+        pointer_default(unique)
+]
+interface IMediaSeeking : IUnknown {
+
+    // Returns the capability flags
+    HRESULT GetCapabilities( [out] DWORD * pCapabilities );
+
+    // And's the capabilities flag with the capabilities requested.
+    // Returns S_OK if all are present, S_FALSE if some are present, E_FAIL if none.
+    // *pCababilities is always updated with the result of the 'and'ing and can be
+    // checked in the case of an S_FALSE return code.
+    HRESULT CheckCapabilities( [in,out] DWORD * pCapabilities );
+
+    // returns S_OK if mode is supported, S_FALSE otherwise
+    HRESULT IsFormatSupported([in] const GUID * pFormat);
+    HRESULT QueryPreferredFormat([out] GUID * pFormat);
+
+    HRESULT GetTimeFormat([out] GUID *pFormat);
+    // Returns S_OK if *pFormat is the current time format, otherwise S_FALSE
+    // This may be used instead of the above and will save the copying of the GUID
+    HRESULT IsUsingTimeFormat([in] const GUID * pFormat);
+
+    // (may return VFE_E_WRONG_STATE if graph is stopped)
+    HRESULT SetTimeFormat([in] const GUID * pFormat);
+
+    // return current properties
+    HRESULT GetDuration([out] LONGLONG *pDuration);
+    HRESULT GetStopPosition([out] LONGLONG *pStop);
+    HRESULT GetCurrentPosition([out] LONGLONG *pCurrent);
+
+    // Convert time from one format to another.
+    // We must be able to convert between all of the formats that we say we support.
+    // (However, we can use intermediate formats (e.g. MEDIA_TIME).)
+    // If a pointer to a format is null, it implies the currently selected format.
+    HRESULT ConvertTimeFormat([out] LONGLONG * pTarget, [in] const GUID * pTargetFormat,
+                              [in]  LONGLONG    Source, [in] const GUID * pSourceFormat );
+
+
+    // Set current and end positions in one operation
+    // Either pointer may be null, implying no change
+    HRESULT SetPositions( [in,out] LONGLONG * pCurrent, [in] DWORD dwCurrentFlags
+            , [in,out] LONGLONG * pStop, [in] DWORD dwStopFlags );
+
+    // Get CurrentPosition & StopTime
+    // Either pointer may be null, implying not interested
+    HRESULT GetPositions( [out] LONGLONG * pCurrent,
+                          [out] LONGLONG * pStop );
+
+    // Get earliest / latest times to which we can currently seek "efficiently".
+    // This method is intended to help with graphs where the source filter has
+    // a very high latency.  Seeking within the returned limits should just
+    // result in a re-pushing of already cached data.  Seeking beyond these
+    // limits may result in extended delays while the data is fetched (e.g.
+    // across a slow network).
+    // (NULL pointer is OK, means caller isn't interested.)
+    HRESULT GetAvailable( [out] LONGLONG * pEarliest, [out] LONGLONG * pLatest );
+
+    // Rate stuff
+    HRESULT SetRate([in]  double dRate);
+    HRESULT GetRate([out] double * pdRate);
+
+    // Preroll
+    HRESULT GetPreroll([out] LONGLONG * pllPreroll);
+}
+
+typedef IMediaSeeking *PMEDIASEEKING;
+
+//  Flags for IMediaEventEx
+cpp_quote("enum tagAM_MEDIAEVENT_FLAGS")
+cpp_quote("{")
+cpp_quote("    AM_MEDIAEVENT_NONOTIFY = 0x01")
+cpp_quote("};")