Update recompile code base

This commit is contained in:
2024-09-20 03:35:59 +08:00
parent d367252091
commit bd69031a3d
192 changed files with 161561 additions and 201 deletions

View File

@@ -0,0 +1,338 @@
//------------------------------------------------------------------------------
// File: AMStream.idl
//
// Desc:
//
// Copyright (c) 1998 - 2000, Microsoft Corporation. All rights reserved.
//------------------------------------------------------------------------------
import "unknwn.idl";
import "mmstream.idl";
import "strmif.idl";
cpp_quote("#include <ddraw.h>")
cpp_quote("#include <mmsystem.h>")
cpp_quote("#include <mmstream.h>")
cpp_quote("#include <ddstream.h>")
cpp_quote("#include <austream.h>")
interface IAMMultiMediaStream;
interface IAMMediaStream;
interface IMediaStreamFilter;
interface IDirectDraw;
interface IDirectDrawSurface;
interface IAMMediaTypeStream;
interface IAMMediaTypeSample;
// Flags definitions for IAMMultiMediaStream::Initialize
enum {
AMMSF_NOGRAPHTHREAD = 0x00000001
};
// Flags definitions for AddMediaStream and IAMMediaStream::Initialize
enum {
// Don't add a stream - create a default renderer instead
// for the supplied purpose id
AMMSF_ADDDEFAULTRENDERER = 0x00000001,
AMMSF_CREATEPEER = 0x00000002,
// If no samples are created when we run or the last sample
// is deleted then terminate this stream
AMMSF_STOPIFNOSAMPLES = 0x00000004,
// If Update is not called keep going
AMMSF_NOSTALL = 0x00000008
};
// Flag definitions for OpenFile and OpenMoniker
enum {
AMMSF_RENDERTYPEMASK = 0x00000003,
AMMSF_RENDERTOEXISTING = 0x00000000,
AMMSF_RENDERALLSTREAMS = 0x00000001,
AMMSF_NORENDER = 0x00000002,
AMMSF_NOCLOCK = 0x00000004,
AMMSF_RUN = 0x00000008
};
typedef [v1_enum] enum {
Disabled = 0,
ReadData = 1,
RenderData = 2
} OUTPUT_STATE;
[
object,
uuid(7DB01C96-C0C3-11d0-8FF1-00C04FD9189D),
dual,
helpstring("IDirectShowStream Interface"),
pointer_default(unique)
]
interface IDirectShowStream : IDispatch
{
[propget, id(1), helpstring("property FileName")] HRESULT FileName([out, retval] BSTR *pVal);
[propput, id(1), helpstring("property FileName")] HRESULT FileName([in] BSTR newVal);
[propget, id(2), helpstring("property Video")] HRESULT Video([out, retval] OUTPUT_STATE *pVal);
[propput, id(2), helpstring("propetry Video")] HRESULT Video([in] OUTPUT_STATE newVal);
[propget, id(3), helpstring("property Audio")] HRESULT Audio([out, retval] OUTPUT_STATE *pVal);
[propput, id(3), helpstring("propetry Audio")] HRESULT Audio([in] OUTPUT_STATE newVal);
};
// IAMMultiMediaStream interface
[
object,
uuid(BEBE595C-9A6F-11d0-8FDE-00C04FD9189D),
pointer_default(unique)
]
interface IAMMultiMediaStream : IMultiMediaStream
{
HRESULT Initialize(
[in] STREAM_TYPE StreamType,
[in] DWORD dwFlags,
[in] IGraphBuilder *pFilterGraph);
HRESULT GetFilterGraph(
[out] IGraphBuilder **ppGraphBuilder);
HRESULT GetFilter(
[out] IMediaStreamFilter **ppFilter);
HRESULT AddMediaStream(
[in] IUnknown *pStreamObject,
[in] const MSPID *PurposeId,
[in] DWORD dwFlags,
[out] IMediaStream **ppNewStream);
HRESULT OpenFile(
[in] LPCWSTR pszFileName,
[in] DWORD dwFlags);
HRESULT OpenMoniker(
[in] IBindCtx *pCtx,
[in] IMoniker *pMoniker,
[in] DWORD dwFlags);
HRESULT Render(
[in] DWORD dwFlags);
}
// IAMMediaStream interface
[
object,
uuid(BEBE595D-9A6F-11d0-8FDE-00C04FD9189D),
pointer_default(unique)
]
interface IAMMediaStream : IMediaStream
{
HRESULT Initialize(
[in] IUnknown *pSourceObject,
[in] DWORD dwFlags,
[in] REFMSPID PurposeId,
[in] const STREAM_TYPE StreamType);
HRESULT SetState(
[in] FILTER_STATE State);
HRESULT JoinAMMultiMediaStream(
[in] IAMMultiMediaStream *pAMMultiMediaStream);
HRESULT JoinFilter(
[in] IMediaStreamFilter *pMediaStreamFilter);
HRESULT JoinFilterGraph(
[in] IFilterGraph *pFilterGraph);
};
// IMediaStreamFilter interface
[
object,
local,
uuid(BEBE595E-9A6F-11d0-8FDE-00C04FD9189D),
pointer_default(unique)
]
interface IMediaStreamFilter : IBaseFilter
{
HRESULT AddMediaStream(
[in] IAMMediaStream *pAMMediaStream);
HRESULT GetMediaStream(
[in] REFMSPID idPurpose,
[out] IMediaStream **ppMediaStream);
HRESULT EnumMediaStreams(
[in] long Index,
[out] IMediaStream **ppMediaStream);
HRESULT SupportSeeking(
[in] BOOL bRenderer);
HRESULT ReferenceTimeToStreamTime(
[in] [out] REFERENCE_TIME *pTime);
HRESULT GetCurrentStreamTime(
[out] REFERENCE_TIME *pCurrentStreamTime);
HRESULT WaitUntil(
[in] REFERENCE_TIME WaitStreamTime);
HRESULT Flush(
[in] BOOL bCancelEOS);
HRESULT EndOfStream();
};
[
object,
local,
uuid(AB6B4AFC-F6E4-11d0-900D-00C04FD9189D),
pointer_default(unique)
]
interface IDirectDrawMediaSampleAllocator : IUnknown
{
HRESULT GetDirectDraw(IDirectDraw **ppDirectDraw);
};
[
object,
local,
uuid(AB6B4AFE-F6E4-11d0-900D-00C04FD9189D),
pointer_default(unique)
]
interface IDirectDrawMediaSample : IUnknown
{
HRESULT GetSurfaceAndReleaseLock(
[out] IDirectDrawSurface **ppDirectDrawSurface,
[out] RECT * pRect);
HRESULT LockMediaSamplePointer(void);
};
[
object,
local,
uuid(AB6B4AFA-F6E4-11d0-900D-00C04FD9189D),
pointer_default(unique)
]
interface IAMMediaTypeStream : IMediaStream
{
HRESULT GetFormat(
[out] AM_MEDIA_TYPE * pMediaType,
[in] DWORD dwFlags);
HRESULT SetFormat(
[in] AM_MEDIA_TYPE * pMediaType,
[in] DWORD dwFlags);
HRESULT CreateSample(
[in] long lSampleSize,
[in] BYTE * pbBuffer,
[in] DWORD dwFlags,
[in] IUnknown *pUnkOuter,
[out] IAMMediaTypeSample ** ppAMMediaTypeSample);
HRESULT GetStreamAllocatorRequirements(
[out] ALLOCATOR_PROPERTIES *pProps);
HRESULT SetStreamAllocatorRequirements(
[in] ALLOCATOR_PROPERTIES *pProps);
};
[
object,
local,
uuid(AB6B4AFB-F6E4-11d0-900D-00C04FD9189D),
pointer_default(unique)
]
interface IAMMediaTypeSample : IStreamSample
{
//
// Unique methods for IAMMediaTypeSample
//
HRESULT SetPointer([in] BYTE *pBuffer, [in] long lSize);
//
// Mirror of IMediaSample
//
HRESULT GetPointer([out] BYTE ** ppBuffer);
long GetSize(void);
HRESULT GetTime([out] REFERENCE_TIME * pTimeStart, [out] REFERENCE_TIME * pTimeEnd);
HRESULT SetTime([in] REFERENCE_TIME * pTimeStart, [in] REFERENCE_TIME * pTimeEnd);
HRESULT IsSyncPoint(void);
HRESULT SetSyncPoint(BOOL bIsSyncPoint);
HRESULT IsPreroll(void);
HRESULT SetPreroll(BOOL bIsPreroll);
long GetActualDataLength(void);
HRESULT SetActualDataLength(long);
HRESULT GetMediaType(AM_MEDIA_TYPE **ppMediaType);
HRESULT SetMediaType(AM_MEDIA_TYPE *pMediaType);
HRESULT IsDiscontinuity(void);
HRESULT SetDiscontinuity(BOOL bDiscontinuity);
HRESULT GetMediaTime([out] LONGLONG * pTimeStart, [out] LONGLONG * pTimeEnd);
HRESULT SetMediaTime([in] LONGLONG * pTimeStart, [in] LONGLONG * pTimeEnd);
};
[
uuid(4E6CDE29-C0C4-11d0-8FF1-00C04FD9189D),
version(1.0),
helpstring("DirectShowStream 1.0 Type Library")
]
library DirectShowStreamLib
{
importlib("stdole32.tlb");
importlib("stdole2.tlb");
[
uuid(49c47ce5-9ba4-11d0-8212-00c04fc32c45),
helpstring("DirectShow Multi Media Stream")
]
coclass AMMultiMediaStream
{
[default] dispinterface IDirectShowStream;
};
};
//
// The MIDL compiler wants to produce a CLSID for everything defined in
// our type library, but it also wants to generate huge, fat proxy code
// so we use DEFINE_GUID for all other classes. It has another interesting
// bug in that it defines CLSID_AMMultiMediaStream within a #ifdef __cplusplus
// block, so we need to define it outside of that scope.
//
cpp_quote("#ifndef __cplusplus")
cpp_quote("EXTERN_C const CLSID CLSID_AMMultiMediaStream;")
cpp_quote("#endif")
cpp_quote("DEFINE_GUID(CLSID_AMDirectDrawStream, /* 49c47ce4-9ba4-11d0-8212-00c04fc32c45 */")
cpp_quote("0x49c47ce4, 0x9ba4, 0x11d0, 0x82, 0x12, 0x00, 0xc0, 0x4f, 0xc3, 0x2c, 0x45);")
cpp_quote("DEFINE_GUID(CLSID_AMAudioStream, /* 8496e040-af4c-11d0-8212-00c04fc32c45 */")
cpp_quote("0x8496e040, 0xaf4c, 0x11d0, 0x82, 0x12, 0x00, 0xc0, 0x4f, 0xc3, 0x2c, 0x45);")
cpp_quote("DEFINE_GUID(CLSID_AMAudioData, /* f2468580-af8a-11d0-8212-00c04fc32c45 */")
cpp_quote("0xf2468580, 0xaf8a, 0x11d0, 0x82, 0x12, 0x00, 0xc0, 0x4f, 0xc3, 0x2c, 0x45);")
cpp_quote("DEFINE_GUID(CLSID_AMMediaTypeStream, /* CF0F2F7C-F7BF-11d0-900D-00C04FD9189D */")
cpp_quote("0xcf0f2f7c, 0xf7bf, 0x11d0, 0x90, 0xd, 0x0, 0xc0, 0x4f, 0xd9, 0x18, 0x9d);")

View File

@@ -0,0 +1,171 @@
//------------------------------------------------------------------------------
// File: AMVPE.idl
//
// Desc:
//
// Copyright (c) 1992 - 2000, Microsoft Corporation. All rights reserved.
//------------------------------------------------------------------------------
import "unknwn.idl";
import "objidl.idl"; // for IPersist (IFilter's root)
/*
* VIDOESIGNALINFO
*/
typedef struct _VIDEOSIGNALINFO
{
DWORD dwSize; // Size of the structure
DWORD dwVREFHeight; // Specifies the number of lines of data in the vref
BOOL bDoubleClock; // videoport should enable double clocking
BOOL bVACT; // videoport should use an external VACT signal
BOOL bInterlaced; // Indicates that the signal is interlaced
BOOL bHalfline; // Device will write half lines into the frame buffer
BOOL bInvertedPolarity; // Devoce inverts the polarity by default
} AMVIDEOSIGNALINFO;
typedef struct AMVIDEOSIGNALINFO *LPAMVIDEOSIGNALINFO;
interface IVPEConfig;
interface IVPE;
/*
* DDVIDEOPORTCONNECT
*/
typedef struct _DDVIDEOPORTCONNECT
{
DWORD dwSize; // size of the DDVIDEOPORTCONNECT structure
GUID guidTypeID; // Description of video port connection
DWORD dwPortWidth; // Width of the video port
DWORD dwFlags; // Connection flags
} DDVIDEOPORTCONNECT;
typedef DDVIDEOPORTCONNECT *LPDDVIDEOPORTCONNECT;
/*
* DDPIXELFORMAT
*/
typedef struct _DDPIXELFORMAT
{
DWORD dwSize; // size of structure
DWORD dwFlags; // pixel format flags
DWORD dwFourCC; // (FOURCC code)
union
{
DWORD dwRGBBitCount; // how many bits per pixel (BD_1,2,4,8,16,24,32)
DWORD dwYUVBitCount; // how many bits per pixel (BD_4,8,16,24,32)
DWORD dwZBufferBitDepth; // how many bits for z buffers (BD_8,16,24,32)
DWORD dwAlphaBitDepth; // how many bits for alpha channels (BD_1,2,4,8)
};
union
{
DWORD dwRBitMask; // mask for red bit
DWORD dwYBitMask; // mask for Y bits
};
union
{
DWORD dwGBitMask; // mask for green bits
DWORD dwUBitMask; // mask for U bits
};
union
{
DWORD dwBBitMask; // mask for blue bits
DWORD dwVBitMask; // mask for V bits
};
union
{
DWORD dwRGBAlphaBitMask; // mask for alpha channel
DWORD dwYUVAlphaBitMask; // mask for alpha channel
DWORD dwRGBZBitMask; // mask for Z channel
DWORD dwYUVZBitMask; // mask for Z channel
};
} DDPIXELFORMAT;
typedef DDPIXELFORMAT * LPDDPIXELFORMAT;
[
object,
uuid(BC29A660-30E3-11d0-9E69-00C04FD7C15B),
pointer_default(unique)
]
interface IVPEConfig : IUnknown {
// gets the various connection information structures (guid, portwidth)
// in an array of structures. If the pointer to the array is NULL, first
// parameter returns the total number of formats supported.
HRESULT GetConnectInfo(
[in,out] LPDWORD lpNumConnectInfo,
[out] LPDDVIDEOPORTCONNECT lpddvpConnectInfo
);
HRESULT SetConnectInfo(
[in] DDVIDEOPORTCONNECT ddvpConnectInfo
);
// gets the various formats supported by the decoder in an array
// of structures. If the pointer to the array is NULL, first parameter
// returns the total number of formats supported.
HRESULT GetVideoFormats(
[in,out] LPDWORD lpNumFormats,
[out] LPDDPIXELFORMAT lpddpfFormats
);
// retrives maximum pixels per second rate expected for a given
// format and a given scaling factor. If decoder does not support
// those scaling factors, then it gives the rate and the nearest
// scaling factors.
HRESULT GetMaxPixelRate(
[in] DDPIXELFORMAT ddpfFormat,
[in,out] LPDWORD lpdwZoomHeight,
[in,out] LPDWORD lpdwZoomWidth,
[out] LPDWORD lpdwMaxPixelsPerSecond
);
// retrives various properties of the decoder for a given format
HRESULT GetVideoSignalInfo(
[in] DDPIXELFORMAT ddpfFormat,
[out] LPAMVIDEOSIGNALINFO lpAMVideoSignalInfo
);
// asks the decoder to ouput in this format. Return value should give
// appropriate error code
HRESULT SetVideoFormat(
[in] DDPIXELFORMAT ddpfFormat
);
// asks the decoder to treat even fields like odd fields and visa versa
HRESULT SetInvertPolarity(
);
// sets the scaling factors. If decoder does not support these,
// then it sets the values to the nearest factors it can support
HRESULT SetScalingFactors(
[in,out] LPDWORD lpdwZoomHeight,
[in,out] LPDWORD lpdwZoomWidth
);
}
[
object,
uuid(BC29A661-30E3-11d0-9E69-00C04FD7C15B),
pointer_default(unique)
]
interface IVPE : IUnknown {
HRESULT SetOverlaySurface(
// [in] LPDIRECTDRAWSURFACE lpOverlaySurface,
[in] LPUNKNOWN lpOverlaySurface,
[in] INT iNumBackBuffers
);
}

