able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/public/sdk/inc/wmsdkidl.idl

2690 lines
96 KiB
Plaintext
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//============================================================================
//
// Microsoft Windows Media Technology
// Copyright (C) Microsoft Corporation, 1999 - 2001. All Rights Reserved.
//
// File: wmsdkidl.idl
//
// Description:
//
//============================================================================
cpp_quote( "//=========================================================================" )
cpp_quote( "//" )
cpp_quote( "// Microsoft Windows Media Technologies" )
cpp_quote( "// Copyright (C) Microsoft Corporation, 1999 - 2001. All Rights Reserved." )
cpp_quote( "//" )
cpp_quote( "//=========================================================================" )
///////////////////////////////////////////////////////////////////////////////
//
// Enumerations and constants used by the SDK.
//
///////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//
// Imports, typedefs and forward declarations
//
import "oaidl.idl";
import "wmsbuffer.idl";
import "drmexternals.idl";
typedef unsigned __int64 QWORD;
//
// Here's a list of all the interfaces we define in this file:
//
interface IWMMediaProps;
interface IWMVideoMediaProps;
interface IWMWriter;
interface IWMInputMediaProps;
interface IWMReader;
interface IWMOutputMediaProps;
interface IWMReaderCallback;
interface IWMMetadataEditor;
interface IWMMetadataEditor2;
interface IWMHeaderInfo;
interface IWMProfile;
interface IWMProfileManager;
interface IWMStreamConfig;
interface IWMStreamList;
interface IWMMutualExclusion;
interface IWMPacketSize;
interface IWMWriterAdvanced;
interface IWMWriterAdvanced2;
interface IWMWriterSink;
interface IWMWriterFileSink;
interface IWMWriterNetworkSink;
interface IWMReaderAdvanced;
interface IWMReaderAdvanced2;
interface IWMReaderAdvanced3;
interface IWMReaderCallbackAdvanced;
interface IWMDRMReader;
interface IWMReaderNetworkConfig;
interface IWMLicenseBackup;
interface IWMLicenseRestore;
interface IWMBackupRestoreProps;
interface IWMCodecInfo;
interface IWMCodecInfo2;
///////////////////////////////////////////////////////////////////////////////
//
// Attributes
//
///////////////////////////////////////////////////////////////////////////////
cpp_quote( "////////////////////////////////////////////////////////////////" )
cpp_quote( "//" )
cpp_quote( "// These are the special case attributes that give information " )
cpp_quote( "// about the Windows Media file." )
cpp_quote( "//" )
cpp_quote( "static const DWORD g_dwWMSpecialAttributes = 15;" )
cpp_quote( "static const WCHAR *g_wszWMDuration = L\"Duration\";" )
cpp_quote( "static const WCHAR *g_wszWMBitrate = L\"Bitrate\";" )
cpp_quote( "static const WCHAR *g_wszWMSeekable = L\"Seekable\";" )
cpp_quote( "static const WCHAR *g_wszWMStridable = L\"Stridable\";" )
cpp_quote( "static const WCHAR *g_wszWMBroadcast = L\"Broadcast\";" )
cpp_quote( "static const WCHAR *g_wszWMProtected = L\"Is_Protected\";" )
cpp_quote( "static const WCHAR *g_wszWMTrusted = L\"Is_Trusted\";" )
cpp_quote( "static const WCHAR *g_wszWMSignature_Name = L\"Signature_Name\";" )
cpp_quote( "static const WCHAR *g_wszWMHasAudio = L\"HasAudio\";" )
cpp_quote( "static const WCHAR *g_wszWMHasImage = L\"HasImage\";" )
cpp_quote( "static const WCHAR *g_wszWMHasScript = L\"HasScript\";" )
cpp_quote( "static const WCHAR *g_wszWMHasVideo = L\"HasVideo\";" )
cpp_quote( "static const WCHAR *g_wszWMCurrentBitrate = L\"CurrentBitrate\";" )
cpp_quote( "static const WCHAR *g_wszWMOptimalBitrate = L\"OptimalBitrate\";" )
cpp_quote( "static const WCHAR *g_wszWMHasAttachedImages = L\"HasAttachedImages\";" )
cpp_quote( "" )
cpp_quote( "////////////////////////////////////////////////////////////////" )
cpp_quote( "//" )
cpp_quote( "// The content description object supports 5 basic attributes." )
cpp_quote( "//" )
cpp_quote( "static const DWORD g_dwWMContentAttributes = 5;" )
cpp_quote( "static const WCHAR *g_wszWMTitle = L\"Title\";" )
cpp_quote( "static const WCHAR *g_wszWMAuthor = L\"Author\";" )
cpp_quote( "static const WCHAR *g_wszWMDescription = L\"Description\";" )
cpp_quote( "static const WCHAR *g_wszWMRating = L\"Rating\";" )
cpp_quote( "static const WCHAR *g_wszWMCopyright = L\"Copyright\";" )
cpp_quote( "" )
cpp_quote( "////////////////////////////////////////////////////////////////" )
cpp_quote( "//" )
cpp_quote( "// These attributes are used to set DRM properties." )
cpp_quote( "//" )
cpp_quote( "static const WCHAR *g_wszWMUse_DRM = L\"Use_DRM\";" )
cpp_quote( "static const WCHAR *g_wszWMDRM_Flags = L\"DRM_Flags\";" )
cpp_quote( "static const WCHAR *g_wszWMDRM_Level = L\"DRM_Level\";" )
cpp_quote( "" )
cpp_quote( "////////////////////////////////////////////////////////////////" )
cpp_quote( "//" )
cpp_quote( "// These are the additional attributes defined in the WM attribute" )
cpp_quote( "// namespace that give information about the content." )
cpp_quote( "//" )
cpp_quote( "static const WCHAR *g_wszWMAlbumTitle = L\"WM/AlbumTitle\";" )
cpp_quote( "static const WCHAR *g_wszWMTrack = L\"WM/Track\";" )
cpp_quote( "static const WCHAR *g_wszWMPromotionURL = L\"WM/PromotionURL\";" )
cpp_quote( "static const WCHAR *g_wszWMAlbumCoverURL = L\"WM/AlbumCoverURL\";" )
cpp_quote( "static const WCHAR *g_wszWMGenre = L\"WM/Genre\";" )
cpp_quote( "static const WCHAR *g_wszWMYear = L\"WM/Year\";" )
cpp_quote( "static const WCHAR *g_wszWMGenreID = L\"WM/GenreID\";" )
cpp_quote( "static const WCHAR *g_wszWMMCDI = L\"WM/MCDI\";" )
cpp_quote( "static const WCHAR *g_wszWMComposer = L\"WM/Composer\";" )
cpp_quote( "static const WCHAR *g_wszWMLyrics = L\"WM/Lyrics\";" )
cpp_quote( "static const WCHAR *g_wszWMTrackNumber = L\"WM/TrackNumber\";" )
cpp_quote( "static const WCHAR *g_wszWMToolName = L\"WM/ToolName\";" )
cpp_quote( "static const WCHAR *g_wszWMToolVersion = L\"WM/ToolVersion\";" )
cpp_quote( "" )
cpp_quote( "////////////////////////////////////////////////////////////////" )
cpp_quote( "//" )
cpp_quote( "// These optional attributes may be used to give information " )
cpp_quote( "// about the branding of the content." )
cpp_quote( "//" )
cpp_quote( "static const WCHAR *g_wszWMBannerImageType = L\"BannerImageType\";" )
cpp_quote( "static const WCHAR *g_wszWMBannerImageData = L\"BannerImageData\";" )
cpp_quote( "static const WCHAR *g_wszWMBannerImageURL = L\"BannerImageURL\";" )
cpp_quote( "static const WCHAR *g_wszWMCopyrightURL = L\"CopyrightURL\";" )
cpp_quote( "////////////////////////////////////////////////////////////////" )
cpp_quote( "//" )
cpp_quote( "// The NSC file supports the following attributes." )
cpp_quote( "//" )
cpp_quote( "static const DWORD g_dwWMNSCAttributes = 5;" )
cpp_quote( "static const WCHAR *g_wszWMNSCName = L\"NSC_Name\";" )
cpp_quote( "static const WCHAR *g_wszWMNSCAddress = L\"NSC_Address\";" )
cpp_quote( "static const WCHAR *g_wszWMNSCPhone = L\"NSC_Phone\";" )
cpp_quote( "static const WCHAR *g_wszWMNSCEmail = L\"NSC_Email\";" )
cpp_quote( "static const WCHAR *g_wszWMNSCDescription = L\"NSC_Description\";" )
cpp_quote( "" )
///////////////////////////////////////////////////////////////////////////////
cpp_quote( "////////////////////////////////////////////////////////////////" )
cpp_quote( "//" )
cpp_quote( "// These are setting names for use in Get/SetOutputSetting" )
cpp_quote( "//" )
cpp_quote( "static const WCHAR *g_wszEarlyDataDelivery = L\"EarlyDataDelivery\";" )
cpp_quote( "static const WCHAR *g_wszJustInTimeDecode = L\"JustInTimeDecode\";" )
cpp_quote( "static const WCHAR *g_wszSingleOutputBuffer = L\"SingleOutputBuffer\";" )
cpp_quote( "static const WCHAR *g_wszSoftwareScaling = L\"SoftwareScaling\";" )
cpp_quote( "static const WCHAR *g_wszDeliverOnReceive = L\"DeliverOnReceive\";" )
cpp_quote( "static const WCHAR *g_wszScrambledAudio = L\"ScrambledAudio\";" )
cpp_quote( "" )
///////////////////////////////////////////////////////////////////////////////
cpp_quote( "////////////////////////////////////////////////////////////////" )
cpp_quote( "//" )
cpp_quote( "// These are setting names for use in Get/SetInputSetting" )
cpp_quote( "//" )
cpp_quote( "static const WCHAR *g_wszDeinterlaceMode = L\"DeinterlaceMode\";" )
cpp_quote( "" )
cpp_quote( "////////////////////////////////////////////////////////////////" )
cpp_quote( "//" )
cpp_quote( "// All known IWMPropertyVault property names" )
cpp_quote( "//" )
cpp_quote( "static const WCHAR *g_wszOriginalSourceFormatTag = L\"_SOURCEFORMATTAG\";" )
cpp_quote( "" )
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//
// Enumerations and flags used by the SDK.
//
///////////////////////////////////////////////////////////////////////////////
cpp_quote( "////////////////////////////////////////////////////////////////" )
cpp_quote( "//" )
cpp_quote( "// Flags that can be passed into the Start method of IWMReader" )
cpp_quote( "//" )
cpp_quote( "#define WM_START_CURRENTPOSITION ( ( QWORD )-1 )" )
cpp_quote( "" )
//
// Flag to force overwrite of existing license backup
//
cpp_quote( "#define WM_BACKUP_OVERWRITE ((DWORD) 0x00000001)" )
cpp_quote( "#define WM_RESTORE_INDIVIDUALIZE ((DWORD) 0x00000002)" )
//
// Wave format ex type
//
cpp_quote( "#define WAVE_FORMAT_DRM 0x0009" )
//
// The flags that can be set on a sample (input or output).
//
enum
{
WM_SF_CLEANPOINT = 0x1,
WM_SF_DISCONTINUITY = 0x2,
WM_SF_DATALOSS = 0x4,
};
//
// These flags might be set for a call to the IWMReaderAllocatorEx methods.
//
enum
{
WM_SFEX_NOTASYNCPOINT = 0x2,
WM_SFEX_DATALOSS = 0x4,
};
//
// Status messages that the reader and index objects can
// pass in the OnStatus call.
//
typedef enum WMT_STATUS
{
WMT_ERROR = 0,
WMT_OPENED = 1,
WMT_BUFFERING_START = 2,
WMT_BUFFERING_STOP = 3,
WMT_EOF = 4,
WMT_END_OF_FILE = 4,
WMT_END_OF_SEGMENT = 5,
WMT_END_OF_STREAMING = 6,
WMT_LOCATING = 7,
WMT_CONNECTING = 8,
WMT_NO_RIGHTS = 9,
WMT_MISSING_CODEC = 10,
WMT_STARTED = 11,
WMT_STOPPED = 12,
WMT_CLOSED = 13,
WMT_STRIDING = 14,
WMT_TIMER = 15,
WMT_INDEX_PROGRESS = 16,
WMT_SAVEAS_START = 17,
WMT_SAVEAS_STOP = 18,
WMT_NEW_SOURCEFLAGS = 19,
WMT_NEW_METADATA = 20,
WMT_BACKUPRESTORE_BEGIN = 21,
WMT_SOURCE_SWITCH = 22,
WMT_ACQUIRE_LICENSE = 23,
WMT_INDIVIDUALIZE = 24,
WMT_NEEDS_INDIVIDUALIZATION = 25,
WMT_NO_RIGHTS_EX = 26,
WMT_BACKUPRESTORE_END = 27,
WMT_BACKUPRESTORE_CONNECTING = 28,
WMT_BACKUPRESTORE_DISCONNECTING = 29,
WMT_ERROR_WITHURL = 30,
WMT_RESTRICTED_LICENSE = 31,
WMT_CLIENT_CONNECT = 32,
WMT_CLIENT_DISCONNECT = 33
} WMT_STATUS;
typedef enum WMT_RIGHTS
{
WMT_RIGHT_PLAYBACK = 0x00000001,
WMT_RIGHT_COPY_TO_NON_SDMI_DEVICE = 0x00000002,
WMT_RIGHT_COPY_TO_CD = 0x00000008,
WMT_RIGHT_COPY_TO_SDMI_DEVICE = 0x00000010,
WMT_RIGHT_ONE_TIME = 0x00000020,
WMT_RIGHT_SDMI_TRIGGER = 0x00010000,
WMT_RIGHT_SDMI_NOMORECOPIES = 0x00020000
} WMT_RIGHTS;
//
// Stream selection statuses (stati?).
//
typedef enum WMT_STREAM_SELECTION
{
WMT_OFF = 0,
WMT_CLEANPOINT_ONLY = 1,
WMT_ON = 2,
} WMT_STREAM_SELECTION;
//
// Attribute datatypes.
//
typedef enum WMT_ATTR_DATATYPE
{
WMT_TYPE_DWORD = 0,
WMT_TYPE_STRING = 1,
WMT_TYPE_BINARY = 2,
WMT_TYPE_BOOL = 3,
WMT_TYPE_QWORD = 4,
WMT_TYPE_WORD = 5,
WMT_TYPE_GUID = 6,
} WMT_ATTR_DATATYPE;
//
// Types of images that can be stored in the header of a Windows Media File.
//
typedef enum WMT_ATTR_IMAGETYPE
{
WMT_IMAGETYPE_BITMAP = 1,
WMT_IMAGETYPE_JPEG = 2,
WMT_IMAGETYPE_GIF = 3,
} WMT_ATTR_IMAGETYPE;
//
// Windows Media versions.
//
typedef enum WMT_VERSION
{
WMT_VER_4_0 = 0x00040000,
WMT_VER_7_0 = 0x00070000,
} WMT_VERSION;
//
// Protocols that the network sink supports.
//
typedef enum WMT_NET_PROTOCOL
{
WMT_PROTOCOL_HTTP = 0,
} WMT_NET_PROTOCOL;
//
// The reader supports a number of different types of playback, each with
// slightly different characteristics.
//
typedef enum WMT_PLAY_MODE
{
WMT_PLAY_MODE_AUTOSELECT = 0,
WMT_PLAY_MODE_LOCAL = 1,
WMT_PLAY_MODE_DOWNLOAD = 2,
WMT_PLAY_MODE_STREAMING = 3,
} WMT_PLAY_MODE;
//
// Network Proxy settings for the reader
//
typedef enum WMT_PROXY_SETTINGS
{
WMT_PROXY_SETTING_NONE = 0,
WMT_PROXY_SETTING_MANUAL = 1,
WMT_PROXY_SETTING_AUTO = 2,
WMT_PROXY_SETTING_BROWSER = 3, // Only valid for HTTP
} WMT_PROXY_SETTINGS;
typedef enum WMT_CODEC_INFO_TYPE
{
WMT_CODECINFO_AUDIO = 0, // codec info is a word = wFormatTag
WMT_CODECINFO_VIDEO = 1, // codec info is a dword = biCompression
WMT_CODECINFO_UNKNOWN = 0xFFFFFFFF, // codec info is undefined
} WMT_CODEC_INFO_TYPE;
//
// These values can be passed in when setting the DeinterlaceMode
// setting on the writer
//
enum
{
WM_DM_NOTINTERLACED = 0,
WM_DM_DEINTERLACE_NORMAL = 1,
WM_DM_DEINTERLACE_HALFSIZE = 2,
WM_DM_DEINTERLACE_HALFSIZEDOUBLERATE = 3,
WM_DM_DEINTERLACE_INVERSETELECINE = 4,
WM_DM_DEINTERLACE_VERTICALHALFSIZEDOUBLERATE = 5,
};
//
// Frame level access data structures - not supported in this version
//
typedef enum tagWMT_OFFSET_FORMAT
{
WMT_OFFSET_FORMAT_100NS,
WMT_OFFSET_FORMAT_SMPTE,
WMT_OFFSET_FORMAT_FRAME_NUMBERS,
WMT_OFFSET_FORMAT_PLAYLIST_OFFSET
} WMT_OFFSET_FORMAT;
///////////////////////////////////////////////////////////////////////////////
//
// Structures used by the SDK.
//
///////////////////////////////////////////////////////////////////////////////
//
// Writer Statistics struct
//
typedef struct _WMWriterStatistics
{
QWORD qwSampleCount;
QWORD qwByteCount;
QWORD qwDroppedSampleCount;
QWORD qwDroppedByteCount;
DWORD dwCurrentBitrate;
DWORD dwAverageBitrate;
DWORD dwExpectedBitrate;
//
// Sample rates are given as 1000 * (samples / second).
//
DWORD dwCurrentSampleRate;
DWORD dwAverageSampleRate;
DWORD dwExpectedSampleRate;
} WM_WRITER_STATISTICS;
//
// Reader Statistics struct
//
typedef struct _WMReaderStatistics
{
DWORD cbSize;
DWORD dwBandwidth;
DWORD cPacketsReceived;
DWORD cPacketsRecovered;
DWORD cPacketsLost;
WORD wQuality;
} WM_READER_STATISTICS;
//
// Reader Client Info struct
//
typedef struct _WMReaderClientInfo
{
DWORD cbSize;
WCHAR *wszLang; // 2-3 letter language code
WCHAR *wszBrowserUserAgent; // Embedded browser's user-agent string
WCHAR *wszBrowserWebPage; // The web page that contains the plugin
QWORD qwReserved; // Reserved
LPARAM *pReserved; // Reserved
WCHAR *wszHostExe; // iexplore.exe, netscape.exe dshow.exe, etc
QWORD qwHostVersion; // Version of the host application e.g.:4.70.12.15
} WM_READER_CLIENTINFO;
typedef struct _WMClientProperties
{
DWORD dwIPAddress;
DWORD dwPort;
} WM_CLIENT_PROPERTIES;
//
// Inclusive port number range.
// Used by IWMReaderNetworkConfig.
//
typedef struct _WMPortNumberRange
{
WORD wPortBegin;
WORD wPortEnd;
} WM_PORT_NUMBER_RANGE;
///////////////////////////////////////////////////////////////////////////////
//
// Structure needed for using GetDRMProperty.
//
///////////////////////////////////////////////////////////////////////////////
typedef struct _WM_LICENSE_STATE_DATA
{
DWORD dwSize; // Size of the entire structure.
DWORD dwNumStates; // Number of state data passed back in array of structure below
DRM_LICENSE_STATE_DATA stateData[1];
} WM_LICENSE_STATE_DATA;
///////////////////////////////////////////////////////////////////////////////
//
// Media-type structures and GUIDs.
//
///////////////////////////////////////////////////////////////////////////////
//
// We use DirectShow media types in this SDK. However, to avoid conflict with
// their names, we define our own version of the structure. This is exactly
// the same as an AM_MEDIA_TYPE!
//
typedef struct _WMMediaType
{
GUID majortype;
GUID subtype;
BOOL bFixedSizeSamples;
BOOL bTemporalCompression;
ULONG lSampleSize;
GUID formattype;
IUnknown *pUnk;
ULONG cbFormat;
[size_is(cbFormat)] BYTE *pbFormat;
} WM_MEDIA_TYPE;
cpp_quote( "typedef struct tagWMVIDEOINFOHEADER" )
cpp_quote( "{" )
cpp_quote( " //" )
cpp_quote( " // The bit we really want to use." )
cpp_quote( " //" )
cpp_quote( " RECT rcSource;" )
cpp_quote( "" )
cpp_quote( " //" )
cpp_quote( " // Where the video should go." )
cpp_quote( " //" )
cpp_quote( " RECT rcTarget;" )
cpp_quote( "" )
cpp_quote( " //" )
cpp_quote( " // Approximate bit data rate." )
cpp_quote( " //" )
cpp_quote( " DWORD dwBitRate;" )
cpp_quote( "" )
cpp_quote( " //" )
cpp_quote( " // Bit error rate for this stream." )
cpp_quote( " //" )
cpp_quote( " DWORD dwBitErrorRate;" )
cpp_quote( "" )
cpp_quote( " //" )
cpp_quote( " // Average time per frame (100ns units)." )
cpp_quote( " //" )
cpp_quote( " LONGLONG AvgTimePerFrame;" )
cpp_quote( "" )
cpp_quote( " BITMAPINFOHEADER bmiHeader;" )
cpp_quote( "} WMVIDEOINFOHEADER;" )
cpp_quote( "typedef struct tagWMSCRIPTFORMAT" )
cpp_quote( "{" )
cpp_quote( " GUID scriptType; ")
cpp_quote( "} WMSCRIPTFORMAT;" )
//
// This special GUID is used to create a subtype from an audio format tag, or
// video four-character code. Just fill in the first DWORD of the GUID with
// the appropriate value.
//
cpp_quote( "// 00000000-0000-0010-8000-00AA00389B71 WMMEDIASUBTYPE_Base " )
cpp_quote( "EXTERN_GUID(WMMEDIASUBTYPE_Base, " )
cpp_quote( "0x00000000, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71); " )
cpp_quote( "// 73646976-0000-0010-8000-00AA00389B71 'vids' == WMMEDIATYPE_Video " )
cpp_quote( "EXTERN_GUID(WMMEDIATYPE_Video, " )
cpp_quote( "0x73646976, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); " )
cpp_quote( "// e436eb78-524f-11ce-9f53-0020af0ba770 MEDIASUBTYPE_RGB1 " )
cpp_quote( "EXTERN_GUID(WMMEDIASUBTYPE_RGB1, " )
cpp_quote( "0xe436eb78, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70); " )
cpp_quote( "// e436eb79-524f-11ce-9f53-0020af0ba770 MEDIASUBTYPE_RGB4 " )
cpp_quote( "EXTERN_GUID(WMMEDIASUBTYPE_RGB4, " )
cpp_quote( "0xe436eb79, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70); " )
cpp_quote( "// e436eb7a-524f-11ce-9f53-0020af0ba770 MEDIASUBTYPE_RGB8 " )
cpp_quote( "EXTERN_GUID(WMMEDIASUBTYPE_RGB8, " )
cpp_quote( "0xe436eb7a, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70); " )
cpp_quote( "// e436eb7b-524f-11ce-9f53-0020af0ba770 MEDIASUBTYPE_RGB565 " )
cpp_quote( "EXTERN_GUID(WMMEDIASUBTYPE_RGB565, " )
cpp_quote( "0xe436eb7b, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70); " )
cpp_quote( "// e436eb7c-524f-11ce-9f53-0020af0ba770 MEDIASUBTYPE_RGB555 " )
cpp_quote( "EXTERN_GUID(WMMEDIASUBTYPE_RGB555, " )
cpp_quote( "0xe436eb7c, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70); " )
cpp_quote( "// e436eb7d-524f-11ce-9f53-0020af0ba770 MEDIASUBTYPE_RGB24 " )
cpp_quote( "EXTERN_GUID(WMMEDIASUBTYPE_RGB24, " )
cpp_quote( "0xe436eb7d, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70); " )
cpp_quote( "// e436eb7e-524f-11ce-9f53-0020af0ba770 MEDIASUBTYPE_RGB32 " )
cpp_quote( "EXTERN_GUID(WMMEDIASUBTYPE_RGB32, " )
cpp_quote( "0xe436eb7e, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70); " )
cpp_quote( "// 30323449-0000-0010-8000-00AA00389B71 'YV12' == MEDIASUBTYPE_I420 " )
cpp_quote( "EXTERN_GUID(WMMEDIASUBTYPE_I420, " )
cpp_quote( "0x30323449, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); " )
cpp_quote( "// 56555949-0000-0010-8000-00AA00389B71 'YV12' == MEDIASUBTYPE_IYUV " )
cpp_quote( "EXTERN_GUID(WMMEDIASUBTYPE_IYUV, " )
cpp_quote( "0x56555949, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); " )
cpp_quote( "// 31313259-0000-0010-8000-00AA00389B71 'YV12' == MEDIASUBTYPE_YV12 " )
cpp_quote( "EXTERN_GUID(WMMEDIASUBTYPE_YV12, " )
cpp_quote( "0x32315659, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); " )
cpp_quote( "// 32595559-0000-0010-8000-00AA00389B71 'YUY2' == MEDIASUBTYPE_YUY2 " )
cpp_quote( "EXTERN_GUID(WMMEDIASUBTYPE_YUY2, " )
cpp_quote( "0x32595559, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); " )
cpp_quote( "// 59565955-0000-0010-8000-00AA00389B71 'UYVY' == MEDIASUBTYPE_UYVY " )
cpp_quote( "EXTERN_GUID(WMMEDIASUBTYPE_UYVY, " )
cpp_quote( "0x59565955, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); " )
cpp_quote( "// 55595659-0000-0010-8000-00AA00389B71 'YVYU' == MEDIASUBTYPE_YVYU " )
cpp_quote( "EXTERN_GUID(WMMEDIASUBTYPE_YVYU, " )
cpp_quote( "0x55595659, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); " )
cpp_quote( "// 39555659-0000-0010-8000-00AA00389B71 'YVU9' == MEDIASUBTYPE_YVU9 " )
cpp_quote( "EXTERN_GUID(WMMEDIASUBTYPE_YVU9, " )
cpp_quote( "0x39555659, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); " )
cpp_quote( "// 3334504D-0000-0010-8000-00AA00389B71 WMMEDIASUBTYPE_MP43 " )
cpp_quote( "EXTERN_GUID(WMMEDIASUBTYPE_MP43, " )
cpp_quote( "0x3334504D, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71); " )
cpp_quote( "// 5334504D-0000-0010-8000-00AA00389B71 WMMEDIASUBTYPE_MP4S " )
cpp_quote( "EXTERN_GUID(WMMEDIASUBTYPE_MP4S, " )
cpp_quote( "0x5334504D, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71); " )
cpp_quote( "// 31564D57-0000-0010-8000-00AA00389B71 WMMEDIASUBTYPE_WMV1 " )
cpp_quote( "EXTERN_GUID(WMMEDIASUBTYPE_WMV1, " )
cpp_quote( "0x31564D57, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71); " )
cpp_quote( "// 32564D57-0000-0010-8000-00AA00389B71 WMMEDIASUBTYPE_WMV2 " )
cpp_quote( "EXTERN_GUID(WMMEDIASUBTYPE_WMV2, " )
cpp_quote( "0x32564D57, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71); " )
cpp_quote( "// 3153534D-0000-0010-8000-00AA00389B71 WMMEDIASUBTYPE_MSS1 " )
cpp_quote( "EXTERN_GUID(WMMEDIASUBTYPE_MSS1, " )
cpp_quote( "0x3153534D, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71); " )
cpp_quote( "// 73647561-0000-0010-8000-00AA00389B71 'auds' == WMMEDIATYPE_Audio " )
cpp_quote( "EXTERN_GUID(WMMEDIATYPE_Audio, " )
cpp_quote( "0x73647561, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); " )
cpp_quote( "// 00000001-0000-0010-8000-00AA00389B71 WMMEDIASUBTYPE_PCM " )
cpp_quote( "EXTERN_GUID(WMMEDIASUBTYPE_PCM, " )
cpp_quote( "0x00000001, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71); " )
cpp_quote( "// 00000009-0000-0010-8000-00AA00389B71 WMMEDIASUBTYPE_DRM " )
cpp_quote( "EXTERN_GUID(WMMEDIASUBTYPE_DRM, " )
cpp_quote( "0x00000009, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71); " )
//
// WM Audio v2 and v7 are actually compatible bitstreams.
//
cpp_quote( "// 00000161-0000-0010-8000-00AA00389B71 WMMEDIASUBTYPE_WMAudioV7 " )
cpp_quote( "EXTERN_GUID(WMMEDIASUBTYPE_WMAudioV7, " )
cpp_quote( "0x00000161, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71); " )
cpp_quote( "// 00000161-0000-0010-8000-00AA00389B71 WMMEDIASUBTYPE_WMAudioV2 " )
cpp_quote( "EXTERN_GUID(WMMEDIASUBTYPE_WMAudioV2, " )
cpp_quote( "0x00000161, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71); " )
cpp_quote( "// 00000130-0000-0010-8000-00AA00389B71 WMMEDIASUBTYPE_ACELPnet " )
cpp_quote( "EXTERN_GUID(WMMEDIASUBTYPE_ACELPnet, " )
cpp_quote( "0x00000130, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71); " )
cpp_quote( "// 73636d64-0000-0010-8000-00AA00389B71 'scmd' == MEDIATYPE_Script " )
cpp_quote( "EXTERN_GUID(WMMEDIATYPE_Script, " )
cpp_quote( "0x73636d64, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); " )
cpp_quote( "// 34A50FD8-8AA5-4386-81FE-A0EFE0488E31 WMMEDIATYPE_Image " )
cpp_quote( "EXTERN_GUID(WMMEDIATYPE_Image, " )
cpp_quote( "0x34a50fd8, 0x8aa5, 0x4386, 0x81, 0xfe, 0xa0, 0xef, 0xe0, 0x48, 0x8e, 0x31); " )
cpp_quote( "// 05589f80-c356-11ce-bf01-00aa0055595a WMFORMAT_VideoInfo " )
cpp_quote( "EXTERN_GUID(WMFORMAT_VideoInfo, " )
cpp_quote( "0x05589f80, 0xc356, 0x11ce, 0xbf, 0x01, 0x00, 0xaa, 0x00, 0x55, 0x59, 0x5a); " )
cpp_quote( "// 05589f81-c356-11ce-bf01-00aa0055595a WMFORMAT_WaveFormatEx " )
cpp_quote( "EXTERN_GUID(WMFORMAT_WaveFormatEx, " )
cpp_quote( "0x05589f81, 0xc356, 0x11ce, 0xbf, 0x01, 0x00, 0xaa, 0x00, 0x55, 0x59, 0x5a); " )
cpp_quote( "// 5C8510F2-DEBE-4ca7-BBA5-F07A104F8DFF WMFORMAT_Script " )
cpp_quote( "EXTERN_GUID(WMFORMAT_Script, " )
cpp_quote( "0x5c8510f2, 0xdebe, 0x4ca7, 0xbb, 0xa5, 0xf0, 0x7a, 0x10, 0x4f, 0x8d, 0xff); " )
cpp_quote( "// 82f38a70-c29f-11d1-97ad-00a0c95ea850 WMSCRIPTTYPE_TwoStrings " )
cpp_quote( "EXTERN_GUID( WMSCRIPTTYPE_TwoStrings, " )
cpp_quote( "0x82f38a70,0xc29f,0x11d1,0x97,0xad,0x00,0xa0,0xc9,0x5e,0xa8,0x50); " )
///////////////////////////////////////////////////////////////////////////////
//
// IID GUIDs defined here.
//
///////////////////////////////////////////////////////////////////////////////
cpp_quote( "EXTERN_GUID( IID_IWMMediaProps, 0x96406bce,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff );" )
cpp_quote( "EXTERN_GUID( IID_IWMVideoMediaProps, 0x96406bcf,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff );" )
cpp_quote( "EXTERN_GUID( IID_IWMWriter, 0x96406bd4,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff );" )
cpp_quote( "EXTERN_GUID( IID_IWMInputMediaProps, 0x96406bd5,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff );" )
cpp_quote( "EXTERN_GUID( IID_IWMReader, 0x96406bd6,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff );" )
cpp_quote( "EXTERN_GUID( IID_IWMOutputMediaProps, 0x96406bd7,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff );" )
cpp_quote( "EXTERN_GUID( IID_IWMStatusCallback, 0x6d7cdc70,0x9888,0x11d3,0x8e,0xdc,0x00,0xc0,0x4f,0x61,0x09,0xcf );" )
cpp_quote( "EXTERN_GUID( IID_IWMReaderCallback, 0x96406bd8,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff );" )
cpp_quote( "EXTERN_GUID( IID_IWMCredentialCallback, 0x342e0eb7,0xe651,0x450c,0x97,0x5b,0x2a,0xce,0x2c,0x90,0xc4,0x8e );" )
cpp_quote( "EXTERN_GUID( IID_IWMMetadataEditor, 0x96406bd9,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff );" )
cpp_quote( "EXTERN_GUID( IID_IWMMetadataEditor2, 0x203cffe3,0x2e18,0x4fdf,0xb5,0x9d,0x6e,0x71,0x53,0x05,0x34,0xcf );" )
cpp_quote( "EXTERN_GUID( IID_IWMHeaderInfo, 0x96406bda,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff );" )
cpp_quote( "EXTERN_GUID( IID_IWMHeaderInfo2, 0x15cf9781,0x454e,0x482e,0xb3,0x93,0x85,0xfa,0xe4,0x87,0xa8,0x10 );" )
cpp_quote( "EXTERN_GUID( IID_IWMProfileManager, 0xd16679f2,0x6ca0,0x472d,0x8d,0x31,0x2f,0x5d,0x55,0xae,0xe1,0x55 );" )
cpp_quote( "EXTERN_GUID( IID_IWMProfileManager2, 0x7a924e51,0x73c1,0x494d,0x80,0x19,0x23,0xd3,0x7e,0xd9,0xb8,0x9a );" )
cpp_quote( "EXTERN_GUID( IID_IWMProfile, 0x96406bdb,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff );" )
cpp_quote( "EXTERN_GUID( IID_IWMProfile2, 0x07e72d33,0xd94e,0x4be7,0x88,0x43,0x60,0xae,0x5f,0xf7,0xe5,0xf5 );" )
cpp_quote( "EXTERN_GUID( IID_IWMStreamConfig, 0x96406bdc,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff );" )
cpp_quote( "EXTERN_GUID( IID_IWMStreamList, 0x96406bdd,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff );" )
cpp_quote( "EXTERN_GUID( IID_IWMMutualExclusion, 0x96406bde,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff );" )
cpp_quote( "EXTERN_GUID( IID_IWMWriterAdvanced, 0x96406be3,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff );" )
cpp_quote( "EXTERN_GUID( IID_IWMWriterAdvanced2, 0x962dc1ec,0xc046,0x4db8,0x9c,0xc7,0x26,0xce,0xae,0x50,0x08,0x17 );" )
cpp_quote( "EXTERN_GUID( IID_IWMWriterSink, 0x96406be4,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff );" )
cpp_quote( "EXTERN_GUID( IID_IWMWriterFileSink, 0x96406be5,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff );" )
cpp_quote( "EXTERN_GUID( IID_IWMWriterFileSink2, 0x14282ba7,0x4aef,0x4205,0x8c,0xe5,0xc2,0x29,0x03,0x5a,0x05,0xbc );" )
cpp_quote( "EXTERN_GUID( IID_IWMWriterNetworkSink, 0x96406be7,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff );" )
cpp_quote( "EXTERN_GUID( IID_IWMClientConnections, 0x73c66010,0xa299,0x41df,0xb1,0xf0,0xcc,0xf0,0x3b,0x09,0xc1,0xc6 );" )
cpp_quote( "EXTERN_GUID( IID_IWMReaderAdvanced, 0x96406bea,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff );" )
cpp_quote( "EXTERN_GUID( IID_IWMReaderAdvanced2, 0xae14a945,0xb90c,0x4d0d,0x91,0x27,0x80,0xd6,0x65,0xf7,0xd7,0x3e );" )
cpp_quote( "EXTERN_GUID( IID_IWMReaderAdvanced3, 0x5dc0674b,0xf04b,0x4a4e,0x9f,0x2a,0xb1,0xaf,0xde,0x2c,0x81,0x00 );" )
cpp_quote( "EXTERN_GUID( IID_IWMDRMReader, 0xd2827540,0x3ee7,0x432c,0xb1,0x4c,0xdc,0x17,0xf0,0x85,0xd3,0xb3 );" )
cpp_quote( "EXTERN_GUID( IID_IWMReaderCallbackAdvanced, 0x96406beb,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff );" )
cpp_quote( "EXTERN_GUID( IID_IWMReaderNetworkConfig,0x96406bec,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff );" )
cpp_quote( "EXTERN_GUID( IID_IWMReaderStreamClock, 0x96406bed,0x2b2b,0x11d3,0xb3,0x6b,0x00,0xc0,0x4f,0x61,0x08,0xff );" )
cpp_quote( "EXTERN_GUID( IID_IWMIndexer, 0x6d7cdc71,0x9888,0x11d3,0x8e,0xdc,0x00,0xc0,0x4f,0x61,0x09,0xcf );" )
cpp_quote( "EXTERN_GUID( IID_IWMReaderAllocatorEx, 0x9f762fa7,0xa22e,0x428d,0x93,0xc9,0xac,0x82,0xf3,0xaa,0xfe,0x5a );" )
cpp_quote( "EXTERN_GUID( IID_IWMReaderTypeNegotiation, 0xfdbe5592,0x81a1,0x41ea,0x93,0xbd,0x73,0x5c,0xad,0x1a,0xdc,0x5 );" )
cpp_quote( "EXTERN_GUID( IID_IWMLicenseBackup, 0x05E5AC9F,0x3FB6,0x4508,0xBB,0x43,0xA4,0x06,0x7B,0xA1,0xEB,0xE8);")
cpp_quote( "EXTERN_GUID( IID_IWMLicenseRestore, 0xC70B6334,0xa22e,0x4efb,0xA2,0x45,0x15,0xE6,0x5A,0x00,0x4A,0x13);")
cpp_quote( "EXTERN_GUID( IID_IWMBackupRestoreProps, 0x3C8E0DA6,0x996F,0x4ff3,0xA1,0xAF,0x48,0x38,0xF9,0x37,0x7e,0x2e);")
cpp_quote( "EXTERN_GUID( IID_IWMPacketSize, 0xcdfb97ab,0x188f,0x40b3,0xb6,0x43,0x5b,0x79,0x03,0x97,0x5c,0x59);")
cpp_quote( "EXTERN_GUID( IID_IWMRegisterCallback, 0xcf4b1f99,0x4de2,0x4e49,0xa3,0x63,0x25,0x27,0x40,0xd9,0x9b,0xc1);")
cpp_quote( "EXTERN_GUID( IID_IWMWriterPostView, 0x81e20ce4,0x75ef,0x491a,0x80,0x04,0xfc,0x53,0xc4,0x5b,0xdc,0x3e);")
cpp_quote( "EXTERN_GUID( IID_IWMWriterPostViewCallback, 0xd9d6549d,0xa193,0x4f24,0xb3,0x08,0x03,0x12,0x3d,0x9b,0x7f,0x8d);")
cpp_quote( "EXTERN_GUID( IID_IWMCodecInfo, 0xa970f41e,0x34de,0x4a98,0xb3,0xba,0xe4,0xb3,0xca,0x75,0x28,0xf0);")
cpp_quote( "EXTERN_GUID( IID_IWMCodecInfo2, 0xaa65e273,0xb686,0x4056,0x91,0xec,0xdd,0x76,0x8d,0x4d,0xf7,0x10);")
cpp_quote( "EXTERN_GUID( IID_IWMPropertyVault, 0x72995A79,0x5090,0x42a4,0x9C,0x8C,0xD9,0xD0,0xB6,0xD3,0x4B,0xE5 );" )
///////////////////////////////////////////////////////////////////////////////
//
// Other GUIDs defined here
//
///////////////////////////////////////////////////////////////////////////////
cpp_quote( "EXTERN_GUID( CLSID_WMMUTEX_Bitrate, 0xD6E22A01,0x35DA,0x11D1,0x90,0x34,0x00,0xA0,0xC9,0x03,0x49,0xBE );" )
///////////////////////////////////////////////////////////////////////////////
//
// Max Video Streams / Bands
//
///////////////////////////////////////////////////////////////////////////////
cpp_quote( "#define WM_MAX_VIDEO_STREAMS 0x00c" )
///////////////////////////////////////////////////////////////////////////////
//
// Creation functions.
//
// The SDK supports 3 major objects:
// - CLSID_WMWriter - For writing out WM content.
// - CLSID_WMReader - For playing back WM content.
// - CLSID_WMMetadataEditor - For getting and editing header metadata in WM
// content.
//
///////////////////////////////////////////////////////////////////////////////
cpp_quote( "HRESULT STDMETHODCALLTYPE WMCreateCertificate( IUnknown** pUnkCert );" )
cpp_quote( "HRESULT STDMETHODCALLTYPE WMCreateWriter( IUnknown* pUnkCert, IWMWriter **ppWriter );" )
cpp_quote( "HRESULT STDMETHODCALLTYPE WMCreateReader( IUnknown* pUnkCert, DWORD dwRights, IWMReader **ppReader );" )
cpp_quote( "HRESULT STDMETHODCALLTYPE WMCreateEditor( IWMMetadataEditor **ppEditor );" )
cpp_quote( "HRESULT STDMETHODCALLTYPE WMCreateIndexer( IWMIndexer **ppIndexer );" )
cpp_quote( "HRESULT STDMETHODCALLTYPE WMCreateBackupRestorer( IUnknown *pCallback, IWMLicenseBackup **ppBackup );" )
cpp_quote( "HRESULT STDMETHODCALLTYPE WMCreateProfileManager( IWMProfileManager **ppProfileManager );" )
cpp_quote( "HRESULT STDMETHODCALLTYPE WMCreateWriterFileSink( IWMWriterFileSink **ppSink );" )
cpp_quote( "HRESULT STDMETHODCALLTYPE WMCreateWriterNetworkSink( IWMWriterNetworkSink **ppSink );" )
///////////////////////////////////////////////////////////////////////////////
//
// The following interfaces define the media types that this SDK supports.
// These media types are used by the writer, the reader, and the profile
// object, to identify the media-type specific properties of a media stream.
//
// The main media type is stored in the WM_MEDIA_TYPE structure. Some
// interesting (option) parameters may exist for particular stream types;
// in that case, an IWM<x>MediaProps interface can be used to get and set
// these additional parameters.
//
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 96406BCE-2B2B-11d3-B36B-00C04F6108FF ),
helpstring( "IWMMediaProps Interface"),
pointer_default(unique),
local
]
interface IWMMediaProps : IUnknown
{
//
// GetType is provided for convenience; it returns the same as the
// majortype of the WM_MEDIA_TYPE.
//
HRESULT GetType( [out] GUID *pguidType );
HRESULT GetMediaType( [out] WM_MEDIA_TYPE *pType,
[in, out] DWORD *pcbType );
HRESULT SetMediaType( [in] WM_MEDIA_TYPE *pType );
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 96406BCF-2B2B-11d3-B36B-00C04F6108FF ),
helpstring( "IWMVideoMediaProps Interface"),
pointer_default(unique),
local
]
interface IWMVideoMediaProps : IWMMediaProps
{
HRESULT GetMaxKeyFrameSpacing( [out] LONGLONG *pllTime );
HRESULT SetMaxKeyFrameSpacing( [in] LONGLONG llTime );
HRESULT GetQuality( [out] DWORD *pdwQuality );
HRESULT SetQuality( [in] DWORD dwQuality );
};
///////////////////////////////////////////////////////////////////////////////
//
// The CLSID_WMWriter basic interfaces.
//
// Usage scenario is as follows:
// 1) SetProfile to define the configuration.
// 2) Set the outputs.
// 3) Call GetInputCount (which is valid after (1)), and GetInputProps for
// each stream. Get the default input format, and change it if desired.
// 3.5) Call SetAttribute to add metadata to the header
// At this point, the writer has been configured.
// 4) Call WriteSample repeatedly, until done. (Note that the AllocateSample
// call is just provided for convenience. You are welcome to pass in your
// own samples.)
// 5) Call Flush to write out any buffered data, and update the header and
// index.
//
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 96406BD4-2B2B-11d3-B36B-00C04F6108FF ),
helpstring( "IWMWriter Interface"),
pointer_default(unique),
local
]
interface IWMWriter : IUnknown
{
// This interface QI's for IWMHeaderInfo, and IWMWriterAdvanced.
//
// There are 3 options for setting the profile on the writer. Note that
// setting the profile means that the profile is copied into the writer.
// Further editing of that profile object will have no effect, unless
// SetProfile() is called again.
//
// Calling SetProfile() removes any previously set header attribute info
//
HRESULT SetProfileByID( [in] REFGUID guidProfile );
HRESULT SetProfile( [in] IWMProfile *pProfile );
//
// The easiest way to use the writer is just to write to file.
//
HRESULT SetOutputFilename( [in] const WCHAR *pwszFilename );
//
// The user can enumerate through the various inputs, and get the input
// format. Note that these are not ASF streams; one input stream may map
// to multiple ASF streams in a MEB scenario.
//
// Manipulating the IWMInputMediaProps has no effect on the writer, unless
// the user calls SetInputProps to configure the input.
//
HRESULT GetInputCount( [out] DWORD *pcInputs );
HRESULT GetInputProps( [in] DWORD dwInputNum,
[out] IWMInputMediaProps **ppInput );
HRESULT SetInputProps( [in] DWORD dwInputNum,
[in] IWMInputMediaProps *pInput );
//
// Used for determining all possible format types supported by this
// input on the writer.
//
HRESULT GetInputFormatCount( [in] DWORD dwInputNumber,
[out] DWORD *pcFormats );
HRESULT GetInputFormat( [in] DWORD dwInputNumber,
[in] DWORD dwFormatNumber,
[out] IWMInputMediaProps** pProps );
//
// You must call BeginWriting before sending any samples, and
// you must call EndWriting when you're done sending samples.
//
HRESULT BeginWriting();
//
// EndWriting flushes everything, updates indices and headers,
// and closes the file.
//
HRESULT EndWriting();
//
// Allocate a sample. This is optional; the user is welcome to allocate
// their own buffer class.
//
HRESULT AllocateSample( [in] DWORD dwSampleSize,
[out] INSSBuffer **ppSample );
HRESULT WriteSample( [in] DWORD dwInputNum,
[in] QWORD cnsSampleTime,
[in] DWORD dwFlags,
[in] INSSBuffer *pSample );
//
// Flush() will flush the writer, but leaves the writer prepared to run
// again, when WriteSample() is called again.
// Flush() also causes an updated header to be sent to the sink.
//
HRESULT Flush();
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 96406BD5-2B2B-11d3-B36B-00C04F6108FF ),
helpstring( "IWMInputMediaProps Interface"),
pointer_default(unique),
local
]
interface IWMInputMediaProps : IWMMediaProps
{
HRESULT GetConnectionName( [out] WCHAR *pwszName,
[in, out] WORD *pcchName );
HRESULT GetGroupName( [out] WCHAR *pwszName,
[in, out] WORD *pcchName );
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 72995A79-5090-42a4-9C8C-D9D0B6D34BE5 ),
helpstring( "IWMPropertyVault Interface"),
pointer_default(unique),
local
]
interface IWMPropertyVault : IUnknown
{
HRESULT GetPropertyCount(
[in] DWORD *pdwCount );
HRESULT GetPropertyByName(
[in] LPCWSTR pszName,
[out] WMT_ATTR_DATATYPE *pType,
[out] BYTE *pValue,
[in,out] DWORD *pdwSize );
HRESULT SetProperty(
[in] LPCWSTR pszName,
[in] WMT_ATTR_DATATYPE pType,
[in] BYTE *pValue,
[in] DWORD dwSize );
HRESULT GetPropertyByIndex(
[in] DWORD dwIndex,
[out] LPWSTR pszName,
[in, out] DWORD *pdwNameLen,
[out] WMT_ATTR_DATATYPE *pType,
[out] BYTE *pValue,
[in,out] DWORD *pdwSize );
HRESULT CopyPropertiesFrom(
[in] IWMPropertyVault *pIWMPropertyVault );
HRESULT Clear();
};
///////////////////////////////////////////////////////////////////////////////
//
// The CLSID_WMReader basic interfaces.
//
// Usage is as follows:
// 1) Call Open with a URL (possibly a local filename) and a user-supplied
// callback. After open has completed, the file has been opened and parsed.
// 2) Call GetOutputCount, and GetOutputProps for each output. This
// is valid after (1). This allows the user to get the output format for
// each output.
// 3) Call Start. Status messages and samples will begin arriving in the
// callback function.
// 4) Continue with any combination of Start/Stop/Pause/Seek/SetRate, until
// finished.
//
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 96406BD6-2B2B-11d3-B36B-00C04F6108FF ),
helpstring( "IWMReader Interface"),
pointer_default(unique),
local
]
interface IWMReader : IUnknown
{
//
// This interface QI's for IWMHeaderInfo, IWMProfile, IWMReaderAdvanced,
// IWMReaderAdvanced2, and IWMReaderAdvanced3.
//
//
// Open is an asynch call; it returns almost immediately (if the URL
// is valid), and the user should wait for appropriate OnStatus calls to
// be sent to the callback.
//
HRESULT Open( [in] const WCHAR *pwszURL,
[in] IWMReaderCallback *pCallback,
[in] void *pvContext );
HRESULT Close();
//
// The user can enumerate through the various outputs, and get the
// output format for that data.
//
// Manipulating the IWMOutputMediaProps has no effect on the output, unless
// the user also calls SetOutputProps.
//
HRESULT GetOutputCount( [out] DWORD *pcOutputs );
HRESULT GetOutputProps( [in] DWORD dwOutputNum,
[out] IWMOutputMediaProps **ppOutput );
HRESULT SetOutputProps( [in] DWORD dwOutputNum,
[in] IWMOutputMediaProps *pOutput );
//
// Used for determining all possible format types supported by this
// output on the reader.
//
HRESULT GetOutputFormatCount( [in] DWORD dwOutputNumber,
[out] DWORD *pcFormats );
HRESULT GetOutputFormat( [in] DWORD dwOutputNumber,
[in] DWORD dwFormatNumber,
[out] IWMOutputMediaProps** ppProps );
//
// If duration is 0, play to the end of the file.
// If msStart is set to WM_START_CURRENTPOSITION then don't perform a seek
// operation. A good use for this is when you want to change the rate but
// not the current file position.
//
// Note that any call to start while Paused will be treated as a seek.
// Even calls to Start( WM_START_CURRENTPOSITION, ... ). If your intention
// is to seek (which will incur the buffering penalty from network files)
// then you can go ahead and call Start. However, if your intention was
// to continue playing from where the user paused, you should call Resume
// instead.
//
HRESULT Start( [in] QWORD cnsStart,
[in] QWORD cnsDuration,
[in] float fRate,
[in] void *pvContext );
HRESULT Stop();
HRESULT Pause();
HRESULT Resume();
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 96406BD7-2B2B-11d3-B36B-00C04F6108FF ),
helpstring( "IWMOutputMediaProps Interface"),
pointer_default(unique),
local
]
interface IWMOutputMediaProps : IWMMediaProps
{
//
// A Stream Group and type together uniquely identify each output. (The
// type is on IWMMediaProps).
//
HRESULT GetStreamGroupName( [out] WCHAR *pwszName,
[in, out] WORD *pcchName );
HRESULT GetConnectionName( [out] WCHAR *pwszName,
[in, out] WORD *pcchName );
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 6d7cdc70-9888-11d3-8edc-00c04f6109cf ),
helpstring( "IWMStatusCallback Interface"),
pointer_default(unique),
local
]
interface IWMStatusCallback : IUnknown
{
//
// The contents of pValue depends on the Status.
//
HRESULT OnStatus( [in] WMT_STATUS Status,
[in] HRESULT hr,
[in] WMT_ATTR_DATATYPE dwType,
[in] BYTE *pValue,
[in] void *pvContext );
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 96406BD8-2B2B-11d3-B36B-00C04F6108FF ),
helpstring( "IWMReaderCallback Interface"),
pointer_default(unique),
local
]
interface IWMReaderCallback : IWMStatusCallback
{
//
// cnsSampleDuration will be 0 for most media types.
//
HRESULT OnSample( [in] DWORD dwOutputNum,
[in] QWORD cnsSampleTime,
[in] QWORD cnsSampleDuration,
[in] DWORD dwFlags,
[in] INSSBuffer *pSample,
[in] void *pvContext );
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 342e0eb7-e651-450c-975b-2ace2c90c48e ),
helpstring( "IWMCredentialCallback Interface"),
pointer_default(unique),
local
]
interface IWMCredentialCallback : IUnknown
{
HRESULT AcquireCredentials( [in] WCHAR *pwszRealm,
[in] WCHAR *pwszSite,
[in, out, size_is( cchUser )] WCHAR *pwszUser,
[in] DWORD cchUser,
[in, out, size_is( cchPassword )] WCHAR *pwszPassword,
[in] DWORD cchPassword,
[in] HRESULT hrStatus,
[in, out] DWORD *pdwFlags );
};
///////////////////////////////////////////////////////////////////////////////
//
// The CLSID_WMMetadataEditor basic interfaces.
//
// Usage:
// 1) Call Open with a filename.
// 2) QI for IWMHeaderInfo, and use that to get and set attributes as
// needed.
// 3) Flush() will cause any changes to be written back to disk (if possible).
// 4) Close() closes the file without writing any changes to disk.
//
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 96406BD9-2B2B-11d3-B36B-00C04F6108FF ),
helpstring( "IWMMetadataEditor Interface"),
pointer_default(unique),
local
]
interface IWMMetadataEditor : IUnknown
{
// QI this for IWMHeaderInfo to edit the header attributes.
//
// Manage the file
//
HRESULT Open( [in] const WCHAR *pwszFilename );
HRESULT Close();
HRESULT Flush();
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 203CFFE3-2E18-4fdf-B59D-6E71530534CF ),
helpstring( "IWMMetadataEditor2 Interface" ),
pointer_default(unique),
local
]
interface IWMMetadataEditor2 : IWMMetadataEditor
{
//
// The flags to dwDesiredAccess and dwShareMode match the flags to
// (the win32 API) CreateFile.
//
// Supported modes are:
// GENERIC_READ | GENERIC_WRITE, 0
// GENERIC_READ, 0 or
// FILE_SHARE_READ or
// FILE_SHARE_DELETE or
// FILE_SHARE_READ | FILE_SHARE_DELETE
//
HRESULT OpenEx( [in] const WCHAR *pwszFilename,
[in] DWORD dwDesiredAccess,
[in] DWORD dwShareMode );
};
///////////////////////////////////////////////////////////////////////////////
//
// Below are utility interfaces used across all 3 of the main objects.
//
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 96406BDA-2B2B-11d3-B36B-00C04F6108FF ),
helpstring( "IWMHeaderInfo Interface"),
pointer_default(unique),
local
]
//
// The 3 main interface (IWMWriter, IWMReader, and
// IWMMetadataEditor) can be QI'd for this interface to get and set
// header attributes, and markers.
//
interface IWMHeaderInfo : IUnknown
{
//
// For attributes, the stream number passed in means:
// -1 (0xffff) to specifies "any or no stream".
// 0 specifies "no stream".
// Any other value indicates the stream number.
//
// Windows Media version 4 and earlier does not support per stream
// attributes, so any stream number other than 0 will fail.
//
HRESULT GetAttributeCount( [in] WORD wStreamNum,
[out] WORD *pcAttributes );
HRESULT GetAttributeByIndex( [in] WORD wIndex,
[in, out] WORD *pwStreamNum,
[out] WCHAR *pwszName,
[in,out] WORD *pcchNameLen,
[out] WMT_ATTR_DATATYPE *pType,
[out] BYTE *pValue,
[in,out] WORD *pcbLength );
HRESULT GetAttributeByName( [in, out] WORD *pwStreamNum,
[in] LPCWSTR pszName,
[out] WMT_ATTR_DATATYPE *pType,
[out] BYTE *pValue,
[in,out] WORD *pcbLength );
HRESULT SetAttribute( [in] WORD wStreamNum,
[in] LPCWSTR pszName,
[in] WMT_ATTR_DATATYPE Type,
[in] const BYTE *pValue,
[in] WORD cbLength );
//
// Marker methods.
//
HRESULT GetMarkerCount( [out] WORD *pcMarkers );
HRESULT GetMarker( [in] WORD wIndex,
[out] WCHAR *pwszMarkerName,
[in, out] WORD *pcchMarkerNameLen,
[out] QWORD *pcnsMarkerTime );
HRESULT AddMarker( [in] WCHAR *pwszMarkerName,
[in] QWORD cnsMarkerTime );
HRESULT RemoveMarker( [in] WORD wIndex );
//
// Script command methods.
//
HRESULT GetScriptCount( [out] WORD *pcScripts );
HRESULT GetScript( [in] WORD wIndex,
[out] WCHAR *pwszType,
[in, out] WORD *pcchTypeLen,
[out] WCHAR *pwszCommand,
[in, out] WORD *pcchCommandLen,
[out] QWORD *pcnsScriptTime );
HRESULT AddScript( [in] WCHAR *pwszType,
[in] WCHAR *pwszCommand,
[in] QWORD cnsScriptTime );
HRESULT RemoveScript( [in] WORD wIndex );
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 15CF9781-454E-482e-B393-85FAE487A810 ),
helpstring( "IWMHeaderInfo Interface"),
pointer_default(unique),
local
]
//
// The 3 main interface (IWMWriter, IWMReader, and
// IWMMetadataEditor) can be QI'd for this interface to get and set
// header attributes, and markers.
//
interface IWMHeaderInfo2 : IWMHeaderInfo
{
HRESULT GetCodecInfoCount( [out] DWORD* pcCodecInfos );
HRESULT GetCodecInfo( [in] DWORD wIndex,
[in,out] WORD* pcchName,
[out] WCHAR* pwszName,
[in,out] WORD* pcchDescription,
[out] WCHAR* pwszDescription,
[out] WMT_CODEC_INFO_TYPE* pCodecType,
[in,out] WORD* pcbCodecInfo,
[out] BYTE* pbCodecInfo );
};
///////////////////////////////////////////////////////////////////////////////
//
// The profile API. The intention is that most users don't touch the profile
// API, but just use pre-existing profiles.
//
// Profiles define authoring configurations, such as stream types, bitrates,
// etc.
//
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( d16679f2-6ca0-472d-8d31-2f5d55aee155 ),
helpstring( "IWMProfileManager Interface"),
pointer_default(unique),
local
]
interface IWMProfileManager : IUnknown
{
//
// Create a profile with nothing in it.
//
HRESULT CreateEmptyProfile( [in] WMT_VERSION dwVersion,
[out] IWMProfile **ppProfile );
//
// Load a system profile given its ID.
//
HRESULT LoadProfileByID( [in] REFGUID guidProfile,
[out] IWMProfile **ppProfile );
//
// Load a profile from a stored string.
//
HRESULT LoadProfileByData( [in] const WCHAR *pwszProfile,
[out] IWMProfile **ppProfile );
//
// Save profile specified by its string.
//
HRESULT SaveProfile( [in] IWMProfile *pIWMProfile, [in] WCHAR *pwszProfile, [in, out] DWORD *pdwLength );
//
// Iterate through the system profiles.
//
HRESULT GetSystemProfileCount( [out] DWORD *pcProfiles );
HRESULT LoadSystemProfile( [in] DWORD dwProfileIndex,
[out] IWMProfile **ppProfile );
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 7A924E51-73C1-494d-8019-23D37ED9B89A ),
helpstring( "IWMProfileManager2 Interface"),
pointer_default(unique),
local
]
interface IWMProfileManager2 : IWMProfileManager
{
//
// Set the version number of the system profiles that the profile manager
// will enumerate. WMT_VER_4_0 is the default, for compatibility reasons,
// so be sure to set this to the latest version if that is the desired
// result.
//
HRESULT GetSystemProfileVersion( WMT_VERSION *pdwVersion );
HRESULT SetSystemProfileVersion( WMT_VERSION dwVersion );
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 96406BDB-2B2B-11d3-B36B-00C04F6108FF ),
helpstring( "IWMProfile Interface"),
pointer_default(unique),
local
]
interface IWMProfile : IUnknown
{
//
// By default, when the user creates a profile, it will use the latest
// version of Windows Media. To create a backward-compatible profile,
// call IWMProfileManager::CreateEmptyProfile with the appropriate version
// number.
//
HRESULT GetVersion( [out] WMT_VERSION *pdwVersion );
//
// Profiles have names and descriptions, for use when displaying lists
// of profiles, etc.
//
HRESULT GetName( [out] WCHAR *pwszName,
[in, out] DWORD *pcchName );
HRESULT SetName( [in] const WCHAR *pwszName );
HRESULT GetDescription( [out] WCHAR *pwszDescription,
[in, out] DWORD *pcchName );
HRESULT SetDescription( [in] const WCHAR *pwszDescription );
//
// Methods for enumerating the streams. Note that updating the
// returned IWMStreamConfig has no effect on the profile until you
// call ReconfigStream().
//
HRESULT GetStreamCount( [out] DWORD *pcStreams );
HRESULT GetStream( [in] DWORD dwStreamIndex,
[out] IWMStreamConfig **ppConfig );
HRESULT GetStreamByNumber( [in] WORD wStreamNum,
[out] IWMStreamConfig **ppConfig );
//
// Remove a stream.
//
HRESULT RemoveStream( [in] IWMStreamConfig *pConfig );
HRESULT RemoveStreamByNumber( [in] WORD wStreamNum );
//
// Adding a stream copies the config into the profile.
//
HRESULT AddStream( [in] IWMStreamConfig *pConfig );
HRESULT ReconfigStream( [in] IWMStreamConfig *pConfig );
//
// Create a new stream config object (avoiding the need to CoCreate).
// This will still need to be added to the profile using the AddStream()
// call (but only after it has been configured).
//
HRESULT CreateNewStream( [in] REFGUID guidStreamType,
[out] IWMStreamConfig **ppConfig );
//
// Mutual Exclusion. As above, only Add and Remove actual change the
// profile.
//
HRESULT GetMutualExclusionCount( [out] DWORD *pcME );
HRESULT GetMutualExclusion( [in] DWORD dwMEIndex,
[out] IWMMutualExclusion **ppME );
HRESULT RemoveMutualExclusion( [in] IWMMutualExclusion *pME );
HRESULT AddMutualExclusion( [in] IWMMutualExclusion *pME );
HRESULT CreateNewMutualExclusion( [out] IWMMutualExclusion **ppME );
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 07E72D33-D94E-4be7-8843-60AE5FF7E5F5 ),
helpstring( "IWMProfile2 Interface"),
pointer_default(unique),
local
]
interface IWMProfile2 : IWMProfile
{
//
// Get/set this profile's unique identifier
//
HRESULT GetProfileID( [out] GUID* pguidID );
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 96406BDC-2B2B-11d3-B36B-00C04F6108FF ),
helpstring( "IWMStreamConfig Interface"),
pointer_default(unique),
local
]
//
// IWMStreamConfig represents an ASF stream.
//
interface IWMStreamConfig : IUnknown
{
// This interface QI's for IWMMediaProps and one of it's inheritors.
// (IWMVideoMediaProps, for instance).
HRESULT GetStreamType( [out] GUID *pguidStreamType );
HRESULT GetStreamNumber( [out] WORD *pwStreamNum );
HRESULT SetStreamNumber( [in] WORD wStreamNum );
HRESULT GetStreamName( [out] WCHAR *pwszStreamName,
[in, out] WORD *pcchStreamName );
HRESULT SetStreamName( [in] WCHAR *pwszStreamName );
HRESULT GetConnectionName( [out] WCHAR *pwszInputName,
[in, out] WORD *pcchInputName );
HRESULT SetConnectionName( [in] WCHAR *pwszInputName );
HRESULT GetBitrate( [out] DWORD *pdwBitrate );
HRESULT SetBitrate( [in] DWORD pdwBitrate );
//
// A buffer window of -1 (0xffffffff) indicates that the buffer window
// is unknown. On the writer side, this means the writer can use whatever
// buffer window it chooses.
//
HRESULT GetBufferWindow( [out] DWORD *pmsBufferWindow );
HRESULT SetBufferWindow( [in] DWORD msBufferWindow );
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( CDFB97AB-188F-40b3-B643-5B7903975C59 ),
helpstring( "IWMPacketSize Interface"),
pointer_default(unique),
local
]
//
// Controls how big packets can get in an ASF file.
//
interface IWMPacketSize : IUnknown
{
HRESULT GetMaxPacketSize( [out] DWORD *pdwMaxPacketSize );
HRESULT SetMaxPacketSize( [in] DWORD dwMaxPacketSize );
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 96406BDD-2B2B-11d3-B36B-00C04F6108FF ),
helpstring( "IWMStreamList Interface"),
pointer_default(unique),
local
]
//
// IWMStreamList is used for the various objects that define relationships
// between streams.
//
interface IWMStreamList : IUnknown
{
HRESULT GetStreams( [out] WORD *pwStreamNumArray,
[in, out] WORD *pcStreams );
HRESULT AddStream( [in] WORD wStreamNum );
HRESULT RemoveStream( [in] WORD wStreamNum );
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 96406BDE-2B2B-11d3-B36B-00C04F6108FF ),
helpstring( "IWMMutualExclusion Interface"),
pointer_default(unique),
local
]
//
// IWMMutualExclusion specifies a group of streams, of which only one can
// be played at once. These are used to do MEB (stream selection based on
// bandwidth).
//
interface IWMMutualExclusion : IWMStreamList
{
//
// The possible types of mutual exclusion are defined in the ASF
// header.
//
HRESULT GetType( [out] GUID *pguidType );
HRESULT SetType( [in] REFGUID guidType );
};
///////////////////////////////////////////////////////////////////////////////
//
// Advanced features.
//
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 96406BE3-2B2B-11d3-B36B-00C04F6108FF ),
helpstring( "IWMWriterAdvanced Interface"),
pointer_default(unique),
local
]
//
// The writer can be QI'd for this interface, which provides advanced writing
// functionality.
//
interface IWMWriterAdvanced : IUnknown
{
//
// Sinks are where the output ASF data goes.
//
HRESULT GetSinkCount( [out] DWORD *pcSinks );
HRESULT GetSink( [in] DWORD dwSinkNum,
[out] IWMWriterSink **ppSink );
HRESULT AddSink( [in] IWMWriterSink *pSink );
HRESULT RemoveSink( [in] IWMWriterSink *pSink );
//
// By default, the user provides samples to an input on the
// IWMWriter interface, and the samples may be compressed, put
// into a MEB stream, etc. However, the user can use this interface to
// put the samples directly into the ASF, with no compression etc.
//
HRESULT WriteStreamSample( [in] WORD wStreamNum,
[in] QWORD cnsSampleTime,
[in] DWORD msSampleSendTime,
[in] QWORD cnsSampleDuration,
[in] DWORD dwFlags,
[in] INSSBuffer *pSample );
//
// The writer may be running in real-time. If so, it's interesting to
// get the current time from the writer.
//
HRESULT SetLiveSource( BOOL fIsLiveSource );
HRESULT IsRealTime( [out] BOOL *pfRealTime );
HRESULT GetWriterTime( [out] QWORD *pcnsCurrentTime );
//
// To get statistics, pass in a WM_WRITER_STATISTICS structure, which
// will be filled out by the GetStatistics() call with the requested
// stats.
//
// Pass in a stream number to get statistics for a specific stream, or
// pass 0 to get statistics for the entire ASF file.
//
HRESULT GetStatistics( [in] WORD wStreamNum,
[out] WM_WRITER_STATISTICS *pStats );
//
// Sync tolerance determines how far out of sync the inputs will be allowed
// to get before samples are thrown away. Default is 3000 ms.
//
HRESULT SetSyncTolerance( [in] DWORD msWindow );
HRESULT GetSyncTolerance( [out] DWORD* pmsWindow );
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 962dc1ec-c046-4db8-9cc7-26ceae500817 ),
helpstring( "IWMWriterAdvanced2 Interface"),
pointer_default(unique),
local
]
//
// The writer can be QI'd for this interface, which provides advanced writing
// functionality.
//
interface IWMWriterAdvanced2 : IWMWriterAdvanced
{
//
// Retrieves a setting for a particular output by name
//
HRESULT GetInputSetting(
[in] DWORD dwInputNum,
[in] LPCWSTR pszName,
[out] WMT_ATTR_DATATYPE *pType,
[out] BYTE *pValue,
[in,out] WORD *pcbLength );
//
// Sets a named setting for a particular input
//
HRESULT SetInputSetting(
[in] DWORD dwInputNum,
[in] LPCWSTR pszName,
[in] WMT_ATTR_DATATYPE Type,
[in] const BYTE *pValue,
[in] WORD cbLength );
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( D9D6549D-A193-4f24-B308-03123D9B7F8D ),
helpstring( "IWMWriterPostViewCallback Interface"),
pointer_default(unique),
local
]
//
// This is the interface that receives uncompressed samples from the writer
// to preview (well, postview) what the codec is doing.
//
interface IWMWriterPostViewCallback : IWMStatusCallback
{
//
// cnsSampleDuration will be 0 for most media types.
//
HRESULT OnPostViewSample( [in] WORD wStreamNumber,
[in] QWORD cnsSampleTime,
[in] QWORD cnsSampleDuration,
[in] DWORD dwFlags,
[in] INSSBuffer *pSample,
[in] void *pvContext );
HRESULT AllocateForPostView([in] WORD wStreamNum,
[in] DWORD cbBuffer,
[out] INSSBuffer **ppBuffer,
[in] void *pvContext );
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 81E20CE4-75EF-491a-8004-FC53C45BDC3E ),
helpstring( "IWMWriterPostView Interface"),
pointer_default(unique),
local
]
//
// The writer can be QI'd for this interface, which provides advanced writing
// functionality.
//
interface IWMWriterPostView : IUnknown
{
//
// Specify the callback to use for PostView
//
HRESULT SetPostViewCallback( IWMWriterPostViewCallback* pCallback, void* pvContext );
//
// Turns on delivery of postview samples for a given stream
//
HRESULT SetReceivePostViewSamples( [in] WORD wStreamNum,
[in] BOOL fReceivePostViewSamples );
HRESULT GetReceivePostViewSamples( [in] WORD wStreamNum,
[out] BOOL *pfReceivePostViewSamples );
//
// The user can enumerate through the various outputs, and get the
// output format for that data.
//
// Manipulating the IWMOutputMediaProps has no effect on the output, unless
// the user also calls SetOutputProps.
//
HRESULT GetPostViewProps( [in] WORD wStreamNumber,
[out] IWMMediaProps **ppOutput );
HRESULT SetPostViewProps( [in] WORD wStreamNumber,
[in] IWMMediaProps *pOutput );
//
// Used for determining all possible format types supported by this
// output on the reader.
//
HRESULT GetPostViewFormatCount( [in] WORD wStreamNumber,
[out] DWORD *pcFormats );
HRESULT GetPostViewFormat( [in] WORD wStreamNumber,
[in] DWORD dwFormatNumber,
[out] IWMMediaProps** ppProps );
//
// The user can register himself to provide buffers for any of the outputs
// (for instance, DDraw buffers). The actual allocation is on the
// IWMReaderCallbackAdvanced interface.
//
HRESULT SetAllocateForPostView( [in] WORD wStreamNumber,
[in] BOOL fAllocate );
HRESULT GetAllocateForPostView( [in] WORD wStreamNumber,
[out] BOOL *pfAllocate );
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 96406BE4-2B2B-11d3-B36B-00C04F6108FF ),
helpstring( "IWMWriterSink Interface"),
pointer_default(unique),
local
]
//
// This is the interface that receives raw ASF from the writer.
//
interface IWMWriterSink : IUnknown
{
HRESULT OnHeader( [in] INSSBuffer *pHeader );
//
// Some sinks require that data be fed to them in real-time.
//
HRESULT IsRealTime( [out] BOOL *pfRealTime );
HRESULT AllocateDataUnit( [in] DWORD cbDataUnit,
[out] INSSBuffer **ppDataUnit );
HRESULT OnDataUnit( [in] INSSBuffer *pDataUnit );
//
// This function is called when the writer is done sending data.
//
HRESULT OnEndWriting();
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( CF4B1F99-4DE2-4e49-A363-252740D99BC1 ),
helpstring( "IWMRegisterCallback Interface"),
pointer_default(unique),
local
]
interface IWMRegisterCallback : IUnknown
{
HRESULT Advise( [in] IWMStatusCallback* pCallback,
[in] void* pvContext );
HRESULT Unadvise( [in] IWMStatusCallback* pCallback,
[in] void* pvContext );
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 96406BE5-2B2B-11d3-B36B-00C04F6108FF ),
helpstring( "IWMWriterFileSink Interface"),
pointer_default(unique),
local
]
interface IWMWriterFileSink : IWMWriterSink
{
HRESULT Open( [in] const WCHAR *pwszFilename );
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 14282BA7-4AEF-4205-8CE5-C229035A05BC ),
helpstring( "IWMWriterFileSink2 Interface"),
pointer_default(unique),
local
]
interface IWMWriterFileSink2 : IWMWriterFileSink
{
HRESULT Start( [in] QWORD cnsStartTime );
HRESULT Stop( [in] QWORD cnsStopTime );
HRESULT IsStopped( [out] BOOL *pfStopped );
HRESULT GetFileDuration( [out] QWORD *pcnsDuration );
HRESULT GetFileSize( [out] QWORD *pcbFile );
HRESULT Close();
HRESULT IsClosed( [out] BOOL *pfClosed );
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 96406BE7-2B2B-11d3-B36B-00C04F6108FF ),
helpstring( "IWMWriterNetworkSink Interface"),
pointer_default(unique),
local
]
interface IWMWriterNetworkSink : IWMWriterSink
{
//
// Determine the maximum number of clients that can connect to this sink.
// Default is 10.
//
HRESULT SetMaximumClients( [in] DWORD dwMaxClients );
HRESULT GetMaximumClients( [out] DWORD *pdwMaxClients );
//
// The network protocol that the network sink will use.
//
HRESULT SetNetworkProtocol( [in] WMT_NET_PROTOCOL protocol );
HRESULT GetNetworkProtocol( [out] WMT_NET_PROTOCOL *pProtocol );
//
// Find out the name of the URL on which we're broadcasting
//
HRESULT GetHostURL( [out] WCHAR *pwszURL,
[in, out] DWORD *pcchURL );
//
// The method claims the network port number. Close the sink to release
// the port.
//
// Specify 0 for the port number and the sink will select a port for
// the user.
//
HRESULT Open( [in, out] DWORD *pdwPortNum );
//
// Disconnect all connected clients.
//
HRESULT Disconnect();
//
// Close and release the open port.
//
HRESULT Close();
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 73C66010-A299-41df-B1F0-CCF03B09C1C6 ),
helpstring( "IWMClientConnections Interface"),
pointer_default(unique),
local
]
interface IWMClientConnections : IUnknown
{
//
// Determine the number of connected clients
//
HRESULT GetClientCount( [out] DWORD* pcClients );
//
// Get information about a connected client
//
HRESULT GetClientProperties( [in] DWORD dwClientNum,
[out] WM_CLIENT_PROPERTIES *pClientProperties );
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 96406BEA-2B2B-11d3-B36B-00C04F6108FF ),
helpstring( "IWMReaderAdvanced Interface"),
pointer_default(unique),
local
]
//
// The reader can be QI'd for this interface for advanced functionality.
//
interface IWMReaderAdvanced : IUnknown
{
//
// The user may want to drive the clock himself, particularly if he wants
// to source from a file faster-than-realtime. This call may fail if the
// current source does not support user-driven clocks.
//
// The proper way for a user to drive the clock is for the user to call
// DeliverTime, and then wait for the OnTime call on
// IWMReaderCallbackAdvanced to reach the time he specified.
//
HRESULT SetUserProvidedClock( [in] BOOL fUserClock );
HRESULT GetUserProvidedClock( [out] BOOL *pfUserClock );
HRESULT DeliverTime( [in] QWORD cnsTime );
//
// The user can select streams manually, instead of relying on the
// automatic bandwidth stream selection that the reader will
// normally do. To figure out what streams are in this ASF and what their
// numbers are, QI for IWMProfile.
//
// When SetManualStreamSelection( TRUE ) is called, all streams are
// selected by default.
//
HRESULT SetManualStreamSelection( [in] BOOL fSelection );
HRESULT GetManualStreamSelection( [out] BOOL *pfSelection );
HRESULT SetStreamsSelected( [in] WORD cStreamCount,
[in] WORD *pwStreamNumbers,
[in] WMT_STREAM_SELECTION *pSelections );
HRESULT GetStreamSelected( [in] WORD wStreamNum,
[out] WMT_STREAM_SELECTION *pSelection );
//
// The user can also choose to get callbacks when automatic stream
// selection occurs.
//
HRESULT SetReceiveSelectionCallbacks( [in] BOOL fGetCallbacks );
HRESULT GetReceiveSelectionCallbacks( [in] BOOL *pfGetCallbacks );
//
// The user can register himself to receive samples directly from the
// ASF streams, rather than letting the Reader decompress them. Note that
// to do this, the IWMReaderCallback (supplied by the user) must support
// IWMReaderCallbackAdvanced.
//
// To get actual information about the contents of a stream, QI the
// object for IWMProfile.
//
HRESULT SetReceiveStreamSamples( [in] WORD wStreamNum,
[in] BOOL fReceiveStreamSamples );
HRESULT GetReceiveStreamSamples( [in] WORD wStreamNum,
[out] BOOL *pfReceiveStreamSamples );
//
// The user can register himself to provide buffers for any of the outputs
// (for instance, DDraw buffers). The actual allocation is on the
// IWMReaderCallbackAdvanced interface.
//
HRESULT SetAllocateForOutput( [in] DWORD dwOutputNum,
[in] BOOL fAllocate );
HRESULT GetAllocateForOutput( [in] DWORD dwOutputNum,
[out] BOOL *pfAllocate );
HRESULT SetAllocateForStream( [in] WORD dwStreamNum,
[in] BOOL fAllocate );
HRESULT GetAllocateForStream( [in] WORD dwSreamNum,
[out] BOOL *pfAllocate );
//
// Get statistics on demand
//
HRESULT GetStatistics( [in] WM_READER_STATISTICS *pStatistics );
//
// Set client side information used for logging
//
HRESULT SetClientInfo( [in] WM_READER_CLIENTINFO *pClientInfo );
//
// Get the maximum required buffer sizes that the SDK will allocate.
// The first is for output buffers, the second for stream buffers.
//
HRESULT GetMaxOutputSampleSize( [in] DWORD dwOutput, [out] DWORD *pcbMax );
HRESULT GetMaxStreamSampleSize( [in] WORD wStream, [out] DWORD *pcbMax );
//
// Used to notify the reader that it's delivering data
// too slowly to the client. The reader will try to speed
// up.
//
HRESULT NotifyLateDelivery( QWORD cnsLateness );
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( ae14a945-b90c-4d0d-9127-80d665f7d73e ),
helpstring( "IWMReaderAdvanced2 Interface"),
pointer_default(unique),
local
]
//
// The reader can be QI'd for this interface for advanced functionality.
//
interface IWMReaderAdvanced2 : IWMReaderAdvanced
{
//
// Set the play mode to WMT_PLAY_MODE_AUTOSELECT to allow the reader
// to pick the mode. (This is the default). If you select a play mode that
// is impossible for the requested URL, an error will be returned when
// the URL is opened.
//
HRESULT SetPlayMode( [in] WMT_PLAY_MODE Mode );
//
// Get the current play mode.
//
HRESULT GetPlayMode( [out] WMT_PLAY_MODE *pMode );
//
// Between WMT_BUFFERING_START and WMT_BUFFERING_STOP this call will
// return progress values. pdwPercent returns the percentage of buffering
// that has completed, and pcnsBuffering returns the amount of buffering
// remaining.
//
HRESULT GetBufferProgress( [out] DWORD *pdwPercent,
[out] QWORD *pcnsBuffering );
//
// When the play mode is WMT_PLAY_MODE_DOWNLOAD, this call will return
// progress values. pdwPercent returns the percentage of the download
// that has completed, pqwBytesDownloaded returns the number of bytes
// that have been downloaded, and pcnsDownload returns the amount of
// downloading remaining.
//
HRESULT GetDownloadProgress( [out] DWORD *pdwPercent,
[out] QWORD *pqwBytesDownloaded,
[out] QWORD *pcnsDownload );
//
// When saving a file, the operation may take awhile. Between
// WMT_SAVEAS_START and WMT_SAVEAS_STOP, this call will return progress
// values. pdwPercent returns the percentage of the save as that has
// completed.
//
HRESULT GetSaveAsProgress( [out] DWORD *pdwPercent );
//
// Save the current file. This only works for WMT_PLAY_MODE_DOWNLOAD.
// This operation is asynchronous; WMT_SAVEAS_STOP indicates that the
// save has completed. Closing the reader will abort a save operation
// that has not completed.
//
HRESULT SaveFileAs( [in] const WCHAR *pwszFilename );
//
// Returns the name of the protocol that is currently being used.
// The protocol name is a URL scheme, such as "mmsu", "http", "file", etc.
// Note, however, that the protocol name may differ from the URL scheme
// that was specified in IWMReader::Open().
// This method may return an empty string if the protocol name cannot be determined.
//
HRESULT GetProtocolName( [out] WCHAR *pwszProtocol, [in, out] DWORD *pcchProtocol );
//
// Same as IWMReader::Start, but uses a marker index instead of a time value.
//
HRESULT StartAtMarker( [in] WORD wMarkerIndex,
[in] QWORD cnsDuration,
[in] float fRate,
[in] void *pvContext );
//
// Retrieves a setting for a particular output by name
//
HRESULT GetOutputSetting(
[in] DWORD dwOutputNum,
[in] LPCWSTR pszName,
[out] WMT_ATTR_DATATYPE *pType,
[out] BYTE *pValue,
[in,out] WORD *pcbLength );
//
// Sets a named setting for a particular output
//
HRESULT SetOutputSetting(
[in] DWORD dwOutputNum,
[in] LPCWSTR pszName,
[in] WMT_ATTR_DATATYPE Type,
[in] const BYTE *pValue,
[in] WORD cbLength );
//
// Used to begin prerolling the reader. Call this method
// when you know you're going to call Start soon and want
// to start buffering data in advance. cnsStart, cnsDuration
// and fRate should be the same as the values you plan to pass
// to Start in the future.
//
HRESULT Preroll(
[in] QWORD cnsStart,
[in] QWORD cnsDuration,
[in] float fRate );
//
// Specifies whether the SDK should send the client's unique identifier
// to the server when streaming.
//
HRESULT SetLogClientID( [in] BOOL fLogClientID );
HRESULT GetLogClientID( [out] BOOL *pfLogClientID );
//
// This method requests that the Reader send WMT_BUFFERING_STOP as soon
// as possible. The Reader will only honor the request if it is currently
// buffering, i.e., it has sent a WMT_BUFFERING_START, but not yet sent the
// corresponding WMT_BUFFERING_STOP.
//
HRESULT StopBuffering( );
//
// Same as IWMReader::Open but takes an IStream interface pointer instead
// of an URL to be opened
//
HRESULT OpenStream( [in] IStream *pStream,
[in] IWMReaderCallback *pCallback,
[in] void *pvContext );
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 5DC0674B-F04B-4a4e-9F2A-B1AFDE2C8100 ),
helpstring( "IWMReaderAdvanced3 Interface" ),
pointer_default(unique),
local
]
//
// The reader can be QI'ed for this interface for frame access functionaly.
//
interface IWMReaderAdvanced3 : IWMReaderAdvanced2
{
//
// This method is used when you want to stop net streaming right away but
// continue to receive samples that SDK have gotten so far.
//
// If it's successful, user should receive an END_OF_STREAMING quickly.
//
HRESULT StopNetStreaming( );
//
// This method is for frame based accessing, start with SMPTE time stamp etc.
// It is not supported in current version, we'll start to support this from v9
//
HRESULT StartAtPosition( [in] WORD wStreamNum,
[in] void *pvOffsetStart,
[in] void *pvDuration,
[in] WMT_OFFSET_FORMAT dwOffsetFormat,
[in] float fRate,
[in] void *pvContext );
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 9F762FA7-A22E-428d-93C9-AC82F3AAFE5A ),
helpstring( "IWMReaderAllocatorEx Interface"),
pointer_default(unique),
local
]
interface IWMReaderAllocatorEx : IUnknown
{
HRESULT AllocateForStreamEx( [in] WORD wStreamNum,
[in] DWORD cbBuffer,
[out] INSSBuffer **ppBuffer,
[in] DWORD dwFlags,
[in] QWORD cnsSampleTime,
[in] QWORD cnsSampleDuration,
[in] void *pvContext );
HRESULT AllocateForOutputEx( [in] DWORD dwOutputNum,
[in] DWORD cbBuffer,
[out] INSSBuffer **ppBuffer,
[in] DWORD dwFlags,
[in] QWORD cnsSampleTime,
[in] QWORD cnsSampleDuration,
[in] void *pvContext );
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( FDBE5592-81A1-41ea-93BD-735CAD1ADC05 ),
helpstring( "IWMReaderTypeNegotiation Interface"),
pointer_default(unique),
local
]
interface IWMReaderTypeNegotiation : IUnknown
{
HRESULT TryOutputProps( [in] DWORD dwOutputNum,
[in] IWMOutputMediaProps *pOutput );
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 96406BEB-2B2B-11d3-B36B-00C04F6108FF ),
helpstring( "IWMReaderCallbackAdvanced Interface"),
pointer_default(unique),
local
]
//
// For some advanced functionality, the IWMReaderCallback must support this
// interface.
//
interface IWMReaderCallbackAdvanced : IUnknown
{
//
// Receive a sample directly from the ASF. To get this call, the user
// must register himself to receive samples for a particular stream.
//
HRESULT OnStreamSample( [in] WORD wStreamNum,
[in] QWORD cnsSampleTime,
[in] QWORD cnsSampleDuration,
[in] DWORD dwFlags,
[in] INSSBuffer *pSample,
[in] void *pvContext );
//
// In some cases, the user may want to get callbacks telling what the
// reader thinks the current time is. This is interesting in 2 cases:
// - If the ASF has gaps in it; say no audio for 10 seconds. This call
// will continue to be called, while OnSample won't be called.
// - If the user is driving the clock, the reader needs to communicate
// back to the user its time, to avoid the user overrunning the reader.
//
HRESULT OnTime( [in] QWORD cnsCurrentTime, [in] void *pvContext );
//
// The user can also get callbacks when stream selection occurs.
//
HRESULT OnStreamSelection( [in] WORD wStreamCount,
[in] WORD *pStreamNumbers,
[in] WMT_STREAM_SELECTION *pSelections,
[in] void *pvContext );
//
// Will be called if the user got an async result from their
// call to SetOutputProps. The next sample you receive for
// this output will have these properties. The contents of the
// media type after calling SetOutputProps and before receiving
// an OutputPropsChanged notification are undefined.
//
HRESULT OnOutputPropsChanged( [in] DWORD dwOutputNum,
[in] WM_MEDIA_TYPE *pMediaType,
[in] void *pvContext );
//
// If the user has registered to allocate buffers, this is where he must
// do it.
//
HRESULT AllocateForStream( [in] WORD wStreamNum,
[in] DWORD cbBuffer,
[out] INSSBuffer **ppBuffer,
[in] void *pvContext );
HRESULT AllocateForOutput( [in] DWORD dwOutputNum,
[in] DWORD cbBuffer,
[out] INSSBuffer **ppBuffer,
[in] void *pvContext );
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( D2827540-3EE7-432c-B14C-DC17F085D3B3 ),
helpstring( "IWMDRMReader Interface"),
pointer_default(unique),
local
]
//
// Used to access advanced DRM functionality.
//
interface IWMDRMReader : IUnknown
{
HRESULT AcquireLicense( [in] DWORD dwFlags );
HRESULT CancelLicenseAcquisition();
HRESULT Individualize( [in] DWORD dwFlags );
HRESULT CancelIndividualization();
HRESULT MonitorLicenseAcquisition();
HRESULT CancelMonitorLicenseAcquisition();
HRESULT SetDRMProperty( [in] LPCWSTR pwstrName,
[in] WMT_ATTR_DATATYPE dwType,
[in] const BYTE *pValue,
[in] WORD cbLength );
HRESULT GetDRMProperty( [in] LPCWSTR pwstrName,
[out] WMT_ATTR_DATATYPE* pdwType,
[out] BYTE *pValue,
[out] WORD *pcbLength );
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 96406BEC-2B2B-11d3-B36B-00C04F6108FF ),
helpstring( "IWMReaderNetworkConfig Interface"),
pointer_default(unique),
local
]
//
// Used to configure the network. This interface is implemented by
// the IWMReader object.
//
interface IWMReaderNetworkConfig : IUnknown
{
//
// Get and set the amount of time the network source will buffer
// data before rendering it.
//
HRESULT GetBufferingTime( [out] QWORD *pcnsBufferingTime );
HRESULT SetBufferingTime( [in] QWORD cnsBufferingTime );
//
// Returns the UDP port number ranges that will be used for receiving
// data. If no ranges are available, random UDP port numbers will be used.
//
HRESULT GetUDPPortRanges( [out] WM_PORT_NUMBER_RANGE *pRangeArray,
[in, out] DWORD *pcRanges );
//
// Sets the UDP port number ranges that can be used for receiving data.
// If no ranges are specified, random UDP port numbers will be used.
//
HRESULT SetUDPPortRanges( [in] WM_PORT_NUMBER_RANGE *pRangeArray,
[in] DWORD cRanges );
//
// Proxy settings: Manual proxy, Autodetect, UseBrowser (only for HTTP), or No Proxy.
//
HRESULT GetProxySettings( LPCWSTR pwszProtocol, WMT_PROXY_SETTINGS *pProxySetting );
HRESULT SetProxySettings( LPCWSTR pwszProtocol, WMT_PROXY_SETTINGS ProxySetting );
//
// The host to use as the proxy.
//
HRESULT GetProxyHostName( [in] LPCWSTR pwszProtocol, [out] WCHAR *pwszHostName, [in, out] DWORD *pcchHostName );
HRESULT SetProxyHostName( [in] LPCWSTR pwszProtocol, [in] LPCWSTR pwszHostName );
//
// The port to use as the proxy.
//
HRESULT GetProxyPort( [in] LPCWSTR pwszProtocol, [out] DWORD *pdwPort );
HRESULT SetProxyPort( [in] LPCWSTR pwszProtocol, [in] DWORD dwPort );
//
// Get and set the proxy exception list.
//
HRESULT GetProxyExceptionList( [in] LPCWSTR pwszProtocol, [out] WCHAR *pwszExceptionList, [in, out] DWORD *pcchExceptionList );
HRESULT SetProxyExceptionList( [in] LPCWSTR pwszProtocol, [in] LPCWSTR pwszExceptionList );
//
// Whether or not to bypass proxy for local hosts
//
HRESULT GetProxyBypassForLocal( [in] LPCWSTR pwszProtocol, [out] BOOL *pfBypassForLocal );
HRESULT SetProxyBypassForLocal( [in] LPCWSTR pwszProtocol, [in] BOOL fBypassForLocal );
//
// Whether to force a wpad discovery on the next run
//
HRESULT GetForceRerunAutoProxyDetection( [out] BOOL *pfForceRerunDetection );
HRESULT SetForceRerunAutoProxyDetection( [in] BOOL fForceRerunDetection );
//
// Whether or not to use multicast, http, tcp, or udp
//
HRESULT GetEnableMulticast( [out] BOOL *pfEnableMulticast );
HRESULT SetEnableMulticast( [in] BOOL fEnableMulticast );
HRESULT GetEnableHTTP( [out] BOOL *pfEnableHTTP );
HRESULT SetEnableHTTP( [in] BOOL fEnableHTTP );
HRESULT GetEnableUDP( [out] BOOL *pfEnableUDP );
HRESULT SetEnableUDP( [in] BOOL fEnableUDP );
HRESULT GetEnableTCP( [out] BOOL *pfEnableTCP );
HRESULT SetEnableTCP( [in] BOOL fEnableTCP );
//
// Forgets automatic protocol detection settings and redetects next time.
//
HRESULT ResetProtocolRollover( );
//
// Return or set the client's link bandwidth in bps. This is an optional
// setting. By default, the SDK will automatically detect its connection
// bandwidth to the streaming media server.
//
HRESULT GetConnectionBandwidth( [out] DWORD *pdwConnectionBandwidth );
HRESULT SetConnectionBandwidth( [in] DWORD dwConnectionBandwidth );
//
// Iterate through the network protocols supported by this reader
//
HRESULT GetNumProtocolsSupported( [out] DWORD *pcProtocols );
HRESULT GetSupportedProtocolName( [in] DWORD dwProtocolNum, [out] WCHAR *pwszProtocolName, [in, out] DWORD *pcchProtocolName);
//
// Adds the specified pszUrl to the list of URL's to recieve logging data.
// This list is in addition to the origin server.
//
HRESULT AddLoggingUrl( [in] LPCWSTR pwszUrl );
//
// Fills the buffer with the URL corresponding to index dwIndex.
//
HRESULT GetLoggingUrl( [in] DWORD dwIndex, [out] LPWSTR pwszUrl, [in, out] DWORD *pcchUrl );
//
// Returns the number of URLs in the current list of logging URLs.
//
HRESULT GetLoggingUrlCount( [out] DWORD *pdwUrlCount );
//
// Clears the list of logging URLs
//
HRESULT ResetLoggingUrlList( );
}
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 96406BED-2B2B-11d3-B36B-00C04F6108FF ),
helpstring( "IWMReaderStreamClock Interface"),
pointer_default(unique),
local
]
//
// Used to configure the network. This interface is implemented by
// the IWMReader object.
//
interface IWMReaderStreamClock : IUnknown
{
//
// Get the current value of the stream clock
//
HRESULT GetTime( [in] QWORD *pcnsNow );
//
// Set or kill a timer. All timers are automatically
// killed whenever you stop the Reader. When a timer
// expires, you'll receive a WMT_TIMER OnStatus callback
// with hr == S_OK, pValue = TimerId and pvContext == pvParam.
//
//
HRESULT SetTimer( [in] QWORD cnsWhen, [in]void *pvParam, [out] DWORD *pdwTimerId );
HRESULT KillTimer( [in] DWORD dwTimerId );
}
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 6d7cdc71-9888-11d3-8edc-00c04f6109cf ),
helpstring( "IWMIndexer Interface"),
pointer_default(unique),
local
]
interface IWMIndexer : IUnknown
{
//
// Start is an asynchronous call; it returns almost immediately and the user
// should wait for appropriate OnStatus calls to be sent to the callback.
//
HRESULT StartIndexing( [in] const WCHAR *pwszURL,
[in] IWMStatusCallback *pCallback,
[in] void *pvContext );
HRESULT Cancel();
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 05E5AC9F-3FB6-4508-BB43-A4067BA1EBE8 ),
helpstring( "IWMLicenseBackup Interface"),
pointer_default(unique),
local
]
interface IWMLicenseBackup : IUnknown
{
HRESULT BackupLicenses( [in] DWORD dwFlags,
[in] IWMStatusCallback *pCallback );
HRESULT CancelLicenseBackup();
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( C70B6334-0544-4efb-A245-15E65A004A13 ),
helpstring( "IWMLicenseRestore Interface"),
pointer_default(unique),
local
]
interface IWMLicenseRestore : IUnknown
{
HRESULT RestoreLicenses( [in] DWORD dwFlags,
[in] IWMStatusCallback *pCallback );
HRESULT CancelLicenseRestore();
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( 3C8E0DA6-996F-4ff3-A1AF-4838F9377E2E ),
helpstring( "IWMBackupRestoreProps Interface"),
pointer_default(unique),
local
]
interface IWMBackupRestoreProps : IUnknown
{
HRESULT GetPropCount( [out] WORD *pcProps );
HRESULT GetPropByIndex( [in] WORD wIndex,
[out] WCHAR *pwszName,
[in,out] WORD *pcchNameLen,
[out] WMT_ATTR_DATATYPE *pType,
[out] BYTE *pValue,
[in,out] WORD *pcbLength );
HRESULT GetPropByName( [in] LPCWSTR pszName,
[out] WMT_ATTR_DATATYPE *pType,
[out] BYTE *pValue,
[in,out] WORD *pcbLength );
HRESULT SetProp( [in] LPCWSTR pszName,
[in] WMT_ATTR_DATATYPE Type,
[in] const BYTE *pValue,
[in] WORD cbLength );
HRESULT RemoveProp( [in] LPCWSTR pcwszName );
HRESULT RemoveAllProps();
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( A970F41E-34DE-4a98-B3BA-E4B3CA7528F0 ),
helpstring( "IWMCodecInfo Interface"),
pointer_default(unique),
local
]
interface IWMCodecInfo : IUnknown
{
HRESULT GetCodecInfoCount( [in] REFGUID guidType,
[out] DWORD *pcCodecs );
HRESULT GetCodecFormatCount( [in] REFGUID guidType,
[in] DWORD dwCodecIndex,
[out] DWORD *pcFormat );
HRESULT GetCodecFormat( [in] REFGUID guidType,
[in] DWORD dwCodecIndex,
[in] DWORD dwFormatIndex,
[out] IWMStreamConfig **ppIStreamConfig );
};
///////////////////////////////////////////////////////////////////////////////
[
object,
uuid( AA65E273-B686-4056-91EC-DD768D4DF710 ),
helpstring( "IWMCodecInfo2 Interface"),
pointer_default(unique),
local
]
interface IWMCodecInfo2 : IWMCodecInfo
{
HRESULT GetCodecName( [in] REFGUID guidType,
[in] DWORD dwCodecIndex,
[out] WCHAR *wszName,
[out] DWORD *pcchName );
HRESULT GetCodecFormatDesc( [in] REFGUID guidType,
[in] DWORD dwCodecIndex,
[in] DWORD dwFormatIndex,
[out] IWMStreamConfig **ppIStreamConfig,
[out] WCHAR *wszDesc,
[in, out] DWORD *pcchDesc );
};
Reference in a new issue Copy permalink