|
|
//------------------------------------------------------------------------------// File: AXCore.idl//// Desc: Core streaming interfaces. Other ActiveMovie-only interfaces// are in AXExtend.idl.//// Copyright (c) 1992 - 2000, 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} + nullcpp_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 is 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 recognise 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 pintypedef enum _PinDirection { PINDIR_INPUT, PINDIR_OUTPUT} PIN_DIRECTION;
// other types that need defining#define MAX_PIN_NAME 128cpp_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_PROPERTIESenum 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 structuretypedef 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 2cpp_quote("#define AM_GBF_PREVFRAMESKIPPED 1")cpp_quote("#define AM_GBF_NOTASYNCPOINT 2")
// This may not be supported by allocatorscpp_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 IMediaEventExcpp_quote("enum tagAM_MEDIAEVENT_FLAGS")cpp_quote("{")cpp_quote(" AM_MEDIAEVENT_NONOTIFY = 0x01")cpp_quote("};")
|