View File

@@ -0,0 +1,106 @@
//------------------------------------------------------------------------------
// File: AuStream.idl
//
// Desc:
//
// Copyright (c) 1998 - 2000, Microsoft Corporation. All rights reserved.
//------------------------------------------------------------------------------
import "unknwn.idl";
import "mmstream.idl";
cpp_quote("//")
cpp_quote("// The following declarations within the 'if 0' block are dummy typedefs used to make")
cpp_quote("// the ddstream.idl file build. The actual definitions are contained in DDRAW.H")
cpp_quote("//")
cpp_quote("#if 0")
typedef struct tWAVEFORMATEX WAVEFORMATEX;
cpp_quote ("#endif")
interface IAudioMediaStream;
interface IAudioStreamSample;
interface IMemoryData;
interface IAudioData;
// IAudioMediaStream
[
object,
local,
uuid(f7537560-a3be-11d0-8212-00c04fc32c45),
pointer_default(unique)
]
interface IAudioMediaStream : IMediaStream
{
HRESULT GetFormat(
[out] WAVEFORMATEX *pWaveFormatCurrent
);
HRESULT SetFormat(
[in] const WAVEFORMATEX *lpWaveFormat);
HRESULT CreateSample(
[in] IAudioData *pAudioData,
[in] DWORD dwFlags,
[out] IAudioStreamSample **ppSample
);
}
[
object,
local,
uuid(345fee00-aba5-11d0-8212-00c04fc32c45),
pointer_default(unique)
]
interface IAudioStreamSample : IStreamSample
{
HRESULT GetAudioData(
[out] IAudioData **ppAudio
);
}
[
object,
local,
uuid(327fc560-af60-11d0-8212-00c04fc32c45),
pointer_default(unique)
]
interface IMemoryData : IUnknown
{
HRESULT SetBuffer(
[in] DWORD cbSize,
[in] BYTE *pbData,
[in] DWORD dwFlags
);
HRESULT GetInfo(
[out] DWORD *pdwLength,
[out] BYTE **ppbData,
[out] DWORD *pcbActualData
);
HRESULT SetActual(
[in] DWORD cbDataValid
);
}
[
object,
local,
uuid(54c719c0-af60-11d0-8212-00c04fc32c45),
pointer_default(unique)
]
interface IAudioData : IMemoryData
{
HRESULT GetFormat(
[out] WAVEFORMATEX *pWaveFormatCurrent
);
HRESULT SetFormat(
[in] const WAVEFORMATEX *lpWaveFormat
);
}

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@@ -0,0 +1,772 @@
//------------------------------------------------------------------------------
// File: BDAIface.idl
//
// Desc: This file defines the Ring 3 BDA interfaces that are common to
// all BDA network and device types.
//
// The interfaces specific to a particular Network Type or filter
// implementation are defined in a separate include file for that
// Network Type or filter implementation.
//
// Copyright (c) 1999 - 2000, Microsoft Corporation. All rights reserved.
//------------------------------------------------------------------------------
//---------------------------------------------------------------------
// IUnknown import idl
//---------------------------------------------------------------------
#ifndef DO_NO_IMPORTS
import "unknwn.idl";
import "strmif.idl";
import "BdaTypes.h";
#endif
//---------------------------------------------------------------------
//
// IBDA_NetworkProvider interface
//
// Implemented by a BDA Network Provider
//
// Used by a BDA device filter to register itself with
// a Network Provider and query information about the
// the current tuning request.
//
//---------------------------------------------------------------------
[
object,
uuid(fd501041-8ebe-11ce-8183-00aa00577da2),
pointer_default(unique)
]
interface IBDA_NetworkProvider : IUnknown
{
HRESULT
PutSignalSource (
[in] ULONG ulSignalSource
);
HRESULT
GetSignalSource (
[in, out] ULONG * pulSignalSource
);
HRESULT
GetNetworkType (
[in, out] GUID * pguidNetworkType
);
HRESULT
PutTuningSpace (
[in] REFGUID guidTuningSpace
);
HRESULT
GetTuningSpace (
[in, out] GUID * pguidTuingSpace
);
HRESULT
RegisterDeviceFilter (
[in] IUnknown * pUnkFilterControl,
[in, out] ULONG * ppvRegisitrationContext
);
HRESULT
UnRegisterDeviceFilter (
[in] ULONG pvRegistrationContext
);
}
//---------------------------------------------------------------------
//
// IBDA_EthernetFilter interface
//
// Implemented by a BDA Network Provider
//
// Used by an Ethernet Network Data Sink filter (eg. IPSink) to
// request that the Network Provider make its best effort to tune
// to the stream(s) on which a list of Ethernet multicast addresses
// may be transmitted.
//
// Addresses in the address list are byte aligned in Network order.
// UlcbAddresses will always be an integer multiple of the
// size of an ethernet address.
//
//---------------------------------------------------------------------
[
object,
uuid(71985F43-1CA1-11d3-9CC8-00C04F7971E0),
pointer_default(unique)
]
interface IBDA_EthernetFilter : IUnknown
{
HRESULT
GetMulticastListSize (
[in, out] ULONG * pulcbAddresses
);
HRESULT
PutMulticastList (
[in] ULONG ulcbAddresses,
[in, size_is(ulcbAddresses)] BYTE pAddressList []
);
HRESULT
GetMulticastList (
[in, out] ULONG * pulcbAddresses,
[out, size_is(*pulcbAddresses)] BYTE pAddressList []
);
HRESULT
PutMulticastMode (
[in] ULONG ulModeMask
);
HRESULT
GetMulticastMode (
[out] ULONG * pulModeMask
);
}
//---------------------------------------------------------------------
//
// IBDA_IPV4Filter interface
//
// Implemented by a BDA Network Provider
//
// Used by an IPv4 Network Data Sink filter to request
// that the Network Provider make its best effort to tune
// to the stream(s) on which a list of IPv4 multicast addresses
// may be transmitted.
//
// Addresses in the address list are byte aligned in Network order.
// UlcbAddresses will always be an integer multiple of the
// size of an IPv4 address.
//
//---------------------------------------------------------------------
[
object,
uuid(71985F44-1CA1-11d3-9CC8-00C04F7971E0),
pointer_default(unique)
]
interface IBDA_IPV4Filter : IUnknown
{
HRESULT
GetMulticastListSize (
[in, out] ULONG * pulcbAddresses
);
HRESULT
PutMulticastList (
[in] ULONG ulcbAddresses,
[in, size_is(ulcbAddresses)] BYTE pAddressList []
);
HRESULT
GetMulticastList (
[in, out] ULONG * pulcbAddresses,
[out, size_is(*pulcbAddresses)] BYTE pAddressList []
);
HRESULT
PutMulticastMode (
[in] ULONG ulModeMask
);
HRESULT
GetMulticastMode (
[out] ULONG* pulModeMask
);
}
//---------------------------------------------------------------------
//
// IBDA_IPV6Filter interface
//
// Implemented by a BDA Network Provider
//
// Used by an IPv6 Network Data Sink filter to request
// that the Network Provider make its best effort to tune
// to the stream(s) on which a list of IPv6 multicast addresses
// may be transmitted.
//
// Addresses in the address list are byte aligned in Network order.
// UlcbAddresses will always be an integer multiple of the
// size of an IPv6 address.
//
//---------------------------------------------------------------------
[
object,
uuid(E1785A74-2A23-4fb3-9245-A8F88017EF33),
pointer_default(unique)
]
interface IBDA_IPV6Filter : IUnknown
{
HRESULT
GetMulticastListSize (
[in, out] ULONG * pulcbAddresses
);
HRESULT
PutMulticastList (
[in] ULONG ulcbAddresses,
[in, size_is(ulcbAddresses)] BYTE pAddressList []
);
HRESULT
GetMulticastList (
[in, out] ULONG * pulcbAddresses,
[out, size_is(*pulcbAddresses)] BYTE pAddressList []
);
HRESULT
PutMulticastMode (
[in] ULONG ulModeMask
);
HRESULT
GetMulticastMode (
[out] ULONG* pulModeMask
);
}
//---------------------------------------------------------------------
//
// IBDA_DeviceControl interface
//
// Implemented by a BDA Device Filter
//
// Used by the Network Provider to commit a series of changes
// on a BDA device filter. The device filter validates and
// accumulates all changes requested after StartChanges(). It
// effects the accumulated list of changes when CommitChanges() is
// called.
//
//---------------------------------------------------------------------
[
object,
uuid(FD0A5AF3-B41D-11d2-9C95-00C04F7971E0),
pointer_default(unique)
]
interface IBDA_DeviceControl : IUnknown
{
HRESULT
StartChanges (
void
);
HRESULT
CheckChanges (
void
);
HRESULT
CommitChanges (
void
);
HRESULT
GetChangeState (
[in, out] ULONG * pState
);
}
//---------------------------------------------------------------------
//
// IBDA_PinControl interface
//
// Implemented by a BDA Device Filter's Pin
//
// Used by the Network Provider to determine the BDA PinID and
// PinType on a BDA Filter's Pin
//
//---------------------------------------------------------------------
[
object,
uuid(0DED49D5-A8B7-4d5d-97A1-12B0C195874D),
pointer_default(unique)
]
interface IBDA_PinControl : IUnknown
{
HRESULT
GetPinID (
[in, out] ULONG * pulPinID
);
HRESULT
GetPinType (
[in, out] ULONG * pulPinType
);
}
//---------------------------------------------------------------------
//
// IBDA_SignalProperties interface
//
// Implemented by a BDA Device Filter
//
// BDA Signal Properties is used by a Network Provider to inform
// a BDA Device Filter about the current tuning request. The
// Network Provider will call the Put functions when the BDA
// device is first registered with the Network Provider and whenever
// the current tuning request is modified.
//
//---------------------------------------------------------------------
[
object,
uuid(D2F1644B-B409-11d2-BC69-00A0C9EE9E16),
pointer_default(unique)
]
interface IBDA_SignalProperties : IUnknown
{
HRESULT
PutNetworkType (
[in] REFGUID guidNetworkType
);
HRESULT
GetNetworkType (
[in, out] GUID * pguidNetworkType
);
HRESULT
PutSignalSource (
[in] ULONG ulSignalSource
);
HRESULT
GetSignalSource (
[in, out] ULONG * pulSignalSource
);
HRESULT
PutTuningSpace (
[in] REFGUID guidTuningSpace
);
HRESULT
GetTuningSpace (
[in, out] GUID * pguidTuingSpace
);
}
//---------------------------------------------------------------------
//
// IBDA_Topology interface
//
// Implemented by a BDA Device Filter
//
// Used by the Network Provider to query a BDA Device Filter's
// possible topologies (template topology) and to configure
// the device with an appropriate topology for the current
// tuning request. It is also used to get an IUnknown to
// a control node which may be used to set specific tuning
// information.
//
//---------------------------------------------------------------------
[
object,
uuid(A14EE835-0A23-11d3-9CC7-00C04F7971E0),
pointer_default(unique)
]
interface IBDA_Topology : IUnknown
{
HRESULT
GetNodeTypes (
[in, out] ULONG * pulcNodeTypes,
[in] ULONG ulcNodeTypesMax,
[in, out, size_is (ulcNodeTypesMax)] ULONG rgulNodeTypes[]
);
HRESULT
GetNodeInterfaces (
[in] ULONG ulNodeType,
[in, out] ULONG * pulcInterfaces,
[in] ULONG ulcInterfacesMax,
[in, out, size_is (ulcInterfacesMax)] GUID * rgguidInterfaces[]
);
HRESULT
GetPinTypes (
[in, out] ULONG * pulcPinTypes,
[in] ULONG ulcPinTypesMax,
[in, out, size_is (ulcPinTypesMax)] ULONG rgulPinTypes[]
);
HRESULT
GetTemplateConnections (
[in, out] ULONG * pulcConnections,
[in] ULONG ulcConnectionsMax,
[in, out, size_is (ulcConnectionsMax)] BDA_TEMPLATE_CONNECTION rgConnections[]
);
HRESULT
CreatePin (
[in] ULONG ulPinType,
[in, out] ULONG * pulPinId
);
HRESULT
DeletePin (
[in] ULONG ulPinId
);
HRESULT
SetMediaType (
[in] ULONG ulPinId,
[in] AM_MEDIA_TYPE * pMediaType
);
HRESULT
SetMedium (
[in] ULONG ulPinId,
[in] REGPINMEDIUM * pMedium
);
HRESULT
CreateTopology (
[in] ULONG ulInputPinId,
[in] ULONG ulOutputPinId
);
HRESULT
GetControlNode (
[in] ULONG ulInputPinId,
[in] ULONG ulOutputPinId,
[in] ULONG ulNodeType,
[in, out] IUnknown ** ppControlNode
);
}
//---------------------------------------------------------------------
// IBDA_VoidTransform interface
//---------------------------------------------------------------------
[
object,
uuid(71985F46-1CA1-11d3-9CC8-00C04F7971E0),
pointer_default(unique)
]
interface IBDA_VoidTransform : IUnknown
{
HRESULT
Start (
void
);
HRESULT
Stop (
void
);
}
//---------------------------------------------------------------------
// IBDA_NullTransform interface
//---------------------------------------------------------------------
[
object,
uuid(DDF15B0D-BD25-11d2-9CA0-00C04F7971E0),
pointer_default(unique)
]
interface IBDA_NullTransform : IUnknown
{
HRESULT
Start (
void
);
HRESULT
Stop (
void
);
}
//---------------------------------------------------------------------
// IBDA_FrequencyFilter interface
//---------------------------------------------------------------------
[
object,
uuid(71985F47-1CA1-11d3-9CC8-00C04F7971E0),
pointer_default(unique)
]
interface IBDA_FrequencyFilter : IUnknown
{
HRESULT
put_Autotune (
[in] ULONG * pulTransponder
);
HRESULT
put_Frequency (
[in] ULONG * pulFrequency
);
HRESULT
get_Frequency (
[in, out] ULONG * pulFrequency
);
HRESULT
put_Polarity (
[in] ULONG * pulPolarity
);
HRESULT
get_Polarity (
[in, out] ULONG * pulPolarity
);
HRESULT
put_Range (
[in] ULONG * pulRange
);
HRESULT
get_Range (
[in, out] ULONG * pulRange
);
}
//---------------------------------------------------------------------
// IBDA_AutoDemodulate interface
//---------------------------------------------------------------------
[
object,
uuid(DDF15B12-BD25-11d2-9CA0-00C04F7971E0),
pointer_default(unique)
]
interface IBDA_AutoDemodulate : IUnknown
{
HRESULT
put_AutoDemodulate (
void
);
}
//---------------------------------------------------------------------
// IBDA_DigitalDemodulator interface
//---------------------------------------------------------------------
[
object,
uuid(EF30F379-985B-4d10-B640-A79D5E04E1E0),
pointer_default(unique)
]
interface IBDA_DigitalDemodulator : IUnknown
{
HRESULT
put_ModulationType (
[in] ModulationType * pModulationType
);
HRESULT
get_ModulationType (
[in, out] ModulationType * pModulationType
);
HRESULT
put_InnerFECMethod (
[in] FECMethod * pFECMethod
);
HRESULT
get_InnerFECMethod (
[in, out] FECMethod * pFECMethod
);
HRESULT
put_InnerFECRate (
[in] BinaryConvolutionCodeRate * pFECRate
);
HRESULT
get_InnerFECRate (
[in, out] BinaryConvolutionCodeRate * pFECRate
);
HRESULT
put_OuterFECMethod (
[in] FECMethod * pFECMethod
);
HRESULT
get_OuterFECMethod (
[in, out] FECMethod * pFECMethod
);
HRESULT
put_OuterFECRate (
[in] BinaryConvolutionCodeRate * pFECRate
);
HRESULT
get_OuterFECRate (
[in, out] BinaryConvolutionCodeRate * pFECRate
);
HRESULT
put_SymbolRate (
[in] ULONG * pSymbolRate
);
HRESULT
get_SymbolRate (
[in, out] ULONG * pSymbolRate
);
HRESULT
put_SpectralInversion (
[in] SpectralInversion * pSpectralInversion
);
HRESULT
get_SpectralInversion (
[in, out] SpectralInversion * pSpectralInversion
);
}
typedef enum
{
KSPROPERTY_IPSINK_MULTICASTLIST,
KSPROPERTY_IPSINK_ADAPTER_DESCRIPTION,
KSPROPERTY_IPSINK_ADAPTER_ADDRESS
} KSPROPERTY_IPSINK;
//---------------------------------------------------------------------
// IBDA_IPSinkControl interface
//---------------------------------------------------------------------
[
object,
uuid(3F4DC8E2-4050-11d3-8F4B-00C04F7971E2),
pointer_default(unique)
]
interface IBDA_IPSinkControl : IUnknown
{
HRESULT GetMulticastList (
[in, out] unsigned long *pulcbSize,
[in, out] BYTE **pbBuffer
);
HRESULT GetAdapterIPAddress (
[in,out] unsigned long *pulcbSize,
[in,out] BYTE **pbBuffer
);
}
//
// mpeg-2 demultiplexer-specific interfaces follow
//
//---------------------------------------------------------------------
// IEnumPIDMap interface
//---------------------------------------------------------------------
#ifdef REMOVE_THESE
typedef enum {
MEDIA_TRANSPORT_PACKET, // complete TS packet e.g. pass-through mode
MEDIA_ELEMENTARY_STREAM, // PES payloads; audio/video only
MEDIA_MPEG2_PSI, // PAT, PMT, CAT, Private
MEDIA_TRANSPORT_PAYLOAD // gathered TS packet payloads (PES packets, etc...)
} MEDIA_SAMPLE_CONTENT ;
typedef struct {
ULONG ulPID ;
MEDIA_SAMPLE_CONTENT MediaSampleContent ;
} PID_MAP ;
#endif // REMOVE_THESE
[
object,
uuid (afb6c2a2-2c41-11d3-8a60-0000f81e0e4a),
pointer_default(unique)
]
interface IEnumPIDMap : IUnknown
{
HRESULT
Next (
[in] ULONG cRequest,
[in, out, size_is (cRequest)] PID_MAP * pPIDMap,
[out] ULONG * pcReceived
) ;
HRESULT
Skip (
[in] ULONG cRecords
) ;
HRESULT
Reset (
) ;
HRESULT
Clone (
[out] IEnumPIDMap ** ppIEnumPIDMap
) ;
} ;
//---------------------------------------------------------------------
// IMPEG2PIDMap interface
//---------------------------------------------------------------------
[
object,
uuid (afb6c2a1-2c41-11d3-8a60-0000f81e0e4a),
pointer_default(unique)
]
interface IMPEG2PIDMap : IUnknown
{
HRESULT
MapPID (
[in] ULONG culPID,
[in] ULONG * pulPID,
[in] MEDIA_SAMPLE_CONTENT MediaSampleContent
) ;
HRESULT
UnmapPID (
[in] ULONG culPID,
[in] ULONG * pulPID
) ;
HRESULT
EnumPIDMap (
[out] IEnumPIDMap ** pIEnumPIDMap
) ;
} ;

