481 lines
15 KiB
Text
481 lines
15 KiB
Text
//------------------------------------------------------------------------------
|
|
// File: MFTransform.idl
|
|
//
|
|
// Desc: Define the interfaces for Media Foundation Transforms. This file will be
|
|
// processed by the MIDL tool to produce MFTransform.h and proxy-stub code.
|
|
//
|
|
// Copyright (c) 1999 - 2003, Microsoft Corporation. All rights reserved.
|
|
//------------------------------------------------------------------------------
|
|
|
|
import "mfobjects.idl";
|
|
|
|
// Per-buffer flags that apply to input buffers
|
|
enum _MFT_INPUT_DATA_BUFFER_FLAGS {
|
|
//
|
|
// Not carried over from DMO (IMediaObject), but should be
|
|
// reserved so no new MFT flag clashes with them:
|
|
//
|
|
// DMO_INPUT_DATA_BUFFER_SYNCPOINT = 0x00000001,
|
|
// DMO_INPUT_DATA_BUFFER_TIME = 0x00000002,
|
|
// DMO_INPUT_DATA_BUFFER_TIMELENGTH = 0x00000004
|
|
|
|
MFT_INPUT_DATA_BUFFER_PLACEHOLDER = 0xFFFFFFFF // right now there are no flags defined
|
|
};
|
|
|
|
// Per-buffer flags that apply to output buffers.
|
|
enum _MFT_OUTPUT_DATA_BUFFER_FLAGS {
|
|
//
|
|
// Not carried over from DMO (IMediaObject), but should be
|
|
// reserved so no new MFT flag clashes with them:
|
|
//
|
|
// DMO_OUTPUT_DATA_BUFFER_SYNCPOINT = 0x00000001,
|
|
// DMO_OUTPUT_DATA_BUFFER_TIME = 0x00000002,
|
|
// DMO_OUTPUT_DATA_BUFFER_TIMELENGTH = 0x00000004,
|
|
|
|
//
|
|
// This flag means the object can produce more samples without any more input.
|
|
//
|
|
MFT_OUTPUT_DATA_BUFFER_INCOMPLETE = 0x01000000,
|
|
|
|
//
|
|
// New for MFT
|
|
//
|
|
MFT_OUTPUT_DATA_BUFFER_FORMAT_CHANGE = 0x00000100,
|
|
MFT_OUTPUT_DATA_BUFFER_STREAM_END = 0x00000200,
|
|
MFT_OUTPUT_DATA_BUFFER_NO_SAMPLE = 0x00000300
|
|
|
|
};
|
|
|
|
// Flags returned by GetInputStatusFlags()
|
|
enum _MFT_INPUT_STATUS_FLAGS {
|
|
//
|
|
// Carried over from DMO (IMediaObject)
|
|
//
|
|
|
|
//
|
|
// ACCEPT_DATA indicates that the input stream is ready to accept
|
|
// new data via ProcessInput().
|
|
//
|
|
MFT_INPUT_STATUS_ACCEPT_DATA = 0x00000001
|
|
};
|
|
|
|
// Flags returned by GetOutputStatusFlags()
|
|
enum _MFT_OUTPUT_STATUS_FLAGS {
|
|
//
|
|
// New for MFT
|
|
//
|
|
|
|
//
|
|
// SAMPLE_READY indicates that a sample is available on at least one
|
|
// of the output streams, and a call to ProcessOutput will
|
|
// retrieve it.
|
|
//
|
|
MFT_OUTPUT_STATUS_SAMPLE_READY = 0x00000001
|
|
};
|
|
|
|
// Flags returned by GetInputStreamInfo()
|
|
enum _MFT_INPUT_STREAM_INFO_FLAGS {
|
|
//
|
|
// Carried over from DMO (IMediaObject)
|
|
//
|
|
MFT_INPUT_STREAM_WHOLE_SAMPLES = 0x00000001,
|
|
MFT_INPUT_STREAM_SINGLE_SAMPLE_PER_BUFFER = 0x00000002,
|
|
MFT_INPUT_STREAM_FIXED_SAMPLE_SIZE = 0x00000004,
|
|
MFT_INPUT_STREAM_HOLDS_BUFFERS = 0x00000008,
|
|
|
|
//
|
|
// New for MFT
|
|
//
|
|
MFT_INPUT_STREAM_DOES_NOT_ADDREF = 0x00000100,
|
|
MFT_INPUT_STREAM_REMOVABLE = 0x00000200,
|
|
MFT_INPUT_STREAM_OPTIONAL = 0x00000400,
|
|
MFT_INPUT_STREAM_PROCESSES_IN_PLACE = 0x00000800
|
|
};
|
|
|
|
// Flags returned by GetOutputStreamInfo()
|
|
enum _MFT_OUTPUT_STREAM_INFO_FLAGS {
|
|
//
|
|
// Carried over from DMO (IMediaObject)
|
|
//
|
|
MFT_OUTPUT_STREAM_WHOLE_SAMPLES = 0x00000001,
|
|
MFT_OUTPUT_STREAM_SINGLE_SAMPLE_PER_BUFFER = 0x00000002,
|
|
MFT_OUTPUT_STREAM_FIXED_SAMPLE_SIZE = 0x00000004,
|
|
MFT_OUTPUT_STREAM_DISCARDABLE = 0x00000008,
|
|
MFT_OUTPUT_STREAM_OPTIONAL = 0x00000010,
|
|
|
|
//
|
|
// New for MFT
|
|
//
|
|
MFT_OUTPUT_STREAM_PROVIDES_SAMPLES = 0x00000100,
|
|
MFT_OUTPUT_STREAM_CAN_PROVIDE_SAMPLES = 0x00000200,
|
|
MFT_OUTPUT_STREAM_LAZY_READ = 0x00000400,
|
|
MFT_OUTPUT_STREAM_REMOVABLE = 0x00000800
|
|
};
|
|
|
|
// SetType flags
|
|
enum _MFT_SET_TYPE_FLAGS {
|
|
//
|
|
// Carried over from DMO (IMediaObject)
|
|
//
|
|
MFT_SET_TYPE_TEST_ONLY = 0x00000001,// check but don't set
|
|
|
|
//
|
|
// not carried over from DMO - use NULL type to unset.
|
|
//
|
|
//MFT_SET_TYPE_CLEAR = 0x00000002 // unset
|
|
};
|
|
|
|
//
|
|
// ProcessOutput() dwFlags (signals from caller to MFT)
|
|
//
|
|
enum _MFT_PROCESS_OUTPUT_FLAGS {
|
|
//
|
|
// Carried over from DMO (IMediaObject)
|
|
//
|
|
MFT_PROCESS_OUTPUT_DISCARD_WHEN_NO_BUFFER = 0x00000001 // discard this sample if pSample ptr is NULL.
|
|
};
|
|
|
|
//
|
|
// ProcessOutput() pdwStatus (output from MFT to caller)
|
|
//
|
|
enum _MFT_PROCESS_OUTPUT_STATUS {
|
|
//
|
|
// new for MFT
|
|
//
|
|
MFT_PROCESS_OUTPUT_STATUS_NEW_STREAMS = 0x00000100 // Output flag
|
|
};
|
|
|
|
enum _MFT_DRAIN_TYPE {
|
|
MFT_DRAIN_PRODUCE_TAILS = 0x00000000,
|
|
MFT_DRAIN_NO_TAILS = 0x00000001
|
|
};
|
|
|
|
//
|
|
// used by GetStreamLimits - the transform returns it in *pdwInputMaximum or *pdwOutputMaximum
|
|
// to mean that the MFT has no theoretical stream limit.
|
|
//
|
|
cpp_quote( "#define MFT_STREAMS_UNLIMITED 0xFFFFFFFF" )
|
|
|
|
//
|
|
// Used by SetOutputBounds when the lower or upper limit are unbounded.
|
|
//
|
|
cpp_quote( "#define MFT_OUTPUT_BOUND_LOWER_UNBOUNDED MINLONGLONG" )
|
|
cpp_quote( "#define MFT_OUTPUT_BOUND_UPPER_UNBOUNDED MAXLONGLONG" )
|
|
|
|
typedef enum _MFT_MESSAGE_TYPE {
|
|
//
|
|
// commands - must be acted on
|
|
//
|
|
MFT_MESSAGE_COMMAND_FLUSH = 0x00000000,
|
|
MFT_MESSAGE_COMMAND_DRAIN = 0x00000001,
|
|
MFT_MESSAGE_SET_D3D_MANAGER = 0x00000002,
|
|
|
|
//
|
|
// notifications - no action required; effect is transform-dependent
|
|
//
|
|
MFT_MESSAGE_NOTIFY_BEGIN_STREAMING = 0x10000000,
|
|
MFT_MESSAGE_NOTIFY_END_STREAMING = 0x10000001,
|
|
MFT_MESSAGE_NOTIFY_END_OF_STREAM = 0x10000002,
|
|
|
|
//
|
|
// send by pipeline before processing the first sample
|
|
//
|
|
MFT_MESSAGE_NOTIFY_START_OF_STREAM = 0x10000003
|
|
} MFT_MESSAGE_TYPE;
|
|
|
|
typedef struct _MFT_INPUT_STREAM_INFO {
|
|
LONGLONG hnsMaxLatency; // maximum time latency in 100ns increments
|
|
DWORD dwFlags; // MFT_INPUT_STREAM_INFO_FLAGS
|
|
DWORD cbSize; // size of each sample's buffer
|
|
DWORD cbMaxLookahead; // max total bytes held
|
|
DWORD cbAlignment; // buffer alignment requirement
|
|
} MFT_INPUT_STREAM_INFO;
|
|
|
|
typedef struct _MFT_OUTPUT_STREAM_INFO {
|
|
DWORD dwFlags; // MFT_INPUT_STREAM_INFO_FLAGS
|
|
DWORD cbSize; // size of each sample's buffer
|
|
DWORD cbAlignment; // buffer alignment requirement
|
|
} MFT_OUTPUT_STREAM_INFO;
|
|
|
|
//
|
|
// Output buffer info structure: one of these must be passed in for each
|
|
// output stream with every ProcessOutput() call
|
|
// All [out] fields should be
|
|
// assumed undefined if ProcessOutput() failed
|
|
//
|
|
typedef struct _MFT_OUTPUT_DATA_BUFFER {
|
|
DWORD dwStreamID; // [in] which stream is this for
|
|
IMFSample * pSample; // [in/out] can be NULL
|
|
DWORD dwStatus; // [out] MFT_OUTPUT_DATA_BUFFER_FLAGS (INCOMPLETE, etc.)
|
|
IMFCollection * pEvents; // [out] Can be NULL. Zero or more events produced by the MFT
|
|
} MFT_OUTPUT_DATA_BUFFER, *PMFT_OUTPUT_DATA_BUFFER;
|
|
|
|
cpp_quote( "//" )
|
|
cpp_quote( "// redefine all the method names to have MFT at the beginning so they don't class with DMO methods." )
|
|
cpp_quote( "//" )
|
|
cpp_quote( "#ifdef MFT_UNIQUE_METHOD_NAMES" )
|
|
cpp_quote( "#define GetStreamLimits MFTGetStreamLimits" )
|
|
cpp_quote( "#define GetStreamCount MFTGetStreamCount" )
|
|
cpp_quote( "#define GetStreamIDs MFTGetStreamIDs" )
|
|
cpp_quote( "#define GetInputStreamInfo MFTGetInputStreamInfo" )
|
|
cpp_quote( "#define GetOutputStreamInfo MFTGetOutputStreamInfo" )
|
|
cpp_quote( "#define DeleteInputStream MFTDeleteInputStream" )
|
|
cpp_quote( "#define AddInputStreams MFTAddInputStreams" )
|
|
cpp_quote( "#define GetInputAvailableType MFTGetInputAvailableType" )
|
|
cpp_quote( "#define GetOutputAvailableType MFTGetOutputAvailableType" )
|
|
cpp_quote( "#define SetInputType MFTSetInputType" )
|
|
cpp_quote( "#define SetOutputType MFTSetOutputType" )
|
|
cpp_quote( "#define GetInputCurrentType MFTGetInputCurrentType" )
|
|
cpp_quote( "#define GetOutputCurrentType MFTGetOutputCurrentType" )
|
|
cpp_quote( "#define GetInputStatus MFTGetInputStatus" )
|
|
cpp_quote( "#define GetOutputStatus MFTGetOutputStatus" )
|
|
cpp_quote( "#define SetOutputBounds MFTSetOutputBounds" )
|
|
cpp_quote( "#define ProcessEvent MFTProcessEvent" )
|
|
cpp_quote( "#define ProcessMessage MFTProcessMessage" )
|
|
cpp_quote( "#define ProcessInput MFTProcessInput" )
|
|
cpp_quote( "#define ProcessOutput MFTProcessOutput" )
|
|
cpp_quote( "#endif" )
|
|
|
|
// Interface supported by media objects
|
|
[
|
|
object,
|
|
uuid(bf94c121-5b05-4e6f-8000-ba598961414d)
|
|
]
|
|
interface IMFTransform : IUnknown
|
|
{
|
|
|
|
//
|
|
// Stream enumeration
|
|
//
|
|
HRESULT
|
|
GetStreamLimits(
|
|
[out] DWORD *pdwInputMinimum,
|
|
[out] DWORD *pdwInputMaximum,
|
|
[out] DWORD *pdwOutputMinimum,
|
|
[out] DWORD *pdwOutputMaximum
|
|
);
|
|
|
|
HRESULT
|
|
GetStreamCount(
|
|
[out] DWORD *pcInputStreams,
|
|
[out] DWORD *pcOutputStreams
|
|
);
|
|
|
|
HRESULT
|
|
GetStreamIDs(
|
|
DWORD dwInputIDArraySize,
|
|
[out,size_is(dwInputIDArraySize)] DWORD *pdwInputIDs,
|
|
DWORD dwOutputIDArraySize,
|
|
[out,size_is(dwOutputIDArraySize)] DWORD *pdwOutputIDs
|
|
);
|
|
|
|
HRESULT
|
|
GetInputStreamInfo(
|
|
DWORD dwInputStreamID,
|
|
[out] MFT_INPUT_STREAM_INFO * pStreamInfo
|
|
);
|
|
|
|
HRESULT
|
|
GetOutputStreamInfo(
|
|
DWORD dwOutputStreamID,
|
|
[out] MFT_OUTPUT_STREAM_INFO * pStreamInfo
|
|
);
|
|
|
|
HRESULT
|
|
GetAttributes(
|
|
[out] IMFAttributes** pAttributes
|
|
);
|
|
|
|
HRESULT
|
|
GetInputStreamAttributes(
|
|
DWORD dwInputStreamID,
|
|
[out] IMFAttributes** pAttributes
|
|
);
|
|
|
|
HRESULT
|
|
GetOutputStreamAttributes(
|
|
DWORD dwOutputStreamID,
|
|
[out] IMFAttributes** pAttributes
|
|
);
|
|
|
|
HRESULT
|
|
DeleteInputStream(
|
|
DWORD dwStreamID
|
|
);
|
|
|
|
HRESULT
|
|
AddInputStreams(
|
|
DWORD cStreams,
|
|
[in] DWORD * adwStreamIDs
|
|
);
|
|
|
|
|
|
//
|
|
// Mediatypes
|
|
//
|
|
//
|
|
// GetxxxAvailableTypes - iterate through media types supported by a stream.
|
|
//
|
|
HRESULT
|
|
GetInputAvailableType(
|
|
DWORD dwInputStreamID,
|
|
DWORD dwTypeIndex, // 0-based
|
|
[out] IMFMediaType ** ppType
|
|
);
|
|
HRESULT
|
|
GetOutputAvailableType(
|
|
DWORD dwOutputStreamID,
|
|
DWORD dwTypeIndex, // 0-based
|
|
[out] IMFMediaType ** ppType
|
|
);
|
|
|
|
//
|
|
// SetType - tell the object the type of data it will work with.
|
|
//
|
|
HRESULT
|
|
SetInputType(
|
|
DWORD dwInputStreamID,
|
|
[in] IMFMediaType *pType,
|
|
DWORD dwFlags
|
|
);
|
|
HRESULT
|
|
SetOutputType(
|
|
DWORD dwOutputStreamID,
|
|
[in] IMFMediaType *pType,
|
|
DWORD dwFlags
|
|
);
|
|
|
|
//
|
|
// GetCurrentType - get the current type set for the given stream index.
|
|
//
|
|
HRESULT
|
|
GetInputCurrentType(
|
|
DWORD dwInputStreamID,
|
|
[out] IMFMediaType ** ppType
|
|
);
|
|
HRESULT
|
|
GetOutputCurrentType(
|
|
DWORD dwOutputStreamID,
|
|
[out] IMFMediaType ** ppType
|
|
);
|
|
|
|
//
|
|
// Streaming / state methods
|
|
//
|
|
// GetInputFlags - the only flag defined right now is MFT_INPUT_STATUS_ACCEPT_DATA.
|
|
HRESULT
|
|
GetInputStatus(
|
|
DWORD dwInputStreamID,
|
|
[out] DWORD * pdwFlags // MFT_INPUT_STATUS_ACCEPT_DATA
|
|
);
|
|
|
|
// GetOutputFlags - the only flag defined right now is MFT_OUTPUT_STATUS_SAMPLE_READY.
|
|
HRESULT
|
|
GetOutputStatus(
|
|
[out] DWORD *pdwFlags
|
|
);
|
|
|
|
//
|
|
// SetOutputBounds - optional interface to tell transform the desired
|
|
// range of output times desired. Implementation is optional.
|
|
//
|
|
HRESULT
|
|
SetOutputBounds(
|
|
LONGLONG hnsLowerBound,
|
|
LONGLONG hnsUpperBound
|
|
);
|
|
|
|
HRESULT
|
|
ProcessEvent(
|
|
DWORD dwInputStreamID,
|
|
[in] IMFMediaEvent * pEvent
|
|
);
|
|
|
|
//
|
|
// ProcessMessage - used to send a notification or command to a transform
|
|
//
|
|
HRESULT
|
|
ProcessMessage(
|
|
MFT_MESSAGE_TYPE eMessage,
|
|
ULONG_PTR ulParam
|
|
);
|
|
|
|
//
|
|
// Pass one new buffer to an input stream
|
|
//
|
|
[local] HRESULT
|
|
ProcessInput(
|
|
DWORD dwInputStreamID,
|
|
IMFSample * pSample,
|
|
DWORD dwFlags
|
|
);
|
|
|
|
//
|
|
// ProcessOutput() - generate output for current input buffers
|
|
//
|
|
// Output stream specific status information is returned in the
|
|
// dwStatus member of each buffer wrapper structure.
|
|
//
|
|
[local] HRESULT
|
|
ProcessOutput(
|
|
DWORD dwFlags, // MFT_PROCESS_OUTPUT_FLAGS
|
|
DWORD cOutputBufferCount, // # returned by GetStreamCount()
|
|
[in,out,size_is(cOutputBufferCount)]
|
|
MFT_OUTPUT_DATA_BUFFER *pOutputSamples, // one per stream
|
|
[out] DWORD * pdwStatus // MFT_PROCESS_OUTPUT_XXX
|
|
);
|
|
|
|
};
|
|
|
|
|
|
cpp_quote( "//" )
|
|
cpp_quote( "// Define the MFT methods back so we don't accidentally hose the IMediaObject interface." )
|
|
cpp_quote( "//" )
|
|
cpp_quote( "#ifdef MFT_UNIQUE_METHOD_NAMES" )
|
|
cpp_quote( "#undef GetStreamLimits " )
|
|
cpp_quote( "#undef GetStreamCount " )
|
|
cpp_quote( "#undef GetStreamIDs " )
|
|
cpp_quote( "#undef GetInputStreamInfo " )
|
|
cpp_quote( "#undef GetOutputStreamInfo " )
|
|
cpp_quote( "#undef DeleteInputStream " )
|
|
cpp_quote( "#undef AddInputStreams " )
|
|
cpp_quote( "#undef GetInputAvailableType " )
|
|
cpp_quote( "#undef GetOutputAvailableType " )
|
|
cpp_quote( "#undef SetInputType " )
|
|
cpp_quote( "#undef SetOutputType " )
|
|
cpp_quote( "#undef GetInputCurrentType " )
|
|
cpp_quote( "#undef GetOutputCurrentType " )
|
|
cpp_quote( "#undef GetInputStatus " )
|
|
cpp_quote( "#undef GetOutputStatus " )
|
|
cpp_quote( "#undef SetOutputBounds " )
|
|
cpp_quote( "#undef ProcessMessage " )
|
|
cpp_quote( "#undef ProcessInput " )
|
|
cpp_quote( "#undef ProcessOutput " )
|
|
cpp_quote( "#endif" )
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// GENERIC DMO PROPERTY KEYS
|
|
//
|
|
|
|
// All MFTs
|
|
cpp_quote( "static const PROPERTYKEY MFPKEY_CLSID = { { 0xc57a84c0, 0x1a80, 0x40a3, {0x97, 0xb5, 0x92, 0x72, 0xa4, 0x3, 0xc8, 0xae} }, 0x01 }; ")
|
|
cpp_quote( "static const PROPERTYKEY MFPKEY_CATEGORY = { { 0xc57a84c0, 0x1a80, 0x40a3, {0x97, 0xb5, 0x92, 0x72, 0xa4, 0x3, 0xc8, 0xae} }, 0x02 }; ")
|
|
|
|
// ExAttribute-supported MFTs
|
|
cpp_quote( "static const PROPERTYKEY MFPKEY_EXATTRIBUTE_SUPPORTED = { { 0x456fe843, 0x3c87, 0x40c0, {0x94, 0x9d, 0x14, 0x9, 0xc9, 0x7d, 0xab, 0x2c} }, 0x01 }; ")
|
|
|
|
// Audio Multichannel
|
|
cpp_quote( "static const PROPERTYKEY MFPKEY_MULTICHANNEL_CHANNEL_MASK = { { 0x58bdaf8c, 0x3224, 0x4692, { 0x86, 0xd0, 0x44, 0xd6, 0x5c, 0x5b, 0xf8, 0x2b } }, 0x01 }; ")
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// GENERIC MFT ATTRIBUTES
|
|
cpp_quote( "static const GUID MF_SA_D3D_AWARE = { 0xeaa35c29, 0x775e, 0x488e, { 0x9b, 0x61, 0xb3, 0x28, 0x3e, 0x49, 0x58, 0x3b } }; ")
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
cpp_quote( "static const GUID MF_SA_REQUIRED_SAMPLE_COUNT = { 0x18802c61, 0x324b, 0x4952, { 0xab, 0xd0, 0x17, 0x6f, 0xf5, 0xc6, 0x96, 0xff } };" )
|
|
|
|
|