Delphi控件源码

开发平台：

Delphi

WMF9.pas：源码内容

(*********************************************************************
* Windows Media Format 9 API *
* *
* home page : http://www.progdigy.com *
* email : hgourvest@progdigy.com *
* *
* date : 21-02-2003 *
* *
* The contents of this file are used with permission, subject to *
* the Mozilla Public License Version 1.1 (the "License"); you may *
* not use this file except in compliance with the License. You may *
* obtain a copy of the License at *
* http://www.mozilla.org/MPL/MPL-1.1.html *
* *
* wmsdkvalidate.h, wmdxva.idl, wmnetsourcecreator.idl, *
* wmsbuffer.idl, drmexternals.id, asferr.h, wmsysprf.h, *
* WMSInternalAdminNetSource.idl, wmsdkidl.idl, dshowasf.idl *
* *
* Software distributed under the License is distributed on an *
* "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or *
* implied. See the License for the specific language governing *
* rights and limitations under the License. *
* *
*********************************************************************)
unit WMF9;
interface
{$I DirectX.inc}
{$IFDEF DYNAMIC_LINK_ALL}
{$DEFINE WMF9_DYNAMIC_LINK}
{$ENDIF}
{$HPPEMIT '#include "asferr.h"'}
{$HPPEMIT '#include "drmexternals.h"'}
{$HPPEMIT '#include "dshowasf.h"'}
{$HPPEMIT '#include "nserror.h"'}
{$HPPEMIT '#include "wmdxva.h"'}
{$HPPEMIT '#include "wmnetsourcecreator.h"'}
{$HPPEMIT '#include "wmsbuffer.h"'}
{$HPPEMIT '#include "wmsdk.h"'}
{$HPPEMIT '#include "wmsdkidl.h"'}
{$HPPEMIT '#include "wmsdkvalidate.h"'}
{$HPPEMIT '#include "wmsinternaladminnetsource.h"'}
{$HPPEMIT '#include "wmsysprf.h"'}
uses Windows, ActiveX, DirectShow9;
//*@@@+++@@@@******************************************************************
//
// Microsoft Windows Media
//
//*@@@---@@@@******************************************************************
const
WMProfile_V40_DialUpMBR : TGUID = '{fd7f47f1-72a6-45a4-80f0-3aecefc32c07}';
{$EXTERNALSYM WMProfile_V40_DialUpMBR}
WMProfile_V40_IntranetMBR : TGUID = '{82cd3321-a94a-4ffc-9c2b-092c10ca16e7}';
{$EXTERNALSYM WMProfile_V40_IntranetMBR}
WMProfile_V40_2856100MBR : TGUID = '{5a1c2206-dc5e-4186-beb2-4c5a994b132e}';
{$EXTERNALSYM WMProfile_V40_2856100MBR}
WMProfile_V40_6VoiceAudio : TGUID = '{D508978A-11A0-4d15-B0DA-ACDC99D4F890}';
{$EXTERNALSYM WMProfile_V40_6VoiceAudio}
WMProfile_V40_16AMRadio : TGUID = '{0f4be81f-d57d-41e1-b2e3-2fad986bfec2}';
{$EXTERNALSYM WMProfile_V40_16AMRadio}
WMProfile_V40_288FMRadioMono : TGUID = '{7fa57fc8-6ea4-4645-8abf-b6e5a8f814a1}';
{$EXTERNALSYM WMProfile_V40_288FMRadioMono}
WMProfile_V40_288FMRadioStereo : TGUID = '{22fcf466-aa40-431f-a289-06d0ea1a1e40}';
{$EXTERNALSYM WMProfile_V40_288FMRadioStereo}
WMProfile_V40_56DialUpStereo : TGUID = '{e8026f87-e905-4594-a3c7-00d00041d1d9}';
{$EXTERNALSYM WMProfile_V40_56DialUpStereo}
WMProfile_V40_64Audio : TGUID = '{4820b3f7-cbec-41dc-9391-78598714c8e5}';
{$EXTERNALSYM WMProfile_V40_64Audio}
WMProfile_V40_96Audio : TGUID = '{0efa0ee3-9e64-41e2-837f-3c0038f327ba}';
{$EXTERNALSYM WMProfile_V40_96Audio}
WMProfile_V40_128Audio : TGUID = '{93ddbe12-13dc-4e32-a35e-40378e34279a}';
{$EXTERNALSYM WMProfile_V40_128Audio}
WMProfile_V40_288VideoVoice : TGUID = '{bb2bc274-0eb6-4da9-b550-ecf7f2b9948f}';
{$EXTERNALSYM WMProfile_V40_288VideoVoice}
WMProfile_V40_288VideoAudio : TGUID = '{ac617f2d-6cbe-4e84-8e9a-ce151a12a354}';
{$EXTERNALSYM WMProfile_V40_288VideoAudio}
WMProfile_V40_288VideoWebServer : TGUID = '{abf2f00d-d555-4815-94ce-8275f3a70bfe}';
{$EXTERNALSYM WMProfile_V40_288VideoWebServer}
WMProfile_V40_56DialUpVideo : TGUID = '{e21713bb-652f-4dab-99de-71e04400270f}';
{$EXTERNALSYM WMProfile_V40_56DialUpVideo}
WMProfile_V40_56DialUpVideoWebServer : TGUID = '{b756ff10-520f-4749-a399-b780e2fc9250}';
{$EXTERNALSYM WMProfile_V40_56DialUpVideoWebServer}
WMProfile_V40_100Video : TGUID = '{8f99ddd8-6684-456b-a0a3-33e1316895f0}';
{$EXTERNALSYM WMProfile_V40_100Video}
WMProfile_V40_250Video : TGUID = '{541841c3-9339-4f7b-9a22-b11540894e42}';
{$EXTERNALSYM WMProfile_V40_250Video}
WMProfile_V40_512Video : TGUID = '{70440e6d-c4ef-4f84-8cd0-d5c28686e784}';
{$EXTERNALSYM WMProfile_V40_512Video}
WMProfile_V40_1MBVideo : TGUID = '{b4482a4c-cc17-4b07-a94e-9818d5e0f13f}';
{$EXTERNALSYM WMProfile_V40_1MBVideo}
WMProfile_V40_3MBVideo : TGUID = '{55374ac0-309b-4396-b88f-e6e292113f28}';
{$EXTERNALSYM WMProfile_V40_3MBVideo}
WMProfile_V70_DialUpMBR : TGUID = '{5B16E74B-4068-45b5-B80E-7BF8C80D2C2F}';
{$EXTERNALSYM WMProfile_V70_DialUpMBR}
WMProfile_V70_IntranetMBR : TGUID = '{045880DC-34B6-4ca9-A326-73557ED143F3}';
{$EXTERNALSYM WMProfile_V70_IntranetMBR}
WMProfile_V70_2856100MBR : TGUID = '{07DF7A25-3FE2-4a5b-8B1E-348B0721CA70}';
{$EXTERNALSYM WMProfile_V70_2856100MBR}
WMProfile_V70_288VideoVoice : TGUID = '{B952F38E-7DBC-4533-A9CA-B00B1C6E9800}';
{$EXTERNALSYM WMProfile_V70_288VideoVoice}
WMProfile_V70_288VideoAudio : TGUID = '{58BBA0EE-896A-4948-9953-85B736F83947}';
{$EXTERNALSYM WMProfile_V70_288VideoAudio}
WMProfile_V70_288VideoWebServer : TGUID = '{70A32E2B-E2DF-4ebd-9105-D9CA194A2D50}';
{$EXTERNALSYM WMProfile_V70_288VideoWebServer}
WMProfile_V70_56VideoWebServer : TGUID = '{DEF99E40-57BC-4ab3-B2D1-B6E3CAF64257}';
{$EXTERNALSYM WMProfile_V70_56VideoWebServer}
WMProfile_V70_64VideoISDN : TGUID = '{C2B7A7E9-7B8E-4992-A1A1-068217A3B311}';
{$EXTERNALSYM WMProfile_V70_64VideoISDN}
WMProfile_V70_100Video : TGUID = '{D9F3C932-5EA9-4c6d-89B4-2686E515426E}';
{$EXTERNALSYM WMProfile_V70_100Video}
WMProfile_V70_256Video : TGUID = '{AFE69B3A-403F-4a1b-8007-0E21CFB3DF84}';
{$EXTERNALSYM WMProfile_V70_256Video}
WMProfile_V70_384Video : TGUID = '{F3D45FBB-8782-44df-97C6-8678E2F9B13D}';
{$EXTERNALSYM WMProfile_V70_384Video}
WMProfile_V70_768Video : TGUID = '{0326EBB6-F76E-4964-B0DB-E729978D35EE}';
{$EXTERNALSYM WMProfile_V70_768Video}
WMProfile_V70_1500Video : TGUID = '{0B89164A-5490-4686-9E37-5A80884E5146}';
{$EXTERNALSYM WMProfile_V70_1500Video}
WMProfile_V70_2000Video : TGUID = '{AA980124-BF10-4e4f-9AFD-4329A7395CFF}';
{$EXTERNALSYM WMProfile_V70_2000Video}
WMProfile_V70_700FilmContentVideo : TGUID = '{7A747920-2449-4d76-99CB-FDB0C90484D4}';
{$EXTERNALSYM WMProfile_V70_700FilmContentVideo}
WMProfile_V70_1500FilmContentVideo : TGUID = '{F6A5F6DF-EE3F-434c-A433-523CE55F516B}';
{$EXTERNALSYM WMProfile_V70_1500FilmContentVideo}
WMProfile_V70_6VoiceAudio : TGUID = '{EABA9FBF-B64F-49b3-AA0C-73FBDD150AD0}';
{$EXTERNALSYM WMProfile_V70_6VoiceAudio}
WMProfile_V70_288FMRadioMono : TGUID = '{C012A833-A03B-44a5-96DC-ED95CC65582D}';
{$EXTERNALSYM WMProfile_V70_288FMRadioMono}
WMProfile_V70_288FMRadioStereo : TGUID = '{E96D67C9-1A39-4dc4-B900-B1184DC83620}';
{$EXTERNALSYM WMProfile_V70_288FMRadioStereo}
WMProfile_V70_56DialUpStereo : TGUID = '{674EE767-0949-4fac-875E-F4C9C292013B}';
{$EXTERNALSYM WMProfile_V70_56DialUpStereo}
WMProfile_V70_64AudioISDN : TGUID = '{91DEA458-9D60-4212-9C59-D40919C939E4}';
{$EXTERNALSYM WMProfile_V70_64AudioISDN}
WMProfile_V70_64Audio : TGUID = '{B29CFFC6-F131-41db-B5E8-99D8B0B945F4}';
{$EXTERNALSYM WMProfile_V70_64Audio}
WMProfile_V70_96Audio : TGUID = '{A9D4B819-16CC-4a59-9F37-693DBB0302D6}';
{$EXTERNALSYM WMProfile_V70_96Audio}
WMProfile_V70_128Audio : TGUID = '{C64CF5DA-DF45-40d3-8027-DE698D68DC66}';
{$EXTERNALSYM WMProfile_V70_128Audio}
WMProfile_V70_225VideoPDA : TGUID = '{F55EA573-4C02-42b5-9026-A8260C438A9F}';
{$EXTERNALSYM WMProfile_V70_225VideoPDA}
WMProfile_V70_150VideoPDA : TGUID = '{0F472967-E3C6-4797-9694-F0304C5E2F17}';
{$EXTERNALSYM WMProfile_V70_150VideoPDA}
WMProfile_V80_255VideoPDA : TGUID = '{FEEDBCDF-3FAC-4c93-AC0D-47941EC72C0B}';
{$EXTERNALSYM WMProfile_V80_255VideoPDA}
WMProfile_V80_150VideoPDA : TGUID = '{AEE16DFA-2C14-4a2f-AD3F-A3034031784F}';
{$EXTERNALSYM WMProfile_V80_150VideoPDA}
WMProfile_V80_28856VideoMBR : TGUID = '{D66920C4-C21F-4ec8-A0B4-95CF2BD57FC4}';
{$EXTERNALSYM WMProfile_V80_28856VideoMBR}
WMProfile_V80_100768VideoMBR : TGUID = '{5BDB5A0E-979E-47d3-9596-73B386392A55}';
{$EXTERNALSYM WMProfile_V80_100768VideoMBR}
WMProfile_V80_288100VideoMBR : TGUID = '{D8722C69-2419-4b36-B4E0-6E17B60564E5}';
{$EXTERNALSYM WMProfile_V80_288100VideoMBR}
WMProfile_V80_288Video : TGUID = '{3DF678D9-1352-4186-BBF8-74F0C19B6AE2}';
{$EXTERNALSYM WMProfile_V80_288Video}
WMProfile_V80_56Video : TGUID = '{254E8A96-2612-405c-8039-F0BF725CED7D}';
{$EXTERNALSYM WMProfile_V80_56Video}
WMProfile_V80_100Video : TGUID = '{A2E300B4-C2D4-4fc0-B5DD-ECBD948DC0DF}';
{$EXTERNALSYM WMProfile_V80_100Video}
WMProfile_V80_256Video : TGUID = '{BBC75500-33D2-4466-B86B-122B201CC9AE}';
{$EXTERNALSYM WMProfile_V80_256Video}
WMProfile_V80_384Video : TGUID = '{29B00C2B-09A9-48bd-AD09-CDAE117D1DA7}';
{$EXTERNALSYM WMProfile_V80_384Video}
WMProfile_V80_768Video : TGUID = '{74D01102-E71A-4820-8F0D-13D2EC1E4872}';
{$EXTERNALSYM WMProfile_V80_768Video}
WMProfile_V80_700NTSCVideo : TGUID = '{C8C2985F-E5D9-4538-9E23-9B21BF78F745}';
{$EXTERNALSYM WMProfile_V80_700NTSCVideo}
WMProfile_V80_1400NTSCVideo : TGUID = '{931D1BEE-617A-4bcd-9905-CCD0786683EE}';
{$EXTERNALSYM WMProfile_V80_1400NTSCVideo}
WMProfile_V80_384PALVideo : TGUID = '{9227C692-AE62-4f72-A7EA-736062D0E21E}';
{$EXTERNALSYM WMProfile_V80_384PALVideo}
WMProfile_V80_700PALVideo : TGUID = '{EC298949-639B-45e2-96FD-4AB32D5919C2}';
{$EXTERNALSYM WMProfile_V80_700PALVideo}
WMProfile_V80_288MonoAudio : TGUID = '{7EA3126D-E1BA-4716-89AF-F65CEE0C0C67}';
{$EXTERNALSYM WMProfile_V80_288MonoAudio}
WMProfile_V80_288StereoAudio : TGUID = '{7E4CAB5C-35DC-45bb-A7C0-19B28070D0CC}';
{$EXTERNALSYM WMProfile_V80_288StereoAudio}
WMProfile_V80_32StereoAudio : TGUID = '{60907F9F-B352-47e5-B210-0EF1F47E9F9D}';
{$EXTERNALSYM WMProfile_V80_32StereoAudio}
WMProfile_V80_48StereoAudio : TGUID = '{5EE06BE5-492B-480a-8A8F-12F373ECF9D4}';
{$EXTERNALSYM WMProfile_V80_48StereoAudio}
WMProfile_V80_64StereoAudio : TGUID = '{09BB5BC4-3176-457f-8DD6-3CD919123E2D}';
{$EXTERNALSYM WMProfile_V80_64StereoAudio}
WMProfile_V80_96StereoAudio : TGUID = '{1FC81930-61F2-436f-9D33-349F2A1C0F10}';
{$EXTERNALSYM WMProfile_V80_96StereoAudio}
WMProfile_V80_128StereoAudio : TGUID = '{407B9450-8BDC-4ee5-88B8-6F527BD941F2}';
{$EXTERNALSYM WMProfile_V80_128StereoAudio}
WMProfile_V80_288VideoOnly : TGUID = '{8C45B4C7-4AEB-4f78-A5EC-88420B9DADEF}';
{$EXTERNALSYM WMProfile_V80_288VideoOnly}
WMProfile_V80_56VideoOnly : TGUID = '{6E2A6955-81DF-4943-BA50-68A986A708F6}';
{$EXTERNALSYM WMProfile_V80_56VideoOnly}
WMProfile_V80_FAIRVBRVideo : TGUID = '{3510A862-5850-4886-835F-D78EC6A64042}';
{$EXTERNALSYM WMProfile_V80_FAIRVBRVideo}
WMProfile_V80_HIGHVBRVideo : TGUID = '{0F10D9D3-3B04-4fb0-A3D3-88D4AC854ACC}';
{$EXTERNALSYM WMProfile_V80_HIGHVBRVideo}
WMProfile_V80_BESTVBRVideo : TGUID = '{048439BA-309C-440e-9CB4-3DCCA3756423}';
{$EXTERNALSYM WMProfile_V80_BESTVBRVideo}
//*@@@+++@@@@******************************************************************
//
// Microsoft Windows Media
//
//*@@@---@@@@******************************************************************
//
//import "mediaobj.idl";
//import "videoacc.idl"; // IAMVideoAccelerator
const
IID_IWMPlayerTimestampHook : TGUID = '{28580dda-d98e-48d0-b7ae-69e473a02825}';
{$EXTERNALSYM IID_IWMPlayerTimestampHook}
IID_IWMCodecVideoAccelerator : TGUID = '{990641b0-739f-4e94-a808-9888da8f75af}';
{$EXTERNALSYM IID_IWMCodecVideoAccelerator}
IID_IWMCodecAMVideoAccelerator : TGUID = '{d98ee251-34e0-4a2d-9312-9b4c788d9fa1}';
{$EXTERNALSYM IID_IWMCodecAMVideoAccelerator}
type
// Implemented by the player
{$HPPEMIT 'typedef System::DelphiInterface<IWMPlayerTimestampHook> _di_IWMPlayerTimestampHook;'}
{$EXTERNALSYM IWMPlayerTimestampHook}
IWMPlayerTimestampHook = interface(IUnknown)
['{28580dda-d98e-48d0-b7ae-69e473a02825}']
(*** IWMPlayerTimestampHook methods ***)
function MapTimestamp(rtIn: TReferenceTime;
out prtOut: TReferenceTime): HRESULT; stdcall;
end;
// Implemeted by video decoder DMOs for DXVA support
{$HPPEMIT 'typedef System::DelphiInterface<IWMCodecAMVideoAccelerator> _di_IWMCodecAMVideoAccelerator;'}
{$EXTERNALSYM IWMCodecAMVideoAccelerator}
IWMCodecAMVideoAccelerator = interface(IUnknown)
['{d98ee251-34e0-4a2d-9312-9b4c788d9fa1}']
(*** IWMCodecAMVideoAccelerator methods ***)
function SetAcceleratorInterface(pIAMVA: IAMVideoAccelerator): HRESULT; stdcall;
function NegotiateConnection(pMediaType: PDMOMediaType ): HRESULT; stdcall;
function SetPlayerNotify(pHook: IWMPlayerTimestampHook): HRESULT; stdcall;
end;
// Outdated version of IWMCodecAMVideoAccelerator
{$HPPEMIT 'typedef System::DelphiInterface<IWMCodecVideoAccelerator> _di_IWMCodecVideoAccelerator;'}
{$EXTERNALSYM IWMCodecVideoAccelerator}
IWMCodecVideoAccelerator = interface(IUnknown)
['{990641b0-739f-4e94-a808-9888da8f75af}']
(*** IWMCodecVideoAccelerator methods ***)
function NegotiateConnection(pIAMVA: IAMVideoAccelerator;
pMediaType: PDMOMediaType): HRESULT;
function SetPlayerNotify(pHook: IWMPlayerTimestampHook): HRESULT;
end;
//*****************************************************************************
//
// Microsoft Windows Media
//
// FileName: WMNetSourceCreator.idl
//
// Abstract:
//
//*****************************************************************************
const
CLSID_ClientNetManager : TGUID = '{CD12A3CE-9C42-11D2-BEED-0060082F2054}';
{$EXTERNALSYM CLSID_ClientNetManager}
IID_INSNetSourceCreator : TGUID = '{0C0E4080-9081-11d2-BEEC-0060082F2054}';
{$EXTERNALSYM IID_INSNetSourceCreator}
//////////////////////////////////////////////////////////////////////////////
//
// Interface for creating a NetSource plugin.
//
type
{$HPPEMIT 'typedef System::DelphiInterface<INSNetSourceCreator> _di_INSNetSourceCreator;'}
{$EXTERNALSYM INSNetSourceCreator}
INSNetSourceCreator = interface(IUnknown)
['{0C0E4080-9081-11d2-BEEC-0060082F2054}']
(*** INSNetSourceCreator methods ***)
function Initialize: HRESULT; stdcall;
//
// This method is called to create an instance of the a particular
// Network Source plugin
//
function CreateNetSource(pszStreamName: PWideChar; pMonitor: IUnknown;
pData: PBYTE; pUserContext, pCallback: IUnknown; qwContext: Int64): HRESULT; stdcall;
//
// This method returns the namespace node for the properties of the
// the Network Source plugin that would be used given the
// provided stream name.
//
function GetNetSourceProperties(pszStreamName: PWideChar;
out ppPropertiesNode: IUnknown): HRESULT; stdcall;
//
// Returns part of the Namespace that is used for values that are
// shared among all Network Source plugins
//
function GetNetSourceSharedNamespace(out ppSharedNamespace: IUnknown): HRESULT; stdcall;
function GetNetSourceAdminInterface(pszStreamName: PWideChar;
out pVal: OLEVARIANT): HRESULT; stdcall;
//
// Iterate through the network protocols supported
//
function GetNumProtocolsSupported(out pcProtocols: LongWord): HRESULT; stdcall;
function GetProtocolName(dwProtocolNum: LongWord; {out} pwszProtocolName: PWideChar;
var pcchProtocolName: Word): HRESULT; stdcall;
function Shutdown: HRESULT; stdcall;
end;
//*@@@+++@@@@******************************************************************
//
// Microsoft Windows Media
//
//*@@@---@@@@******************************************************************
const
IID_INSSBuffer : TGUID = '{E1CD3524-03D7-11d2-9EED-006097D2D7CF}';
{$EXTERNALSYM IID_INSSBuffer}
IID_IWMSBuffer : TGUID = '{E1CD3524-03D7-11d2-9EED-006097D2D7CF}';
{$EXTERNALSYM IID_IWMSBuffer}
IID_INSSBuffer2 : TGUID = '{4f528693-1035-43fe-b428-757561ad3a68}';
{$EXTERNALSYM IID_INSSBuffer2}
IID_INSSBuffer3 : TGUID = '{c87ceaaf-75be-4bc4-84eb-ac2798507672}';
{$EXTERNALSYM IID_INSSBuffer3}
IID_INSSBuffer4 : TGUID = '{b6b8fd5a-32e2-49d4-a910-c26cc85465ed}';
{$EXTERNALSYM IID_INSSBuffer4}
IID_IWMSBufferAllocator : TGUID = '{61103CA4-2033-11d2-9EF1-006097D2D7CF}';
{$EXTERNALSYM IID_IWMSBufferAllocator}
type
{$HPPEMIT 'typedef System::DelphiInterface<INSSBuffer> _di_INSSBuffer;'}
{$EXTERNALSYM INSSBuffer}
INSSBuffer = interface(IUnknown)
['{E1CD3524-03D7-11d2-9EED-006097D2D7CF}']
(*** INSSBuffer methods ***)
function GetLength(out pdwLength: LongWord): HRESULT; stdcall;
function SetLength(dwLength: LongWord): HRESULT; stdcall;
function GetMaxLength(out pdwLength: LongWord): HRESULT; stdcall;
function GetBuffer(out ppdwBuffer: PBYTE): HRESULT; stdcall;
function GetBufferAndLength(out ppdwBuffer: PBYTE; out pdwLength: LongWord): HRESULT; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<INSSBuffer2> _di_INSSBuffer2;'}
{$EXTERNALSYM INSSBuffer2}
INSSBuffer2 = interface(INSSBuffer)
['{4F528693-1035-43fe-B428-757561AD3A68}']
(*** INSSBuffer2 methods ***)
function GetSampleProperties(cbProperties: LongWord; {out} pbProperties: PBYTE): HRESULT; stdcall;
function SetSampleProperties(cbProperties: LongWord; pbProperties: PBYTE): HRESULT; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<INSSBuffer3> _di_INSSBuffer3;'}
{$EXTERNALSYM INSSBuffer3}
INSSBuffer3 = interface(INSSBuffer2)
['{C87CEAAF-75BE-4bc4-84EB-AC2798507672}']
(*** INSSBuffer3 methods ***)
function SetProperty(guidBufferProperty: TGUID; pvBufferProperty: Pointer;
dwBufferPropertySize: LongWord): HRESULT; stdcall;
function GetProperty(guidBufferProperty: TGUID; {out} pvBufferProperty: Pointer;
var pdwBufferPropertySize: LongWord): HRESULT; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<INSSBuffer4> _di_INSSBuffer4;'}
{$EXTERNALSYM INSSBuffer4}
INSSBuffer4 = interface(INSSBuffer3)
['{B6B8FD5A-32E2-49d4-A910-C26CC85465ED}']
(*** INSSBuffer4 methods ***)
function GetPropertyCount(out pcBufferProperties: LongWord): HRESULT; stdcall;
function GetPropertyByIndex(dwBufferPropertyIndex: LongWord;
out pguidBufferProperty: TGUID; pvBufferProperty: pointer;
var pdwBufferPropertySize: LongWord): HRESULT; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMSBufferAllocator> _di_IWMSBufferAllocator;'}
{$EXTERNALSYM IWMSBufferAllocator}
IWMSBufferAllocator = interface(IUnknown)
['{61103CA4-2033-11d2-9EF1-006097D2D7CF}']
(*** IWMSBufferAllocator methods ***)
function AllocateBuffer(dwMaxBufferSize: LongWord; out ppBuffer: INSSBuffer): HRESULT; stdcall;
function AllocatePageSizeBuffer(dwMaxBufferSize: LongWord; out ppBuffer: INSSBuffer): HRESULT; stdcall;
end;
//*@@@+++@@@@******************************************************************
//
// Microsoft Windows Media
//
//*@@@---@@@@******************************************************************
//
// The following is a partial list of DRM actions that are of interest to applications
const
g_wszWMDRM_RIGHT_PLAYBACK = WideString('Play');
{$EXTERNALSYM g_wszWMDRM_RIGHT_PLAYBACK}
g_wszWMDRM_RIGHT_COPY_TO_CD = WideString('Print.redbook');
{$EXTERNALSYM g_wszWMDRM_RIGHT_COPY_TO_CD}
g_wszWMDRM_RIGHT_COPY_TO_SDMI_DEVICE = WideString('Transfer.SDMI');
{$EXTERNALSYM g_wszWMDRM_RIGHT_COPY_TO_SDMI_DEVICE}
g_wszWMDRM_RIGHT_COPY_TO_NON_SDMI_DEVICE = WideString('Transfer.NONSDMI');
{$EXTERNALSYM g_wszWMDRM_RIGHT_COPY_TO_NON_SDMI_DEVICE}
g_wszWMDRM_RIGHT_BACKUP = WideString('Backup');
{$EXTERNALSYM g_wszWMDRM_RIGHT_BACKUP}
g_wszWMDRM_IsDRM = WideString('IsDRM');
{$EXTERNALSYM g_wszWMDRM_IsDRM}
g_wszWMDRM_IsDRMCached = WideString('IsDRMCached');
{$EXTERNALSYM g_wszWMDRM_IsDRMCached}
g_wszWMDRM_BaseLicenseAcqURL = WideString('BaseLAURL');
{$EXTERNALSYM g_wszWMDRM_BaseLicenseAcqURL}
g_wszWMDRM_Rights = WideString('Rights');
{$EXTERNALSYM g_wszWMDRM_Rights}
g_wszWMDRM_LicenseID = WideString('LID');
{$EXTERNALSYM g_wszWMDRM_LicenseID}
g_wszWMDRM_ActionAllowed = WideString('ActionAllowed.');
{$EXTERNALSYM g_wszWMDRM_ActionAllowed}
g_wszWMDRM_ActionAllowed_Playback = WideString('ActionAllowed.Play');
{$EXTERNALSYM g_wszWMDRM_ActionAllowed_Playback}
g_wszWMDRM_ActionAllowed_CopyToCD = WideString('ActionAllowed.Print.redbook');
{$EXTERNALSYM g_wszWMDRM_ActionAllowed_CopyToCD}
g_wszWMDRM_ActionAllowed_CopyToSDMIDevice = WideString('ActionAllowed.Transfer.SDMI');
{$EXTERNALSYM g_wszWMDRM_ActionAllowed_CopyToSDMIDevice}
g_wszWMDRM_ActionAllowed_CopyToNonSDMIDevice = WideString('ActionAllowed.Transfer.NONSDMI');
{$EXTERNALSYM g_wszWMDRM_ActionAllowed_CopyToNonSDMIDevice}
g_wszWMDRM_ActionAllowed_Backup = WideString('ActionAllowed.Backup');
{$EXTERNALSYM g_wszWMDRM_ActionAllowed_Backup}
g_wszWMDRM_LicenseState = WideString('LicenseStateData.');
{$EXTERNALSYM g_wszWMDRM_LicenseState}
g_wszWMDRM_LicenseState_Playback = WideString('LicenseStateData.Play');
{$EXTERNALSYM g_wszWMDRM_LicenseState_Playback}
g_wszWMDRM_LicenseState_CopyToCD = WideString('LicenseStateData.Print.redbook');
{$EXTERNALSYM g_wszWMDRM_LicenseState_CopyToCD}
g_wszWMDRM_LicenseState_CopyToSDMIDevice = WideString('LicenseStateData.Transfer.SDMI');
{$EXTERNALSYM g_wszWMDRM_LicenseState_CopyToSDMIDevice}
g_wszWMDRM_LicenseState_CopyToNonSDMIDevice = WideString('LicenseStateData.Transfer.NONSDMI');
{$EXTERNALSYM g_wszWMDRM_LicenseState_CopyToNonSDMIDevice}
g_wszWMDRM_DRMHeader = WideString('DRMHeader.');
{$EXTERNALSYM g_wszWMDRM_DRMHeader}
g_wszWMDRM_DRMHeader_KeyID = WideString('DRMHeader.KID');
{$EXTERNALSYM g_wszWMDRM_DRMHeader_KeyID}
g_wszWMDRM_DRMHeader_LicenseAcqURL = WideString('DRMHeader.LAINFO');
{$EXTERNALSYM g_wszWMDRM_DRMHeader_LicenseAcqURL}
g_wszWMDRM_DRMHeader_ContentID = WideString('DRMHeader.CID');
{$EXTERNALSYM g_wszWMDRM_DRMHeader_ContentID}
g_wszWMDRM_DRMHeader_IndividualizedVersion = WideString('DRMHeader.SECURITYVERSION');
{$EXTERNALSYM g_wszWMDRM_DRMHeader_IndividualizedVersion}
g_wszWMDRM_DRMHeader_ContentDistributor = WideString('DRMHeader.ContentDistributor');
{$EXTERNALSYM g_wszWMDRM_DRMHeader_ContentDistributor}
g_wszWMDRM_DRMHeader_SubscriptionContentID = WideString('DRMHeader.SubscriptionContentID');
{$EXTERNALSYM g_wszWMDRM_DRMHeader_SubscriptionContentID}
// This enum indicates the category for each possible output string to be displayed.
// 0 - Playback not permitted.
// 1 - Playback unlimited.
// 2 - Playback valid 5 times.
// 3 - Playback valid from 7/12/00.
// 4 - Playback valid until 7/12/00.
// 5 - Playback valid from 5/12 to 9/12.
// 6 - Playback valid 5 times from 7/12/00.
// 7 - Playback valid 5 times until 7/12/00.
// 8 - Playback valid 5 times from 5/12 to 9/12.
// 9 - Playback valid for 24 hours from first use.
type
DRM_LICENSE_STATE_CATEGORY = (
WM_DRM_LICENSE_STATE_NORIGHT,
WM_DRM_LICENSE_STATE_UNLIM,
WM_DRM_LICENSE_STATE_COUNT,
WM_DRM_LICENSE_STATE_FROM,
WM_DRM_LICENSE_STATE_UNTIL,
WM_DRM_LICENSE_STATE_FROM_UNTIL,
WM_DRM_LICENSE_STATE_COUNT_FROM,
WM_DRM_LICENSE_STATE_COUNT_UNTIL,
WM_DRM_LICENSE_STATE_COUNT_FROM_UNTIL,
WM_DRM_LICENSE_STATE_EXPIRATION_AFTER_FIRSTUSE
);
{$EXTERNALSYM DRM_LICENSE_STATE_CATEGORY}
TDRMLicenseStateCategory = DRM_LICENSE_STATE_CATEGORY;
PDRMLicenseStateData = ^TDRMLicenseStateData;
_DRM_LICENSE_STATE_DATA = packed record
dwStreamId : LongWord; // 0 -> All streams, != 0 -> A particular stream.
dwCategory : TDRMLicenseStateCategory; // Indicates the category of string to be displayed.
dwNumCounts : LongWord; // Number of items supplied in dwCount.
dwCount : array[0..3] of LongWord; // Up to 4 counts.
dwNumDates : LongWord; // Number of items supplied in dwDate.
datetime : array [0..3] of FILETIME; // Up to 4 dates.
dwVague : LongWord; // 0 -> certain, 1 -> atleast. (There could be more
// licenses. Aggregation not possible.)
end;
{$EXTERNALSYM _DRM_LICENSE_STATE_DATA}
DRM_LICENSE_STATE_DATA = _DRM_LICENSE_STATE_DATA;
{$EXTERNALSYM DRM_LICENSE_STATE_DATA}
TDRMLicenseStateData = _DRM_LICENSE_STATE_DATA;
DRM_HTTP_STATUS = (
HTTP_NOTINITIATED,
HTTP_CONNECTING,
HTTP_REQUESTING,
HTTP_RECEIVING,
HTTP_COMPLETED
);
{$EXTERNALSYM DRM_HTTP_STATUS}
TDRMHTTPStatus = DRM_HTTP_STATUS;
// The various states individualization can be in:
{$IFNDEF COMPILER6_UP}
DRM_INDIVIDUALIZATION_STATUS = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord;
const
INDI_UNDEFINED = $00;
{$EXTERNALSYM INDI_UNDEFINED}
INDI_BEGIN = $01;
{$EXTERNALSYM INDI_BEGIN}
INDI_SUCCEED = $02;
{$EXTERNALSYM INDI_SUCCEED}
INDI_FAIL = $04;
{$EXTERNALSYM INDI_FAIL}
INDI_CANCEL = $08;
{$EXTERNALSYM INDI_CANCEL}
INDI_DOWNLOAD = $10;
{$EXTERNALSYM INDI_DOWNLOAD}
INDI_INSTALL = $20;
{$EXTERNALSYM INDI_INSTALL}
{$ELSE}
type
DRM_INDIVIDUALIZATION_STATUS = (
INDI_UNDEFINED = $00,
INDI_BEGIN = $01,
INDI_SUCCEED = $02,
INDI_FAIL = $04,
INDI_CANCEL = $08,
INDI_DOWNLOAD = $10,
INDI_INSTALL = $20
);
{$ENDIF}
type
{$EXTERNALSYM DRM_INDIVIDUALIZATION_STATUS}
TDRMIndividualizationStatus = DRM_INDIVIDUALIZATION_STATUS;
type
PWMIndividualizeStatus = ^TWMIndividualizeStatus;
_WMIndividualizeStatus = packed record
hr : HRESULT;
enIndiStatus : TDRMIndividualizationStatus;
pszIndiRespUrl : PChar;
dwHTTPRequest : LongWord;
enHTTPStatus : TDRMHTTPStatus;
dwHTTPReadProgress : LongWord;
dwHTTPReadTotal : LongWord;
end;
{$EXTERNALSYM _WMIndividualizeStatus}
WM_INDIVIDUALIZE_STATUS = _WMIndividualizeStatus;
{$EXTERNALSYM WM_INDIVIDUALIZE_STATUS}
TWMIndividualizeStatus = _WMIndividualizeStatus;
PWMGetLicenseData = ^TWMGetLicenseData;
_WMGetLicenseData = packed record
dwSize : LongWord;
hr : HRESULT;
wszURL : PWideChar;
wszLocalFilename : PWideChar;
pbPostData : PBYTE;
dwPostDataSize : LongWord;
end;
{$EXTERNALSYM _WMGetLicenseData}
WM_GET_LICENSE_DATA = _WMGetLicenseData;
{$EXTERNALSYM WM_GET_LICENSE_DATA}
TWMGetLicenseData = _WMGetLicenseData;
//*****************************************************************************
//
// Microsoft Windows Media
//
// FileName: WMSInternalAdminNetSource.idl
//
// Abstract:
//
//*****************************************************************************
const
IID_IWMSInternalAdminNetSource : TGUID = '{8BB23E5F-D127-4afb-8D02-AE5B66D54C78}';
{$EXTERNALSYM IID_IWMSInternalAdminNetSource}
IID_IWMSInternalAdminNetSource2 : TGUID = '{E74D58C3-CF77-4b51-AF17-744687C43EAE}';
{$EXTERNALSYM IID_IWMSInternalAdminNetSource2}
IID_IWMSInternalAdminNetSource3 : TGUID = '{6b63d08e-4590-44af-9eb3-57ff1e73bf80}';
{$EXTERNALSYM IID_IWMSInternalAdminNetSource3}
type
NETSOURCE_URLCREDPOLICY_SETTINGS = (
NETSOURCE_URLCREDPOLICY_SETTING_SILENTLOGONOK,
NETSOURCE_URLCREDPOLICY_SETTING_MUSTPROMPTUSER,
NETSOURCE_URLCREDPOLICY_SETTING_ANONYMOUSONLY
);
{$EXTERNALSYM NETSOURCE_URLCREDPOLICY_SETTINGS}
TNetSourceURLCredpolicySettings = NETSOURCE_URLCREDPOLICY_SETTINGS;
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// This interface is used by WMP 7 and MPXP
//
{$HPPEMIT 'typedef System::DelphiInterface<IWMSInternalAdminNetSource> _di_IWMSInternalAdminNetSource;'}
{$EXTERNALSYM IWMSInternalAdminNetSource}
IWMSInternalAdminNetSource = interface(IUnknown)
['{8BB23E5F-D127-4afb-8D02-AE5B66D54C78}']
(*** IWMSInternalAdminNetSource methods ***)
function Initialize(pSharedNamespace,
pNamespaceNode: IUnknown;
pNetSourceCreator: INSNetSourceCreator;
fEmbeddedInServer: BOOL): HRESULT; stdcall;
function GetNetSourceCreator(out ppNetSourceCreator: INSNetSourceCreator): HRESULT; stdcall;
// Authentication
function SetCredentials(bstrRealm, bstrName, bstrPassword: WideString; fPersist, fConfirmedGood: BOOL): HRESULT; stdcall;
function GetCredentials(bstrRealm: WideString; out pbstrName, pbstrPassword: WideString; out pfConfirmedGood: BOOL): HRESULT; stdcall;
function DeleteCredentials(bstrRealm: WideString): HRESULT; stdcall;
function GetCredentialFlags(out lpdwFlags: LongWord): HRESULT; stdcall;
function SetCredentialFlags(dwFlags: LongWord): HRESULT; stdcall;
// Proxy
function FindProxyForURL(bstrProtocol, bstrHost: WideString;
out pfProxyEnabled: BOOL;
out pbstrProxyServer: WideString;
out pdwProxyPort: LongWord;
var pdwProxyContext: LongWord): HRESULT; stdcall;
function RegisterProxyFailure(hrParam: HRESULT; dwProxyContext: LongWord): HRESULT; stdcall;
function ShutdownProxyContext(dwProxyContext: LongWord): HRESULT; stdcall;
function IsUsingIE(dwProxyContext: LongWord; out pfIsUsingIE: BOOL): HRESULT; stdcall;
end;
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// This interface is used by WMP 7 and MPXP
//
{$HPPEMIT 'typedef System::DelphiInterface<IWMSInternalAdminNetSource2> _di_IWMSInternalAdminNetSource2;'}
{$EXTERNALSYM IWMSInternalAdminNetSource2}
IWMSInternalAdminNetSource2 = interface(IUnknown)
['{E74D58C3-CF77-4b51-AF17-744687C43EAE}']
(*** IWMSInternalAdminNetSource2 methods ***)
// Authentication
function SetCredentialsEx(bstrRealm : WideString;
bstrUrl : WideString;
fProxy : BOOL;
bstrName : WideString;
bstrPassword : WideString;
fPersist : BOOL;
fConfirmedGood : BOOL): HRESULT; stdcall;
function GetCredentialsEx(bstrRealm : WideString;
bstrUrl : WideString;
fProxy : BOOL;
out pdwUrlPolicy : TNetSourceURLCredpolicySettings;
out pbstrName : WideString;
out pbstrPassword : WideString;
out pfConfirmedGood : BOOL): HRESULT; stdcall;
function DeleteCredentialsEx(bstrRealm, bstrUrl: WideString; fProxy: BOOL): HRESULT; stdcall;
function FindProxyForURLEx(bstrProtocol : WideString;
bstrHost : WideString;
bstrUrl : WideString;
out pfProxyEnabled : BOOL;
out pbstrProxyServer : WideString;
out pdwProxyPort : LongWord;
var pdwProxyContext : LongWord): HRESULT; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMSInternalAdminNetSource3> _di_IWMSInternalAdminNetSource3;'}
{$EXTERNALSYM IWMSInternalAdminNetSource3}
IWMSInternalAdminNetSource3 = interface(IWMSInternalAdminNetSource2)
['{6b63d08e-4590-44af-9eb3-57ff1e73bf80}']
(*** IWMSInternalAdminNetSource3 methods ***)
function GetNetSourceCreator2(out ppNetSourceCreator: IUnknown): HRESULT; stdcall;
// Proxy
function FindProxyForURLEx2(bstrProtocol : WideString;
bstrHost : WideString;
bstrUrl : WideString;
out pfProxyEnabled : BOOL;
out pbstrProxyServer : WideString;
out pdwProxyPort : LongWord;
var pqwProxyContext : Int64): HRESULT; stdcall;
function RegisterProxyFailure2(hrParam: HRESULT; qwProxyContext: Int64): HRESULT; stdcall;
function ShutdownProxyContext2(qwProxyContext: Int64): HRESULT; stdcall;
function IsUsingIE2(qwProxyContext: Int64; out pfIsUsingIE: BOOL): HRESULT; stdcall;
// Authentication
function SetCredentialsEx2(bstrRealm : WideString;
bstrUrl : WideString;
fProxy : BOOL;
bstrName : WideString;
bstrPassword : WideString;
fPersist : BOOL;
fConfirmedGood : BOOL;
fClearTextAuthentication : BOOL): HRESULT; stdcall;
function GetCredentialsEx2(bstrRealm : WideString;
bstrUrl : WideString;
fProxy : BOOL;
fClearTextAuthentication : BOOL;
out pdwUrlPolicy : TNetSourceURLCredpolicySettings;
out pbstrName : WideString;
out pbstrPassword : WideString;
out pfConfirmedGood : BOOL): HRESULT; stdcall;
end;
//*@@@+++@@@@******************************************************************
//
// Microsoft Windows Media
//
//*@@@---@@@@******************************************************************
//
///////////////////////////////////////////////////////////////////////////////
//
// Enumerations and constants used by the SDK.
//
///////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//
// Imports, typedefs and forward declarations
//
///////////////////////////////////////////////////////////////////////////////
//
// Attributes
//
///////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
//
// These are the special case attributes that give information
// about the Windows Media file.
//
const
g_dwWMSpecialAttributes = LongWord(20);
{$EXTERNALSYM g_dwWMSpecialAttributes}
g_wszWMDuration = WideString('Duration');
{$EXTERNALSYM g_wszWMDuration}
g_wszWMBitrate = WideString('Bitrate');
{$EXTERNALSYM g_wszWMBitrate}
g_wszWMSeekable = WideString('Seekable');
{$EXTERNALSYM g_wszWMSeekable}
g_wszWMStridable = WideString('Stridable');
{$EXTERNALSYM g_wszWMStridable}
g_wszWMBroadcast = WideString('Broadcast');
{$EXTERNALSYM g_wszWMBroadcast}
g_wszWMProtected = WideString('Is_Protected');
{$EXTERNALSYM g_wszWMProtected}
g_wszWMTrusted = WideString('Is_Trusted');
{$EXTERNALSYM g_wszWMTrusted}
g_wszWMSignature_Name = WideString('Signature_Name');
{$EXTERNALSYM g_wszWMSignature_Name}
g_wszWMHasAudio = WideString('HasAudio');
{$EXTERNALSYM g_wszWMHasAudio}
g_wszWMHasImage = WideString('HasImage');
{$EXTERNALSYM g_wszWMHasImage}
g_wszWMHasScript = WideString('HasScript');
{$EXTERNALSYM g_wszWMHasScript}
g_wszWMHasVideo = WideString('HasVideo');
{$EXTERNALSYM g_wszWMHasVideo}
g_wszWMCurrentBitrate = WideString('CurrentBitrate');
{$EXTERNALSYM g_wszWMCurrentBitrate}
g_wszWMOptimalBitrate = WideString('OptimalBitrate');
{$EXTERNALSYM g_wszWMOptimalBitrate}
g_wszWMHasAttachedImages = WideString('HasAttachedImages');
{$EXTERNALSYM g_wszWMHasAttachedImages}
g_wszWMSkipBackward = WideString('Can_Skip_Backward');
{$EXTERNALSYM g_wszWMSkipBackward}
g_wszWMSkipForward = WideString('Can_Skip_Forward');
{$EXTERNALSYM g_wszWMSkipForward}
g_wszWMNumberOfFrames = WideString('NumberOfFrames');
{$EXTERNALSYM g_wszWMNumberOfFrames}
g_wszWMFileSize = WideString('FileSize');
{$EXTERNALSYM g_wszWMFileSize}
g_wszWMHasArbitraryDataStream = WideString('HasArbitraryDataStream');
{$EXTERNALSYM g_wszWMHasArbitraryDataStream}
g_wszWMHasFileTransferStream = WideString('HasFileTransferStream');
{$EXTERNALSYM g_wszWMHasFileTransferStream}
g_wszWMContainerFormat = WideString('WM/ContainerFormat');
{$EXTERNALSYM g_wszWMContainerFormat}
////////////////////////////////////////////////////////////////
//
// The content description object supports 5 basic attributes.
//
g_dwWMContentAttributes = LongWord(5);
{$EXTERNALSYM g_dwWMContentAttributes}
g_wszWMTitle = WideString('Title');
{$EXTERNALSYM g_wszWMTitle}
g_wszWMAuthor = WideString('Author');
{$EXTERNALSYM g_wszWMAuthor}
g_wszWMDescription = WideString('Description');
{$EXTERNALSYM g_wszWMDescription}
g_wszWMRating = WideString('Rating');
{$EXTERNALSYM g_wszWMRating}
g_wszWMCopyright = WideString('Copyright');
{$EXTERNALSYM g_wszWMCopyright}
////////////////////////////////////////////////////////////////
//
// These attributes are used to configure and query DRM settings in the reader and writer.
//
g_wszWMUse_DRM = WideString('Use_DRM');
{$EXTERNALSYM g_wszWMUse_DRM}
g_wszWMDRM_Flags = WideString('DRM_Flags');
{$EXTERNALSYM g_wszWMDRM_Flags}
g_wszWMDRM_Level = WideString('DRM_Level');
{$EXTERNALSYM g_wszWMDRM_Level}
g_wszWMUse_Advanced_DRM = WideString('Use_Advanced_DRM');
{$EXTERNALSYM g_wszWMUse_Advanced_DRM}
g_wszWMDRM_KeySeed = WideString('DRM_KeySeed');
{$EXTERNALSYM g_wszWMDRM_KeySeed}
g_wszWMDRM_KeyID = WideString('DRM_KeyID');
{$EXTERNALSYM g_wszWMDRM_KeyID}
g_wszWMDRM_ContentID = WideString('DRM_ContentID');
{$EXTERNALSYM g_wszWMDRM_ContentID}
g_wszWMDRM_IndividualizedVersion = WideString('DRM_IndividualizedVersion');
{$EXTERNALSYM g_wszWMDRM_IndividualizedVersion}
g_wszWMDRM_LicenseAcqURL = WideString('DRM_LicenseAcqURL');
{$EXTERNALSYM g_wszWMDRM_LicenseAcqURL}
g_wszWMDRM_V1LicenseAcqURL = WideString('DRM_V1LicenseAcqURL');
{$EXTERNALSYM g_wszWMDRM_V1LicenseAcqURL}
g_wszWMDRM_HeaderSignPrivKey = WideString('DRM_HeaderSignPrivKey');
{$EXTERNALSYM g_wszWMDRM_HeaderSignPrivKey}
g_wszWMDRM_LASignaturePrivKey = WideString('DRM_LASignaturePrivKey');
{$EXTERNALSYM g_wszWMDRM_LASignaturePrivKey}
g_wszWMDRM_LASignatureCert = WideString('DRM_LASignatureCert');
{$EXTERNALSYM g_wszWMDRM_LASignatureCert}
g_wszWMDRM_LASignatureLicSrvCert = WideString('DRM_LASignatureLicSrvCert');
{$EXTERNALSYM g_wszWMDRM_LASignatureLicSrvCert}
g_wszWMDRM_LASignatureRootCert = WideString('DRM_LASignatureRootCert');
{$EXTERNALSYM g_wszWMDRM_LASignatureRootCert}
////////////////////////////////////////////////////////////////
//
// These are the additional attributes defined in the WM attribute
// namespace that give information about the content.
//
g_wszWMAlbumTitle = WideString('WM/AlbumTitle');
{$EXTERNALSYM g_wszWMAlbumTitle}
g_wszWMTrack = WideString('WM/Track');
{$EXTERNALSYM g_wszWMTrack}
g_wszWMPromotionURL = WideString('WM/PromotionURL');
{$EXTERNALSYM g_wszWMPromotionURL}
g_wszWMAlbumCoverURL = WideString('WM/AlbumCoverURL');
{$EXTERNALSYM g_wszWMAlbumCoverURL}
g_wszWMGenre = WideString('WM/Genre');
{$EXTERNALSYM g_wszWMGenre}
g_wszWMYear = WideString('WM/Year');
{$EXTERNALSYM g_wszWMYear}
g_wszWMGenreID = WideString('WM/GenreID');
{$EXTERNALSYM g_wszWMGenreID}
g_wszWMMCDI = WideString('WM/MCDI');
{$EXTERNALSYM g_wszWMMCDI}
g_wszWMComposer = WideString('WM/Composer');
{$EXTERNALSYM g_wszWMComposer}
g_wszWMLyrics = WideString('WM/Lyrics');
{$EXTERNALSYM g_wszWMLyrics}
g_wszWMTrackNumber = WideString('WM/TrackNumber');
{$EXTERNALSYM g_wszWMTrackNumber}
g_wszWMToolName = WideString('WM/ToolName');
{$EXTERNALSYM g_wszWMToolName}
g_wszWMToolVersion = WideString('WM/ToolVersion');
{$EXTERNALSYM g_wszWMToolVersion}
g_wszWMIsVBR = WideString('IsVBR');
{$EXTERNALSYM g_wszWMIsVBR}
//
// WM/AlbumArtist is a potentially different value than Author
//
g_wszWMAlbumArtist = WideString('WM/AlbumArtist');
{$EXTERNALSYM g_wszWMAlbumArtist}
////////////////////////////////////////////////////////////////
//
// These optional attributes may be used to give information
// about the branding of the content.
//
g_wszWMBannerImageType = WideString('BannerImageType');
{$EXTERNALSYM g_wszWMBannerImageType}
g_wszWMBannerImageData = WideString('BannerImageData');
{$EXTERNALSYM g_wszWMBannerImageData}
g_wszWMBannerImageURL = WideString('BannerImageURL');
{$EXTERNALSYM g_wszWMBannerImageURL}
g_wszWMCopyrightURL = WideString('CopyrightURL');
{$EXTERNALSYM g_wszWMCopyrightURL}
////////////////////////////////////////////////////////////////
//
// Optional attributes, used to give information
// about video stream properties.
//
g_wszWMAspectRatioX = WideString('AspectRatioX');
{$EXTERNALSYM g_wszWMAspectRatioX}
g_wszWMAspectRatioY = WideString('AspectRatioY');
{$EXTERNALSYM g_wszWMAspectRatioY}
////////////////////////////////////////////////////////////////
//
// Optional attributes, used to give information
// about the overall streaming properties of VBR files.
// This attribute takes the format:
// Word wReserved (must be 0)
// WM_LEAKY_BUCKET_PAIR pair1
// WM_LEAKY_BUCKET_PAIR pair2
// ...
//
g_wszASFLeakyBucketPairs = WideString('ASFLeakyBucketPairs');
{$EXTERNALSYM g_wszASFLeakyBucketPairs}
////////////////////////////////////////////////////////////////
//
// The NSC file supports the following attributes.
//
g_dwWMNSCAttributes = LongWord(5);
{$EXTERNALSYM g_dwWMNSCAttributes}
g_wszWMNSCName = WideString('NSC_Name');
{$EXTERNALSYM g_wszWMNSCName}
g_wszWMNSCAddress = WideString('NSC_Address');
{$EXTERNALSYM g_wszWMNSCAddress}
g_wszWMNSCPhone = WideString('NSC_Phone');
{$EXTERNALSYM g_wszWMNSCPhone}
g_wszWMNSCEmail = WideString('NSC_Email');
{$EXTERNALSYM g_wszWMNSCEmail}
g_wszWMNSCDescription = WideString('NSC_Description');
{$EXTERNALSYM g_wszWMNSCDescription}
///////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
//
// Attributes introduced in V9
//
g_wszWMWriter = WideString('WM/Writer');
{$EXTERNALSYM g_wszWMWriter}
g_wszWMConductor = WideString('WM/Conductor');
{$EXTERNALSYM g_wszWMConductor}
g_wszWMProducer = WideString('WM/Producer');
{$EXTERNALSYM g_wszWMProducer}
g_wszWMDirector = WideString('WM/Director');
{$EXTERNALSYM g_wszWMDirector}
g_wszWMContentGroupDescription = WideString('WM/ContentGroupDescription');
{$EXTERNALSYM g_wszWMContentGroupDescription}
g_wszWMSubTitle = WideString('WM/SubTitle');
{$EXTERNALSYM g_wszWMSubTitle}
g_wszWMPartOfSet = WideString('WM/PartOfSet');
{$EXTERNALSYM g_wszWMPartOfSet}
g_wszWMProtectionType = WideString('WM/ProtectionType');
{$EXTERNALSYM g_wszWMProtectionType}
g_wszWMVideoHeight = WideString('WM/VideoHeight');
{$EXTERNALSYM g_wszWMVideoHeight}
g_wszWMVideoWidth = WideString('WM/VideoWidth');
{$EXTERNALSYM g_wszWMVideoWidth}
g_wszWMVideoFrameRate = WideString('WM/VideoFrameRate');
{$EXTERNALSYM g_wszWMVideoFrameRate}
g_wszWMMediaClassPrimaryID = WideString('WM/MediaClassPrimaryID');
{$EXTERNALSYM g_wszWMMediaClassPrimaryID}
g_wszWMMediaClassSecondaryID = WideString('WM/MediaClassSecondaryID');
{$EXTERNALSYM g_wszWMMediaClassSecondaryID}
g_wszWMPeriod = WideString('WM/Period');
{$EXTERNALSYM g_wszWMPeriod}
g_wszWMCategory = WideString('WM/Category');
{$EXTERNALSYM g_wszWMCategory}
g_wszWMPicture = WideString('WM/Picture');
{$EXTERNALSYM g_wszWMPicture}
g_wszWMLyrics_Synchronised = WideString('WM/Lyrics_Synchronised');
{$EXTERNALSYM g_wszWMLyrics_Synchronised}
g_wszWMOriginalLyricist = WideString('WM/OriginalLyricist');
{$EXTERNALSYM g_wszWMOriginalLyricist}
g_wszWMOriginalArtist = WideString('WM/OriginalArtist');
{$EXTERNALSYM g_wszWMOriginalArtist}
g_wszWMOriginalAlbumTitle = WideString('WM/OriginalAlbumTitle');
{$EXTERNALSYM g_wszWMOriginalAlbumTitle}
g_wszWMOriginalReleaseYear = WideString('WM/OriginalReleaseYear');
{$EXTERNALSYM g_wszWMOriginalReleaseYear}
g_wszWMOriginalFilename = WideString('WM/OriginalFilename');
{$EXTERNALSYM g_wszWMOriginalFilename}
g_wszWMPublisher = WideString('WM/Publisher');
{$EXTERNALSYM g_wszWMPublisher}
g_wszWMEncodedBy = WideString('WM/EncodedBy');
{$EXTERNALSYM g_wszWMEncodedBy}
g_wszWMEncodingSettings = WideString('WM/EncodingSettings');
{$EXTERNALSYM g_wszWMEncodingSettings}
g_wszWMEncodingTime = WideString('WM/EncodingTime');
{$EXTERNALSYM g_wszWMEncodingTime}
g_wszWMAuthorURL = WideString('WM/AuthorURL');
{$EXTERNALSYM g_wszWMAuthorURL}
g_wszWMUserWebURL = WideString('WM/UserWebURL');
{$EXTERNALSYM g_wszWMUserWebURL}
g_wszWMAudioFileURL = WideString('WM/AudioFileURL');
{$EXTERNALSYM g_wszWMAudioFileURL}
g_wszWMAudioSourceURL = WideString('WM/AudioSourceURL');
{$EXTERNALSYM g_wszWMAudioSourceURL}
g_wszWMLanguage = WideString('WM/Language');
{$EXTERNALSYM g_wszWMLanguage}
g_wszWMParentalRating = WideString('WM/ParentalRating');
{$EXTERNALSYM g_wszWMParentalRating}
g_wszWMBeatsPerMinute = WideString('WM/BeatsPerMinute');
{$EXTERNALSYM g_wszWMBeatsPerMinute}
g_wszWMInitialKey = WideString('WM/InitialKey');
{$EXTERNALSYM g_wszWMInitialKey}
g_wszWMMood = WideString('WM/Mood');
{$EXTERNALSYM g_wszWMMood}
g_wszWMText = WideString('WM/Text');
{$EXTERNALSYM g_wszWMText}
g_wszWMDVDID = WideString('WM/DVDID');
{$EXTERNALSYM g_wszWMDVDID}
g_wszWMWMContentID = WideString('WM/WMContentID');
{$EXTERNALSYM g_wszWMWMContentID}
g_wszWMWMCollectionID = WideString('WM/WMCollectionID');
{$EXTERNALSYM g_wszWMWMCollectionID}
g_wszWMWMCollectionGroupID = WideString('WM/WMCollectionGroupID');
{$EXTERNALSYM g_wszWMWMCollectionGroupID}
g_wszWMUniqueFileIdentifier = WideString('WM/UniqueFileIdentifier');
{$EXTERNALSYM g_wszWMUniqueFileIdentifier}
g_wszWMModifiedBy = WideString('WM/ModifiedBy');
{$EXTERNALSYM g_wszWMModifiedBy}
g_wszWMRadioStationName = WideString('WM/RadioStationName');
{$EXTERNALSYM g_wszWMRadioStationName}
g_wszWMRadioStationOwner = WideString('WM/RadioStationOwner');
{$EXTERNALSYM g_wszWMRadioStationOwner}
g_wszWMPlaylistDelay = WideString('WM/PlaylistDelay');
{$EXTERNALSYM g_wszWMPlaylistDelay}
g_wszWMCodec = WideString('WM/Codec');
{$EXTERNALSYM g_wszWMCodec}
g_wszWMDRM = WideString('WM/DRM');
{$EXTERNALSYM g_wszWMDRM}
g_wszWMISRC = WideString('WM/ISRC');
{$EXTERNALSYM g_wszWMISRC}
g_wszWMProvider = WideString('WM/Provider');
{$EXTERNALSYM g_wszWMProvider}
g_wszWMProviderRating = WideString('WM/ProviderRating');
{$EXTERNALSYM g_wszWMProviderRating}
g_wszWMProviderStyle = WideString('WM/ProviderStyle');
{$EXTERNALSYM g_wszWMProviderStyle}
g_wszWMContentDistributor = WideString('WM/ContentDistributor');
{$EXTERNALSYM g_wszWMContentDistributor}
g_wszWMSubscriptionContentID = WideString('WM/SubscriptionContentID');
{$EXTERNALSYM g_wszWMSubscriptionContentID}
g_wszWMWMADRCPeakReference = WideString('WM/WMADRCPeakReference');
{$EXTERNALSYM g_wszWMWMADRCPeakReference}
g_wszWMWMADRCPeakTarget = WideString('WM/WMADRCPeakTarget');
{$EXTERNALSYM g_wszWMWMADRCPeakTarget}
g_wszWMWMADRCAverageReference = WideString('WM/WMADRCAverageReference');
{$EXTERNALSYM g_wszWMWMADRCAverageReference}
g_wszWMWMADRCAverageTarget = WideString('WM/WMADRCAverageTarget');
{$EXTERNALSYM g_wszWMWMADRCAverageTarget}
///////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
//
// These are setting names for use in Get/SetOutputSetting
//
g_wszEarlyDataDelivery = WideString('EarlyDataDelivery');
{$EXTERNALSYM g_wszEarlyDataDelivery}
g_wszJustInTimeDecode = WideString('JustInTimeDecode');
{$EXTERNALSYM g_wszJustInTimeDecode}
g_wszSingleOutputBuffer = WideString('SingleOutputBuffer');
{$EXTERNALSYM g_wszSingleOutputBuffer}
g_wszSoftwareScaling = WideString('SoftwareScaling');
{$EXTERNALSYM g_wszSoftwareScaling}
g_wszDeliverOnReceive = WideString('DeliverOnReceive');
{$EXTERNALSYM g_wszDeliverOnReceive}
g_wszScrambledAudio = WideString('ScrambledAudio');
{$EXTERNALSYM g_wszScrambledAudio}
g_wszDedicatedDeliveryThread = WideString('DedicatedDeliveryThread');
{$EXTERNALSYM g_wszDedicatedDeliveryThread}
g_wszEnableDiscreteOutput = WideString('EnableDiscreteOutput');
{$EXTERNALSYM g_wszEnableDiscreteOutput}
g_wszSpeakerConfig = WideString('SpeakerConfig');
{$EXTERNALSYM g_wszSpeakerConfig}
g_wszDynamicRangeControl = WideString('DynamicRangeControl');
{$EXTERNALSYM g_wszDynamicRangeControl}
g_wszAllowInterlacedOutput = WideString('AllowInterlacedOutput');
{$EXTERNALSYM g_wszAllowInterlacedOutput}
g_wszVideoSampleDurations = WideString('VideoSampleDurations');
{$EXTERNALSYM g_wszVideoSampleDurations}
g_wszStreamLanguage = WideString('StreamLanguage');
{$EXTERNALSYM g_wszStreamLanguage}
///////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
//
// These are setting names for use in Get/SetInputSetting
//
g_wszDeinterlaceMode = WideString('DeinterlaceMode');
{$EXTERNALSYM g_wszDeinterlaceMode}
g_wszInitialPatternForInverseTelecine = WideString('InitialPatternForInverseTelecine');
{$EXTERNALSYM g_wszInitialPatternForInverseTelecine}
g_wszJPEGCompressionQuality = WideString('JPEGCompressionQuality');
{$EXTERNALSYM g_wszJPEGCompressionQuality}
g_wszWatermarkCLSID = WideString('WatermarkCLSID');
{$EXTERNALSYM g_wszWatermarkCLSID}
g_wszWatermarkConfig = WideString('WatermarkConfig');
{$EXTERNALSYM g_wszWatermarkConfig}
g_wszInterlacedCoding = WideString('InterlacedCoding');
{$EXTERNALSYM g_wszInterlacedCoding}
g_wszFixedFrameRate = WideString('FixedFrameRate');
{$EXTERNALSYM g_wszFixedFrameRate}
////////////////////////////////////////////////////////////////
//
// All known IWMPropertyVault property names
//
// g_wszOriginalSourceFormatTag is obsolete and has been superceded by g_wszOriginalWaveFormat
g_wszOriginalSourceFormatTag = WideString('_SOURCEFORMATTAG');
{$EXTERNALSYM g_wszOriginalSourceFormatTag}
g_wszOriginalWaveFormat = WideString('_ORIGINALWAVEFORMAT');
{$EXTERNALSYM g_wszOriginalWaveFormat}
g_wszEDL = WideString('_EDL');
{$EXTERNALSYM g_wszEDL}
g_wszComplexity = WideString('_COMPLEXITYEX');
{$EXTERNALSYM g_wszComplexity}
g_wszDecoderComplexityRequested = WideString('_DECODERCOMPLEXITYPROFILE');
{$EXTERNALSYM g_wszDecoderComplexityRequested}
////////////////////////////////////////////////////////////////
//
// All known IWMIStreamProps property names
//
g_wszReloadIndexOnSeek = WideString('ReloadIndexOnSeek');
{$EXTERNALSYM g_wszReloadIndexOnSeek}
g_wszStreamNumIndexObjects = WideString('StreamNumIndexObjects');
{$EXTERNALSYM g_wszStreamNumIndexObjects}
g_wszFailSeekOnError = WideString('FailSeekOnError');
{$EXTERNALSYM g_wszFailSeekOnError}
g_wszPermitSeeksBeyondEndOfStream = WideString('PermitSeeksBeyondEndOfStream');
{$EXTERNALSYM g_wszPermitSeeksBeyondEndOfStream}
g_wszUsePacketAtSeekPoint = WideString('UsePacketAtSeekPoint');
{$EXTERNALSYM g_wszUsePacketAtSeekPoint}
g_wszSourceBufferTime = WideString('SourceBufferTime');
{$EXTERNALSYM g_wszSourceBufferTime}
g_wszSourceMaxBytesAtOnce = WideString('SourceMaxBytesAtOnce');
{$EXTERNALSYM g_wszSourceMaxBytesAtOnce}
///////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
//
// VBR encoding settings
//
g_wszVBREnabled = WideString('_VBRENABLED');
{$EXTERNALSYM g_wszVBREnabled}
g_wszVBRQuality = WideString('_VBRQUALITY');
{$EXTERNALSYM g_wszVBRQuality}
g_wszVBRBitrateMax = WideString('_RMAX');
{$EXTERNALSYM g_wszVBRBitrateMax}
g_wszVBRBufferWindowMax = WideString('_BMAX');
{$EXTERNALSYM g_wszVBRBufferWindowMax}
////////////////////////////////////////////////////////////////
//
// VBR Video settings
//
g_wszVBRPeak = WideString('VBR Peak');
{$EXTERNALSYM g_wszVBRPeak}
g_wszBufferAverage = WideString('Buffer Average');
{$EXTERNALSYM g_wszBufferAverage}
////////////////////////////////////////////////////////////////
//
// Codec encoding complexity settings
//
// g_wszComplexity should be used to set desired encoding complexity on the
// stream's IWMPropertyVault (see above for definition)
// The below settings can be queried from IWMCodecInfo3::GetCodecProp()
//
g_wszComplexityMax = WideString('_COMPLEXITYEXMAX');
{$EXTERNALSYM g_wszComplexityMax}
g_wszComplexityOffline = WideString('_COMPLEXITYEXOFFLINE');
{$EXTERNALSYM g_wszComplexityOffline}
g_wszComplexityLive = WideString('_COMPLEXITYEXLIVE');
{$EXTERNALSYM g_wszComplexityLive}
g_wszIsVBRSupported = WideString('_ISVBRSUPPORTED');
{$EXTERNALSYM g_wszIsVBRSupported}
////////////////////////////////////////////////////////////////
//
// Codec enumeration settings
//
// g_wszVBREnabled can be used as a codec enumeration setting (see above for definition)
g_wszNumPasses = WideString('_PASSESUSED');
{$EXTERNALSYM g_wszNumPasses}
////////////////////////////////////////////////////////////////
//
// These are WMA Voice V9 attribute names and values
//
g_wszMusicSpeechClassMode = WideString('MusicSpeechClassMode');
{$EXTERNALSYM g_wszMusicSpeechClassMode}
g_wszMusicClassMode = WideString('MusicClassMode');
{$EXTERNALSYM g_wszMusicClassMode}
g_wszSpeechClassMode = WideString('SpeechClassMode');
{$EXTERNALSYM g_wszSpeechClassMode}
g_wszMixedClassMode = WideString('MixedClassMode');
{$EXTERNALSYM g_wszMixedClassMode}
////////////////////////////////////////////////////////////////
//
// The WMA Voice V9 supports the following format property.
//
g_wszSpeechCaps = WideString('SpeechFormatCap');
{$EXTERNALSYM g_wszSpeechCaps}
////////////////////////////////////////////////////////////////
//
// Multi-channel WMA properties
//
g_wszPeakValue = WideString('PeakValue');
{$EXTERNALSYM g_wszPeakValue}
g_wszAverageLevel = WideString('AverageLevel');
{$EXTERNALSYM g_wszAverageLevel}
g_wszFold6To2Channels3 = WideString('Fold6To2Channels3');
{$EXTERNALSYM g_wszFold6To2Channels3}
g_wszFoldToChannelsTemplate = WideString('Fold%luTo%luChannels%lu');
{$EXTERNALSYM g_wszFoldToChannelsTemplate}
////////////////////////////////////////////////////////////////
//
// Complexity profile description strings
//
g_wszDeviceConformanceTemplate = WideString('DeviceConformanceTemplate');
{$EXTERNALSYM g_wszDeviceConformanceTemplate}
////////////////////////////////////////////////////////////////
//
// Frame interpolation on video decode
//
g_wszEnableFrameInterpolation = WideString('EnableFrameInterpolation');
{$EXTERNALSYM g_wszEnableFrameInterpolation}
////////////////////////////////////////////////////////////////
//
// Needs previous sample for Delta frame on video decode
//
g_wszNeedsPreviousSample = WideString('NeedsPreviousSample');
{$EXTERNALSYM g_wszNeedsPreviousSample}
///////////////////////////////////////////////////////////////////////////////
//
// Enumerations and flags used by the SDK.
//
///////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
//
// Flags that can be passed into the Start method of IWMReader
//
WM_START_CURRENTPOSITION = Int64(-1);
{$EXTERNALSYM WM_START_CURRENTPOSITION}
//
// Flag to force overwrite of existing license backup
//
WM_BACKUP_OVERWRITE = LongWord($00000001);
{$EXTERNALSYM WM_BACKUP_OVERWRITE}
WM_RESTORE_INDIVIDUALIZE = LongWord($00000002);
{$EXTERNALSYM WM_RESTORE_INDIVIDUALIZE}
//
// Wave format ex type
//
WAVE_FORMAT_DRM = $0009;
{$EXTERNALSYM WAVE_FORMAT_DRM}
//
// Sample type ids for Web Streams
//
WEBSTREAM_SAMPLE_TYPE_FILE = $1;
{$EXTERNALSYM WEBSTREAM_SAMPLE_TYPE_FILE}
WEBSTREAM_SAMPLE_TYPE_RENDER = $2;
{$EXTERNALSYM WEBSTREAM_SAMPLE_TYPE_RENDER}
//
// The flags that can be set on a sample (input or output).
//
WM_SF_CLEANPOINT = $1;
{$EXTERNALSYM WM_SF_CLEANPOINT}
WM_SF_DISCONTINUITY = $2;
{$EXTERNALSYM WM_SF_DISCONTINUITY}
WM_SF_DATALOSS = $4;
{$EXTERNALSYM WM_SF_DATALOSS}
//
// These flags might be set for a call to the IWMReaderAllocatorEx methods.
//
WM_SFEX_NOTASYNCPOINT = $2;
{$EXTERNALSYM WM_SFEX_NOTASYNCPOINT}
WM_SFEX_DATALOSS = $4;
{$EXTERNALSYM WM_SFEX_DATALOSS}
//
// Status messages that the reader and index objects can
// pass in the OnStatus call.
//
type
WMT_STATUS = (
WMT_ERROR,
WMT_OPENED,
WMT_BUFFERING_START,
WMT_BUFFERING_STOP,
WMT_END_OF_FILE,
{$IFDEF COMPILER6_UP}
WMT_EOF = 4,
{$ENDIF}
WMT_END_OF_SEGMENT,
WMT_END_OF_STREAMING,
WMT_LOCATING,
WMT_CONNECTING,
WMT_NO_RIGHTS,
WMT_MISSING_CODEC,
WMT_STARTED,
WMT_STOPPED,
WMT_CLOSED,
WMT_STRIDING,
WMT_TIMER,
WMT_INDEX_PROGRESS,
WMT_SAVEAS_START,
WMT_SAVEAS_STOP,
WMT_NEW_SOURCEFLAGS,
WMT_NEW_METADATA,
WMT_BACKUPRESTORE_BEGIN,
WMT_SOURCE_SWITCH,
WMT_ACQUIRE_LICENSE,
WMT_INDIVIDUALIZE,
WMT_NEEDS_INDIVIDUALIZATION,
WMT_NO_RIGHTS_EX,
WMT_BACKUPRESTORE_END,
WMT_BACKUPRESTORE_CONNECTING,
WMT_BACKUPRESTORE_DISCONNECTING,
WMT_ERROR_WITHURL,
WMT_RESTRICTED_LICENSE,
WMT_CLIENT_CONNECT,
WMT_CLIENT_DISCONNECT,
WMT_NATIVE_OUTPUT_PROPS_CHANGED,
WMT_RECONNECT_START,
WMT_RECONNECT_END,
WMT_CLIENT_CONNECT_EX,
WMT_CLIENT_DISCONNECT_EX,
WMT_SET_FEC_SPAN,
WMT_PREROLL_READY,
WMT_PREROLL_COMPLETE,
WMT_CLIENT_PROPERTIES,
WMT_LICENSEURL_SIGNATURE_STATE
);
{$EXTERNALSYM WMT_STATUS}
TWMTStatus = WMT_STATUS;
{$IFNDEF COMPILER6_UP}
const
WMT_EOF = WMT_END_OF_FILE;
{$NODEFINE WMT_EOF}
{$ENDIF}
type
WMT_RIGHTS = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord;
{$EXTERNALSYM WMT_RIGHTS}
const
WMT_RIGHT_PLAYBACK = $00000001;
{$EXTERNALSYM WMT_RIGHT_PLAYBACK}
WMT_RIGHT_COPY_TO_NON_SDMI_DEVICE = $00000002;
{$EXTERNALSYM WMT_RIGHT_COPY_TO_NON_SDMI_DEVICE}
WMT_RIGHT_COPY_TO_CD = $00000008;
{$EXTERNALSYM WMT_RIGHT_COPY_TO_CD}
WMT_RIGHT_COPY_TO_SDMI_DEVICE = $00000010;
{$EXTERNALSYM WMT_RIGHT_COPY_TO_SDMI_DEVICE}
WMT_RIGHT_ONE_TIME = $00000020;
{$EXTERNALSYM WMT_RIGHT_ONE_TIME}
WMT_RIGHT_SAVE_STREAM_PROTECTED = $00000040;
{$EXTERNALSYM WMT_RIGHT_SAVE_STREAM_PROTECTED}
WMT_RIGHT_SDMI_TRIGGER = $00010000;
{$EXTERNALSYM WMT_RIGHT_SDMI_TRIGGER}
WMT_RIGHT_SDMI_NOMORECOPIES = $00020000;
{$EXTERNALSYM WMT_RIGHT_SDMI_NOMORECOPIES}
//
// Stream selection statuses (stati?).
//
type
PWMTStreamSelection = ^TWMTStreamSelection;
WMT_STREAM_SELECTION = (
WMT_OFF,
WMT_CLEANPOINT_ONLY,
WMT_ON
);
{$EXTERNALSYM WMT_STREAM_SELECTION}
TWMTStreamSelection = WMT_STREAM_SELECTION;
//
// Image types (used with CBO)
//
WMT_IMAGE_TYPE = (
WMT_IT_NONE,
WMT_IT_BITMAP,
WMT_IT_JPEG,
WMT_IT_GIF
);
{$EXTERNALSYM WMT_IMAGE_TYPE}
TWMTImageType = WMT_IMAGE_TYPE;
//
// Attribute datatypes.
//
WMT_ATTR_DATATYPE = (
WMT_TYPE_DWORD,
WMT_TYPE_STRING,
WMT_TYPE_BINARY,
WMT_TYPE_BOOL,
WMT_TYPE_QWORD,
WMT_TYPE_WORD,
WMT_TYPE_GUID
);
{$EXTERNALSYM WMT_ATTR_DATATYPE}
TWMTAttrDataType = WMT_ATTR_DATATYPE;
//
// Types of images that can be stored in the header of a Windows Media File.
//
WMT_ATTR_IMAGETYPE = (
{$IFNDEF COMPILER6_UP}
WMT_IMAGETYPE_INVALID_0,
WMT_IMAGETYPE_BITMAP,
{$ELSE}
WMT_IMAGETYPE_BITMAP = 1,
{$ENDIF}
WMT_IMAGETYPE_JPEG,
WMT_IMAGETYPE_GIF
);
{$EXTERNALSYM WMT_ATTR_IMAGETYPE}
TWMTAttrImageType = WMT_ATTR_IMAGETYPE;
//
// Windows Media versions.
//
WMT_VERSION = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord;
{$EXTERNALSYM WMT_VERSION}
const
WMT_VER_4_0 = $00040000;
{$EXTERNALSYM WMT_VER_4_0}
WMT_VER_7_0 = $00070000;
{$EXTERNALSYM WMT_VER_7_0}
WMT_VER_8_0 = $00080000;
{$EXTERNALSYM WMT_VER_8_0}
WMT_VER_9_0 = $00090000;
{$EXTERNALSYM WMT_VER_9_0}
//
// Storage formats. These are the values returned when querying
// the WM/ContainerFormat attribute (g_wszWMContainerFormat).
//
type
tagWMT_STORAGE_FORMAT = (
WMT_Storage_Format_MP3,
WMT_Storage_Format_V1
);
{$EXTERNALSYM tagWMT_STORAGE_FORMAT}
WMT_STORAGE_FORMAT = tagWMT_STORAGE_FORMAT;
{$EXTERNALSYM WMT_STORAGE_FORMAT}
TWMTStorageFormat = tagWMT_STORAGE_FORMAT;
tagWMT_DRMLA_TRUST = (
WMT_DRMLA_UNTRUSTED,
WMT_DRMLA_TRUSTED,
WMT_DRMLA_TAMPERED
);
{$EXTERNALSYM tagWMT_DRMLA_TRUST}
WMT_DRMLA_TRUST = tagWMT_DRMLA_TRUST;
{$EXTERNALSYM WMT_DRMLA_TRUST}
TWMTDRMLATrust = tagWMT_DRMLA_TRUST;
//
// Type of data communication protocol (reliable or unreliable)
//
tagWMT_TRANSPORT_TYPE = (
WMT_Transport_Type_Unreliable,
WMT_Transport_Type_Reliable
);
{$EXTERNALSYM tagWMT_TRANSPORT_TYPE}
WMT_TRANSPORT_TYPE = tagWMT_TRANSPORT_TYPE;
{$EXTERNALSYM WMT_TRANSPORT_TYPE}
TWMTTransportType = tagWMT_TRANSPORT_TYPE;
//
// Protocols that the network sink supports.
//
WMT_NET_PROTOCOL = (
WMT_PROTOCOL_HTTP
);
{$EXTERNALSYM WMT_NET_PROTOCOL}
TWMTNetProtocol = WMT_NET_PROTOCOL;
//
// The reader supports a number of different types of playback, each with
// slightly different characteristics.
//
WMT_PLAY_MODE = (
WMT_PLAY_MODE_AUTOSELECT,
WMT_PLAY_MODE_LOCAL,
WMT_PLAY_MODE_DOWNLOAD,
WMT_PLAY_MODE_STREAMING
);
{$EXTERNALSYM WMT_PLAY_MODE}
TWMTPlayMode = WMT_PLAY_MODE;
//
// Network Proxy settings for the reader
//
WMT_PROXY_SETTINGS = (
WMT_PROXY_SETTING_NONE,
WMT_PROXY_SETTING_MANUAL,
WMT_PROXY_SETTING_AUTO,
WMT_PROXY_SETTING_BROWSER, // Only valid for HTTP
WMT_PROXY_SETTING_MAX
);
{$EXTERNALSYM WMT_PROXY_SETTINGS}
TWMTProxySettings = WMT_PROXY_SETTINGS;
WMT_CODEC_INFO_TYPE = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord;
{$EXTERNALSYM WMT_CODEC_INFO_TYPE}
const
WMT_CODECINFO_AUDIO = 0; // codec info is a Word = wFormatTag
{$EXTERNALSYM WMT_CODECINFO_AUDIO}
WMT_CODECINFO_VIDEO = 1; // codec info is a LongWord = biCompression
{$EXTERNALSYM WMT_CODECINFO_VIDEO}
WMT_CODECINFO_UNKNOWN = $FFFFFFFF; // codec info is undefined
{$EXTERNALSYM WMT_CODECINFO_UNKNOWN}
//
// These values can be passed in when setting the DeinterlaceMode
// setting on the writer
//
WM_DM_NOTINTERLACED = LongWord(0);
{$EXTERNALSYM WM_DM_NOTINTERLACED}
WM_DM_DEINTERLACE_NORMAL = LongWord(1);
{$EXTERNALSYM WM_DM_DEINTERLACE_NORMAL}
WM_DM_DEINTERLACE_HALFSIZE = LongWord(2);
{$EXTERNALSYM WM_DM_DEINTERLACE_HALFSIZE}
WM_DM_DEINTERLACE_HALFSIZEDOUBLERATE = LongWord(3);
{$EXTERNALSYM WM_DM_DEINTERLACE_HALFSIZEDOUBLERATE}
WM_DM_DEINTERLACE_INVERSETELECINE = LongWord(4);
{$EXTERNALSYM WM_DM_DEINTERLACE_INVERSETELECINE}
WM_DM_DEINTERLACE_VERTICALHALFSIZEDOUBLERATE = LongWord(5);
{$EXTERNALSYM WM_DM_DEINTERLACE_VERTICALHALFSIZEDOUBLERATE}
//
// These values can be passed to further configure the inverse
// telecine process
//
WM_DM_IT_DISABLE_COHERENT_MODE = LongWord(0);
{$EXTERNALSYM WM_DM_IT_DISABLE_COHERENT_MODE}
WM_DM_IT_FIRST_FRAME_IN_CLIP_IS_AA_TOP = LongWord(1);
{$EXTERNALSYM WM_DM_IT_FIRST_FRAME_IN_CLIP_IS_AA_TOP}
WM_DM_IT_FIRST_FRAME_IN_CLIP_IS_BB_TOP = LongWord(2);
{$EXTERNALSYM WM_DM_IT_FIRST_FRAME_IN_CLIP_IS_BB_TOP}
WM_DM_IT_FIRST_FRAME_IN_CLIP_IS_BC_TOP = LongWord(3);
{$EXTERNALSYM WM_DM_IT_FIRST_FRAME_IN_CLIP_IS_BC_TOP}
WM_DM_IT_FIRST_FRAME_IN_CLIP_IS_CD_TOP = LongWord(4);
{$EXTERNALSYM WM_DM_IT_FIRST_FRAME_IN_CLIP_IS_CD_TOP}
WM_DM_IT_FIRST_FRAME_IN_CLIP_IS_DD_TOP = LongWord(5);
{$EXTERNALSYM WM_DM_IT_FIRST_FRAME_IN_CLIP_IS_DD_TOP}
WM_DM_IT_FIRST_FRAME_IN_CLIP_IS_AA_BOTTOM = LongWord(6);
{$EXTERNALSYM WM_DM_IT_FIRST_FRAME_IN_CLIP_IS_AA_BOTTOM}
WM_DM_IT_FIRST_FRAME_IN_CLIP_IS_BB_BOTTOM = LongWord(7);
{$EXTERNALSYM WM_DM_IT_FIRST_FRAME_IN_CLIP_IS_BB_BOTTOM}
WM_DM_IT_FIRST_FRAME_IN_CLIP_IS_BC_BOTTOM = LongWord(8);
{$EXTERNALSYM WM_DM_IT_FIRST_FRAME_IN_CLIP_IS_BC_BOTTOM}
WM_DM_IT_FIRST_FRAME_IN_CLIP_IS_CD_BOTTOM = LongWord(9);
{$EXTERNALSYM WM_DM_IT_FIRST_FRAME_IN_CLIP_IS_CD_BOTTOM}
WM_DM_IT_FIRST_FRAME_IN_CLIP_IS_DD_BOTTOM = LongWord(10);
{$EXTERNALSYM WM_DM_IT_FIRST_FRAME_IN_CLIP_IS_DD_BOTTOM}
//
// Frame level access data structures
//
type
tagWMT_OFFSET_FORMAT = (
WMT_OFFSET_FORMAT_100NS,
WMT_OFFSET_FORMAT_FRAME_NUMBERS,
WMT_OFFSET_FORMAT_PLAYLIST_OFFSET,
WMT_OFFSET_FORMAT_TIMECODE
);
{$EXTERNALSYM tagWMT_OFFSET_FORMAT}
WMT_OFFSET_FORMAT = tagWMT_OFFSET_FORMAT;
{$EXTERNALSYM WMT_OFFSET_FORMAT}
TWMTOffsetFormat = tagWMT_OFFSET_FORMAT;
//
// Indexer type and index type
//
tagWMT_INDEXER_TYPE = (
WMT_IT_PRESENTATION_TIME,
WMT_IT_FRAME_NUMBERS,
WMT_IT_TIMECODE
);
{$EXTERNALSYM tagWMT_INDEXER_TYPE}
WMT_INDEXER_TYPE = tagWMT_INDEXER_TYPE;
{$EXTERNALSYM WMT_INDEXER_TYPE}
TWMTIndexerType = tagWMT_INDEXER_TYPE;
tagWMT_INDEX_TYPE = (
{$IFNDEF COMPILER6_UP}
WMT_IT_NEAREST_INVALID_0,
WMT_IT_NEAREST_DATA_UNIT,
{$ELSE}
WMT_IT_NEAREST_DATA_UNIT = 1,
{$ENDIF}
WMT_IT_NEAREST_OBJECT,
WMT_IT_NEAREST_CLEAN_POINT
);
{$EXTERNALSYM tagWMT_INDEX_TYPE}
WMT_INDEX_TYPE = tagWMT_INDEX_TYPE;
{$EXTERNALSYM WMT_INDEX_TYPE}
TWMTIndexType = tagWMT_INDEX_TYPE;
//
// The types of input accepted by the file sink
//
WMT_FILESINK_MODE = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord;
{$EXTERNALSYM WMT_FILESINK_MODE}
const
WMT_FM_SINGLE_BUFFERS = $00000001;
{$EXTERNALSYM WMT_FM_SINGLE_BUFFERS}
WMT_FM_FILESINK_DATA_UNITS = $00000002;
{$EXTERNALSYM WMT_FM_FILESINK_DATA_UNITS}
WMT_FM_FILESINK_UNBUFFERED = $00000004;
{$EXTERNALSYM WMT_FM_FILESINK_UNBUFFERED}
//
// WMA Voice V9 supports several type of compression,
// profile settting are mapped to these constants
//
type
tagWMT_MUSICSPEECH_CLASS_MODE = (
WMT_MS_CLASS_MUSIC,
WMT_MS_CLASS_SPEECH,
WMT_MS_CLASS_MIXED
);
{$EXTERNALSYM tagWMT_MUSICSPEECH_CLASS_MODE}
WMT_MUSICSPEECH_CLASS_MODE = tagWMT_MUSICSPEECH_CLASS_MODE;
{$EXTERNALSYM WMT_MUSICSPEECH_CLASS_MODE}
TWMTMusicSpeechClassMode = tagWMT_MUSICSPEECH_CLASS_MODE;
tagWMT_WATERMARK_ENTRY_TYPE = (
{$IFNDEF COMPILER6_UP}
WMT_WMETYPE_INVALID_0,
WMT_WMETYPE_AUDIO,
{$ELSE}
WMT_WMETYPE_AUDIO = 1,
{$ENDIF}
WMT_WMETYPE_VIDEO
);
{$EXTERNALSYM tagWMT_WATERMARK_ENTRY_TYPE}
WMT_WATERMARK_ENTRY_TYPE = tagWMT_WATERMARK_ENTRY_TYPE;
{$EXTERNALSYM WMT_WATERMARK_ENTRY_TYPE}
TWMTWatermarkEntryType = tagWMT_WATERMARK_ENTRY_TYPE;
//
// Dynamic Range Control values for playback
//
const
WM_PLAYBACK_DRC_HIGH = 0;
{$EXTERNALSYM WM_PLAYBACK_DRC_HIGH}
WM_PLAYBACK_DRC_MEDIUM = 1;
{$EXTERNALSYM WM_PLAYBACK_DRC_MEDIUM}
WM_PLAYBACK_DRC_LOW = 2;
{$EXTERNALSYM WM_PLAYBACK_DRC_LOW}
//
// Timecode frame rates. These are meant to be used as the
// values for the stream-based frame rate metadata attribute.
// See the WM Format SDK docs for more details.
//
WMT_TIMECODE_FRAMERATE_30 = 0;
{$EXTERNALSYM WMT_TIMECODE_FRAMERATE_30}
WMT_TIMECODE_FRAMERATE_30DROP = 1;
{$EXTERNALSYM WMT_TIMECODE_FRAMERATE_30DROP}
WMT_TIMECODE_FRAMERATE_25 = 2;
{$EXTERNALSYM WMT_TIMECODE_FRAMERATE_25}
WMT_TIMECODE_FRAMERATE_24 = 3;
{$EXTERNALSYM WMT_TIMECODE_FRAMERATE_24}
//
// Flags that can be specified in IWMCredentialCallback::AcquireCredentials()
//
type
WMT_CREDENTIAL_FLAGS = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord;
{$EXTERNALSYM WMT_CREDENTIAL_FLAGS}
const
WMT_CREDENTIAL_SAVE = $00000001; // Save the credentials in a persistent manner
{$EXTERNALSYM WMT_CREDENTIAL_SAVE}
WMT_CREDENTIAL_DONT_CACHE = $00000002; // Don't cache the credentials in memory
{$EXTERNALSYM WMT_CREDENTIAL_DONT_CACHE}
WMT_CREDENTIAL_CLEAR_TEXT = $00000004; // Credentials will be sent in clear text
{$EXTERNALSYM WMT_CREDENTIAL_CLEAR_TEXT}
WMT_CREDENTIAL_PROXY = $00000008; // Credentials are for a proxy server
{$EXTERNALSYM WMT_CREDENTIAL_PROXY}
WMT_CREDENTIAL_ENCRYPT = $00000010; // Encryption supported/used (in request/response, respectively)
{$EXTERNALSYM WMT_CREDENTIAL_ENCRYPT}
type
WM_AETYPE = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord;
{$EXTERNALSYM WM_AETYPE}
const
WM_AETYPE_INCLUDE = $69;
{$EXTERNALSYM WM_AETYPE_INCLUDE}
WM_AETYPE_EXCLUDE = $65;
{$EXTERNALSYM WM_AETYPE_EXCLUDE}
///////////////////////////////////////////////////////////////////////////////
//
// Structures used by the SDK.
//
///////////////////////////////////////////////////////////////////////////////
//
// Stream prioritization struct
//
type
PWMStreamPrioritizationRecord = ^TWMStreamPrioritizationRecord;
_WMStreamPrioritizationRecord = packed record
wStreamNumber: Word;
fMandatory : BOOL;
end;
{$EXTERNALSYM _WMStreamPrioritizationRecord}
WM_STREAM_PRIORITY_RECORD = _WMStreamPrioritizationRecord;
{$EXTERNALSYM WM_STREAM_PRIORITY_RECORD}
TWMStreamPrioritizationRecord = _WMStreamPrioritizationRecord;
//
// Writer Statistics struct
//
PWMWriterStatistics = ^TWMWriterStatistics;
_WMWriterStatistics = packed record
qwSampleCount : Int64;
qwByteCount : Int64;
qwDroppedSampleCount : Int64;
qwDroppedByteCount : Int64;
dwCurrentBitrate : LongWord;
dwAverageBitrate : LongWord;
dwExpectedBitrate : LongWord;
//
// Sample rates are given as 1000 * (samples / second).
//
dwCurrentSampleRate : LongWord;
dwAverageSampleRate : LongWord;
dwExpectedSampleRate : LongWord;
end;
{$EXTERNALSYM _WMWriterStatistics}
WM_WRITER_STATISTICS = _WMWriterStatistics;
{$EXTERNALSYM WM_WRITER_STATISTICS}
TWMWriterStatistics = _WMWriterStatistics;
//
// Extended Writer Statistics
//
PWMWriterStatisticsEx = ^TWMWriterStatisticsEx;
_WMWriterStatisticsEx = packed record
//
// Bitrate that includes overhead
//
dwBitratePlusOverhead : LongWord;
//
// Sample rates are given as 1000 * (samples / second)
//
dwCurrentSampleDropRateInQueue : LongWord;
dwCurrentSampleDropRateInCodec : LongWord;
dwCurrentSampleDropRateInMultiplexer : LongWord;
//
// Cumulative sample drops
//
dwTotalSampleDropsInQueue : LongWord;
dwTotalSampleDropsInCodec : LongWord;
dwTotalSampleDropsInMultiplexer : LongWord;
end;
{$EXTERNALSYM _WMWriterStatisticsEx}
WM_WRITER_STATISTICS_EX = _WMWriterStatisticsEx;
{$EXTERNALSYM WM_WRITER_STATISTICS_EX}
TWMWriterStatisticsEx = _WMWriterStatisticsEx;
//
// Reader Statistics struct
//
PWMReaderStatistics = ^TWMReaderStatistics;
_WMReaderStatistics = packed record
cbSize : LongWord;
dwBandwidth : LongWord;
cPacketsReceived : LongWord;
cPacketsRecovered : LongWord;
cPacketsLost : LongWord;
wQuality : Word;
end;
{$EXTERNALSYM _WMReaderStatistics}
WM_READER_STATISTICS = _WMReaderStatistics;
{$EXTERNALSYM WM_READER_STATISTICS}
TWMReaderStatistics = _WMReaderStatistics;
//
// Reader Client Info struct
//
PWMReaderClientInfo = ^TWMReaderClientInfo;
_WMReaderClientInfo = packed record
cbSize : LongWord;
wszLang : PWideChar; // 2-3 letter language code
wszBrowserUserAgent : PWideChar; // Embedded browser's user-agent string
wszBrowserWebPage : PWideChar; // The web page that contains the plugin
qwReserved : Int64; // Reserved
pReserved : PLongInt; // Reserved
wszHostExe : PWideChar; // iexplore.exe, netscape.exe dshow.exe, etc
qwHostVersion : Int64; // Version of the host application e.g.:4.70.12.15
wszPlayerUserAgent : PWideChar; // String identifying the player application, e.g. WMPlayer/9.0.0.0
end;
{$EXTERNALSYM _WMReaderClientInfo}
WM_READER_CLIENTINFO = _WMReaderClientInfo;
{$EXTERNALSYM WM_READER_CLIENTINFO}
TWMReaderClientInfo = _WMReaderClientInfo;
//
// This structure is returned with the WMT_CLIENT_CONNECT and
// WMT_CLIENT_DISCONNECT status notifications. It is also used
// by IWMClientConnections.
//
PWMClientProperties = ^TWMClientProperties;
_WMClientProperties = packed record
dwIPAddress : LongWord;
dwPort : LongWord;
end;
{$EXTERNALSYM _WMClientProperties}
WM_CLIENT_PROPERTIES = _WMClientProperties;
{$EXTERNALSYM WM_CLIENT_PROPERTIES}
TWMClientProperties = _WMClientProperties;
//
// This structure is returned with the WMT_CLIENT_CONNECT_EX, WMT_CLIENT_DISCONNECT_EX
// and WMT_CLIENT_PROPERTIES status notifications.
//
PWMClientPropertiesEx = ^TWMClientPropertiesEx;
_WMClientPropertiesEx = packed record
cbSize : LongWord; // size of structure
pwszIPAddress : PWideChar; // IP address in dot notation
pwszPort : PWideChar; // Client's port number
pwszDNSName : PWideChar; // DNS name of client, if known
end;
{$EXTERNALSYM _WMClientPropertiesEx}
WM_CLIENT_PROPERTIES_EX = _WMClientPropertiesEx;
{$EXTERNALSYM WM_CLIENT_PROPERTIES_EX}
TWMClientPropertiesEx = _WMClientPropertiesEx;
//
// Inclusive port number range.
// Used by IWMReaderNetworkConfig.
//
PWMPortNumberRange = ^TWMPortNumberRange;
_WMPortNumberRange = packed record
wPortBegin : Word;
wPortEnd : Word;
end;
{$EXTERNALSYM _WMPortNumberRange}
WM_PORT_NUMBER_RANGE = _WMPortNumberRange;
{$EXTERNALSYM WM_PORT_NUMBER_RANGE}
TWMPortNumberRange = _WMPortNumberRange;
//
// For passing data units to the file sink
//
PWMTBufferSegment = ^TWMTBufferSegment;
_WMT_BUFFER_SEGMENT = packed record
pBuffer : INSSBuffer;
cbOffset : LongWord;
cbLength : LongWord;
end;
{$EXTERNALSYM _WMT_BUFFER_SEGMENT}
WMT_BUFFER_SEGMENT = _WMT_BUFFER_SEGMENT;
{$EXTERNALSYM WMT_BUFFER_SEGMENT}
TWMTBufferSegment = _WMT_BUFFER_SEGMENT;
PWMTPayloadFragment = ^TWMTPayloadFragment;
_WMT_PAYLOAD_FRAGMENT = packed record
dwPayloadIndex : LongWord;
segmentData : TWMTBufferSegment;
end;
{$EXTERNALSYM _WMT_PAYLOAD_FRAGMENT}
WMT_PAYLOAD_FRAGMENT = _WMT_PAYLOAD_FRAGMENT;
{$EXTERNALSYM WMT_PAYLOAD_FRAGMENT}
TWMTPayloadFragment = _WMT_PAYLOAD_FRAGMENT;
PWMTFileSinkDataUnit = ^TWMTFileSinkDataUnit;
_WMT_FILESINK_DATA_UNIT = packed record
packetHeaderBuffer : TWMTBufferSegment;
cPayloads : LongWord;
pPayloadHeaderBuffers : PWMTBufferSegment;
cPayloadDataFragments : LongWord;
pPayloadDataFragments : PWMTPayloadFragment;
end;
{$EXTERNALSYM _WMT_FILESINK_DATA_UNIT}
WMT_FILESINK_DATA_UNIT = _WMT_FILESINK_DATA_UNIT;
{$EXTERNALSYM WMT_FILESINK_DATA_UNIT}
TWMTFileSinkDataUnit = _WMT_FILESINK_DATA_UNIT;
PWMTWebStreamFormat = ^TWMTWebStreamFormat;
_WMT_WEBSTREAM_FORMAT = packed record
cbSize : Word; // Set to sizeof( WMT_WEBSTREAM_FORMAT )
cbSampleHeaderFixedData : Word; // Length of the fixed part of the sample header should be
// set to sizeof( WMT_WEBSTREAM_SAMPLE_HEADER )
wVersion : Word;
wReserved : Word; // Reserved. Should be set to 0.
end;
{$EXTERNALSYM _WMT_WEBSTREAM_FORMAT}
WMT_WEBSTREAM_FORMAT = _WMT_WEBSTREAM_FORMAT;
{$EXTERNALSYM WMT_WEBSTREAM_FORMAT}
TWMTWebStreamFormat = WMT_WEBSTREAM_FORMAT;
PWMTWebStreamSampleHeader = ^TWMTWebStreamSampleHeader;
_WMT_WEBSTREAM_SAMPLE_HEADER = packed record
cbLength : Word; // Length of this header including string data
// should be set to sizeof( WMT_WEBSTREAM_SAMPLE_HEADER ) +
// wcslen( wszURL ) * sizeof( WCHAR )
wPart : Word; // Current part. From 0 to cTotalParts - 1
cTotalParts : Word; // Total number of parts for this file must be at least 1.
wSampleType : Word; // Sample type. Should be set to
// WEBSTREAM_SAMPLE_TYPE_FILE = 0x0001 or
// WEBSTREAM_SAMPLE_TYPE_RENDER = 0x0002
wszURL : array[0..0] of WCHAR; // Variable length string data containing file url
end;
{$EXTERNALSYM _WMT_WEBSTREAM_SAMPLE_HEADER}
WMT_WEBSTREAM_SAMPLE_HEADER = _WMT_WEBSTREAM_SAMPLE_HEADER;
{$EXTERNALSYM WMT_WEBSTREAM_SAMPLE_HEADER}
TWMTWebStreamSampleHeader = _WMT_WEBSTREAM_SAMPLE_HEADER;
PWMAddressAccessEntry = ^TWMAddressAccessEntry;
_WMAddressAccessEntry = packed record
dwIPAddress : LongWord;
dwMask : LongWord;
end;
{$EXTERNALSYM _WMAddressAccessEntry}
WM_ADDRESS_ACCESSENTRY = _WMAddressAccessEntry;
{$EXTERNALSYM WM_ADDRESS_ACCESSENTRY}
TWMAddressAccessEntry = _WMAddressAccessEntry;
///////////////////////////////////////////////////////////////////////////////
//
// Structures for complex metadata attributes
//
///////////////////////////////////////////////////////////////////////////////
PWMPicture = ^TWMPicture;
_WMPicture = packed record
pwszMIMEType : PWideChar;
bPictureType : BYTE;
pwszDescription : PWideChar;
dwDataLen : LongWord;
pbData : PBYTE;
end;
{$EXTERNALSYM _WMPicture}
WM_PICTURE = _WMPicture;
{$EXTERNALSYM WM_PICTURE}
TWMPicture = _WMPicture;
PWMSynchronisedLyrics = ^TWMSynchronisedLyrics;
_WMSynchronisedLyrics = packed record
bTimeStampFormat : BYTE;
bContentType : BYTE;
pwszContentDescriptor : PWideChar;
dwLyricsLen : LongWord;
pbLyrics : PBYTE;
end;
{$EXTERNALSYM _WMSynchronisedLyrics}
WM_SYNCHRONISED_LYRICS = _WMSynchronisedLyrics;
{$EXTERNALSYM WM_SYNCHRONISED_LYRICS}
TWMSynchronisedLyrics = _WMSynchronisedLyrics;
PWMUserWebURL = ^TWMUserWebURL;
_WMUserWebURL = packed record
pwszDescription : PWideChar;
pwszURL : PWideChar;
end;
{$EXTERNALSYM _WMUserWebURL}
WM_USER_WEB_URL = _WMUserWebURL;
{$EXTERNALSYM WM_USER_WEB_URL}
TWMUserWebURL = _WMUserWebURL;
PWMUserText = ^TWMUserText;
_WMUserText = packed record
pwszDescription : PWideChar;
pwszText : PWideChar;
end;
{$EXTERNALSYM _WMUserText}
WM_USER_TEXT = _WMUserText;
{$EXTERNALSYM WM_USER_TEXT}
TWMUserText = _WMUserText;
PWMLeakyBucketPair = ^TWMLeakyBucketPair;
_WMLeakyBucketPair = packed record
dwBitrate : LongWord;
msBufferWindow : LongWord;
end;
{$EXTERNALSYM _WMLeakyBucketPair}
WM_LEAKY_BUCKET_PAIR = _WMLeakyBucketPair;
{$EXTERNALSYM WM_LEAKY_BUCKET_PAIR}
TWMLeakyBucketPair = _WMLeakyBucketPair;
///////////////////////////////////////////////////////////////////////////////
//
// Structure needed for using GetDRMProperty.
//
///////////////////////////////////////////////////////////////////////////////
PWMLicenseStateData = ^TWMLicenseStateData;
_WM_LICENSE_STATE_DATA = packed record
dwSize : LongWord; // Size of the entire structure.
dwNumStates : LongWord; // Number of state data passed back in array of structure below
stateData : array[0..0] of TDRMLicenseStateData;
end;
{$EXTERNALSYM _WM_LICENSE_STATE_DATA}
WM_LICENSE_STATE_DATA = _WM_LICENSE_STATE_DATA;
{$EXTERNALSYM WM_LICENSE_STATE_DATA}
TWMLicenseStateData = _WM_LICENSE_STATE_DATA;
///////////////////////////////////////////////////////////////////////////////
// Watermark entry
///////////////////////////////////////////////////////////////////////////////
PWMTWatermarkEntry = ^TWMTWatermarkEntry;
__WMT_WATERMARK_ENTRY = packed record
wmetType : TWMTWatermarkEntryType;
clsid : TGUID;
cbDisplayName : UINT;
pwszDisplayName : PWideChar;
end;
{$EXTERNALSYM __WMT_WATERMARK_ENTRY}
WMT_WATERMARK_ENTRY = __WMT_WATERMARK_ENTRY;
{$EXTERNALSYM WMT_WATERMARK_ENTRY}
TWMTWatermarkEntry = __WMT_WATERMARK_ENTRY;
///////////////////////////////////////////////////////////////////////////////
// VideoImage structs
///////////////////////////////////////////////////////////////////////////////
//
// dwControlFlags
//
const
WMT_VIDEOIMAGE_SAMPLE_INPUT_FRAME = 1; // sample has input frame
{$EXTERNALSYM WMT_VIDEOIMAGE_SAMPLE_INPUT_FRAME}
WMT_VIDEOIMAGE_SAMPLE_OUTPUT_FRAME = 2; // sample produces output frame
{$EXTERNALSYM WMT_VIDEOIMAGE_SAMPLE_OUTPUT_FRAME}
WMT_VIDEOIMAGE_SAMPLE_USES_CURRENT_INPUT_FRAME = 4;
{$EXTERNALSYM WMT_VIDEOIMAGE_SAMPLE_USES_CURRENT_INPUT_FRAME}
WMT_VIDEOIMAGE_SAMPLE_USES_PREVIOUS_INPUT_FRAME = 8;
{$EXTERNALSYM WMT_VIDEOIMAGE_SAMPLE_USES_PREVIOUS_INPUT_FRAME}
//
// dwInputFlags
//
WMT_VIDEOIMAGE_SAMPLE_MOTION = 1; // acef used (includes resizing)
{$EXTERNALSYM WMT_VIDEOIMAGE_SAMPLE_MOTION}
WMT_VIDEOIMAGE_SAMPLE_ROTATION = 2; // bd also used (not valid without acef)
{$EXTERNALSYM WMT_VIDEOIMAGE_SAMPLE_ROTATION}
WMT_VIDEOIMAGE_SAMPLE_BLENDING = 4; // BlendCoef1 used
{$EXTERNALSYM WMT_VIDEOIMAGE_SAMPLE_BLENDING}
WMT_VIDEOIMAGE_SAMPLE_ADV_BLENDING = 8; // BlendCoef2 also used (not valid without BlendCoef1)
{$EXTERNALSYM WMT_VIDEOIMAGE_SAMPLE_ADV_BLENDING}
WMT_VIDEOIMAGE_INTEGER_DENOMINATOR = 65536;
{$EXTERNALSYM WMT_VIDEOIMAGE_INTEGER_DENOMINATOR}
WMT_VIDEOIMAGE_MAGIC_NUMBER = $1d4a45f2;
{$EXTERNALSYM WMT_VIDEOIMAGE_MAGIC_NUMBER}
type
PWMTVideoImageSample = ^TWMTVideoImageSample;
__WMT_VIDEOIMAGE_SAMPLE = packed record
dwMagic : LongWord;
cbStruct : ULONG; // size of structure; incudes dwMagic and cbStruct
dwControlFlags : LongWord;
//
// most recent input frame
//
dwInputFlagsCur : LongWord;
lCurMotionXtoX : LongInt; // a
lCurMotionYtoX : LongInt; // b
lCurMotionXoffset : LongInt; // c
lCurMotionXtoY : LongInt; // d
lCurMotionYtoY : LongInt; // e
lCurMotionYoffset : LongInt; // f
lCurBlendCoef1 : LongInt;
lCurBlendCoef2 : LongInt;
//
// second most recent input frame
//
dwInputFlagsPrev : LongWord;
lPrevMotionXtoX : LongInt; // a
lPrevMotionYtoX : LongInt; // b
lPrevMotionXoffset : LongInt; // c
lPrevMotionXtoY : LongInt; // d
lPrevMotionYtoY : LongInt; // e
lPrevMotionYoffset : LongInt; // f
lPrevBlendCoef1 : LongInt;
lPrevBlendCoef2 : LongInt;
end;
{$EXTERNALSYM __WMT_VIDEOIMAGE_SAMPLE}
WMT_VIDEOIMAGE_SAMPLE = __WMT_VIDEOIMAGE_SAMPLE;
{$EXTERNALSYM WMT_VIDEOIMAGE_SAMPLE}
TWMTVideoImageSample = __WMT_VIDEOIMAGE_SAMPLE;
///////////////////////////////////////////////////////////////////////////////
//
// 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!
//
PWMMediaType = ^TWMMediaType;
_WMMediaType = packed record
majortype : TGUID;
subtype : TGUID;
bFixedSizeSamples : BOOL;
bTemporalCompression : BOOL;
lSampleSize : ULONG;
formattype : TGUID;
pUnk : IUnknown;
cbFormat : ULONG;
pbFormat : PBYTE; // size_is(cbFormat)
end;
{$EXTERNALSYM _WMMediaType}
WM_MEDIA_TYPE = _WMMediaType;
{$EXTERNALSYM WM_MEDIA_TYPE}
TWMMediaType = _WMMediaType;
PWMVideoInfoHeader = ^TWMVideoInfoHeader;
tagWMVIDEOINFOHEADER = packed record
rcSource : TRECT; // The bit we really want to use.
rcTarget : TRECT; // Where the video should go.
dwBitRate : LongWord; // Approximate bit data rate.
dwBitErrorRate : LongWord; // Bit error rate for this stream.
AvgTimePerFrame : Int64; // Average time per frame (100ns units).
bmiHeader : TBitmapInfoHeader;
end;
{$EXTERNALSYM tagWMVIDEOINFOHEADER}
WMVIDEOINFOHEADER = tagWMVIDEOINFOHEADER;
{$EXTERNALSYM WMVIDEOINFOHEADER}
TWMVideoInfoHeader = tagWMVIDEOINFOHEADER;
PWMVideoInfoHeader2 = ^TWMVideoInfoHeader2;
tagWMVIDEOINFOHEADER2 = packed record
rcSource : TRECT; // The bit we really want to use.
rcTarget : TRECT; // Where the video should go.
dwBitRate : LongWord; // Approximate bit data rate.
dwBitErrorRate : LongWord; // Bit error rate for this stream.
AvgTimePerFrame : Int64; // Average time per frame (100ns units).
dwInterlaceFlags : LongWord; // Use AMINTERLACE_* defines. Reject connection if undefined bits are not 0.
dwCopyProtectFlags : LongWord; // use AMCOPYPROTECT_* defines. Reject connection if undefined bits are not 0.
dwPictAspectRatioX : LongWord; // X dimension of picture aspect ratio, e.g. 16 for 16x9 display.
dwPictAspectRatioY : LongWord; // Y dimension of picture aspect ratio, e.g. 9 for 16x9 display.
dwReserved1 : LongWord; // Must be 0; reject connection otherwise.
dwReserved2 : LongWord; // Must be 0; reject connection otherwise.
bmiHeader : TBitmapInfoHeader;
end;
{$EXTERNALSYM tagWMVIDEOINFOHEADER2}
WMVIDEOINFOHEADER2 = tagWMVIDEOINFOHEADER2;
{$EXTERNALSYM WMVIDEOINFOHEADER2}
TWMVideoInfoHeader2 = tagWMVIDEOINFOHEADER2;
PWMMPEG2VideoInfo = ^TWMMPEG2VideoInfo;
tagWMMPEG2VIDEOINFO = packed record
hdr : TWMVideoInfoHeader2; // Video info header2.
dwStartTimeCode : LongWord; // Not used for DVD.
cbSequenceHeader : LongWord; // Is 0 for DVD (no sequence header).
dwProfile : LongWord; // Use enum MPEG2Profile.
dwLevel : LongWord; // Use enum MPEG2Level.
dwFlags : LongWord; // Use AMMPEG2_* defines. Reject connection if undefined bits are not 0.
dwSequenceHeader : array[0..0] of LongWord; // Sequence header.
end;
{$EXTERNALSYM tagWMMPEG2VIDEOINFO}
WMMPEG2VIDEOINFO = tagWMMPEG2VIDEOINFO;
{$EXTERNALSYM WMMPEG2VIDEOINFO}
TWMMPEG2VideoInfo = tagWMMPEG2VIDEOINFO;
PWMScriptFormat = ^TWMScriptFormat;
tagWMSCRIPTFORMAT = packed record
scriptType: TGUID;
end;
{$EXTERNALSYM tagWMSCRIPTFORMAT}
WMSCRIPTFORMAT = tagWMSCRIPTFORMAT;
{$EXTERNALSYM WMSCRIPTFORMAT}
TWMScriptFormat = tagWMSCRIPTFORMAT;
//
// This special GUID is used to create a subtype from an audio format tag, or
// video four-character code. Just fill in the first LongWord of the GUID with
// the appropriate value.
//
const
WMMEDIASUBTYPE_Base : TGUID = '{00000000-0000-0010-8000-00AA00389B71}';
{$EXTERNALSYM WMMEDIASUBTYPE_Base}
WMMEDIATYPE_Video : TGUID = '{73646976-0000-0010-8000-00AA00389B71}'; // 'vids'
{$EXTERNALSYM WMMEDIATYPE_Video}
WMMEDIASUBTYPE_RGB1 : TGUID = '{e436eb78-524f-11ce-9f53-0020af0ba770}';
{$EXTERNALSYM WMMEDIASUBTYPE_RGB1}
WMMEDIASUBTYPE_RGB4 : TGUID = '{e436eb79-524f-11ce-9f53-0020af0ba770}';
{$EXTERNALSYM WMMEDIASUBTYPE_RGB4}
WMMEDIASUBTYPE_RGB8 : TGUID = '{e436eb7a-524f-11ce-9f53-0020af0ba770}';
{$EXTERNALSYM WMMEDIASUBTYPE_RGB8}
WMMEDIASUBTYPE_RGB565 : TGUID = '{e436eb7b-524f-11ce-9f53-0020af0ba770}';
{$EXTERNALSYM WMMEDIASUBTYPE_RGB565}
WMMEDIASUBTYPE_RGB555 : TGUID = '{e436eb7c-524f-11ce-9f53-0020af0ba770}';
{$EXTERNALSYM WMMEDIASUBTYPE_RGB555}
WMMEDIASUBTYPE_RGB24 : TGUID = '{e436eb7d-524f-11ce-9f53-0020af0ba770}';
{$EXTERNALSYM WMMEDIASUBTYPE_RGB24}
WMMEDIASUBTYPE_RGB32 : TGUID = '{e436eb7e-524f-11ce-9f53-0020af0ba770}';
{$EXTERNALSYM WMMEDIASUBTYPE_RGB32}
WMMEDIASUBTYPE_I420 : TGUID = '{30323449-0000-0010-8000-00AA00389B71}'; // 'YV12'
{$EXTERNALSYM WMMEDIASUBTYPE_I420}
WMMEDIASUBTYPE_IYUV : TGUID = '{56555949-0000-0010-8000-00AA00389B71}'; // 'YV12'
{$EXTERNALSYM WMMEDIASUBTYPE_IYUV}
WMMEDIASUBTYPE_YV12 : TGUID = '{31313259-0000-0010-8000-00AA00389B71}'; // 'YV12'
{$EXTERNALSYM WMMEDIASUBTYPE_YV12}
WMMEDIASUBTYPE_YUY2 : TGUID = '{32595559-0000-0010-8000-00AA00389B71}'; // 'YUY2'
{$EXTERNALSYM WMMEDIASUBTYPE_YUY2}
WMMEDIASUBTYPE_UYVY : TGUID = '{59565955-0000-0010-8000-00AA00389B71}'; // 'UYVY'
{$EXTERNALSYM WMMEDIASUBTYPE_UYVY}
WMMEDIASUBTYPE_YVYU : TGUID = '{55595659-0000-0010-8000-00AA00389B71}'; // 'YVYU'
{$EXTERNALSYM WMMEDIASUBTYPE_YVYU}
WMMEDIASUBTYPE_YVU9 : TGUID = '{39555659-0000-0010-8000-00AA00389B71}'; // 'YVU9'
{$EXTERNALSYM WMMEDIASUBTYPE_YVU9}
WMMEDIASUBTYPE_VIDEOIMAGE : TGUID = '{1d4a45f2-e5f6-4b44-8388-f0ae5c0e0c37}';
{$EXTERNALSYM WMMEDIASUBTYPE_VIDEOIMAGE}
WMMEDIASUBTYPE_MP43 : TGUID = '{3334504D-0000-0010-8000-00AA00389B71}';
{$EXTERNALSYM WMMEDIASUBTYPE_MP43}
WMMEDIASUBTYPE_MP4S : TGUID = '{5334504D-0000-0010-8000-00AA00389B71}';
{$EXTERNALSYM WMMEDIASUBTYPE_MP4S}
WMMEDIASUBTYPE_WMV1 : TGUID = '{31564D57-0000-0010-8000-00AA00389B71}';
{$EXTERNALSYM WMMEDIASUBTYPE_WMV1}
WMMEDIASUBTYPE_WMV2 : TGUID = '{32564D57-0000-0010-8000-00AA00389B71}';
{$EXTERNALSYM WMMEDIASUBTYPE_WMV2}
WMMEDIASUBTYPE_MSS1 : TGUID = '{3153534D-0000-0010-8000-00AA00389B71}';
{$EXTERNALSYM WMMEDIASUBTYPE_MSS1}
WMMEDIASUBTYPE_MPEG2_VIDEO : TGUID = '{e06d8026-db46-11cf-b4d1-00805f6cbbea}';
{$EXTERNALSYM WMMEDIASUBTYPE_MPEG2_VIDEO}
WMMEDIATYPE_Audio : TGUID = '{73647561-0000-0010-8000-00AA00389B71}'; // 'auds'
{$EXTERNALSYM WMMEDIATYPE_Audio}
WMMEDIASUBTYPE_PCM : TGUID = '{00000001-0000-0010-8000-00AA00389B71}';
{$EXTERNALSYM WMMEDIASUBTYPE_PCM}
WMMEDIASUBTYPE_DRM : TGUID = '{00000009-0000-0010-8000-00AA00389B71}';
{$EXTERNALSYM WMMEDIASUBTYPE_DRM}
WMMEDIASUBTYPE_WMAudioV9 : TGUID = '{00000162-0000-0010-8000-00AA00389B71}';
{$EXTERNALSYM WMMEDIASUBTYPE_WMAudioV9}
WMMEDIASUBTYPE_WMAudio_Lossless : TGUID = '{00000163-0000-0010-8000-00AA00389B71}';
{$EXTERNALSYM WMMEDIASUBTYPE_WMAudio_Lossless}
WMMEDIASUBTYPE_MSS2 : TGUID = '{3253534D-0000-0010-8000-00AA00389B71}';
{$EXTERNALSYM WMMEDIASUBTYPE_MSS2}
WMMEDIASUBTYPE_WMSP1 : TGUID = '{0000000A-0000-0010-8000-00AA00389B71}';
{$EXTERNALSYM WMMEDIASUBTYPE_WMSP1}
WMMEDIASUBTYPE_WMV3 : TGUID = '{33564D57-0000-0010-8000-00AA00389B71}';
{$EXTERNALSYM WMMEDIASUBTYPE_WMV3}
WMMEDIASUBTYPE_WMVP : TGUID = '{50564D57-0000-0010-8000-00AA00389B71}';
{$EXTERNALSYM WMMEDIASUBTYPE_WMVP}
//
// WM Audio v2 and v7 are actually compatible bitstreams.
//
WMMEDIASUBTYPE_WMAudioV8 : TGUID = '{00000161-0000-0010-8000-00AA00389B71}';
{$EXTERNALSYM WMMEDIASUBTYPE_WMAudioV8}
WMMEDIASUBTYPE_WMAudioV7 : TGUID = '{00000161-0000-0010-8000-00AA00389B71}';
{$EXTERNALSYM WMMEDIASUBTYPE_WMAudioV7}
WMMEDIASUBTYPE_WMAudioV2 : TGUID = '{00000161-0000-0010-8000-00AA00389B71}';
{$EXTERNALSYM WMMEDIASUBTYPE_WMAudioV2}
WMMEDIASUBTYPE_ACELPnet : TGUID = '{00000130-0000-0010-8000-00AA00389B71}';
{$EXTERNALSYM WMMEDIASUBTYPE_ACELPnet}
WMMEDIASUBTYPE_MP3 : TGUID = '{00000050-0000-0010-8000-00AA00389B71}';
{$EXTERNALSYM WMMEDIASUBTYPE_MP3}
WMMEDIASUBTYPE_WebStream : TGUID = '{776257d4-c627-41cb-8f81-7ac7ff1c40cc}';
{$EXTERNALSYM WMMEDIASUBTYPE_WebStream}
WMMEDIATYPE_Script : TGUID = '{73636d64-0000-0010-8000-00AA00389B71}'; // 'scmd'
{$EXTERNALSYM WMMEDIATYPE_Script}
WMMEDIATYPE_Image : TGUID = '{34A50FD8-8AA5-4386-81FE-A0EFE0488E31}'; // 'imag'
{$EXTERNALSYM WMMEDIATYPE_Image}
WMMEDIATYPE_FileTransfer : TGUID = '{D9E47579-930E-4427-ADFC-AD80F290E470}'; // 'fxfr'
{$EXTERNALSYM WMMEDIATYPE_FileTransfer}
WMMEDIATYPE_Text : TGUID = '{9BBA1EA7-5AB2-4829-BA57-0940209BCF3E}'; // 'text'
{$EXTERNALSYM WMMEDIATYPE_Text}
WMFORMAT_VideoInfo : TGUID = '{05589f80-c356-11ce-bf01-00aa0055595a}';
{$EXTERNALSYM WMFORMAT_VideoInfo}
WMFORMAT_MPEG2Video : TGUID = '{e06d80e3-db46-11cf-b4d1-00805f6cbbea}';
{$EXTERNALSYM WMFORMAT_MPEG2Video}
WMFORMAT_WaveFormatEx : TGUID = '{05589f81-c356-11ce-bf01-00aa0055595a}';
{$EXTERNALSYM WMFORMAT_WaveFormatEx}
WMFORMAT_Script : TGUID = '{5C8510F2-DEBE-4ca7-BBA5-F07A104F8DFF}';
{$EXTERNALSYM WMFORMAT_Script}
WMFORMAT_WebStream : TGUID = '{da1e6b13-8359-4050-b398-388e965bf00c}';
{$EXTERNALSYM WMFORMAT_WebStream}
WMSCRIPTTYPE_TwoStrings : TGUID = '{82f38a70-c29f-11d1-97ad-00a0c95ea850}';
{$EXTERNALSYM WMSCRIPTTYPE_TwoStrings}
//////////////////////////////////////////////////////////////////////////////
//
// GUIDs for common buffer properties
//
WM_SampleExtensionGUID_OutputCleanPoint : TGUID = '{f72a3c6f-6eb4-4ebc-b192-09ad9759e828}';
{$EXTERNALSYM WM_SampleExtensionGUID_OutputCleanPoint}
WM_SampleExtensionGUID_Timecode : TGUID = '{399595ec-8667-4e2d-8fdb-98814ce76c1e}';
{$EXTERNALSYM WM_SampleExtensionGUID_Timecode}
//
// This buffer property is used in conjunction with file transfer streams.
// It is the name of the file being transfered (in WCHARs).
//
WM_SampleExtensionGUID_FileName : TGUID = '{e165ec0e-19ed-45d7-b4a7-25cbd1e28e9b}';
{$EXTERNALSYM WM_SampleExtensionGUID_FileName}
WM_SampleExtensionGUID_ContentType : TGUID = '{d590dc20-07bc-436c-9cf7-f3bbfbf1a4dc}';
{$EXTERNALSYM WM_SampleExtensionGUID_ContentType}
WM_SampleExtensionGUID_PixelAspectRatio : TGUID = '{1b1ee554-f9ea-4bc8-821a-376b74e4c4b8}';
{$EXTERNALSYM WM_SampleExtensionGUID_PixelAspectRatio}
WM_SampleExtensionGUID_SampleDuration : TGUID = '{c6bd9450-867f-4907-83a3-c77921b733ad}';
{$EXTERNALSYM WM_SampleExtensionGUID_SampleDuration}
//
// Constants for use with the corresponding sample extension properties
//
WM_SampleExtension_ContentType_Size = 1;
{$EXTERNALSYM WM_SampleExtension_ContentType_Size}
WM_SampleExtension_PixelAspectRatio_Size = 2;
{$EXTERNALSYM WM_SampleExtension_PixelAspectRatio_Size}
WM_SampleExtension_Timecode_Size = 14;
{$EXTERNALSYM WM_SampleExtension_Timecode_Size}
WM_SampleExtension_SampleDuration_Size = 2;
{$EXTERNALSYM WM_SampleExtension_SampleDuration_Size}
///////////////////////////////////////////////////////////////////////////////
//
// Content Types to be used with WM_SampleExtensionGUID_ContentType
// on INSSBuffer3::SetProperty/GetProperty
//
///////////////////////////////////////////////////////////////////////////////
WM_CT_INTERLACED = 128;
{$EXTERNALSYM WM_CT_INTERLACED}
WM_CT_BOTTOM_FIELD_FIRST = 32;
{$EXTERNALSYM WM_CT_BOTTOM_FIELD_FIRST}
WM_CT_TOP_FIELD_FIRST = 64;
{$EXTERNALSYM WM_CT_TOP_FIELD_FIRST}
///////////////////////////////////////////////////////////////////////////////
//
// Timecode structures to be used with WM_SampleExtensionGUID_Timecode
// on INSSBuffer3::SetProperty/GetProperty. The timecode LongWord
// contains the following timecode representation:
//
// BYTE MSB LSB
// ----------------------------------------------
// 1 Tens of hour Hour
// 2 Tens of minute Minute
// 3 Tens of second Second
// 4 Tens of frame Frame
//
///////////////////////////////////////////////////////////////////////////////
type
PWMTTimeCodeExtensionData = ^TWMTTimeCodeExtensionData;
_WMT_TIMECODE_EXTENSION_DATA = packed record
wRange : Word;
dwTimecode : LongWord;
dwUserbits : LongWord;
dwAmFlags : LongWord;
end;
{$EXTERNALSYM _WMT_TIMECODE_EXTENSION_DATA}
WMT_TIMECODE_EXTENSION_DATA = _WMT_TIMECODE_EXTENSION_DATA;
{$EXTERNALSYM WMT_TIMECODE_EXTENSION_DATA}
TWMTTimeCodeExtensionData = _WMT_TIMECODE_EXTENSION_DATA;
///////////////////////////////////////////////////////////////////////////////
//
// IID GUIDs defined here.
//
///////////////////////////////////////////////////////////////////////////////
const
IID_IWMMediaProps : TGUID = '{96406bce-2b2b-11d3-b36b-00c04f6108ff}';
{$EXTERNALSYM IID_IWMMediaProps}
IID_IWMVideoMediaProps : TGUID = '{96406bcf-2b2b-11d3-b36b-00c04f6108ff}';
{$EXTERNALSYM IID_IWMVideoMediaProps}
IID_IWMWriter : TGUID = '{96406bd4-2b2b-11d3-b36b-00c04f6108ff}';
{$EXTERNALSYM IID_IWMWriter}
IID_IWMInputMediaProps : TGUID = '{96406bd5-2b2b-11d3-b36b-00c04f6108ff}';
{$EXTERNALSYM IID_IWMInputMediaProps}
IID_IWMReader : TGUID = '{96406bd6-2b2b-11d3-b36b-00c04f6108ff}';
{$EXTERNALSYM IID_IWMReader}
IID_IWMSyncReader : TGUID = '{9397f121-7705-4dc9-b049-98b698188414}';
{$EXTERNALSYM IID_IWMSyncReader}
IID_IWMSyncReader2 : TGUID = '{faed3d21-1b6b-4af7-8cb6-3e189bbc187b}';
{$EXTERNALSYM IID_IWMSyncReader2}
IID_IWMOutputMediaProps : TGUID = '{96406bd7-2b2b-11d3-b36b-00c04f6108ff}';
{$EXTERNALSYM IID_IWMOutputMediaProps}
IID_IWMStatusCallback : TGUID = '{6d7cdc70-9888-11d3-8edc-00c04f6109cf}';
{$EXTERNALSYM IID_IWMStatusCallback}
IID_IWMReaderCallback : TGUID = '{96406bd8-2b2b-11d3-b36b-00c04f6108ff}';
{$EXTERNALSYM IID_IWMReaderCallback}
IID_IWMCredentialCallback : TGUID = '{342e0eb7-e651-450c-975b-2ace2c90c48e}';
{$EXTERNALSYM IID_IWMCredentialCallback}
IID_IWMMetadataEditor : TGUID = '{96406bd9-2b2b-11d3-b36b-00c04f6108ff}';
{$EXTERNALSYM IID_IWMMetadataEditor}
IID_IWMMetadataEditor2 : TGUID = '{203cffe3-2e18-4fdf-b59d-6e71530534cf}';
{$EXTERNALSYM IID_IWMMetadataEditor2}
IID_IWMDRMEditor : TGUID = '{FF130EBC-A6C3-42A6-B401-C3382C3E08B3}';
{$EXTERNALSYM IID_IWMDRMEditor}
IID_IWMHeaderInfo : TGUID = '{96406bda-2b2b-11d3-b36b-00c04f6108ff}';
{$EXTERNALSYM IID_IWMHeaderInfo}
IID_IWMHeaderInfo2 : TGUID = '{15cf9781-454e-482e-b393-85fae487a810}';
{$EXTERNALSYM IID_IWMHeaderInfo2}
IID_IWMHeaderInfo3 : TGUID = '{15CC68E3-27CC-4ecd-B222-3F5D02D80BD5}';
{$EXTERNALSYM IID_IWMHeaderInfo3}
IID_IWMProfileManager : TGUID = '{d16679f2-6ca0-472d-8d31-2f5d55aee155}';
{$EXTERNALSYM IID_IWMProfileManager}
IID_IWMProfileManager2 : TGUID = '{7a924e51-73c1-494d-8019-23d37ed9b89a}';
{$EXTERNALSYM IID_IWMProfileManager2}
IID_IWMProfileManagerLanguage : TGUID = '{ba4dcc78-7ee0-4ab8-b27a-dbce8bc51454}';
{$EXTERNALSYM IID_IWMProfileManagerLanguage}
IID_IWMProfile : TGUID = '{96406bdb-2b2b-11d3-b36b-00c04f6108ff}';
{$EXTERNALSYM IID_IWMProfile}
IID_IWMProfile2 : TGUID = '{07e72d33-d94e-4be7-8843-60ae5ff7e5f5}';
{$EXTERNALSYM IID_IWMProfile2}
IID_IWMProfile3 : TGUID = '{00ef96cc-a461-4546-8bcd-c9a28f0e06f5}';
{$EXTERNALSYM IID_IWMProfile3}
IID_IWMStreamConfig : TGUID = '{96406bdc-2b2b-11d3-b36b-00c04f6108ff}';
{$EXTERNALSYM IID_IWMStreamConfig}
IID_IWMStreamConfig2 : TGUID = '{7688d8cb-fc0d-43bd-9459-5a8dec200cfa}';
{$EXTERNALSYM IID_IWMStreamConfig2}
IID_IWMStreamConfig3 : TGUID = '{cb164104-3aa9-45a7-9ac9-4daee131d6e1}';
{$EXTERNALSYM IID_IWMStreamConfig3}
IID_IWMStreamList : TGUID = '{96406bdd-2b2b-11d3-b36b-00c04f6108ff}';
{$EXTERNALSYM IID_IWMStreamList}
IID_IWMMutualExclusion : TGUID = '{96406bde-2b2b-11d3-b36b-00c04f6108ff}';
{$EXTERNALSYM IID_IWMMutualExclusion}
IID_IWMMutualExclusion2 : TGUID = '{0302b57d-89d1-4ba2-85c9-166f2c53eb91}';
{$EXTERNALSYM IID_IWMMutualExclusion2}
IID_IWMBandwidthSharing : TGUID = '{ad694af1-f8d9-42f8-bc47-70311b0c4f9e}';
{$EXTERNALSYM IID_IWMBandwidthSharing}
IID_IWMStreamPrioritization : TGUID = '{8c1c6090-f9a8-4748-8ec3-dd1108ba1e77}';
{$EXTERNALSYM IID_IWMStreamPrioritization}
IID_IWMWriterAdvanced : TGUID = '{96406be3-2b2b-11d3-b36b-00c04f6108ff}';
{$EXTERNALSYM IID_IWMWriterAdvanced}
IID_IWMWriterAdvanced2 : TGUID = '{962dc1ec-c046-4db8-9cc7-26ceae500817}';
{$EXTERNALSYM IID_IWMWriterAdvanced2}
IID_IWMWriterAdvanced3 : TGUID = '{2cd6492d-7c37-4e76-9d3b-59261183a22e}';
{$EXTERNALSYM IID_IWMWriterAdvanced3}
IID_IWMWriterPreprocess : TGUID = '{fc54a285-38c4-45b5-aa23-85b9f7cb424b}';
{$EXTERNALSYM IID_IWMWriterPreprocess}
IID_IWMWriterSink : TGUID = '{96406be4-2b2b-11d3-b36b-00c04f6108ff}';
{$EXTERNALSYM IID_IWMWriterSink}
IID_IWMWriterFileSink : TGUID = '{96406be5-2b2b-11d3-b36b-00c04f6108ff}';
{$EXTERNALSYM IID_IWMWriterFileSink}
IID_IWMWriterFileSink2 : TGUID = '{14282ba7-4aef-4205-8ce5-c229035a05bc}';
{$EXTERNALSYM IID_IWMWriterFileSink2}
IID_IWMWriterFileSink3 : TGUID = '{3fea4feb-2945-47a7-a1dd-c53a8fc4c45c}';
{$EXTERNALSYM IID_IWMWriterFileSink3}
IID_IWMWriterNetworkSink : TGUID = '{96406be7-2b2b-11d3-b36b-00c04f6108ff}';
{$EXTERNALSYM IID_IWMWriterNetworkSink}
IID_IWMClientConnections : TGUID = '{73c66010-a299-41df-b1f0-ccf03b09c1c6}';
{$EXTERNALSYM IID_IWMClientConnections}
IID_IWMClientConnections2 : TGUID = '{4091571e-4701-4593-bb3d-d5f5f0c74246}';
{$EXTERNALSYM IID_IWMClientConnections2}
IID_IWMReaderAdvanced : TGUID = '{96406bea-2b2b-11d3-b36b-00c04f6108ff}';
{$EXTERNALSYM IID_IWMReaderAdvanced}
IID_IWMReaderAdvanced2 : TGUID = '{ae14a945-b90c-4d0d-9127-80d665f7d73e}';
{$EXTERNALSYM IID_IWMReaderAdvanced2}
IID_IWMReaderAdvanced3 : TGUID = '{5dc0674b-f04b-4a4e-9f2a-b1afde2c8100}';
{$EXTERNALSYM IID_IWMReaderAdvanced3}
IID_IWMReaderAdvanced4 : TGUID = '{945a76a2-12ae-4d48-bd3c-cd1d90399b85}';
{$EXTERNALSYM IID_IWMReaderAdvanced4}
IID_IWMDRMReader : TGUID = '{d2827540-3ee7-432c-b14c-dc17f085d3b3}';
{$EXTERNALSYM IID_IWMDRMReader}
IID_IWMReaderCallbackAdvanced : TGUID = '{96406beb-2b2b-11d3-b36b-00c04f6108ff}';
{$EXTERNALSYM IID_IWMReaderCallbackAdvanced}
IID_IWMReaderNetworkConfig : TGUID = '{96406bec-2b2b-11d3-b36b-00c04f6108ff}';
{$EXTERNALSYM IID_IWMReaderNetworkConfig}
IID_IWMReaderStreamClock : TGUID = '{96406bed-2b2b-11d3-b36b-00c04f6108ff}';
{$EXTERNALSYM IID_IWMReaderStreamClock}
IID_IWMIndexer : TGUID = '{6d7cdc71-9888-11d3-8edc-00c04f6109cf}';
{$EXTERNALSYM IID_IWMIndexer}
IID_IWMIndexer2 : TGUID = '{b70f1e42-6255-4df0-a6b9-02b212d9e2bb}';
{$EXTERNALSYM IID_IWMIndexer2}
IID_IWMReaderAllocatorEx : TGUID = '{9f762fa7-a22e-428d-93c9-ac82f3aafe5a}';
{$EXTERNALSYM IID_IWMReaderAllocatorEx}
IID_IWMReaderTypeNegotiation : TGUID = '{fdbe5592-81a1-41ea-93bd-735cad1adc05}';
{$EXTERNALSYM IID_IWMReaderTypeNegotiation}
IID_IWMLicenseBackup : TGUID = '{05E5AC9F-3FB6-4508-BB43-A4067BA1EBE8}';
{$EXTERNALSYM IID_IWMLicenseBackup}
IID_IWMLicenseRestore : TGUID = '{C70B6334-a22e-4efb-A245-15E65A004A13}';
{$EXTERNALSYM IID_IWMLicenseRestore}
IID_IWMBackupRestoreProps : TGUID = '{3C8E0DA6-996F-4ff3-A1AF-4838F9377e2e}';
{$EXTERNALSYM IID_IWMBackupRestoreProps}
IID_IWMPacketSize : TGUID = '{cdfb97ab-188f-40b3-b643-5b7903975c59}';
{$EXTERNALSYM IID_IWMPacketSize}
IID_IWMPacketSize2 : TGUID = '{8bfc2b9e-b646-4233-a877-1c6a079669dc}';
{$EXTERNALSYM IID_IWMPacketSize2}
IID_IWMRegisterCallback : TGUID = '{cf4b1f99-4de2-4e49-a363-252740d99bc1}';
{$EXTERNALSYM IID_IWMRegisterCallback}
IID_IWMWriterPostView : TGUID = '{81e20ce4-75ef-491a-8004-fc53c45bdc3e}';
{$EXTERNALSYM IID_IWMWriterPostView}
IID_IWMWriterPostViewCallback : TGUID = '{d9d6549d-a193-4f24-b308-03123d9b7f8d}';
{$EXTERNALSYM IID_IWMWriterPostViewCallback}
IID_IWMCodecInfo : TGUID = '{a970f41e-34de-4a98-b3ba-e4b3ca7528f0}';
{$EXTERNALSYM IID_IWMCodecInfo}
IID_IWMCodecInfo2 : TGUID = '{aa65e273-b686-4056-91ec-dd768d4df710}';
{$EXTERNALSYM IID_IWMCodecInfo2}
IID_IWMCodecInfo3 : TGUID = '{7e51f487-4d93-4f98-8ab4-27d0565adc51}';
{$EXTERNALSYM IID_IWMCodecInfo3}
IID_IWMPropertyVault : TGUID = '{72995A79-5090-42a4-9C8C-D9D0B6D34BE5}';
{$EXTERNALSYM IID_IWMPropertyVault}
IID_IWMIStreamProps : TGUID = '{6816dad3-2b4b-4c8e-8149-874c3483a753}';
{$EXTERNALSYM IID_IWMIStreamProps}
IID_IWMLanguageList : TGUID = '{df683f00-2d49-4d8e-92b7-fb19f6a0dc57}';
{$EXTERNALSYM IID_IWMLanguageList}
IID_IWMDRMWriter : TGUID = '{d6ea5dd0-12a0-43f4-90ab-a3fd451e6a07}';
{$EXTERNALSYM IID_IWMDRMWriter}
IID_IWMWriterPushSink : TGUID = '{dc10e6a5-072c-467d-bf57-6330a9dde12a}';
{$EXTERNALSYM IID_IWMWriterPushSink}
IID_IWMReaderNetworkConfig2 : TGUID = '{d979a853-042b-4050-8387-c939db22013f}';
{$EXTERNALSYM IID_IWMReaderNetworkConfig2}
IID_IWMWatermarkInfo : TGUID = '{6f497062-f2e2-4624-8ea7-9dd40d81fc8d}';
{$EXTERNALSYM IID_IWMWatermarkInfo}
IID_IWMReaderAccelerator : TGUID = '{bddc4d08-944d-4d52-a612-46c3fda07dd4}';
{$EXTERNALSYM IID_IWMReaderAccelerator}
IID_IWMReaderTimecode : TGUID = '{f369e2f0-e081-4fe6-8450-b810b2f410d1}';
{$EXTERNALSYM IID_IWMReaderTimecode}
IID_IWMImageInfo : TGUID = '{9f0aa3b6-7267-4d89-88f2-ba915aa5c4c6}';
{$EXTERNALSYM IID_IWMImageInfo}
IID_IWMAddressAccess : TGUID = '{BB3C6389-1633-4e92-AF14-9F3173BA39D0}';
{$EXTERNALSYM IID_IWMAddressAccess}
IID_IWMAddressAccess2 : TGUID = '{65a83fc2-3e98-4d4d-81b5-2a742886b33d}';
{$EXTERNALSYM IID_IWMAddressAccess2}
///////////////////////////////////////////////////////////////////////////////
//
// Other GUIDs defined here
//
///////////////////////////////////////////////////////////////////////////////
CLSID_WMMUTEX_Language : TGUID = '{D6E22A00-35DA-11D1-9034-00A0C90349BE}';
{$EXTERNALSYM CLSID_WMMUTEX_Language}
CLSID_WMMUTEX_Bitrate : TGUID = '{D6E22A01-35DA-11D1-9034-00A0C90349BE}';
{$EXTERNALSYM CLSID_WMMUTEX_Bitrate}
CLSID_WMMUTEX_Presentation : TGUID = '{D6E22A02-35DA-11D1-9034-00A0C90349BE}';
{$EXTERNALSYM CLSID_WMMUTEX_Presentation}
CLSID_WMMUTEX_Unknown : TGUID = '{D6E22A03-35DA-11D1-9034-00A0C90349BE}';
{$EXTERNALSYM CLSID_WMMUTEX_Unknown}
CLSID_WMBandwidthSharing_Exclusive : TGUID = '{af6060aa-5197-11d2-b6af-00c04fd908e9}';
{$EXTERNALSYM CLSID_WMBandwidthSharing_Exclusive}
CLSID_WMBandwidthSharing_Partial : TGUID = '{af6060ab-5197-11d2-b6af-00c04fd908e9}';
{$EXTERNALSYM CLSID_WMBandwidthSharing_Partial}
WMT_DMOCATEGORY_AUDIO_WATERMARK : TGUID = '{B42CDE2B-6178-4a2c-A375-89DD3FD7F497}';
{$EXTERNALSYM WMT_DMOCATEGORY_AUDIO_WATERMARK}
WMT_DMOCATEGORY_VIDEO_WATERMARK : TGUID = '{E77797C6-18AF-4458-BBDD-492D3F78FC8F}';
{$EXTERNALSYM WMT_DMOCATEGORY_VIDEO_WATERMARK}
///////////////////////////////////////////////////////////////////////////////
//
// Max Video Streams / Bands
//
///////////////////////////////////////////////////////////////////////////////
WM_MAX_VIDEO_STREAMS = $3f;
{$EXTERNALSYM WM_MAX_VIDEO_STREAMS}
WM_MAX_STREAMS = $3f;
{$EXTERNALSYM WM_MAX_STREAMS}
///////////////////////////////////////////////////////////////////////////////
//
// 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.
//
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//
// 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.
//
type
{$HPPEMIT 'typedef System::DelphiInterface<IWMMediaProps> _di_IWMMediaProps;'}
{$EXTERNALSYM IWMMediaProps}
IWMMediaProps = interface(IUnknown)
['{96406BCE-2B2B-11d3-B36B-00C04F6108FF}']
(*** IWMMediaProps methods ***)
//
// GetType is provided for convenience; it returns the same as the
// majortype of the WM_MEDIA_TYPE.
//
function GetType(out pguidType: TGUID): HRESULT; stdcall;
function GetMediaType(pType: PWMMediaType;
var pcbType: LongWord): HRESULT; stdcall;
function SetMediaType(pType: PWMMediaType): HRESULT; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMVideoMediaProps> _di_IWMVideoMediaProps;'}
{$EXTERNALSYM IWMVideoMediaProps}
IWMVideoMediaProps = interface(IWMMediaProps)
['{96406BCF-2B2B-11d3-B36B-00C04F6108FF}']
(*** IWMVideoMediaProps methods ***)
function GetMaxKeyFrameSpacing(out pllTime: Int64): HRESULT; stdcall;
function SetMaxKeyFrameSpacing(llTime: Int64): HRESULT; stdcall;
function GetQuality(out pdwQuality: LongWord): HRESULT; stdcall;
function SetQuality(dwQuality: LongWord): HRESULT; stdcall;
end;
///////////////////////////////////////////////////////////////////////////////
//
// 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.
//
///////////////////////////////////////////////////////////////////////////////
IWMProfile = interface;
IWMInputMediaProps = interface;
{$HPPEMIT 'typedef System::DelphiInterface<IWMWriter> _di_IWMWriter;'}
{$EXTERNALSYM IWMWriter}
IWMWriter = interface(IUnknown)
['{96406BD4-2B2B-11d3-B36B-00C04F6108FF}']
(*** IWMWriter methods ***)
// 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
//
function SetProfileByID(const guidProfile: TGUID): HRESULT; stdcall;
function SetProfile(pProfile: IWMProfile): HRESULT; stdcall;
//
// The easiest way to use the writer is just to write to file.
//
function SetOutputFilename(pwszFilename: PWideChar): HRESULT; stdcall;
//
// 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.
//
function GetInputCount(out pcInputs: LongWord): HRESULT; stdcall;
function GetInputProps(dwInputNum: LongWord; out ppInput: IWMInputMediaProps): HRESULT; stdcall;
function SetInputProps(dwInputNum: LongWord; pInput: IWMInputMediaProps): HRESULT; stdcall;
//
// Used for determining all possible format types supported by this
// input on the writer.
//
function GetInputFormatCount(dwInputNumber: LongWord; out pcFormats: LongWord): HRESULT; stdcall;
function GetInputFormat(dwInputNumber, dwFormatNumber: LongWord;
out pProps: IWMInputMediaProps): HRESULT; stdcall;
//
// You must call BeginWriting before sending any samples, and
// you must call EndWriting when you're done sending samples.
//
function BeginWriting: HRESULT; stdcall;
//
// EndWriting flushes everything, updates indices and headers,
// and closes the file.
//
function EndWriting: HRESULT; stdcall;
//
// Allocate a sample. This is optional; the user is welcome to allocate
// their own buffer class.
//
function AllocateSample(dwSampleSize: LongWord; out ppSample: INSSBuffer): HRESULT; stdcall;
function WriteSample(dwInputNum: LongWord; cnsSampleTime: Int64; dwFlags: LongWord;
pSample: INSSBuffer): HRESULT; stdcall;
//
// 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.
//
function Flush: HRESULT; stdcall;
end;
//
// The writer can be QI'd for this interface, which provides helpers
// to generate DRM keys.
//
{$HPPEMIT 'typedef System::DelphiInterface<IWMDRMWriter> _di_IWMDRMWriter;'}
{$EXTERNALSYM IWMDRMWriter}
IWMDRMWriter = interface(IUnknown)
['{d6ea5dd0-12a0-43f4-90ab-a3fd451e6a07}']
(*** IWMDRMWriter methods ***)
function GenerateKeySeed({out} pwszKeySeed: PWideChar; var pcwchLength: LongWord): HRESULT; stdcall;
function GenerateKeyID({out} pwszKeyID: PWideChar; var pcwchLength: LongWord): HRESULT; stdcall;
function GenerateSigningKeyPair({out} pwszPrivKey: PWideChar;
var pcwchPrivKeyLength: LongWord;
{out} pwszPubKey: PWideChar;
var pcwchPubKeyLength: LongWord): HRESULT; stdcall;
function SetDRMAttribute(wStreamNum: Word; pszName: PWideChar; Type_: TWMTAttrDataType;
pValue: PBYTE; cbLength: Word): HRESULT; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMInputMediaProps> _di_IWMInputMediaProps;'}
{$EXTERNALSYM IWMInputMediaProps}
IWMInputMediaProps = interface(IWMMediaProps)
['{96406BD5-2B2B-11d3-B36B-00C04F6108FF}']
(*** IWMInputMediaProps methods ***)
function GetConnectionName({out} pwszName: PWideChar; var pcchName: Word): HRESULT; stdcall;
function GetGroupName({out} pwszName: PWideChar; var pcchName: Word): HRESULT; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMPropertyVault> _di_IWMPropertyVault;'}
{$EXTERNALSYM IWMPropertyVault}
IWMPropertyVault = interface(IUnknown)
['{72995A79-5090-42a4-9C8C-D9D0B6D34BE5}']
(*** IWMPropertyVault methods ***)
function GetPropertyCount(out pdwCount: LongWord): HRESULT; stdcall;
function GetPropertyByName(pszName: PWideChar; out pType: TWMTAttrDataType;
{out} pValue: PBYTE; var pdwSize: LongWord): HRESULT; stdcall;
function SetProperty(pszName: PWideChar; pType: TWMTAttrDataType;
pValue: PBYTE; dwSize: LongWord): HRESULT; stdcall;
function GetPropertyByIndex(dwIndex: LongWord; {out} pszName: PWideChar;
var pdwNameLen: LongWord; out pType: TWMTAttrDataType;
{out} pValue: PBYTE; var pdwSize: LongWord): HRESULT; stdcall;
function CopyPropertiesFrom(pIWMPropertyVault: IWMPropertyVault): HRESULT; stdcall;
function Clear: HRESULT; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMIStreamProps> _di_IWMIStreamProps;'}
{$EXTERNALSYM IWMIStreamProps}
IWMIStreamProps = interface(IUnknown)
['{6816dad3-2b4b-4c8e-8149-874c3483a753}']
(*** IWMIStreamProps methods ***)
function GetProperty(pszName: PWideChar; out pType: TWMTAttrDataType;
{out} pValue: PBYTE; var pdwSize: LongWord): HRESULT; stdcall;
end;
///////////////////////////////////////////////////////////////////////////////
//
// 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, until finished.
//
///////////////////////////////////////////////////////////////////////////////
IWMReaderCallback = interface;
IWMOutputMediaProps = interface;
{$HPPEMIT 'typedef System::DelphiInterface<IWMReader> _di_IWMReader;'}
{$EXTERNALSYM IWMReader}
IWMReader = interface(IUnknown)
['{96406BD6-2B2B-11d3-B36B-00C04F6108FF}']
(*** IWMReader methods ***)
//
// 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.
//
function Open(pwszURL: PWideChar; pCallback: IWMReaderCallback;
pvContext: Pointer): HRESULT; stdcall;
function Close: HRESULT; stdcall;
//
// 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.
//
function GetOutputCount(out pcOutputs: LongWord): HRESULT; stdcall;
function GetOutputProps(dwOutputNum: LongWord; out ppOutput: IWMOutputMediaProps): HRESULT; stdcall;
function SetOutputProps(dwOutputNum: LongWord; pOutput: IWMOutputMediaProps): HRESULT; stdcall;
//
// Used for determining all possible format types supported by this
// output on the reader.
//
function GetOutputFormatCount(dwOutputNumber: LongWord; out pcFormats: LongWord): HRESULT; stdcall;
function GetOutputFormat(dwOutputNumber, dwFormatNumber: LongWord;
out ppProps: IWMOutputMediaProps): HRESULT; stdcall;
//
// 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.
//
function Start(cnsStart, cnsDuration: Int64; fRate: Single; pvContext: Pointer): HRESULT; stdcall;
function Stop: HRESULT; stdcall;
function Pause: HRESULT; stdcall;
function Resume: HRESULT; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMSyncReader> _di_IWMSyncReader;'}
{$EXTERNALSYM IWMSyncReader}
IWMSyncReader = interface(IUnknown)
['{9397F121-7705-4dc9-B049-98B698188414}']
(*** IWMSyncReader methods ***)
//
// This interface can be QI'ed for IWMProfile, IWMHeaderInfo and
// IWMReaderTimecode interfaces
//
//
// Open is an synchronous call. We do not support streaming at this time.
// All open with http:// etc would fail. We do support MP3 or Windows
// media files from both local file or UNC path.
//
function Open(pwszFilename: PWideChar): HRESULT; stdcall;
function Close: HRESULT; stdcall;
//
// SetRange is basically a seek method, you can only set same range
// for all streams. Use cnsDuration=0 to specify reading to end of file.
//
function SetRange(cnsStartTime, cnsDuration: Int64): HRESULT; stdcall;
//
// SetRangeByFrame is frame-based access, the file has to be frame
// indexed to succeeded this call. If the call is successful, all
// streams are synchronized to the same position based on time.
// Also use cFramesToRead=0 to specify reading to end of file.
//
function SetRangeByFrame(wStreamNum: Word; qwFrameNumber, cFramesToRead: Int64 ): HRESULT; stdcall;
//
// If a valid stream number is specified, next sample from that stream
// will be returned, pwStreamNum can be NULL in this case. Otherwise,
// GetNextSample returns the next sample in time line (regardless of
// which stream). The sample's stream number will be returned.
// Time line is presentation time if no output setting is specified.
// To get early delivery for some stream, use SetOutputSetting
//
function GetNextSample(wStreamNum: Word; out ppSample: INSSBuffer;
out pcnsSampleTime: Int64; out pcnsDuration: Int64;
out pdwFlags: LongWord; out pdwOutputNum: LongWord;
out pwStreamNum: Word): HRESULT; stdcall;
//
// Stream selection methods are the same as asynchronous interface
//
function SetStreamsSelected(cStreamCount: Word; pwStreamNumbers: PWORD;
pSelections: PWMTStreamSelection): HRESULT; stdcall;
function GetStreamSelected(wStreamNum: Word; out pSelection: TWMTStreamSelection): HRESULT; stdcall;
function SetReadStreamSamples(wStreamNum: Word; fCompressed: BOOL): HRESULT; stdcall;
function GetReadStreamSamples(wStreamNum: Word; out pfCompressed: BOOL): HRESULT; stdcall;
//
// The following two methods are the same as the ones in
// IWMReaderAdvanced2 interface. We don't support JustInTimeDecode
// in this interface
//
function GetOutputSetting(dwOutputNum: LongWord; pszName: PWideChar;
out pType: TWMTAttrDataType; {out} pValue: PBYTE;
var pcbLength: Word): HRESULT; stdcall;
//
// Sets a named setting for a particular output
//
function SetOutputSetting(dwOutputNum: LongWord; pszName: PWideChar;
Type_: TWMTAttrDataType; {in} pValue: PBYTE; cbLength: Word): HRESULT; stdcall;
//
// The following methods are important for receiving uncompressed samples,
// they are identical to methods in asynchronous Reader interface.
//
function GetOutputCount(out pcOutputs: LongWord): HRESULT; stdcall;
function GetOutputProps(dwOutputNum: LongWord; out ppOutput: IWMOutputMediaProps): HRESULT; stdcall;
function SetOutputProps(dwOutputNum: LongWord; pOutput: IWMOutputMediaProps): HRESULT; stdcall;
//
// Used for determining all possible format types supported by this
// output on the reader.
//
function GetOutputFormatCount(dwOutputNum: LongWord; out pcFormats: LongWord): HRESULT; stdcall;
function GetOutputFormat(dwOutputNum, dwFormatNum: LongWord; out ppProps: IWMOutputMediaProps): HRESULT; stdcall;
//
// Methods provided to relate output numbers with stream numbers
//
function GetOutputNumberForStream(wStreamNum: Word; out pdwOutputNum: LongWord): HRESULT; stdcall;
function GetStreamNumberForOutput(dwOutputNum: LongWord; out pwStreamNum: Word): HRESULT; stdcall;
function GetMaxOutputSampleSize(dwOutput: LongWord; out pcbMax: LongWord): HRESULT; stdcall;
function GetMaxStreamSampleSize(wStream: Word; out pcbMax: LongWord): HRESULT; stdcall;
//
// Same as IWMSyncReader::Open but takes an IStream interface pointer
// instead of an file name to be opened. This method is typically
// used for custom source.
//
function OpenStream(pStream: IStream): HRESULT; stdcall;
end;
IWMReaderAllocatorEx = interface;
{$HPPEMIT 'typedef System::DelphiInterface<IWMSyncReader2> _di_IWMSyncReader2;'}
{$EXTERNALSYM IWMSyncReader2}
IWMSyncReader2 = interface(IWMSyncReader)
['{faed3d21-1b6b-4af7-8cb6-3e189bbc187b}']
(*** IWMSyncReader2 methods ***)
//
// SetRangeByTimecode is timecode-based access, the file has to be timecode
// indexed to succeeded this call. If the call is successful, all
// streams are synchronized to the same position based on presentation
// time.
//
function SetRangeByTimecode(wStreamNum: Word;
var pStart, pEnd: TWMTTimeCodeExtensionData): HRESULT; stdcall;
//
// SetRangeByFrame is frame-based access, the file has to be frame
// indexed to succeeded this call. If the call is successful, all
// streams are synchronized to the same position based on time.
// Also use cFramesToRead=0 to specify reading to end of file.
//
function SetRangeByFrameEx(wStreamNum: Word; qwFrameNumber, cFramesToRead: Int64;
out pcnsStartTime: Int64): HRESULT; stdcall;
//
// The following four methods are for user buffer allocations
//
function SetAllocateForOutput(dwOutputNum: LongWord; pAllocator: IWMReaderAllocatorEx): HRESULT; stdcall;
function GetAllocateForOutput(dwOutputNum: LongWord; out ppAllocator: IWMReaderAllocatorEx): HRESULT; stdcall;
function SetAllocateForStream(wStreamNum: Word; pAllocator: IWMReaderAllocatorEx): HRESULT; stdcall;
function GetAllocateForStream(dwSreamNum: Word; out ppAllocator: IWMReaderAllocatorEx): HRESULT; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMOutputMediaProps> _di_IWMOutputMediaProps;'}
{$EXTERNALSYM IWMOutputMediaProps}
IWMOutputMediaProps = interface(IWMMediaProps)
['{96406BD7-2B2B-11d3-B36B-00C04F6108FF}']
(*** IWMOutputMediaProps methods ***)
//
// A Stream Group and type together uniquely identify each output. (The
// type is on IWMMediaProps).
//
function GetStreamGroupName({out} pwszName: PWideChar; var pcchName: Word): HRESULT; stdcall;
function GetConnectionName({out} pwszName: PWideChar; var pcchName: Word): HRESULT; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMStatusCallback> _di_IWMStatusCallback;'}
{$EXTERNALSYM IWMStatusCallback}
IWMStatusCallback = interface(IUnknown)
['{6d7cdc70-9888-11d3-8edc-00c04f6109cf}']
(*** IWMStatusCallback methods ***)
// The contents of pValue depends on the Status.
function OnStatus(Status: TWMTStatus; hr: HRESULT; dwType: TWMTAttrDataType;
pValue: PBYTE; pvContext: Pointer): HRESULT; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMReaderCallback> _di_IWMReaderCallback;'}
{$EXTERNALSYM IWMReaderCallback}
IWMReaderCallback = interface(IWMStatusCallback)
['{96406BD8-2B2B-11d3-B36B-00C04F6108FF}']
(*** IWMReaderCallback methods ***)
// cnsSampleDuration will be 0 for most media types.
function OnSample(dwOutputNum: LongWord; cnsSampleTime, cnsSampleDuration: Int64;
dwFlags: LongWord; pSample: INSSBuffer; pvContext: Pointer): HRESULT; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMCredentialCallback> _di_IWMCredentialCallback;'}
{$EXTERNALSYM IWMCredentialCallback}
IWMCredentialCallback = interface(IUnknown)
['{342e0eb7-e651-450c-975b-2ace2c90c48e}']
(*** IWMCredentialCallback methods ***)
function AcquireCredentials(pwszRealm, pwszSite: PWideChar; {out} pwszUser: PWideChar;
cchUser: LongWord; {out} pwszPassword: PWideChar; cchPassword: LongWord;
hrStatus: HRESULT; out pdwFlags: LongWord): HRESULT; stdcall; // Combination of WMT_CREDENTIAL_FLAGS
end;
///////////////////////////////////////////////////////////////////////////////
//
// 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.
//
///////////////////////////////////////////////////////////////////////////////
{$HPPEMIT 'typedef System::DelphiInterface<IWMMetadataEditor> _di_IWMMetadataEditor;'}
{$EXTERNALSYM IWMMetadataEditor}
IWMMetadataEditor = interface(IUnknown)
['{96406BD9-2B2B-11d3-B36B-00C04F6108FF}']
(*** IWMMetadataEditor methods ***)
// QI this for IWMHeaderInfo to edit the header attributes.
// Manage the file
function Open(pwszFilename: PWideChar): HRESULT; stdcall;
function Close: HRESULT; stdcall;
function Flush: HRESULT; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMMetadataEditor2> _di_IWMMetadataEditor2;'}
{$EXTERNALSYM IWMMetadataEditor2}
IWMMetadataEditor2 = interface(IWMMetadataEditor)
['{203CFFE3-2E18-4fdf-B59D-6E71530534CF}']
(*** IWMMetadataEditor2 methods ***)
//
// The flags to dwDesiredAccess and dwShareMode match the flags to
// (the win32 API) CreateFile.
//
// Supported combinations are:
//
// dwDesiredAccess dwShareMode
// ---------------------------- -----------
// GENERIC_READ | GENERIC_WRITE 0
// GENERIC_READ | GENERIC_WRITE FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE
// GENERIC_READ 0
// GENERIC_READ FILE_SHARE_READ
// GENERIC_READ FILE_SHARE_DELETE
// GENERIC_READ FILE_SHARE_READ | FILE_SHARE_DELETE
//
function OpenEx(pwszFilename: PWideChar; dwDesiredAccess, dwShareMode: LongWord): HRESULT; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMDRMEditor> _di_IWMDRMEditor;'}
{$EXTERNALSYM IWMDRMEditor}
IWMDRMEditor = interface(IUnknown)
['{FF130EBC-A6C3-42A6-B401-C3382C3E08B3}']
(*** IWMDRMEditor methods ***)
// For accessing DRM properties from the metadata editor.
function GetDRMProperty(pwstrName: PWideChar; out pdwType: TWMTAttrDataType;
{out} pValue: PBYTE; var pcbLength: Word): HRESULT; stdcall;
end;
///////////////////////////////////////////////////////////////////////////////
//
// Below are utility interfaces used across all 3 of the main objects.
//
///////////////////////////////////////////////////////////////////////////////
//
// The 3 main interface (IWMWriter, IWMReader, and
// IWMMetadataEditor) can be QI'd for this interface to get and set
// header attributes, and markers.
//
{$HPPEMIT 'typedef System::DelphiInterface<IWMHeaderInfo> _di_IWMHeaderInfo;'}
{$EXTERNALSYM IWMHeaderInfo}
IWMHeaderInfo = interface(IUnknown)
['{96406BDA-2B2B-11d3-B36B-00C04F6108FF}']
(*** IWMHeaderInfo methods ***)
// 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.
//
function GetAttributeCount(wStreamNum: Word; out pcAttributes: Word): HRESULT; stdcall;
function GetAttributeByIndex(wIndex: Word; var pwStreamNum: Word;
{out} pwszName: PWideChar; var pcchNameLen: Word;
out pType: TWMTAttrDataType; {out} pValue: PBYTE;
var pcbLength: Word): HRESULT; stdcall;
function GetAttributeByName(var pwStreamNum: Word; pszName: PWideChar;
out pType: TWMTAttrDataType; {out} pValue: PBYTE;
var pcbLength: Word): HRESULT; stdcall;
function SetAttribute(wStreamNum: Word; pszName: PWideChar;
Type_: TWMTAttrDataType; {in} pValue: PBYTE;
cbLength: Word): HRESULT; stdcall;
// Marker methods.
function GetMarkerCount(out pcMarkers: Word): HRESULT; stdcall;
function GetMarker(wIndex: Word; {out} pwszMarkerName: PWideChar;
var pcchMarkerNameLen: Word; out pcnsMarkerTime: Int64): HRESULT; stdcall;
function AddMarker(pwszMarkerName: PWideChar; cnsMarkerTime: Int64): HRESULT; stdcall;
function RemoveMarker(wIndex: Word): HRESULT; stdcall;
// Script command methods.
function GetScriptCount(out pcScripts: Word): HRESULT; stdcall;
function GetScript(wIndex: Word; {out} pwszType: PWideChar;
var pcchTypeLen: Word; {out} pwszCommand: PWideChar;
var pcchCommandLen: Word; out pcnsScriptTime: Int64): HRESULT; stdcall;
function AddScript(pwszType, pwszCommand: PWideChar;
cnsScriptTime: Int64): HRESULT; stdcall;
function RemoveScript(wIndex: Word): HRESULT; stdcall;
end;
// The 3 main interface (IWMWriter, IWMReader, and
// IWMMetadataEditor) can be QI'd for this interface to get and set
// header attributes, and markers.
{$HPPEMIT 'typedef System::DelphiInterface<IWMHeaderInfo2> _di_IWMHeaderInfo2;'}
{$EXTERNALSYM IWMHeaderInfo2}
IWMHeaderInfo2 = interface(IWMHeaderInfo)
['{15CF9781-454E-482e-B393-85FAE487A810}']
(*** IWMHeaderInfo2 methods ***)
function GetCodecInfoCount(out pcCodecInfos: LongWord): HRESULT; stdcall;
function GetCodecInfo(wIndex: LongWord; var pcchName: Word;
{out} pwszName: PWideChar; var pcchDescription: Word;
{out} pwszDescription: PWideChar; out pCodecType: WMT_CODEC_INFO_TYPE;
var pcbCodecInfo: Word; {out} pbCodecInfo: PBYTE): HRESULT; stdcall;
end;
///////////////////////////////////////////////////////////////////////////////
//
// IWMHeaderInfo3 - V9 metadata features. This interface extends IWMHeaderInfo
// functionality:
// - allows >64k attributes;
// - allows multiple attributes with the same name;
// - works with attribute languages.
//
///////////////////////////////////////////////////////////////////////////////
{$HPPEMIT 'typedef System::DelphiInterface<IWMHeaderInfo3> _di_IWMHeaderInfo3;'}
{$EXTERNALSYM IWMHeaderInfo3}
IWMHeaderInfo3 = interface(IWMHeaderInfo2)
['{15CC68E3-27CC-4ecd-B222-3F5D02D80BD5}']
(*** IWMHeaderInfo3 methods ***)
function GetAttributeCountEx(wStreamNum: Word; out pcAttributes: Word): HRESULT; stdcall;
function GetAttributeIndices(wStreamNum: Word; pwszName: PWideChar;
pwLangIndex: PWORD; {out} pwIndices: PWORD; var pwCount: Word): HRESULT; stdcall;
function GetAttributeByIndexEx(wStreamNum: Word; wIndex: Word; {out} pwszName: PWideChar;
var pwNameLen: Word; out pType: TWMTAttrDataType; out pwLangIndex: Word;
{out} pValue: PBYTE; var pdwDataLength: LongWord): HRESULT; stdcall;
function ModifyAttribute(wStreamNum: Word; wIndex: Word; Type_: TWMTAttrDataType;
wLangIndex: Word; pValue: PBYTE; dwLength: LongWord): HRESULT; stdcall;
function AddAttribute(wStreamNum: Word; pszName: PWideChar;
out pwIndex: Word; Type_: TWMTAttrDataType; wLangIndex: Word;
pValue: PBYTE; dwLength: LongWord): HRESULT; stdcall;
function DeleteAttribute(wStreamNum, wIndex: Word): HRESULT; stdcall;
function AddCodecInfo(pwszName: PWideChar; pwszDescription: PWideChar;
codecType: WMT_CODEC_INFO_TYPE; cbCodecInfo: Word;
pbCodecInfo: PBYTE): HRESULT; stdcall;
end;
///////////////////////////////////////////////////////////////////////////////
//
// 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.
//
///////////////////////////////////////////////////////////////////////////////
{$HPPEMIT 'typedef System::DelphiInterface<IWMProfileManager> _di_IWMProfileManager;'}
{$EXTERNALSYM IWMProfileManager}
IWMProfileManager = interface(IUnknown)
['{d16679f2-6ca0-472d-8d31-2f5d55aee155}']
(*** IWMProfileManager methods ***)
// Create a profile with nothing in it.
function CreateEmptyProfile(dwVersion: WMT_VERSION; out ppProfile: IWMProfile): HRESULT; stdcall;
// Load a system profile given its ID.
function LoadProfileByID(const guidProfile: TGUID; out ppProfile: IWMProfile): HRESULT; stdcall;
// Load a profile from a stored string.
function LoadProfileByData(pwszProfile: PWideChar; out ppProfile: IWMProfile): HRESULT; stdcall;
// Save profile specified by its string.
function SaveProfile(pIWMProfile: IWMProfile; pwszProfile: PWideChar;
var pdwLength: LongWord): HRESULT; stdcall;
// Iterate through the system profiles.
function GetSystemProfileCount(out pcProfiles: LongWord): HRESULT; stdcall;
function LoadSystemProfile(dwProfileIndex: LongWord; out ppProfile: IWMProfile): HRESULT; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMProfileManager2> _di_IWMProfileManager2;'}
{$EXTERNALSYM IWMProfileManager2}
IWMProfileManager2 = interface(IWMProfileManager)
['{7A924E51-73C1-494d-8019-23D37ED9B89A}']
(*** IWMProfileManager2 methods ***)
// 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.
function GetSystemProfileVersion(out pdwVersion: WMT_VERSION): HRESULT; stdcall;
function SetSystemProfileVersion(dwVersion: WMT_VERSION): HRESULT; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMProfileManagerLanguage> _di_IWMProfileManagerLanguage;'}
{$EXTERNALSYM IWMProfileManagerLanguage}
IWMProfileManagerLanguage = interface(IUnknown)
['{BA4DCC78-7EE0-4ab8-B27A-DBCE8BC51454}']
(*** IWMProfileManagerLanguage methods ***)
// Set the language ID that user prefers to use, it must be a valid
// LANGID we support and the corresponding localized profile must
// present. Or we'll use English as default
function GetUserLanguageID(out wLangID: Word): HRESULT; stdcall;
function SetUserLanguageID(wLangID: Word): HRESULT; stdcall;
end;
IWMStreamConfig = interface;
IWMMutualExclusion = interface;
{$HPPEMIT 'typedef System::DelphiInterface<IWMProfile> _di_IWMProfile;'}
{$EXTERNALSYM IWMProfile}
IWMProfile = interface(IUnknown)
['{96406BDB-2B2B-11d3-B36B-00C04F6108FF}']
(*** IWMProfile methods ***)
// 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.
function GetVersion(out pdwVersion: WMT_VERSION): HRESULT; stdcall;
// Profiles have names and descriptions, for use when displaying lists
// of profiles, etc.
function GetName({out} pwszName: PWideChar; var pcchName: LongWord): HRESULT; stdcall;
function SetName(pwszName: PWideChar): HRESULT; stdcall;
function GetDescription({out} pwszDescription: PWideChar;
var pcchDescription: LongWord): HRESULT; stdcall;
function SetDescription(pwszDescription: PWideChar): HRESULT; stdcall;
// Methods for enumerating the streams. Note that updating the
// returned IWMStreamConfig has no effect on the profile until you
// call ReconfigStream().
function GetStreamCount(out pcStreams: LongWord): HRESULT; stdcall;
function GetStream(dwStreamIndex: LongWord; out ppConfig: IWMStreamConfig): HRESULT; stdcall;
function GetStreamByNumber(wStreamNum: Word; out ppConfig: IWMStreamConfig): HRESULT; stdcall;
// Remove a stream.
function RemoveStream(pConfig: IWMStreamConfig): HRESULT; stdcall;
function RemoveStreamByNumber(wStreamNum: Word): HRESULT; stdcall;
// Adding a stream copies the config into the profile.
function AddStream(pConfig: IWMStreamConfig): HRESULT; stdcall;
function ReconfigStream(pConfig: IWMStreamConfig): HRESULT; stdcall;
// 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).
function CreateNewStream(const guidStreamType: TGUID;
out ppConfig: IWMStreamConfig): HRESULT; stdcall;
// Mutual Exclusion. As above, only Add and Remove actual change the
// profile.
function GetMutualExclusionCount(out pcME: LongWord): HRESULT; stdcall;
function GetMutualExclusion(dwMEIndex: LongWord; out ppME: IWMMutualExclusion): HRESULT; stdcall;
function RemoveMutualExclusion(pME: IWMMutualExclusion): HRESULT; stdcall;
function AddMutualExclusion(pME: IWMMutualExclusion): HRESULT; stdcall;
function CreateNewMutualExclusion(out ppME: IWMMutualExclusion): HRESULT; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMProfile2> _di_IWMProfile2;'}
{$EXTERNALSYM IWMProfile2}
IWMProfile2 = interface(IWMProfile)
['{07E72D33-D94E-4be7-8843-60AE5FF7E5F5}']
(*** IWMProfile2 methods ***)
// Get/set this profile's unique identifier
function GetProfileID(out pguidID: TGUID): HRESULT; stdcall;
end;
IWMBandwidthSharing = interface;
IWMStreamPrioritization = interface;
{$HPPEMIT 'typedef System::DelphiInterface<IWMProfile3> _di_IWMProfile3;'}
{$EXTERNALSYM IWMProfile3}
IWMProfile3 = interface(IWMProfile2)
['{00EF96CC-A461-4546-8BCD-C9A28F0E06F5}']
(*** IWMProfile3 methods ***)
// Get/set the storage format. These calls have been deprecated.
// Query the WM/ContainerFormat attribute instead.
//
function GetStorageFormat(out pnStorageFormat: TWMTStorageFormat): HRESULT; stdcall;
function SetStorageFormat(nStorageFormat: TWMTStorageFormat): HRESULT; stdcall;
//
// Bandwidth sharing. Only Add and Remove actually change the
// profile.
//
function GetBandwidthSharingCount(out pcBS: LongWord): HRESULT; stdcall;
function GetBandwidthSharing(dwBSIndex: LongWord; out ppBS: IWMBandwidthSharing): HRESULT; stdcall;
function RemoveBandwidthSharing(pBS: IWMBandwidthSharing): HRESULT; stdcall;
function AddBandwidthSharing(pBS: IWMBandwidthSharing): HRESULT; stdcall;
function CreateNewBandwidthSharing(out ppBS: IWMBandwidthSharing): HRESULT; stdcall;
//
// Stream prioritization. Only Set and Remove actually
// change the profile.
// Note that there can be at most one such object.
//
function GetStreamPrioritization(out ppSP: IWMStreamPrioritization): HRESULT; stdcall;
function SetStreamPrioritization(pSP: IWMStreamPrioritization): HRESULT; stdcall;
function RemoveStreamPrioritization: HRESULT; stdcall;
function CreateNewStreamPrioritization(out ppSP: IWMStreamPrioritization): HRESULT; stdcall;
//
// Get information about how the muxing will be done
//
function GetExpectedPacketCount(msDuration: Int64; out pcPackets: Int64): HRESULT; stdcall;
end;
//
// IWMStreamConfig represents an ASF stream.
//
{$HPPEMIT 'typedef System::DelphiInterface<IWMStreamConfig> _di_IWMStreamConfig;'}
{$EXTERNALSYM IWMStreamConfig}
IWMStreamConfig = interface(IUnknown)
['{96406BDC-2B2B-11d3-B36B-00C04F6108FF}']
(*** IWMStreamConfig methods ***)
// This interface QI's for IWMMediaProps and one of it's inheritors.
// (IWMVideoMediaProps, for instance).
function GetStreamType(out pguidStreamType: TGUID): HRESULT; stdcall;
function GetStreamNumber(out pwStreamNum: Word): HRESULT; stdcall;
function SetStreamNumber(wStreamNum: Word): HRESULT; stdcall;
function GetStreamName({out} pwszStreamName: PWideChar; var pcchStreamName: Word): HRESULT; stdcall;
function SetStreamName(pwszStreamName: PWideChar): HRESULT; stdcall;
function GetConnectionName({out} pwszInputName: PWideChar; var pcchInputName: Word): HRESULT; stdcall;
function SetConnectionName(pwszInputName: PWideChar): HRESULT; stdcall;
function GetBitrate(out pdwBitrate: LongWord): HRESULT; stdcall;
function SetBitrate(pdwBitrate: LongWord): HRESULT; stdcall;
//
// 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.
//
function GetBufferWindow(out pmsBufferWindow: LongWord): HRESULT; stdcall;
function SetBufferWindow(msBufferWindow: LongWord): HRESULT; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMStreamConfig2> _di_IWMStreamConfig2;'}
{$EXTERNALSYM IWMStreamConfig2}
IWMStreamConfig2 = interface(IWMStreamConfig)
['{7688D8CB-FC0D-43BD-9459-5A8DEC200CFA}']
(*** IWMStreamConfig2 methods ***)
// Get/set the type of data communication protocol (reliable or unreliable)
function GetTransportType (out pnTransportType: TWMTTransportType): HRESULT; stdcall;
function SetTransportType(nTransportType: TWMTTransportType): HRESULT; stdcall;
//
// Add/Get data unit extension systems (for attaching user-defined
// data to samples in the output file)
//
function AddDataUnitExtension(const guidExtensionSystemID: TGUID;
cbExtensionDataSize: Word; pbExtensionSystemInfo: PBYTE;
cbExtensionSystemInfo: LongWord): HRESULT; stdcall;
function GetDataUnitExtensionCount(out pcDataUnitExtensions: Word): HRESULT; stdcall;
function GetDataUnitExtension(wDataUnitExtensionNumber: Word;
out pguidExtensionSystemID: TGUID; out pcbExtensionDataSize: Word;
{out} pbExtensionSystemInfo: PBYTE; var pcbExtensionSystemInfo: LongWord): HRESULT; stdcall;
function RemoveAllDataUnitExtensions: HRESULT; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMStreamConfig3> _di_IWMStreamConfig3;'}
{$EXTERNALSYM IWMStreamConfig3}
IWMStreamConfig3 = interface(IWMStreamConfig2)
['{CB164104-3AA9-45a7-9AC9-4DAEE131D6E1}']
(*** IWMStreamConfig3 methods ***)
// Get/set language info for this stream as an RFC1766 string.
function GetLanguage({out} pwszLanguageString: PWideChar; var pcchLanguageStringLength: Word): HRESULT; stdcall;
function SetLanguage(pwszLanguageString: PWideChar): HRESULT; stdcall;
end;
// Controls how big packets can get in an ASF file.
{$HPPEMIT 'typedef System::DelphiInterface<IWMPacketSize> _di_IWMPacketSize;'}
{$EXTERNALSYM IWMPacketSize}
IWMPacketSize = interface(IUnknown)
['{CDFB97AB-188F-40b3-B643-5B7903975C59}']
(*** IWMPacketSize methods ***)
function GetMaxPacketSize(out pdwMaxPacketSize: LongWord): HRESULT; stdcall;
function SetMaxPacketSize(dwMaxPacketSize: LongWord): HRESULT; stdcall;
end;
// Controls how small packets can get in an ASF file.
{$HPPEMIT 'typedef System::DelphiInterface<IWMPacketSize2> _di_IWMPacketSize2;'}
{$EXTERNALSYM IWMPacketSize2}
IWMPacketSize2 = interface(IWMPacketSize)
['{8BFC2B9E-B646-4233-A877-1C6A079669DC}']
(*** IWMPacketSize2 methods ***)
function GetMinPacketSize(out pdwMinPacketSize: LongWord): HRESULT; stdcall;
function SetMinPacketSize(dwMinPacketSize: LongWord): HRESULT; stdcall;
end;
// IWMStreamList is used for the various objects that define relationships
// between streams.
{$HPPEMIT 'typedef System::DelphiInterface<IWMStreamList> _di_IWMStreamList;'}
{$EXTERNALSYM IWMStreamList}
IWMStreamList = interface(IUnknown)
['{96406BDD-2B2B-11d3-B36B-00C04F6108FF}']
(*** IWMStreamList methods ***)
function GetStreams({out} pwStreamNumArray: PWORD; var pcStreams: PWORD): HRESULT; stdcall;
function AddStream(wStreamNum: Word): HRESULT; stdcall;
function RemoveStream(wStreamNum: Word): HRESULT; stdcall;
end;
// 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).
{$HPPEMIT 'typedef System::DelphiInterface<IWMMutualExclusion> _di_IWMMutualExclusion;'}
{$EXTERNALSYM IWMMutualExclusion}
IWMMutualExclusion = interface(IWMStreamList)
['{96406BDE-2B2B-11d3-B36B-00C04F6108FF}']
(*** IWMMutualExclusion methods ***)
// The possible types of mutual exclusion are defined in the ASF
// header.
function GetType(out pguidType: TGUID): HRESULT; stdcall;
function SetType(guidType: TGUID): HRESULT; stdcall;
end;
// IWMMutualExclusion2 extends IWMMutualExclusion to incorporate more advanced
// mutual exclusion concepts.
//
{$HPPEMIT 'typedef System::DelphiInterface<IWMMutualExclusion2> _di_IWMMutualExclusion2;'}
{$EXTERNALSYM IWMMutualExclusion2}
IWMMutualExclusion2 = interface(IWMMutualExclusion)
['{0302B57D-89D1-4ba2-85C9-166F2C53EB91}']
(*** IWMMutualExclusion2 methods ***)
// Methods to get and set the name of the mutual exclusion.
function GetName({out} pwszName: PWideChar; var pcchName: Word): HRESULT; stdcall;
function SetName(pwszName: PWideChar): HRESULT; stdcall;
// Methods to query and manipulate the records in the object.
function GetRecordCount(out pwRecordCount: Word): HRESULT; stdcall;
function AddRecord: HRESULT; stdcall;
function RemoveRecord(wRecordNumber: Word ): HRESULT; stdcall;
// Methods to get and set the name associated with a record.
function GetRecordName(wRecordNumber: Word; {out} pwszRecordName: PWideChar;
var pcchRecordName: Word): HRESULT; stdcall;
function SetRecordName(wRecordNumber: Word; pwszRecordName: PWideChar): HRESULT; stdcall;
// Methods to get and set the streams in a record.
function GetStreamsForRecord(wRecordNumber: Word; {out} pwStreamNumArray: PWORD;
var pcStreams: Word): HRESULT; stdcall;
function AddStreamForRecord(wRecordNumber, wStreamNumber: Word): HRESULT; stdcall;
function RemoveStreamForRecord(wRecordNumber, wStreamNumber: Word): HRESULT; stdcall;
end;
// IWMBandwidthSharing specifies a group of streams whose combined bitrate
// and buffer size are not to exceed the parameters given to this interface,
// even though the sum of their individual bitrates may be more.
{$HPPEMIT 'typedef System::DelphiInterface<IWMBandwidthSharing> _di_IWMBandwidthSharing;'}
{$EXTERNALSYM IWMBandwidthSharing}
IWMBandwidthSharing = interface(IWMStreamList)
['{AD694AF1-F8D9-42F8-BC47-70311B0C4F9E}']
(*** IWMBandwidthSharing methods ***)
// The possible types of bandwidth are defined in the ASF
// header.
function GetType(out pguidType: TGUID): HRESULT; stdcall;
function SetType(const guidType: TGUID): HRESULT; stdcall;
// Methods to get and set properties of the combined streams.
// Buffer windows are given in milliseconds
function GetBandwidth(out pdwBitrate, pmsBufferWindow: LongWord): HRESULT; stdcall;
function SetBandwidth(dwBitrate, msBufferWindow: LongWord): HRESULT; stdcall;
end;
// IWMStreamPrioritization specifies the author's intentions as to which
// streams should or should not be dropped in response to various network
// congestion situations.
{$HPPEMIT 'typedef System::DelphiInterface<IWMStreamPrioritization> _di_IWMStreamPrioritization;'}
{$EXTERNALSYM IWMStreamPrioritization}
IWMStreamPrioritization = interface(IUnknown)
['{8C1C6090-F9A8-4748-8EC3-DD1108BA1E77}']
(*** IWMStreamPrioritization methods ***)
// Records in a stream prioritization object are given in order of
// decreasing priority
function GetPriorityRecords({out} pRecordArray: PWMStreamPrioritizationRecord; var cRecords: Word): HResult; stdcall;
function SetPriorityRecords(pRecordArray: PWMStreamPrioritizationRecord; cRecords: Word): HResult; stdcall;
end;
///////////////////////////////////////////////////////////////////////////////
//
// Advanced features.
//
///////////////////////////////////////////////////////////////////////////////
IWMWriterSink = interface;
// The writer can be QI'd for this interface, which provides advanced writing
// functionality.
{$HPPEMIT 'typedef System::DelphiInterface<IWMWriterAdvanced> _di_IWMWriterAdvanced;'}
{$EXTERNALSYM IWMWriterAdvanced}
IWMWriterAdvanced = interface(IUnknown)
['{96406BE3-2B2B-11D3-B36B-00C04F6108FF}']
(*** IWMWriterAdvanced methods ***)
// Sinks are where the output ASF data goes.
function GetSinkCount(out pcSinks: LongWord): HResult; stdcall;
function GetSink(dwSinkNum: LongWord; out ppSink: IWMWriterSink): HResult; stdcall;
function AddSink(pSink: IWMWriterSink): HResult; stdcall;
function RemoveSink(pSink: IWMWriterSink): HResult; stdcall;
// 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.
function WriteStreamSample(wStreamNum: Word; cnsSampleTime: Int64;
msSampleSendTime: LongWord; cnsSampleDuration: Int64;
dwFlags: LongWord; pSample: INSSBuffer): HResult; stdcall;
// The writer may be running in real-time. If so, it's interesting to
// get the current time from the writer.
function SetLiveSource(fIsLiveSource: BOOL): HResult; stdcall;
function IsRealTime(out pfRealTime: BOOL): HResult; stdcall;
function GetWriterTime(out pcnsCurrentTime: Int64): HResult; stdcall;
// 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.
function GetStatistics(wStreamNum: Word; out pStats: TWMWriterStatistics): HResult; stdcall;
// Sync tolerance determines how far out of sync the inputs will be allowed
// to get before samples are thrown away. Default is 3000 ms.
function SetSyncTolerance(msWindow: LongWord): HResult; stdcall;
function GetSyncTolerance(out pmsWindow: LongWord): HResult; stdcall;
end;
// The writer can be QI'd for this interface, which provides advanced writing
// functionality.
{$HPPEMIT 'typedef System::DelphiInterface<IWMWriterAdvanced2> _di_IWMWriterAdvanced2;'}
{$EXTERNALSYM IWMWriterAdvanced2}
IWMWriterAdvanced2 = interface(IWMWriterAdvanced)
['{962DC1EC-C046-4DB8-9CC7-26CEAE500817}']
(*** IWMWriterAdvanced2 methods ***)
// Retrieves a setting for a particular output by name
function GetInputSetting(dwInputNum: LongWord; pszName: PWideChar;
out pType: TWMTAttrDataType; {out} pValue: PByte; var pcbLength: Word): HResult; stdcall;
// Sets a named setting for a particular input
function SetInputSetting(dwInputNum: LongWord; pszName: PWideChar; Type_: TWMTAttrDataType;
pValue: PByte; cbLength: Word): HResult; stdcall;
end;
// The writer can be QI'd for this interface, which provides advanced writing
// functionality.
{$HPPEMIT 'typedef System::DelphiInterface<IWMWriterAdvanced3> _di_IWMWriterAdvanced3;'}
{$EXTERNALSYM IWMWriterAdvanced3}
IWMWriterAdvanced3 = interface(IWMWriterAdvanced2)
['{2CD6492D-7C37-4E76-9D3B-59261183A22E}']
(*** IWMWriterAdvanced3 methods ***)
// To get extended statistics, pass in a WM_WRITER_STATISTICS_EX structure, which
// will be filled out by the GetStatisticsEx() call with the requested
// stats.
//
// Pass in a stream number to get extended statistics for a specific stream, or
// pass 0 to get extended statistics for the entire ASF file.
function GetStatisticsEx(wStreamNum: Word; out pStats: TWMWriterStatisticsEx): HResult; stdcall;
function SetNonBlocking: HResult; stdcall;
end;
// The writer can be QI'd for this interface, which provides multi-pass
// encoding functionality.
{$HPPEMIT 'typedef System::DelphiInterface<IWMWriterPreprocess> _di_IWMWriterPreprocess;'}
{$EXTERNALSYM IWMWriterPreprocess}
IWMWriterPreprocess = interface(IUnknown)
['{FC54A285-38C4-45B5-AA23-85B9F7CB424B}']
(*** IWMWriterPreprocess methods ***)
function GetMaxPreprocessingPasses(dwInputNum: LongWord; dwFlags: LongWord;
out pdwMaxNumPasses: LongWord): HResult; stdcall;
function SetNumPreprocessingPasses(dwInputNum: LongWord; dwFlags: LongWord;
dwNumPasses: LongWord): HResult; stdcall;
function BeginPreprocessingPass(dwInputNum: LongWord; dwFlags: LongWord): HResult; stdcall;
function PreprocessSample(dwInputNum: LongWord; cnsSampleTime: Int64; dwFlags: LongWord;
pSample: INSSBuffer): HResult; stdcall;
function EndPreprocessingPass(dwInputNum: LongWord; dwFlags: LongWord): HResult; stdcall;
end;
// This is the interface that receives uncompressed samples from the writer
// to preview (well, postview) what the codec is doing.
{$HPPEMIT 'typedef System::DelphiInterface<IWMWriterPostViewCallback> _di_IWMWriterPostViewCallback;'}
{$EXTERNALSYM IWMWriterPostViewCallback}
IWMWriterPostViewCallback = interface(IWMStatusCallback)
['{D9D6549D-A193-4F24-B308-03123D9B7F8D}']
(*** IWMWriterPostViewCallback methods ***)
// cnsSampleDuration will be 0 for most media types.
function OnPostViewSample(wStreamNumber: Word; cnsSampleTime: Int64;
cnsSampleDuration: Int64; dwFlags: LongWord;
pSample: INSSBuffer; pvContext: Pointer): HResult; stdcall;
function AllocateForPostView(wStreamNum: Word; cbBuffer: LongWord; out ppBuffer: INSSBuffer;
pvContext: Pointer): HResult; stdcall;
end;
// The writer can be QI'd for this interface, which provides advanced writing
// functionality.
{$HPPEMIT 'typedef System::DelphiInterface<IWMWriterPostView> _di_IWMWriterPostView;'}
{$EXTERNALSYM IWMWriterPostView}
IWMWriterPostView = interface(IUnknown)
['{81E20CE4-75EF-491A-8004-FC53C45BDC3E}']
(*** IWMWriterPostView methods ***)
// Specify the callback to use for PostView
function SetPostViewCallback(pCallback: IWMWriterPostViewCallback; pvContext: Pointer): HResult; stdcall;
// Turns on delivery of postview samples for a given stream
function SetReceivePostViewSamples(wStreamNum: Word; fReceivePostViewSamples: BOOL): HResult; stdcall;
function GetReceivePostViewSamples(wStreamNum: Word; out pfReceivePostViewSamples: BOOL): HResult; stdcall;
// 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.
function GetPostViewProps(wStreamNumber: Word; out ppOutput: IWMMediaProps): HResult; stdcall;
function SetPostViewProps(wStreamNumber: Word; pOutput: IWMMediaProps): HResult; stdcall;
// Used for determining all possible format types supported by this
// output on the reader.
function GetPostViewFormatCount(wStreamNumber: Word; out pcFormats: LongWord): HResult; stdcall;
function GetPostViewFormat(wStreamNumber: Word; dwFormatNumber: LongWord;
out ppProps: IWMMediaProps): HResult; stdcall;
// 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.
function SetAllocateForPostView(wStreamNumber: Word; fAllocate: BOOL): HResult; stdcall;
function GetAllocateForPostView(wStreamNumber: Word; out pfAllocate: BOOL): HResult; stdcall;
end;
// This is the interface that receives raw ASF from the writer.
{$HPPEMIT 'typedef System::DelphiInterface<IWMWriterSink> _di_IWMWriterSink;'}
{$EXTERNALSYM IWMWriterSink}
IWMWriterSink = interface(IUnknown)
['{96406BE4-2B2B-11D3-B36B-00C04F6108FF}']
(*** IWMWriterSink methods ***)
function OnHeader(pHeader: INSSBuffer): HResult; stdcall;
// Some sinks require that data be fed to them in real-time.
function IsRealTime(out pfRealTime: BOOL): HResult; stdcall;
function AllocateDataUnit(cbDataUnit: LongWord; out ppDataUnit: INSSBuffer): HResult; stdcall;
function OnDataUnit(pDataUnit: INSSBuffer): HResult; stdcall;
// This function is called when the writer is done sending data.
function OnEndWriting: HResult; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMRegisterCallback> _di_IWMRegisterCallback;'}
{$EXTERNALSYM IWMRegisterCallback}
IWMRegisterCallback = interface(IUnknown)
['{CF4B1F99-4DE2-4E49-A363-252740D99BC1}']
(*** IWMRegisterCallback methods ***)
function Advise(pCallback: IWMStatusCallback; pvContext: Pointer): HResult; stdcall;
function Unadvise(pCallback: IWMStatusCallback; pvContext: Pointer): HResult; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMWriterFileSink> _di_IWMWriterFileSink;'}
{$EXTERNALSYM IWMWriterFileSink}
IWMWriterFileSink = interface(IWMWriterSink)
['{96406BE5-2B2B-11D3-B36B-00C04F6108FF}']
(*** IWMWriterFileSink methods ***)
function Open(pwszFilename: PWideChar): HResult; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMWriterFileSink2> _di_IWMWriterFileSink2;'}
{$EXTERNALSYM IWMWriterFileSink2}
IWMWriterFileSink2 = interface(IWMWriterFileSink)
['{14282BA7-4AEF-4205-8CE5-C229035A05BC}']
(*** IWMWriterFileSink2 methods ***)
function Start(cnsStartTime: Int64): HResult; stdcall;
function Stop(cnsStopTime: Int64): HResult; stdcall;
function IsStopped(out pfStopped: BOOL): HResult; stdcall;
function GetFileDuration(out pcnsDuration: Int64): HResult; stdcall;
function GetFileSize(out pcbFile: Int64): HResult; stdcall;
function Close: HResult; stdcall;
function IsClosed(out pfClosed: BOOL): HResult; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMWriterFileSink3> _di_IWMWriterFileSink3;'}
{$EXTERNALSYM IWMWriterFileSink3}
IWMWriterFileSink3 = interface(IWMWriterFileSink2)
['{3FEA4FEB-2945-47A7-A1DD-C53A8FC4C45C}']
(*** IWMWriterFileSink3 methods ***)
function SetAutoIndexing(fDoAutoIndexing: BOOL): HResult; stdcall;
function GetAutoIndexing(out pfAutoIndexing: BOOL): HResult; stdcall;
function SetControlStream(wStreamNumber: Word; fShouldControlStartAndStop: BOOL): HResult; stdcall;
function GetMode(out pdwFileSinkMode: LongWord): HResult; stdcall;
function OnDataUnitEx(pFileSinkDataUnit: PWMTFileSinkDataUnit): HResult; stdcall;
function SetUnbufferedIO(fUnbufferedIO: BOOL; fRestrictMemUsage: BOOL): HResult; stdcall;
function GetUnbufferedIO(out pfUnbufferedIO: BOOL): HResult; stdcall;
function CompleteOperations: HResult; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMWriterNetworkSink> _di_IWMWriterNetworkSink;'}
{$EXTERNALSYM IWMWriterNetworkSink}
IWMWriterNetworkSink = interface(IWMWriterSink)
['{96406BE7-2B2B-11D3-B36B-00C04F6108FF}']
(*** IWMWriterNetworkSink methods ***)
// Determine the maximum number of clients that can connect to this sink.
// Default is 5.
function SetMaximumClients(dwMaxClients: LongWord): HResult; stdcall;
function GetMaximumClients(out pdwMaxClients: LongWord): HResult; stdcall;
// The network protocol that the network sink will use.
function SetNetworkProtocol(protocol: TWMTNetProtocol): HResult; stdcall;
function GetNetworkProtocol(out pProtocol: TWMTNetProtocol): HResult; stdcall;
// Find out the name of the URL on which we're broadcasting
function GetHostURL({out} pwszURL: PWideChar; var pcchURL: LongWord): HResult; stdcall;
// 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.
function Open(var pdwPortNum: LongWord): HResult; stdcall;
// Disconnect all connected clients.
function Disconnect: HResult; stdcall;
// Close and release the open port.
function Close: HResult; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMClientConnections> _di_IWMClientConnections;'}
{$EXTERNALSYM IWMClientConnections}
IWMClientConnections = interface(IUnknown)
['{73C66010-A299-41DF-B1F0-CCF03B09C1C6}']
(*** IWMClientConnections methods ***)
// Determine the number of connected clients
function GetClientCount(out pcClients: LongWord): HResult; stdcall;
// Get information about a connected client
function GetClientProperties(dwClientNum: LongWord; out pClientProperties: TWMClientProperties): HResult; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMClientConnections2> _di_IWMClientConnections2;'}
{$EXTERNALSYM IWMClientConnections2}
IWMClientConnections2 = interface(IWMClientConnections)
['{4091571E-4701-4593-BB3D-D5F5F0C74246}']
(*** IWMClientConnections2 methods ***)
// Get information about a connected client
function GetClientInfo(dwClientNum: LongWord; {out} pwszNetworkAddress: PWideChar;
var pcchNetworkAddress: LongWord; {out} pwszPort: PWideChar;
var pcchPort: LongWord; {out} pwszDNSName: PWideChar;
var pcchDNSName: LongWord): HResult; stdcall;
end;
// The reader can be QI'd for this interface for advanced functionality.
{$HPPEMIT 'typedef System::DelphiInterface<IWMReaderAdvanced> _di_IWMReaderAdvanced;'}
{$EXTERNALSYM IWMReaderAdvanced}
IWMReaderAdvanced = interface(IUnknown)
['{96406BEA-2B2B-11D3-B36B-00C04F6108FF}']
(*** IWMReaderAdvanced methods ***)
// 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.
function SetUserProvidedClock(fUserClock: BOOL): HResult; stdcall;