View File

@@ -0,0 +1,912 @@
//==========================================================================;
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
// KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
// PURPOSE.
//
// Copyright (c) 1992 - 1999 Microsoft Corporation. All Rights Reserved.
//
//--------------------------------------------------------------------------;
// Neutral/English language type library for basic Quartz control interfaces
// the quartz type library defines the basic control interfaces
[
uuid(56a868b0-0ad4-11ce-b03a-0020af0ba770),
helpstring("ActiveMovie control type library"),
lcid(0x0000),
version(1.0)
]
library QuartzTypeLib
{
importlib("STDOLE32.TLB");
// types are restricted to be automation-compatible
typedef double REFTIME; // ReferenceTime
typedef LONG_PTR OAEVENT; // should be a HANDLE
typedef LONG_PTR OAHWND; // should be an hwnd
// from strmif.idl
typedef long OAFilterState;
// collection interface - represents a collection of IUnknowns
// this is used below to collect filter-info objects, registry-filters
// pin-info objects and wrapped media type objects
[
uuid(56a868b9-0ad4-11ce-b03a-0020af0ba770),
helpstring("Collection"),
odl,
oleautomation,
dual
]
interface IAMCollection : IDispatch
{
// number of items in collection
[propget]
HRESULT Count(
[out, retval] LONG* plCount);
// return IUnknown for contained item by index
HRESULT Item(
[in] long lItem,
[out] IUnknown** ppUnk);
// return IUnknown for an object that implements IEnumVARIANT on
// this collection
[propget]
HRESULT _NewEnum(
[out, retval] IUnknown** ppUnk);
}
// core control providing state control
[
uuid(56a868b1-0ad4-11ce-b03a-0020af0ba770),
helpstring("IMediaControl interface"),
odl,
oleautomation,
dual
]
interface IMediaControl : IDispatch
{
// methods
HRESULT Run();
HRESULT Pause();
HRESULT Stop();
//returns the state. same semantics as IMediaFilter::GetState
HRESULT GetState(
[in] LONG msTimeout,
[out] OAFilterState* pfs);
// adds and connects filters needed to play the specified file
// (same as IFilterGraph::RenderFile)
HRESULT RenderFile(
[in] BSTR strFilename);
// adds to the graph the source filter that can read this file,
// and returns an IFilterInfo object for it (actually returns
// an IDispatch for the IFilterInfo object).
HRESULT AddSourceFilter(
[in] BSTR strFilename,
[out] IDispatch**ppUnk);
// get a collection of IFilterInfo objects representing the
// filters in the graph (returns IDispatch for an object
// that supports IAMCollection
[propget]
HRESULT FilterCollection(
[out, retval] IDispatch** ppUnk);
// get a collection of IRegFilter objects representing the
// filters available in the registry
[propget]
HRESULT RegFilterCollection(
[out, retval] IDispatch** ppUnk);
HRESULT StopWhenReady();
}
// provides an event notification scheme passing events
// asynchronously to applications. See also IMediaEventSink in
// strmif.idl and sdk\h\evcodes.h.
//
// this interface behaves as if events are held on a queue. A call to
// IMediaEventSink::Notify will place an event on this queue. Calling
// GetEvent removes the first item off the queue and returns it. Items are
// returned in the order they were queued (there is no priority scheme).
// The event handle is in a signalled state iff the queue is non-empty.
//
// Apps that issue multiple Run calls without always picking up the
// completion events are advised to call GetEvent or WaitForCompletion
// (with a 0 timeout) repeatedly to remove all events from the queue
// when in stopped or paused state before each Run method.
//
// Parameters to events are actually LONG, IUnknown* or BSTR. You need to
// look at evcode.h for details of parameters to a specific event code.
// In order to correctly free resources, always call FreeEventParams
// after receiving an event.
//
[
uuid(56a868b6-0ad4-11ce-b03a-0020af0ba770),
helpstring("IMediaEvent interface"),
odl,
oleautomation,
dual
]
interface IMediaEvent : IDispatch
{
// get back the event handle. This is manual-reset
// (don't - it's reset by the event mechanism) and remains set
// when events are queued, and reset when the queue is empty.
HRESULT GetEventHandle(
[out] OAEVENT * hEvent);
// remove the next event notification from the head of the queue and
// return it. Waits up to msTimeout millisecs if there are no events.
// if a timeout occurs without any events, this method will return
// E_ABORT, and the value of the event code and other parameters
// is undefined.
//
// If this call returns successfully the caller MUST call
// FreeEventParams(lEventCode, lParam1, lParam2) to release
// resources held inside the event arguments
//
HRESULT GetEvent(
[out] long * lEventCode,
[out] LONG_PTR * lParam1,
[out] LONG_PTR * lParam2,
[in] long msTimeout
);
// Calls GetEvent repeatedly discarding events until it finds a
// completion event (EC_COMPLETE, EC_ERRORABORT, or EC_USERABORT).
// The completion event is removed from the queue and returned
// in pEvCode. Note that the object is still in running mode until
// a Pause or Stop call is made.
// If the timeout occurs, *pEvCode will be 0 and E_ABORT will be
// returned.
HRESULT WaitForCompletion(
[in] long msTimeout,
[out] long * pEvCode);
// cancels any system handling of the specified event code
// and ensures that the events are passed straight to the application
// (via GetEvent) and not handled. A good example of this is
// EC_REPAINT: default handling for this ensures the painting of the
// window and does not get posted to the app.
HRESULT CancelDefaultHandling(
[in] long lEvCode);
// restore the normal system default handling that may have been
// cancelled by CancelDefaultHandling().
HRESULT RestoreDefaultHandling( [in] long lEvCode);
// Free any resources associated with the parameters to an event.
// Event parameters may be LONGs, IUnknown* or BSTR. No action
// is taken with LONGs. IUnknown are passed addrefed and need a
// Release call. BSTR are allocated by the task allocator and will be
// freed by calling the task allocator.
HRESULT FreeEventParams(
[in] long lEvCode,
[in] LONG_PTR lParam1,
[in] LONG_PTR lParam2
);
}
[
uuid(56a868c0-0ad4-11ce-b03a-0020af0ba770),
helpstring("IMediaEventEx interface"),
odl
]
interface IMediaEventEx : IMediaEvent
{
// Register a window to send messages to when events occur
// Parameters:
//
// hwnd - handle of window to notify -
// pass NULL to stop notification
// lMsg - Message id to pass messages with
// lInstanceData - will come back in lParam
//
// The event information must still be retrived by a call
// to GetEvent when the window message is received.
//
// Multiple events may be notified with one window message.
//
HRESULT SetNotifyWindow(
[in] OAHWND hwnd,
[in] long lMsg,
[in] LONG_PTR lInstanceData
);
// Turn events notification on or off
// lNoNotify = 0x00 event notification is ON
// lNoNotify = 0x01 event notification is OFF. The
// handle returned by GetEventHandle will be signalled at
// end of stream
HRESULT SetNotifyFlags(
[in] long lNoNotifyFlags
);
HRESULT GetNotifyFlags(
[out] long *lplNoNotifyFlags
);
}
// seek/cueing for positional media
[
uuid(56a868b2-0ad4-11ce-b03a-0020af0ba770),
helpstring("IMediaPosition interface"),
odl,
oleautomation,
dual
]
interface IMediaPosition : IDispatch
{
// properties
[propget]
HRESULT Duration(
[out, retval] REFTIME* plength);
[propput]
HRESULT CurrentPosition(
[in] REFTIME llTime);
[propget]
HRESULT CurrentPosition(
[out, retval] REFTIME* pllTime);
[propget]
HRESULT StopTime(
[out, retval] REFTIME* pllTime);
[propput]
HRESULT StopTime(
[in] REFTIME llTime);
[propget]
HRESULT PrerollTime(
[out, retval] REFTIME* pllTime);
[propput]
HRESULT PrerollTime(
[in] REFTIME llTime);
[propput]
HRESULT Rate(
[in] double dRate);
[propget]
HRESULT Rate(
[out, retval] double * pdRate);
HRESULT CanSeekForward([out, retval] LONG *pCanSeekForward);
HRESULT CanSeekBackward([out, retval] LONG *pCanSeekBackward);
}
// basic audio-related functionality
[
uuid(56a868b3-0ad4-11ce-b03a-0020af0ba770),
helpstring("IBasicAudio interface"),
odl,
oleautomation,
dual
]
interface IBasicAudio : IDispatch
{
// properties
[propput]
HRESULT Volume(
[in] long lVolume);
[propget]
HRESULT Volume(
[out, retval] long * plVolume);
[propput]
HRESULT Balance(
[in] long lBalance);
[propget]
HRESULT Balance(
[out, retval] long * plBalance);
}
// basic window-related functionality
[
uuid(56a868b4-0ad4-11ce-b03a-0020af0ba770),
helpstring("IVideoWindow interface"),
odl,
oleautomation,
dual
]
interface IVideoWindow : IDispatch
{
// properties
// set and get the window title caption
[propput]
HRESULT Caption([in] BSTR strCaption);
[propget]
HRESULT Caption([out, retval] BSTR *strCaption);
// change the window styles (as per Win32)
[propput]
HRESULT WindowStyle([in] long WindowStyle);
[propget]
HRESULT WindowStyle([out, retval] long *WindowStyle);
// change the extended window styles (as per Win32)
[propput]
HRESULT WindowStyleEx([in] long WindowStyleEx);
[propget]
HRESULT WindowStyleEx([out, retval] long *WindowStyleEx);
[propput]
HRESULT AutoShow([in] long AutoShow);
[propget]
HRESULT AutoShow([out, retval] long *AutoShow);
// change the window state (as per Win32)
[propput]
HRESULT WindowState([in] long WindowState);
[propget]
HRESULT WindowState([out, retval] long *WindowState);
// realise the palette in the background
[propput]
HRESULT BackgroundPalette([in] long BackgroundPalette);
[propget]
HRESULT BackgroundPalette([out, retval] long *pBackgroundPalette);
// affect the visibility of the window
[propput]
HRESULT Visible([in] long Visible);
[propget]
HRESULT Visible([out, retval] long *pVisible);
// change the desktop position of the video window
[propput]
HRESULT Left([in] long Left);
[propget]
HRESULT Left([out, retval] long *pLeft);
[propput]
HRESULT Width([in] long Width);
[propget]
HRESULT Width([out, retval] long *pWidth);
[propput]
HRESULT Top([in] long Top);
[propget]
HRESULT Top([out, retval] long *pTop);
[propput]
HRESULT Height([in] long Height);
[propget]
HRESULT Height([out, retval] long *pHeight);
// change the owning window of the video
[propput]
HRESULT Owner([in] OAHWND Owner);
[propget]
HRESULT Owner([out, retval] OAHWND *Owner);
// change the window to receive posted messages
[propput]
HRESULT MessageDrain([in] OAHWND Drain);
[propget]
HRESULT MessageDrain([out, retval] OAHWND *Drain);
[propget]
HRESULT BorderColor([out, retval] long *Color);
[propput]
HRESULT BorderColor([in] long Color);
[propget]
HRESULT FullScreenMode([out, retval] long *FullScreenMode);
[propput]
HRESULT FullScreenMode([in] long FullScreenMode);
// methods
// ask the renderer to grab it's window the foreground
// and optionally also give the window the input focus
HRESULT SetWindowForeground([in] long Focus);
// owners should pass WM_PALETTECHANGED and WM_SYSCOLORCHANGE
// messages on the filter graph so they can be distributed
// otherwise child renderers never see these messages go by
HRESULT NotifyOwnerMessage([in] OAHWND hwnd,
[in] long uMsg,
[in] LONG_PTR wParam,
[in] LONG_PTR lParam
);
// get and set the window position on the desktop
HRESULT SetWindowPosition([in] long Left,
[in] long Top,
[in] long Width,
[in] long Height);
HRESULT GetWindowPosition([out] long *pLeft,
[out] long *pTop,
[out] long *pWidth,
[out] long *pHeight);
// get the ideal sizes for the video image playback (client) area
HRESULT GetMinIdealImageSize([out] long *pWidth,[out] long *pHeight);
HRESULT GetMaxIdealImageSize([out] long *pWidth,[out] long *pHeight);
// get the restored window size when we're maximised or iconic
HRESULT GetRestorePosition([out] long *pLeft,
[out] long *pTop,
[out] long *pWidth,
[out] long *pHeight);
// show and hide cursors useful when fullscreen
HRESULT HideCursor([in] long HideCursor);
HRESULT IsCursorHidden([out] long *CursorHidden);
}
// basic video-related functionality
[
uuid(56a868b5-0ad4-11ce-b03a-0020af0ba770),
helpstring("IBasicVideo interface"),
odl,
oleautomation,
dual
]
interface IBasicVideo : IDispatch
{
// properties
// Video specific (approximate) bit and frame rates
[propget]
HRESULT AvgTimePerFrame([out, retval] REFTIME *pAvgTimePerFrame);
[propget]
HRESULT BitRate([out, retval] long *pBitRate);
[propget]
HRESULT BitErrorRate([out, retval] long *pBitErrorRate);
// read the native video size
[propget]
HRESULT VideoWidth([out, retval] long *pVideoWidth);
[propget]
HRESULT VideoHeight([out, retval] long *pVideoHeight);
// change the source rectangle for the video
[propput]
HRESULT SourceLeft([in] long SourceLeft);
[propget]
HRESULT SourceLeft([out, retval] long *pSourceLeft);
[propput]
HRESULT SourceWidth([in] long SourceWidth);
[propget]
HRESULT SourceWidth([out, retval] long *pSourceWidth);
[propput]
HRESULT SourceTop([in] long SourceTop);
[propget]
HRESULT SourceTop([out, retval] long *pSourceTop);
[propput]
HRESULT SourceHeight([in] long SourceHeight);
[propget]
HRESULT SourceHeight([out, retval] long *pSourceHeight);
// change the destination rectangle for the video
[propput]
HRESULT DestinationLeft([in] long DestinationLeft);
[propget]
HRESULT DestinationLeft([out, retval] long *pDestinationLeft);
[propput]
HRESULT DestinationWidth([in] long DestinationWidth);
[propget]
HRESULT DestinationWidth([out, retval] long *pDestinationWidth);
[propput]
HRESULT DestinationTop([in] long DestinationTop);
[propget]
HRESULT DestinationTop([out, retval] long *pDestinationTop);
[propput]
HRESULT DestinationHeight([in] long DestinationHeight);
[propget]
HRESULT DestinationHeight([out, retval] long *pDestinationHeight);
// methods
// get and set the source rectangle position
HRESULT SetSourcePosition([in] long Left,
[in] long Top,
[in] long Width,
[in] long Height);
HRESULT GetSourcePosition([out] long *pLeft,
[out] long *pTop,
[out] long *pWidth,
[out] long *pHeight);
HRESULT SetDefaultSourcePosition();
// get and set the destination rectangle position
HRESULT SetDestinationPosition([in] long Left,
[in] long Top,
[in] long Width,
[in] long Height);
HRESULT GetDestinationPosition([out] long *pLeft,
[out] long *pTop,
[out] long *pWidth,
[out] long *pHeight);
HRESULT SetDefaultDestinationPosition();
// get the native video dimensions
HRESULT GetVideoSize([out] long *pWidth,[out] long *pHeight);
// get all or some of the current video palette
HRESULT GetVideoPaletteEntries([in] long StartIndex,
[in] long Entries,
[out] long *pRetrieved,
[out] long *pPalette);
HRESULT GetCurrentImage([in,out] long *pBufferSize,
[out] long *pDIBImage);
// are we using a default source or destination
HRESULT IsUsingDefaultSource();
HRESULT IsUsingDefaultDestination();
}
// interface extension to IBasicVideo to return preferred aspect ratio
[
uuid(329bb360-f6ea-11d1-9038-00a0c9697298),
helpstring("IBasicVideo2"),
odl
]
interface IBasicVideo2 : IBasicVideo
{
// This may not match the native video dimensions because of
// non-square pixels or whatever.
// The video may not always be displayed in the preferred
// aspect ratio for performance reasons
HRESULT GetPreferredAspectRatio([out] long *plAspectX,
[out] long *plAspectY);
}
// interface returned to a command that has been queued via IQueueCommand
[
uuid(56a868b8-0ad4-11ce-b03a-0020af0ba770),
helpstring("IDeferredCommand"),
odl
]
interface IDeferredCommand : IUnknown
{
HRESULT Cancel();
HRESULT Confidence(
[out] LONG* pConfidence);
HRESULT Postpone(
[in] REFTIME newtime);
// return value is S_OK if completed. phrResult is set to the
// result of the deferred command.
HRESULT GetHResult(
[out] HRESULT* phrResult);
};
// queue an IDispatch-based command for execution at a specified time
[
uuid(56a868b7-0ad4-11ce-b03a-0020af0ba770),
helpstring("IQueueCommand"),
odl
]
interface IQueueCommand : IUnknown
{
HRESULT InvokeAtStreamTime(
[out] IDeferredCommand** pCmd,
[in] REFTIME time, // at this streamtime
[in] GUID* iid, // call this interface
[in] long dispidMethod, // ..and this method
[in] short wFlags, // method/property
[in] long cArgs, // count of args
[in] VARIANT* pDispParams, // actual args
[in, out] VARIANT* pvarResult, // return value
[out] short* puArgErr // which arg in error
);
HRESULT InvokeAtPresentationTime(
[out] IDeferredCommand** pCmd,
[in] REFTIME time, // at this presentation time
[in] GUID* iid, // call this interface
[in] long dispidMethod, // ..and this method
[in] short wFlags, // method/property
[in] long cArgs, // count of args
[in] VARIANT* pDispParams, // actual args
[in, out] VARIANT* pvarResult, // return value
[out] short* puArgErr // which arg in error
);
};
// the filgraph object (CLSID_Filgraph)
[
uuid(e436ebb3-524f-11ce-9f53-0020af0ba770),
helpstring("Filtergraph type info")
]
coclass FilgraphManager
{
[default] interface IMediaControl;
interface IMediaEvent;
interface IMediaPosition;
interface IBasicAudio;
interface IBasicVideo;
interface IVideoWindow;
};
// represents a filter (you can't QI for IBaseFilter from this object)
[
uuid(56a868ba-0ad4-11ce-b03a-0020af0ba770),
helpstring("FilterInfo"),
odl,
oleautomation,
dual
]
interface IFilterInfo : IDispatch
{
// find a pin given an id - returns an object supporting
// IPinInfo
HRESULT FindPin(
[in] BSTR strPinID,
[out] IDispatch** ppUnk);
// filter name
[propget]
HRESULT Name(
[out, retval] BSTR* strName);
// Vendor info string
[propget]
HRESULT VendorInfo(
[out, retval] BSTR* strVendorInfo);
// returns the actual filter object (supports IBaseFilter)
[propget]
HRESULT Filter(
[out, retval] IUnknown **ppUnk);
// returns an IAMCollection object containing the PinInfo objects
// for this filter
[propget]
HRESULT Pins(
[out, retval] IDispatch ** ppUnk);
// returns -1 if true or 0 if false (OATRUE/FALSE)
[propget]
HRESULT IsFileSource(
[out, retval] LONG * pbIsSource);
[propget]
HRESULT Filename(
[out, retval] BSTR* pstrFilename);
[propput]
HRESULT Filename(
[in] BSTR strFilename);
}
[
uuid(56a868bb-0ad4-11ce-b03a-0020af0ba770),
helpstring("Registry Filter Info"),
odl,
oleautomation,
dual
]
interface IRegFilterInfo : IDispatch
{
// get the name of this filter
[propget]
HRESULT Name(
[out, retval] BSTR* strName);
// make an instance of this filter, add it to the graph and
// return an IFilterInfo for it.
HRESULT Filter(
[out] IDispatch** ppUnk);
}
// wrapper for a media type
[
uuid(56a868bc-0ad4-11ce-b03a-0020af0ba770),
helpstring("Media Type"),
odl,
oleautomation,
dual
]
interface IMediaTypeInfo : IDispatch
{
// get the major type GUID as a string
[propget]
HRESULT Type(
[out, retval] BSTR* strType);
// get the subtype GUID as a string
[propget]
HRESULT Subtype(
[out, retval] BSTR* strType);
}
[
uuid(56a868bd-0ad4-11ce-b03a-0020af0ba770),
helpstring("Pin Info"),
odl,
oleautomation,
dual
]
interface IPinInfo : IDispatch
{
// get the pin object (IUnknown for an object that
// supports IPin
[propget]
HRESULT Pin(
[out, retval] IUnknown** ppUnk);
// get the PinInfo object for the pin we are connected to
[propget]
HRESULT ConnectedTo(
[out, retval] IDispatch** ppUnk);
// get the media type on this connection - returns an
// object supporting IMediaTypeInfo
[propget]
HRESULT ConnectionMediaType(
[out, retval] IDispatch** ppUnk);
// return the FilterInfo object for the filter this pin
// is part of
[propget]
HRESULT FilterInfo(
[out, retval] IDispatch** ppUnk);
// get the name of this pin
[propget]
HRESULT Name(
[out, retval] BSTR* ppUnk);
// pin direction
[propget]
HRESULT Direction(
[out, retval] LONG *ppDirection);
// PinID - can pass to IFilterInfo::FindPin
[propget]
HRESULT PinID(
[out, retval] BSTR* strPinID);
// collection of preferred media types (IAMCollection)
[propget]
HRESULT MediaTypes(
[out, retval] IDispatch** ppUnk);
// Connect to the following pin, using other transform
// filters as necessary. pPin can support either IPin or IPinInfo
HRESULT Connect(
[in] IUnknown* pPin);
// Connect directly to the following pin, not using any intermediate
// filters
HRESULT ConnectDirect(
[in] IUnknown* pPin);
// Connect directly to the following pin, using the specified
// media type only. pPin is an object that must support either
// IPin or IPinInfo, and pMediaType must support IMediaTypeInfo.
HRESULT ConnectWithType(
[in] IUnknown * pPin,
[in] IDispatch * pMediaType);
// disconnect this pin and the corresponding connected pin from
// each other. (Calls IPin::Disconnect on both pins).
HRESULT Disconnect(void);
// render this pin using any necessary transform and rendering filters
HRESULT Render(void);
}
//--------------------------------------------------------------------
//
// IAMStats - statistics
//
// Note that the calls using an index are likely to be much faster
//--------------------------------------------------------------------
[
uuid(bc9bcf80-dcd2-11d2-abf6-00a0c905f375),
helpstring("Statistics"),
odl,
oleautomation,
dual
]
interface IAMStats : IDispatch {
// Reset all stats
HRESULT Reset();
// Get number of stats collected
[propget]
HRESULT Count(
[out, retval] LONG* plCount);
// Pull out a specific value by position
HRESULT GetValueByIndex([in] long lIndex,
[out] BSTR *szName,
[out] long *lCount,
[out] double *dLast,
[out] double *dAverage,
[out] double *dStdDev,
[out] double *dMin,
[out] double *dMax);
// Pull out a specific value by name
HRESULT GetValueByName([in] BSTR szName,
[out] long *lIndex,
[out] long *lCount,
[out] double *dLast,
[out] double *dAverage,
[out] double *dStdDev,
[out] double *dMin,
[out] double *dMax);
// The calls below are for generators of statistics
// Return the index for a string - optinally create
HRESULT GetIndex([in] BSTR szName,
[in] long lCreate,
[out] long *plIndex);
// Add a new value
HRESULT AddValue([in] long lIndex,
[in] double dValue);
}
};

