From b1f9e28cd155459ab2843690c248ed9f4767bc3f Mon Sep 17 00:00:00 2001 From: Fire-Head Date: Sun, 2 Jun 2019 06:00:38 +0300 Subject: skeleton updated, windows specific stuff added --- dxsdk/Include/DShowIDL/axcore.idl | 1284 +++++++++++++++++++++++++++++++++++++ 1 file changed, 1284 insertions(+) create mode 100644 dxsdk/Include/DShowIDL/axcore.idl (limited to 'dxsdk/Include/DShowIDL/axcore.idl') diff --git a/dxsdk/Include/DShowIDL/axcore.idl b/dxsdk/Include/DShowIDL/axcore.idl new file mode 100644 index 00000000..4aceea78 --- /dev/null +++ b/dxsdk/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("};") -- cgit v1.2.3