UMSKT
/
xpmgr
mirror of https://github.com/UMSKT/xpmgr.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
xpmgr/BuildTools/Include/mfreadwrite.idl

918 lines
36 KiB
Plaintext
Raw Blame History

//*@@@+++@@@@******************************************************************
//
// Microsoft Windows Media Foundation
// Copyright (C) Microsoft Corporation. All rights reserved.
//
//*@@@---@@@@******************************************************************
//
import "mfobjects.idl";
cpp_quote("#if (WINVER >= _WIN32_WINNT_WIN7) ")
//////////////////////////////////////////////////////////////////////////////
//
// Class Factory for MF Source Reader and MF Sink Writer
//
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// CLSID_MFReadWriteClassFactory
// Data type: GUID
// CLSID for creating the MFReadWrite Class Factory. This object can be used to create initialized Source Reader and Sink Writer objects.
//
// {48e2ed0f-98c2-4a37-bed5-166312ddd83f}
cpp_quote( "EXTERN_GUID(CLSID_MFReadWriteClassFactory, 0x48e2ed0f, 0x98c2, 0x4a37, 0xbe, 0xd5, 0x16, 0x63, 0x12, 0xdd, 0xd8, 0x3f);" )
[
object,
uuid(E7FE2E12-661C-40DA-92F9-4F002AB67627),
local
]
interface IMFReadWriteClassFactory : IUnknown
{
HRESULT CreateInstanceFromURL(
[in, annotation("__in")] REFCLSID clsid,
[in, annotation("__in")] LPCWSTR pwszURL,
[in, annotation("__in_opt")] IMFAttributes *pAttributes,
[in, annotation("__in")] REFIID riid,
[out, iid_is(riid), annotation("__out")] LPVOID *ppvObject );
HRESULT CreateInstanceFromObject(
[in, annotation("__in")] REFCLSID clsid,
[in, annotation("__in")] IUnknown *punkObject,
[in, annotation("__in_opt")] IMFAttributes *pAttributes,
[in, annotation("__in")] REFIID riid,
[out, iid_is(riid), annotation("__out")] LPVOID *ppvObject );
};
//////////////////////////////////////////////////////////////////////////////
//
// MF Source Reader
//
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// CLSID_MFSourceReader
// Data type: GUID
// CLSID for the MF Source Reader object.
//
// {1777133c-0881-411b-a577-ad545f0714c4}
cpp_quote( "EXTERN_GUID(CLSID_MFSourceReader, 0x1777133c, 0x0881, 0x411b, 0xa5, 0x77, 0xad, 0x54, 0x5f, 0x07, 0x14, 0xc4);" )
/// <summary>
/// This function is used to instantiate an MF Source Reader object for
/// the specified URL.
/// </summary>
/// <param name="pwszURL">
/// URL that specifies the location of the media content to open.
/// </param>
/// <param name="pAttributes">
/// Optional parameter specifying additional Source Reader configuration.
/// See: section below on MF Source Reader Attributes
/// </param>
/// <param name="ppSourceReader">
/// Specifies a pointer to a variable where the source reader object
/// will be stored.
/// </param>
/// <remarks>
/// This function is synchronous and performs I/O that can
/// block the calling thread.
/// </remarks>
cpp_quote( "STDAPI MFCreateSourceReaderFromURL(" )
cpp_quote( " __in LPCWSTR pwszURL," )
cpp_quote( " __in_opt IMFAttributes *pAttributes," )
cpp_quote( " __out IMFSourceReader **ppSourceReader );" )
/// <summary>
/// This function is used to instantiate an MF Source Reader object for
/// the specified bytestream.
/// </summary>
/// <param name="pByteStream">
/// Instance of an IMFByteStream that contains the media content.
/// </param>
/// <param name="pAttributes">
/// Optional parameter specifying additional Source Reader configuration.
/// See: section below on MF Source Reader Attributes
/// </param>
/// <param name="ppSourceReader">
/// Specifies a pointer to a variable where the source reader object
/// will be stored.
/// </param>
/// <remarks>
/// This function is synchronous and performs I/O that can
/// block the calling thread.
/// </remarks>
cpp_quote( "STDAPI MFCreateSourceReaderFromByteStream(" )
cpp_quote( " __in IMFByteStream *pByteStream," )
cpp_quote( " __in_opt IMFAttributes *pAttributes," )
cpp_quote( " __out IMFSourceReader **ppSourceReader );" )
/// <summary>
/// This function is used to instantiate an MF Source Reader object using
/// an existing instance of an MF Media Source.
/// </summary>
/// <param name="pMediaSource">
/// Instance of an IMFMediaSource that will be used to produce samples.
/// </param>
/// <param name="pAttributes">
/// Optional parameter specifying additional Source Reader configuration.
/// See: section below on MF Source Reader Attributes
/// </param>
/// <param name="ppSourceReader">
/// Specifies a pointer to a variable where the source reader object
/// will be stored.
/// </param>
cpp_quote( "STDAPI MFCreateSourceReaderFromMediaSource(" )
cpp_quote( " __in IMFMediaSource *pMediaSource," )
cpp_quote( " __in_opt IMFAttributes *pAttributes," )
cpp_quote( " __out IMFSourceReader **ppSourceReader );" )
//
// MF Source Reader attributes
//
// MF_SOURCE_READER_ASYNC_CALLBACK
// Data type: IUnknown
// This attribute should be set to the IUnknown interface of an
// object that implements the IMFSourceReaderCallback interface.
// If the MF_SOURCE_READER_ASYNC_CALLBACK attribute is set, then the
// Source Reader will operate in asynchronous mode.
// Otherwise, by default, the Source Reader operates synchronously.
cpp_quote( "EXTERN_GUID( MF_SOURCE_READER_ASYNC_CALLBACK, 0x1e3dbeac, 0xbb43, 0x4c35, 0xb5, 0x07, 0xcd, 0x64, 0x44, 0x64, 0xc9, 0x65);" )
// MF_SOURCE_READER_D3D_MANAGER
// Data type: IUnknown
// This attribute enables video sample allocation using D3D9 surfaces,
// and enables hardware acceleration within the Source Reader.
// This should be set to the IUnknown interface of an
// object that implements the IDirect3DDeviceManager9 interface.
cpp_quote( "EXTERN_GUID( MF_SOURCE_READER_D3D_MANAGER, 0xec822da2, 0xe1e9, 0x4b29, 0xa0, 0xd8, 0x56, 0x3c, 0x71, 0x9f, 0x52, 0x69);" )
// MF_SOURCE_READER_DISABLE_DXVA
// Data type: UINT32
// DXVA is enabled by default if the Source Reader is configured with
// a D3D manager. This attribute can be set to TRUE in order to
// disable DXVA, while still allocating video samples using the D3D manager.
cpp_quote( "EXTERN_GUID( MF_SOURCE_READER_DISABLE_DXVA, 0xaa456cfd, 0x3943, 0x4a1e, 0xa7, 0x7d, 0x18, 0x38, 0xc0, 0xea, 0x2e, 0x35);" )
// MF_SOURCE_READER_MEDIASOURCE_CONFIG
// Data type: IUnknown
// The Source Reader uses the MF Source Resolver API to instantiate
// the MF Media Source when passed either a URL or a bytestream.
// The Source Resolver allows an application to pass runtime
// configuration parameters to the Media Source via an IPropertyStore
// interface. The application can use this attribute when creating
// the Source Reader to pass the same IPropertyStore configuration
// down to the underlying Media Source. The attribute should be
// set as the IUnknown interface of an object that implements the
// IPropertyStore interface.
cpp_quote( "EXTERN_GUID( MF_SOURCE_READER_MEDIASOURCE_CONFIG, 0x9085abeb, 0x0354, 0x48f9, 0xab, 0xb5, 0x20, 0x0d, 0xf8, 0x38, 0xc6, 0x8e);" )
// MF_SOURCE_READER_MEDIASOURCE_CHARACTERISTICS
// Data type: UINT32
// The application can query for this attribute using the
// IMFSourceReader::GetPresentationAttribute API in order to
// determine the characteristics of the underlying media source.
// The value returned is a bitwise OR of zero or more flags from
// the MFMEDIASOURCE_CHARACTERISTICS enumeration.
cpp_quote( "EXTERN_GUID( MF_SOURCE_READER_MEDIASOURCE_CHARACTERISTICS, 0x6d23f5c8, 0xc5d7, 0x4a9b, 0x99, 0x71, 0x5d, 0x11, 0xf8, 0xbc, 0xa8, 0x80);" )
// MF_SOURCE_READER_ENABLE_VIDEO_PROCESSING
// Data type: UINT32
// This attribute enables limited video processing on
// video samples within the source reader.
cpp_quote( "EXTERN_GUID( MF_SOURCE_READER_ENABLE_VIDEO_PROCESSING, 0xfb394f3d, 0xccf1, 0x42ee, 0xbb, 0xb3, 0xf9, 0xb8, 0x45, 0xd5, 0x68, 0x1d);" )
// MF_SOURCE_READER_DISCONNECT_MEDIASOURCE_ON_SHUTDOWN
// Data type: UINT32
// By default, if the source reader is passed in an existing media
// source object, then it will also shutdown the media source.
// The application can set this attribute to TRUE in order to have
// the source reader stop the media source and wait for MESourceStopped
// and MEStreamStopped events instead of shutting the media source down.
// After receiving the stop events, the source reader will disconnect from
// the media source's MEG allowing the application to reuse the media source.
cpp_quote( "EXTERN_GUID( MF_SOURCE_READER_DISCONNECT_MEDIASOURCE_ON_SHUTDOWN, 0x56b67165, 0x219e, 0x456d, 0xa2, 0x2e, 0x2d, 0x30, 0x04, 0xc7, 0xfe, 0x56);" )
//
// MF Source Reader Flags
//
/// <summary>
/// The enumeration type defines the various flags that can be returned
/// from the MF Source Reader when retrieving the next sample.
/// </summary>
typedef [v1_enum] enum MF_SOURCE_READER_FLAG
{
/// <summary>
/// Specifies that an error has occurred while processing sample
/// requests. If this is set, then no other calls should be made
/// on the source reader besides shutting it down.
/// </summary>
MF_SOURCE_READERF_ERROR = 0x00000001,
/// <summary>
/// Specifies that the stream has ended.
/// </summary>
MF_SOURCE_READERF_ENDOFSTREAM = 0x00000002,
/// <summary>
/// Specifies that one or more new streams have been created.
/// The application can modify stream selection and configure
/// output media types for the new streams.
/// </summary>
MF_SOURCE_READERF_NEWSTREAM = 0x00000004,
/// <summary>
/// Specifies that the native media type for the stream has changed.
/// </summary>
MF_SOURCE_READERF_NATIVEMEDIATYPECHANGED = 0x00000010,
/// <summary>
/// Specifies that the current media type for the stream has changed.
/// </summary>
MF_SOURCE_READERF_CURRENTMEDIATYPECHANGED = 0x00000020,
/// <summary>
/// Specifies that there is a gap in the stream.
/// </summary>
MF_SOURCE_READERF_STREAMTICK = 0x00000100,
} MF_SOURCE_READER_FLAG;
cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(MF_SOURCE_READER_FLAG)")
/// <summary>
/// The enumeration type defines the various flags that can be passed
/// to the Source Reader's ReadSample method.
/// </summary>
typedef [v1_enum] enum MF_SOURCE_READER_CONTROL_FLAG
{
/// <summary>
/// Specifies that ReadSample should only drain samples from
/// the stream, and not request more samples from the media source.
/// This can be used to ensure all samples are returned for the
/// stream before flushing, changing position, or changing the
/// output media type for the stream.
/// </summary>
MF_SOURCE_READER_CONTROLF_DRAIN = 0x00000001,
} MF_SOURCE_READER_CONTROL_FLAG;
cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(MF_SOURCE_READER_CONTROL_FLAG)")
enum
{
MF_SOURCE_READER_INVALID_STREAM_INDEX = 0xFFFFFFFF,
MF_SOURCE_READER_ALL_STREAMS = 0xFFFFFFFE,
MF_SOURCE_READER_ANY_STREAM = 0xFFFFFFFE,
MF_SOURCE_READER_FIRST_AUDIO_STREAM = 0xFFFFFFFD,
MF_SOURCE_READER_FIRST_VIDEO_STREAM = 0xFFFFFFFC,
MF_SOURCE_READER_MEDIASOURCE = 0xFFFFFFFF,
};
[
object,
uuid(70ae66f2-c809-4e4f-8915-bdcb406b7993),
local
]
/// <summary>
/// The MF Source Reader provides a simple programming model that allows
/// applications to easily access multimedia content from files or
/// devices.
/// </summary>
interface IMFSourceReader : IUnknown
{
/// <summary>
/// Returns whether or not the specified stream is selected.
/// If the specified stream does not exist, the error
/// MF_E_INVALIDSTREAMNUMBER is returned.
/// </summary>
/// <param name="dwStreamIndex">
/// Specifies the stream index to query for selection state.
/// </param>
/// <param name="pfSelected">
/// Specifies a pointer to a variable where the selection state
/// will be stored.
/// </param>
HRESULT GetStreamSelection(
[in, annotation("__in")] DWORD dwStreamIndex,
[out, annotation("__out")] BOOL *pfSelected );
/// <summary>
/// Sets the selection state for the specified stream.
/// MF_SOURCE_READER_ALL_STREAMS can be specified in order
/// to set the stream selection for all available streams.
/// </summary>
/// <param name="dwStreamIndex">
/// Specifies the stream index.
/// </param>
/// <param name="fSelected">
/// Specifies whether or not the stream should be selected.
/// </param>
HRESULT SetStreamSelection(
[in, annotation("__in")] DWORD dwStreamIndex,
[in, annotation("__in")] BOOL fSelected );
/// <summary>
/// Returns the native media type for the specified stream.
/// </summary>
/// <param name="dwStreamIndex">
/// Specifies the stream index.
/// </param>
/// <param name="dwMediaTypeIndex">
/// Specifies the media type index. As some sources support
/// multiple native media types, the index is used to indicate
/// the position in the list of supported media types.
/// </param>
/// <param name="ppMediaType">
/// Receives a copy of the specified native media type.
/// </param>
HRESULT GetNativeMediaType(
[in, annotation("__in")] DWORD dwStreamIndex,
[in, annotation("__in")] DWORD dwMediaTypeIndex,
[out, annotation("__out")] IMFMediaType **ppMediaType );
/// <summary>
/// Returns the media type of the samples currently being
/// output for the specified stream.
/// </summary>
/// <param name="dwStreamIndex">
/// Specifies the stream index.
/// </param>
/// <param name="ppMediaType">
/// Receives a copy of the current media type.
/// </param>
HRESULT GetCurrentMediaType(
[in, annotation("__in")] DWORD dwStreamIndex,
[out, annotation("__out")] IMFMediaType **ppMediaType );
/// <summary>
/// Sets the output media type for samples returned for the specified
/// stream.
/// </summary>
/// <param name="dwStreamIndex">
/// Specifies the stream index.
/// </param>
/// <param name="pdwReserved">
/// Reserved for future use.
/// </param>
/// <param name="pMediaType">
/// Specifies the desired media type for the stream.
/// </param>
/// <remarks>
/// If an appropriate MFT cannot be found to transform the native
/// media type into the desired media type, then an error is
/// returned, and the current media type remains unchanged.
/// </remarks>
HRESULT SetCurrentMediaType(
[in, annotation("__in")] DWORD dwStreamIndex,
[in, out, annotation("__reserved")] DWORD *pdwReserved,
[in, annotation("__in")] IMFMediaType *pMediaType );
/// <summary>
/// Sets the position for where the next sample will be returned.
/// </summary>
/// <param name="guidTimeFormat">
/// Reference to a GUID that specifies the time format.
/// This can be GUID_NULL, in which case the time format
/// is in 100-nanosecond units.
/// </param>
/// <param name="varStartPosition">
/// Specifies the start position. The units for this parameter
/// are indicated by the time format given in guidTimeFormat.
/// </param>
/// <remarks>
/// When reading samples asynchronously, the application may still
/// receive samples from the previous position if they were already
/// queued for delivery before this call was made.
///
/// If the underlying media source is not seekable, then
/// an appropriate error will be returned.
/// </remarks>
HRESULT SetCurrentPosition(
[in, annotation("__in")] REFGUID guidTimeFormat,
[in, annotation("__in")] REFPROPVARIANT varPosition );
/// <summary>
/// Requests the next available sample. The caller can either
/// request a sample from a specific stream, or from any of
/// the selected streams.
/// </summary>
/// <param name="dwStreamIndex">
/// Specifies the stream for which the sample request is being made.
/// MF_SOURCE_READER_ANY_STREAM can be specified in order to request
/// the next sample from any available stream.
/// </param>
/// <param name="dwControlFlags">
/// Specifies flags that control the behavior of ReadSample.
/// See: section above on MF Source Reader Control Flags.
/// </param>
/// <param name="pdwActualStreamIndex">
/// Receives the actual stream index of the media sample.
/// </param>
/// <param name="pdwStreamFlags">
/// Receives the accumulated flags for the stream.
/// See: section above on MF Source Reader Flags
/// </param>
/// <param name="pllTimestamp">
/// Receives the presentation time of the sample.
/// If MF_SOURCE_READERF_STREAM_TICK is set in the stream flags,
/// then this receives the timestamp for the stream tick.
/// </param>
/// <param name="ppSample">
/// Receives the next sample for the stream.
/// </param>
/// <remarks>
/// When operating in synchronous mode, the out parameters
/// are all required parameters.
///
/// When operating in asynchronous mode, the out parameters
/// must all be set to NULL.
///
/// Streams must be selected in order to request samples
/// from them.
///
/// It is possible for ReadSample to return S_OK in synchronous
/// mode while not returning a sample. The caller should always
/// check for NULL before dereferencing the sample. This can
/// happen if EOS is reached, in which case
/// MF_SOURCE_READERF_ENDOFSTREAM will be set for the stream.
/// Another reason is if there is a gap in the stream, in which
/// case MF_SOURCE_READERF_STREAMTICK will be set. For stream
/// ticks, the sample will be NULL, but the timestamp parameter
/// will be set to indicate the position in the stream where the
/// gap occurred.
///
/// </remarks>
HRESULT ReadSample(
[in, annotation("__in")] DWORD dwStreamIndex,
[in, annotation("__in")] DWORD dwControlFlags,
[out, annotation("__out_opt")] DWORD *pdwActualStreamIndex,
[out, annotation("__out_opt")] DWORD *pdwStreamFlags,
[out, annotation("__out_opt")] LONGLONG *pllTimestamp,
[out, annotation("__out_opt")] IMFSample **ppSample );
/// <summary>
/// Releases any queued up samples, and cancels any outstanding sample
/// requests.
/// </summary>
/// <param name="dwStreamIndex">
/// Allows the application to specify which stream to flush.
/// MF_SOURCE_READER_ALL_STREAMS can be specified in order to
/// flush all available streams.
/// </param>
/// <remarks>
/// In async mode, the OnFlush callback is called when the
/// flush operation completes. Before receiving the OnFlush
/// callback, the application should not request any more
/// samples from the source reader. Doing so will result in
/// the MF_E_NOTACCEPTING error being returned.
/// </remarks>
HRESULT Flush(
[in, annotation("__in")] DWORD dwStreamIndex );
/// <summary>
/// Allows the application to query for services and interfaces
/// that are implemented by decoder MFTs for the specified stream.
/// </summary>
/// <param name="dwStreamIndex">
/// Specifies the stream index.
/// MF_SOURCE_READER_MEDIASOURCE can be specified in order to get
/// the service off of the media source instead of a particular stream.
/// </param>
/// <param name="guidService">
/// Specifies the service GUID.
/// GUID_NULL can be passed in, in which case the Source Reader
/// will attempt to directly query for the interface from the MFT.
/// </param>
/// <param name="riid">
/// Specifies the interface ID.
/// </param>
/// <param name="ppvObject">
/// Receives the interface pointer.
/// </param>
HRESULT GetServiceForStream(
[in, annotation("__in")] DWORD dwStreamIndex,
[in, annotation("__in")] REFGUID guidService,
[in, annotation("__in")] REFIID riid,
[out, annotation("__out")] LPVOID *ppvObject );
/// <summary>
/// Allows the application to get attributes from either the
/// media source or from a specific stream.
/// </summary>
/// <param name="dwStreamIndex">
/// Specifies the stream index.
/// MF_SOURCE_READER_MEDIASOURCE can be specified in order to get the
/// attribute from the media source instead of a particular stream.
/// </param>
/// <param name="guidAttribute">
/// Specifies the attribute ID.
/// </param>
/// <param name="pvarAttribute">
/// Receives the attribute value as a PROPVARIANT.
/// </param>
HRESULT GetPresentationAttribute(
[in, annotation("__in")] DWORD dwStreamIndex,
[in, annotation("__in")] REFGUID guidAttribute,
[out, annotation("__out")] PROPVARIANT *pvarAttribute );
};
[
object,
uuid(deec8d99-fa1d-4d82-84c2-2c8969944867),
local
]
/// <summary>
/// This interface is used as the callback mechanism for when the
/// MF Source Reader is used in asynchronous mode. The application
/// passes in an instance of an object that implements this
/// callback interface as an attribute when creating the source
/// reader instance.
/// </summary>
interface IMFSourceReaderCallback : IUnknown
{
/// <summary>
/// Callback function that completes an asynchronous request for the
/// next available sample.
/// </summary>
/// <param name="hrStatus">
/// Specifies the error code if an error occurred while processing
/// the sample request.
/// </param>
/// <param name="dwStreamIndex">
/// Specifies the stream index for the sample.
/// </param>
/// <param name="dwStreamFlags">
/// Specifies the accumulated flags for the stream.
/// See: section above on MF Source Reader Flags
/// </param>
/// <param name="llTimestamp">
/// Contains the presentation time of the sample.
/// If MF_SOURCE_READERF_STREAM_TICK is set for the stream flags,
/// then this contains the timestamp for the stream tick.
/// </param>
/// <param name="pSample">
/// Contains the next sample for the stream. It is possible for
/// this parameter to be NULL, so the application should
/// explicitly check for NULL before dereferencing the sample.
/// </param>
HRESULT OnReadSample(
[in, annotation("__in")] HRESULT hrStatus,
[in, annotation("__in")] DWORD dwStreamIndex,
[in, annotation("__in")] DWORD dwStreamFlags,
[in, annotation("__in")] LONGLONG llTimestamp,
[in, annotation("__in_opt")] IMFSample *pSample );
/// <summary>
/// Callback function that completes an asynchronous request to
/// flush a particular stream or all the streams.
/// </summary>
/// <param name="dwStreamIndex">
/// Specifies the stream index that was flushed or MF_SOURCE_READER_ALL_STREAMS
/// </param>
HRESULT OnFlush(
[in, annotation("__in")] DWORD dwStreamIndex );
/// <summary>
/// Callback function that notifies the application when
/// certain events occur.
/// </summary>
/// <param name="dwStreamIndex">
/// Specifies the stream index associated with the event.
/// For events from the media source, this will be set to
/// MF_SOURCE_READER_MEDIASOURCE.
/// </param>
/// <param name="pEvent">
/// Contains the event object.
/// </param>
HRESULT OnEvent(
[in, annotation("__in")] DWORD dwStreamIndex,
[in, annotation("__in")] IMFMediaEvent *pEvent );
};
//////////////////////////////////////////////////////////////////////////////
//
// MF Sink Writer
//
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// CLSID_MFSinkWriter
// Data type: GUID
// CLSID for the MF Sink Writer object.
//
// {a3bbfb17-8273-4e52-9e0e-9739dc887990}
cpp_quote( "EXTERN_GUID(CLSID_MFSinkWriter, 0xa3bbfb17, 0x8273, 0x4e52, 0x9e, 0x0e, 0x97, 0x39, 0xdc, 0x88, 0x79, 0x90);" )
//
// Creates the Sink Writer by specifying the output URL to generate.
// A suitable media archive sink is instantiated using the file extension
// of the URL. The application can directly indicate which archive media
// sink to instantiate by setting the MF_TRANSCODE_CONTAINERTYPE attribute
// to one of the supported values.
//
// - pwszOutputURL specifies the URL of the content to generate.
// If a bytestream is passed in and the container type attribute is set,
// then the URL can be NULL, otherwise it is a required parameter.
// - pByteStream can optionally specify a bytestream that has already been
// opened for write access to the specified URL. If this is NULL
// then the Sink Writer will create its own bytestream. Passing in a
// bytestream can be useful for things like creating the bytestream
// with admin privileges and then dropping down to an account with
// lower privileges while encoding and writing to the bytestream.
// - pAttributes specifies container or media sink encoding parameters.
// - ppSinkWriter receives an instance of the MF Sink Writer
//
cpp_quote( "STDAPI MFCreateSinkWriterFromURL(" )
cpp_quote( " __in_opt LPCWSTR pwszOutputURL," )
cpp_quote( " __in_opt IMFByteStream *pByteStream," )
cpp_quote( " __in_opt IMFAttributes *pAttributes," )
cpp_quote( " __out IMFSinkWriter **ppSinkWriter );" )
//
// Creates the Sink Writer using an existing instance of an MF Media Sink.
//
// - pMediaSink specifies the MF Media Sink.
// - pAttributes specifies container or media sink encoding parameters.
// - ppSinkWriter receives an instance of the MF Sink Writer
//
cpp_quote( "STDAPI MFCreateSinkWriterFromMediaSink(" )
cpp_quote( " __in IMFMediaSink *pMediaSink," )
cpp_quote( " __in_opt IMFAttributes *pAttributes," )
cpp_quote( " __out IMFSinkWriter **ppSinkWriter );" )
//
// MF Sink Writer attributes
//
// MF_SINK_WRITER_ASYNC_CALLBACK
// Data type: IUnknown
// If the MF_SINK_WRITER_ASYNC_CALLBACK attribute is set, then the
// Sink Writer will not block during the call to Finalize(), but instead
// will trigger a callback when the operation completes.
// This attribute should be set to the IUnknown interface of an
// object that implements the IMFSinkWriterCallback interface.
cpp_quote( "EXTERN_GUID( MF_SINK_WRITER_ASYNC_CALLBACK, 0x48cb183e, 0x7b0b, 0x46f4, 0x82, 0x2e, 0x5e, 0x1d, 0x2d, 0xda, 0x43, 0x54);" )
// MF_SINK_WRITER_DISABLE_THROTTLING
// Data type: UINT32
// This attribute can be set when instantiating the Sink Writer
// in order to prevent the Sink Writer from throttling calls to
// IMFSinkWriter::WriteSample.
cpp_quote( "EXTERN_GUID( MF_SINK_WRITER_DISABLE_THROTTLING, 0x08b845d8, 0x2b74, 0x4afe, 0x9d, 0x53, 0xbe, 0x16, 0xd2, 0xd5, 0xae, 0x4f);" )
enum
{
MF_SINK_WRITER_INVALID_STREAM_INDEX = 0xFFFFFFFF,
MF_SINK_WRITER_ALL_STREAMS = 0xFFFFFFFE,
MF_SINK_WRITER_MEDIASINK = 0xFFFFFFFF,
};
//
// MF Sink Writer Statistics
//
//
// Structure that contains various statistics about the performance
// of the Sink Writer
//
typedef struct _MF_SINK_WRITER_STATISTICS
{
//
// Set to the size of the structure. Used so that future releases
// can support additional statistics without having to rev the interface.
//
DWORD cb;
LONGLONG llLastTimestampReceived;
LONGLONG llLastTimestampEncoded;
LONGLONG llLastTimestampProcessed;
LONGLONG llLastStreamTickReceived;
LONGLONG llLastSinkSampleRequest;
QWORD qwNumSamplesReceived;
QWORD qwNumSamplesEncoded;
QWORD qwNumSamplesProcessed;
QWORD qwNumStreamTicksReceived;
DWORD dwByteCountQueued;
QWORD qwByteCountProcessed;
DWORD dwNumOutstandingSinkSampleRequests;
DWORD dwAverageSampleRateReceived;
DWORD dwAverageSampleRateEncoded;
DWORD dwAverageSampleRateProcessed;
} MF_SINK_WRITER_STATISTICS;
//
// MF Sink Writer Interface
//
[
object,
uuid(3137f1cd-fe5e-4805-a5d8-fb477448cb3d),
local
]
interface IMFSinkWriter : IUnknown
{
//
// Adds a stream to the writer.
// - pTargetMediaType specifies the target format of the media samples
// for the stream. This is the format of the samples as they will
// be written out to the storage medium.
// - pdwStreamIndex receives the stream index associated with the
// new stream.
//
HRESULT AddStream(
[in, annotation("__in")] IMFMediaType *pTargetMediaType,
[out, annotation("__out")] DWORD *pdwStreamIndex );
//
// Specifies the format of the media samples that will be passed to the
// Sink Writer for a particular stream if different from the target
// format. This method is used to identify the encoder to be used
// for the stream.
//
// - dwStreamIndex specifies the index of the stream to configure.
// - pInputMediaType specifies the format of the media samples that
// will be passed to the Sink Writer for this stream.
// - pEncodingParameters is used to specify additional attributes used
// to configure the encoder.
//
// Note: This can called at any time to dynamically change the format
// of the input samples for the stream. Since a format change
// is queued on the stream, and may fail during processing, calling
// SetInputMediaType will immediately test the MFT to see if the new
// type is supported, and only then will it queue the format change.
//
HRESULT SetInputMediaType(
[in, annotation("__in")] DWORD dwStreamIndex,
[in, annotation("__in")] IMFMediaType *pInputMediaType,
[in, annotation("__in_opt")] IMFAttributes *pEncodingParameters );
//
// Called after all streams are configured, but before
// writing out any samples.
//
HRESULT BeginWriting( void );
//
// Called to pass in a new sample to the writer.
//
// Note: By default calls to WriteSample may block for a period of time
// to throttle the rate at which samples are processed. The
// application can disable this throttling by configuring the writer
// with the MF_SINK_WRITER_DISABLE_THROTTLING attribute.
//
HRESULT WriteSample(
[in, annotation("__in")] DWORD dwStreamIndex,
[in, annotation("__in")] IMFSample *pSample );
//
// Called to notify that there is a gap in the stream.
//
HRESULT SendStreamTick(
[in, annotation("__in")] DWORD dwStreamIndex,
[in, annotation("__in")] LONGLONG llTimestamp );
//
// Called to request a callback after the Sink Writer has processed
// all samples in the specified stream.
//
// - dwStreamIndex specifies the stream to request a callback for.
// - pvContext will be passed back to the application when the
// callback is triggered.
//
// Note: In order for PlaceMarker to work, the application must
// configure the Sink Writer with the async callback interface
// IMFSinkWriterCallback.
//
HRESULT PlaceMarker(
[in, annotation("__in")] DWORD dwStreamIndex,
[in, annotation("__in")] LPVOID pvContext );
//
// Called to notify that the stream has reached the end of a segment.
//
// - dwStreamIndex can either specify a single stream or can be set to
// MF_SINK_WRITER_ALL_STREAMS
//
HRESULT NotifyEndOfSegment(
[in, annotation("__in")] DWORD dwStreamIndex );
//
// Called to flush all samples that are queued to be encoded
// or have not yet been sent to the sink.
//
// - dwStreamIndex can either specify a single stream or can be set to
// MF_SINK_WRITER_ALL_STREAMS to flush all stream.
//
HRESULT Flush(
[in, annotation("__in")] DWORD dwStreamIndex );
//
// Called after all samples have been passed to the writer.
//
// Note: By default, this call will block until the content generation
// has completed, which may take some time.
// The app can choose to make Finalize() return immediately and
// trigger a callback when the operation completes by configuring
// the Sink Writer with an IMFSinkWriterCallback interface set on
// the attribute store during Sink Writer creation.
//
HRESULT Finalize( void );
//
// Allows access to a service or interface from the encoder MFTs
// or the media sink.
//
// - dwStreamIndex specifies which stream to query for the
// service/interface. MF_SINK_WRITER_MEDIASINK can be specified
// instead to get the service/interface from the media sink.
// - guidService specifies the service identifier. This can be set to
// GUID_NULL in order to query directory for a specific interface
// instead of a service.
// - riid specifies the interface identifer to query for.
// - ppvObject receives the requested interface.
//
HRESULT GetServiceForStream(
[in, annotation("__in")] DWORD dwStreamIndex,
[in, annotation("__in")] REFGUID guidService,
[in, annotation("__in")] REFIID riid,
[out, annotation("__out")] LPVOID *ppvObject );
//
// Returns various statistics about the performance of the sink writer.
//
// - dwStreamIndex can either specify a single stream or can be set to
// MF_SINK_WRITER_ALL_STREAMS to return aggregated statistics for all
// streams.
// - pStats receives the statistics.
//
HRESULT GetStatistics(
[in, annotation("__in")] DWORD dwStreamIndex,
[out, annotation("__out")] MF_SINK_WRITER_STATISTICS *pStats );
};
//
// This interface is used as the callback mechanism for when the
// MF Sink Writer is configured to finalize content generation
// asynchronously.
//
[
object,
uuid(666f76de-33d2-41b9-a458-29ed0a972c58),
local
]
interface IMFSinkWriterCallback : IUnknown
{
//
// Callback function that completes the asynchronous Finalize()
// operation.
//
// - hrStatus specifies the result of the Finalize() operation.
//
HRESULT OnFinalize(
[in, annotation("__in")] HRESULT hrStatus );
//
// Callback function that is triggered after all samples have been
// processed for a specific stream and the application had requested
// a callback using the IMFSinkWriter::PlaceMarker method.
//
// - dwStreamIndex specifies the stream that had the marker
// place on it.
// - pvContext passes back an application specified context value.
//
HRESULT OnMarker(
[in, annotation("__in")] DWORD dwStreamIndex,
[in, annotation("__in")] LPVOID pvContext );
};
//
// MF Read/Write common attributes
//
// MF_READWRITE_DISABLE_CONVERTERS
// Data type: UINT32
// This attribute can be used to ensure that the Source Reader
// or Sink Writer does not perform additional conversion on
// the multimedia data besides a single decode or encode operation.
cpp_quote( "EXTERN_GUID( MF_READWRITE_DISABLE_CONVERTERS, 0x98d5b065, 0x1374, 0x4847, 0x8d, 0x5d, 0x31, 0x52, 0x0f, 0xee, 0x71, 0x56);" )
// MF_READWRITE_ENABLE_HARDWARE_TRANSFORMS
// Data type: UINT32
// By default, the Source Reader and Sink Writer will not
// use hardware decoders or encoders. This attribute can
// be set to TRUE to enable hardware transforms.
cpp_quote( "EXTERN_GUID( MF_READWRITE_ENABLE_HARDWARE_TRANSFORMS, 0xa634a91c, 0x822b, 0x41b9, 0xa4, 0x94, 0x4d, 0xe4, 0x64, 0x36, 0x12, 0xb0);" )
cpp_quote("#endif // (WINVER >= _WIN32_WINNT_WIN7) ")
Reference in New Issue View Git Blame Copy Permalink