View File

@@ -0,0 +1,86 @@
//------------------------------------------------------------------------------
// File: DDStream.idl
//
// Desc:
//
// Copyright (c) 1998 - 2000, Microsoft Corporation. All rights reserved.
//------------------------------------------------------------------------------
import "unknwn.idl";
import "mmstream.idl";
cpp_quote("//")
cpp_quote("// The following declarations within the 'if 0' block are dummy typedefs used to make")
cpp_quote("// the ddstream.idl file build. The actual definitions are contained in DDRAW.H")
cpp_quote("//")
cpp_quote("#if 0")
typedef void * LPDDSURFACEDESC;
typedef struct tDDSURFACEDESC DDSURFACEDESC;
cpp_quote("#endif")
cpp_quote("#include <ddraw.h>")
enum {
DDSFF_PROGRESSIVERENDER = 0x00000001
};
interface IDirectDraw;
interface IDirectDrawSurface;
interface IDirectDrawPalette;
interface IDirectDrawMediaStream;
interface IDirectDrawStreamSample;
// IDirectDrawMediaStream
[
object,
local,
uuid(F4104FCE-9A70-11d0-8FDE-00C04FD9189D),
pointer_default(unique)
]
interface IDirectDrawMediaStream : IMediaStream
{
HRESULT GetFormat(
[out] DDSURFACEDESC *pDDSDCurrent,
[out] IDirectDrawPalette **ppDirectDrawPalette,
[out] DDSURFACEDESC *pDDSDDesired,
[out] DWORD *pdwFlags);
HRESULT SetFormat(
[in] const DDSURFACEDESC *pDDSurfaceDesc,
[in] IDirectDrawPalette *pDirectDrawPalette);
HRESULT GetDirectDraw(
[out] IDirectDraw **ppDirectDraw);
HRESULT SetDirectDraw(
[in] IDirectDraw *pDirectDraw);
HRESULT CreateSample(
[in] IDirectDrawSurface *pSurface,
[in] const RECT *pRect,
[in] DWORD dwFlags,
[out]IDirectDrawStreamSample **ppSample);
HRESULT GetTimePerFrame(
[out] STREAM_TIME *pFrameTime);
};
// IDirectDrawStreamSample
[
object,
local,
uuid(F4104FCF-9A70-11d0-8FDE-00C04FD9189D),
pointer_default(unique)
]
interface IDirectDrawStreamSample : IStreamSample
{
HRESULT GetSurface(
[out] IDirectDrawSurface ** ppDirectDrawSurface,
[out] RECT * pRect);
HRESULT SetRect(
[in] const RECT * pRect);
};

