//============================================================================ // // 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 IWMMediaProps 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 ); };