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