View File

@@ -0,0 +1,30 @@
//------------------------------------------------------------------------------
// File: DevEnum.idl
//
// Desc: IDL source for devenum.dll. This file will be processed by the
// MIDL tool to produce the type library (devenum.tlb) and marshalling
// code.
//
// Copyright (c) 1998 - 2000, Microsoft Corporation. All rights reserved.
//------------------------------------------------------------------------------
cpp_quote("#define CDEF_CLASS_DEFAULT 0x0001")
cpp_quote("#define CDEF_BYPASS_CLASS_MANAGER 0x0002")
//cpp_quote("#define CDEF_CLASS_LEGACY 0x0004")
cpp_quote("#define CDEF_MERIT_ABOVE_DO_NOT_USE 0x0008")
[
object,
uuid(29840822-5B84-11D0-BD3B-00A0C911CE86),
pointer_default(unique)
]
interface ICreateDevEnum : IUnknown
{
import "oaidl.idl";
HRESULT CreateClassEnumerator(
[in] REFCLSID clsidDeviceClass,
[out] IEnumMoniker ** ppEnumMoniker,
[in] DWORD dwFlags);
}

View File

@@ -0,0 +1,32 @@
//------------------------------------------------------------------------------
// File: DMODShow.idl
//
// Desc:
//
// Copyright (c) 1999 - 2000, Microsoft Corporation. All rights reserved.
//------------------------------------------------------------------------------
import "unknwn.idl";
import "objidl.idl";
import "mediaobj.idl";
// 94297043-bd82-4dfd-b0de-8177739c6d20
cpp_quote("DEFINE_GUID(CLSID_DMOWrapperFilter, 0x94297043,0xbd82,0x4dfd,0xb0,0xde,0x81,0x77,0x73,0x9c,0x6d,0x20);")
// bcd5796c-bd52-4d30-ab76-70f975b89199
cpp_quote("DEFINE_GUID(CLSID_DMOFilterCategory,0xbcd5796c,0xbd52,0x4d30,0xab,0x76,0x70,0xf9,0x75,0xb8,0x91,0x99);")
[
object,
uuid(52d6f586-9f0f-4824-8fc8-e32ca04930c2),
]
interface IDMOWrapperFilter : IUnknown
{
// Init is passed in the clsid (so it can call CoCreateInstance)
// and the catgory under which the DMO lives
// Note that catDMO can be CLSID_NULL in which case no special
// category-specific processing will be invoked in the wrapper filter
HRESULT Init(REFCLSID clsidDMO, REFCLSID catDMO);
}

View File

@@ -0,0 +1,59 @@
//------------------------------------------------------------------------------
// File: DShowASF.idl
//
// Desc:
//
// Copyright (c) 1992-2000, Microsoft Corporation. All rights reserved.
//------------------------------------------------------------------------------
import "unknwn.idl";
import "objidl.idl";
import "strmif.idl"; // for media type and time definitions
import "wmsdkidl.idl";
cpp_quote( "EXTERN_GUID( IID_IConfigAsfWriter,0x45086030,0xF7E4,0x486a,0xB5,0x04,0x82,0x6B,0xB5,0x79,0x2A,0x3B );" )
interface IConfigAsfWriter;
interface IWMProfile;
// Interface to control the ASF writer
[
object,
uuid(45086030-F7E4-486a-B504-826BB5792A3B),
pointer_default(unique)
]
interface IConfigAsfWriter : IUnknown
{
//
// The user is expected to enumerate profiles using the wmsdk IWMProfileManager
// method and then pass the desired profile index to the ASF Writer filter via this
// method. The filter will then try to configure itself for the selected profile.
//
// NOTE: These 2 XXXProfileId methods are now obsolete because they assume
// version 4.0 WMSDK profiles. To configure the filter for later profile
// versions using a profile index, use the XXXProfile methods which take
// the IWMProfile* directly.
//
HRESULT ConfigureFilterUsingProfileId([in] DWORD dwProfileId);
HRESULT GetCurrentProfileId([out] DWORD *pdwProfileId);
//
// configure using a pre-defined wmsdk profile guid
//
HRESULT ConfigureFilterUsingProfileGuid([in] REFGUID guidProfile);
HRESULT GetCurrentProfileGuid([out] GUID *pProfileGuid);
//
// Use these methods when a custom profile setup is preferred
//
HRESULT ConfigureFilterUsingProfile([in] IWMProfile * pProfile);
HRESULT GetCurrentProfile([out] IWMProfile **ppProfile);
//
// allow app to control whether or not to index file
//
HRESULT SetIndexMode( [in] BOOL bIndexFile );
HRESULT GetIndexMode( [out] BOOL *pbIndexFile );
}

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@@ -0,0 +1,318 @@
//------------------------------------------------------------------------------
// File: DynGraph.idl
//
// Desc: Dynamic graph interfaces.
//
// Copyright (c) 1999 - 2000, Microsoft Corporation. All rights reserved.
//------------------------------------------------------------------------------
interface IPinConnection;
interface IPinFlowControl;
interface IGraphConfig;
interface IGraphConfigCallback;
//--------------------------------------------------------------------
//
// IPinConnection - supported by input pins
//
//--------------------------------------------------------------------
[
local,
object,
uuid(4a9a62d3-27d4-403d-91e9-89f540e55534),
pointer_default(unique)
]
interface IPinConnection : IUnknown {
// Do you accept this type chane in your current state?
HRESULT DynamicQueryAccept([in] const AM_MEDIA_TYPE *pmt);
// Set event when EndOfStream receive - do NOT pass it on
// This condition is cancelled by a flush or Stop
HRESULT NotifyEndOfStream([in] HANDLE hNotifyEvent);
// Are you an 'end pin'
HRESULT IsEndPin();
HRESULT DynamicDisconnect();
};
//--------------------------------------------------------------------
//
// IPinFlowControl - supported by output pins
//
//--------------------------------------------------------------------
[
local,
object,
uuid(c56e9858-dbf3-4f6b-8119-384af2060deb),
pointer_default(unique)
]
interface IPinFlowControl : IUnknown {
// Block processing on this pin
HRESULT Block([in] DWORD dwBlockFlags, [in] HANDLE hEvent);
}
// block flags
enum _AM_PIN_FLOW_CONTROL_BLOCK_FLAGS {
AM_PIN_FLOW_CONTROL_BLOCK = 0x00000001, // 0 means unblock
};
// Reconnect flags
typedef enum _AM_GRAPH_CONFIG_RECONNECT_FLAGS {
AM_GRAPH_CONFIG_RECONNECT_DIRECTCONNECT = 0x00000001,
AM_GRAPH_CONFIG_RECONNECT_CACHE_REMOVED_FILTERS = 0x00000002,
AM_GRAPH_CONFIG_RECONNECT_USE_ONLY_CACHED_FILTERS = 0x00000004
} AM_GRAPH_CONFIG_RECONNECT_FLAGS;
// RemoveFilterEx flags
enum _REM_FILTER_FLAGS {
REMFILTERF_LEAVECONNECTED = 0x00000001
};
typedef enum _AM_FILTER_FLAGS {
AM_FILTER_FLAGS_REMOVABLE = 0x00000001
} AM_FILTER_FLAGS;
//--------------------------------------------------------------------
//
// IGraphConfig
//
//--------------------------------------------------------------------
[
local,
object,
uuid(03A1EB8E-32BF-4245-8502-114D08A9CB88),
pointer_default(unique)
]
interface IGraphConfig : IUnknown {
HRESULT Reconnect([in] IPin *pOutputPin,
[in] IPin *pInputPin,
[in] const AM_MEDIA_TYPE *pmtFirstConnection,
[in] IBaseFilter *pUsingFilter, // can be NULL
[in] HANDLE hAbortEvent,
[in] DWORD dwFlags);
HRESULT Reconfigure([in] IGraphConfigCallback *pCallback,
[in] PVOID pvContext,
[in] DWORD dwFlags,
[in] HANDLE hAbortEvent);
HRESULT AddFilterToCache([in] IBaseFilter *pFilter);
HRESULT EnumCacheFilter([out] IEnumFilters **pEnum);
HRESULT RemoveFilterFromCache([in]IBaseFilter *pFilter);
// Get the start time associated with the last Run() call
// If the graph is not running returns VFW_E_WRONG_STATE
HRESULT GetStartTime([out] REFERENCE_TIME *prtStart);
HRESULT PushThroughData(
[in] IPin *pOutputPin,
[in] IPinConnection *pConnection,
[in] HANDLE hEventAbort);
HRESULT SetFilterFlags([in] IBaseFilter *pFilter, [in] DWORD dwFlags);
HRESULT GetFilterFlags([in] IBaseFilter *pFilter, [out] DWORD *pdwFlags);
HRESULT RemoveFilterEx( [in] IBaseFilter *pFilter, DWORD Flags );
}
//--------------------------------------------------------------------
//
// IGraphConfigCallback
//
//--------------------------------------------------------------------
[
local,
object,
uuid(ade0fd60-d19d-11d2-abf6-00a0c905f375),
pointer_default(unique)
]
interface IGraphConfigCallback : IUnknown
{
HRESULT Reconfigure(PVOID pvContext, DWORD dwFlags);
}
// Filter Chain Definition
//
// Filter chains have the following properties:
//
// - Each filter chain has one or more filters.
//
// - Each filter in a filter chain has at most one connected input pin and one
// connected output pin. For example, filters A, C, D, F, G, H, I, J and K
// (see the diagram below) can be in a filter chain because each one has at
// most one connected input pin and one connected output pin.
//
// - Any filter in a chain is reachable by any other filter in the chain.
// For example, in the filter chain F-G-H, F can reach H by following the F-
// G connection to G and then following the G-H connection to H. Filters F
// and J cannot be in the same filter chain because J is not reachable from
// F. Anotherwords, there no sequence of connected filters between F and J.
//
// - The start filter is the only filter in the filter chain who's input
// pin is not connected to another filter in the chain. For instance, F is
// the start filter in F-G-H because F's input pin is connected to E and E
// is not in the filter chain. G's input pin is connected to F and H's is
// connected to G. Both F and G are in the filter chain.
//
// - The end filter is the only filter in the filter chain who's output pin
// is not connected to another filter in the chain. For example, in the
// filter chain J-K, K is the end filter because K's output pin is
// connected to L. J's output pin is connected to K and K is in the J-K
// filter chain.
//
//
// --->|---| |---|--->
// | C |--->| D |
// |---| |---|--->|---| |---|--->|---| |---| |---| |---|
// | A |--->| B | | E |--->| F |--->| G |--->| H |
// |---| |---|--->|---|------------>|---| |---| |---| |---|
// | I |--->
// --->|---|--->
//
// |---| |---| |---|
// | J |--->| K |--->| L |
// |---| |---| |---|
//
// Example Filter Graph
//
//
//
// IFilterChain Methods Documentation
//
// HRESULT StartChain( [in] IBaseFilter *pStartFilter, [in] IBaseFilter *pEndFilter );
//
// StartChain() switches all the filters in the chain into the running state
// If one of the filters will not switch to the running state, then all the filters
// in the chain are stopped. This method can only be called if the filter graph is
// running.
//
// Parameters:
// - pStartFilter [in]
// The first filter in the filter chain. Note that this can be the same
// filter as pEndFilter .
//
// - pEndFilter [in]
// The last filter in the filter chain. Note that this can be the same
// filter as pStartFilter. If pEndFilter is NULL then the filter chain extends
// from pStartFilter to the last downstream filter which can be in a filter chain.
// For example, IFilterChain::StartChain( A, NULL ) would start filter A.
// IFilterChain::StartChain( G, NULL ) would start filters G and H.
// IFilterChain::StartChain( C, NULL ) would start filters C and D. Finally,
// IFilterChain::StartChain( E, NULL ) would fail because E cannot be in a
// filter chain (see the Filter Chain Definition section for more information).
//
// Return Value:
// An HRESULT. See the Direct Show SDK and COM SDK documentation for more
// information on interpreting HRESULTs.
//
//
//
//
// HRESULT PauseChain( [in] IBaseFilter *pStartFilter, [in] IBaseFilter *pEndFilter );
//
// PauseChain() switches all the filters in a chain to the paused state. If it cannot
// switch one of the filtres into the paused state, all the filters in the chain are
// stopped. This method can only be called if the filter graph is paused.
//
// Parameters:
// - pStartFilter [in]
// The first filter in the filter chain. Note that this can be the same
// filter as pEndFilter .
//
// - pEndFilter [in]
// The last filter in the filter chain. Note that this can be the same
// filter as pStartFilter. If pEndFilter is NULL then the filter chain extends
// from pStartFilter to the last downstream filter which can be in a filter chain.
// For example, IFilterChain::StopChain( A, NULL ) would stop filter A.
// IFilterChain::StopChain( G, NULL ) would stop filters G and H.
// IFilterChain::StopChain( C, NULL ) would stop filters C and D. Finally,
// IFilterChain::StopChain( E, NULL ) would fail because E cannot be in a filter
// chain (see the Filter Chain Definition section for more information).
//
//
// Return Value:
// An HRESULT. See the Direct Show SDK and COM SDK documentation for more
// information on interpreting HRESULTs.
//
//
//
// HRESULT StopChain( [in] IBaseFilter *pStartFilter, [in] IBaseFilter *pEndFilter );
//
// StopChain() switches all the filters in chain to the stopped state.
//
// Parameters:
// - pStartFilter [in]
// The first filter in the filter chain. Note that this can be the same
// filter as pEndFilter .
//
// - pEndFilter [in]
// The last filter in the filter chain. Note that this can be the same
// filter as pStartFilter. If pEndFilter is NULL then the filter chain extends
// from pStartFilter to the last downstream filter which can be in a filter chain.
// For example, IFilterChain::StopChain( A, NULL ) would stop filter A.
// IFilterChain::StopChain( G, NULL ) would stop filters G and H.
// IFilterChain::StopChain( C, NULL ) would stop filters C and D. Finally,
// IFilterChain::StopChain( E, NULL ) would fail because E cannot be in a filter
// chain (see the Filter Chain Definition section for more information).
//
//
// Return Value:
// An HRESULT. See the Direct Show SDK and COM SDK documentation for more
// information on interpreting HRESULTs.
//
//
//
//
//
// HRESULT RemoveChain( [in] IBaseFilter *pStartFilter, [in] IBaseFilter *pEndFilter );
//
// RemoveChain() removes every filter in a chain from the filter graph.
// The filters can be removed while the graph is running.
//
// Parameters:
// - pStartFilter [in]
// The first filter in the filter chain. Note that this can be the same
// filter as pEndFilter .
//
// - pEndFilter [in]
// The last filter in the filter chain. Note that this can be the same
// filter as pStartFilter. If pEndFilter is NULL then the filter chain
// extends from pStartFilter to the last downstream filter which can be in a
// filter chain. For example, IFilterChain::RemoveChain( A, NULL ) would remove
// filter A from the filter graph. IFilterChain::RemoveChain( G, NULL ) would
// remove filters G and H. IFilterChain::RemoveChain( C, NULL ) would remove
// filters C and D. Finally, IFilterChain::RemoveChain( E, NULL ) would fail
// because E cannot be in a filter chain (see the Filter Chain Definition
// section for more information).
//
//
// Return Value:
// An HRESULT. See the Direct Show SDK and COM SDK documentation for more
// information on interpreting HRESULTs.
//
//
[
local,
object,
uuid(DCFBDCF6-0DC2-45f5-9AB2-7C330EA09C29),
pointer_default(unique)
]
interface IFilterChain : IUnknown
{
HRESULT StartChain( [in] IBaseFilter *pStartFilter, [in] IBaseFilter *pEndFilter );
HRESULT PauseChain( [in] IBaseFilter *pStartFilter, [in] IBaseFilter *pEndFilter );
HRESULT StopChain( [in] IBaseFilter *pStartFilter, [in] IBaseFilter *pEndFilter );
HRESULT RemoveChain( [in] IBaseFilter *pStartFilter, [in] IBaseFilter *pEndFilter );
}

