mirror of https://git.rip/DMCA_FUCKER/re3.git
5170 lines
171 KiB
Plaintext
5170 lines
171 KiB
Plaintext
//------------------------------------------------------------------------------
|
|
// File: AXExtend.idl
|
|
//
|
|
// Desc: Extended streaming interface definitions for the ActiveMovie
|
|
// streaming and synchronization architecture. Core streaming
|
|
// interfaces are in AXCore.idl, and control interfaces for the
|
|
// type library are in Control.odl.
|
|
//
|
|
// Copyright (c) 1992 - 2000, Microsoft Corporation. All rights reserved.
|
|
//------------------------------------------------------------------------------
|
|
|
|
|
|
// include after unknwn.idl, objidl.idl and axcore.idl
|
|
|
|
|
|
// forward declarations - these are the interfaces declared in this file
|
|
|
|
interface IEnumRegFilters;
|
|
interface IFileSourceFilter;
|
|
interface IFileSinkFilter;
|
|
interface IFileSinkFilter2;
|
|
interface IGraphBuilder;
|
|
interface ICaptureGraphBuilder;
|
|
interface ICaptureGraphBuilder2;
|
|
interface IAMCopyCaptureFileProgress;
|
|
interface IFilterMapper;
|
|
interface IFilterMapper2;
|
|
interface IMediaEventSink;
|
|
interface IOverlay;
|
|
interface IOverlayNotify;
|
|
interface IOverlayNotify2;
|
|
interface IQualityControl;
|
|
interface ISeekingPassThru;
|
|
interface IAMStreamConfig;
|
|
interface IAMDevMemoryAllocator;
|
|
interface IAMDevMemoryControl;
|
|
interface IConfigInterleaving;
|
|
interface IConfigAviMux;
|
|
interface IAMVideoCompression;
|
|
interface IAMVfwCaptureDialogs;
|
|
interface IAMVfwCompressDialogs;
|
|
interface IAMDroppedFrames;
|
|
interface IAMAudioInputMixer;
|
|
interface IAMBufferNegotiation;
|
|
interface IAMAnalogVideoDecoder;
|
|
interface IAMVideoProcAmp;
|
|
interface IAMAnalogVideoEncoder;
|
|
interface IAMCameraControl;
|
|
interface IAMCrossbar;
|
|
interface IAMTVTuner;
|
|
interface IKsPropertySet;
|
|
interface IAMPhysicalPinInfo;
|
|
interface IAMExtDevice;
|
|
interface IAMExtTransport;
|
|
interface IAMTimecodeReader;
|
|
interface IAMTimecodeGenerator;
|
|
interface IAMTimecodeDisplay;
|
|
interface IDrawVideoImage;
|
|
interface IDecimateVideoImage;
|
|
interface IAMVideoDecimationProperties;
|
|
interface IAMPushSource;
|
|
interface IAMAudioRendererStats;
|
|
interface IAMLatency;
|
|
interface IAMGraphStreams;
|
|
interface IAMOverlayFX;
|
|
interface IAMOpenProgress;
|
|
interface IMpeg2Demultiplexer ;
|
|
interface IMPEG2StreamIdMap ;
|
|
interface IEnumStreamIdMap ;
|
|
interface IAMClockSlave ;
|
|
interface IEncoderAPI;
|
|
interface IVideoEncoder;
|
|
interface IAMGraphBuilderCallback;
|
|
interface IAMCertifiedOutputProtection;
|
|
|
|
//==========================================================================
|
|
//==========================================================================
|
|
// IEnumRegFilters interface -- enumerates registered filters.
|
|
// enumerator interface returned from IFilterMapper::EnumMatchingFilters().
|
|
// based on IEnum pseudo-template
|
|
//==========================================================================
|
|
//==========================================================================
|
|
|
|
typedef struct {
|
|
CLSID Clsid; // class id of the filter
|
|
LPWSTR Name; // name of filter
|
|
} REGFILTER;
|
|
|
|
[
|
|
object,
|
|
uuid(56a868a4-0ad4-11ce-b03a-0020af0ba770),
|
|
pointer_default(unique)
|
|
]
|
|
|
|
// The point of the mapper is to avoid loading filters. By looking in the
|
|
// registry we can reduce the number of filters which must be loaded and tried.
|
|
// This enumerator returns descriptors of filters (including the GUIDs that
|
|
// CoCreateInstance can instantiate). The filters themselves are not loaded.
|
|
|
|
interface IEnumRegFilters : IUnknown {
|
|
import "unknwn.idl";
|
|
|
|
// The caller must use CoTaskMemFree to free each REGFILTER* returned
|
|
// in the array.
|
|
HRESULT Next
|
|
( [in] ULONG cFilters, // place this many filters...
|
|
[out] REGFILTER ** apRegFilter, // ...in this array of REGFILTER*
|
|
[out] ULONG * pcFetched // actual count passed returned here
|
|
);
|
|
|
|
// I can't think why anyone would want to skip, so it's not implemented.
|
|
// (anyone who thinks they know what they would be skipping over is probably
|
|
// missing some piece of the jigsaw). This ALWAYS returns E_NOTIMPL.
|
|
|
|
HRESULT Skip(
|
|
[in] ULONG cFilters
|
|
);
|
|
|
|
HRESULT Reset(void);
|
|
|
|
// No cloning either - also ALWAYS returns E_NOTIMPL.
|
|
|
|
HRESULT Clone(
|
|
[out] IEnumRegFilters **ppEnum
|
|
);
|
|
}
|
|
|
|
|
|
typedef IEnumRegFilters *PENUMREGFILTERS;
|
|
|
|
//========================================================================
|
|
//========================================================================
|
|
// abstraction representing the registered information about filters.
|
|
// This allows properties of filters to be looked up without loading them.
|
|
//========================================================================
|
|
//========================================================================
|
|
|
|
[
|
|
object,
|
|
uuid(56a868a3-0ad4-11ce-b03a-0020af0ba770),
|
|
pointer_default(unique)
|
|
]
|
|
interface IFilterMapper : IUnknown {
|
|
import "unknwn.idl";
|
|
|
|
//==========================================================================
|
|
// Registration functions.
|
|
// A filter should be registered before any other use.
|
|
// The registration can be NON_VOLATILE (i.e. permanent, do once ever)
|
|
// or VOLATILE (once per boot of the system).
|
|
// UnregisterFilter (obviously) removes the registration.
|
|
// The action of any of the other calls on unregistered filters is undefined.
|
|
// it will either work or you'll get an error, but I'm not saying which.
|
|
//==========================================================================
|
|
|
|
// Four predefined values controling the order in which filters are tried
|
|
// for intelligent graph building. Intermediate values are legal.
|
|
// Any value <=MERIT_DO_NOT_USE will mean that the filter will never
|
|
// be tried by the filtergrah to automatically complete a connection.
|
|
|
|
enum { MERIT_PREFERRED = 0x800000,
|
|
MERIT_NORMAL = 0x600000,
|
|
MERIT_UNLIKELY = 0x400000,
|
|
MERIT_DO_NOT_USE = 0x200000,
|
|
MERIT_SW_COMPRESSOR = 0x100000,
|
|
MERIT_HW_COMPRESSOR = 0x100050
|
|
};
|
|
|
|
// Register a filter
|
|
|
|
HRESULT RegisterFilter
|
|
( [in] CLSID clsid, // GUID of the filter
|
|
[in] LPCWSTR Name, // Descriptive name for the filter
|
|
[in] DWORD dwMerit // DO_NOT_USE, UNLIKELY, NORMAL or PREFERRED.
|
|
);
|
|
|
|
|
|
// Register an identifiable instance of a filter. This deals with cases
|
|
// such as two similar sound cards which are driven by the same driver,
|
|
// but we want to choose which oif these cards the sound will come out of.
|
|
// This is not needed if there is only one instance of the filter
|
|
// (e.g. there is only one sound card in the machine) or if all instances
|
|
// of the filter are equivalent.
|
|
|
|
// The filter itself must have already been registered // ??? Is that true?
|
|
HRESULT RegisterFilterInstance
|
|
( [in] CLSID clsid, // GUID of the filter
|
|
[in] LPCWSTR Name, // Descriptive name of instance.
|
|
[out] CLSID *MRId // Returned Media Resource Id. A
|
|
// locally unique id for this instance
|
|
// of this filter
|
|
);
|
|
|
|
|
|
HRESULT RegisterPin
|
|
( [in] CLSID Filter, // GUID of filter
|
|
[in] LPCWSTR Name, // Name of the pin
|
|
[in] BOOL bRendered, // The filter renders this input
|
|
[in] BOOL bOutput, // TRUE if this is an Output pin
|
|
[in] BOOL bZero, // TRUE if OK for zero instances of pin
|
|
// In this case you will have to Create
|
|
// a pin to have even one instance
|
|
[in] BOOL bMany, // TRUE if OK for many instances of pin
|
|
[in] CLSID ConnectsToFilter, // Filter it connects to if it has
|
|
// subterranean connection, else NULL
|
|
[in] LPCWSTR ConnectsToPin // Name of pin it connects to
|
|
// NULL for output pins
|
|
);
|
|
|
|
HRESULT RegisterPinType
|
|
( [in] CLSID clsFilter, // GUID of filter
|
|
[in] LPCWSTR strName, // Descriptive name of the pin
|
|
[in] CLSID clsMajorType, // Major type of the data stream
|
|
[in] CLSID clsSubType // Sub type of the data stream
|
|
);
|
|
|
|
|
|
HRESULT UnregisterFilter
|
|
( [in] CLSID Filter // GUID of filter
|
|
);
|
|
|
|
|
|
HRESULT UnregisterFilterInstance
|
|
( [in] CLSID MRId // Media Resource Id of this instance
|
|
);
|
|
|
|
|
|
HRESULT UnregisterPin
|
|
( [in] CLSID Filter, // GUID of filter
|
|
[in] LPCWSTR Name // Name of the pin
|
|
);
|
|
|
|
|
|
// Set *ppEnum to be an enumerator for filters matching the requirements.
|
|
|
|
HRESULT EnumMatchingFilters
|
|
( [out] IEnumRegFilters **ppEnum // enumerator returned
|
|
, [in] DWORD dwMerit // at least this merit needed
|
|
, [in] BOOL bInputNeeded // need at least one input pin
|
|
, [in] CLSID clsInMaj // input major type
|
|
, [in] CLSID clsInSub // input sub type
|
|
, [in] BOOL bRender // must the input be rendered?
|
|
, [in] BOOL bOututNeeded // need at least one output pin
|
|
, [in] CLSID clsOutMaj // output major type
|
|
, [in] CLSID clsOutSub // output sub type
|
|
);
|
|
|
|
}
|
|
|
|
// structure used to identify media types a pin handles. Used for
|
|
// registration through IFilterMapper and IFilterMapper2
|
|
//
|
|
typedef struct
|
|
{
|
|
const CLSID * clsMajorType;
|
|
const CLSID * clsMinorType;
|
|
} REGPINTYPES;
|
|
|
|
// describes pin for filter registration. Used for registration
|
|
// through IFilterMapper and IFilterMapper2
|
|
//
|
|
typedef struct
|
|
{
|
|
LPWSTR strName;
|
|
|
|
// The filter renders this input
|
|
BOOL bRendered;
|
|
|
|
// This is an Output pin
|
|
BOOL bOutput;
|
|
|
|
// OK to have zero instances of pin In this case you will have to
|
|
// Create a pin to have even one instance
|
|
BOOL bZero;
|
|
|
|
// OK to create many instance of pin
|
|
BOOL bMany;
|
|
|
|
const CLSID * clsConnectsToFilter;
|
|
const WCHAR * strConnectsToPin;
|
|
|
|
UINT nMediaTypes;
|
|
const REGPINTYPES * lpMediaType;
|
|
} REGFILTERPINS;
|
|
|
|
// mediums (as defined in the Windows NT DDK) for registration with
|
|
// IFilterMapper2
|
|
//
|
|
typedef struct
|
|
{
|
|
CLSID clsMedium;
|
|
DWORD dw1;
|
|
DWORD dw2;
|
|
} REGPINMEDIUM;
|
|
|
|
// flags for dwFlags in REFILTERPINS2
|
|
enum
|
|
{
|
|
// OK to have zero instances of pin In this case you will have to
|
|
// Create a pin to have even one instance
|
|
REG_PINFLAG_B_ZERO = 0x1,
|
|
|
|
// The filter renders this input
|
|
REG_PINFLAG_B_RENDERER = 0x2,
|
|
|
|
// OK to create many instance of pin
|
|
REG_PINFLAG_B_MANY = 0x4,
|
|
|
|
// This is an Output pin
|
|
REG_PINFLAG_B_OUTPUT = 0x8
|
|
};
|
|
|
|
|
|
// describes pin for filter registration through IFilterMapper2
|
|
typedef struct
|
|
{
|
|
// combination of REG_PINFLAG flags
|
|
DWORD dwFlags;
|
|
|
|
// number of instances of the pin if known
|
|
UINT cInstances;
|
|
|
|
UINT nMediaTypes;
|
|
[size_is(nMediaTypes)] const REGPINTYPES * lpMediaType;
|
|
|
|
UINT nMediums;
|
|
[size_is(nMediums)] const REGPINMEDIUM *lpMedium;
|
|
|
|
// pin category (for Kernel Streaming pins) as defined in the
|
|
// Windows NT DDK
|
|
const CLSID *clsPinCategory;
|
|
|
|
} REGFILTERPINS2;
|
|
|
|
// describes filter for registration through IFilterMapper2
|
|
typedef struct
|
|
{
|
|
DWORD dwVersion; // 1 or 2
|
|
DWORD dwMerit;
|
|
|
|
/* unnamed union */
|
|
[switch_is(dwVersion)] [switch_type(DWORD)] union
|
|
{
|
|
[case(1)]
|
|
|
|
struct
|
|
{
|
|
ULONG cPins;
|
|
[size_is(cPins)] const REGFILTERPINS *rgPins;
|
|
};
|
|
|
|
[case(2)]
|
|
|
|
struct
|
|
{
|
|
ULONG cPins2;
|
|
[size_is(cPins2)] const REGFILTERPINS2 *rgPins2;
|
|
};
|
|
|
|
[default]
|
|
;
|
|
} ;
|
|
|
|
} REGFILTER2;
|
|
|
|
|
|
|
|
[
|
|
object,
|
|
uuid(b79bb0b0-33c1-11d1-abe1-00a0c905f375),
|
|
pointer_default(unique)
|
|
]
|
|
interface IFilterMapper2 : IUnknown {
|
|
import "unknwn.idl";
|
|
|
|
// create or rename ActiveMovie category
|
|
HRESULT CreateCategory
|
|
( [in] REFCLSID clsidCategory,
|
|
[in] DWORD dwCategoryMerit,
|
|
[in] LPCWSTR Description
|
|
);
|
|
|
|
HRESULT UnregisterFilter
|
|
( [in] const CLSID *pclsidCategory,
|
|
[in] const OLECHAR *szInstance,
|
|
[in] REFCLSID Filter // GUID of filter
|
|
);
|
|
|
|
// Register a filter, pins, and media types under a category.
|
|
HRESULT RegisterFilter
|
|
( [in] REFCLSID clsidFilter, // GUID of the filter
|
|
[in] LPCWSTR Name, // Descriptive name for the filter
|
|
|
|
// ppMoniker can be null. or *ppMoniker can contain the
|
|
// moniker where this filter data will be written;
|
|
// *ppMoniker will be set to null on return. or *ppMoniker
|
|
// can be null in which case the moniker will be returned
|
|
// with refcount.
|
|
[in, out] IMoniker **ppMoniker,
|
|
|
|
// can be null
|
|
[in] const CLSID *pclsidCategory,
|
|
|
|
// cannot be null
|
|
[in] const OLECHAR *szInstance,
|
|
|
|
// rest of filter and pin registration
|
|
[in] const REGFILTER2 *prf2
|
|
);
|
|
|
|
// Set *ppEnum to be an enumerator for filters matching the
|
|
// requirements.
|
|
HRESULT EnumMatchingFilters
|
|
( [out] IEnumMoniker **ppEnum // enumerator returned
|
|
, [in] DWORD dwFlags // 0
|
|
, [in] BOOL bExactMatch // don't match wildcards
|
|
, [in] DWORD dwMerit // at least this merit needed
|
|
, [in] BOOL bInputNeeded // need at least one input pin
|
|
, [in] DWORD cInputTypes // Number of input types to match
|
|
// Any match is OK
|
|
, [size_is(cInputTypes*2)] const GUID *pInputTypes // input major+subtype pair array
|
|
, [in] const REGPINMEDIUM *pMedIn // input medium
|
|
, [in] const CLSID *pPinCategoryIn // input pin category
|
|
, [in] BOOL bRender // must the input be rendered?
|
|
, [in] BOOL bOutputNeeded // need at least one output pin
|
|
, [in] DWORD cOutputTypes // Number of output types to match
|
|
// Any match is OK
|
|
, [size_is(cOutputTypes*2)] const GUID *pOutputTypes // output major+subtype pair array
|
|
, [in] const REGPINMEDIUM *pMedOut // output medium
|
|
, [in] const CLSID *pPinCategoryOut // output pin category
|
|
);
|
|
}
|
|
|
|
[
|
|
object,
|
|
uuid(b79bb0b1-33c1-11d1-abe1-00a0c905f375),
|
|
pointer_default(unique)
|
|
]
|
|
interface IFilterMapper3 : IFilterMapper2 {
|
|
// new interface to allow creating filters using the mapper's devenum instance
|
|
// primarily needed for out-of-proc access to a graph
|
|
HRESULT GetICreateDevEnum( [out] ICreateDevEnum **ppEnum );
|
|
}
|
|
|
|
//========================================================================
|
|
//========================================================================
|
|
// Defines IQualityControl interface
|
|
//
|
|
// Defines quality messages and allows a quality manager to install itself
|
|
// as the sink for quality messages.
|
|
//========================================================================
|
|
//========================================================================
|
|
|
|
typedef enum tagQualityMessageType {
|
|
Famine,
|
|
Flood
|
|
} QualityMessageType;
|
|
|
|
typedef struct tagQuality {
|
|
QualityMessageType Type;
|
|
long Proportion; // milli-units. 1000 = no change
|
|
// for Flood:
|
|
// What proportion of the media samples currently
|
|
// coming through are required in the future.
|
|
// 800 means please drop another 20%
|
|
// For Famine:
|
|
// How much to "keep in" e.g. 800 means send me
|
|
// 20% less e.g. by dropping 20% of the samples.
|
|
// 1100 would mean "I'm coping, send me more".
|
|
REFERENCE_TIME Late;
|
|
// How much you need to catch up by
|
|
REFERENCE_TIME TimeStamp;
|
|
// The stream time when this was generated (probably
|
|
// corresponds to the start time on some sample).
|
|
} Quality;
|
|
|
|
typedef IQualityControl *PQUALITYCONTROL;
|
|
|
|
|
|
[
|
|
object,
|
|
uuid(56a868a5-0ad4-11ce-b03a-0020af0ba770),
|
|
pointer_default(unique)
|
|
]
|
|
interface IQualityControl : IUnknown {
|
|
|
|
// Notify the recipient that a quality change is requested.
|
|
// pSelf is the IBaseFilter* of the sender.
|
|
// this is sent from a filter
|
|
// to (the quality manager or) an upstream peer.
|
|
HRESULT Notify
|
|
( [in] IBaseFilter * pSelf,
|
|
[in] Quality q
|
|
);
|
|
|
|
// Notify the recipient that future quality messages are to be sent
|
|
// to iqc. If piqc is NULL then quality messages are to default back to
|
|
// the upstream peer.
|
|
// This is sent from the quality manager to a filter.
|
|
// The recipient should hold piqc as a WEAK reference,
|
|
// i.e. do not AddRef it, do not Release it.
|
|
HRESULT SetSink
|
|
( [in] IQualityControl * piqc
|
|
);
|
|
}
|
|
|
|
//=====================================================================
|
|
//=====================================================================
|
|
// Definitions required for overlay transport
|
|
//=====================================================================
|
|
//=====================================================================
|
|
|
|
|
|
// Used to communicate the colour that the IOverlay client wants the window
|
|
// painted in so that it can draw directly to the correct clipping region
|
|
// A colour key can be described in two alternate ways, the first is by a
|
|
// range of one or more (system) palette indices. The second is by defining
|
|
// a colour cube with two RGB values, any of which would be acceptable.
|
|
//
|
|
// The CK values are consistent with GDI PALETTEINDEX and PALETTERGB macros
|
|
|
|
|
|
enum { CK_NOCOLORKEY = 0x0, // No color key is required
|
|
CK_INDEX = 0x1, // Index into the current system palette
|
|
CK_RGB = 0x2 }; // Color key is an RGB value (or range)
|
|
|
|
typedef struct tagCOLORKEY {
|
|
|
|
DWORD KeyType; // Explains meaning of the structure
|
|
DWORD PaletteIndex; // Palette index if available
|
|
COLORREF LowColorValue; // Low colour space RGB value
|
|
COLORREF HighColorValue; // Defines the high RGB value
|
|
|
|
} COLORKEY;
|
|
|
|
// When a filter sets up an advise link it can ask that only certain types
|
|
// of notifications be sent, for example just palette changes. While this
|
|
// doesn't mean that the other notification call backs won't ever be called
|
|
// the IOverlay implementation may use this as an efficiency optimisation
|
|
|
|
enum { ADVISE_NONE = 0x0, // No notifications required
|
|
ADVISE_CLIPPING = 0x1, // Synchronous clip information
|
|
ADVISE_PALETTE = 0x2, // Palette change notifications
|
|
ADVISE_COLORKEY = 0x4, // Called when colour key changes
|
|
ADVISE_POSITION = 0x8, // Likewise when window moves etc
|
|
ADVISE_DISPLAY_CHANGE = 0x10 // Called on WM_DISPLAYCHANGE
|
|
};
|
|
|
|
const DWORD ADVISE_ALL = ADVISE_CLIPPING |
|
|
ADVISE_PALETTE |
|
|
ADVISE_COLORKEY |
|
|
ADVISE_POSITION;
|
|
|
|
const DWORD ADVISE_ALL2 = ADVISE_ALL |
|
|
ADVISE_DISPLAY_CHANGE;
|
|
|
|
// This isn't defined when you run IDL
|
|
|
|
cpp_quote("#ifndef _WINGDI_")
|
|
|
|
typedef struct _RGNDATAHEADER {
|
|
DWORD dwSize;
|
|
DWORD iType;
|
|
DWORD nCount;
|
|
DWORD nRgnSize;
|
|
RECT rcBound;
|
|
} RGNDATAHEADER;
|
|
|
|
typedef struct _RGNDATA {
|
|
RGNDATAHEADER rdh;
|
|
char Buffer[1];
|
|
} RGNDATA;
|
|
|
|
cpp_quote("#endif")
|
|
|
|
|
|
//=====================================================================
|
|
//=====================================================================
|
|
// Defines IOverlayNotify interface
|
|
//
|
|
// This interface gives asynchronous notifications of changes to the
|
|
// rendering window - such as changes to the exposed window area
|
|
//=====================================================================
|
|
//=====================================================================
|
|
|
|
[
|
|
object,
|
|
local,
|
|
uuid(56a868a0-0ad4-11ce-b03a-0020af0ba770),
|
|
pointer_default(unique)
|
|
]
|
|
interface IOverlayNotify : IUnknown {
|
|
|
|
// IOverlayNotify methods
|
|
|
|
// This notifies the filter of palette changes, the filter should copy
|
|
// the array of RGBQUADs if it needs to use them after returning. This
|
|
// is not called when the palette is actually changed in the display
|
|
// but at a short time after (in sync with WM_PALETTECHANGED messages)
|
|
|
|
HRESULT OnPaletteChange(
|
|
[in] DWORD dwColors, // Number of colours present
|
|
[in] const PALETTEENTRY *pPalette); // Array of palette colours
|
|
|
|
// This provides synchronous clip changes so that the client is called
|
|
// before the window is moved to freeze the video, and then when the
|
|
// window has stabilised it is called again to start playback again.
|
|
// If the window rect is all zero then the window is invisible, the
|
|
// filter must take a copy of the information if it wants to keep it
|
|
|
|
HRESULT OnClipChange(
|
|
[in] const RECT *pSourceRect, // Region of video to use
|
|
[in] const RECT *pDestinationRect, // Where video goes
|
|
[in] const RGNDATA *pRgnData); // Defines clipping information
|
|
|
|
HRESULT OnColorKeyChange([in] const COLORKEY *pColorKey);
|
|
|
|
// The calls to OnClipChange happen in sync with the window. So it is
|
|
// called with an empty clip list before the window moves to freeze
|
|
// the video, and then when the window has stabilised it is called
|
|
// again with the new clip list. The OnPositionChange callback is for
|
|
// overlay cards that don't want the expense of synchronous clipping
|
|
// updates and just want to know when the source or destination video
|
|
// positions change. They will NOT be called in sync with the window
|
|
// but at some point after the window has changed (basicly in time
|
|
// with WM_SIZE etc messages received). This is therefore suitable
|
|
// for overlay cards that don't inlay their data to the frame buffer
|
|
// NOTE the destination is NOT clipped to the visible display area
|
|
|
|
HRESULT OnPositionChange([in] const RECT *pSourceRect,
|
|
[in] const RECT *pDestinationRect);
|
|
}
|
|
|
|
typedef IOverlayNotify *POVERLAYNOTIFY;
|
|
|
|
|
|
//=====================================================================
|
|
//=====================================================================
|
|
// Defines IOverlayNotify2 interface
|
|
//
|
|
// This interface gives asynchronous notifications of changes to the
|
|
// rendering window - such as changes to the exposed window area
|
|
// This is optionally supported by the advise sink for the purposes
|
|
// of accepting OnDisplayChange notification.
|
|
//=====================================================================
|
|
//=====================================================================
|
|
|
|
cpp_quote("#if !defined(HMONITOR_DECLARED) && !defined(HMONITOR) && (WINVER < 0x0500)")
|
|
cpp_quote("#define HMONITOR_DECLARED")
|
|
cpp_quote("#if 0")
|
|
typedef HANDLE HMONITOR;
|
|
cpp_quote("#endif")
|
|
cpp_quote("DECLARE_HANDLE(HMONITOR);")
|
|
cpp_quote("#endif")
|
|
|
|
[
|
|
object,
|
|
local,
|
|
uuid(680EFA10-D535-11D1-87C8-00A0C9223196),
|
|
pointer_default(unique)
|
|
]
|
|
interface IOverlayNotify2 : IOverlayNotify {
|
|
|
|
// IOverlayNotify2 methods
|
|
|
|
HRESULT OnDisplayChange( // ADVISE_DISPLAY_CHANGE
|
|
HMONITOR hMonitor);
|
|
}
|
|
|
|
typedef IOverlayNotify2 *POVERLAYNOTIFY2;
|
|
|
|
|
|
//=====================================================================
|
|
//=====================================================================
|
|
// Defines IOverlay interface
|
|
//
|
|
// This interface provides information so that a filter can write direct to
|
|
// the frame buffer while placing the video in the correct window position
|
|
//=====================================================================
|
|
//=====================================================================
|
|
|
|
[
|
|
object,
|
|
local,
|
|
uuid(56a868a1-0ad4-11ce-b03a-0020af0ba770),
|
|
pointer_default(unique)
|
|
]
|
|
interface IOverlay : IUnknown {
|
|
|
|
// IOverlay methods
|
|
|
|
HRESULT GetPalette(
|
|
[out] DWORD *pdwColors, // Number of colours present
|
|
[out] PALETTEENTRY **ppPalette); // Where to put palette data
|
|
|
|
HRESULT SetPalette(
|
|
[in] DWORD dwColors, // Number of colours present
|
|
[in] PALETTEENTRY *pPalette); // Colours to use for palette
|
|
|
|
// If you change the colour key through SetColorKey then all the advise
|
|
// links will receive an OnColorKeyChange callback with the new colour
|
|
|
|
HRESULT GetDefaultColorKey([out] COLORKEY *pColorKey);
|
|
HRESULT GetColorKey([out] COLORKEY *pColorKey);
|
|
HRESULT SetColorKey([in,out] COLORKEY *pColorKey);
|
|
HRESULT GetWindowHandle([out] HWND *pHwnd);
|
|
|
|
// The IOverlay implementation allocates the memory for the clipping
|
|
// rectangles as it can be variable in length. The filter calling
|
|
// this method should free the memory when it is finished with it
|
|
|
|
HRESULT GetClipList([out] RECT *pSourceRect,
|
|
[out] RECT *pDestinationRect,
|
|
[out] RGNDATA **ppRgnData);
|
|
|
|
// Returns the current video source and destination
|
|
|
|
HRESULT GetVideoPosition([out] RECT *pSourceRect,
|
|
[out] RECT *pDestinationRect);
|
|
|
|
HRESULT Advise(
|
|
[in] IOverlayNotify *pOverlayNotify, // Notification interface
|
|
[in] DWORD dwInterests); // Callbacks interested in
|
|
|
|
HRESULT Unadvise(); // Stop the callbacks now
|
|
}
|
|
|
|
typedef IOverlay *POVERLAY;
|
|
|
|
|
|
//=====================================================================
|
|
//=====================================================================
|
|
// control related interfaces (others are defined in control.odl)
|
|
//=====================================================================
|
|
//=====================================================================
|
|
|
|
|
|
//=====================================================================
|
|
//=====================================================================
|
|
// Defines IMediaEventSink interface
|
|
//
|
|
// Exposed by filtergraph. Called by filters to notify events. Will be
|
|
// passed on to application by the IMediaControl event methods.
|
|
//=====================================================================
|
|
//=====================================================================
|
|
|
|
[
|
|
object,
|
|
uuid(56a868a2-0ad4-11ce-b03a-0020af0ba770),
|
|
pointer_default(unique)
|
|
]
|
|
interface IMediaEventSink : IUnknown {
|
|
|
|
// notify an event. will be queued, but not delivered to
|
|
// the application on this thread.
|
|
HRESULT Notify(
|
|
[in] long EventCode,
|
|
[in] LONG_PTR EventParam1,
|
|
[in] LONG_PTR EventParam2
|
|
);
|
|
}
|
|
|
|
typedef IMediaEventSink *PMEDIAEVENTSINK;
|
|
|
|
//=====================================================================
|
|
//=====================================================================
|
|
// Defines IFileSourceFilter interface
|
|
//
|
|
// Exposed by source filters to set the file name and media type.
|
|
//=====================================================================
|
|
//=====================================================================
|
|
|
|
[
|
|
object,
|
|
uuid(56a868a6-0ad4-11ce-b03a-0020af0ba770),
|
|
pointer_default(unique)
|
|
]
|
|
interface IFileSourceFilter : IUnknown {
|
|
|
|
// Load a file and assign it the given media type
|
|
HRESULT Load(
|
|
[in] LPCOLESTR pszFileName, // Pointer to absolute path of file to open
|
|
[in, unique] const AM_MEDIA_TYPE *pmt // Media type of file - can be NULL
|
|
);
|
|
// Get the currently loaded file name
|
|
HRESULT GetCurFile(
|
|
[out] LPOLESTR *ppszFileName, // Pointer to the path for the current file
|
|
[out] AM_MEDIA_TYPE *pmt // Pointer to the media type
|
|
);
|
|
}
|
|
|
|
typedef IFileSourceFilter *PFILTERFILESOURCE;
|
|
|
|
//=====================================================================
|
|
//=====================================================================
|
|
// Defines IFileSinkFilter interface
|
|
//
|
|
// Exposed by renderers to set the output file name.
|
|
//=====================================================================
|
|
//=====================================================================
|
|
|
|
[
|
|
object,
|
|
uuid(a2104830-7c70-11cf-8bce-00aa00a3f1a6),
|
|
pointer_default(unique)
|
|
]
|
|
interface IFileSinkFilter : IUnknown {
|
|
|
|
// Output to this file. default is to open the existing file
|
|
HRESULT SetFileName(
|
|
[in] LPCOLESTR pszFileName, // Pointer to absolute path of output file
|
|
[in, unique] const AM_MEDIA_TYPE *pmt // Media type of file - can be NULL
|
|
);
|
|
// Get the current file name
|
|
HRESULT GetCurFile(
|
|
[out] LPOLESTR *ppszFileName, // Pointer to the path for the current file
|
|
[out] AM_MEDIA_TYPE *pmt // Pointer to the media type
|
|
);
|
|
}
|
|
|
|
typedef IFileSinkFilter *PFILTERFILESINK;
|
|
|
|
[
|
|
object,
|
|
uuid(00855B90-CE1B-11d0-BD4F-00A0C911CE86),
|
|
pointer_default(unique)
|
|
]
|
|
interface IFileSinkFilter2 : IFileSinkFilter {
|
|
|
|
HRESULT SetMode(
|
|
[in] DWORD dwFlags // AM_FILESINK_FLAGS
|
|
);
|
|
|
|
HRESULT GetMode(
|
|
[out] DWORD *pdwFlags // AM_FILESINK_FLAGS
|
|
);
|
|
}
|
|
|
|
typedef IFileSinkFilter2 *PFILESINKFILTER2;
|
|
|
|
typedef enum {
|
|
|
|
// create a new file
|
|
AM_FILE_OVERWRITE = 0x00000001,
|
|
|
|
} AM_FILESINK_FLAGS;
|
|
|
|
|
|
//
|
|
// Intelligent connectivity for filters - an interface supported by
|
|
// filter graphs (since it is an extension to IFilterGraph) that supports
|
|
// building of graphs by automatic selection and connection of appropriate
|
|
// filters
|
|
|
|
[
|
|
object,
|
|
uuid(56a868a9-0ad4-11ce-b03a-0020af0ba770),
|
|
pointer_default(unique)
|
|
]
|
|
interface IGraphBuilder : IFilterGraph {
|
|
// 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
|
|
);
|
|
|
|
|
|
// Build a filter graph that will render this file using this play list.
|
|
// If lpwstrPlayList is NULL then it will use the default play list
|
|
// which will typically render the whole file.
|
|
|
|
HRESULT RenderFile
|
|
( [in] LPCWSTR lpcwstrFile,
|
|
[in, unique] LPCWSTR lpcwstrPlayList
|
|
);
|
|
|
|
|
|
// Add to the filter graph a source filter for this file. This would
|
|
// be the same source filter that would be added by calling Render.
|
|
// This call gives you more control over building
|
|
// the rest of the graph, e.g. AddFilter(<a renderer of your choice>)
|
|
// and then Connect the two.
|
|
// The IBaseFilter* interface exposed by the source filter is returned
|
|
// in ppFilter, addrefed already for you
|
|
// The filter will be known by the name lpcwstrFIlterName
|
|
// nn this filter graph,
|
|
HRESULT AddSourceFilter
|
|
( [in] LPCWSTR lpcwstrFileName,
|
|
[in, unique] LPCWSTR lpcwstrFilterName,
|
|
[out] IBaseFilter* *ppFilter
|
|
);
|
|
|
|
|
|
// If this call is made then trace information will be written to the
|
|
// file showing the actions taken in attempting to perform an operation.
|
|
HRESULT SetLogFile
|
|
( [in] DWORD_PTR hFile // open file handle e.g. from CreateFile
|
|
);
|
|
|
|
|
|
// Request that the graph builder should return as soon as possible from
|
|
// its current task.
|
|
// Note that it is possible fot the following to occur in the following
|
|
// sequence:
|
|
// Operation begins; Abort is requested; Operation completes normally.
|
|
// This would be normal whenever the quickest way to finish an operation
|
|
// was to simply continue to the end.
|
|
HRESULT Abort();
|
|
|
|
// Return S_OK if the curent operation is to continue,
|
|
// return S_FALSE if the current operation is to be aborted.
|
|
// This method can be called as a callback from a filter which is doing
|
|
// some operation at the request of the graph.
|
|
HRESULT ShouldOperationContinue();
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// New capture graph builder
|
|
|
|
[
|
|
object,
|
|
uuid(bf87b6e0-8c27-11d0-b3f0-00aa003761c5),
|
|
pointer_default(unique)
|
|
]
|
|
interface ICaptureGraphBuilder : IUnknown {
|
|
|
|
// Use this filtergraph
|
|
HRESULT SetFiltergraph(
|
|
[in] IGraphBuilder *pfg);
|
|
|
|
// what filtergraph are you using?
|
|
// *ppfg->Release() when you're done with it
|
|
HRESULT GetFiltergraph(
|
|
[out] IGraphBuilder **ppfg);
|
|
|
|
// creates a rendering section in the filtergraph consisting of a MUX
|
|
// of some filetype, and a file writer (and connects them together)
|
|
// *ppf->Release() when you're done with it
|
|
// *ppSink->Release() when you're done with it
|
|
HRESULT SetOutputFileName(
|
|
[in] const GUID *pType, // type of file to write, eg. MEDIASUBTYPE_Avi
|
|
[in] LPCOLESTR lpstrFile, // filename given to file writer
|
|
[out] IBaseFilter **ppf, // returns pointer to the MUX
|
|
[out] IFileSinkFilter **ppSink);// queried from file writer
|
|
|
|
// Looks for an interface on the filter and on the output pin of the given
|
|
// category. (Categories: CAPTURE/PREVIEW/VIDEOPORT/VBI etc. or
|
|
// NULL for "don't care".
|
|
// It will also look upstream and downstream of
|
|
// the pin for the interface, to find interfaces on renderers, MUXES, TV
|
|
// Tuners, etc.
|
|
// Call *ppint->Release() when you're done with it
|
|
[local] HRESULT FindInterface(
|
|
[in, unique] const GUID *pCategory, // can be NULL for all pins
|
|
[in] IBaseFilter *pf,
|
|
[in] REFIID riid,
|
|
[out] void **ppint);
|
|
[call_as(FindInterface)] HRESULT RemoteFindInterface(
|
|
[in, unique] const GUID *pCategory, // can be NULL for all pins
|
|
[in] IBaseFilter *pf,
|
|
[in] REFIID riid,
|
|
[out] IUnknown **ppint);
|
|
|
|
// Connects the pin of the given category of the source filter to the
|
|
// rendering filter, optionally through another filter (compressor?)
|
|
// For a non-NULL category, it will instantiate and connect additional
|
|
// required filters upstream too, like TV Tuners and Crossbars.
|
|
// If there is only one output pin on the source, use a NULL
|
|
// category. You can also have pSource be a pin
|
|
HRESULT RenderStream(
|
|
[in] const GUID *pCategory, // can be NULL if only one output pin
|
|
[in] IUnknown *pSource, // filter or pin
|
|
[in] IBaseFilter *pfCompressor,
|
|
[in] IBaseFilter *pfRenderer); // can be NULL
|
|
|
|
// Sends IAMStreamControl messages to the pin of the desired category, eg.
|
|
// "capture" or "preview"
|
|
// REFERENCE_TIME=NULL means NOW
|
|
// REFERENCE_TIME=MAX_TIME means never, or cancel previous request
|
|
// NULL controls all capture filters in the graph - you will get one
|
|
// notification for each filter with a pin of that category found
|
|
// returns S_FALSE if stop will be signalled before last sample is
|
|
// rendered.
|
|
// return a FAILURE code if the filter does not support IAMStreamControl
|
|
HRESULT ControlStream(
|
|
[in] const GUID *pCategory,
|
|
[in] IBaseFilter *pFilter,
|
|
[in] REFERENCE_TIME *pstart,
|
|
[in] REFERENCE_TIME *pstop,
|
|
[in] WORD wStartCookie, // high word reserved
|
|
[in] WORD wStopCookie); // high word reserved
|
|
|
|
// creates a pre-allocated file of a given size in bytes
|
|
HRESULT AllocCapFile(
|
|
[in] LPCOLESTR lpstr,
|
|
[in] DWORDLONG dwlSize);
|
|
|
|
// Copies the valid file data out of the old, possibly huge old capture
|
|
// file into a shorter new file.
|
|
// Return S_FALSE from your progress function to abort capture, S_OK to
|
|
// continue
|
|
HRESULT CopyCaptureFile(
|
|
[in] LPOLESTR lpwstrOld,
|
|
[in] LPOLESTR lpwstrNew,
|
|
[in] int fAllowEscAbort, // pressing ESC will abort?
|
|
[in] IAMCopyCaptureFileProgress *pCallback); // implement this to
|
|
// get progress
|
|
}
|
|
|
|
|
|
//
|
|
// Capture graph builder "CopyCapturedFile" progress callback
|
|
|
|
[
|
|
object,
|
|
uuid(670d1d20-a068-11d0-b3f0-00aa003761c5),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMCopyCaptureFileProgress : IUnknown {
|
|
|
|
// If you support this interface somewhere, this function will be called
|
|
// periodically while ICaptureGraphBuilder::CopyCaptureFile is executing
|
|
// to let you know the progress
|
|
//
|
|
// Return S_OK from this function to continue. Return S_FALSE to abort the
|
|
// copy
|
|
HRESULT Progress(
|
|
[in] int iProgress); // a number between 0 and 100 (%)
|
|
}
|
|
|
|
|
|
//
|
|
// Capture graph builder that can deal with a single filter having more than
|
|
// one pin of each category... some new devices can capture both audio and
|
|
// video, for example
|
|
//
|
|
|
|
[
|
|
object,
|
|
uuid(93E5A4E0-2D50-11d2-ABFA-00A0C9C6E38D),
|
|
pointer_default(unique)
|
|
]
|
|
interface ICaptureGraphBuilder2 : IUnknown {
|
|
|
|
// Use this filtergraph
|
|
HRESULT SetFiltergraph(
|
|
[in] IGraphBuilder *pfg);
|
|
|
|
// what filtergraph are you using?
|
|
// *ppfg->Release() when you're done with it
|
|
HRESULT GetFiltergraph(
|
|
[out] IGraphBuilder **ppfg);
|
|
|
|
// creates a rendering section in the filtergraph consisting of a MUX
|
|
// of some filetype, and a file writer (and connects them together)
|
|
// *ppf->Release() when you're done with it
|
|
// *ppSink->Release() when you're done with it
|
|
HRESULT SetOutputFileName(
|
|
[in] const GUID *pType, // GUID of MUX filter to use
|
|
[in] LPCOLESTR lpstrFile, // filename given to file writer
|
|
[out] IBaseFilter **ppf, // returns pointer to the MUX
|
|
[out] IFileSinkFilter **ppSink);// queried from file writer
|
|
|
|
// Looks for an interface on the filter and on the output pin of the given
|
|
// category and type. (Categories: CAPTURE/PREVIEW/VIDEOPORT/VBI etc. or
|
|
// NULL for "don't care". Type: MAJORTYPE_Video/Audio etc or NULL)
|
|
// !!! Will some filters have >1 capture pin? ie RGB and MPEG?
|
|
// It will also look upstream and downstream of
|
|
// the pin for the interface, to find interfaces on renderers, MUXES, TV
|
|
// Tuners, etc.
|
|
// Call *ppint->Release() when you're done with it
|
|
[local] HRESULT FindInterface(
|
|
[in] const GUID *pCategory, // can be NULL for all pins
|
|
[in] const GUID *pType, // Audio/Video/??? or NULL (don't care)
|
|
[in] IBaseFilter *pf,
|
|
[in] REFIID riid,
|
|
[out] void **ppint);
|
|
[call_as(FindInterface)] HRESULT RemoteFindInterface(
|
|
[in] const GUID *pCategory, // can be NULL for all pins
|
|
[in] const GUID *pType, // Audio/Video/??? or NULL (don't care)
|
|
[in] IBaseFilter *pf,
|
|
[in] REFIID riid,
|
|
[out] IUnknown **ppint);
|
|
|
|
// Connects the pin of the given category and type of the source filter to
|
|
// the rendering filter, optionally through another filter (compressor?)
|
|
// (Type is a Majortype, like Video or Audio)
|
|
// For a non-NULL category, it will instantiate and connect additional
|
|
// required filters upstream too, like TV Tuners and Crossbars.
|
|
// If there is only one output pin on the source, use a NULL category
|
|
// and type. You can also have pSource be a pin
|
|
HRESULT RenderStream(
|
|
[in] const GUID *pCategory, // can be NULL if only one output pin
|
|
[in] const GUID *pType, // Major type (Video/Audio/etc)
|
|
[in] IUnknown *pSource, // filter or pin
|
|
[in] IBaseFilter *pfCompressor,
|
|
[in] IBaseFilter *pfRenderer); // can be NULL
|
|
|
|
// Sends IAMStreamControl messages to the pin of the desired category,
|
|
// (eg. "capture" or "preview") and of the desired type (eg. VIDEO or AUDIO)
|
|
// A category MUST be given. If a filter is given, a type must be too.
|
|
// REFERENCE_TIME=NULL means NOW
|
|
// REFERENCE_TIME=MAX_TIME means never, or cancel previous request
|
|
// NULL controls all capture filters in the graph - you will get one
|
|
// notification for each filter with a pin of that category found
|
|
// returns S_FALSE if stop will be signalled before last sample is
|
|
// rendered.
|
|
// return a FAILURE code if the filter does not support IAMStreamControl
|
|
HRESULT ControlStream(
|
|
[in] const GUID *pCategory,
|
|
[in] const GUID *pType, // Major type (Video/Audio/etc)
|
|
[in] IBaseFilter *pFilter,
|
|
[in] REFERENCE_TIME *pstart,
|
|
[in] REFERENCE_TIME *pstop,
|
|
[in] WORD wStartCookie, // high word reserved
|
|
[in] WORD wStopCookie); // high word reserved
|
|
|
|
// creates a pre-allocated file of a given size in bytes
|
|
HRESULT AllocCapFile(
|
|
[in] LPCOLESTR lpstr,
|
|
[in] DWORDLONG dwlSize);
|
|
|
|
// Copies the valid file data out of the old, possibly huge old capture
|
|
// file into a shorter new file.
|
|
// Return S_FALSE from your progress function to abort capture, S_OK to
|
|
// continue
|
|
HRESULT CopyCaptureFile(
|
|
[in] LPOLESTR lpwstrOld,
|
|
[in] LPOLESTR lpwstrNew,
|
|
[in] int fAllowEscAbort, // pressing ESC will abort?
|
|
[in] IAMCopyCaptureFileProgress *pCallback); // implement this to
|
|
// get progress
|
|
// Helper fn to find a certain pin on a filter.
|
|
HRESULT FindPin(
|
|
[in] IUnknown *pSource,
|
|
[in] PIN_DIRECTION pindir, // input or output?
|
|
[in] const GUID *pCategory, // what category? (or NULL)
|
|
[in] const GUID *pType, // what Major type (or NULL)
|
|
[in] BOOL fUnconnected, // must it be unconnected?
|
|
[in] int num, // which pin matching this? (0 based)
|
|
[out] IPin **ppPin);
|
|
}
|
|
|
|
enum _AM_RENSDEREXFLAGS {
|
|
AM_RENDEREX_RENDERTOEXISTINGRENDERERS = 0x01 // Dont add any renderers
|
|
};
|
|
|
|
//
|
|
// IFilterGraph2
|
|
//
|
|
// New methods on for IFilterGraph and IGraphBuilder will have to go here.
|
|
//
|
|
|
|
[
|
|
object,
|
|
uuid(36b73882-c2c8-11cf-8b46-00805f6cef60),
|
|
pointer_default(unique)
|
|
]
|
|
interface IFilterGraph2: IGraphBuilder {
|
|
|
|
// Add a Moniker source moniker
|
|
HRESULT AddSourceFilterForMoniker(
|
|
[in] IMoniker *pMoniker,
|
|
[in] IBindCtx *pCtx,
|
|
[in, unique] LPCWSTR lpcwstrFilterName,
|
|
[out] IBaseFilter **ppFilter
|
|
);
|
|
|
|
// Specify the type for a reconnect
|
|
// This is better than Reconnect as sometime the parties to a
|
|
// reconnection can't remember what type they'd agreed (!)
|
|
HRESULT ReconnectEx
|
|
( [in] IPin * ppin, // the pin to disconnect and reconnect
|
|
[in, unique] const AM_MEDIA_TYPE *pmt // the type to reconnect with - can be NULL
|
|
);
|
|
|
|
// Render a pin without adding any new renderers
|
|
HRESULT RenderEx( [in] IPin *pPinOut, // Pin to render
|
|
[in] DWORD dwFlags, // flags
|
|
[in, out] DWORD *pvContext // Unused - set to NULL
|
|
);
|
|
|
|
#if 0
|
|
// Method looks for a filter which supports the specified interface. If such
|
|
// a filter exists, an AddRef()'ed pointer to the requested interface is placed
|
|
// in *ppInterface.
|
|
//
|
|
// *ppInterface will be NULL on return if such a filter could not be found, and
|
|
// the method will return E_NOINTERFACE.
|
|
//
|
|
// pdwIndex is an internal index that is used for obtaining subsequent interfaces.
|
|
// *pdwIndex should be initialized to zero. It is set on return to a value that
|
|
// allows the implementation of FindFilterInterface to search for further interfaces
|
|
// if called again. If no more such interfaces exist, the method will return E_NOINTERFACE.
|
|
//
|
|
// If pdwIndex is NULL, FindFilterInterface returns an interface only if there is just
|
|
// a single filter in the graph that supports the interface. Otherwise it returns
|
|
// E_NOINTERFACE.
|
|
//
|
|
HRESULT FindFilterInterface( [in] REFIID iid, [out] void ** ppInterface, [in,out] LPDWORD pdwIndex );
|
|
|
|
// Tries to obtain the interface from the filter graph itself. If this fails,
|
|
// it attempts to find the unique filter that supports the interface.
|
|
// On failure the method will return E_NOINTERFACE. On success, it returns
|
|
// S_OK and an AddRef()'ed pointer to the requested interface in *ppInterface.
|
|
//
|
|
HRESULT FindInterface( [in] REFIID iid, [out] void ** ppInterface );
|
|
|
|
#endif
|
|
}
|
|
|
|
//
|
|
// StreamBuilder
|
|
// aka Graph building with constraints
|
|
// aka convergent graphs
|
|
// aka Closed captioning
|
|
|
|
[
|
|
object,
|
|
local,
|
|
uuid(56a868bf-0ad4-11ce-b03a-0020af0ba770),
|
|
pointer_default(unique)
|
|
]
|
|
interface IStreamBuilder : IUnknown {
|
|
|
|
// Connect this output pin directly or indirectly, using transform filters
|
|
// if necessary to thing(s) that will render it, within this graph
|
|
// Move from Initial state to Rendered state.
|
|
|
|
HRESULT Render
|
|
( [in] IPin * ppinOut, // the output pin
|
|
[in] IGraphBuilder * pGraph // the graph
|
|
);
|
|
|
|
// Undo what you did in Render. Return to Initial state.
|
|
HRESULT Backout
|
|
( [in] IPin * ppinOut, // the output pin
|
|
[in] IGraphBuilder * pGraph // the graph
|
|
);
|
|
}
|
|
|
|
|
|
// async reader interface - supported by file source filters. Allows
|
|
// multiple overlapped reads from different positions
|
|
|
|
|
|
[
|
|
object,
|
|
uuid(56a868aa-0ad4-11ce-b03a-0020af0ba770),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAsyncReader : IUnknown
|
|
{
|
|
// pass in your preferred allocator and your preferred properties.
|
|
// method returns the actual allocator to be used. Call GetProperties
|
|
// on returned allocator to learn alignment and prefix etc chosen.
|
|
// this allocator will be not be committed and decommitted by
|
|
// the async reader, only by the consumer.
|
|
// Must call this before calling Request.
|
|
HRESULT RequestAllocator(
|
|
[in] IMemAllocator* pPreferred,
|
|
[in] ALLOCATOR_PROPERTIES* pProps,
|
|
[out] IMemAllocator ** ppActual);
|
|
|
|
// queue a request for data.
|
|
// media sample start and stop times contain the requested absolute
|
|
// byte position (start inclusive, stop exclusive).
|
|
// may fail if sample not obtained from agreed allocator.
|
|
// may fail if start/stop position does not match agreed alignment.
|
|
// samples allocated from source pin's allocator may fail
|
|
// GetPointer until after returning from WaitForNext.
|
|
// Stop position must be aligned - this means it may exceed duration.
|
|
// on completion, stop position will be corrected to unaligned
|
|
// actual data.
|
|
HRESULT Request(
|
|
[in] IMediaSample* pSample,
|
|
[in] DWORD_PTR dwUser); // user context
|
|
|
|
// block until the next sample is completed or the timeout occurs.
|
|
// timeout (millisecs) may be 0 or INFINITE. Samples may not
|
|
// be delivered in order. If there is a read error of any sort, a
|
|
// notification will already have been sent by the source filter,
|
|
// and HRESULT will be an error.
|
|
// If ppSample is not null, then a Request completed with the result
|
|
// code returned.
|
|
HRESULT WaitForNext(
|
|
[in] DWORD dwTimeout,
|
|
[out] IMediaSample** ppSample, // completed sample
|
|
[out] DWORD_PTR * pdwUser); // user context
|
|
|
|
// sync read of data. Sample passed in must have been acquired from
|
|
// the agreed allocator. Start and stop position must be aligned.
|
|
// equivalent to a Request/WaitForNext pair, but may avoid the
|
|
// need for a thread on the source filter.
|
|
HRESULT SyncReadAligned(
|
|
[in] IMediaSample* pSample);
|
|
|
|
|
|
// sync read. works in stopped state as well as run state.
|
|
// need not be aligned. Will fail if read is beyond actual total
|
|
// length.
|
|
HRESULT SyncRead(
|
|
[in] LONGLONG llPosition, // absolute file position
|
|
[in] LONG lLength, // nr bytes required
|
|
[out, size_is(lLength)]
|
|
BYTE* pBuffer); // write data here
|
|
|
|
// return total length of stream, and currently available length.
|
|
// reads for beyond the available length but within the total length will
|
|
// normally succeed but may block for a long period.
|
|
HRESULT Length(
|
|
[out] LONGLONG* pTotal,
|
|
[out] LONGLONG* pAvailable);
|
|
|
|
// cause all outstanding reads to return, possibly with a failure code
|
|
//(VFW_E_TIMEOUT) indicating they were cancelled.
|
|
// Between BeginFlush and EndFlush calls, Request calls will fail and
|
|
// WaitForNext calls will always complete immediately.
|
|
HRESULT BeginFlush(void);
|
|
HRESULT EndFlush(void);
|
|
}
|
|
|
|
|
|
// interface provided by the filtergraph itself to let other objects
|
|
// (especially plug-in distributors, but also apps like graphedt) know
|
|
// when the graph has changed.
|
|
[
|
|
object,
|
|
uuid(56a868ab-0ad4-11ce-b03a-0020af0ba770),
|
|
pointer_default(unique)
|
|
]
|
|
interface IGraphVersion : IUnknown
|
|
{
|
|
// returns the current graph version number
|
|
// this is incremented every time there is a change in the
|
|
// set of filters in the graph or in their connections
|
|
//
|
|
// if this is changed since your last enumeration, then re-enumerate
|
|
// the graph
|
|
HRESULT QueryVersion(LONG* pVersion);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
// interface describing an object that uses resources.
|
|
//
|
|
// implement if: you request resources using IResourceManager. You will
|
|
// need to pass your implementation of this pointer as an in param.
|
|
//
|
|
// use if: you are a resource manager who implements IResourceManager
|
|
[
|
|
object,
|
|
uuid(56a868ad-0ad4-11ce-b03a-0020af0ba770),
|
|
pointer_default(unique)
|
|
]
|
|
interface IResourceConsumer : IUnknown
|
|
{
|
|
// you may acquire the resource specified.
|
|
// return values:
|
|
// S_OK -- I have successfully acquired it
|
|
// S_FALSE -- I will acquire it and call NotifyAcquire afterwards
|
|
// VFW_S_NOT_NEEDED: I no longer need the resource
|
|
// FAILED(hr)-I tried to acquire it and failed.
|
|
|
|
HRESULT
|
|
AcquireResource(
|
|
[in] LONG idResource);
|
|
|
|
|
|
|
|
// Please release the resource.
|
|
// return values:
|
|
// S_OK -- I have released it (and want it again when available)
|
|
// S_FALSE -- I will call NotifyRelease when I have released it
|
|
// other something went wrong.
|
|
HRESULT
|
|
ReleaseResource(
|
|
[in] LONG idResource);
|
|
}
|
|
|
|
|
|
|
|
// interface describing a resource manager that will resolve contention for
|
|
// named resources.
|
|
//
|
|
// implement if: you are a resource manager. The filtergraph will be a resource
|
|
// manager, internally delegating to the system wide resource manager
|
|
// (when there is one)
|
|
//
|
|
// use if: you need resources that are limited. Use the resource manager to
|
|
// resolve contention by registering the resource with this interface,
|
|
// and requesting it from this interface whenever needed.
|
|
//
|
|
// or use if: you detect focus changes which should affect resource usage.
|
|
// Notifying change of focus to the resource manager will cause the resource
|
|
// manager to switch contended resources to the objects that have the user's
|
|
// focus
|
|
[
|
|
object,
|
|
uuid(56a868ac-0ad4-11ce-b03a-0020af0ba770),
|
|
pointer_default(unique)
|
|
]
|
|
interface IResourceManager : IUnknown
|
|
{
|
|
// tell the manager how many there are of a resource.
|
|
// ok if already registered. will take new count. if new count
|
|
// is lower, will de-allocate resources to new count.
|
|
//
|
|
// You get back a token that will be used in further calls.
|
|
//
|
|
// Passing a count of 0 will eliminate this resource. There is currently
|
|
// no defined way to find the id without knowing the count.
|
|
//
|
|
HRESULT
|
|
Register(
|
|
[in] LPCWSTR pName, // this named resource
|
|
[in] LONG cResource, // has this many instances
|
|
[out] LONG* plToken // token placed here on return
|
|
);
|
|
|
|
HRESULT
|
|
RegisterGroup(
|
|
[in] LPCWSTR pName, // this named resource group
|
|
[in] LONG cResource, // has this many resources
|
|
[in, size_is(cResource)]
|
|
LONG* palTokens, // these are the contained resources
|
|
[out] LONG* plToken // group resource id put here on return
|
|
);
|
|
|
|
// request the use of a given, registered resource.
|
|
// possible return values:
|
|
// S_OK == yes you can use it now
|
|
// S_FALSE == you will be called back when the resource is available
|
|
// other - there is an error.
|
|
//
|
|
// The priority of this request should be affected by the associated
|
|
// focus object -- that is, when SetFocus is called for that focus
|
|
// object (or a 'related' object) then my request should be put through.
|
|
//
|
|
// A filter should pass the filter's IUnknown here. The filtergraph
|
|
// will match filters to the filtergraph, and will attempt to trace
|
|
// filters to common source filters when checking focus objects.
|
|
// The Focus object must be valid for the entire lifetime of the request
|
|
// -- until you call CancelRequest or NotifyRelease(id, p, FALSE)
|
|
HRESULT
|
|
RequestResource(
|
|
[in] LONG idResource,
|
|
[in] IUnknown* pFocusObject,
|
|
[in] IResourceConsumer* pConsumer
|
|
);
|
|
|
|
|
|
// notify the resource manager that an acquisition attempt completed.
|
|
// Call this method after an AcquireResource method returned
|
|
// S_FALSE to indicate asynchronous acquisition.
|
|
// HR should be S_OK if the resource was successfully acquired, or a
|
|
// failure code if the resource could not be acquired.
|
|
HRESULT
|
|
NotifyAcquire(
|
|
[in] LONG idResource,
|
|
[in] IResourceConsumer* pConsumer,
|
|
[in] HRESULT hr);
|
|
|
|
// Notify the resource manager that you have released a resource. Call
|
|
// this in response to a ReleaseResource method, or when you have finished
|
|
// with the resource. bStillWant should be TRUE if you still want the
|
|
// resource when it is next available, or FALSE if you no longer want
|
|
// the resource.
|
|
HRESULT
|
|
NotifyRelease(
|
|
[in] LONG idResource,
|
|
[in] IResourceConsumer* pConsumer,
|
|
[in] BOOL bStillWant);
|
|
|
|
// I don't currently have the resource, and I no longer need it.
|
|
HRESULT
|
|
CancelRequest(
|
|
[in] LONG idResource,
|
|
[in] IResourceConsumer* pConsumer);
|
|
|
|
// Notify the resource manager that a given object has been given the
|
|
// user's focus. In ActiveMovie, this will normally be a video renderer
|
|
// whose window has received the focus. The filter graph will switch
|
|
// contended resources to (in order):
|
|
// requests made with this same focus object
|
|
// requests whose focus object shares a common source with this
|
|
// requests whose focus object shares a common filter graph
|
|
// After calling this, you *must* call ReleaseFocus before the IUnknown
|
|
// becomes invalid, unless you can guarantee that another SetFocus
|
|
// of a different object is done in the meantime. No addref is held.
|
|
//
|
|
// The resource manager will hold this pointer until replaced or cancelled,
|
|
// and will use it to resolve resource contention. It will call
|
|
// QueryInterface for IBaseFilter at least and if found will call methods on
|
|
// that interface.
|
|
HRESULT
|
|
SetFocus(
|
|
[in] IUnknown* pFocusObject);
|
|
|
|
// Sets the focus to NULL if the current focus object is still
|
|
// pFocusObject. Call this when
|
|
// the focus object is about to be destroyed to ensure that no-one is
|
|
// still referencing the object.
|
|
HRESULT
|
|
ReleaseFocus(
|
|
[in] IUnknown* pFocusObject);
|
|
|
|
|
|
|
|
// !!! still need
|
|
// -- app override (some form of SetPriority)
|
|
// -- enumeration and description of resources
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// Interface representing an object that can be notified about state
|
|
// and other changes within a filter graph. The filtergraph will call plug-in
|
|
// distributors that expose this optional interface so that they can
|
|
// respond to appropriate changes.
|
|
//
|
|
// Implement if: you are a plug-in distributor (your class id is found
|
|
// under HKCR\Interface\<IID>\Distributor= for some interface).
|
|
//
|
|
// Use if: you are the filtergraph.
|
|
[
|
|
object,
|
|
uuid(56a868af-0ad4-11ce-b03a-0020af0ba770),
|
|
pointer_default(unique)
|
|
]
|
|
interface IDistributorNotify : IUnknown
|
|
{
|
|
// called when graph is entering stop state. Called before
|
|
// filters are stopped.
|
|
HRESULT Stop(void);
|
|
|
|
// called when graph is entering paused state, before filters are
|
|
// notified
|
|
HRESULT Pause(void);
|
|
|
|
// called when graph is entering running state, before filters are
|
|
// notified. tStart is the stream-time offset parameter that will be
|
|
// given to each filter's IBaseFilter::Run method.
|
|
HRESULT Run(REFERENCE_TIME tStart);
|
|
|
|
// called when the graph's clock is changing, with the new clock. Addref
|
|
// the clock if you hold it beyond this method. Called before
|
|
// the filters are notified.
|
|
HRESULT SetSyncSource(
|
|
[in] IReferenceClock * pClock);
|
|
|
|
// called when the set of filters or their connections has changed.
|
|
// Called on every AddFilter, RemoveFilter or ConnectDirect (or anything
|
|
// that will lead to one of these).
|
|
// You don't need to rebuild your list of interesting filters at this point
|
|
// but you should release any refcounts you hold on any filters that
|
|
// have been removed.
|
|
HRESULT NotifyGraphChange(void);
|
|
}
|
|
|
|
typedef enum {
|
|
AM_STREAM_INFO_START_DEFINED = 0x00000001,
|
|
AM_STREAM_INFO_STOP_DEFINED = 0x00000002,
|
|
AM_STREAM_INFO_DISCARDING = 0x00000004,
|
|
AM_STREAM_INFO_STOP_SEND_EXTRA = 0x00000010
|
|
} AM_STREAM_INFO_FLAGS;
|
|
|
|
// Stream information
|
|
typedef struct {
|
|
REFERENCE_TIME tStart;
|
|
REFERENCE_TIME tStop;
|
|
DWORD dwStartCookie;
|
|
DWORD dwStopCookie;
|
|
DWORD dwFlags;
|
|
} AM_STREAM_INFO;
|
|
|
|
//
|
|
// IAMStreamControl
|
|
//
|
|
|
|
[
|
|
object,
|
|
uuid(36b73881-c2c8-11cf-8b46-00805f6cef60),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMStreamControl : IUnknown
|
|
{
|
|
// The REFERENCE_TIME pointers may be null, which
|
|
// indicates immediately. If the pointer is non-NULL
|
|
// and dwCookie is non-zero, then pins should send
|
|
// EC_STREAM_CONTROL_STOPPED / EC_STREAM_CONTROL_STARTED
|
|
// with an IPin pointer and the cookie, thus allowing
|
|
// apps to tie the events back to their requests.
|
|
// If either dwCookies is zero, or the pointer is null,
|
|
// then no event is sent.
|
|
|
|
// If you have a capture pin hooked up to a MUX input pin and they
|
|
// both support IAMStreamControl, you'll want the MUX to signal the
|
|
// stop so you know the last frame was written out. In order for the
|
|
// MUX to know it's finished, the capture pin will have to send one
|
|
// extra sample after it was supposed to stop, so the MUX can trigger
|
|
// off that. So you would set bSendExtra to TRUE for the capture pin
|
|
// Leave it FALSE in all other cases.
|
|
|
|
HRESULT StartAt( [in] const REFERENCE_TIME * ptStart,
|
|
[in] DWORD dwCookie );
|
|
HRESULT StopAt( [in] const REFERENCE_TIME * ptStop,
|
|
[in] BOOL bSendExtra,
|
|
[in] DWORD dwCookie );
|
|
HRESULT GetInfo( [out] AM_STREAM_INFO *pInfo);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// ISeekingPassThru
|
|
//
|
|
|
|
[
|
|
object,
|
|
uuid(36b73883-c2c8-11cf-8b46-00805f6cef60),
|
|
pointer_default(unique)
|
|
]
|
|
interface ISeekingPassThru : IUnknown
|
|
{
|
|
HRESULT Init( [in] BOOL bSupportRendering,
|
|
[in] IPin *pPin);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// IAMStreamConfig - pin interface
|
|
//
|
|
|
|
// A capture filter or compression filter's output pin
|
|
// supports this interface - no matter what data type you produce.
|
|
|
|
// This interface can be used to set the output format of a pin (as an
|
|
// alternative to connecting the pin using a specific media type).
|
|
// After setting an output format, the pin will use that format
|
|
// the next time it connects to somebody, so you can just Render that
|
|
// pin and get a desired format without using Connect(CMediaType)
|
|
// Your pin should do that by ONLY OFFERING the media type set in SetFormat
|
|
// in its enumeration of media types, and no others. This will ensure that
|
|
// that format is indeed used for connection (or at least offer it first).
|
|
// An application interested in enumerating accepted mediatypes may have to
|
|
// do so BEFORE calling SetFormat.
|
|
|
|
// But this interface's GetStreamCaps function can get more information
|
|
// about accepted media types than the traditional way of enumerating a pin's
|
|
// media types, so it should typically be used instead.
|
|
// GetStreamCaps gets information about the kinds of formats allowed... how
|
|
// it can stretch and crop, and the frame rate and data rates allowed (for
|
|
// video)
|
|
|
|
// VIDEO EXAMPLE
|
|
//
|
|
// GetStreamCaps returns a whole array of {MediaType, Capabilities}.
|
|
// Let's say your capture card supports JPEG anywhere between 160x120 and
|
|
// 320x240, and also the size 640x480. Also, say it supports RGB24 at
|
|
// resolutions between 160x120 and 320x240 but only multiples of 8. You would
|
|
// expose these properties by offering a media type of 320 x 240 JPEG
|
|
// (if that is your default or preferred size) coupled with
|
|
// capabilities saying minimum 160x120 and maximum 320x240 with granularity of
|
|
// 1. The next pair you expose is a media type of 640x480 JPEG coupled with
|
|
// capabilities of min 640x480 max 640x480. The third pair is media type
|
|
// 320x240 RGB24 with capabilities min 160x120 max 320x240 granularity 8.
|
|
// In this way you can expose almost every quirk your card might have.
|
|
// An application interested in knowing what compression formats you provide
|
|
// can get all the pairs and make a list of all the unique sub types of the
|
|
// media types.
|
|
//
|
|
// If a filter's output pin is connected with a media type that has rcSource
|
|
// and rcTarget not empty, it means the filter is being asked to stretch the
|
|
// rcSource sub-rectangle of its InputSize (the format of the input pin for
|
|
// a compressor, and the largest bitmap a capture filter can generate with
|
|
// every pixel unique) into the rcTarget sub-rectangle of its output format.
|
|
// For instance, if a video compressor has as input 160x120 RGB, and as output
|
|
// 320x240 MPEG with an rcSource of (10,10,20,20) and rcTarget of (0,0,100,100)
|
|
// this means the compressor is being asked to take a 10x10 piece of the 160x120
|
|
// RGB bitmap, and make it fill the top 100x100 area of a 320x240 bitmap,
|
|
// leaving the rest of the 320x240 bitmap untouched.
|
|
// A filter does not have to support this and can fail to connect with a
|
|
// media type where rcSource and rcTarget are not empty.
|
|
//
|
|
// Your output pin is connected to the next filter with a certain media
|
|
// type (either directly or using the media type passed by SetFormat),
|
|
// and you need to look at the AvgBytesPerSecond field of the format
|
|
// of that mediatype to see what data rate you are being asked to compress
|
|
// the video to, and use that data rate. Using the number of frames per
|
|
// second in AvgTimePerFrame, you can figure out how many bytes each frame
|
|
// is supposed to be. You can make it smaller, but NEVER EVER make a bigger
|
|
// data rate. For a video compressor, your input pin's media type tells you
|
|
// the frame rate (use that AvgTimePerFrame). For a capture filter, the
|
|
// output media type tells you, so use that AvgTimePerFrame.
|
|
//
|
|
// The cropping rectangle described below is the same as the rcSrc of the
|
|
// output pin's media type.
|
|
//
|
|
// The output rectangle described below is the same of the width and height
|
|
// of the BITMAPINFOHEADER of the media type of the output pin's media type
|
|
|
|
|
|
// AUDIO EXAMPLE
|
|
//
|
|
// This API can return an array of pairs of (media type, capabilities).
|
|
// This can be used to expose all kinds of wierd capabilities. Let's say you
|
|
// do any PCM frequency from 11,025 to 44,100 at 8 or 16 bit mono or
|
|
// stereo, and you also do 48,000 16bit stereo as a special combination.
|
|
// You would expose 3 pairs. The first pair would have Min Freq of 11025 and
|
|
// Max Freq of 44100, with MaxChannels=2 and MinBits=8 and MaxBits=8 for the
|
|
// capabilites structure, and a media type of anything you like, maybe
|
|
// 22kHz, 8bit stereo as a default.
|
|
// The 2nd pair would be the same except for MinBits=16 and MaxBits=16 in
|
|
// the capabilities structure and the media type could be something like
|
|
// 44kHz, 16bit stereo as a default (the media type in the pair should always
|
|
// be something legal as described by the capabilities structure... the
|
|
// structure tells you how you can change the media type to produce other
|
|
// legal media types... for instance changing 44kHz to 29010Hz would be legal,
|
|
// but changing bits from 16 to 14 would not be.)
|
|
// The 3rd pair would be MinFreq=48000 MaxFreq=48000 MaxChannels=2
|
|
// MinBits=16 and MaxBits=16, and the media type would be 48kHz 16bit stereo.
|
|
// You can also use the Granularity elements of the structure (like the example
|
|
// for video) if you support values that multiples of n, eg. you could say
|
|
// minimum bits per sample 8, max 16, and granularity 8 to describe doing
|
|
// either 8 or 16 bit all in one structure
|
|
//
|
|
// If you support non-PCM formats, the media type returned in GetStreamCaps
|
|
// can show which non-PCM formats you support (with a default sample rate,
|
|
// bit rate and channels) and the capabilities structure going with that
|
|
// media type can describe which other sample rates, bit rates and channels
|
|
// you support.
|
|
|
|
[
|
|
object,
|
|
uuid(C6E13340-30AC-11d0-A18C-00A0C9118956),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMStreamConfig : IUnknown
|
|
{
|
|
|
|
// this is the structure returned by a VIDEO filter
|
|
//
|
|
typedef struct _VIDEO_STREAM_CONFIG_CAPS {
|
|
|
|
GUID guid; // will be MEDIATYPE_Video
|
|
|
|
// the logical or of all the AnalogVideoStandard's supported
|
|
// typically zero if not supported
|
|
ULONG VideoStandard;
|
|
|
|
// the inherent size of the incoming signal... taken from the input
|
|
// pin for a compressor, or the largest size a capture filter can
|
|
// digitize the signal with every pixel still unique
|
|
SIZE InputSize;
|
|
|
|
// The input of a compressor filter may have to be connected for these
|
|
// to be known
|
|
|
|
// smallest rcSrc cropping rect allowed
|
|
SIZE MinCroppingSize;
|
|
// largest rcSrc cropping rect allowed
|
|
SIZE MaxCroppingSize;
|
|
// granularity of cropping size - eg only widths a multiple of 4 allowed
|
|
int CropGranularityX;
|
|
int CropGranularityY;
|
|
// alignment of cropping rect - eg rect must start on multiple of 4
|
|
int CropAlignX;
|
|
int CropAlignY;
|
|
|
|
// The input of a compressor filter may have to be connected for these
|
|
// to be known
|
|
|
|
// smallest bitmap this pin can produce
|
|
SIZE MinOutputSize;
|
|
// largest bitmap this pin can produce
|
|
SIZE MaxOutputSize;
|
|
// granularity of output bitmap size
|
|
int OutputGranularityX;
|
|
int OutputGranularityY;
|
|
// !!! what about alignment of rcTarget inside BIH if different?
|
|
|
|
// how well can you stretch in the x direction? 0==not at all
|
|
// 1=pixel doubling 2=interpolation(2 taps) 3=better interpolation
|
|
// etc.
|
|
int StretchTapsX;
|
|
int StretchTapsY;
|
|
// how well can you shrink in the x direction? 0==not at all
|
|
// 1=pixel doubling 2=interpolation(2 taps) 3=better interpolation
|
|
// etc.
|
|
int ShrinkTapsX;
|
|
int ShrinkTapsY;
|
|
|
|
// CAPTURE filter only - what frame rates are allowed?
|
|
LONGLONG MinFrameInterval;
|
|
LONGLONG MaxFrameInterval;
|
|
|
|
// what data rates can this pin produce?
|
|
LONG MinBitsPerSecond;
|
|
LONG MaxBitsPerSecond;
|
|
} VIDEO_STREAM_CONFIG_CAPS;
|
|
|
|
|
|
// this is the structure returned by an AUDIO filter
|
|
//
|
|
typedef struct _AUDIO_STREAM_CONFIG_CAPS {
|
|
|
|
GUID guid; // will be MEDIATYPE_Audio
|
|
ULONG MinimumChannels;
|
|
ULONG MaximumChannels;
|
|
ULONG ChannelsGranularity;
|
|
ULONG MinimumBitsPerSample;
|
|
ULONG MaximumBitsPerSample;
|
|
ULONG BitsPerSampleGranularity;
|
|
ULONG MinimumSampleFrequency;
|
|
ULONG MaximumSampleFrequency;
|
|
ULONG SampleFrequencyGranularity;
|
|
} AUDIO_STREAM_CONFIG_CAPS;
|
|
|
|
// - only allowed when pin is not streaming, else the call will FAIL
|
|
// - If your output pin is not yet connected, and you can
|
|
// connect your output pin with this media type, you should
|
|
// succeed the call, and start offering it first (enumerate as format#0)
|
|
// from GetMediaType so that this format will be used to connect with
|
|
// when you do connect to somebody
|
|
// - if your output pin is already connected, and you can provide this
|
|
// type, reconnect your pin. If the other pin can't accept it, FAIL
|
|
// this call and leave your connection alone.
|
|
HRESULT SetFormat(
|
|
[in] AM_MEDIA_TYPE *pmt);
|
|
|
|
// the format it's connected with, or will connect with
|
|
// the application is responsible for calling DeleteMediaType(*ppmt);
|
|
HRESULT GetFormat(
|
|
[out] AM_MEDIA_TYPE **ppmt);
|
|
|
|
// how many different Stream Caps structures are there?
|
|
// also, how big is the stream caps structure?
|
|
HRESULT GetNumberOfCapabilities(
|
|
[out] int *piCount,
|
|
[out] int *piSize); // pSCC of GetStreamCaps needs to be this big
|
|
|
|
// - gets one of the pairs of {Mediatype, Caps}
|
|
// - return S_FALSE if iIndex is too high
|
|
// - the application is responsible for calling DeleteMediaType(*ppmt);
|
|
// - the first thing pSCC points to is a GUID saying MEDIATYPE_Video
|
|
// or MEDIATYPE_Audio, so you can tell if you have a pointer to a
|
|
// VIDEO_STREAM_CONFIG_CAPS or an AUDIO_STREAM_CONFIG_CAPS structure
|
|
// There could potentially be many more possibilities other than video
|
|
// or audio.
|
|
HRESULT GetStreamCaps(
|
|
[in] int iIndex, // 0 to #caps-1
|
|
[out] AM_MEDIA_TYPE **ppmt,
|
|
[out] BYTE *pSCC);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Interface to control interleaving of different streams in one file
|
|
[
|
|
object,
|
|
uuid(BEE3D220-157B-11d0-BD23-00A0C911CE86),
|
|
pointer_default(unique)
|
|
]
|
|
interface IConfigInterleaving : IUnknown
|
|
{
|
|
import "unknwn.idl";
|
|
|
|
typedef enum
|
|
{
|
|
// uninterleaved - samples written out in the order they
|
|
// arrive.
|
|
INTERLEAVE_NONE,
|
|
|
|
// approximate interleaving with less overhead for video
|
|
// capture
|
|
INTERLEAVE_CAPTURE,
|
|
|
|
// full, precise interleaving. slower.
|
|
INTERLEAVE_FULL,
|
|
|
|
// samples written out in the order they arrive. writes are
|
|
// buffered
|
|
INTERLEAVE_NONE_BUFFERED
|
|
|
|
} InterleavingMode;
|
|
|
|
HRESULT put_Mode(
|
|
[in] InterleavingMode mode
|
|
);
|
|
|
|
HRESULT get_Mode(
|
|
[out] InterleavingMode *pMode
|
|
);
|
|
|
|
HRESULT put_Interleaving(
|
|
[in] const REFERENCE_TIME *prtInterleave,
|
|
[in] const REFERENCE_TIME *prtPreroll
|
|
);
|
|
|
|
HRESULT get_Interleaving(
|
|
[out] REFERENCE_TIME *prtInterleave,
|
|
[out] REFERENCE_TIME *prtPreroll
|
|
);
|
|
}
|
|
|
|
// Interface to control the AVI mux
|
|
[
|
|
object,
|
|
uuid(5ACD6AA0-F482-11ce-8B67-00AA00A3F1A6),
|
|
pointer_default(unique)
|
|
]
|
|
interface IConfigAviMux : IUnknown
|
|
{
|
|
import "unknwn.idl";
|
|
|
|
// control whether the AVI mux adjusts the frame rate or audio
|
|
// sampling rate for drift when the file is closed. -1 to disables
|
|
// this behavior.
|
|
HRESULT SetMasterStream([in] LONG iStream);
|
|
HRESULT GetMasterStream([out] LONG *pStream);
|
|
|
|
// control whether the AVI mux writes out an idx1 index chunk for
|
|
// compatibility with older AVI players.
|
|
HRESULT SetOutputCompatibilityIndex([in] BOOL fOldIndex);
|
|
HRESULT GetOutputCompatibilityIndex([out] BOOL *pfOldIndex);
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
// CompressionCaps enum
|
|
//---------------------------------------------------------------------
|
|
|
|
// This tells you which features of IAMVideoCompression are supported
|
|
|
|
// CanCrunch means that it can compress video to a specified data rate
|
|
// If so, then the output pin's media type will contain that data rate
|
|
// in the format's AvgBytesPerSecond field, and that should be used.
|
|
|
|
typedef enum
|
|
{
|
|
CompressionCaps_CanQuality = 0x01,
|
|
CompressionCaps_CanCrunch = 0x02,
|
|
CompressionCaps_CanKeyFrame = 0x04,
|
|
CompressionCaps_CanBFrame = 0x08,
|
|
CompressionCaps_CanWindow = 0x10
|
|
} CompressionCaps;
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
// IAMVideoCompression interface
|
|
//
|
|
// Control compression parameters - pin interface
|
|
//---------------------------------------------------------------------
|
|
|
|
// This interface is implemented by the output pin of a video capture
|
|
// filter or video compressor that provides video data
|
|
|
|
// You use this interface to control how video is compressed... how
|
|
// many keyframes, etc., and to find information like capabilities and
|
|
// the description of this compressor
|
|
|
|
[
|
|
object,
|
|
uuid(C6E13343-30AC-11d0-A18C-00A0C9118956),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMVideoCompression : IUnknown
|
|
{
|
|
// - Only valid if GetInfo's pCapabilities sets
|
|
// CompressionCaps_CanKeyFrame
|
|
// - KeyFrameRate < 0 means use the compressor default
|
|
// - KeyFrames == 0 means only the first frame is a key
|
|
HRESULT put_KeyFrameRate (
|
|
[in] long KeyFrameRate);
|
|
|
|
HRESULT get_KeyFrameRate (
|
|
[out] long * pKeyFrameRate);
|
|
|
|
// - Only valid if GetInfo's pCapabilities sets
|
|
// CompressionCaps_CanBFrame
|
|
// - If keyframes are every 10, and there are 3 P Frames per key,
|
|
// they will be spaced evenly between the key frames and the other
|
|
// 6 frames will be B frames
|
|
// - PFramesPerKeyFrame < 0 means use the compressor default
|
|
HRESULT put_PFramesPerKeyFrame (
|
|
[in] long PFramesPerKeyFrame);
|
|
|
|
HRESULT get_PFramesPerKeyFrame (
|
|
[out] long * pPFramesPerKeyFrame);
|
|
|
|
// - Only valid if GetInfo's pCapabilities sets
|
|
// CompressionCaps_CanQuality
|
|
// - Controls image quality
|
|
// - If you are compressing to a fixed data rate, a high quality
|
|
// means try and use all of the data rate, and a low quality means
|
|
// feel free to use much lower than the data rate if you want to.
|
|
// - Quality < 0 means use the compressor default
|
|
HRESULT put_Quality (
|
|
[in] double Quality);
|
|
|
|
HRESULT get_Quality (
|
|
[out] double * pQuality);
|
|
|
|
// If you have set a data rate of 100K/sec on a 10fps movie, that
|
|
// will normally mean each frame must be <=10K. But a window size
|
|
// means every consecutive n frames must average to the data rate,
|
|
// but an individual frame (if n > 1) is allowed to exceed the
|
|
// frame size suggested by the data rate
|
|
HRESULT put_WindowSize (
|
|
[in] DWORDLONG WindowSize);
|
|
|
|
HRESULT get_WindowSize (
|
|
[out] DWORDLONG * pWindowSize);
|
|
|
|
// - pszVersion might be "Version 2.1.0"
|
|
// - pszDescription might be "Danny's awesome video compressor"
|
|
// - pcbVersion and pcbDescription will be filled in with the
|
|
// required length if they are too short
|
|
// - *pCapabilities is a logical OR of some CompressionCaps flags
|
|
HRESULT GetInfo(
|
|
[out, size_is(*pcbVersion)] WCHAR * pszVersion,
|
|
[in,out] int *pcbVersion,
|
|
[out, size_is(*pcbDescription)] LPWSTR pszDescription,
|
|
[in,out] int *pcbDescription,
|
|
[out] long *pDefaultKeyFrameRate,
|
|
[out] long *pDefaultPFramesPerKey,
|
|
[out] double *pDefaultQuality,
|
|
[out] long *pCapabilities //CompressionCaps
|
|
);
|
|
|
|
// - this means when this frame number comes along after the graph
|
|
// is running, make it a keyframe even if you weren't going to
|
|
HRESULT OverrideKeyFrame(
|
|
[in] long FrameNumber
|
|
);
|
|
|
|
// - Only valid if GetInfo's pCapabilities sets
|
|
// CompressionCaps_CanCrunch
|
|
// - this means when this frame number comes along after the graph
|
|
// is running, make it this many bytes big instead of whatever size
|
|
// you were going to make it.
|
|
HRESULT OverrideFrameSize(
|
|
[in] long FrameNumber,
|
|
[in] long Size
|
|
);
|
|
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
// VfwCaptureDialogs enum
|
|
//---------------------------------------------------------------------
|
|
|
|
typedef enum
|
|
{
|
|
VfwCaptureDialog_Source = 0x01,
|
|
VfwCaptureDialog_Format = 0x02,
|
|
VfwCaptureDialog_Display = 0x04
|
|
} VfwCaptureDialogs;
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
// VfwCompressDialogs enum
|
|
//---------------------------------------------------------------------
|
|
|
|
typedef enum
|
|
{
|
|
VfwCompressDialog_Config = 0x01,
|
|
VfwCompressDialog_About = 0x02,
|
|
// returns S_OK if the dialog exists and can be shown, else S_FALSE
|
|
VfwCompressDialog_QueryConfig = 0x04,
|
|
VfwCompressDialog_QueryAbout = 0x08
|
|
} VfwCompressDialogs;
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
// IAMVfwCaptureDialogs - filter interface
|
|
//
|
|
// Show a VfW capture driver dialog - SOURCE, FORMAT, or DISPLAY
|
|
//---------------------------------------------------------------------
|
|
|
|
// This interface is supported only by Microsoft's Video For Windows
|
|
// capture driver Capture Filter. It allows an application to bring up
|
|
// one of the 3 driver dialogs that VfW capture drivers have.
|
|
|
|
[
|
|
object,
|
|
local,
|
|
uuid(D8D715A0-6E5E-11D0-B3F0-00AA003761C5),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMVfwCaptureDialogs : IUnknown
|
|
{
|
|
HRESULT HasDialog(
|
|
[in] int iDialog // VfwCaptureDialogs enum
|
|
);
|
|
|
|
HRESULT ShowDialog(
|
|
[in] int iDialog, // VfwCaptureDialogs enum
|
|
[in] HWND hwnd
|
|
);
|
|
|
|
HRESULT SendDriverMessage(
|
|
[in] int iDialog, // VfwCaptureDialogs enum
|
|
[in] int uMsg,
|
|
[in] long dw1,
|
|
[in] long dw2
|
|
);
|
|
|
|
// - iDialog can be one of the VfwCaptureDialogs enums
|
|
// - HasDialog returns S_OK if it has the dialog, else S_FALSE
|
|
// - ShowDialog can only be called when not streaming or when another
|
|
// dialog is not already up
|
|
// - SendDriverMessage can send a private message to the capture driver.
|
|
// USE IT AT YOUR OWN RISK!
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
// IAMVfwCompressDialogs - filter interface
|
|
//
|
|
// Show a VfW codec driver dialog - CONFIG or ABOUT
|
|
//---------------------------------------------------------------------
|
|
|
|
// This interface is supported only by Microsoft's ICM Compressor filter
|
|
// (Co). It allows an application to bring up either the Configure or
|
|
// About dialogs for the ICM codec that it is currently using.
|
|
|
|
[
|
|
object,
|
|
local,
|
|
uuid(D8D715A3-6E5E-11D0-B3F0-00AA003761C5),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMVfwCompressDialogs : IUnknown
|
|
{
|
|
|
|
// Bring up a dialog for this codec
|
|
HRESULT ShowDialog(
|
|
[in] int iDialog, // VfwCompressDialogs enum
|
|
[in] HWND hwnd
|
|
);
|
|
|
|
// Calls ICGetState and gives you the result
|
|
HRESULT GetState(
|
|
[out, size_is(*pcbState)] LPVOID pState,
|
|
[in, out] int *pcbState
|
|
);
|
|
|
|
// Calls ICSetState
|
|
HRESULT SetState(
|
|
[in, size_is(cbState)] LPVOID pState,
|
|
[in] int cbState
|
|
);
|
|
|
|
// Send a codec specific message
|
|
HRESULT SendDriverMessage(
|
|
[in] int uMsg,
|
|
[in] long dw1,
|
|
[in] long dw2
|
|
);
|
|
|
|
// - iDialog can be one of the VfwCaptureDialogs enums
|
|
// - ShowDialog can only be called when not streaming or when no other
|
|
// dialog is up already
|
|
// - an application can call GetState after ShowDialog(CONFIG) to
|
|
// see how the compressor was configured and next time the graph
|
|
// is used, it can call SetState with the data it saved to return
|
|
// the codec to the state configured by the dialog box from last time
|
|
// - GetState with a NULL pointer returns the size needed
|
|
// - SendDriverMessage can send a private message to the codec.
|
|
// USE IT AT YOUR OWN RISK!
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
// IAMDroppedFrames interface
|
|
//
|
|
// Report status of capture - pin interface
|
|
//---------------------------------------------------------------------
|
|
|
|
// A capture filter's video output pin supports this. It reports
|
|
// how many frames were not sent (dropped), etc.
|
|
|
|
// Every time your filter goes from STOPPED-->PAUSED, you reset all your
|
|
// counts to zero.
|
|
|
|
// An app may call this all the time while you are capturing to see how
|
|
// capturing is going. MAKE SURE you always return as current information
|
|
// as possible while you are running.
|
|
|
|
// When your capture filter starts running, it starts by sending frame 0,
|
|
// then 1, 2, 3, etc. The time stamp of each frame sent should correspond
|
|
// to the graph clock's time when the image was digitized. The end time
|
|
// is the start time plus the duration of the video frame.
|
|
// You should also set the MediaTime of each sample (SetMediaTime) as well.
|
|
// This should be the frame number ie (0,1) (1,2) (2,3).
|
|
// If a frame is dropped, a downstream filter will be able to tell easily
|
|
// not by looking for gaps in the regular time stamps, but by noticing a
|
|
// frame number is missing (eg. (1,2) (2,3) (4,5) (5,6) means frame 3
|
|
// was dropped.
|
|
|
|
// Using the info provided by this interface, an application can figure out
|
|
// the number of frames dropped, the frame rate achieved (the length of
|
|
// time the graph was running divided by the number of frames not dropped),
|
|
// and the data rate acheived (the length of time the graph was running
|
|
// divided by the average frame size).
|
|
|
|
// If your filter is running, then paused, and then run again, you need
|
|
// to continue to deliver frames as if it was never paused. The first
|
|
// frame after the second RUN cannot be time stamped earlier than the last
|
|
// frame sent before the pause.
|
|
|
|
// Your filter must always increment the MediaTime of each sample sent.
|
|
// Never send the same frame # twice, and never go back in time. The
|
|
// regular time stamp of a sample can also never go back in time.
|
|
|
|
[
|
|
object,
|
|
uuid(C6E13344-30AC-11d0-A18C-00A0C9118956),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMDroppedFrames : IUnknown
|
|
{
|
|
// Get the number of dropped frames
|
|
HRESULT GetNumDropped(
|
|
[out] long * plDropped
|
|
|
|
);
|
|
|
|
//Get the number of non-dropped frames
|
|
HRESULT GetNumNotDropped(
|
|
[out] long * plNotDropped
|
|
|
|
);
|
|
|
|
// - plArray points to an array of lSize longs. The filter will
|
|
// fill it with the frame number of the first lSize frames dropped.
|
|
// A filter may not have bothered to remember as many as you asked
|
|
// for, so it will set *plNumCopied to the number of frames it filled
|
|
// in.
|
|
HRESULT GetDroppedInfo(
|
|
[in] long lSize,
|
|
[out] long * plArray,
|
|
[out] long * plNumCopied
|
|
);
|
|
|
|
// - This is the average size of the frames it didn't drop (in bytes)
|
|
HRESULT GetAverageFrameSize(
|
|
[out] long * plAverageSize
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
cpp_quote("#define AMF_AUTOMATICGAIN -1.0")
|
|
|
|
//---------------------------------------------------------------------
|
|
// IAMAudioInputMixer interface
|
|
//
|
|
// Sets the recording levels, pan and EQ for the audio card inputs
|
|
//---------------------------------------------------------------------
|
|
|
|
// This interface is implemented by each input pin of an audio capture
|
|
// filter, to tell it what level, panning, and EQ to use for each input.
|
|
// The name of each pin will reflect the type of input, eg. "Line input 1"
|
|
// or "Mic". An application uses the pin names to decide how it wants to
|
|
// set the recording levels
|
|
|
|
// This interface can also be supported by the audio capture filter itself
|
|
// to control to overall record level and panning after the mix
|
|
|
|
[
|
|
object,
|
|
uuid(54C39221-8380-11d0-B3F0-00AA003761C5),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMAudioInputMixer : IUnknown
|
|
{
|
|
// This interface is only supported by the input pins, not the filter
|
|
// If disabled, this channel will not be mixed in as part of the
|
|
// recorded signal.
|
|
HRESULT put_Enable (
|
|
[in] BOOL fEnable); // TRUE=enable FALSE=disable
|
|
|
|
//Is this channel enabled?
|
|
HRESULT get_Enable (
|
|
[out] BOOL *pfEnable);
|
|
|
|
// When set to mono mode, making a stereo recording of this channel
|
|
// will have both channels contain the same data... a mixture of the
|
|
// left and right signals
|
|
HRESULT put_Mono (
|
|
[in] BOOL fMono); // TRUE=mono FALSE=multi channel
|
|
|
|
//all channels combined into a mono signal?
|
|
HRESULT get_Mono (
|
|
[out] BOOL *pfMono);
|
|
|
|
// !!! WILL CARDS BE ABLE TO BOOST THE GAIN?
|
|
//Set the record level for this channel
|
|
HRESULT put_MixLevel (
|
|
[in] double Level); // 0 = off, 1 = full (unity?) volume
|
|
// AMF_AUTOMATICGAIN, if supported,
|
|
// means automatic
|
|
|
|
//Get the record level for this channel
|
|
HRESULT get_MixLevel (
|
|
[out] double *pLevel);
|
|
|
|
// For instance, when panned full left, and you make a stereo recording
|
|
// of this channel, you will record a silent right channel.
|
|
HRESULT put_Pan (
|
|
[in] double Pan); // -1 = full left, 0 = centre, 1 = right
|
|
|
|
//Get the pan for this channel
|
|
HRESULT get_Pan (
|
|
[out] double *pPan);
|
|
|
|
// Boosts the bass of low volume signals before they are recorded
|
|
// to compensate for the fact that your ear has trouble hearing quiet
|
|
// bass sounds
|
|
HRESULT put_Loudness (
|
|
[in] BOOL fLoudness);// TRUE=on FALSE=off
|
|
|
|
HRESULT get_Loudness (
|
|
[out] BOOL *pfLoudness);
|
|
|
|
// boosts or cuts the treble of the signal before it's recorded by
|
|
// a certain amount of dB
|
|
HRESULT put_Treble (
|
|
[in] double Treble); // gain in dB (-ve = attenuate)
|
|
|
|
//Get the treble EQ for this channel
|
|
HRESULT get_Treble (
|
|
[out] double *pTreble);
|
|
|
|
// This is the maximum value allowed in put_Treble. ie 6.0 means
|
|
// any value between -6.0 and 6.0 is allowed
|
|
HRESULT get_TrebleRange (
|
|
[out] double *pRange); // largest value allowed
|
|
|
|
// boosts or cuts the bass of the signal before it's recorded by
|
|
// a certain amount of dB
|
|
HRESULT put_Bass (
|
|
[in] double Bass); // gain in dB (-ve = attenuate)
|
|
|
|
// Get the bass EQ for this channel
|
|
HRESULT get_Bass (
|
|
[out] double *pBass);
|
|
|
|
// This is the maximum value allowed in put_Bass. ie 6.0 means
|
|
// any value between -6.0 and 6.0 is allowed
|
|
HRESULT get_BassRange (
|
|
[out] double *pRange); // largest value allowed
|
|
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
// IAMBufferNegotiation interface
|
|
//
|
|
// Tells a pin what kinds of buffers to use when connected
|
|
//---------------------------------------------------------------------
|
|
|
|
// This interface can be implemented by any pin that will connect to
|
|
// another pin using IMemInputPin. All capture filters should support
|
|
// this interface.
|
|
|
|
// SuggestAllocatorProperties is a way for an application to get
|
|
// in on the buffer negotiation process for a pin. This pin will use
|
|
// the numbers given to it by the application as its request to the
|
|
// allocator. An application can use a negative number for any element
|
|
// in the ALLOCATOR_PROPERTIES to mean "don't care". An application must
|
|
// call this function before the pin is connected, or it will be too late
|
|
// To ensure that an application gets what it wants, it would be wise to
|
|
// call this method on both pins being connected together, so the other
|
|
// pin doesn't overrule the application's request.
|
|
|
|
// GetAllocatorProperties can only be called after a pin is connected and
|
|
// it returns the properties of the current allocator being used
|
|
|
|
[
|
|
object,
|
|
uuid(56ED71A0-AF5F-11D0-B3F0-00AA003761C5),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMBufferNegotiation : IUnknown
|
|
{
|
|
HRESULT SuggestAllocatorProperties (
|
|
[in] const ALLOCATOR_PROPERTIES *pprop);
|
|
|
|
HRESULT GetAllocatorProperties (
|
|
[out] ALLOCATOR_PROPERTIES *pprop);
|
|
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
// AnalogVideoStandard enum
|
|
//---------------------------------------------------------------------
|
|
|
|
typedef enum tagAnalogVideoStandard
|
|
{
|
|
AnalogVideo_None = 0x00000000, // This is a digital sensor
|
|
AnalogVideo_NTSC_M = 0x00000001, // 75 IRE Setup
|
|
AnalogVideo_NTSC_M_J = 0x00000002, // Japan, 0 IRE Setup
|
|
AnalogVideo_NTSC_433 = 0x00000004,
|
|
|
|
AnalogVideo_PAL_B = 0x00000010,
|
|
AnalogVideo_PAL_D = 0x00000020,
|
|
AnalogVideo_PAL_G = 0x00000040,
|
|
AnalogVideo_PAL_H = 0x00000080,
|
|
AnalogVideo_PAL_I = 0x00000100,
|
|
AnalogVideo_PAL_M = 0x00000200,
|
|
AnalogVideo_PAL_N = 0x00000400,
|
|
|
|
AnalogVideo_PAL_60 = 0x00000800,
|
|
|
|
AnalogVideo_SECAM_B = 0x00001000,
|
|
AnalogVideo_SECAM_D = 0x00002000,
|
|
AnalogVideo_SECAM_G = 0x00004000,
|
|
AnalogVideo_SECAM_H = 0x00008000,
|
|
AnalogVideo_SECAM_K = 0x00010000,
|
|
AnalogVideo_SECAM_K1 = 0x00020000,
|
|
AnalogVideo_SECAM_L = 0x00040000,
|
|
AnalogVideo_SECAM_L1 = 0x00080000,
|
|
|
|
AnalogVideo_PAL_N_COMBO // Argentina
|
|
= 0x00100000
|
|
} AnalogVideoStandard;
|
|
|
|
cpp_quote("#define AnalogVideo_NTSC_Mask 0x00000007")
|
|
cpp_quote("#define AnalogVideo_PAL_Mask 0x00100FF0")
|
|
cpp_quote("#define AnalogVideo_SECAM_Mask 0x000FF000")
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
// TunerInputType enum
|
|
//---------------------------------------------------------------------
|
|
|
|
typedef enum tagTunerInputType
|
|
{
|
|
TunerInputCable,
|
|
TunerInputAntenna
|
|
} TunerInputType;
|
|
|
|
//---------------------------------------------------------------------
|
|
// VideoCopyProtectionType enum
|
|
//---------------------------------------------------------------------
|
|
|
|
typedef enum
|
|
{
|
|
VideoCopyProtectionMacrovisionBasic,
|
|
VideoCopyProtectionMacrovisionCBI
|
|
} VideoCopyProtectionType;
|
|
|
|
//---------------------------------------------------------------------
|
|
// PhysicalConnectorType enum
|
|
//---------------------------------------------------------------------
|
|
|
|
typedef enum tagPhysicalConnectorType
|
|
{
|
|
PhysConn_Video_Tuner = 1,
|
|
PhysConn_Video_Composite,
|
|
PhysConn_Video_SVideo,
|
|
PhysConn_Video_RGB,
|
|
PhysConn_Video_YRYBY,
|
|
PhysConn_Video_SerialDigital,
|
|
PhysConn_Video_ParallelDigital,
|
|
PhysConn_Video_SCSI,
|
|
PhysConn_Video_AUX,
|
|
PhysConn_Video_1394,
|
|
PhysConn_Video_USB,
|
|
PhysConn_Video_VideoDecoder,
|
|
PhysConn_Video_VideoEncoder,
|
|
PhysConn_Video_SCART,
|
|
PhysConn_Video_Black,
|
|
|
|
|
|
PhysConn_Audio_Tuner = 0x1000,
|
|
PhysConn_Audio_Line,
|
|
PhysConn_Audio_Mic,
|
|
PhysConn_Audio_AESDigital,
|
|
PhysConn_Audio_SPDIFDigital,
|
|
PhysConn_Audio_SCSI,
|
|
PhysConn_Audio_AUX,
|
|
PhysConn_Audio_1394,
|
|
PhysConn_Audio_USB,
|
|
PhysConn_Audio_AudioDecoder,
|
|
} PhysicalConnectorType;
|
|
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
// IAMAnalogVideoDecoder interface
|
|
//---------------------------------------------------------------------
|
|
|
|
[
|
|
object,
|
|
uuid(C6E13350-30AC-11d0-A18C-00A0C9118956),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMAnalogVideoDecoder : IUnknown
|
|
{
|
|
|
|
//Gets the supported analog video standards (NTSC/M, PAL/B, SECAM/K1...
|
|
HRESULT get_AvailableTVFormats(
|
|
[out] long *lAnalogVideoStandard
|
|
);
|
|
|
|
//Sets or gets the current analog video standard (NTSC/M, PAL/B, SECAM/K1, ...
|
|
HRESULT put_TVFormat(
|
|
[in] long lAnalogVideoStandard
|
|
);
|
|
|
|
// Sets or gets the current analog video standard (NTSC/M, PAL/B, SECAM/K1, ...
|
|
HRESULT get_TVFormat(
|
|
[out] long * plAnalogVideoStandard
|
|
);
|
|
|
|
// True if horizontal sync is locked
|
|
HRESULT get_HorizontalLocked (
|
|
[out] long * plLocked);
|
|
|
|
// True if connected to a VCR (changes PLL timing)
|
|
HRESULT put_VCRHorizontalLocking (
|
|
[in] long lVCRHorizontalLocking);
|
|
|
|
HRESULT get_VCRHorizontalLocking (
|
|
[out] long * plVCRHorizontalLocking);
|
|
|
|
// Returns the number of lines in the video signal")]
|
|
HRESULT get_NumberOfLines (
|
|
[out] long *plNumberOfLines);
|
|
|
|
// Enables or disables the output bus
|
|
HRESULT put_OutputEnable (
|
|
[in] long lOutputEnable);
|
|
|
|
HRESULT get_OutputEnable (
|
|
[out] long *plOutputEnable);
|
|
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
// VideoProcAmp Property enum
|
|
//---------------------------------------------------------------------
|
|
|
|
typedef enum tagVideoProcAmpProperty
|
|
{
|
|
VideoProcAmp_Brightness,
|
|
VideoProcAmp_Contrast,
|
|
VideoProcAmp_Hue,
|
|
VideoProcAmp_Saturation,
|
|
VideoProcAmp_Sharpness,
|
|
VideoProcAmp_Gamma,
|
|
VideoProcAmp_ColorEnable,
|
|
VideoProcAmp_WhiteBalance,
|
|
VideoProcAmp_BacklightCompensation,
|
|
VideoProcAmp_Gain
|
|
} VideoProcAmpProperty;
|
|
|
|
//---------------------------------------------------------------------
|
|
// VideoProcAmp Flags enum
|
|
//---------------------------------------------------------------------
|
|
|
|
typedef enum tagVideoProcAmpFlags
|
|
{
|
|
VideoProcAmp_Flags_Auto = 0x0001,
|
|
VideoProcAmp_Flags_Manual = 0x0002
|
|
} VideoProcAmpFlags;
|
|
|
|
//---------------------------------------------------------------------
|
|
// IAMVideoProcAmp interface
|
|
//
|
|
// Adjusts video quality in either the analog or digital domain.
|
|
//
|
|
//---------------------------------------------------------------------
|
|
|
|
[
|
|
object,
|
|
uuid(C6E13360-30AC-11d0-A18C-00A0C9118956),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMVideoProcAmp : IUnknown
|
|
{
|
|
// Returns min, max, step size, and default values
|
|
HRESULT GetRange(
|
|
[in] long Property, // Which property to query
|
|
[out] long * pMin, // Range minimum
|
|
[out] long * pMax, // Range maxumum
|
|
[out] long * pSteppingDelta,// Step size
|
|
[out] long * pDefault, // Default value
|
|
[out] long * pCapsFlags // VideoProcAmpFlags
|
|
|
|
);
|
|
|
|
// Set a VideoProcAmp property
|
|
HRESULT Set(
|
|
[in] long Property, // VideoProcAmpProperty
|
|
[in] long lValue, // Value to set
|
|
[in] long Flags // VideoProcAmp_Flags_*
|
|
|
|
);
|
|
|
|
// Get a VideoProcAmp property
|
|
HRESULT Get(
|
|
[in] long Property, // VideoProcAmpProperty
|
|
[out] long * lValue, // Current value
|
|
[out] long * Flags // VideoProcAmp_Flags_*
|
|
);
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
// CameraControl Property enum
|
|
//---------------------------------------------------------------------
|
|
|
|
typedef enum tagCameraControlProperty
|
|
{
|
|
CameraControl_Pan,
|
|
CameraControl_Tilt,
|
|
CameraControl_Roll,
|
|
CameraControl_Zoom,
|
|
CameraControl_Exposure,
|
|
CameraControl_Iris,
|
|
CameraControl_Focus
|
|
} CameraControlProperty;
|
|
|
|
//---------------------------------------------------------------------
|
|
// CameraControl Flags enum
|
|
//---------------------------------------------------------------------
|
|
|
|
typedef enum tagCameraControlFlags
|
|
{
|
|
CameraControl_Flags_Auto = 0x0001,
|
|
CameraControl_Flags_Manual = 0x0002
|
|
} CameraControlFlags;
|
|
|
|
//---------------------------------------------------------------------
|
|
// IAMCameraControl interface
|
|
//
|
|
// Control of local or remote cameras
|
|
//---------------------------------------------------------------------
|
|
|
|
[
|
|
object,
|
|
uuid(C6E13370-30AC-11d0-A18C-00A0C9118956),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMCameraControl : IUnknown
|
|
{
|
|
// Returns min, max, step size, and default values
|
|
HRESULT GetRange(
|
|
[in] long Property, // Which property to query
|
|
[out] long * pMin, // Range minimum
|
|
[out] long * pMax, // Range maxumum
|
|
[out] long * pSteppingDelta,// Step size
|
|
[out] long * pDefault, // Default value
|
|
[out] long * pCapsFlags // CamaeraControlFlags
|
|
|
|
);
|
|
|
|
// Set a CameraControl property
|
|
HRESULT Set(
|
|
[in] long Property, // CameraControlProperty
|
|
[in] long lValue, // Value to set
|
|
[in] long Flags // CameraControl_Flags_*
|
|
|
|
);
|
|
|
|
// Get a CameraControl property
|
|
HRESULT Get(
|
|
[in] long Property, // CameraControlProperty
|
|
[out] long * lValue, // Current value
|
|
[out] long * Flags // CameraControl_Flags_*
|
|
);
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
// VideoControl Flags enum
|
|
//---------------------------------------------------------------------
|
|
|
|
typedef enum tagVideoControlFlags
|
|
{
|
|
VideoControlFlag_FlipHorizontal = 0x0001,
|
|
VideoControlFlag_FlipVertical = 0x0002,
|
|
VideoControlFlag_ExternalTriggerEnable = 0x0004,
|
|
VideoControlFlag_Trigger = 0x0008
|
|
|
|
} VideoControlFlags;
|
|
|
|
//---------------------------------------------------------------------
|
|
// IAMVideoControl interface
|
|
//
|
|
// Control of horizontal & vertical flip, external trigger,
|
|
// and listing available frame rates
|
|
//---------------------------------------------------------------------
|
|
|
|
[
|
|
object,
|
|
uuid(6a2e0670-28e4-11d0-a18c-00a0c9118956),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMVideoControl : IUnknown
|
|
{
|
|
// What can the underlying hardware do?
|
|
HRESULT GetCaps(
|
|
[in] IPin * pPin, // the pin to query or control
|
|
[out] long * pCapsFlags // VideoControlFlag_*
|
|
|
|
);
|
|
|
|
// Set the mode of operation
|
|
HRESULT SetMode(
|
|
[in] IPin * pPin, // the pin to query or control
|
|
[in] long Mode // VideoControlFlag_*
|
|
|
|
);
|
|
|
|
// Get the mode of operation
|
|
HRESULT GetMode(
|
|
[in] IPin * pPin, // the pin to query or control
|
|
[out] long * Mode // VideoControlFlag_*
|
|
);
|
|
|
|
// Get actual frame rate info for USB and 1394
|
|
// This is only available when streaming
|
|
HRESULT GetCurrentActualFrameRate(
|
|
[in] IPin * pPin, // the pin to query or control
|
|
[out] LONGLONG * ActualFrameRate // 100 nS units
|
|
);
|
|
|
|
// Get max available frame rate info for USB and 1394
|
|
// Returns the max frame rate currently available based on bus bandwidth usage
|
|
HRESULT GetMaxAvailableFrameRate(
|
|
[in] IPin * pPin, // the pin to query or control
|
|
[in] long iIndex, // 0 to IAMStreamConfig->GetNumberOfCapabilities-1
|
|
[in] SIZE Dimensions, // width and height
|
|
[out] LONGLONG * MaxAvailableFrameRate // 100 nS units
|
|
);
|
|
|
|
// Get List of available frame rates
|
|
HRESULT GetFrameRateList(
|
|
[in] IPin * pPin, // the pin to query or control
|
|
[in] long iIndex, // 0 to IAMStreamConfig->GetNumberOfCapabilities-1
|
|
[in] SIZE Dimensions, // width and height
|
|
[out] long * ListSize, // Number of elements in the list
|
|
[out] LONGLONG ** FrameRates // Array of framerates in 100 nS units
|
|
// or NULL to just get ListSize
|
|
);
|
|
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
// IAMCrossbar interface
|
|
//
|
|
// Controls a routing matrix for analog or digital video or audio
|
|
//---------------------------------------------------------------------
|
|
|
|
[
|
|
object,
|
|
uuid(C6E13380-30AC-11d0-A18C-00A0C9118956),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMCrossbar : IUnknown
|
|
{
|
|
|
|
// How many pins are there?
|
|
HRESULT get_PinCounts(
|
|
[out] long * OutputPinCount, // count of output pins
|
|
[out] long * InputPinCount); // count of input pins
|
|
|
|
// True if routing is possible
|
|
HRESULT CanRoute (
|
|
[in] long OutputPinIndex, // the output pin
|
|
[in] long InputPinIndex); // the input pin
|
|
|
|
// Routes an input pin to an output pin
|
|
HRESULT Route (
|
|
[in] long OutputPinIndex, // the output pin
|
|
[in] long InputPinIndex); // the input pin
|
|
|
|
// Returns the input pin connected to a given output pin
|
|
HRESULT get_IsRoutedTo (
|
|
[in] long OutputPinIndex, // the output pin
|
|
[out] long * InputPinIndex); // the connected input pin
|
|
|
|
// Returns a pin which is related to a given pin
|
|
// (ie. this audio pin is related to a video pin)
|
|
HRESULT get_CrossbarPinInfo (
|
|
[in] BOOL IsInputPin, // TRUE for input pins
|
|
[in] long PinIndex, // a pin
|
|
[out] long * PinIndexRelated, // Index of related pin
|
|
[out] long * PhysicalType); // Physical type of pin
|
|
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
// IAMTuner interface
|
|
//
|
|
// base tuner device
|
|
//---------------------------------------------------------------------
|
|
|
|
// predefined subchannel values
|
|
typedef enum tagAMTunerSubChannel
|
|
{
|
|
AMTUNER_SUBCHAN_NO_TUNE = -2, // don't tune
|
|
AMTUNER_SUBCHAN_DEFAULT = -1 // use default sub chan
|
|
} AMTunerSubChannel;
|
|
|
|
// predefined signal strength values
|
|
typedef enum tagAMTunerSignalStrength
|
|
{
|
|
AMTUNER_HASNOSIGNALSTRENGTH = -1, // cannot indicate signal strength
|
|
AMTUNER_NOSIGNAL = 0, // no signal available
|
|
AMTUNER_SIGNALPRESENT = 1 // signal present
|
|
} AMTunerSignalStrength;
|
|
|
|
// specifies the mode of operation of the tuner
|
|
typedef enum tagAMTunerModeType
|
|
{
|
|
AMTUNER_MODE_DEFAULT = 0x0000, // default tuner mode
|
|
AMTUNER_MODE_TV = 0x0001, // tv
|
|
AMTUNER_MODE_FM_RADIO = 0x0002, // fm radio
|
|
AMTUNER_MODE_AM_RADIO = 0x0004, // am radio
|
|
AMTUNER_MODE_DSS = 0x0008, // dss
|
|
} AMTunerModeType;
|
|
|
|
// Events reported by IAMTunerNotification
|
|
typedef enum tagAMTunerEventType{
|
|
AMTUNER_EVENT_CHANGED = 0x0001, // status changed
|
|
} AMTunerEventType;
|
|
|
|
interface IAMTunerNotification;
|
|
|
|
[
|
|
object,
|
|
uuid(211A8761-03AC-11d1-8D13-00AA00BD8339),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMTuner : IUnknown
|
|
{
|
|
// Sets and gets the Channel
|
|
HRESULT put_Channel(
|
|
[in] long lChannel,
|
|
[in] long lVideoSubChannel,
|
|
[in] long lAudioSubChannel
|
|
);
|
|
HRESULT get_Channel(
|
|
[out] long *plChannel,
|
|
[out] long *plVideoSubChannel,
|
|
[out] long *plAudioSubChannel
|
|
);
|
|
|
|
// Gets the minimum and maximum channel available
|
|
HRESULT ChannelMinMax(
|
|
[out] long *lChannelMin,
|
|
[out] long *lChannelMax
|
|
);
|
|
|
|
// CountryCode is the same as the international
|
|
// long distance telephone dialing prefix
|
|
|
|
HRESULT put_CountryCode(
|
|
[in] long lCountryCode
|
|
);
|
|
HRESULT get_CountryCode(
|
|
[out] long *plCountryCode
|
|
);
|
|
|
|
HRESULT put_TuningSpace(
|
|
[in] long lTuningSpace
|
|
);
|
|
HRESULT get_TuningSpace(
|
|
[out] long *plTuningSpace
|
|
);
|
|
|
|
[local] HRESULT Logon(
|
|
[in] HANDLE hCurrentUser
|
|
);
|
|
HRESULT Logout();
|
|
|
|
// Signal status for current channel
|
|
// signal strength == TUNER_NOSIGNAL, or strength value
|
|
HRESULT SignalPresent(
|
|
[out] long * plSignalStrength // AMTunerSignalStrength
|
|
);
|
|
|
|
// allow multifunction tuner to be switch between modes
|
|
HRESULT put_Mode(
|
|
[in] AMTunerModeType lMode // AMTunerModeType
|
|
);
|
|
HRESULT get_Mode(
|
|
[out] AMTunerModeType *plMode // AMTunerModeType
|
|
);
|
|
|
|
// retrieve a bitmask of the possible modes
|
|
HRESULT GetAvailableModes(
|
|
[out] long *plModes // AMTunerModeType
|
|
);
|
|
|
|
// allow IAMTuner clients to receive event notification
|
|
HRESULT RegisterNotificationCallBack(
|
|
[in] IAMTunerNotification *pNotify,
|
|
[in] long lEvents // bitmask from AMTunerEventType enumeration
|
|
);
|
|
HRESULT UnRegisterNotificationCallBack(
|
|
[in] IAMTunerNotification *pNotify
|
|
);
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
// IAMTunerNotification interface
|
|
//
|
|
// Provided to IAMTuner if notification callbacks are desired
|
|
//---------------------------------------------------------------------
|
|
|
|
[
|
|
object,
|
|
uuid(211A8760-03AC-11d1-8D13-00AA00BD8339),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMTunerNotification : IUnknown
|
|
{
|
|
HRESULT OnEvent([in] AMTunerEventType Event);
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
// IAMTVTuner interface
|
|
//
|
|
// Controls an analog TV tuner device
|
|
//---------------------------------------------------------------------
|
|
|
|
[
|
|
object,
|
|
uuid(211A8766-03AC-11d1-8D13-00AA00BD8339),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMTVTuner : IAMTuner
|
|
{
|
|
// Gets the supported analog video standards (NTSC/M, PAL/B, SECAM/K1, ...
|
|
HRESULT get_AvailableTVFormats(
|
|
[out] long *lAnalogVideoStandard
|
|
);
|
|
|
|
// Gets the current analog video standard (NTSC/M, PAL/B, SECAM/K1, ...)
|
|
HRESULT get_TVFormat(
|
|
[out] long * plAnalogVideoStandard
|
|
);
|
|
|
|
// Scans for a signal on a given channel
|
|
// NOTE: this is equivalent to put_Channel(), SignalStrength()
|
|
HRESULT AutoTune(
|
|
[in] long lChannel,
|
|
[out] long * plFoundSignal
|
|
);
|
|
|
|
// Saves the fine tuning information for all channels")]
|
|
HRESULT StoreAutoTune();
|
|
|
|
// The number of TV sources plugged into the tuner
|
|
HRESULT get_NumInputConnections(
|
|
[out] long * plNumInputConnections
|
|
);
|
|
|
|
// Sets or gets the tuner input type (Cable or Antenna)
|
|
HRESULT put_InputType(
|
|
[in] long lIndex,
|
|
[in] TunerInputType InputType
|
|
);
|
|
HRESULT get_InputType(
|
|
[in] long lIndex,
|
|
[out] TunerInputType * pInputType
|
|
);
|
|
|
|
// Sets or gets the tuner input
|
|
HRESULT put_ConnectInput(
|
|
[in] long lIndex
|
|
);
|
|
HRESULT get_ConnectInput(
|
|
[out] long *plIndex
|
|
);
|
|
|
|
// Gets the video and audio carrier frequencies
|
|
HRESULT get_VideoFrequency(
|
|
[out] long *lFreq
|
|
);
|
|
HRESULT get_AudioFrequency(
|
|
[out] long *lFreq
|
|
);
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
// IBPCSatelliteTuner interface
|
|
//
|
|
// An interface supporting Satellite tuning-related functions
|
|
//---------------------------------------------------------------------
|
|
[
|
|
object,
|
|
local,
|
|
uuid(211A8765-03AC-11d1-8D13-00AA00BD8339),
|
|
pointer_default(unique)
|
|
]
|
|
interface IBPCSatelliteTuner : IAMTuner
|
|
{
|
|
HRESULT get_DefaultSubChannelTypes(
|
|
[out] long *plDefaultVideoType, // Provider-specific service type
|
|
[out] long *plDefaultAudioType // Provider-specific service type
|
|
);
|
|
|
|
HRESULT put_DefaultSubChannelTypes(
|
|
[in] long lDefaultVideoType, // Provider-specific service type
|
|
[in] long lDefaultAudioType // Provider-specific service type
|
|
);
|
|
|
|
HRESULT IsTapingPermitted(); // S_OK yes, S_FALSE no
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
// IAMTVAudio interface
|
|
//
|
|
// TV Audio control
|
|
//---------------------------------------------------------------------
|
|
|
|
typedef enum tagTVAudioMode
|
|
{
|
|
AMTVAUDIO_MODE_MONO = 0x0001, // Mono
|
|
AMTVAUDIO_MODE_STEREO = 0x0002, // Stereo
|
|
AMTVAUDIO_MODE_LANG_A = 0x0010, // Primary language
|
|
AMTVAUDIO_MODE_LANG_B = 0x0020, // 2nd avail language
|
|
AMTVAUDIO_MODE_LANG_C = 0x0040, // 3rd avail language
|
|
} TVAudioMode;
|
|
|
|
// Events reported by IAMTVAudioNotification
|
|
typedef enum tagAMTVAudioEventType
|
|
{
|
|
AMTVAUDIO_EVENT_CHANGED = 0x0001, // mode changed
|
|
} AMTVAudioEventType;
|
|
|
|
interface IAMTVAudioNotification;
|
|
|
|
[
|
|
object,
|
|
local,
|
|
uuid(83EC1C30-23D1-11d1-99E6-00A0C9560266),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMTVAudio : IUnknown
|
|
{
|
|
// retrieve a bitmask of the formats available in the hardware
|
|
HRESULT GetHardwareSupportedTVAudioModes(
|
|
[out] long *plModes // TVAudioMode
|
|
);
|
|
|
|
// retrieve a bitmask of the possible modes
|
|
HRESULT GetAvailableTVAudioModes(
|
|
[out] long *plModes // TVAudioMode
|
|
);
|
|
|
|
HRESULT get_TVAudioMode(
|
|
[out] long *plMode // TVAudioMode
|
|
);
|
|
HRESULT put_TVAudioMode(
|
|
[in] long lMode // TVAudioMode
|
|
);
|
|
|
|
// allow IAMTVAudio clients to receive event notification
|
|
HRESULT RegisterNotificationCallBack(
|
|
[in] IAMTunerNotification *pNotify,
|
|
[in] long lEvents // bitmask from AMTVAudioEventType enumeration
|
|
);
|
|
HRESULT UnRegisterNotificationCallBack(
|
|
IAMTunerNotification *pNotify
|
|
);
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
// IAMTVAudioNotification interface
|
|
//
|
|
// Provided to IAMTVAudio clients if notification callbacks are desired
|
|
//---------------------------------------------------------------------
|
|
|
|
[
|
|
object,
|
|
local,
|
|
uuid(83EC1C33-23D1-11d1-99E6-00A0C9560266),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMTVAudioNotification : IUnknown
|
|
{
|
|
HRESULT OnEvent([in] AMTVAudioEventType Event);
|
|
}
|
|
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
// IAMAnalogVideoEncoder interface
|
|
//---------------------------------------------------------------------
|
|
|
|
[
|
|
object,
|
|
uuid(C6E133B0-30AC-11d0-A18C-00A0C9118956),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMAnalogVideoEncoder : IUnknown
|
|
{
|
|
// Gets the supported analog video standards (NTSC/M, PAL/B, SECAM/K1, ...)
|
|
HRESULT get_AvailableTVFormats(
|
|
[out] long *lAnalogVideoStandard
|
|
);
|
|
|
|
// Sets or gets the current analog video standard (NTSC/M, PAL/B, SECAM/K1, ...)
|
|
HRESULT put_TVFormat(
|
|
[in] long lAnalogVideoStandard
|
|
);
|
|
|
|
HRESULT get_TVFormat(
|
|
[out] long * plAnalogVideoStandard
|
|
);
|
|
|
|
// Sets or gets the copy protection
|
|
HRESULT put_CopyProtection (
|
|
[in] long lVideoCopyProtection); // VideoCopyProtectionType
|
|
|
|
HRESULT get_CopyProtection (
|
|
[out] long *lVideoCopyProtection); // VideoCopyProtectionType
|
|
|
|
|
|
// Enables and disables close captioning
|
|
HRESULT put_CCEnable (
|
|
[in] long lCCEnable);
|
|
|
|
HRESULT get_CCEnable (
|
|
[out] long *lCCEnable);
|
|
|
|
}
|
|
|
|
// used by IKsPropertySet set AMPROPSETID_Pin
|
|
typedef enum {
|
|
AMPROPERTY_PIN_CATEGORY,
|
|
AMPROPERTY_PIN_MEDIUM
|
|
} AMPROPERTY_PIN;
|
|
|
|
//---------------------------------------------------------------------
|
|
// IKsPropertySet interface
|
|
//
|
|
// Sets or gets a property identified by a property set GUID and a
|
|
// property ID.
|
|
//
|
|
// Return codes for all 3 methods:
|
|
// E_PROP_SET_UNSUPPORTED the property set is not supported
|
|
// E_PROP_ID_UNSUPPORTED the property ID is not supported
|
|
// for the specified property set
|
|
//---------------------------------------------------------------------
|
|
|
|
cpp_quote("#ifndef _IKsPropertySet_")
|
|
cpp_quote("#define _IKsPropertySet_")
|
|
|
|
//---------------------------------------------------------------------
|
|
// #defines for IKsPropertySet::QuerySupported return result in pTypeSupport
|
|
//---------------------------------------------------------------------
|
|
|
|
cpp_quote("#define KSPROPERTY_SUPPORT_GET 1")
|
|
cpp_quote("#define KSPROPERTY_SUPPORT_SET 2")
|
|
|
|
|
|
[
|
|
object,
|
|
uuid(31EFAC30-515C-11d0-A9AA-00AA0061BE93),
|
|
pointer_default(unique)
|
|
]
|
|
interface IKsPropertySet : IUnknown
|
|
{
|
|
[local] HRESULT Set(
|
|
[in] REFGUID guidPropSet,
|
|
[in] DWORD dwPropID,
|
|
[in, size_is(cbInstanceData)] LPVOID pInstanceData,
|
|
[in] DWORD cbInstanceData,
|
|
[in, size_is(cbPropData)] LPVOID pPropData,
|
|
[in] DWORD cbPropData);
|
|
|
|
[call_as(Set)] HRESULT RemoteSet(
|
|
[in] REFGUID guidPropSet,
|
|
[in] DWORD dwPropID,
|
|
[in, size_is(cbInstanceData)] byte * pInstanceData,
|
|
[in] DWORD cbInstanceData,
|
|
[in, size_is(cbPropData)] byte * pPropData,
|
|
[in] DWORD cbPropData);
|
|
|
|
// To get a property, the caller allocates a buffer which the called
|
|
// function fills in. To determine necessary buffer size, call Get with
|
|
// pPropData=NULL and cbPropData=0.
|
|
[local] HRESULT Get(
|
|
[in] REFGUID guidPropSet,
|
|
[in] DWORD dwPropID,
|
|
[in, size_is(cbInstanceData)] LPVOID pInstanceData,
|
|
[in] DWORD cbInstanceData,
|
|
[out, size_is(cbPropData)] LPVOID pPropData,
|
|
[in] DWORD cbPropData,
|
|
[out] DWORD * pcbReturned);
|
|
|
|
[call_as(Get)] HRESULT RemoteGet(
|
|
[in] REFGUID guidPropSet,
|
|
[in] DWORD dwPropID,
|
|
[in, size_is(cbInstanceData)] byte * pInstanceData,
|
|
[in] DWORD cbInstanceData,
|
|
[out, size_is(cbPropData)] byte * pPropData,
|
|
[in] DWORD cbPropData,
|
|
[out] DWORD * pcbReturned);
|
|
// QuerySupported must either return E_NOTIMPL or correctly indicate
|
|
// if getting or setting the property set and property is supported.
|
|
// S_OK indicates the property set and property ID combination is
|
|
HRESULT QuerySupported(
|
|
[in] REFGUID guidPropSet,
|
|
[in] DWORD dwPropID,
|
|
[out] DWORD *pTypeSupport);
|
|
}
|
|
cpp_quote("#endif // _IKsPropertySet_")
|
|
|
|
[
|
|
object,
|
|
uuid(6025A880-C0D5-11d0-BD4E-00A0C911CE86),
|
|
pointer_default(unique)
|
|
]
|
|
interface IMediaPropertyBag : IPropertyBag
|
|
{
|
|
import "ocidl.idl";
|
|
|
|
typedef IMediaPropertyBag *LPMEDIAPROPERTYBAG;
|
|
|
|
// return the i'th element in the property bag
|
|
HRESULT EnumProperty(
|
|
[in] ULONG iProperty,
|
|
[in, out] VARIANT * pvarPropertyName,
|
|
[in, out] VARIANT * pvarPropertyValue
|
|
);
|
|
|
|
}
|
|
|
|
|
|
[
|
|
object,
|
|
uuid(5738E040-B67F-11d0-BD4D-00A0C911CE86),
|
|
pointer_default(unique)
|
|
]
|
|
interface IPersistMediaPropertyBag : IPersist
|
|
{
|
|
import "ocidl.idl";
|
|
import "unknwn.idl";
|
|
|
|
HRESULT InitNew(
|
|
void
|
|
);
|
|
|
|
HRESULT Load(
|
|
[in] IMediaPropertyBag * pPropBag,
|
|
[in] IErrorLog * pErrorLog
|
|
);
|
|
|
|
HRESULT Save(
|
|
[in] IMediaPropertyBag * pPropBag,
|
|
[in] BOOL fClearDirty,
|
|
[in] BOOL fSaveAllProperties
|
|
);
|
|
|
|
|
|
typedef IPersistMediaPropertyBag * LPPERSISTMEDIAPROPERTYBAG;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
//
|
|
// Defines IAMPhysicalPinInfo Interface
|
|
//
|
|
// Returns an enum and string that describes an input pin's physical type.
|
|
//
|
|
// Implement if: you have physical input pins such as video or audio (like
|
|
// on a video capture card or a VCR)
|
|
//
|
|
// Use if: you want to communicate to a user available physical input pins
|
|
// and allow them to select the active one if there is more than one
|
|
//---------------------------------------------------------------------
|
|
|
|
|
|
[
|
|
object,
|
|
uuid(F938C991-3029-11cf-8C44-00AA006B6814),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMPhysicalPinInfo : IUnknown {
|
|
|
|
// Returns VFW_E_NO_ACCEPTABLE_TYPES if not a physical pin
|
|
HRESULT GetPhysicalType(
|
|
[out] long *pType, // the enum representing the Physical Type
|
|
[out] LPOLESTR *ppszType // a friendly name
|
|
);
|
|
}
|
|
typedef IAMPhysicalPinInfo *PAMPHYSICALPININFO;
|
|
|
|
//---------------------------------------------------------------------
|
|
// Defines IAMExtDevice Interface
|
|
//
|
|
// Base interface for external professional devices
|
|
//
|
|
// Implement if: the filter controls an external device such as a VCR,
|
|
// timecode reader/generator, etc. The intent is to build a object from
|
|
// this implementation plus another that specifically describes the device,
|
|
// such as IAMExtTransport.
|
|
//
|
|
// Use if: you want to control and external device such as a VCR
|
|
//
|
|
// See edevdefs.h for the enumerated parameter list
|
|
//---------------------------------------------------------------------
|
|
[
|
|
object,
|
|
uuid(B5730A90-1A2C-11cf-8C23-00AA006B6814),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMExtDevice : IUnknown
|
|
{
|
|
// General device capabilities property. See edevdefs.h for supported
|
|
// values
|
|
HRESULT GetCapability(
|
|
[in] long Capability, // identify the property
|
|
[out] long *pValue, // return value
|
|
[out] double *pdblValue // return value
|
|
);
|
|
|
|
// Get external device identification string. Usually the model #
|
|
// of the device
|
|
HRESULT get_ExternalDeviceID(
|
|
[out] LPOLESTR *ppszData // ID string
|
|
);
|
|
|
|
HRESULT get_ExternalDeviceVersion(
|
|
[out] LPOLESTR *ppszData // revision string
|
|
);
|
|
|
|
// Controls the external device's power mode
|
|
HRESULT put_DevicePower([in] long PowerMode
|
|
);
|
|
HRESULT get_DevicePower([out] long *pPowerMode
|
|
);
|
|
|
|
// Some devices need to be reset in some way, i.e., rewinding a VCR
|
|
// to the beginning of the tape and resetting the counter to zero.
|
|
HRESULT Calibrate(
|
|
[in] HEVENT hEvent,
|
|
[in] long Mode,
|
|
[out] long *pStatus // OATRUE is active, OAFALSE is inactive
|
|
);
|
|
|
|
// Selects the device's communications port, i.e.,COM1, IEEE1394, etc.
|
|
// See edevdefs.h for enums
|
|
HRESULT put_DevicePort([in] long DevicePort
|
|
);
|
|
HRESULT get_DevicePort([out] long *pDevicePort
|
|
);
|
|
|
|
}
|
|
typedef IAMExtDevice *PEXTDEVICE;
|
|
|
|
//---------------------------------------------------------------------
|
|
// Defines IAMExtTransport Interface
|
|
//
|
|
// Contains properties and methods that control behavior of an external
|
|
// transport device such as a VTR
|
|
//
|
|
// Implement if: you control such a device. Intended to be agregated
|
|
// with IAMExtDevice.
|
|
//
|
|
// Use if: you want to control such a device
|
|
//
|
|
// See edevdefs.h for the parameter lists
|
|
//---------------------------------------------------------------------
|
|
[
|
|
object,
|
|
uuid(A03CD5F0-3045-11cf-8C44-00AA006B6814),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMExtTransport : IUnknown {
|
|
|
|
// General transport capabilities property. See edevdefs.h for enums
|
|
HRESULT GetCapability(
|
|
[in] long Capability, // identify the property
|
|
[out] long *pValue, // return value
|
|
[out] double *pdblValue // return value
|
|
);
|
|
|
|
// For disc-based devices: spinning, or not spinning.
|
|
// For tape-based device: threaded, unthreaded or ejected
|
|
HRESULT put_MediaState([in] long State
|
|
);
|
|
HRESULT get_MediaState([out] long *pState // see edevdefs.h
|
|
);
|
|
|
|
// Determines state of unit's front panel
|
|
HRESULT put_LocalControl([in] long State
|
|
);
|
|
HRESULT get_LocalControl([out] long *pState // OATRUE or OAFALSE
|
|
);
|
|
|
|
// Transport status such as Play, Stop, etc. More extensive
|
|
// than AM states.
|
|
HRESULT GetStatus(
|
|
[in] long StatusItem, // see edevdefs.h
|
|
[out] long *pValue
|
|
);
|
|
|
|
// Parameters such as recording speed, servo reference, ballistics, etc.
|
|
HRESULT GetTransportBasicParameters(
|
|
[in] long Param,
|
|
[out] long *pValue,
|
|
[out] LPOLESTR *ppszData
|
|
);
|
|
|
|
HRESULT SetTransportBasicParameters(
|
|
[in] long Param,
|
|
[in] long Value,
|
|
[in] LPCOLESTR pszData
|
|
);
|
|
|
|
// Parameters such as video output mode
|
|
HRESULT GetTransportVideoParameters(
|
|
[in] long Param,
|
|
[out] long *pValue
|
|
);
|
|
|
|
HRESULT SetTransportVideoParameters(
|
|
[in] long Param,
|
|
[in] long Value
|
|
);
|
|
|
|
// Parameters such as audio channel enable
|
|
HRESULT GetTransportAudioParameters(
|
|
[in] long Param,
|
|
[out] long *pValue
|
|
);
|
|
|
|
HRESULT SetTransportAudioParameters(
|
|
[in] long Param,
|
|
[in] long Value
|
|
);
|
|
|
|
// Mode is the movement of the transport, i.e., Play, Stop,
|
|
// Record, Edit, etc.
|
|
HRESULT put_Mode([in] long Mode
|
|
);
|
|
HRESULT get_Mode([out] long *pMode
|
|
);
|
|
|
|
// Rate is for variable speed control of the the device. This
|
|
// can be linked to IMediaControl::Rate() in the implementation
|
|
// if desired.
|
|
HRESULT put_Rate([in] double dblRate
|
|
);
|
|
HRESULT get_Rate([out] double *pdblRate
|
|
);
|
|
|
|
// This is a lengthy method, that is, it is in effect until canceled or complete and
|
|
// requires housekeeping by the filter. It puts transport in play mode and maintains
|
|
// fixed relationship between master time reference and transport position.
|
|
HRESULT GetChase(
|
|
[out] long *pEnabled, // OATRUE | OAFALSE
|
|
[out] long *pOffset, // offset in current time format
|
|
[out] HEVENT *phEvent // completion notification
|
|
);
|
|
HRESULT SetChase(
|
|
[in] long Enable, // OATRUE | OAFALSE
|
|
[in] long Offset, // offset in current time format
|
|
[in] HEVENT hEvent // completion notification
|
|
);
|
|
|
|
// Also a lengthy method: temporarily change transport speed (for synchronizing).
|
|
HRESULT GetBump(
|
|
[out] long *pSpeed,
|
|
[out] long *pDuration // in current time format
|
|
);
|
|
HRESULT SetBump(
|
|
[in] long Speed,
|
|
[in] long Duration // in current time format
|
|
);
|
|
|
|
// Enable/Disable transport anti-headclog control.
|
|
HRESULT get_AntiClogControl([out] long *pEnabled // OATRUE | OAFALSE
|
|
);
|
|
HRESULT put_AntiClogControl([in] long Enable // OATRUE | OAFALSE
|
|
);
|
|
|
|
// The following group of properties describes edit events. An edit event can be a
|
|
// standard insert or assemble edit or a memorized position called a bookmark.
|
|
// A NOTE ABOUT EVENTS: as with all lengthy commands, event objects must be created to
|
|
// signal completion or error.
|
|
|
|
// Intended usage: an edit event is prepared for use by:
|
|
// 1. Registering an edit property set and getting an EditID
|
|
// 2. Setting the necessary edit properties
|
|
// 3. Setting the edit property set active
|
|
|
|
// Please see edevdefs.h for properties and values
|
|
|
|
// The reference clock's advance is the mechanism that puts an edit in motion (see
|
|
// ED_EDIT_REC_INPOINT).
|
|
|
|
// Property set methods
|
|
HRESULT GetEditPropertySet(
|
|
[in] long EditID,
|
|
[out] long *pState // ED_SET_ACTIVE | ED_SET_INACTIVE | ED_SET_INVALID
|
|
// | ED_SET_EXECUTING
|
|
);
|
|
|
|
HRESULT SetEditPropertySet(
|
|
[in, out] long *pEditID,
|
|
[in] long State // ED_SET_REGISTER | ED_SET_DELETE | ED_SET_ACTIVE |
|
|
); // ED_SET_INACTIVE
|
|
|
|
// the following properties define an edit event such as a bookmark, seek point, or
|
|
// actual edit
|
|
HRESULT GetEditProperty(
|
|
[in] long EditID,
|
|
[in] long Param,
|
|
[out] long *pValue
|
|
);
|
|
HRESULT SetEditProperty(
|
|
[in] long EditID,
|
|
[in] long Param,
|
|
[in] long Value
|
|
);
|
|
|
|
// Activates a capable transport's edit control (typically used for "on the fly" editing).
|
|
HRESULT get_EditStart([out] long *pValue // OATRUE or OAFALSE
|
|
);
|
|
HRESULT put_EditStart([in] long Value // OATRUE or OAFALSE
|
|
);
|
|
}
|
|
typedef IAMExtTransport *PIAMEXTTRANSPORT;
|
|
|
|
//---------------------------------------------------------------------
|
|
// Defines IAMTimecodeReader Interface
|
|
//
|
|
// Contains properties and methods that define behavior of a
|
|
// SMPTE/MIDI Timecode Reader. It is expected that this interface
|
|
// will be combined (aggregated) with IAMExtTransport to "build" a pro
|
|
// VCR.
|
|
//
|
|
// Implement if: you control such a device
|
|
//
|
|
// Use if: you want to control such a device
|
|
//
|
|
// See edevdefs.h for the parameter lists
|
|
//=====================================================================
|
|
|
|
|
|
// timecode structures
|
|
cpp_quote("#if 0")
|
|
cpp_quote("/* the following is what MIDL knows how to remote */")
|
|
typedef struct tagTIMECODE {
|
|
WORD wFrameRate; // will be replaced by AM defs, but see ED_FORMAT_SMPTE for now
|
|
WORD wFrameFract; // fractional frame. full scale is always 0x1000
|
|
DWORD dwFrames;
|
|
}TIMECODE;
|
|
cpp_quote("#else /* 0 */")
|
|
cpp_quote("#ifndef TIMECODE_DEFINED")
|
|
cpp_quote("#define TIMECODE_DEFINED")
|
|
cpp_quote("typedef union _timecode {")
|
|
cpp_quote(" struct {")
|
|
cpp_quote(" WORD wFrameRate;")
|
|
cpp_quote(" WORD wFrameFract;")
|
|
cpp_quote(" DWORD dwFrames;")
|
|
cpp_quote(" };")
|
|
cpp_quote(" DWORDLONG qw;")
|
|
cpp_quote(" } TIMECODE;")
|
|
cpp_quote("")
|
|
cpp_quote("#endif /* TIMECODE_DEFINED */")
|
|
cpp_quote("#endif /* 0 */")
|
|
|
|
typedef TIMECODE *PTIMECODE;
|
|
|
|
typedef struct tagTIMECODE_SAMPLE {
|
|
LONGLONG qwTick; // ActiveMovie 100ns timestamp
|
|
TIMECODE timecode; // timecode
|
|
DWORD dwUser; // timecode user data (aka user bits)
|
|
DWORD dwFlags; // timecode flags - see below
|
|
} TIMECODE_SAMPLE;
|
|
typedef TIMECODE_SAMPLE *PTIMECODE_SAMPLE;
|
|
|
|
|
|
[
|
|
object,
|
|
uuid(9B496CE1-811B-11cf-8C77-00AA006B6814),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMTimecodeReader : IUnknown
|
|
{
|
|
// Timecode Reader Mode - gets/sets the following properties
|
|
// ED_TCR_SOURCE - timecode gen (readback), LTC, VITC, or Control Track
|
|
HRESULT GetTCRMode(
|
|
[in] long Param,
|
|
[out] long *pValue);
|
|
HRESULT SetTCRMode(
|
|
[in] long Param,
|
|
[in] long Value);
|
|
|
|
// Select which line of the vertical interval timecode will be read from (if VITC).
|
|
// To read VITC on specific multiple lines, the caller would make successive calls to
|
|
// put_VITCLine(), once for each line desired.
|
|
HRESULT put_VITCLine(
|
|
[in] long Line ); // valid lines are 11-20, 0 means autoselect,
|
|
// hi bit set means add to list of lines (for
|
|
// readers that test across multiple lines)
|
|
HRESULT get_VITCLine(
|
|
[out] long *pLine ); // hi bit set means multiple lines are used,
|
|
// and successive calls will cycle through the
|
|
// line numbers (like an enumerator, only simpler)
|
|
|
|
// GetTimecode can be used to obtain the most recent timecode value available in the
|
|
// stream. The client can use this to monitor the timecode, parse duplicates and
|
|
// discontinuities. The source filter supplying the timecode or possibly a down stream
|
|
// filter might want to parse for discontinuities or errors since you have to look at
|
|
// every sample to do this properly.
|
|
//
|
|
|
|
HRESULT GetTimecode(
|
|
[out] PTIMECODE_SAMPLE pTimecodeSample) ;
|
|
|
|
}
|
|
typedef IAMTimecodeReader *PIAMTIMECODEREADER;
|
|
|
|
//---------------------------------------------------------------------
|
|
//=====================================================================
|
|
// Defines IAMTimecodeGenerator Interface
|
|
//
|
|
// Contains properties and methods that define behavior of an external
|
|
// SMPTE/MIDI Timecode Generator. It is expected that this interface
|
|
// will be combined (aggregated) with IAMExtTransport to "build" a pro
|
|
// VCR.
|
|
//
|
|
// Implement if: you control such a device
|
|
//
|
|
// Use if: you want to control such a device
|
|
//
|
|
// See edevdefs.h for the parameter lists
|
|
//---------------------------------------------------------------------
|
|
[
|
|
object,
|
|
uuid(9B496CE0-811B-11cf-8C77-00AA006B6814),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMTimecodeGenerator : IUnknown {
|
|
|
|
// Timecode Generator Mode - gets/sets the following properties (see
|
|
// vcrdefss.h for detailed values):
|
|
// ED_TCG_TIMECODE_TYPE - LTC, VITC, or MIDI
|
|
// ED_TCG_FRAMERATE - 24, 25, 30 drop or 30 nondrop
|
|
// ED_TCG_SYNC_SOURCE - what is driving the bitclock
|
|
// ED_TCG_REFERENCE_SOURCE - what is driving the count value
|
|
HRESULT GetTCGMode(
|
|
[in] long Param,
|
|
[out] long *pValue);
|
|
|
|
HRESULT SetTCGMode(
|
|
[in] long Param,
|
|
[in] long Value);
|
|
|
|
// Select into which line(s) of the vertical interval timecode will be inserted (if VITC).
|
|
// Hi bit set means add this line to any previously set lines.
|
|
// To generate VITC on specific multiple lines, the caller would make successive calls to
|
|
// put_VITCLine(), once for each line desired.
|
|
HRESULT put_VITCLine(
|
|
[in] long Line // valid lines are 11-20, 0 means autoselect(this setting
|
|
); // is for TC readers that decode from multiple lines)
|
|
HRESULT get_VITCLine(
|
|
[out] long *pLine
|
|
);
|
|
|
|
// Sets timecode and/or userbit value. If generator is running, takes effect
|
|
// immediately. If caller wants to set only timecode, set userbit value to -1L (and
|
|
// same for setting userbits only)
|
|
//
|
|
|
|
HRESULT SetTimecode(
|
|
[in] PTIMECODE_SAMPLE pTimecodeSample) ;
|
|
|
|
|
|
// GetTimecode can be used to obtain the most recent timecode value available in the
|
|
// stream. The client can use this to monitor the timecode and verify the generator is
|
|
// working properly
|
|
//
|
|
|
|
HRESULT GetTimecode(
|
|
[out] PTIMECODE_SAMPLE pTimecodeSample) ;
|
|
|
|
}
|
|
typedef IAMTimecodeGenerator *PIAMTIMECODEGENERATOR;
|
|
|
|
//---------------------------------------------------------------------
|
|
// Defines IAMTimecodeDisplay Interface
|
|
//
|
|
// Contains properties and methods that define behavior of an external
|
|
// SMPTE/MIDI Timecode Display device (aka "character generator" for
|
|
// making "burn-ins" or "window dubs"). It is expected that this interface
|
|
// will be combined (aggregated) with IAMExtTransport and the timecode
|
|
// interfaces to "build" a pro VCR.
|
|
//
|
|
// Implement if: you control such a device
|
|
//
|
|
// Use if: you want to control such a device
|
|
//
|
|
// See edevdefs.h for the parameter lists
|
|
//---------------------------------------------------------------------
|
|
[
|
|
object,
|
|
uuid(9B496CE2-811B-11cf-8C77-00AA006B6814),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMTimecodeDisplay : IUnknown
|
|
{
|
|
// Enable/disable external device's timecode reader's character generator output. Some
|
|
// readers have this feature - this is not intended for rendering inside the PC!
|
|
HRESULT GetTCDisplayEnable(
|
|
[out] long *pState); // OATRUE | OAFALSE
|
|
HRESULT SetTCDisplayEnable(
|
|
[in] long State); // OATRUE | OAFALSE
|
|
// Timecode reader's character generator output
|
|
// characteristics (size, position, intensity, etc.).
|
|
HRESULT GetTCDisplay(
|
|
[in] long Param,
|
|
[out] long *pValue);
|
|
HRESULT SetTCDisplay(
|
|
[in] long Param,
|
|
[in] long Value);
|
|
|
|
/* Allowable params and values (see edevdefs.h for details):
|
|
ED_TCD_SOURCE
|
|
ED_TCR | ED_TCG
|
|
ED_TCD_SIZE
|
|
ED_SMALL | ED_MED | ED_LARGE
|
|
ED_TCD_POSITION
|
|
ED_TOP | ED_MIDDLE | ED_BOTTOM or'd with
|
|
ED_LEFT | ED_CENTER | ED_RIGHT
|
|
ED_TCD_INTENSITY
|
|
ED_HIGH | ED_LOW
|
|
ED_TCD_TRANSPARENCY // set from 0 to 4, 0 being completely opaque
|
|
ED_TCD_INVERT // white on black or black on white
|
|
OATRUE | OAFALSE
|
|
ED_TCD_BORDER // white border for black chars, black border for white letters
|
|
OATRUE | OAFALSE
|
|
*/
|
|
}
|
|
typedef IAMTimecodeDisplay *PIAMTIMECODEDISPLAY;
|
|
|
|
|
|
[
|
|
object,
|
|
uuid(c6545bf0-e76b-11d0-bd52-00a0c911ce86),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMDevMemoryAllocator : IUnknown
|
|
{
|
|
HRESULT GetInfo(
|
|
[out] DWORD *pdwcbTotalFree,
|
|
[out] DWORD *pdwcbLargestFree,
|
|
[out] DWORD *pdwcbTotalMemory,
|
|
[out] DWORD *pdwcbMinimumChunk);
|
|
|
|
HRESULT CheckMemory(
|
|
[in] const BYTE *pBuffer);
|
|
|
|
HRESULT Alloc(
|
|
[out] BYTE **ppBuffer,
|
|
[in, out] DWORD *pdwcbBuffer);
|
|
|
|
HRESULT Free(
|
|
[in] BYTE *pBuffer);
|
|
|
|
HRESULT GetDevMemoryObject(
|
|
[out] IUnknown **ppUnkInnner,
|
|
[in] IUnknown *pUnkOuter);
|
|
}
|
|
typedef IAMDevMemoryAllocator *PAMDEVMEMORYALLOCATOR;
|
|
|
|
|
|
[
|
|
object,
|
|
uuid(c6545bf1-e76b-11d0-bd52-00a0c911ce86),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMDevMemoryControl : IUnknown
|
|
{
|
|
HRESULT QueryWriteSync();
|
|
|
|
HRESULT WriteSync();
|
|
|
|
HRESULT GetDevId(
|
|
[out] DWORD *pdwDevId);
|
|
|
|
}
|
|
typedef IAMDevMemoryControl *PAMDEVMEMORYCONTROL;
|
|
|
|
// Flags for IAMStreamSelection::Info
|
|
enum _AMSTREAMSELECTINFOFLAGS {
|
|
AMSTREAMSELECTINFO_ENABLED = 0x01, // Enable - off for disable
|
|
AMSTREAMSELECTINFO_EXCLUSIVE = 0x02 // Turns off the others in the group
|
|
// when enabling this one
|
|
};
|
|
// Flags for IAMStreamSelection::Enable
|
|
enum _AMSTREAMSELECTENABLEFLAGS {
|
|
// Currently valid values are :
|
|
// 0 - disable all streams in the group containing this stream
|
|
// ..._ENABLE - enable only this stream with in the given group
|
|
// and disable all others
|
|
// ..._ENABLEALL - send out all streams
|
|
AMSTREAMSELECTENABLE_ENABLE = 0x01, // Enable
|
|
AMSTREAMSELECTENABLE_ENABLEALL = 0x02 // Enable all streams in the group
|
|
// containing this stream
|
|
};
|
|
|
|
// Control which logical streams are played and find out information about
|
|
// them
|
|
// Normally supported by a filter
|
|
[
|
|
object,
|
|
uuid(c1960960-17f5-11d1-abe1-00a0c905f375),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMStreamSelect : IUnknown
|
|
{
|
|
// Returns total count of streams
|
|
HRESULT Count(
|
|
[out] DWORD *pcStreams); // Count of logical streams
|
|
|
|
// Return info for a given stream - S_FALSE if iIndex out of range
|
|
// The first steam in each group is the default
|
|
HRESULT Info(
|
|
[in] long lIndex, // 0-based index
|
|
[out] AM_MEDIA_TYPE **ppmt, // Media type - optional
|
|
// Use DeleteMediaType to free
|
|
[out] DWORD *pdwFlags, // flags - optional
|
|
[out] LCID *plcid, // LCID (returns 0 if none) - optional
|
|
[out] DWORD *pdwGroup, // Logical group - optional
|
|
[out] WCHAR **ppszName, // Name - optional - free with CoTaskMemFree
|
|
// optional
|
|
[out] IUnknown **ppObject, // Associated object - optional
|
|
// Object may change if Enable is
|
|
// called on this interface
|
|
// - returns NULL if no associated object
|
|
// Returns pin or filter for DShow
|
|
[out] IUnknown **ppUnk); // Stream specific interface
|
|
|
|
// Enable or disable a given stream
|
|
HRESULT Enable(
|
|
[in] long lIndex,
|
|
[in] DWORD dwFlags);
|
|
}
|
|
typedef IAMStreamSelect *PAMSTREAMSELECT;
|
|
|
|
enum _AMRESCTL_RESERVEFLAGS
|
|
{
|
|
AMRESCTL_RESERVEFLAGS_RESERVE = 0x00, // Increment reserve count
|
|
AMRESCTL_RESERVEFLAGS_UNRESERVE = 0x01 // Decrement reserve count
|
|
};
|
|
|
|
// Reserve resources now so that playback can be subsequently
|
|
// guaranteed
|
|
//
|
|
// Normally supported by a filter
|
|
//
|
|
[
|
|
object,
|
|
uuid(8389d2d0-77d7-11d1-abe6-00a0c905f375),
|
|
pointer_default(unique),
|
|
local
|
|
]
|
|
interface IAMResourceControl : IUnknown
|
|
{
|
|
// The reserve count is incremented/decremented if and only if
|
|
// S_OK is returned
|
|
// Unreserve once for every Reserve call
|
|
HRESULT Reserve(
|
|
[in] DWORD dwFlags, // From _AMRESCTL_RESERVEFLAGS enum
|
|
[in] PVOID pvReserved // Must be NULL
|
|
);
|
|
}
|
|
|
|
|
|
// Set clock adjustments - supported by some clocks
|
|
[
|
|
object,
|
|
uuid(4d5466b0-a49c-11d1-abe8-00a0c905f375),
|
|
pointer_default(unique),
|
|
local
|
|
]
|
|
interface IAMClockAdjust : IUnknown
|
|
{
|
|
// Set the following delta to clock times
|
|
// The clock will add adjust its times by the given delta
|
|
HRESULT SetClockDelta(
|
|
[in] REFERENCE_TIME rtDelta
|
|
);
|
|
};
|
|
|
|
// Filter miscellaneous status flags
|
|
|
|
enum _AM_FILTER_MISC_FLAGS {
|
|
AM_FILTER_MISC_FLAGS_IS_RENDERER = 0x00000001, /* Will deliver EC_COMPLETE
|
|
at end of media */
|
|
AM_FILTER_MISC_FLAGS_IS_SOURCE = 0x00000002 /* Filter sources data */
|
|
};
|
|
|
|
[
|
|
object,
|
|
uuid(2dd74950-a890-11d1-abe8-00a0c905f375),
|
|
pointer_default(unique),
|
|
local
|
|
]
|
|
interface IAMFilterMiscFlags : IUnknown
|
|
{
|
|
// Get miscellaneous property flags
|
|
ULONG GetMiscFlags(void);
|
|
};
|
|
|
|
|
|
// Video Image drawing interface
|
|
[
|
|
object,
|
|
local,
|
|
uuid(48efb120-ab49-11d2-aed2-00a0c995e8d5),
|
|
pointer_default(unique),
|
|
]
|
|
interface IDrawVideoImage : IUnknown
|
|
{
|
|
HRESULT DrawVideoImageBegin();
|
|
|
|
HRESULT DrawVideoImageEnd();
|
|
|
|
HRESULT DrawVideoImageDraw(
|
|
[in] HDC hdc,
|
|
[in] LPRECT lprcSrc,
|
|
[in] LPRECT lprcDst
|
|
);
|
|
}
|
|
|
|
//
|
|
// Video Image decimation interface
|
|
//
|
|
// The aim of this interface is to enable a video renderer filter to
|
|
// control the decimation properties of a video decoder connected to
|
|
// the video renderer
|
|
//
|
|
// This interface should only be supported by decoders that are capable of
|
|
// decimating their output image by an arbitary amount.
|
|
//
|
|
//
|
|
[
|
|
object,
|
|
local,
|
|
uuid(2e5ea3e0-e924-11d2-b6da-00a0c995e8df),
|
|
pointer_default(unique),
|
|
]
|
|
interface IDecimateVideoImage : IUnknown
|
|
{
|
|
//
|
|
// Informs the decoder that it should decimate its output
|
|
// image to the specified width and height. If the decoder can
|
|
// decimate to this size it should return S_OK.
|
|
// If the decoder can't perform the requested decimation
|
|
// or wants to stop performing the decimation that it is
|
|
// currently doing it should return E_FAIL.
|
|
//
|
|
HRESULT SetDecimationImageSize(
|
|
[in] long lWidth,
|
|
[in] long lHeight);
|
|
|
|
//
|
|
// Informs the decoder that it should stop decimating its output image
|
|
// and resume normal output.
|
|
//
|
|
HRESULT ResetDecimationImageSize();
|
|
}
|
|
|
|
typedef enum _DECIMATION_USAGE {
|
|
DECIMATION_LEGACY, // decimate at ovly then video port then crop
|
|
DECIMATION_USE_DECODER_ONLY, // decimate image at the decoder only
|
|
DECIMATION_USE_VIDEOPORT_ONLY, // decimate at the video port only
|
|
DECIMATION_USE_OVERLAY_ONLY, // decimate at the overlay only
|
|
DECIMATION_DEFAULT // decimate at decoder then ovly the vide port then crop
|
|
} DECIMATION_USAGE;
|
|
|
|
[
|
|
object,
|
|
local,
|
|
uuid(60d32930-13da-11d3-9ec6-c4fcaef5c7be),
|
|
pointer_default(unique),
|
|
]
|
|
interface IAMVideoDecimationProperties: IUnknown
|
|
{
|
|
//
|
|
// Queries the current usage of the above IDecimateVideoImage
|
|
// interface.
|
|
//
|
|
HRESULT QueryDecimationUsage(
|
|
[out] DECIMATION_USAGE* lpUsage); // from DECIMATION_USAGE enum
|
|
|
|
//
|
|
// Sets the current usage of the above IDecimateVideoImage
|
|
// interface.
|
|
//
|
|
HRESULT SetDecimationUsage(
|
|
[in] DECIMATION_USAGE Usage); // from DECIMATION_USAGE enum
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
//
|
|
// IVideoFrameStep interface
|
|
//
|
|
//---------------------------------------------------------------------
|
|
|
|
[
|
|
object,
|
|
uuid(e46a9787-2b71-444d-a4b5-1fab7b708d6a),
|
|
pointer_default(unique),
|
|
]
|
|
interface IVideoFrameStep : IUnknown
|
|
{
|
|
//
|
|
// Stop(), Pause(), Run() all cancel Step as does any seeking
|
|
// request.
|
|
//
|
|
// The Step() and CancelStep() methods of this interface
|
|
// Cancel any previous step.
|
|
//
|
|
// When stepping is complete EC_STEP_COMPLETE is signalled.
|
|
//
|
|
// When the filter graph gets EC_STEP_COMPLETE it automatically
|
|
// sets the filter graph into paused state and forwards the
|
|
// notification to the application
|
|
//
|
|
// Returns S_OK if stepping initiated.
|
|
//
|
|
// dwFrames
|
|
// 1 means step 1 frame forward
|
|
// 0 is invalid
|
|
// n (n > 1) means skip n - 1 frames and show the nth
|
|
//
|
|
// pStepObject
|
|
// NULL - default step object (filter) picked
|
|
// non-NULL - use this object for stepping
|
|
//
|
|
HRESULT Step(DWORD dwFrames, [unique] IUnknown *pStepObject);
|
|
|
|
// Can step?
|
|
// Returns S_OK if it can, S_FALSE if it can't or error code.
|
|
// bMultiple - if TRUE return whether can step n > 1
|
|
HRESULT CanStep(long bMultiple, [unique] IUnknown *pStepObject);
|
|
|
|
// Cancel stepping
|
|
HRESULT CancelStep();
|
|
}
|
|
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
//
|
|
// IAMPushSource interface
|
|
//
|
|
// Provides a means for source filters to describe information about the
|
|
// data that they source, such as whether the data is live or not, and
|
|
// what type of clock was used for timestamps. This information may be
|
|
// needed by other clocks in the graph in order to provide accurate
|
|
// synchronization. Also provides a way to specify an offset value for
|
|
// the filter to use when timestamping the streams it sources. Provides
|
|
// support for the IAMLatency interface as well.
|
|
//
|
|
//---------------------------------------------------------------------
|
|
|
|
enum _AM_PUSHSOURCE_FLAGS {
|
|
|
|
//
|
|
// The default assumption is that the data is from a live source,
|
|
// time stamped with the graph clock, and the source does not
|
|
// attempt to rate match the data it delivers.
|
|
// The following flags can be used to override this assumption.
|
|
//
|
|
|
|
// capability flags
|
|
AM_PUSHSOURCECAPS_INTERNAL_RM = 0x00000001, // source provides internal support for rate matching
|
|
AM_PUSHSOURCECAPS_NOT_LIVE = 0x00000002, // don't treat source data as live
|
|
AM_PUSHSOURCECAPS_PRIVATE_CLOCK = 0x00000004, // source data timestamped with clock not
|
|
// exposed to the graph
|
|
|
|
// request flags, set by user via SetPushSourceFlags method
|
|
AM_PUSHSOURCEREQS_USE_STREAM_CLOCK = 0x00010000, // source was requested to timestamp
|
|
// using a clock that isn't the graph clock
|
|
|
|
AM_PUSHSOURCEREQS_USE_CLOCK_CHAIN = 0x00020000, // source requests reference clock chaining
|
|
};
|
|
|
|
//
|
|
// Used to set a source filter to run in a "live" mode.
|
|
//
|
|
[
|
|
object,
|
|
uuid(F185FE76-E64E-11d2-B76E-00C04FB6BD3D),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMPushSource : IAMLatency
|
|
{
|
|
// used to discover push source's capabilities.
|
|
// may be any combination of the AM_PUSHSOURCE_FLAGS flags.
|
|
HRESULT GetPushSourceFlags (
|
|
[out] ULONG *pFlags
|
|
);
|
|
|
|
// used to set request flags for a push source.
|
|
// may be a combination of the AM_PUSHSOURCE_REQS_xxx flags.
|
|
HRESULT SetPushSourceFlags (
|
|
[in] ULONG Flags
|
|
);
|
|
|
|
// specify an offset for push source time stamps
|
|
HRESULT SetStreamOffset (
|
|
[in] REFERENCE_TIME rtOffset
|
|
);
|
|
|
|
// retrieve the offset this push source is using
|
|
HRESULT GetStreamOffset (
|
|
[out] REFERENCE_TIME *prtOffset
|
|
);
|
|
|
|
// retrieve the maximum stream offset this push source thinks it can support
|
|
HRESULT GetMaxStreamOffset (
|
|
[out] REFERENCE_TIME *prtMaxOffset
|
|
);
|
|
|
|
// allows the filter graph to tell a push source the maximum latency allowed on the graph
|
|
// this allows pins like the video capture preview pin to be more efficient with the amount
|
|
// of buffering required to support the maximum graph latency
|
|
HRESULT SetMaxStreamOffset (
|
|
[in] REFERENCE_TIME rtMaxOffset
|
|
);
|
|
};
|
|
|
|
|
|
// ------------------------------------------------------------------------
|
|
//
|
|
// IAMDeviceRemoval interface
|
|
//
|
|
// Implemented by filters to request and receive WM_DEVICECHANGE
|
|
// notifications
|
|
//
|
|
// ------------------------------------------------------------------------
|
|
|
|
[
|
|
object,
|
|
uuid(f90a6130-b658-11d2-ae49-0000f8754b99),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMDeviceRemoval : IUnknown
|
|
{
|
|
|
|
HRESULT DeviceInfo(
|
|
[out] CLSID *pclsidInterfaceClass,
|
|
[out] WCHAR **pwszSymbolicLink);
|
|
|
|
HRESULT Reassociate();
|
|
|
|
HRESULT Disassociate();
|
|
}
|
|
|
|
//
|
|
// for DV
|
|
//
|
|
typedef struct {
|
|
//for 1st 5/6 DIF seq.
|
|
DWORD dwDVAAuxSrc;
|
|
DWORD dwDVAAuxCtl;
|
|
//for 2nd 5/6 DIF seq.
|
|
DWORD dwDVAAuxSrc1;
|
|
DWORD dwDVAAuxCtl1;
|
|
//for video information
|
|
DWORD dwDVVAuxSrc;
|
|
DWORD dwDVVAuxCtl;
|
|
DWORD dwDVReserved[2];
|
|
|
|
} DVINFO, *PDVINFO;
|
|
|
|
// ------------------------------------------------------------------------
|
|
//
|
|
// IDVEnc interface
|
|
//
|
|
// Implemented by DV encoder filters to set Encoder format
|
|
//
|
|
// ------------------------------------------------------------------------
|
|
enum _DVENCODERRESOLUTION { //resolution
|
|
DVENCODERRESOLUTION_720x480 = 2012,
|
|
DVENCODERRESOLUTION_360x240 = 2013,
|
|
DVENCODERRESOLUTION_180x120 = 2014,
|
|
DVENCODERRESOLUTION_88x60 = 2015
|
|
};
|
|
enum _DVENCODERVIDEOFORMAT { //PAL/ntsc
|
|
DVENCODERVIDEOFORMAT_NTSC = 2000,
|
|
DVENCODERVIDEOFORMAT_PAL = 2001
|
|
};
|
|
enum _DVENCODERFORMAT { // dvsd/dvhd/dvsl
|
|
DVENCODERFORMAT_DVSD = 2007,
|
|
DVENCODERFORMAT_DVHD = 2008,
|
|
DVENCODERFORMAT_DVSL = 2009
|
|
};
|
|
[
|
|
object,
|
|
uuid(d18e17a0-aacb-11d0-afb0-00aa00b67a42),
|
|
pointer_default(unique)
|
|
]
|
|
interface IDVEnc : IUnknown
|
|
{
|
|
|
|
HRESULT get_IFormatResolution (
|
|
[out] int *VideoFormat, //pal or ntsc
|
|
[out] int *DVFormat, //dvsd dvhd dvsl
|
|
[out] int *Resolution, //720, 360, 180,88
|
|
[in] BYTE fDVInfo, //TRUE: DVINFO structure exist, FALSE: Do not care DVINFO
|
|
[out] DVINFO *sDVInfo //NULL if fDVInfo=FALSE,
|
|
);
|
|
|
|
HRESULT put_IFormatResolution (
|
|
[in] int VideoFormat,
|
|
[in] int DVFormat,
|
|
[in] int Resolution,
|
|
[in] BYTE fDVInfo, //TRUE: DVINFO structure exist, FALSE: Do not care DVINFO
|
|
[in] DVINFO *sDVInfo //NULL if fDVInfo=FALSE,
|
|
);
|
|
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
//
|
|
// IDVDec interface
|
|
//
|
|
// Implemented by DV decoder filters to set decoder size
|
|
//
|
|
// ------------------------------------------------------------------------
|
|
enum _DVDECODERRESOLUTION {
|
|
DVDECODERRESOLUTION_720x480 = 1000,
|
|
DVDECODERRESOLUTION_360x240 = 1001,
|
|
DVDECODERRESOLUTION_180x120 = 1002,
|
|
DVDECODERRESOLUTION_88x60 = 1003
|
|
};
|
|
enum _DVRESOLUTION {
|
|
DVRESOLUTION_FULL = 1000,
|
|
DVRESOLUTION_HALF = 1001,
|
|
DVRESOLUTION_QUARTER = 1002,
|
|
DVRESOLUTION_DC = 1003
|
|
};
|
|
[
|
|
object,
|
|
uuid(b8e8bd60-0bfe-11d0-af91-00aa00b67a42),
|
|
pointer_default(unique)
|
|
]
|
|
interface IIPDVDec : IUnknown
|
|
{
|
|
HRESULT get_IPDisplay (
|
|
[out] int *displayPix // The display pixels arrage
|
|
);
|
|
|
|
HRESULT put_IPDisplay (
|
|
[in] int displayPix // Change to this display pixel arrage
|
|
) ;
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
//
|
|
// IDVRGB219 interface
|
|
//
|
|
// Implemented by both the DV encoder and decoder filters
|
|
// Used for enabling the 219 mode in which the Range of RGB24 either received
|
|
// by the encoder or produced by the decoder becomes (16,16,16)--(235,235,235)
|
|
// instead of (0,0,0)--(255,255,255).
|
|
// The interface's method has no effect in case of any other color space than
|
|
// RGB 24
|
|
//
|
|
//------------------------------------------------------------------------
|
|
|
|
[
|
|
object,
|
|
uuid(58473A19-2BC8-4663-8012-25F81BABDDD1),
|
|
pointer_default(unique)
|
|
]
|
|
interface IDVRGB219 : IUnknown
|
|
{
|
|
HRESULT SetRGB219 ([in] BOOL bState); // State = True Turn 219 mode on else turn it off.
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------------
|
|
//
|
|
// IDVSplitter interface
|
|
//
|
|
// Implemented by DV splitter filters
|
|
//
|
|
// ------------------------------------------------------------------------
|
|
[
|
|
object,
|
|
uuid(92a3a302-da7c-4a1f-ba7e-1802bb5d2d02)
|
|
]
|
|
interface IDVSplitter : IUnknown
|
|
{
|
|
HRESULT DiscardAlternateVideoFrames(
|
|
[in] int nDiscard
|
|
) ;
|
|
}
|
|
|
|
// Audio Renderer statistics params for IAMAudioRendererStats interface
|
|
enum _AM_AUDIO_RENDERER_STAT_PARAM {
|
|
AM_AUDREND_STAT_PARAM_BREAK_COUNT = 1, // audio breaks
|
|
AM_AUDREND_STAT_PARAM_SLAVE_MODE, // current slave mode, see AM_AUDREND_SLAVE_MODEs
|
|
AM_AUDREND_STAT_PARAM_SILENCE_DUR, // silence inserted due to gaps (ms)
|
|
AM_AUDREND_STAT_PARAM_LAST_BUFFER_DUR, // duration of the last buffer received
|
|
AM_AUDREND_STAT_PARAM_DISCONTINUITIES, // discontinuities seen since running
|
|
AM_AUDREND_STAT_PARAM_SLAVE_RATE, // what rate are we currently slaving at? S_FALSE if not slaving
|
|
AM_AUDREND_STAT_PARAM_SLAVE_DROPWRITE_DUR, // for waveOut slaving - data dropped or added to stay in-sync
|
|
// dwParam1 - dropped duration(ms)
|
|
// dwParam2 - paused duration(ms)
|
|
AM_AUDREND_STAT_PARAM_SLAVE_HIGHLOWERROR, // highest & lowest clock differences seen
|
|
// dwParam1 - high err
|
|
// dwParam2 - low err
|
|
AM_AUDREND_STAT_PARAM_SLAVE_LASTHIGHLOWERROR, // last high and low errs seen
|
|
// dwParam1 - last high err
|
|
// dwParam2 - last low err
|
|
AM_AUDREND_STAT_PARAM_SLAVE_ACCUMERROR, // error between master/slave clocks
|
|
AM_AUDREND_STAT_PARAM_BUFFERFULLNESS, // percent audio buffer fullness
|
|
AM_AUDREND_STAT_PARAM_JITTER // input buffer jitter
|
|
};
|
|
|
|
//---------------------------------------------------------------------
|
|
//
|
|
// IAMAudioRendererStats interface
|
|
//
|
|
// Interface to get at statistical information that is optionally stored
|
|
// in an audio renderer filter. Supported on the filter interface (although
|
|
// this might be better for ksproxy if we define it as a pin interface?)
|
|
//
|
|
//---------------------------------------------------------------------
|
|
|
|
[
|
|
object,
|
|
uuid(22320CB2-D41A-11d2-BF7C-D7CB9DF0BF93),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMAudioRendererStats : IUnknown
|
|
{
|
|
// Get value corresponding to the passed in parameter id
|
|
HRESULT GetStatParam(
|
|
[in] DWORD dwParam,
|
|
[out] DWORD *pdwParam1,
|
|
[out] DWORD *pdwParam2
|
|
);
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
//
|
|
// IAMLatency interface
|
|
//
|
|
// Allows a filter to report the expected latency associated with a data
|
|
// stream flowing from its input to output pin. Supported on output pins.
|
|
//
|
|
//---------------------------------------------------------------------
|
|
|
|
[
|
|
object,
|
|
uuid(62EA93BA-EC62-11d2-B770-00C04FB6BD3D),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMLatency : IUnknown
|
|
{
|
|
HRESULT GetLatency(
|
|
[in] REFERENCE_TIME *prtLatency
|
|
);
|
|
}
|
|
|
|
|
|
enum _AM_INTF_SEARCH_FLAGS {
|
|
AM_INTF_SEARCH_INPUT_PIN = 0x00000001, // search input pins
|
|
AM_INTF_SEARCH_OUTPUT_PIN = 0x00000002, // search output pins
|
|
AM_INTF_SEARCH_FILTER = 0x00000004 // search filters
|
|
};
|
|
|
|
//---------------------------------------------------------------------
|
|
//
|
|
// IAMGraphStreams interface
|
|
//
|
|
// Interface used to control or search over connected streams of data
|
|
// flow within a filter graph.
|
|
//
|
|
//---------------------------------------------------------------------
|
|
|
|
[
|
|
object,
|
|
uuid(632105FA-072E-11d3-8AF9-00C04FB6BD3D),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMGraphStreams : IUnknown
|
|
{
|
|
// Search upstream from the current pin, for the specified interface.
|
|
// dwFlags can be any combination of the AM_INTF_SEARCH_FLAGS, and allows
|
|
// control over what objects to search. A value of 0 means to search all.
|
|
HRESULT FindUpstreamInterface(
|
|
[in] IPin *pPin,
|
|
[in] REFIID riid,
|
|
[out, iid_is(riid)] void **ppvInterface,
|
|
[in] DWORD dwFlags );
|
|
|
|
// Enable or disable the graph's setting of a timestamp offset
|
|
// on push sources.
|
|
HRESULT SyncUsingStreamOffset( [in] BOOL bUseStreamOffset );
|
|
|
|
// allow an app to set the maximum offset used on push source filters
|
|
HRESULT SetMaxGraphLatency( [in] REFERENCE_TIME rtMaxGraphLatency );
|
|
}
|
|
|
|
|
|
//
|
|
// IAMOverlayFX
|
|
//
|
|
// This interface is exposed by the overlay mixer filter and allows
|
|
// an application to apply various "effects" to the overlay surface
|
|
// used by the overlay mixer.
|
|
//
|
|
// The effects that can be applied are described by the AMOVERLAYFX
|
|
// enumeration.
|
|
//
|
|
enum AMOVERLAYFX {
|
|
// Normal (ie. top down, left to right) video
|
|
AMOVERFX_NOFX = 0x00000000,
|
|
|
|
// Mirror the overlay across the vertical axis
|
|
AMOVERFX_MIRRORLEFTRIGHT = 0x00000002,
|
|
|
|
// Mirror the overlay across the horizontal axis
|
|
AMOVERFX_MIRRORUPDOWN = 0x00000004,
|
|
|
|
// Deinterlace the overlay, if possible
|
|
AMOVERFX_DEINTERLACE = 0x00000008
|
|
};
|
|
|
|
[
|
|
object,
|
|
uuid(62fae250-7e65-4460-bfc9-6398b322073c),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMOverlayFX : IUnknown
|
|
{
|
|
// Use this method to determine what overlay effects are currently available
|
|
// for the overlay surface used by the overlay mixer filter.
|
|
//
|
|
HRESULT QueryOverlayFXCaps(
|
|
[out] DWORD *lpdwOverlayFXCaps
|
|
);
|
|
|
|
// Use this method to apply a new overlay effect to the overlay surface
|
|
// used by the overlay mixer filter. This method can be called while the
|
|
// filter graph is running, the effect is applied immediately
|
|
//
|
|
HRESULT SetOverlayFX(
|
|
[in] DWORD dwOverlayFX
|
|
);
|
|
|
|
// Use this method to determine what effect (if any) is currently being
|
|
// applied to the overlay surface by the overlay mixer filter.
|
|
//
|
|
HRESULT GetOverlayFX(
|
|
[out] DWORD *lpdwOverlayFX
|
|
);
|
|
}
|
|
|
|
|
|
|
|
// IAMOpenProgress interface provides information about current progress through
|
|
// a download
|
|
|
|
[
|
|
object,
|
|
uuid(8E1C39A1-DE53-11cf-AA63-0080C744528D),
|
|
pointer_default(unique)
|
|
]
|
|
|
|
interface IAMOpenProgress : IUnknown
|
|
{
|
|
// QueryProgress can be used to query the source filter which supports this interface
|
|
// for progress information during a renderfile operation.
|
|
HRESULT QueryProgress(
|
|
[out] LONGLONG* pllTotal,
|
|
[out] LONGLONG* pllCurrent
|
|
);
|
|
|
|
// AbortOperation can be used to request an abort of RenderFile operation
|
|
// causing it to stop downloading. This methods instructs the exporter of
|
|
// the IAMOpenProgress interface to hold up their internal abort flag until
|
|
// further notice.
|
|
HRESULT AbortOperation(
|
|
);
|
|
}
|
|
|
|
|
|
/*++
|
|
IMpeg2Demultiplexer
|
|
|
|
This interface is implemented by the MPEG-2 Demultiplexer filter,
|
|
irrespective of program vs. transport stream splitting functionality.
|
|
--*/
|
|
[
|
|
object,
|
|
local,
|
|
uuid (436eee9c-264f-4242-90e1-4e330c107512),
|
|
pointer_default(unique)
|
|
]
|
|
interface IMpeg2Demultiplexer : IUnknown
|
|
{
|
|
/*++
|
|
------------------------------------------------------------------------
|
|
purpose: Creates an output pin of the specified media type.
|
|
|
|
pMediaType media type specifier for the new pin
|
|
pszPinName pin name; cannot be a duplicate of an existing pin
|
|
ppIPin IPin interface pointer to the newly created pin
|
|
--*/
|
|
HRESULT
|
|
CreateOutputPin (
|
|
[in] AM_MEDIA_TYPE * pMediaType,
|
|
[in] LPWSTR pszPinName,
|
|
[out] IPin ** ppIPin
|
|
) ;
|
|
|
|
/*++
|
|
------------------------------------------------------------------------
|
|
purpose: Updates the media type of the specified output pin. If no
|
|
connection exists, the media type is updated always. If
|
|
the pin is connected, the success/failure of the call will
|
|
depend on downstream input pin's accetance/rejection of
|
|
the specified media type, and subsequent success/failure
|
|
of a reconnect.
|
|
|
|
pszPinName pin name
|
|
pMediaType new media type specifier
|
|
--*/
|
|
HRESULT
|
|
SetOutputPinMediaType (
|
|
[in] LPWSTR pszPinName,
|
|
[in] AM_MEDIA_TYPE * pMediaType
|
|
) ;
|
|
|
|
/*++
|
|
------------------------------------------------------------------------
|
|
purpose: Deletes the specified output pin.
|
|
|
|
pszPinName pin name
|
|
--*/
|
|
HRESULT
|
|
DeleteOutputPin (
|
|
[in] LPWSTR pszPinName
|
|
) ;
|
|
} ;
|
|
|
|
//---------------------------------------------------------------------
|
|
// IEnumStreamIdMap interface
|
|
//---------------------------------------------------------------------
|
|
|
|
cpp_quote("#define MPEG2_PROGRAM_STREAM_MAP 0x00000000")
|
|
cpp_quote("#define MPEG2_PROGRAM_ELEMENTARY_STREAM 0x00000001")
|
|
cpp_quote("#define MPEG2_PROGRAM_DIRECTORY_PES_PACKET 0x00000002")
|
|
cpp_quote("#define MPEG2_PROGRAM_PACK_HEADER 0x00000003")
|
|
cpp_quote("#define MPEG2_PROGRAM_PES_STREAM 0x00000004")
|
|
cpp_quote("#define MPEG2_PROGRAM_SYSTEM_HEADER 0x00000005")
|
|
|
|
cpp_quote("#define SUBSTREAM_FILTER_VAL_NONE 0x10000000")
|
|
|
|
typedef struct {
|
|
ULONG stream_id ; // mpeg-2 stream_id
|
|
DWORD dwMediaSampleContent ; // #define'd above
|
|
ULONG ulSubstreamFilterValue ; // filtering value
|
|
int iDataOffset ; // offset to elementary stream
|
|
} STREAM_ID_MAP ;
|
|
|
|
/*++
|
|
Enumerates the StreamIds mapped on a pin
|
|
--*/
|
|
[
|
|
object,
|
|
local,
|
|
uuid (945C1566-6202-46fc-96C7-D87F289C6534),
|
|
pointer_default(unique)
|
|
]
|
|
interface IEnumStreamIdMap : IUnknown
|
|
{
|
|
HRESULT
|
|
Next (
|
|
[in] ULONG cRequest,
|
|
[in, out, size_is (cRequest)] STREAM_ID_MAP * pStreamIdMap,
|
|
[out] ULONG * pcReceived
|
|
) ;
|
|
|
|
HRESULT
|
|
Skip (
|
|
[in] ULONG cRecords
|
|
) ;
|
|
|
|
HRESULT
|
|
Reset (
|
|
) ;
|
|
|
|
HRESULT
|
|
Clone (
|
|
[out] IEnumStreamIdMap ** ppIEnumStreamIdMap
|
|
) ;
|
|
} ;
|
|
|
|
/*++
|
|
Implemented on the output pin.
|
|
|
|
Provides the ability to map/unmap a stream_id to/from an output pin.
|
|
--*/
|
|
[
|
|
object,
|
|
local,
|
|
uuid (D0E04C47-25B8-4369-925A-362A01D95444),
|
|
pointer_default(unique)
|
|
]
|
|
interface IMPEG2StreamIdMap : IUnknown
|
|
{
|
|
HRESULT
|
|
MapStreamId (
|
|
[in] ULONG ulStreamId, // mpeg-2 stream_id
|
|
[in] DWORD MediaSampleContent, // #define'd above IEnumStreamIdMap
|
|
[in] ULONG ulSubstreamFilterValue, // filter value
|
|
[in] int iDataOffset // elementary stream offset
|
|
) ;
|
|
|
|
HRESULT
|
|
UnmapStreamId (
|
|
[in] ULONG culStreamId, // number of stream_id's in pulStreamId
|
|
[in] ULONG * pulStreamId // array of stream_id's to unmap
|
|
) ;
|
|
|
|
HRESULT
|
|
EnumStreamIdMap (
|
|
[out] IEnumStreamIdMap ** ppIEnumStreamIdMap
|
|
) ;
|
|
} ;
|
|
|
|
|
|
// Register a service provider with the filter graph
|
|
[
|
|
object,
|
|
local,
|
|
uuid(7B3A2F01-0751-48DD-B556-004785171C54),
|
|
pointer_default(unique)
|
|
]
|
|
interface IRegisterServiceProvider : IUnknown
|
|
{
|
|
// registers one service into it's internal table.. Object is refcounted.
|
|
// register a NULL value to remove the service
|
|
HRESULT RegisterService([in] REFGUID guidService, [in] IUnknown *pUnkObject);
|
|
};
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
//
|
|
// IAMClockSlave interface
|
|
//
|
|
// When the audio renderer is slaving to a separate graph clock this
|
|
// interface provides a way for an app to specify how closely in sync
|
|
// the slaving renderer should try to stay to the graph clock. Note that
|
|
// using a larger tolerance for a video & audio playback graph will likely
|
|
// result in looser a/v sync, so it recommended not to change this setting
|
|
// except under special circumstances.
|
|
//
|
|
//---------------------------------------------------------------------
|
|
|
|
//
|
|
// Used to set/get the error tolerance used by a slaving audio renderer
|
|
//
|
|
[
|
|
object,
|
|
uuid(9FD52741-176D-4b36-8F51-CA8F933223BE),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMClockSlave : IUnknown
|
|
{
|
|
// set millisecond value to use for slaving tolerance
|
|
// the allowed range is 1 to 1000ms
|
|
HRESULT SetErrorTolerance (
|
|
[in] DWORD dwTolerance
|
|
);
|
|
|
|
// get millisecond value currently being used for slaving tolerance
|
|
HRESULT GetErrorTolerance (
|
|
[out] DWORD *pdwTolerance
|
|
);
|
|
};
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
//
|
|
// IAMGraphBuilderCallback interface
|
|
//
|
|
// Interface which gives the app a chance to configure filters
|
|
// before a connection is attempted.
|
|
//
|
|
// If this interface is supported by the site passed in to the graph
|
|
// via IObjectWithSite::SetSite, the graph will call back with each
|
|
// filter it creates as part of the Render or Connect process. Does
|
|
// not call back for source filters. Filter may be discarded and not
|
|
// used in graph or may be connected and disconnected more than once
|
|
//
|
|
// The callback occurs with the graph lock held, so do not call into
|
|
// the graph again and do not wait on other threads calling into the
|
|
// graph.
|
|
//
|
|
//---------------------------------------------------------------------
|
|
|
|
[
|
|
object,
|
|
uuid(4995f511-9ddb-4f12-bd3b-f04611807b79),
|
|
local,
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMGraphBuilderCallback : IUnknown
|
|
{
|
|
// graph builder selected a filter to create and attempt to
|
|
// connect. failure indicates filter should be rejected.
|
|
HRESULT SelectedFilter(
|
|
[in] IMoniker *pMon
|
|
);
|
|
|
|
// app configures filter during this call. failure indicates
|
|
// filter should be rejected.
|
|
HRESULT CreatedFilter(
|
|
[in] IBaseFilter *pFil
|
|
);
|
|
};
|
|
|
|
cpp_quote("#ifdef __cplusplus")
|
|
cpp_quote("#ifndef _IAMFilterGraphCallback_")
|
|
cpp_quote("#define _IAMFilterGraphCallback_")
|
|
cpp_quote("// Note: Because this interface was not defined as a proper interface it is")
|
|
cpp_quote("// supported under C++ only. Methods aren't stdcall.")
|
|
cpp_quote("EXTERN_GUID(IID_IAMFilterGraphCallback,0x56a868fd,0x0ad4,0x11ce,0xb0,0xa3,0x0,0x20,0xaf,0x0b,0xa7,0x70);")
|
|
cpp_quote("interface IAMFilterGraphCallback : public IUnknown")
|
|
cpp_quote("{")
|
|
cpp_quote(" // S_OK means rendering complete, S_FALSE means retry now.")
|
|
cpp_quote(" virtual HRESULT UnableToRender(IPin *pPin) = 0;")
|
|
cpp_quote(" ")
|
|
cpp_quote("};")
|
|
cpp_quote("#endif // _IAMFilterGraphCallback_")
|
|
cpp_quote("#endif")
|
|
|
|
//------------------------------------------------------------------------------
|
|
// File: EncAPI.idl
|
|
//
|
|
// Desc: Encoder (and future decoder) interface definitions.
|
|
//
|
|
// Copyright (c) 1992 - 2002, Microsoft Corporation. All rights reserved.
|
|
//------------------------------------------------------------------------------
|
|
|
|
struct CodecAPIEventData
|
|
{
|
|
GUID guid;
|
|
DWORD dataLength;
|
|
DWORD reserved[3];
|
|
// BYTE data[dataLength];
|
|
};
|
|
|
|
interface IStream; // forward declaration
|
|
//
|
|
// Applications can pass the CODECAPI_VIDEO_ENCODER to IsSupported to test for video encoders
|
|
// Similarly, the GUIDs for audio encoders, video decoders, audio decoders and muxes can be
|
|
// used to test for the codec classification
|
|
//
|
|
// See uuids.h for a more detailed list.
|
|
//
|
|
[
|
|
object,
|
|
uuid(901db4c7-31ce-41a2-85dc-8fa0bf41b8da),
|
|
pointer_default(unique)
|
|
]
|
|
interface ICodecAPI : IUnknown
|
|
{
|
|
//
|
|
// IsSupported():
|
|
//
|
|
// Query whether a given parameter is supported.
|
|
//
|
|
HRESULT
|
|
IsSupported (
|
|
[in] const GUID *Api
|
|
);
|
|
|
|
//
|
|
// IsModifiable
|
|
//
|
|
// Query whether a given parameter can be changed given the codec selection
|
|
// and other parameter selections.
|
|
//
|
|
HRESULT
|
|
IsModifiable (
|
|
[in] const GUID *Api
|
|
);
|
|
|
|
//
|
|
// GetParameterRange():
|
|
//
|
|
// Returns the valid range of values that the parameter supports should
|
|
// the parameter support a stepped range as opposed to a list of specific
|
|
// values. The support is [ValueMin .. ValueMax] by SteppingDelta.
|
|
//
|
|
// Ranged variant types must fall into one of the below types. Each
|
|
// parameter will, by definition, return a specific type.
|
|
//
|
|
// If the range has no stepping delta (any delta will do), the Stepping
|
|
// delta will be empty (VT_EMPTY).
|
|
//
|
|
HRESULT
|
|
GetParameterRange (
|
|
[in] const GUID *Api,
|
|
[out] VARIANT *ValueMin,
|
|
[out] VARIANT *ValueMax,
|
|
[out] VARIANT *SteppingDelta
|
|
);
|
|
|
|
//
|
|
// GetParameterValues():
|
|
//
|
|
// Returns the list of values supported by the given parameter as a
|
|
// COM allocated array. The total number of values will be placed in
|
|
// the ValuesCount parameter and the Values array will contain the
|
|
// individual values. This array must be freed by the caller through
|
|
// CoTaskMemFree().
|
|
//
|
|
HRESULT
|
|
GetParameterValues (
|
|
[in] const GUID *Api,
|
|
[out, size_is(,*ValuesCount)] VARIANT **Values,
|
|
[out] ULONG *ValuesCount
|
|
);
|
|
|
|
//
|
|
// GetDefaultValue():
|
|
//
|
|
// Get the default value for a parameter, if one exists. Otherwise,
|
|
// an error will be returned.
|
|
//
|
|
HRESULT
|
|
GetDefaultValue (
|
|
[in] const GUID *Api,
|
|
[out] VARIANT *Value
|
|
);
|
|
|
|
//
|
|
// GetValue():
|
|
//
|
|
// Get the current value of a parameter.
|
|
//
|
|
HRESULT
|
|
GetValue (
|
|
[in] const GUID *Api,
|
|
[out] VARIANT *Value
|
|
);
|
|
|
|
//
|
|
// SetValue():
|
|
//
|
|
// Set the current value of a parameter.
|
|
//
|
|
HRESULT
|
|
SetValue (
|
|
[in] const GUID *Api,
|
|
[in] VARIANT *Value
|
|
);
|
|
|
|
// new methods beyond IEncoderAPI
|
|
|
|
//
|
|
// RegisterForEvent():
|
|
//
|
|
// Enable events to be reported for the given event GUID. For DShow
|
|
// events, the event is returned as
|
|
// (EC_CODECAPI_EVENT, lParam=userData, lParam2=CodecAPIEventData* Data)
|
|
// where
|
|
// - the CodecAPIEventData is COM allocated memory and must be handled and freed
|
|
// by the application using CoTaskMemFree().
|
|
// - the userData is the same pointer passed to RegisterForEvent
|
|
//
|
|
// Each data block starts with the following structure:
|
|
// struct CodecAPIEventData
|
|
// {
|
|
// GUID guid;
|
|
// DWORD dataLength;
|
|
// DWORD reserved[3]; // pad to 16 byte alignment
|
|
// BYTE data[dataLength];
|
|
// }
|
|
// The guid parameter identifies the event. The data associated with the event follows the
|
|
// structure (represented by the variable length BYTE data[dataLength] array).
|
|
//
|
|
// If guid is equal to CODECAPI_CHANGELISTS, then data is an array of GUIDs that changed as
|
|
// a result of setting the parameter, as follows:
|
|
// GUID changedGuids[ header.dataLength / sizeof(GUID) ]
|
|
//
|
|
// The current array is limited, so a driver may send multiple messages if the array size is
|
|
// exceeded.
|
|
//
|
|
HRESULT
|
|
RegisterForEvent (
|
|
[in] const GUID *Api,
|
|
[in] LONG_PTR userData
|
|
);
|
|
|
|
//
|
|
// UnregisterForEvent():
|
|
//
|
|
// Disable event reporting for the given event GUID.
|
|
//
|
|
HRESULT
|
|
UnregisterForEvent (
|
|
[in] const GUID *Api
|
|
);
|
|
|
|
//
|
|
// SetAllDefaults
|
|
//
|
|
HRESULT SetAllDefaults(void);
|
|
|
|
//
|
|
// Extended SetValue & SetAllDefaults:
|
|
//
|
|
// Changes the current value of a parameter and returns back an alteration list
|
|
//
|
|
// The secondary arguments return back a list of other settings
|
|
// that changed as a result of the SetValue() call (for UI updates etc)
|
|
// The client must free the buffer.
|
|
//
|
|
HRESULT
|
|
SetValueWithNotify (
|
|
[in] const GUID *Api,
|
|
[in] VARIANT *Value,
|
|
[out, size_is(,*ChangedParamCount)] GUID **ChangedParam,
|
|
[out] ULONG *ChangedParamCount
|
|
);
|
|
|
|
//
|
|
// SetAllDefaultsWithNotify
|
|
//
|
|
HRESULT SetAllDefaultsWithNotify(
|
|
[out, size_is(,*ChangedParamCount)] GUID **ChangedParam,
|
|
[out] ULONG *ChangedParamCount
|
|
);
|
|
//
|
|
// GetAllSettings
|
|
// Load the current settings from a stream
|
|
//
|
|
HRESULT GetAllSettings( [in] IStream* );
|
|
|
|
//
|
|
// SetAllSettings
|
|
// Save the current settings to a stream
|
|
//
|
|
HRESULT SetAllSettings( [in] IStream* );
|
|
|
|
//
|
|
// SetAllSettingsWithNotify
|
|
//
|
|
HRESULT SetAllSettingsWithNotify( IStream*,
|
|
[out, size_is(,*ChangedParamCount)] GUID **ChangedParam,
|
|
[out] ULONG *ChangedParamCount );
|
|
}
|
|
|
|
[
|
|
object,
|
|
local,
|
|
uuid(a8809222-07bb-48ea-951c-33158100625b),
|
|
pointer_default(unique)
|
|
]
|
|
interface IGetCapabilitiesKey : IUnknown
|
|
{
|
|
HRESULT GetCapabilitiesKey( [out] HKEY* pHKey );
|
|
};
|
|
|
|
// -----------------------------------------------------------------------------------------
|
|
// From this point on, this is retained for backwards compatiblity only
|
|
// Do not use this for future encoders
|
|
// -----------------------------------------------------------------------------------------
|
|
[
|
|
object,
|
|
uuid(70423839-6ACC-4b23-B079-21DBF08156A5),
|
|
pointer_default(unique)
|
|
]
|
|
interface IEncoderAPI : IUnknown
|
|
{
|
|
HRESULT IsSupported ( [in] const GUID *Api );
|
|
HRESULT IsAvailable ( [in] const GUID *Api );
|
|
HRESULT GetParameterRange ( [in] const GUID *Api,
|
|
[out] VARIANT *ValueMin, [out] VARIANT *ValueMax,
|
|
[out] VARIANT *SteppingDelta );
|
|
HRESULT GetParameterValues ( [in] const GUID *Api,
|
|
[out, size_is(,*ValuesCount)] VARIANT **Values,
|
|
[out] ULONG *ValuesCount );
|
|
HRESULT GetDefaultValue ( [in] const GUID *Api, [out] VARIANT *Value );
|
|
HRESULT GetValue ( [in] const GUID *Api, [out] VARIANT *Value );
|
|
HRESULT SetValue ( [in] const GUID *Api, [in] VARIANT *Value );
|
|
}
|
|
|
|
[
|
|
object,
|
|
uuid(02997C3B-8E1B-460e-9270-545E0DE9563E),
|
|
pointer_default(unique)
|
|
]
|
|
interface IVideoEncoder : IEncoderAPI
|
|
{
|
|
}
|
|
//---------------------------------------------------------------------
|
|
//
|
|
// Old Encoder API Interfaces
|
|
//
|
|
//---------------------------------------------------------------------
|
|
|
|
cpp_quote ("#ifndef __ENCODER_API_DEFINES__")
|
|
cpp_quote ("#define __ENCODER_API_DEFINES__")
|
|
|
|
typedef enum {
|
|
|
|
//
|
|
// Bit rate used for encoding is constant
|
|
//
|
|
ConstantBitRate = 0,
|
|
|
|
//
|
|
// Bit rate used for encoding is variable with the specified bitrate used
|
|
// as a guaranteed average over a specified window. The default window
|
|
// size is considered to be 5 minutes.
|
|
//
|
|
VariableBitRateAverage,
|
|
|
|
//
|
|
// Bit rate used for encoding is variable with the specified bitrate used
|
|
// as a peak rate over a specified window. The default window size
|
|
// is considered to be 500ms (classically one GOP).
|
|
//
|
|
VariableBitRatePeak
|
|
|
|
} VIDEOENCODER_BITRATE_MODE;
|
|
|
|
cpp_quote ("#endif // __ENCODER_API_DEFINES__")
|
|
|
|
cpp_quote("#define AM_GETDECODERCAP_QUERY_VMR_SUPPORT 0x00000001")
|
|
cpp_quote("#define VMR_NOTSUPPORTED 0x00000000")
|
|
cpp_quote("#define VMR_SUPPORTED 0x00000001")
|
|
|
|
cpp_quote("#define AM_QUERY_DECODER_VMR_SUPPORT 0x00000001")
|
|
cpp_quote("#define AM_QUERY_DECODER_DXVA_1_SUPPORT 0x00000002")
|
|
|
|
cpp_quote("#define AM_QUERY_DECODER_DVD_SUPPORT 0x00000003")
|
|
cpp_quote("#define AM_QUERY_DECODER_ATSC_SD_SUPPORT 0x00000004")
|
|
cpp_quote("#define AM_QUERY_DECODER_ATSC_HD_SUPPORT 0x00000005")
|
|
cpp_quote("#define AM_GETDECODERCAP_QUERY_VMR9_SUPPORT 0x00000006")
|
|
|
|
cpp_quote("#define DECODER_CAP_NOTSUPPORTED 0x00000000")
|
|
cpp_quote("#define DECODER_CAP_SUPPORTED 0x00000001")
|
|
|
|
[
|
|
object,
|
|
local,
|
|
uuid(c0dff467-d499-4986-972b-e1d9090fa941),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMDecoderCaps : IUnknown
|
|
{
|
|
HRESULT GetDecoderCaps([in] DWORD dwCapIndex, [out] DWORD* lpdwCap);
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// IAMCertifiedOutputProtection
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
typedef struct _AMCOPPSignature {
|
|
BYTE Signature[256];
|
|
} AMCOPPSignature;
|
|
|
|
typedef struct _AMCOPPCommand {
|
|
GUID macKDI; // 16 bytes
|
|
GUID guidCommandID; // 16 bytes
|
|
DWORD dwSequence; // 4 bytes
|
|
DWORD cbSizeData; // 4 bytes
|
|
BYTE CommandData[4056]; // 4056 bytes (4056+4+4+16+16 = 4096)
|
|
} AMCOPPCommand, *LPAMCOPPCommand;
|
|
|
|
typedef struct _AMCOPPStatusInput {
|
|
GUID rApp; // 16 bytes
|
|
GUID guidStatusRequestID;// 16 bytes
|
|
DWORD dwSequence; // 4 bytes
|
|
DWORD cbSizeData; // 4 bytes
|
|
BYTE StatusData[4056]; // 4056 bytes (4056+4+4+16+16 = 4096)
|
|
} AMCOPPStatusInput, *LPAMCOPPStatusInput;
|
|
|
|
typedef struct _AMCOPPStatusOutput {
|
|
GUID macKDI; // 16 bytes
|
|
DWORD cbSizeData; // 4 bytes
|
|
BYTE COPPStatus[4076]; // 4076 bytes (4076+16+4 = 4096)
|
|
} AMCOPPStatusOutput, *LPAMCOPPStatusOutput;
|
|
|
|
|
|
[
|
|
object,
|
|
local,
|
|
uuid(6feded3e-0ff1-4901-a2f1-43f7012c8515),
|
|
pointer_default(unique)
|
|
]
|
|
interface IAMCertifiedOutputProtection : IUnknown
|
|
{
|
|
HRESULT KeyExchange (
|
|
[out] GUID* pRandom, // 128-bit random number generated by Graphics Driver
|
|
[out] BYTE** VarLenCertGH, // Graphics Hardware certificate, memory released by CoTaskMemFree
|
|
[out] DWORD* pdwLengthCertGH); // Length of Graphics Hardware certificate
|
|
|
|
HRESULT SessionSequenceStart(
|
|
[in] AMCOPPSignature*pSig); // Concatenation of 128-bit random data security session key,
|
|
// 128-bit random data integrity session key, 32-bit random
|
|
// starting status sequence number and 32-bit random starting
|
|
// command sequence number encrypted with the public key of
|
|
// the graphic hardware. This value is 2048 bits long.
|
|
|
|
HRESULT ProtectionCommand(
|
|
[in] const AMCOPPCommand* cmd); // Encrypted command
|
|
|
|
HRESULT ProtectionStatus(
|
|
[in] const AMCOPPStatusInput* pStatusInput, // Encrypted Status request
|
|
[out] AMCOPPStatusOutput* pStatusOutput); // Encrypted Status results
|
|
};
|
|
|