View File

@@ -0,0 +1,144 @@
//------------------------------------------------------------------------------
// File: IAMovie.idl
//
// Desc:
//
// Copyright (c) 1992 - 2000, Microsoft Corporation. All rights reserved.
//------------------------------------------------------------------------------
[
object,
uuid(359ace10-7688-11cf-8b23-00805f6cef60),
pointer_default(unique)
]
interface IAMovie : IFilterGraph
{
// IGraphBuilder
// Connect these two pins directly or indirectly, using transform filters
// if necessary.
HRESULT Connect
( [in] IPin * ppinOut, // the output pin
[in] IPin * ppinIn // the input pin
);
// Connect this output pin directly or indirectly, using transform filters
// if necessary to something that will render it.
HRESULT Render
( [in] IPin * ppinOut // the output pin
);
// IMediaControl methods
HRESULT Run();
HRESULT Pause();
HRESULT Stop();
//returns the state. same semantics as IMediaFilter::GetState
HRESULT GetState(
[in] LONG msTimeout,
[out] FILTER_STATE* pfs);
// adds and connects filters needed to play the specified file
HRESULT RenderFile(
[in] LPCWSTR strFilename);
// adds to the graph the source filter that can read this file,
// and returns an IFilterInfo object for it
HRESULT AddSourceFilter(
[in] LPCWSTR strFilename,
[out] IBaseFilter ** ppUnk);
// get back the event handle. This is manual-reset
// (don't - it's reset by the event mechanism) and remains set
// when events are queued, and reset when the queue is empty.
HRESULT GetEventHandle(
[out] HEVENT * hEvent);
// remove the next event notification from the head of the queue and
// return it. Waits up to msTimeout millisecs if there are no events.
// if a timeout occurs without any events, this method will return
// E_ABORT, and the value of the event code and other parameters
// is undefined.
HRESULT GetEvent(
[out] long * lEventCode,
[out] long * lParam1,
[out] long * lParam2,
[in] long msTimeout
);
// Calls GetEvent repeatedly discarding events until it finds a
// completion event (EC_COMPLETE, EC_ERRORABORT, or EC_USERABORT).
// The completion event is removed from the queue and returned
// in pEvCode. Note that the object is still in running mode until
// a Pause or Stop call is made.
// If the timeout occurs, *pEvCode will be 0 and E_ABORT will be
// returned.
HRESULT WaitForCompletion(
[in] long msTimeout,
[out] long * pEvCode);
// cancels any system handling of the specified event code
// and ensures that the events are passed straight to the application
// (via GetEvent) and not handled. A good example of this is
// EC_REPAINT: default handling for this ensures the painting of the
// window and does not get posted to the app.
HRESULT CancelDefaultHandling(
[in] long lEvCode);
// restore the normal system default handling that may have been
// cancelled by CancelDefaultHandling().
HRESULT RestoreDefaultHandling( [in] long lEvCode);
// properties
HRESULT get_Duration(
[out] REFTIME* plength);
HRESULT put_CurrentPosition(
[in] REFTIME llTime);
HRESULT get_CurrentPosition(
[out] REFTIME* pllTime);
HRESULT get_StopTime(
[out] REFTIME* pllTime);
HRESULT put_StopTime(
[in] REFTIME llTime);
HRESULT get_PrerollTime(
[out] REFTIME* pllTime);
HRESULT put_PrerollTime(
[in] REFTIME llTime);
HRESULT put_Rate(
[in] double dRate);
HRESULT get_Rate(
[out] double * pdRate);
/* New methods */
HRESULT RemoveAllFilters();
HRESULT Play();
HRESULT PlayFile([in] LPCWSTR strFilename);
HRESULT EnumFiltersByInterface( [in] REFIID riid, [out] IEnumFilters ** ppEnum );
HRESULT EnumPins( [out] IEnumPins ** ppEnum );
HRESULT EnumPinsIn( [out] IEnumPins ** ppEnum );
HRESULT EnumPinsOut( [out] IEnumPins ** ppEnum );
HRESULT RenderAll();
HRESULT RenderNewFile( [in] LPCWSTR strFilename);
// Free any resources associated with the parameters to an event.
// Event parameters may be LONGs, IUnknown* or BSTR. No action
// is taken with LONGs. IUnknown are passed addrefed and need a
// Release call. BSTR are allocated by the task allocator and will be
// freed by calling the task allocator.
HRESULT FreeEventParams(
[in] long lEvCode,
[in] long lParam1,
[in] long lParam2);
}

View File

@@ -0,0 +1,412 @@
//------------------------------------------------------------------------------
// File: MediaObj.idl
//
// Desc: Define the interfaces for DirectX Media Objects. This file will
// be processed by the MIDL tool to produce mediaobj.h and proxy-stub
// code.
//
// Copyright (c) 1999 - 2000, Microsoft Corporation. All rights reserved.
//------------------------------------------------------------------------------
import "unknwn.idl";
import "objidl.idl";
// DMO_MEDIA_TYPE structure
cpp_quote("#ifdef __strmif_h__")
cpp_quote("typedef AM_MEDIA_TYPE DMO_MEDIA_TYPE;")
cpp_quote("#else")
typedef struct _DMOMediaType {
GUID majortype;
GUID subtype;
BOOL bFixedSizeSamples;
BOOL bTemporalCompression;
ULONG lSampleSize;
GUID formattype;
IUnknown *pUnk;
ULONG cbFormat;
[size_is(cbFormat)] BYTE * pbFormat;
} DMO_MEDIA_TYPE;
typedef LONGLONG REFERENCE_TIME;
cpp_quote("#endif")
// Per-buffer flags that apply to input buffers
enum _DMO_INPUT_DATA_BUFFER_FLAGS {
DMO_INPUT_DATA_BUFFERF_SYNCPOINT = 0x00000001,
DMO_INPUT_DATA_BUFFERF_TIME = 0x00000002,
DMO_INPUT_DATA_BUFFERF_TIMELENGTH = 0x00000004
};
// Per-buffer flags that apply to output buffers.
enum _DMO_OUTPUT_DATA_BUFFER_FLAGS {
DMO_OUTPUT_DATA_BUFFERF_SYNCPOINT = 0x00000001,
DMO_OUTPUT_DATA_BUFFERF_TIME = 0x00000002,
DMO_OUTPUT_DATA_BUFFERF_TIMELENGTH = 0x00000004,
//
// This flag means the object could have generated more data for this
// output stream, even with no additional input from any input stream,
// but the output buffer did not have sufficient room.
//
DMO_OUTPUT_DATA_BUFFERF_INCOMPLETE = 0x01000000
};
// Flags returned by GetInputStatus()
enum _DMO_INPUT_STATUS_FLAGS {
//
// ACCEPT_DATA indicates that the input stream is ready to accept
// new data via ProcessInput().
//
DMO_INPUT_STATUSF_ACCEPT_DATA = 0x00000001
};
// Flags returned by GetInputStreamInfo()
enum _DMO_INPUT_STREAM_INFO_FLAGS {
DMO_INPUT_STREAMF_WHOLE_SAMPLES = 0x00000001,
DMO_INPUT_STREAMF_SINGLE_SAMPLE_PER_BUFFER = 0x00000002,
DMO_INPUT_STREAMF_FIXED_SAMPLE_SIZE = 0x00000004,
DMO_INPUT_STREAMF_HOLDS_BUFFERS = 0x00000008
};
// Flags returned by GetOutputStreamInfo()
enum _DMO_OUTPUT_STREAM_INFO_FLAGS {
DMO_OUTPUT_STREAMF_WHOLE_SAMPLES = 0x00000001,
DMO_OUTPUT_STREAMF_SINGLE_SAMPLE_PER_BUFFER = 0x00000002,
DMO_OUTPUT_STREAMF_FIXED_SAMPLE_SIZE = 0x00000004,
DMO_OUTPUT_STREAMF_DISCARDABLE = 0x00000008,
DMO_OUTPUT_STREAMF_OPTIONAL = 0x00000010
};
// SetType flags
enum _DMO_SET_TYPE_FLAGS {
DMO_SET_TYPEF_TEST_ONLY = 0x00000001,// check but don't set
DMO_SET_TYPEF_CLEAR = 0x00000002 // unset
};
// Process Output Flags
enum _DMO_PROCESS_OUTPUT_FLAGS {
DMO_PROCESS_OUTPUT_DISCARD_WHEN_NO_BUFFER = 0x00000001 // Discard
};
// Buffer wrapper interface
[
object,
uuid(59eff8b9-938c-4a26-82f2-95cb84cdc837)
]
interface IMediaBuffer : IUnknown
{
HRESULT SetLength(
DWORD cbLength
);
HRESULT GetMaxLength(
[out] DWORD *pcbMaxLength
);
HRESULT GetBufferAndLength(
[out] BYTE **ppBuffer, // not filled if NULL
[out] DWORD *pcbLength // not filled if NULL
);
}
//
// 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 _DMO_OUTPUT_DATA_BUFFER {
IMediaBuffer *pBuffer; // [in] can be NULL
// ProcessOutput() must set any appropriate flags and zero out the rest.
DWORD dwStatus; // [out] DMO_OUTPUT_DATA_BUFFERF_XXX (INCOMPLETE, etc.)
//
// Each of these is valid if the corresponding flag is set in dwStatus
//
REFERENCE_TIME rtTimestamp; // [out]
REFERENCE_TIME rtTimelength; // [out]
} DMO_OUTPUT_DATA_BUFFER, *PDMO_OUTPUT_DATA_BUFFER;
// Interface supported by media objects
[
object,
uuid(d8ad0f58-5494-4102-97c5-ec798e59bcf4)
]
interface IMediaObject : IUnknown
{
//
// Stream enumeration
//
HRESULT GetStreamCount(
[out] DWORD *pcInputStreams,
[out] DWORD *pcOutputStreams
);
HRESULT GetInputStreamInfo(
DWORD dwInputStreamIndex, // 0-based
[out] DWORD *pdwFlags // HOLDS_BUFFERS
);
HRESULT GetOutputStreamInfo(
DWORD dwOutputStreamIndex, // 0-based
[out] DWORD *pdwFlags // Media object sets to 0
);
//
// Mediatypes
//
//
// GetType - iterate through media types supported by a stream.
// Returns S_FALSE if the type index is out of range ("no more types").
//
HRESULT GetInputType(
DWORD dwInputStreamIndex,
DWORD dwTypeIndex, // 0-based
[out] DMO_MEDIA_TYPE *pmt
);
HRESULT GetOutputType(
DWORD dwOutputStreamIndex,
DWORD dwTypeIndex, // 0-based
[out] DMO_MEDIA_TYPE *pmt
);
//
// SetType - tell the object the type of data it will work with.
//
HRESULT SetInputType(
DWORD dwInputStreamIndex,
[in] const DMO_MEDIA_TYPE *pmt,
DWORD dwFlags // test only
);
HRESULT SetOutputType(
DWORD dwOutputStreamIndex,
[in] const DMO_MEDIA_TYPE *pmt,
DWORD dwFlags // test only
);
//
// GetCurrentType - get the last mediatype supplied via SetType.
// Returns S_FALSE if SetType has not been called.
//
HRESULT GetInputCurrentType(
DWORD dwInputStreamIndex,
[out] DMO_MEDIA_TYPE *pmt
);
HRESULT GetOutputCurrentType(
DWORD dwOutputStreamIndex,
[out] DMO_MEDIA_TYPE *pmt
);
//
// SizeInfo
//
//
// GetSizeInfo - Get buffer size requirementes of a stream.
//
// If buffer size depends on the media type used, the object should
// base its response on the most recent media type set for this stream.
// If no mediatype has been set, the object may return an error.
//
HRESULT GetInputSizeInfo(
DWORD dwInputStreamIndex,
[out] DWORD *pcbSize, // size of input 'quantum'
[out] DWORD *pcbMaxLookahead, // max total bytes held
[out] DWORD *pcbAlignment // buffer alignment requirement
);
HRESULT GetOutputSizeInfo(
DWORD dwOutputStreamIndex,
[out] DWORD *pcbSize, // size of output 'quantum'
[out] DWORD *pcbAlignment // buffer alignment requirement
);
//
// Latency methods
//
HRESULT GetInputMaxLatency(
DWORD dwInputStreamIndex,
[out] REFERENCE_TIME *prtMaxLatency
);
HRESULT SetInputMaxLatency(
DWORD dwInputStreamIndex,
REFERENCE_TIME rtMaxLatency
);
//
// Streaming / state methods
//
//
// Flush() - discard any buffered data.
//
HRESULT Flush();
//
// Send a discontinuity to an input stream. The object will not
// accept any more data on this input stream until the discontinuity
// has been completely processed, which may involve multiple
// ProcessOutput() calls.
//
HRESULT Discontinuity(DWORD dwInputStreamIndex);
//
// If a streaming object needs to perform any time consuming
// initialization before it can stream data, it should do it inside
// AllocateStreamingResources() rather than during the first process
// call.
//
// This method is NOT guaranteed to be called before streaming
// starts. If it is not called, the object should perform any
// required initialization during a process call.
//
HRESULT AllocateStreamingResources();
// Free anything allocated in AllocateStreamingResources().
HRESULT FreeStreamingResources();
// GetInputStatus - the only flag defined right now is ACCEPT_DATA.
HRESULT GetInputStatus(
DWORD dwInputStreamIndex,
[out] DWORD *dwFlags // ACCEPT_DATA
);
//
// Pass one new buffer to an input stream
//
HRESULT ProcessInput(
DWORD dwInputStreamIndex,
IMediaBuffer *pBuffer, // must not be NULL
DWORD dwFlags, // DMO_INPUT_DATA_BUFFERF_XXX (syncpoint, etc.)
REFERENCE_TIME rtTimestamp, // valid if flag set
REFERENCE_TIME rtTimelength // valid if flag set
);
//
// ProcessOutput() - generate output for current input buffers
//
// Output stream specific status information is returned in the
// dwStatus member of each buffer wrapper structure.
//
HRESULT ProcessOutput(
DWORD dwFlags, // DMO_PROCESS_OUTPUT_FLAGS
DWORD cOutputBufferCount, // # returned by GetStreamCount()
[in,out,size_is(cOutputBufferCount)]
DMO_OUTPUT_DATA_BUFFER *pOutputBuffers, // one per stream
[out] DWORD *pdwStatus // TBD, must be set to 0
);
// Locking - lock if bLock is TRUE, otherwise unlock
HRESULT Lock(LONG bLock);
};
//
// Interface returned by the DMO enumeration API
//
[
object,
uuid(2c3cd98a-2bfa-4a53-9c27-5249ba64ba0f)
]
interface IEnumDMO : IUnknown {
HRESULT Next(
DWORD cItemsToFetch,
[out, size_is(cItemsToFetch), length_is(*pcItemsFetched)] CLSID *pCLSID,
[out, size_is(cItemsToFetch), length_is(*pcItemsFetched), string] WCHAR **Names,
[out] DWORD *pcItemsFetched
);
HRESULT Skip(
DWORD cItemsToSkip
);
HRESULT Reset(void);
HRESULT Clone(
[out] IEnumDMO **ppEnum
);
}
// Flags for IMediaObjectInPlace::Process
enum _DMO_INPLACE_PROCESS_FLAGS {
DMO_INPLACE_NORMAL = 0x00000000,
DMO_INPLACE_ZERO = 0x00000001
};
[
object,
uuid(651b9ad0-0fc7-4aa9-9538-d89931010741)
]
interface IMediaObjectInPlace : IUnknown {
// Proces - Given a buffer of size ulSize, put the output
// of the DMO into the same buffer.
HRESULT Process(
[in] ULONG ulSize,
[in,out,size_is(ulSize)] BYTE* pData,
[in] REFERENCE_TIME refTimeStart,
[in] DWORD dwFlags
);
// Create a copy of the In-Place Media Object. This allows
// for very fast initialization of a number of In-Place objects
// in a known state.
HRESULT Clone(
[out] IMediaObjectInPlace **ppMediaObject
);
// GetLatency - Returns a REFERENCE_TIME value
// (1 tick = 100ns) which corresponds to the latency time
// processing this effect will add to the graph. This assumes
// the effect cost per buffer is a constant.
HRESULT GetLatency(
[out] REFERENCE_TIME *pLatencyTime
);
}
// Quality control status flags
enum _DMO_QUALITY_STATUS_FLAGS {
DMO_QUALITY_STATUS_ENABLED = 0x00000001
};
[
object,
uuid(65abea96-cf36-453f-af8a-705e98f16260)
]
interface IDMOQualityControl : IUnknown {
HRESULT SetNow(
[in] REFERENCE_TIME rtNow
);
HRESULT SetStatus(
[in] DWORD dwFlags
);
HRESULT GetStatus(
[out] DWORD *pdwFlags
);
}
// Flags for IVideoOutputOptimizations
enum _DMO_VIDEO_OUTPUT_STREAM_FLAGS {
DMO_VOSF_NEEDS_PREVIOUS_SAMPLE = 0x00000001
};
[
object,
uuid(be8f4f4e-5b16-4d29-b350-7f6b5d9298ac)
]
interface IDMOVideoOutputOptimizations : IUnknown {
HRESULT QueryOperationModePreferences (
ULONG ulOutputStreamIndex,
DWORD *pdwRequestedCapabilities
);
HRESULT SetOperationMode (
ULONG ulOutputStreamIndex,
DWORD dwEnabledFeatures
);
HRESULT GetCurrentOperationMode (
ULONG ulOutputStreamIndex,
DWORD *pdwEnabledFeatures
);
HRESULT GetCurrentSampleRequirements (
ULONG ulOutputStreamIndex,
DWORD *pdwRequestedFeatures
);
}

View File

@@ -0,0 +1,228 @@
//------------------------------------------------------------------------------
// File: MedParam.idl
//
// Desc: Definition of the IMediaParams and associated interfaces. These
// interfaces are designed to allow communication of curve-following
// behaviors for parameters of objects which require dynamic changes
// to their parameters at run time. All changes are specified by
// timestamp and curve type to ensure the parameters can be set
// at sufficient accuracy with predictable behavior on subsequent
// playback of the same curves.
//
// Copyright (c) 1999 - 2000, Microsoft Corporation. All rights reserved.
//------------------------------------------------------------------------------
import "oaidl.idl";
import "ocidl.idl";
import "strmif.idl";
//------------------------------------------------------------------------------
// Define the semantic type to be used for each parameter. All values passed
// into this interface are 32-bit floats, but the interface can specify that
// the values must be integer, or booleans or enumerated types
//------------------------------------------------------------------------------
typedef float MP_DATA; // All data is 32-bit floats
typedef enum _MP_Type {
MPT_INT, // data is signed 23 bit integer (mantissa)
MPT_FLOAT, // data is 32bit IEEE float
MPT_BOOL, // data is true or false (using ANSI C++ definition)
MPT_ENUM, // data is a set (represented by consecutive integers)
MPT_MAX,
} MP_TYPE;
const MP_DATA MPBOOL_TRUE = 1.0; // Value of true
const MP_DATA MPBOOL_FALSE = 0.0; // Value of false
//------------------------------------------------------------------------------
// Define the types of curves which are supported
//------------------------------------------------------------------------------
typedef enum _MP_CURVE_TYPE {
MP_CURVE_JUMP = 0x0001, // No interpolation, just jump to next point
MP_CURVE_LINEAR = 0x0002, // Linear interpolation (y follows x from 0.0 to 1.0)
MP_CURVE_SQUARE = 0x0004, // y follow x^2 from 0.0 to 1.0
MP_CURVE_INVSQUARE = 0x0008, // y follows 1-(x^2) from 0.0 to 1.0
MP_CURVE_SINE = 0x0010, // y follows sin(x) from -pi/2 to pi/2
} MP_CURVE_TYPE;
//------------------------------------------------------------------------------
// Capability bits. Used by the object to specify what capabilities it has.
//------------------------------------------------------------------------------
typedef DWORD MP_CAPS;
// Curve capabilities - If the cap bit is set, that type of curve is supported
const MP_CAPS MP_CAPS_CURVE_JUMP = MP_CURVE_JUMP;
const MP_CAPS MP_CAPS_CURVE_LINEAR = MP_CURVE_LINEAR;
const MP_CAPS MP_CAPS_CURVE_SQUARE = MP_CURVE_SQUARE;
const MP_CAPS MP_CAPS_CURVE_INVSQUARE = MP_CURVE_INVSQUARE;
const MP_CAPS MP_CAPS_CURVE_SINE = MP_CURVE_SINE;
//------------------------------------------------------------------------------
// Structure used to return information about the type and limits of a parameter
//------------------------------------------------------------------------------
typedef struct _MP_PARAMINFO {
MP_TYPE mpType; // One of MP_TYPE_xxx codes
MP_CAPS mopCaps; // A collection of MP_CAPS flags
// Minimum and maximum values
MP_DATA mpdMinValue; // minimum legal value
MP_DATA mpdMaxValue; // maximum legal value
MP_DATA mpdNeutralValue; // default or 'center' value
// Defualt Unit and Label text. These strings will ALWAYS be English
// strings in the UNICODE character set. For international text
// use the GetParamText member function
WCHAR szUnitText[32]; // units of the parameter
WCHAR szLabel[32]; // name of the parameter
} MP_PARAMINFO;
//------------------------------------------------------------------------------
// Parameter Index types
//------------------------------------------------------------------------------
typedef DWORD DWORD;
const DWORD DWORD_ALLPARAMS = -1; // Apply this operation to all params
//------------------------------------------------------------------------------
// Defined list of timestamp types
//------------------------------------------------------------------------------
typedef DWORD MP_TIMEDATA; // Extra data to further define type
// REFERENCE_TIME (1 tick = 100 nanoseconds, MP_TIMEDATA ignored)
cpp_quote("DEFINE_GUID(GUID_TIME_REFERENCE,")
cpp_quote("0x93ad712b, 0xdaa0, 0x4ffe, 0xbc, 0x81, 0xb0, 0xce, 0x50, 0xf, 0xcd, 0xd9);")
// Music Time (MP_TIMEDATA = parts/quarter note)
cpp_quote("DEFINE_GUID(GUID_TIME_MUSIC,")
cpp_quote("0x574c49d, 0x5b04, 0x4b15, 0xa5, 0x42, 0xae, 0x28, 0x20, 0x30, 0x11, 0x7b);")
// Time is measures in samples. MP_TIMEDATA = Samples/sec)
cpp_quote("DEFINE_GUID(GUID_TIME_SAMPLES,")
cpp_quote("0xa8593d05, 0xc43, 0x4984, 0x9a, 0x63, 0x97, 0xaf, 0x9e, 0x2, 0xc4, 0xc0);")
//------------------------------------------------------------------------------
// The value of a given parameter at a specific point in time
//------------------------------------------------------------------------------
typedef DWORD MP_FLAGS;
const MP_FLAGS MPF_ENVLP_STANDARD = 0x0000; // Use all data provided
const MP_FLAGS MPF_ENVLP_BEGIN_CURRENTVAL = 0x0001;
// Ignore valStart value, use current value as the staring point
const MP_FLAGS MPF_ENVLP_BEGIN_NEUTRALVAL = 0x0002;
// Ignore valStart value, use neutral value as the staring point
typedef struct _MP_ENVELOPE_SEGMENT {
REFERENCE_TIME rtStart; // Start time in current time format
REFERENCE_TIME rtEnd; // End time in current time format
MP_DATA valStart; // Initial Value
MP_DATA valEnd; // Final Value
MP_CURVE_TYPE iCurve; // One of MP_CURVE_TYPE codes
MP_FLAGS flags; // Special cases
} MP_ENVELOPE_SEGMENT;
//------------------------------------------------------------------------------
// Define flags for Punch-in timing
//------------------------------------------------------------------------------
const MP_FLAGS MPF_PUNCHIN_REFTIME = 0; // Use the reference time as the PI time
const MP_FLAGS MPF_PUNCHIN_NOW = 0x0001; // Punch in at the current clock time
const MP_FLAGS MPF_PUNCHIN_STOPPED = 0x0002; // Return change notifications during
// author time
//------------------------------------------------------------------------------
// IMediaParamInfo - Interface used to determine the names, data types and
// units of the parameters which are exposed by the object. This interface
// is used at discovery time, and is not required during run-time since the
// objects parameters are a fixed set and this data can be cached by the
// calling applicaiton
//------------------------------------------------------------------------------
[
object,
uuid(6d6cbb60-a223-44aa-842f-a2f06750be6d),
version(1.0)
]
interface IMediaParamInfo : IUnknown
{
HRESULT GetParamCount (
[out] DWORD * pdwParams
);
HRESULT GetParamInfo (
[in] DWORD dwParamIndex,
[out] MP_PARAMINFO * pInfo
);
// returns a series of null terminated strings. strings are in the
// following order:
// Param Label, Units Text, 1st Enum Text, 2nd Enum Text, etc...
HRESULT GetParamText (
[in] DWORD dwParamIndex, // which param to get text for
[out] WCHAR **ppwchText // returns ptr to CoTaskMemAlloc'd string
);
// Returns the number of diffrent time formats this object understands
HRESULT GetNumTimeFormats (
[out] DWORD * pdwNumTimeFormats
);
// Returns the GUID for the ith supported time format
HRESULT GetSupportedTimeFormat(
[in] DWORD dwFormatIndex,
[out] GUID *pguidTimeFormat
);
// Returns the current time format
HRESULT GetCurrentTimeFormat (
[out] GUID *pguidTimeFormat,
[out] MP_TIMEDATA *pTimeData
);
}
//------------------------------------------------------------------------------
// IMediaParams - Interfaes used to actually set the media params and the
// envelopes to follow
//------------------------------------------------------------------------------
[
object,
uuid(6d6cbb61-a223-44aa-842f-a2f06750be6e),
version(1.0)
]
interface IMediaParams : IUnknown
{
// Single param Get/Set methods
HRESULT GetParam (
[in] DWORD dwParamIndex,
[out] MP_DATA *pValue
);
HRESULT SetParam (
[in] DWORD dwParamIndex,
[in] MP_DATA value
);
// Envelope methods (param change over time)
HRESULT AddEnvelope (
[in] DWORD dwParamIndex,
[in] DWORD cSegments,
[in] MP_ENVELOPE_SEGMENT * pEnvelopeSegments
);
// Flush all of the envelope information for the given paramter between
// the timestamps specified
HRESULT FlushEnvelope (
[in] DWORD dwParamIndex,
[in] REFERENCE_TIME refTimeStart,
[in] REFERENCE_TIME refTimeEnd
);
// Change the time format being used by the object
HRESULT SetTimeFormat (
[in] GUID guidTimeFormat,
[in] MP_TIMEDATA mpTimeData
);
}

View File

@@ -0,0 +1,189 @@
//------------------------------------------------------------------------------
// File: MMStream.idl
//
// Desc: MultiMedia streaming interface IDL file.
//
// Copyright (c) 1998 - 2000, Microsoft Corporation. All rights reserved.
//------------------------------------------------------------------------------
import "unknwn.idl";
cpp_quote("#define MS_ERROR_CODE(x) MAKE_HRESULT(1, FACILITY_ITF, (x) + 0x400)")
cpp_quote("#define MS_SUCCESS_CODE(x) MAKE_HRESULT(0, FACILITY_ITF, x)")
cpp_quote("#define MS_S_PENDING MS_SUCCESS_CODE(1)")
cpp_quote("#define MS_S_NOUPDATE MS_SUCCESS_CODE(2)")
cpp_quote("#define MS_S_ENDOFSTREAM MS_SUCCESS_CODE(3)")
cpp_quote("#define MS_E_SAMPLEALLOC MS_ERROR_CODE(1)")
cpp_quote("#define MS_E_PURPOSEID MS_ERROR_CODE(2)")
cpp_quote("#define MS_E_NOSTREAM MS_ERROR_CODE(3)")
cpp_quote("#define MS_E_NOSEEKING MS_ERROR_CODE(4)")
cpp_quote("#define MS_E_INCOMPATIBLE MS_ERROR_CODE(5)")
cpp_quote("#define MS_E_BUSY MS_ERROR_CODE(6)")
cpp_quote("#define MS_E_NOTINIT MS_ERROR_CODE(7)")
cpp_quote("#define MS_E_SOURCEALREADYDEFINED MS_ERROR_CODE(8)")
cpp_quote("#define MS_E_INVALIDSTREAMTYPE MS_ERROR_CODE(9)")
cpp_quote("#define MS_E_NOTRUNNING MS_ERROR_CODE(10)")
cpp_quote("// {A35FF56A-9FDA-11d0-8FDF-00C04FD9189D}")
cpp_quote("DEFINE_GUID(MSPID_PrimaryVideo, ")
cpp_quote("0xa35ff56a, 0x9fda, 0x11d0, 0x8f, 0xdf, 0x0, 0xc0, 0x4f, 0xd9, 0x18, 0x9d);")
cpp_quote("// {A35FF56B-9FDA-11d0-8FDF-00C04FD9189D}")
cpp_quote("DEFINE_GUID(MSPID_PrimaryAudio,")
cpp_quote("0xa35ff56b, 0x9fda, 0x11d0, 0x8f, 0xdf, 0x0, 0xc0, 0x4f, 0xd9, 0x18, 0x9d);")
cpp_quote("#if(_WIN32_WINNT < 0x0400)")
typedef void (__stdcall * PAPCFUNC)(DWORD_PTR dwParam);
cpp_quote("#endif")
typedef LONGLONG STREAM_TIME;
typedef GUID MSPID;
typedef REFGUID REFMSPID;
typedef enum {
STREAMTYPE_READ = 0,
STREAMTYPE_WRITE = 1,
STREAMTYPE_TRANSFORM= 2
} STREAM_TYPE;
typedef enum {
STREAMSTATE_STOP = 0,
STREAMSTATE_RUN = 1
} STREAM_STATE;
typedef enum {
COMPSTAT_NOUPDATEOK = 0x00000001,
COMPSTAT_WAIT = 0x00000002,
COMPSTAT_ABORT = 0x00000004
} COMPLETION_STATUS_FLAGS;
// Flags for GetInformation
enum {
MMSSF_HASCLOCK = 0x00000001,
MMSSF_SUPPORTSEEK = 0x00000002,
MMSSF_ASYNCHRONOUS = 0x00000004
};
// Flags for StreamSample::Update
enum {
SSUPDATE_ASYNC = 0x00000001,
SSUPDATE_CONTINUOUS = 0x00000002
};
interface IMultiMediaStream;
interface IMediaStream;
interface IStreamSample;
// IMultiMediaStream interface
[
object,
local,
uuid(B502D1BC-9A57-11d0-8FDE-00C04FD9189D),
pointer_default(unique)
]
interface IMultiMediaStream : IUnknown {
HRESULT GetInformation(
[out] DWORD *pdwFlags,
[out] STREAM_TYPE *pStreamType);
HRESULT GetMediaStream(
[in] REFMSPID idPurpose,
[out] IMediaStream **ppMediaStream);
HRESULT EnumMediaStreams(
[in] long Index,
[out] IMediaStream **ppMediaStream);
HRESULT GetState(
[out] STREAM_STATE *pCurrentState);
HRESULT SetState(
[in] STREAM_STATE NewState);
HRESULT GetTime(
[out] STREAM_TIME *pCurrentTime);
HRESULT GetDuration(
[out] STREAM_TIME *pDuration);
HRESULT Seek(
[in] STREAM_TIME SeekTime);
HRESULT GetEndOfStreamEventHandle(
[out] HANDLE *phEOS);
};
// IMediaStream interface
[
object,
uuid(B502D1BD-9A57-11d0-8FDE-00C04FD9189D),
pointer_default(unique)
]
interface IMediaStream : IUnknown {
HRESULT GetMultiMediaStream(
[out] IMultiMediaStream **ppMultiMediaStream);
HRESULT GetInformation(
[out] MSPID *pPurposeId,
[out] STREAM_TYPE *pType);
HRESULT SetSameFormat(
[in] IMediaStream *pStreamThatHasDesiredFormat,
[in] DWORD dwFlags);
HRESULT AllocateSample(
[in] DWORD dwFlags,
[out] IStreamSample **ppSample);
HRESULT CreateSharedSample(
[in] IStreamSample *pExistingSample,
[in] DWORD dwFlags,
[out] IStreamSample **ppNewSample);
HRESULT SendEndOfStream(DWORD dwFlags);
};
// IStreamSample interface
[
object,
local,
uuid(B502D1BE-9A57-11d0-8FDE-00C04FD9189D),
pointer_default(unique)
]
interface IStreamSample : IUnknown {
HRESULT GetMediaStream(
[in] IMediaStream **ppMediaStream);
HRESULT GetSampleTimes(
[out] STREAM_TIME * pStartTime,
[out] STREAM_TIME * pEndTime,
[out] STREAM_TIME * pCurrentTime);
HRESULT SetSampleTimes(
[in] const STREAM_TIME *pStartTime,
[in] const STREAM_TIME *pEndTime);
HRESULT Update(
[in] DWORD dwFlags,
[in] HANDLE hEvent,
[in] PAPCFUNC pfnAPC,
[in] DWORD_PTR dwAPCData);
HRESULT CompletionStatus(
[in] DWORD dwFlags,
[in] DWORD dwMilliseconds);
};

File diff suppressed because it is too large Load Diff

View File

@@ -0,0 +1,43 @@
//------------------------------------------------------------------------------
// File: RegBag.idl
//
// Desc: IDL source for RegBag.dll.
//
// Copyright (c) 1999 - 2000, Microsoft Corporation. All rights reserved.
//------------------------------------------------------------------------------
import "objidl.idl";
import "oaidl.idl";
import "ocidl.idl";
//*****************************************************************************
///////////////////////////////////////////////////////////////////////////////
//
// Custom Factory interface
// since com doesn't support ctors or initialization parameters on std factory interface
// we have a custom creation interface
//
///////////////////////////////////////////////////////////////////////////////
//*****************************************************************************
///////////////////////////////////////////////////////////////////////////////////////
[object,
hidden, restricted,
uuid(8A674B48-1F63-11d3-B64C-00C04F79498E),
helpstring("Create property bag backed by registry"),
pointer_default(unique),
local
]
interface ICreatePropBagOnRegKey : IUnknown {
// NOTE: it is up to the caller to set the correct registry access based on the interface
// and methods the caller intends to use
// IPropertyBag2::GetPropertyInfo and CountProperties require both KEY_QUERY_VALUE and KEY_ENUMERATE_SUBKEYS
// IPropertyBagXXX::Read requires KEY_READ
// IPropertyBagXXX::Write requires KEY_WRITE
// also, you must CoTaskMemFree the name string from GetPropertyInfo
// if you write a value of VT_EMPTY or VT_NULL the property will be removed from the bag and the corresponding
// registry info will be deleted.
HRESULT Create([in] HKEY hkey, [in] LPCOLESTR subkey, [in] DWORD ulOptions, [in] DWORD samDesired, REFIID iid, [out] LPVOID *ppBag);
};

View File

@@ -0,0 +1,28 @@
//------------------------------------------------------------------------------
// File: StrmIf.idl
//
// Desc: ActiveMovie interface definitions.
//
// Copyright (c) 1992 - 2000, Microsoft Corporation. All rights reserved.
//------------------------------------------------------------------------------
import "unknwn.idl";
import "objidl.idl"; // for IPersist (IFilter's root)
#include "devenum.idl"
// core interfaces
#include "axcore.idl"
// extended, ActiveMovie-only interfaces
#include "axextend.idl"
// ActiveMovie-only sample plug-in distributor interface
#include "IAMovie.idl"
// application interfaces for DVD
#include "dvdif.idl"
// Dynamic graph stuff
#include "dyngraph.idl"

File diff suppressed because it is too large Load Diff

View File

@@ -0,0 +1,172 @@
//------------------------------------------------------------------------------
// File: VideoAcc.idl
//
// Desc: An interface exposed by the overlay mixer to help decode samples
// using hardware video acceleration.
//
// Copyright (c) 1992 - 2000, Microsoft Corporation. All rights reserved.
//------------------------------------------------------------------------------
import "unknwn.idl";
cpp_quote("//")
cpp_quote("// The following declarations within the 'if 0' block are dummy typedefs used to make")
cpp_quote("// the motncomp.idl file build. The actual definitions are contained in ddraw.h and amva.h")
cpp_quote("//")
cpp_quote("#if 0")
typedef void* LPVOID;
typedef void* LPGUID;
typedef void* LPDIRECTDRAWSURFACE;
typedef void* LPDDPIXELFORMAT;
typedef void* LPAMVAInternalMemInfo;
typedef void AMVAUncompDataInfo;
typedef void* LPAMVACompBufferInfo;
typedef void AMVABUFFERINFO;
typedef void AMVAEndFrameInfo;
typedef void* LPAMVAUncompBufferInfo;
typedef void AMVABeginFrameInfo;
typedef IUnknown* IMediaSample;
cpp_quote("#endif")
cpp_quote("#include <ddraw.h>")
cpp_quote("#include <amva.h>")
[
local,
object,
uuid(256A6A21-FBAD-11d1-82BF-00A0C9696C8F),
helpstring("IAMVideoAcceleratorNotify Interface"),
pointer_default(unique)
]
// IAMVideoAcceleratorNotify
interface IAMVideoAcceleratorNotify : IUnknown
{
// get information necessary to allocate uncompressed data buffers
// which is not part of the mediatype format (like how many buffers to allocate etc)
HRESULT GetUncompSurfacesInfo([in] const GUID *pGuid, [in] [out] LPAMVAUncompBufferInfo pUncompBufferInfo);
// set information regarding allocated uncompressed data buffers
HRESULT SetUncompSurfacesInfo([in] DWORD dwActualUncompSurfacesAllocated);
// get information necessary to create video accelerator object. It is the caller's responsibility
// to call CoTaskMemFree() on *ppMiscData
HRESULT GetCreateVideoAcceleratorData([in] const GUID *pGuid, [out] LPDWORD pdwSizeMiscData, [out] LPVOID *ppMiscData);
};
[
local,
object,
uuid(256A6A22-FBAD-11d1-82BF-00A0C9696C8F),
helpstring("IAMVideoAccelerator Interface"),
pointer_default(unique)
]
// IAMVideoAccelerator
interface IAMVideoAccelerator : IUnknown
{
// pdwNumGuidsSupported is an IN OUT paramter
// pGuidsSupported is an IN OUT paramter
// if pGuidsSupported is NULL, pdwNumGuidsSupported should return back with the
// number of uncompressed pixel formats supported
// Otherwise pGuidsSupported is an array of *pdwNumGuidsSupported structures
HRESULT GetVideoAcceleratorGUIDs([in] [out] LPDWORD pdwNumGuidsSupported, [in] [out] LPGUID pGuidsSupported);
// pGuid is an IN parameter
// pdwNumFormatsSupported is an IN OUT paramter
// pFormatsSupported is an IN OUT paramter (caller should make sure to set the size of EACH struct)
// if pFormatsSupported is NULL, pdwNumFormatsSupported should return back with
// the number of uncompressed pixel formats supported
// Otherwise pFormatsSupported is an array of *pdwNumFormatsSupported structures
HRESULT GetUncompFormatsSupported( [in] const GUID *pGuid, [in] [out] LPDWORD pdwNumFormatsSupported,
[in] [out] LPDDPIXELFORMAT pFormatsSupported);
// pGuid is an IN parameter
// pamvaUncompDataInfo is an IN parameter
// pamvaInternalMemInfo is an IN OUT parameter (caller should make sure to set the size of struct)
// currently only gets info about how much scratch memory will the hal allocate for its private use
HRESULT GetInternalMemInfo([in] const GUID *pGuid, [in] const AMVAUncompDataInfo *pamvaUncompDataInfo,
[in] [out] LPAMVAInternalMemInfo pamvaInternalMemInfo);
// pGuid is an IN parameter
// pamvaUncompDataInfo is an IN parameter
// pdwNumTypesCompBuffers is an IN OUT paramter
// pamvaCompBufferInfo is an IN OUT paramter (caller should make sure to set the size of EACH struct)
// if pamvaCompBufferInfo is NULL, pdwNumTypesCompBuffers should return back with the number of types of
// compressed buffers
// Otherwise pamvaCompBufferInfo is an array of *pdwNumTypesCompBuffers structures
HRESULT GetCompBufferInfo([in] const GUID *pGuid, [in] const AMVAUncompDataInfo *pamvaUncompDataInfo,
[in] [out] LPDWORD pdwNumTypesCompBuffers, [out] LPAMVACompBufferInfo pamvaCompBufferInfo);
// pdwNumTypesCompBuffers is an IN OUT paramter
// pamvaCompBufferInfo is an IN OUT paramter (caller should make sure to set the size of EACH struct)
// if pamvaCompBufferInfo is NULL, pdwNumTypesCompBuffers should return back with the number of types of
// compressed buffers
// Otherwise pamvaCompBufferInfo is an array of *pdwNumTypesCompBuffers structures
// only valid to call this after the pins are connected
HRESULT GetInternalCompBufferInfo([in] [out] LPDWORD pdwNumTypesCompBuffers, [out] LPAMVACompBufferInfo pamvaCompBufferInfo);
// begin a frame, the pMiscData is passed directly to the hal
// only valid to call this after the pins are connected
// Tells the ovmixer which frame is the destination
// frame. Use indices (valid vales are [0 .. pdwNumSurfacesAllocated-1]) to specify frames
HRESULT BeginFrame([in] const AMVABeginFrameInfo *amvaBeginFrameInfo);
// end a frame, the pMiscData is passed directly to the hal
// only valid to call this after the pins are connected
HRESULT EndFrame([in] const AMVAEndFrameInfo *pEndFrameInfo);
// lock and obtain access to a single buffer
// only valid to call this after the pins are connected
// Buffers are identified by type and index within that type
// Specifiying read-only will allow access to busy reference
// frames
// Output (uncompressed) frames use a type index of 0xFFFFFFFF
HRESULT GetBuffer(
[in] DWORD dwTypeIndex,
[in] DWORD dwBufferIndex,
[in] BOOL bReadOnly,
[out] LPVOID *ppBuffer,
[out] LONG *lpStride);
// unlock a single buffer
// Buffers are identified by type and index within that type
// only valid to call this after the pins are connected
HRESULT ReleaseBuffer([in] DWORD dwTypeIndex, [in] DWORD dwBufferIndex);
// Perform a decompression operation
// Private data can be passed to and from a driver
// identifiers for the corresponding members of pamvaMacroBlockInfo
// pamvaMacroBlockInfo is an IN parameter which is array (of length dwNumBlocks) of structures
// only valid to call this after the pins are connected
HRESULT Execute(
[in] DWORD dwFunction,
[in] LPVOID lpPrivateInputData,
[in] DWORD cbPrivateInputData,
[in] LPVOID lpPrivateOutputDat,
[in] DWORD cbPrivateOutputData,
[in] DWORD dwNumBuffers,
[in] const AMVABUFFERINFO *pamvaBufferInfo);
// query the decode status of a particular decompression operation
// dwTypeIndex and dwBufferIndex define the buffer whose status is
// being queried
HRESULT QueryRenderStatus([in] DWORD dwTypeIndex,
[in] DWORD dwBufferIndex,
[in] DWORD dwFlags);
// display a frame. The mediasample contains the timestamps etc for the frame to be displayed
// this call is a non-blocking call
// only valid to call this after the pins are connected
HRESULT DisplayFrame([in] DWORD dwFlipToIndex, [in] IMediaSample *pMediaSample);
};