Delphi控件源码

开发平台：

Delphi

WMF9.pas：源码内容

function GetUserProvidedClock(out pfUserClock: BOOL): HResult; stdcall;
function DeliverTime(cnsTime: Int64): HResult; stdcall;
// The user can select streams manually, instead of relying on the
// automatic bandwidth stream selection that the reader will
// normally do. To figure out what streams are in this ASF and what their
// numbers are, QI for IWMProfile.
//
// When SetManualStreamSelection( TRUE ) is called, all streams are
// selected by default.
function SetManualStreamSelection(fSelection: BOOL): HResult; stdcall;
function GetManualStreamSelection(out pfSelection: BOOL): HResult; stdcall;
function SetStreamsSelected(cStreamCount: Word; pwStreamNumbers: PWord;
pSelections: PWMTStreamSelection): HResult; stdcall;
function GetStreamSelected(wStreamNum: Word; out pSelection: TWMTStreamSelection): HResult; stdcall;
// The user can also choose to get callbacks when automatic stream
// selection occurs.
function SetReceiveSelectionCallbacks(fGetCallbacks: BOOL): HResult; stdcall;
function GetReceiveSelectionCallbacks(out pfGetCallbacks: BOOL): HResult; stdcall;
// The user can register himself to receive samples directly from the
// ASF streams, rather than letting the Reader decompress them. Note that
// to do this, the IWMReaderCallback (supplied by the user) must support
// IWMReaderCallbackAdvanced.
//
// To get actual information about the contents of a stream, QI the
// object for IWMProfile.
function SetReceiveStreamSamples(wStreamNum: Word; fReceiveStreamSamples: BOOL): HResult; stdcall;
function GetReceiveStreamSamples(wStreamNum: Word; out pfReceiveStreamSamples: BOOL): 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 SetAllocateForOutput(dwOutputNum: LongWord; fAllocate: BOOL): HResult; stdcall;
function GetAllocateForOutput(dwOutputNum: LongWord; out pfAllocate: BOOL): HResult; stdcall;
function SetAllocateForStream(wStreamNum: Word; fAllocate: BOOL): HResult; stdcall;
function GetAllocateForStream(dwSreamNum: Word; out pfAllocate: BOOL): HResult; stdcall;
// Get statistics on demand
function GetStatistics(var pStatistics: TWMReaderStatistics): HResult; stdcall;
// Set client side information used for logging
function SetClientInfo(pClientInfo: PWMReaderClientInfo): HResult; stdcall;
// Get the maximum required buffer sizes that the SDK will allocate.
// The first is for output buffers, the second for stream buffers.
function GetMaxOutputSampleSize(dwOutput: LongWord; out pcbMax: LongWord): HResult; stdcall;
function GetMaxStreamSampleSize(wStream: Word; out pcbMax: LongWord): HResult; stdcall;
// Used to notify the reader that it's delivering data
// too slowly to the client. The reader will try to speed
// up.
function NotifyLateDelivery(cnsLateness: Int64): HResult; stdcall;
end;
// The reader can be QI'd for this interface for advanced functionality.
{$HPPEMIT 'typedef System::DelphiInterface<IWMReaderAdvanced2> _di_IWMReaderAdvanced2;'}
{$EXTERNALSYM IWMReaderAdvanced2}
IWMReaderAdvanced2 = interface(IWMReaderAdvanced)
['{AE14A945-B90C-4D0D-9127-80D665F7D73E}']
(*** IWMReaderAdvanced2 methods ***)
// Set the play mode to WMT_PLAY_MODE_AUTOSELECT to allow the reader
// to pick the mode. (This is the default). If you select a play mode that
// is impossible for the requested URL, an error will be returned when
// the URL is opened.
function SetPlayMode(Mode: TWMTPlayMode): HResult; stdcall;
// Get the current play mode.
function GetPlayMode(out pMode: TWMTPlayMode): HResult; stdcall;
// Between WMT_BUFFERING_START and WMT_BUFFERING_STOP this call will
// return progress values. pdwPercent returns the percentage of buffering
// that has completed, and pcnsBuffering returns the amount of buffering
// remaining.
function GetBufferProgress(out pdwPercent: LongWord; out pcnsBuffering: Int64): HResult; stdcall;
// When the play mode is WMT_PLAY_MODE_DOWNLOAD, this call will return
// progress values. pdwPercent returns the percentage of the download
// that has completed, pqwBytesDownloaded returns the number of bytes
// that have been downloaded, and pcnsDownload returns the amount of
// downloading remaining.
function GetDownloadProgress(out pdwPercent: LongWord; out pqwBytesDownloaded: Int64;
out pcnsDownload: Int64): HResult; stdcall;
// When saving a file, the operation may take awhile. Between
// WMT_SAVEAS_START and WMT_SAVEAS_STOP, this call will return progress
// values. pdwPercent returns the percentage of the save as that has
// completed.
function GetSaveAsProgress(out pdwPercent: LongWord): HResult; stdcall;
// Save the current file. This only works for WMT_PLAY_MODE_DOWNLOAD.
// This operation is asynchronous; WMT_SAVEAS_STOP indicates that the
// save has completed. Closing the reader will abort a save operation
// that has not completed.
function SaveFileAs(pwszFilename: PWideChar): HResult; stdcall;
// Returns the name of the protocol that is currently being used.
// The protocol name is a URL scheme, such as "mmsu", "http", "file", etc.
// Note, however, that the protocol name may differ from the URL scheme
// that was specified in IWMReader::Open().
// This method may return an empty string if the protocol name cannot be determined.
function GetProtocolName({out} pwszProtocol: PWideChar; var pcchProtocol: LongWord): HResult; stdcall;
// Same as IWMReader::Start, but uses a marker index instead of a time value.
function StartAtMarker(wMarkerIndex: Word; cnsDuration: Int64; fRate: Single;
pvContext: Pointer): HResult; stdcall;
// Retrieves a setting for a particular output by name
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;
pValue: PByte; cbLength: Word): HResult; stdcall;
// Used to begin prerolling the reader. Call this method
// when you know you're going to call Start soon and want
// to start buffering data in advance. cnsStart, cnsDuration
// and fRate should be the same as the values you plan to pass
// to Start in the future.
function Preroll(cnsStart: Int64; cnsDuration: Int64; fRate: Single): HResult; stdcall;
// Specifies whether the SDK should send the client's unique identifier
// to the server when streaming.
function SetLogClientID(fLogClientID: BOOL): HResult; stdcall;
function GetLogClientID(out pfLogClientID: BOOL): HResult; stdcall;
// This method requests that the Reader send WMT_BUFFERING_STOP as soon
// as possible. The Reader will only honor the request if it is currently
// buffering, i.e., it has sent a WMT_BUFFERING_START, but not yet sent the
// corresponding WMT_BUFFERING_STOP.
function StopBuffering: HResult; stdcall;
// Same as IWMReader::Open but takes an IStream interface pointer instead
// of an URL to be opened
function OpenStream(const pStream: IStream; pCallback: IWMReaderCallback;
pvContext: Pointer): HResult; stdcall;
end;
// The reader can be QI'ed for this interface for frame access functionaly.
{$HPPEMIT 'typedef System::DelphiInterface<IWMReaderAdvanced3> _di_IWMReaderAdvanced3;'}
{$EXTERNALSYM IWMReaderAdvanced3}
IWMReaderAdvanced3 = interface(IWMReaderAdvanced2)
['{5DC0674B-F04B-4A4E-9F2A-B1AFDE2C8100}']
(*** IWMReaderAdvanced3 methods ***)
// This method is used when you want to stop net streaming right away but
// continue to receive samples that SDK have gotten so far.
//
// If it's successful, user should receive an END_OF_STREAMING quickly.
function StopNetStreaming: HResult; stdcall;
// This method supports extended start functionality. The currently
// support start formats are:
//
// WMT_OFFSET_FORMAT_100NS
// WMT_OFFSET_FORMAT_FRAME_NUMBERS
// WMT_OFFSET_FORMAT_PLAYLIST_OFFSET
// WMT_OFFSET_FORMAT_TIMECODE
function StartAtPosition(wStreamNum: Word; pvOffsetStart: Pointer; pvDuration: Pointer;
dwOffsetFormat: TWMTOffsetFormat; fRate: Single;
pvContext: Pointer): HResult; stdcall;
end;
// The reader can be QI'ed for this interface for frame access functionaly.
{$HPPEMIT 'typedef System::DelphiInterface<IWMReaderAdvanced4> _di_IWMReaderAdvanced4;'}
{$EXTERNALSYM IWMReaderAdvanced4}
IWMReaderAdvanced4 = interface(IWMReaderAdvanced3)
['{945A76A2-12AE-4D48-BD3C-CD1D90399B85}']
(*** IWMReaderAdvanced4 methods ***)
function GetLanguageCount(dwOutputNum: LongWord; out pwLanguageCount: Word): HResult; stdcall;
function GetLanguage(dwOutputNum: LongWord; wLanguage: Word; {out} pwszLanguageString: PWideChar;
var pcchLanguageStringLength: Word): HResult; stdcall;
function GetMaxSpeedFactor(out pdblFactor: Double): HResult; stdcall;
function IsUsingFastCache(out pfUsingFastCache: BOOL): HResult; stdcall;
function AddLogParam(wszNameSpace: PWideChar; wszName: PWideChar; wszValue: PWideChar): HResult; stdcall;
function SendLogParams: HResult; stdcall;
// Sets output parameter to TRUE if IWMReaderAdvanced2::SaveFileAs() is
// can be invoked for the current content.
function CanSaveFileAs(out pfCanSave: BOOL): HResult; stdcall;
// Cancels the current FileSaveAs operation
function CancelSaveFileAs: HResult; stdcall;
// This method returns the URL currently being played. This URL might be
// different from the URL passed in to IWMReader::Open, because the Reader
// may have been redirected to an alternate URL.
function GetURL(pwszURL: PWideChar; var pcchURL: LongWord): HResult; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMReaderAllocatorEx> _di_IWMReaderAllocatorEx;'}
{$EXTERNALSYM IWMReaderAllocatorEx}
IWMReaderAllocatorEx = interface(IUnknown)
['{9F762FA7-A22E-428D-93C9-AC82F3AAFE5A}']
(*** IWMReaderAllocatorEx methods ***)
function AllocateForStreamEx(wStreamNum: Word; cbBuffer: LongWord; out ppBuffer: INSSBuffer;
dwFlags: LongWord; cnsSampleTime: Int64;
cnsSampleDuration: Int64; pvContext: Pointer): HResult; stdcall;
function AllocateForOutputEx(dwOutputNum: LongWord; cbBuffer: LongWord;
out ppBuffer: INSSBuffer; dwFlags: LongWord;
cnsSampleTime: Int64; cnsSampleDuration: Int64;
pvContext: Pointer): HResult; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMReaderTypeNegotiation> _di_IWMReaderTypeNegotiation;'}
{$EXTERNALSYM IWMReaderTypeNegotiation}
IWMReaderTypeNegotiation = interface(IUnknown)
['{FDBE5592-81A1-41EA-93BD-735CAD1ADC05}']
(*** IWMReaderTypeNegotiation methods ***)
function TryOutputProps(dwOutputNum: LongWord; pOutput: IWMOutputMediaProps): HResult; stdcall;
end;
// For some advanced functionality, the IWMReaderCallback must support this
// interface.
{$HPPEMIT 'typedef System::DelphiInterface<IWMReaderCallbackAdvanced> _di_IWMReaderCallbackAdvanced;'}
{$EXTERNALSYM IWMReaderCallbackAdvanced}
IWMReaderCallbackAdvanced = interface(IUnknown)
['{96406BEB-2B2B-11D3-B36B-00C04F6108FF}']
(*** IWMReaderCallbackAdvanced methods ***)
// Receive a sample directly from the ASF. To get this call, the user
// must register himself to receive samples for a particular stream.
function OnStreamSample(wStreamNum: Word; cnsSampleTime: Int64;
cnsSampleDuration: Int64; dwFlags: LongWord;
pSample: INSSBuffer; pvContext: Pointer): HResult; stdcall;
// In some cases, the user may want to get callbacks telling what the
// reader thinks the current time is. This is interesting in 2 cases:
// - If the ASF has gaps in it; say no audio for 10 seconds. This call
// will continue to be called, while OnSample won't be called.
// - If the user is driving the clock, the reader needs to communicate
// back to the user its time, to avoid the user overrunning the reader.
function OnTime(cnsCurrentTime: Int64; pvContext: Pointer): HResult; stdcall;
// The user can also get callbacks when stream selection occurs.
function OnStreamSelection(wStreamCount: Word; pStreamNumbers: PWord;
pSelections: PWMTStreamSelection; pvContext: Pointer): HResult; stdcall;
// Will be called if the user got an async result from their
// call to SetOutputProps. The next sample you receive for
// this output will have these properties. The contents of the
// media type after calling SetOutputProps and before receiving
// an OutputPropsChanged notification are undefined.
function OnOutputPropsChanged(dwOutputNum: LongWord; pMediaType: PWMMediaType;
pvContext: Pointer): HResult; stdcall;
// If the user has registered to allocate buffers, this is where he must
// do it.
function AllocateForStream(wStreamNum: Word; cbBuffer: LongWord; out ppBuffer: INSSBuffer;
pvContext: Pointer): HResult; stdcall;
function AllocateForOutput(dwOutputNum: LongWord; cbBuffer: LongWord; out ppBuffer: INSSBuffer;
pvContext: Pointer): HResult; stdcall;
end;
// Used to access advanced DRM functionality.
{$HPPEMIT 'typedef System::DelphiInterface<IWMDRMReader> _di_IWMDRMReader;'}
{$EXTERNALSYM IWMDRMReader}
IWMDRMReader = interface(IUnknown)
['{D2827540-3EE7-432C-B14C-DC17F085D3B3}']
(*** IWMDRMReader methods ***)
function AcquireLicense(dwFlags: LongWord): HResult; stdcall;
function CancelLicenseAcquisition: HResult; stdcall;
function Individualize(dwFlags: LongWord): HResult; stdcall;
function CancelIndividualization: HResult; stdcall;
function MonitorLicenseAcquisition: HResult; stdcall;
function CancelMonitorLicenseAcquisition: HResult; stdcall;
function SetDRMProperty(pwstrName: PWideChar; dwType: TWMTAttrDataType; pValue: PByte;
cbLength: Word): HResult; stdcall;
function GetDRMProperty(pwstrName: PWideChar; out pdwType: TWMTAttrDataType; pValue: PByte;
var pcbLength: Word): HResult; stdcall;
end;
// Used to configure the network. This interface is implemented by
// the IWMReader object.
{$HPPEMIT 'typedef System::DelphiInterface<IWMReaderNetworkConfig> _di_IWMReaderNetworkConfig;'}
{$EXTERNALSYM IWMReaderNetworkConfig}
IWMReaderNetworkConfig = interface(IUnknown)
['{96406BEC-2B2B-11D3-B36B-00C04F6108FF}']
(*** IWMReaderNetworkConfig methods ***)
// Get and set the amount of time the network source will buffer
// data before rendering it.
function GetBufferingTime(out pcnsBufferingTime: Int64): HResult; stdcall;
function SetBufferingTime(cnsBufferingTime: Int64): HResult; stdcall;
// Returns the UDP port number ranges that will be used for receiving
// data. If no ranges are available, random UDP port numbers will be used.
function GetUDPPortRanges({out} pRangeArray: PWMPortNumberRange; var pcRanges: LongWord): HResult; stdcall;
// Sets the UDP port number ranges that can be used for receiving data.
// If no ranges are specified, random UDP port numbers will be used.
function SetUDPPortRanges({in} pRangeArray: PWMPortNumberRange; cRanges: LongWord): HResult; stdcall;
// Proxy settings: Manual proxy, Autodetect, UseBrowser (only for HTTP), or No Proxy.
function GetProxySettings(pwszProtocol: PWideChar; out pProxySetting: TWMTProxySettings): HResult; stdcall;
function SetProxySettings(pwszProtocol: PWideChar; ProxySetting: TWMTProxySettings): HResult; stdcall;
// The host to use as the proxy.
function GetProxyHostName(pwszProtocol: PWideChar; {out} pwszHostName: PWideChar;
var pcchHostName: LongWord): HResult; stdcall;
function SetProxyHostName(pwszProtocol: PWideChar; pwszHostName: PWideChar): HResult; stdcall;
// The port to use as the proxy.
function GetProxyPort(pwszProtocol: PWideChar; out pdwPort: LongWord): HResult; stdcall;
function SetProxyPort(pwszProtocol: PWideChar; dwPort: LongWord): HResult; stdcall;
// Get and set the proxy exception list.
function GetProxyExceptionList(pwszProtocol: PWideChar; {out} pwszExceptionList: PWideChar;
var pcchExceptionList: LongWord): HResult; stdcall;
function SetProxyExceptionList(pwszProtocol: PWideChar; pwszExceptionList: PWideChar): HResult; stdcall;
// Whether or not to bypass proxy for local hosts
function GetProxyBypassForLocal(pwszProtocol: PWideChar; out pfBypassForLocal: BOOL): HResult; stdcall;
function SetProxyBypassForLocal(pwszProtocol: PWideChar; fBypassForLocal: BOOL): HResult; stdcall;
// Whether to force a wpad discovery on the next run
function GetForceRerunAutoProxyDetection(out pfForceRerunDetection: BOOL): HResult; stdcall;
function SetForceRerunAutoProxyDetection(fForceRerunDetection: BOOL): HResult; stdcall;
// Whether or not to use multicast, http, tcp, or udp
function GetEnableMulticast(out pfEnableMulticast: BOOL): HResult; stdcall;
function SetEnableMulticast(fEnableMulticast: BOOL): HResult; stdcall;
function GetEnableHTTP(out pfEnableHTTP: BOOL): HResult; stdcall;
function SetEnableHTTP(fEnableHTTP: BOOL): HResult; stdcall;
function GetEnableUDP(out pfEnableUDP: BOOL): HResult; stdcall;
function SetEnableUDP(fEnableUDP: BOOL): HResult; stdcall;
function GetEnableTCP(out pfEnableTCP: BOOL): HResult; stdcall;
function SetEnableTCP(fEnableTCP: BOOL): HResult; stdcall;
// Forgets automatic protocol detection settings and redetects next time.
function ResetProtocolRollover: HResult; stdcall;
// Return or set the client's link bandwidth in bps. This is an optional
// setting. By default, the SDK will automatically detect its connection
// bandwidth to the streaming media server.
function GetConnectionBandwidth(out pdwConnectionBandwidth: LongWord): HResult; stdcall;
function SetConnectionBandwidth(dwConnectionBandwidth: LongWord): HResult; stdcall;
// Iterate through the network protocols supported by this reader
function GetNumProtocolsSupported(out pcProtocols: LongWord): HResult; stdcall;
function GetSupportedProtocolName(dwProtocolNum: LongWord; {out} pwszProtocolName: PWideChar;
var pcchProtocolName: LongWord): HResult; stdcall;
// Adds the specified pszUrl to the list of URL's to recieve logging data.
// This list is in addition to the origin server.
function AddLoggingUrl(pwszURL: PWideChar): HResult; stdcall;
// Fills the buffer with the URL corresponding to index dwIndex.
function GetLoggingUrl(dwIndex: LongWord; {out} pwszURL: PWideChar; var pcchURL: LongWord): HResult; stdcall;
// Returns the number of URLs in the current list of logging URLs.
function GetLoggingUrlCount(out pdwUrlCount: LongWord): HResult; stdcall;
// Clears the list of logging URLs
function ResetLoggingUrlList: HResult; stdcall;
end;
// Used to configure the network. This interface is implemented by
// the IWMReader object.
{$HPPEMIT 'typedef System::DelphiInterface<IWMReaderNetworkConfig2> _di_IWMReaderNetworkConfig2;'}
{$EXTERNALSYM IWMReaderNetworkConfig2}
IWMReaderNetworkConfig2 = interface(IWMReaderNetworkConfig)
['{D979A853-042B-4050-8387-C939DB22013F}']
(*** IWMReaderNetworkConfig2 methods ***)
// If enabled, allows streaming content (WMT_PLAY_MODE_STREAMING)
// to be cached locally.
function GetEnableContentCaching(out pfEnableContentCaching: BOOL): HResult; stdcall;
function SetEnableContentCaching(fEnableContentCaching: BOOL): HResult; stdcall;
// If enabled, allows streaming content to be streamed at a rate higher
// than the playback rate. This feature requires ContentCaching to be
// enabled as well.
function GetEnableFastCache(out pfEnableFastCache: BOOL): HResult; stdcall;
function SetEnableFastCache(fEnableFastCache: BOOL): HResult; stdcall;
function GetAcceleratedStreamingDuration(out pcnsAccelDuration: Int64): HResult; stdcall;
function SetAcceleratedStreamingDuration(cnsAccelDuration: Int64): HResult; stdcall;
function GetAutoReconnectLimit(out pdwAutoReconnectLimit: LongWord): HResult; stdcall;
function SetAutoReconnectLimit(dwAutoReconnectLimit: LongWord): HResult; stdcall;
function GetEnableResends(out pfEnableResends: BOOL): HResult; stdcall;
function SetEnableResends(fEnableResends: BOOL): HResult; stdcall;
function GetEnableThinning(out pfEnableThinning: BOOL): HResult; stdcall;
function SetEnableThinning(fEnableThinning: BOOL): HResult; stdcall;
function GetMaxNetPacketSize(out pdwMaxNetPacketSize: LongWord): HResult; stdcall;
end;
// Used to configure the network. This interface is implemented by
// the IWMReader object.
{$HPPEMIT 'typedef System::DelphiInterface<IWMReaderStreamClock> _di_IWMReaderStreamClock;'}
{$EXTERNALSYM IWMReaderStreamClock}
IWMReaderStreamClock = interface(IUnknown)
['{96406BED-2B2B-11D3-B36B-00C04F6108FF}']
(*** IWMReaderStreamClock methods ***)
// Get the current value of the stream clock
function GetTime(pcnsNow: PInt64): HResult; stdcall;
// Set or kill a timer. All timers are automatically
// killed whenever you stop the Reader. When a timer
// expires, you'll receive a WMT_TIMER OnStatus callback
// with hr == S_OK, pValue = TimerId and pvContext == pvParam.
function SetTimer(cnsWhen: Int64; pvParam: Pointer; out pdwTimerId: LongWord): HResult; stdcall;
function KillTimer(dwTimerId: LongWord): HResult; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMIndexer> _di_IWMIndexer;'}
{$EXTERNALSYM IWMIndexer}
IWMIndexer = interface(IUnknown)
['{6D7CDC71-9888-11D3-8EDC-00C04F6109CF}']
(*** IWMIndexer methods ***)
// Start is an asynchronous call; it returns almost immediately and the user
// should wait for appropriate OnStatus calls to be sent to the callback.
function StartIndexing(pwszURL: PWideChar; pCallback: IWMStatusCallback;
pvContext: Pointer): HResult; stdcall;
function Cancel: HResult; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMIndexer2> _di_IWMIndexer2;'}
{$EXTERNALSYM IWMIndexer2}
IWMIndexer2 = interface(IWMIndexer)
['{B70F1E42-6255-4DF0-A6B9-02B212D9E2BB}']
(*** IWMIndexer2 methods ***)
function Configure(wStreamNum: Word; nIndexerType: TWMTIndexType;
pvInterval: Pointer; pvIndexType: Pointer): HResult; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMLicenseBackup> _di_IWMLicenseBackup;'}
{$EXTERNALSYM IWMLicenseBackup}
IWMLicenseBackup = interface(IUnknown)
['{05E5AC9F-3FB6-4508-BB43-A4067BA1EBE8}']
(*** IWMLicenseBackup methods ***)
function BackupLicenses(dwFlags: LongWord; pCallback: IWMStatusCallback): HResult; stdcall;
function CancelLicenseBackup: HResult; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMLicenseRestore> _di_IWMLicenseRestore;'}
{$EXTERNALSYM IWMLicenseRestore}
IWMLicenseRestore = interface(IUnknown)
['{C70B6334-A22E-4EFB-A245-15E65A004A13}']
(*** IWMLicenseRestore methods ***)
function RestoreLicenses(dwFlags: LongWord; pCallback: IWMStatusCallback): HResult; stdcall;
function CancelLicenseRestore: HResult; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMBackupRestoreProps> _di_IWMBackupRestoreProps;'}
{$EXTERNALSYM IWMBackupRestoreProps}
IWMBackupRestoreProps = interface(IUnknown)
['{3C8E0DA6-996F-4FF3-A1AF-4838F9377E2E}']
(*** IWMBackupRestoreProps methods ***)
function GetPropCount(out pcProps: Word): HResult; stdcall;
function GetPropByIndex(wIndex: Word; {out} pwszName: PWideChar; var pcchNameLen: Word;
out pType: TWMTAttrDataType; {out} pValue: PByte; var pcbLength: Word): HResult; stdcall;
function GetPropByName(pszName: PWideChar; out pType: TWMTAttrDataType; {out} pValue: PByte;
var pcbLength: Word): HResult; stdcall;
function SetProp(pszName: PWideChar; Type_: TWMTAttrDataType; pValue: PByte; cbLength: Word): HResult; stdcall;
function RemoveProp(pcwszName: PWideChar): HResult; stdcall;
function RemoveAllProps: HResult; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMCodecInfo> _di_IWMCodecInfo;'}
{$EXTERNALSYM IWMCodecInfo}
IWMCodecInfo = interface(IUnknown)
['{A970F41E-34DE-4A98-B3BA-E4B3CA7528F0}']
(*** IWMCodecInfo methods ***)
function GetCodecInfoCount(const guidType: TGUID; out pcCodecs: LongWord): HResult; stdcall;
function GetCodecFormatCount(const guidType: TGUID; dwCodecIndex: LongWord; out pcFormat: LongWord): HResult; stdcall;
function GetCodecFormat(const guidType: TGUID; dwCodecIndex: LongWord; dwFormatIndex: LongWord;
out ppIStreamConfig: IWMStreamConfig): HResult; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMCodecInfo2> _di_IWMCodecInfo2;'}
{$EXTERNALSYM IWMCodecInfo2}
IWMCodecInfo2 = interface(IWMCodecInfo)
['{AA65E273-B686-4056-91EC-DD768D4DF710}']
(*** IWMCodecInfo2 methods ***)
function GetCodecName(const guidType: TGUID; dwCodecIndex: LongWord; {out} wszName: PWideChar;
var pcchName: LongWord): HResult; stdcall;
function GetCodecFormatDesc(const guidType: TGUID; dwCodecIndex: LongWord;
dwFormatIndex: LongWord; out ppIStreamConfig: IWMStreamConfig;
{out} wszDesc: PWideChar; var pcchDesc: LongWord): HResult; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMCodecInfo3> _di_IWMCodecInfo3;'}
{$EXTERNALSYM IWMCodecInfo3}
IWMCodecInfo3 = interface(IWMCodecInfo2)
['{7E51F487-4D93-4F98-8AB4-27D0565ADC51}']
(*** IWMCodecInfo3 methods ***)
function GetCodecFormatProp(const guidType: TGUID; dwCodecIndex: LongWord;
dwFormatIndex: LongWord; pszName: PWideChar;
out pType: TWMTAttrDataType; {out} pValue: PByte;
var pdwSize: LongWord): HResult; stdcall;
function GetCodecProp(const guidType: TGUID; dwCodecIndex: LongWord; pszName: PWideChar;
out pType: TWMTAttrDataType; {out} pValue: PByte; var pdwSize: LongWord): HResult; stdcall;
function SetCodecEnumerationSetting(const guidType: TGUID; dwCodecIndex: LongWord;
pszName: PWideChar; Type_: TWMTAttrDataType;
{in} pValue: PByte; dwSize: LongWord): HResult; stdcall;
function GetCodecEnumerationSetting(const guidType: TGUID; dwCodecIndex: LongWord;
pszName: PWideChar; out pType: TWMTAttrDataType;
{out} pValue: PByte; var pdwSize: LongWord): HResult; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMLanguageList> _di_IWMLanguageList;'}
{$EXTERNALSYM IWMLanguageList}
IWMLanguageList = interface(IUnknown)
['{DF683F00-2D49-4D8E-92B7-FB19F6A0DC57}']
(*** IWMLanguageList methods ***)
function GetLanguageCount(out pwCount: Word): HResult; stdcall;
function GetLanguageDetails(wIndex: Word; {out} pwszLanguageString: PWideChar;
var pcchLanguageStringLength: Word): HResult; stdcall;
function AddLanguageByRFC1766String(pwszLanguageString: PWideChar; out pwIndex: Word): HResult; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMWriterPushSink> _di_IWMWriterPushSink;'}
{$EXTERNALSYM IWMWriterPushSink}
IWMWriterPushSink = interface(IWMWriterSink)
['{DC10E6A5-072C-467D-BF57-6330A9DDE12A}']
(*** IWMWriterPushSink methods ***)
// Connect to a publishing point on the server.
// If the publishing point does not exist, and pwszTemplateURL is
// non-NULL, an attempt will be made to create a new publishing point based
// on the template URL.
function Connect(pwszURL: PWideChar; pwszTemplateURL: PWideChar; fAutoDestroy: BOOL): HResult; stdcall;
// Terminate the control connection with the downstream server. The data path on the
// downstream server remains active for 5 minutes after which it is cleaned up.
function Disconnect: HResult; stdcall;
// Gracefully end the push distribution session. This shuts down the data path on
// the server for the publishing point.
function EndSession: HResult; stdcall;
end;
// The writer can be QI'd for this interface to enumerate all of the
// watermark DMOs installed on a system.
{$HPPEMIT 'typedef System::DelphiInterface<IWMWatermarkInfo> _di_IWMWatermarkInfo;'}
{$EXTERNALSYM IWMWatermarkInfo}
IWMWatermarkInfo = interface(IUnknown)
['{6F497062-F2E2-4624-8EA7-9DD40D81FC8D}']
(*** IWMWatermarkInfo methods ***)
function GetWatermarkEntryCount(wmetType: TWMTWatermarkEntryType; out pdwCount: LongWord): HResult; stdcall;
function GetWatermarkEntry(wmetType: TWMTWatermarkEntryType; dwEntryNum: LongWord;
out pEntry: TWMTWatermarkEntry): HResult; stdcall;
end;
// The Reader can be QI'ed for this interface for DirectX-VA support
{$HPPEMIT 'typedef System::DelphiInterface<IWMReaderAccelerator> _di_IWMReaderAccelerator;'}
{$EXTERNALSYM IWMReaderAccelerator}
IWMReaderAccelerator = interface(IUnknown)
['{BDDC4D08-944D-4D52-A612-46C3FDA07DD4}']
(*** IWMReaderAccelerator methods ***)
function GetCodecInterface(dwOutputNum: LongWord; const riid: TGUID;
out ppvCodecInterface: Pointer): HResult; stdcall;
function Notify(dwOutputNum: LongWord; pSubtype: PWMMediaType): HResult; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMReaderTimecode> _di_IWMReaderTimecode;'}
{$EXTERNALSYM IWMReaderTimecode}
IWMReaderTimecode = interface(IUnknown)
['{F369E2F0-E081-4FE6-8450-B810B2F410D1}']
(*** IWMReaderTimecode methods ***)
// Get the number of ranges of timecode data for a given stream in the file.
// Returns 0 if there is no timecode index for the specified stream.
function GetTimecodeRangeCount(wStreamNum: Word; out pwRangeCount: Word): HResult; stdcall;
// Gets the first and last timecode available for a given range.
function GetTimecodeRangeBounds(wStreamNum: Word; wRangeNum: Word;
out pStartTimecode: LongWord; out pEndTimecode: LongWord): HResult; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMAddressAccess> _di_IWMAddressAccess;'}
{$EXTERNALSYM IWMAddressAccess}
IWMAddressAccess = interface(IUnknown)
['{BB3C6389-1633-4E92-AF14-9F3173BA39D0}']
(*** IWMAddressAccess methods ***)
// Determine the number of access list entries (by type)
function GetAccessEntryCount(aeType: WM_AETYPE; out pcEntries: LongWord): HResult; stdcall;
// Retrieve a single address access entry (by type)
function GetAccessEntry(aeType: WM_AETYPE; dwEntryNum: LongWord;
out pAddrAccessEntry: TWMAddressAccessEntry): HResult; stdcall;
// Add a single address access entry
function AddAccessEntry(aeType: WM_AETYPE; pAddrAccessEntry: PWMAddressAccessEntry): HResult; stdcall;
// Remove a single address access entry (by type)
function RemoveAccessEntry(aeType: WM_AETYPE; dwEntryNum: LongWord): HResult; stdcall;
end;
{$HPPEMIT 'typedef System::DelphiInterface<IWMAddressAccess2> _di_IWMAddressAccess2;'}
{$EXTERNALSYM IWMAddressAccess2}
IWMAddressAccess2 = interface(IWMAddressAccess)
['{65A83FC2-3E98-4D4D-81B5-2A742886B33D}']
(*** IWMAddressAccess2 methods ***)
// Retrieve a single address access entry (by type)
function GetAccessEntryEx(aeType: WM_AETYPE; dwEntryNum: LongWord;
out pbstrAddress: WideString; out pbstrMask: WideString): HResult; stdcall;
// Add a single address access entry
function AddAccessEntryEx(aeType: WM_AETYPE; bstrAddress: WideString;
bstrMask: WideString): HResult; stdcall;
end;
// Used to get "APIC" ID3v2 frames
{$HPPEMIT 'typedef System::DelphiInterface<IWMImageInfo> _di_IWMImageInfo;'}
{$EXTERNALSYM IWMImageInfo}
IWMImageInfo = interface(IUnknown)
['{9F0AA3B6-7267-4D89-88F2-BA915AA5C4C6}']
(*** IWMImageInfo methods ***)
function GetImageCount(out pcImages: LongWord): HResult; stdcall;
function GetImage(wIndex: LongWord; var pcchMIMEType: Word; {out} pwszMIMEType: PWideChar;
var pcchDescription: Word; {out} pwszDescription: PWideChar; out pImageType: Word;
var pcbImageData: LongWord; {out} pbImageData: PByte): HResult; stdcall;
end;
//*@@@+++@@@@******************************************************************
//
// Microsoft Windows Media
//
//*@@@---@@@@******************************************************************
//
const
IID_IConfigAsfWriter2 : TGUID = '{7989ccaa-53f0-44f0-884a-f3b03f6ae066}';
{$EXTERNALSYM IID_IConfigAsfWriter2}
IID_IConfigAsfWriter : TGUID = '{45086030-F7E4-486a-B504-826BB5792A3B}';
{$EXTERNALSYM IID_IConfigAsfWriter}
IID_IAMWMBufferPass : TGUID = '{6DD816D7-E740-4123-9E24-2444412644D8}';
{$EXTERNALSYM IID_IAMWMBufferPass}
IID_IAMWMBufferPassCallback : TGUID = '{B25B8372-D2D2-44b2-8653-1B8DAE332489}';
{$EXTERNALSYM IID_IAMWMBufferPassCallback}
EC_PREPROCESS_COMPLETE = $56;
{$EXTERNALSYM EC_PREPROCESS_COMPLETE}
type
IAMWMBufferPassCallback = interface;
// Interface used to setup callback for app to set/get properties on WindowsMedia buffers that
// are passed by the ASF reader and writer filters
{$HPPEMIT 'typedef System::DelphiInterface<IAMWMBufferPass> _di_IAMWMBufferPass;'}
{$EXTERNALSYM IAMWMBufferPass}
IAMWMBufferPass = interface(IUnknown)
['{6DD816D7-E740-4123-9E24-2444412644D8}']
(*** IAMWMBufferPass methods ***)
// set the interface to use for callback notification
function SetNotify(pCallback: IAMWMBufferPassCallback): HRESULT; stdcall;
end;
// Callback interface used to notify that a WindowMedia buffer is being passed. Typically implemented
// by the app and called by the ASF writer and reader filters.
{$HPPEMIT 'typedef System::DelphiInterface<IAMWMBufferPassCallback> _di_IAMWMBufferPassCallback;'}
{$EXTERNALSYM IAMWMBufferPassCallback}
IAMWMBufferPassCallback = interface(IUnknown)
['{B25B8372-D2D2-44b2-8653-1B8DAE332489}']
(*** IAMWMBufferPassCallback methods ***)
// give the callback receiver a chance to examine
// (and act on) the INSSBuffer3 before passing on
function Notify(pNSSBuffer3: INSSBuffer3; pPin: IPin;
prtStart, prtEnd: PReferenceTime): HRESULT; stdcall;
end;
// ASF Writer filter paramaters for IConfigAsfWriter2 interface
_AM_ASFWRITERCONFIG_PARAM = (
{$IFNDEF COMPILER6_UP}
AM_CONFIGASFWRITER_PARAM_INVALID_0,
AM_CONFIGASFWRITER_PARAM_AUTOINDEX, // dynamic indexing, lParam1 boolean, lParam2
{$ELSE}
AM_CONFIGASFWRITER_PARAM_AUTOINDEX = 1,
{$ENDIF}
AM_CONFIGASFWRITER_PARAM_MULTIPASS, // multipass encoding, app should be able
// to handle EC_PREPROCESS_COMPLETE events
AM_CONFIGASFWRITER_PARAM_DONTCOMPRESS // configure writer to take audio and video input data
// as-is, without any recompression, useful for repackaging
// content in the ASF container
);
{$EXTERNALSYM _AM_ASFWRITERCONFIG_PARAM}
TAMASFWriterConfigParam = _AM_ASFWRITERCONFIG_PARAM;
// Interface to control the ASF writer (version 2)
{$HPPEMIT 'typedef System::DelphiInterface<IConfigAsfWriter2> _di_IConfigAsfWriter2;'}
{$EXTERNALSYM IConfigAsfWriter2}
IConfigAsfWriter2 = interface(IConfigAsfWriter)
['{7989CCAA-53F0-44f0-884A-F3B03F6AE066}']
(*** IConfigAsfWriter2 methods ***)
// Helper method to allow caller to pass in a pin pointer and get back the associated
// stream number. This is helpful when using WMF SDK interfaces directly to work with
// stream-specific properties.
function StreamNumFromPin(pPin: IPin; out pwStreamNum: WORD): HRESULT; stdcall;
// Set value corresponding to the passed in parameter id
function SetParam(dwParam: TAMASFWriterConfigParam; dwParam1, dwParam2 {not used, must be 0}: LongWord): HRESULT; stdcall;
// Get value corresponding to the passed in parameter id
function GetParam(dwParam: LongWord; out pdwParam1, pdwParam2 {not used, must be 0}: LongWord): HRESULT; stdcall;
// Multipass encoding
function ResetMultiPassState: HRESULT; stdcall;
end;
// Interface to control the ASF writer
{$HPPEMIT 'typedef System::DelphiInterface<IConfigAsfWriter> _di_IConfigAsfWriter;'}
{$EXTERNALSYM IConfigAsfWriter}
IConfigAsfWriter = interface(IUnknown)
['{45086030-F7E4-486a-B504-826BB5792A3B}']
(*** IConfigAsfWriter methods ***)
// The user is expected to enumerate profiles using the wmsdk IWMProfileManager
// method and then pass the desired profile index to the ASF Writer filter via this
// method. The filter will then try to configure itself for the selected profile.
//
// NOTE: The following 2 XXXProfileId methods are obsolete and their use is not recommended.
// Once the WMF SDK added the notion of profile versions, their behavior became ambiguous.
// At the time of this release (Corona) the methods will assume use of the default profile
// version number and make no attempt to override that. For instance, in the Corona release
// version 9 profiles are assumed.
//
// Instead, it is recommended that apps use the XXXProfile methods which take the IWMProfile*
// directly or the ProfileGuid methods which take a profile GUID.
function ConfigureFilterUsingProfileId(dwProfileId: LongWord): HRESULT; stdcall;
function GetCurrentProfileId(out pdwProfileId: LongWord): HRESULT; stdcall;
//
// configure using a pre-defined wmsdk profile guid
//
function ConfigureFilterUsingProfileGuid(const guidProfile: TGUID): HRESULT; stdcall;
function GetCurrentProfileGuid(out pProfileGuid: TGUID): HRESULT; stdcall;
//
// Use these methods when a custom profile setup is preferred
//
function ConfigureFilterUsingProfile(pProfile: IWMProfile): HRESULT; stdcall;
function GetCurrentProfile(out ppProfile: IWMProfile): HRESULT; stdcall;
//
// allow app to control whether or not to index file
//
function SetIndexMode(bIndexFile: BOOL): HRESULT; stdcall;
function GetIndexMode(out pbIndexFile: BOOL): HRESULT; stdcall;
end;
// Microsoft Windows Media Technology
//
// Module Name:
// nserror.h
//
// Abstract:
// Definitions for Windows Media events.
//
// Here are the commented error ranges for the Windows Media Technologies Group
//
// LEGACY RANGES
//
// 0 - 199 = General NetShow errors
// 200 - 399 = NetShow error events
// 400 - 599 = NetShow monitor events
// 600 - 799 = NetShow IMmsAutoServer errors
// 1000 - 1199 = NetShow MCMADM errors
//
//
// NEW RANGES
//
// 2000 - 2999 = ASF (defined in ASFERR.MC)
// 3000 - 3999 = Windows Media SDK
// 4000 - 4999 = Windows Media Player
// 5000 - 5999 = Windows Media Server
// 6000 - 6999 = Windows Media HTTP/RTSP result codes (defined in NETERROR.MC)
// 7000 - 7999 = Windows Media Tools
// 8000 - 8999 = Windows Media Content Discovery
// 9000 - 9999 = Windows Media Real Time Collaboration
// 10000 - 10999 = Windows Media Digital Rights Management
// 11000 - 11999 = Windows Media Setup
// 12000 - 12999 = Windows Media Networking
// 13000 - 13999 = Windows Media Client Media Services
//#define STATUS_SEVERITY(hr) (((hr) >> 30) & 0x3)
/////////////////////////////////////////////////////////////////////////
//
// NETSHOW Success Events
//
/////////////////////////////////////////////////////////////////////////
//
// Values are 32 bit values layed out as follows:
//
// 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1
// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
// +---+-+-+-----------------------+-------------------------------+
// |Sev|C|R| Facility | Code |
// +---+-+-+-----------------------+-------------------------------+
//
// where
//
// Sev - is the severity code
//
// 00 - Success
// 01 - Informational
// 10 - Warning
// 11 - Error
//
// C - is the Customer code flag
//
// R - is a reserved bit
//
// Facility - is the facility code
//
// Code - is the facility's status code
//
//
// Define the facility codes
//
const
FACILITY_NS_WIN32 = $7;
{$EXTERNALSYM FACILITY_NS_WIN32}
FACILITY_NS = $D;
{$EXTERNALSYM FACILITY_NS}
//
// Define the severity codes
//
STATUS_SEVERITY_WARNING = $2;
{$EXTERNALSYM STATUS_SEVERITY_WARNING}
STATUS_SEVERITY_SUCCESS = $0;
{$EXTERNALSYM STATUS_SEVERITY_SUCCESS}
STATUS_SEVERITY_INFORMATIONAL = $1;
{$EXTERNALSYM STATUS_SEVERITY_INFORMATIONAL}
STATUS_SEVERITY_ERROR = $3;
{$EXTERNALSYM STATUS_SEVERITY_ERROR}
//
// MessageId: NS_S_CALLPENDING
//
// MessageText:
//
// The requested operation is pending completion.%0
//
NS_S_CALLPENDING = HRESULT($000D0000);
{$EXTERNALSYM NS_S_CALLPENDING}
//
// MessageId: NS_S_CALLABORTED
//
// MessageText:
//
// The requested operation was aborted by the client.%0
NS_S_CALLABORTED = HRESULT($000D0001);
{$EXTERNALSYM NS_S_CALLABORTED}
//
// MessageId: NS_S_STREAM_TRUNCATED
//
// MessageText:
//
// The stream was purposefully stopped before completion.%0
//
NS_S_STREAM_TRUNCATED = HRESULT($000D0002);
{$EXTERNALSYM NS_S_STREAM_TRUNCATED}
/////////////////////////////////////////////////////////////////////////
//
// NETSHOW Warning Events
//
/////////////////////////////////////////////////////////////////////////
//
// MessageId: NS_W_SERVER_BANDWIDTH_LIMIT
//
// MessageText:
//
// The maximum filebitrate value specified is greater than the server's configured maximum bandwidth.%0
//
NS_W_SERVER_BANDWIDTH_LIMIT = HRESULT($800D0003);
{$EXTERNALSYM NS_W_SERVER_BANDWIDTH_LIMIT}
//
// MessageId: NS_W_FILE_BANDWIDTH_LIMIT
//
// MessageText:
//
// The maximum bandwidth value specified is less than the maximum filebitrate.%0
//
NS_W_FILE_BANDWIDTH_LIMIT = HRESULT($800D0004);
{$EXTERNALSYM NS_W_FILE_BANDWIDTH_LIMIT}
/////////////////////////////////////////////////////////////////////////
//
// NETSHOW Error Events
//
/////////////////////////////////////////////////////////////////////////
//
// MessageId: NS_E_NOCONNECTION
//
// MessageText:
//
// There is no connection established with the Windows Media server. The operation failed.%0
//
NS_E_NOCONNECTION = HRESULT($C00D0005);
{$EXTERNALSYM NS_E_NOCONNECTION}
//
// MessageId: NS_E_CANNOTCONNECT
//
// MessageText:
//
// Unable to establish a connection to the server.%0
//
NS_E_CANNOTCONNECT = HRESULT($C00D0006);
{$EXTERNALSYM NS_E_CANNOTCONNECT}
//
// MessageId: NS_E_CANNOTDESTROYTITLE
//
// MessageText:
//
// Unable to destroy the title.%0
//
NS_E_CANNOTDESTROYTITLE = HRESULT($C00D0007);
{$EXTERNALSYM NS_E_CANNOTDESTROYTITLE}
//
// MessageId: NS_E_CANNOTRENAMETITLE
//
// MessageText:
//
// Unable to rename the title.%0
//
NS_E_CANNOTRENAMETITLE = HRESULT($C00D0008);
{$EXTERNALSYM NS_E_CANNOTRENAMETITLE}
//
// MessageId: NS_E_CANNOTOFFLINEDISK
//
// MessageText:
//
// Unable to offline disk.%0
//
NS_E_CANNOTOFFLINEDISK = HRESULT($C00D0009);
{$EXTERNALSYM NS_E_CANNOTOFFLINEDISK}
//
// MessageId: NS_E_CANNOTONLINEDISK
//
// MessageText:
//
// Unable to online disk.%0
//
NS_E_CANNOTONLINEDISK = HRESULT($C00D000A);
{$EXTERNALSYM NS_E_CANNOTONLINEDISK}
//
// MessageId: NS_E_NOREGISTEREDWALKER
//
// MessageText:
//
// There is no file parser registered for this type of file.%0
//
NS_E_NOREGISTEREDWALKER = HRESULT($C00D000B);
{$EXTERNALSYM NS_E_NOREGISTEREDWALKER}
//
// MessageId: NS_E_NOFUNNEL
//
// MessageText:
//
// There is no data connection established.%0
//
NS_E_NOFUNNEL = HRESULT($C00D000C);
{$EXTERNALSYM NS_E_NOFUNNEL}
//
// MessageId: NS_E_NO_LOCALPLAY
//
// MessageText:
//
// Failed to load the local play DLL.%0
//
NS_E_NO_LOCALPLAY = HRESULT($C00D000D);
{$EXTERNALSYM NS_E_NO_LOCALPLAY}
//
// MessageId: NS_E_NETWORK_BUSY
//
// MessageText:
//
// The network is busy.%0
//
NS_E_NETWORK_BUSY = HRESULT($C00D000E);
{$EXTERNALSYM NS_E_NETWORK_BUSY}
//
// MessageId: NS_E_TOO_MANY_SESS
//
// MessageText:
//
// The server session limit was exceeded.%0
//
NS_E_TOO_MANY_SESS = HRESULT($C00D000F);
{$EXTERNALSYM NS_E_TOO_MANY_SESS}
//
// MessageId: NS_E_ALREADY_CONNECTED
//
// MessageText:
//
// The network connection already exists.%0
//
NS_E_ALREADY_CONNECTED = HRESULT($C00D0010);
{$EXTERNALSYM NS_E_ALREADY_CONNECTED}
//
// MessageId: NS_E_INVALID_INDEX
//
// MessageText:
//
// Index %1 is invalid.%0
//
NS_E_INVALID_INDEX = HRESULT($C00D0011);
{$EXTERNALSYM NS_E_INVALID_INDEX}
//
// MessageId: NS_E_PROTOCOL_MISMATCH
//
// MessageText:
//
// There is no protocol or protocol version supported by both the client and the server.%0
//
NS_E_PROTOCOL_MISMATCH = HRESULT($C00D0012);
{$EXTERNALSYM NS_E_PROTOCOL_MISMATCH}
//
// MessageId: NS_E_TIMEOUT
//
// MessageText:
//
// The server, a computer set up to offer multimedia content to other computers, could not handle your request for multimedia content in a timely manner. Please try again later.%0
//
NS_E_TIMEOUT = HRESULT($C00D0013);
{$EXTERNALSYM NS_E_TIMEOUT}
//
// MessageId: NS_E_NET_WRITE
//
// MessageText:
//
// Error writing to the network.%0
//
NS_E_NET_WRITE = HRESULT($C00D0014);
{$EXTERNALSYM NS_E_NET_WRITE}
//
// MessageId: NS_E_NET_READ
//
// MessageText:
//
// Error reading from the network.%0
//
NS_E_NET_READ = HRESULT($C00D0015);
{$EXTERNALSYM NS_E_NET_READ}
//
// MessageId: NS_E_DISK_WRITE
//
// MessageText:
//
// Error writing to a disk.%0
//
NS_E_DISK_WRITE = HRESULT($C00D0016);
{$EXTERNALSYM NS_E_DISK_WRITE}
//
// MessageId: NS_E_DISK_READ
//
// MessageText:
//
// Error reading from a disk.%0
//
NS_E_DISK_READ = HRESULT($C00D0017);
{$EXTERNALSYM NS_E_DISK_READ}
//
// MessageId: NS_E_FILE_WRITE
//
// MessageText:
//
// Error writing to a file.%0
//
NS_E_FILE_WRITE = HRESULT($C00D0018);
{$EXTERNALSYM NS_E_FILE_WRITE}
//
// MessageId: NS_E_FILE_READ
//
// MessageText:
//
// Error reading from a file.%0
//
NS_E_FILE_READ = HRESULT($C00D0019);
{$EXTERNALSYM NS_E_FILE_READ}
//
// MessageId: NS_E_FILE_NOT_FOUND
//
// MessageText:
//
// The system cannot find the file specified.%0
//
NS_E_FILE_NOT_FOUND = HRESULT($C00D001A);
{$EXTERNALSYM NS_E_FILE_NOT_FOUND}
//
// MessageId: NS_E_FILE_EXISTS
//
// MessageText:
//
// The file already exists.%0
//
NS_E_FILE_EXISTS = HRESULT($C00D001B);
{$EXTERNALSYM NS_E_FILE_EXISTS}
//
// MessageId: NS_E_INVALID_NAME
//
// MessageText:
//
// The file name, directory name, or volume label syntax is incorrect.%0
//
NS_E_INVALID_NAME = HRESULT($C00D001C);
{$EXTERNALSYM NS_E_INVALID_NAME}
//
// MessageId: NS_E_FILE_OPEN_FAILED
//
// MessageText:
//
// Failed to open a file.%0
//
NS_E_FILE_OPEN_FAILED = HRESULT($C00D001D);
{$EXTERNALSYM NS_E_FILE_OPEN_FAILED}
//
// MessageId: NS_E_FILE_ALLOCATION_FAILED
//
// MessageText:
//
// Unable to allocate a file.%0
//
NS_E_FILE_ALLOCATION_FAILED = HRESULT($C00D001E);
{$EXTERNALSYM NS_E_FILE_ALLOCATION_FAILED}
//
// MessageId: NS_E_FILE_INIT_FAILED
//
// MessageText:
//
// Unable to initialize a file.%0
//
NS_E_FILE_INIT_FAILED = HRESULT($C00D001F);
{$EXTERNALSYM NS_E_FILE_INIT_FAILED}
//
// MessageId: NS_E_FILE_PLAY_FAILED
//
// MessageText:
//
// Unable to play a file.%0
//
NS_E_FILE_PLAY_FAILED = HRESULT($C00D0020);
{$EXTERNALSYM NS_E_FILE_PLAY_FAILED}
//
// MessageId: NS_E_SET_DISK_UID_FAILED
//
// MessageText:
//
// Could not set the disk UID.%0
//
NS_E_SET_DISK_UID_FAILED = HRESULT($C00D0021);
{$EXTERNALSYM NS_E_SET_DISK_UID_FAILED}
//
// MessageId: NS_E_INDUCED
//
// MessageText:
//
// An error was induced for testing purposes.%0
//
NS_E_INDUCED = HRESULT($C00D0022);
{$EXTERNALSYM NS_E_INDUCED}
//
// MessageId: NS_E_CCLINK_DOWN
//
// MessageText:
//
// Two Content Servers failed to communicate.%0
//
NS_E_CCLINK_DOWN = HRESULT($C00D0023);
{$EXTERNALSYM NS_E_CCLINK_DOWN}
//
// MessageId: NS_E_INTERNAL
//
// MessageText:
//
// An unknown error occurred.%0
//
NS_E_INTERNAL = HRESULT($C00D0024);
{$EXTERNALSYM NS_E_INTERNAL}
//
// MessageId: NS_E_BUSY
//
// MessageText:
//
// The requested resource is in use.%0
//
NS_E_BUSY = HRESULT($C00D0025);
{$EXTERNALSYM NS_E_BUSY}
//
// MessageId: NS_E_UNRECOGNIZED_STREAM_TYPE
//
// MessageText:
//
// The specified protocol is not recognized. Be sure that the file name and syntax, such as slashes, are correct for the protocol.%0
//
NS_E_UNRECOGNIZED_STREAM_TYPE = HRESULT($C00D0026);
{$EXTERNALSYM NS_E_UNRECOGNIZED_STREAM_TYPE}
//
// MessageId: NS_E_NETWORK_SERVICE_FAILURE
//
// MessageText:
//
// The network service provider failed.%0
//
NS_E_NETWORK_SERVICE_FAILURE = HRESULT($C00D0027);
{$EXTERNALSYM NS_E_NETWORK_SERVICE_FAILURE}
//
// MessageId: NS_E_NETWORK_RESOURCE_FAILURE
//
// MessageText:
//
// An attempt to acquire a network resource failed.%0
//
NS_E_NETWORK_RESOURCE_FAILURE = HRESULT($C00D0028);
{$EXTERNALSYM NS_E_NETWORK_RESOURCE_FAILURE}
//
// MessageId: NS_E_CONNECTION_FAILURE
//
// MessageText:
//
// The network connection has failed.%0
//
NS_E_CONNECTION_FAILURE = HRESULT($C00D0029);
{$EXTERNALSYM NS_E_CONNECTION_FAILURE}
//
// MessageId: NS_E_SHUTDOWN
//
// MessageText:
//
// The session is being terminated locally.%0
//
NS_E_SHUTDOWN = HRESULT($C00D002A);
{$EXTERNALSYM NS_E_SHUTDOWN}
//
// MessageId: NS_E_INVALID_REQUEST
//
// MessageText:
//
// The request is invalid in the current state.%0
//
NS_E_INVALID_REQUEST = HRESULT($C00D002B);
{$EXTERNALSYM NS_E_INVALID_REQUEST}
//
// MessageId: NS_E_INSUFFICIENT_BANDWIDTH
//
// MessageText:
//
// There is insufficient bandwidth available to fulfill the request.%0
//
NS_E_INSUFFICIENT_BANDWIDTH = HRESULT($C00D002C);
{$EXTERNALSYM NS_E_INSUFFICIENT_BANDWIDTH}
//
// MessageId: NS_E_NOT_REBUILDING
//
// MessageText:
//
// The disk is not rebuilding.%0
//
NS_E_NOT_REBUILDING = HRESULT($C00D002D);
{$EXTERNALSYM NS_E_NOT_REBUILDING}
//
// MessageId: NS_E_LATE_OPERATION
//
// MessageText:
//
// An operation requested for a particular time could not be carried out on schedule.%0
//
NS_E_LATE_OPERATION = HRESULT($C00D002E);
{$EXTERNALSYM NS_E_LATE_OPERATION}
//
// MessageId: NS_E_INVALID_DATA
//
// MessageText:
//
// Invalid or corrupt data was encountered.%0
//
NS_E_INVALID_DATA = HRESULT($C00D002F);
{$EXTERNALSYM NS_E_INVALID_DATA}
//
// MessageId: NS_E_FILE_BANDWIDTH_LIMIT
//
// MessageText:
//
// The bandwidth required to stream a file is higher than the maximum file bandwidth allowed on the server.%0
//
NS_E_FILE_BANDWIDTH_LIMIT = HRESULT($C00D0030);
{$EXTERNALSYM NS_E_FILE_BANDWIDTH_LIMIT}
//
// MessageId: NS_E_OPEN_FILE_LIMIT
//
// MessageText:
//
// The client cannot have any more files open simultaneously.%0
//
NS_E_OPEN_FILE_LIMIT = HRESULT($C00D0031);
{$EXTERNALSYM NS_E_OPEN_FILE_LIMIT}
//
// MessageId: NS_E_BAD_CONTROL_DATA
//
// MessageText:
//
// The server received invalid data from the client on the control connection.%0
//
NS_E_BAD_CONTROL_DATA = HRESULT($C00D0032);
{$EXTERNALSYM NS_E_BAD_CONTROL_DATA}
//
// MessageId: NS_E_NO_STREAM
//
// MessageText:
//
// There is no stream available.%0
//
NS_E_NO_STREAM = HRESULT($C00D0033);
{$EXTERNALSYM NS_E_NO_STREAM}
//
// MessageId: NS_E_STREAM_END
//
// MessageText:
//
// There is no more data in the stream.%0
//
NS_E_STREAM_END = HRESULT($C00D0034);
{$EXTERNALSYM NS_E_STREAM_END}
//
// MessageId: NS_E_SERVER_NOT_FOUND
//
// MessageText:
//
// The specified server could not be found.%0
//
NS_E_SERVER_NOT_FOUND = HRESULT($C00D0035);
{$EXTERNALSYM NS_E_SERVER_NOT_FOUND}
//
// MessageId: NS_E_DUPLICATE_NAME
//
// MessageText:
//
// The specified name is already in use.
//
NS_E_DUPLICATE_NAME = HRESULT($C00D0036);
{$EXTERNALSYM NS_E_DUPLICATE_NAME}
//
// MessageId: NS_E_DUPLICATE_ADDRESS
//
// MessageText:
//
// The specified address is already in use.
//
NS_E_DUPLICATE_ADDRESS = HRESULT($C00D0037);
{$EXTERNALSYM NS_E_DUPLICATE_ADDRESS}
//
// MessageId: NS_E_BAD_MULTICAST_ADDRESS
//
// MessageText:
//
// The specified address is not a valid multicast address.
//
NS_E_BAD_MULTICAST_ADDRESS = HRESULT($C00D0038);
{$EXTERNALSYM NS_E_BAD_MULTICAST_ADDRESS}
//
// MessageId: NS_E_BAD_ADAPTER_ADDRESS
//
// MessageText:
//
// The specified adapter address is invalid.
//
NS_E_BAD_ADAPTER_ADDRESS = HRESULT($C00D0039);
{$EXTERNALSYM NS_E_BAD_ADAPTER_ADDRESS}
//
// MessageId: NS_E_BAD_DELIVERY_MODE
//
// MessageText:
//
// The specified delivery mode is invalid.
//
NS_E_BAD_DELIVERY_MODE = HRESULT($C00D003A);
{$EXTERNALSYM NS_E_BAD_DELIVERY_MODE}
//
// MessageId: NS_E_INVALID_CHANNEL
//
// MessageText:
//
// The specified station does not exist.
//
NS_E_INVALID_CHANNEL = HRESULT($C00D003B);
{$EXTERNALSYM NS_E_INVALID_CHANNEL}
//
// MessageId: NS_E_INVALID_STREAM
//
// MessageText:
//
// The specified stream does not exist.
//
NS_E_INVALID_STREAM = HRESULT($C00D003C);
{$EXTERNALSYM NS_E_INVALID_STREAM}
//
// MessageId: NS_E_INVALID_ARCHIVE
//
// MessageText:
//
// The specified archive could not be opened.
//
NS_E_INVALID_ARCHIVE = HRESULT($C00D003D);
{$EXTERNALSYM NS_E_INVALID_ARCHIVE}
//
// MessageId: NS_E_NOTITLES
//
// MessageText:
//
// The system cannot find any titles on the server.%0
//
NS_E_NOTITLES = HRESULT($C00D003E);
{$EXTERNALSYM NS_E_NOTITLES}
//
// MessageId: NS_E_INVALID_CLIENT
//
// MessageText:
//
// The system cannot find the client specified.%0
//
NS_E_INVALID_CLIENT = HRESULT($C00D003F);
{$EXTERNALSYM NS_E_INVALID_CLIENT}
//
// MessageId: NS_E_INVALID_BLACKHOLE_ADDRESS
//
// MessageText:
//
// The Blackhole Address is not initialized.%0
//
NS_E_INVALID_BLACKHOLE_ADDRESS = HRESULT($C00D0040);
{$EXTERNALSYM NS_E_INVALID_BLACKHOLE_ADDRESS}
//
// MessageId: NS_E_INCOMPATIBLE_FORMAT
//
// MessageText:
//
// The station does not support the stream format.
//
NS_E_INCOMPATIBLE_FORMAT = HRESULT($C00D0041);
{$EXTERNALSYM NS_E_INCOMPATIBLE_FORMAT}
//
// MessageId: NS_E_INVALID_KEY
//
// MessageText:
//
// The specified key is not valid.
//
NS_E_INVALID_KEY = HRESULT($C00D0042);
{$EXTERNALSYM NS_E_INVALID_KEY}
//
// MessageId: NS_E_INVALID_PORT
//
// MessageText:
//
// The specified port is not valid.
//
NS_E_INVALID_PORT = HRESULT($C00D0043);
{$EXTERNALSYM NS_E_INVALID_PORT}
//
// MessageId: NS_E_INVALID_TTL
//
// MessageText:
//
// The specified TTL is not valid.
//
NS_E_INVALID_TTL = HRESULT($C00D0044);
{$EXTERNALSYM NS_E_INVALID_TTL}
//
// MessageId: NS_E_STRIDE_REFUSED
//
// MessageText:
//
// The request to fast forward or rewind could not be fulfilled.
//
NS_E_STRIDE_REFUSED = HRESULT($C00D0045);
{$EXTERNALSYM NS_E_STRIDE_REFUSED}
//
// IMmsAutoServer Errors
//
//
// MessageId: NS_E_MMSAUTOSERVER_CANTFINDWALKER
//
// MessageText:
//
// Unable to load the appropriate file parser.%0
//
NS_E_MMSAUTOSERVER_CANTFINDWALKER = HRESULT($C00D0046);
{$EXTERNALSYM NS_E_MMSAUTOSERVER_CANTFINDWALKER}
//
// MessageId: NS_E_MAX_BITRATE
//
// MessageText:
//
// Cannot exceed the maximum bandwidth limit.%0
//
NS_E_MAX_BITRATE = HRESULT($C00D0047);
{$EXTERNALSYM NS_E_MAX_BITRATE}
//
// MessageId: NS_E_LOGFILEPERIOD
//
// MessageText:
//
// Invalid value for LogFilePeriod.%0
//
NS_E_LOGFILEPERIOD = HRESULT($C00D0048);
{$EXTERNALSYM NS_E_LOGFILEPERIOD}
//
// MessageId: NS_E_MAX_CLIENTS
//
// MessageText:
//
// Cannot exceed the maximum client limit.%0
//
//
NS_E_MAX_CLIENTS = HRESULT($C00D0049);
{$EXTERNALSYM NS_E_MAX_CLIENTS}
//
// MessageId: NS_E_LOG_FILE_SIZE
//
// MessageText:
//
// The maximum log file size has been reached.%0
//
//
NS_E_LOG_FILE_SIZE = HRESULT($C00D004A);
{$EXTERNALSYM NS_E_LOG_FILE_SIZE}
//
// MessageId: NS_E_MAX_FILERATE
//
// MessageText:
//
// Cannot exceed the maximum file rate.%0
//
NS_E_MAX_FILERATE = HRESULT($C00D004B);
{$EXTERNALSYM NS_E_MAX_FILERATE}
//
// File Walker Errors
//
//
// MessageId: NS_E_WALKER_UNKNOWN
//
// MessageText:
//
// Unknown file type.%0
//
NS_E_WALKER_UNKNOWN = HRESULT($C00D004C);
{$EXTERNALSYM NS_E_WALKER_UNKNOWN}
//
// MessageId: NS_E_WALKER_SERVER
//
// MessageText:
//
// The specified file, %1, cannot be loaded onto the specified server, %2.%0
//
NS_E_WALKER_SERVER = HRESULT($C00D004D);
{$EXTERNALSYM NS_E_WALKER_SERVER}
//
// MessageId: NS_E_WALKER_USAGE
//
// MessageText:
//
// There was a usage error with file parser.%0
//
NS_E_WALKER_USAGE = HRESULT($C00D004E);
{$EXTERNALSYM NS_E_WALKER_USAGE}
/////////////////////////////////////////////////////////////////////////
//
// NETSHOW Monitor Events
//
/////////////////////////////////////////////////////////////////////////
// Tiger Events
// %1 is the tiger name
//
// MessageId: NS_I_TIGER_START
//
// MessageText:
//
// The Title Server %1 is running.%0
//
NS_I_TIGER_START = HRESULT($400D004F);
{$EXTERNALSYM NS_I_TIGER_START}
//
// MessageId: NS_E_TIGER_FAIL
//
// MessageText:
//
// The Title Server %1 has failed.%0
//
NS_E_TIGER_FAIL = HRESULT($C00D0050);
{$EXTERNALSYM NS_E_TIGER_FAIL}
// Cub Events
// %1 is the cub ID
// %2 is the cub name
//
// MessageId: NS_I_CUB_START
//
// MessageText:
//
// Content Server %1 (%2) is starting.%0
//
NS_I_CUB_START = HRESULT($400D0051);
{$EXTERNALSYM NS_I_CUB_START}
//
// MessageId: NS_I_CUB_RUNNING
//
// MessageText:
//
// Content Server %1 (%2) is running.%0
//
NS_I_CUB_RUNNING = HRESULT($400D0052);
{$EXTERNALSYM NS_I_CUB_RUNNING}
//
// MessageId: NS_E_CUB_FAIL
//
// MessageText:
//
// Content Server %1 (%2) has failed.%0
//
NS_E_CUB_FAIL = HRESULT($C00D0053);
{$EXTERNALSYM NS_E_CUB_FAIL}
// Disk Events
// %1 is the tiger disk ID
// %2 is the device name
// %3 is the cub ID
//
// MessageId: NS_I_DISK_START
//
// MessageText:
//
// Disk %1 ( %2 ) on Content Server %3, is running.%0
//
NS_I_DISK_START = HRESULT($400D0054);
{$EXTERNALSYM NS_I_DISK_START}
//
// MessageId: NS_E_DISK_FAIL
//
// MessageText:
//
// Disk %1 ( %2 ) on Content Server %3, has failed.%0
//
NS_E_DISK_FAIL = HRESULT($C00D0055);
{$EXTERNALSYM NS_E_DISK_FAIL}
//
// MessageId: NS_I_DISK_REBUILD_STARTED
//
// MessageText:
//
// Started rebuilding disk %1 ( %2 ) on Content Server %3.%0
//
NS_I_DISK_REBUILD_STARTED = HRESULT($400D0056);
{$EXTERNALSYM NS_I_DISK_REBUILD_STARTED}
//
// MessageId: NS_I_DISK_REBUILD_FINISHED
//
// MessageText:
//
// Finished rebuilding disk %1 ( %2 ) on Content Server %3.%0
//
NS_I_DISK_REBUILD_FINISHED = HRESULT($400D0057);
{$EXTERNALSYM NS_I_DISK_REBUILD_FINISHED}
//
// MessageId: NS_I_DISK_REBUILD_ABORTED
//
// MessageText:
//
// Aborted rebuilding disk %1 ( %2 ) on Content Server %3.%0
//
NS_I_DISK_REBUILD_ABORTED = HRESULT($400D0058);
{$EXTERNALSYM NS_I_DISK_REBUILD_ABORTED}
// Admin Events
//
// MessageId: NS_I_LIMIT_FUNNELS
//
// MessageText:
//
// A NetShow administrator at network location %1 set the data stream limit to %2 streams.%0
//
NS_I_LIMIT_FUNNELS = HRESULT($400D0059);
{$EXTERNALSYM NS_I_LIMIT_FUNNELS}
//
// MessageId: NS_I_START_DISK
//
// MessageText:
//
// A NetShow administrator at network location %1 started disk %2.%0
//
NS_I_START_DISK = HRESULT($400D005A);
{$EXTERNALSYM NS_I_START_DISK}
//
// MessageId: NS_I_STOP_DISK
//
// MessageText:
//
// A NetShow administrator at network location %1 stopped disk %2.%0
//
NS_I_STOP_DISK = HRESULT($400D005B);
{$EXTERNALSYM NS_I_STOP_DISK}
//
// MessageId: NS_I_STOP_CUB
//
// MessageText:
//
// A NetShow administrator at network location %1 stopped Content Server %2.%0
//
NS_I_STOP_CUB = HRESULT($400D005C);
{$EXTERNALSYM NS_I_STOP_CUB}
//
// MessageId: NS_I_KILL_USERSESSION
//
// MessageText:
//
// A NetShow administrator at network location %1 aborted user session %2 from the system.%0
//
NS_I_KILL_USERSESSION = HRESULT($400D005D);
{$EXTERNALSYM NS_I_KILL_USERSESSION}
//
// MessageId: NS_I_KILL_CONNECTION
//
// MessageText:
//
// A NetShow administrator at network location %1 aborted obsolete connection %2 from the system.%0
//
NS_I_KILL_CONNECTION = HRESULT($400D005E);
{$EXTERNALSYM NS_I_KILL_CONNECTION}
//
// MessageId: NS_I_REBUILD_DISK
//
// MessageText:
//
// A NetShow administrator at network location %1 started rebuilding disk %2.%0
//
NS_I_REBUILD_DISK = HRESULT($400D005F);
{$EXTERNALSYM NS_I_REBUILD_DISK}
//
// MessageId: NS_W_UNKNOWN_EVENT
//
// MessageText:
//
// Unknown %1 event encountered.%0
//
NS_W_UNKNOWN_EVENT = HRESULT($800D0060);
{$EXTERNALSYM NS_W_UNKNOWN_EVENT}
// Alerts
//
// MessageId: NS_E_MAX_FUNNELS_ALERT
//
// MessageText:
//
// The NetShow data stream limit of %1 streams was reached.%0
//
NS_E_MAX_FUNNELS_ALERT = HRESULT($C00D0060);
{$EXTERNALSYM NS_E_MAX_FUNNELS_ALERT}
//
// MessageId: NS_E_ALLOCATE_FILE_FAIL
//
// MessageText:
//
// The NetShow Video Server was unable to allocate a %1 block file named %2.%0
//
NS_E_ALLOCATE_FILE_FAIL = HRESULT($C00D0061);
{$EXTERNALSYM NS_E_ALLOCATE_FILE_FAIL}
//
// MessageId: NS_E_PAGING_ERROR
//
// MessageText:
//
// A Content Server was unable to page a block.%0
//
NS_E_PAGING_ERROR = HRESULT($C00D0062);
{$EXTERNALSYM NS_E_PAGING_ERROR}
//
// MessageId: NS_E_BAD_BLOCK0_VERSION
//
// MessageText:
//
// Disk %1 has unrecognized control block version %2.%0
//
NS_E_BAD_BLOCK0_VERSION = HRESULT($C00D0063);
{$EXTERNALSYM NS_E_BAD_BLOCK0_VERSION}
//
// MessageId: NS_E_BAD_DISK_UID
//
// MessageText:
//
// Disk %1 has incorrect uid %2.%0
//
NS_E_BAD_DISK_UID = HRESULT($C00D0064);
{$EXTERNALSYM NS_E_BAD_DISK_UID}
//
// MessageId: NS_E_BAD_FSMAJOR_VERSION
//
// MessageText:
//
// Disk %1 has unsupported file system major version %2.%0
//
NS_E_BAD_FSMAJOR_VERSION = HRESULT($C00D0065);
{$EXTERNALSYM NS_E_BAD_FSMAJOR_VERSION}
//
// MessageId: NS_E_BAD_STAMPNUMBER
//
// MessageText:
//
// Disk %1 has bad stamp number in control block.%0
//
NS_E_BAD_STAMPNUMBER = HRESULT($C00D0066);
{$EXTERNALSYM NS_E_BAD_STAMPNUMBER}
//
// MessageId: NS_E_PARTIALLY_REBUILT_DISK
//
// MessageText:
//
// Disk %1 is partially reconstructed.%0
//
NS_E_PARTIALLY_REBUILT_DISK = HRESULT($C00D0067);
{$EXTERNALSYM NS_E_PARTIALLY_REBUILT_DISK}
//
// MessageId: NS_E_ENACTPLAN_GIVEUP
//
// MessageText:
//
// EnactPlan gives up.%0
//
NS_E_ENACTPLAN_GIVEUP = HRESULT($C00D0068);
{$EXTERNALSYM NS_E_ENACTPLAN_GIVEUP}
// MCMADM warnings/errors
//
// MessageId: MCMADM_I_NO_EVENTS
//
// MessageText:
//
// Event initialization failed, there will be no MCM events.%0
//
MCMADM_I_NO_EVENTS = HRESULT($400D0069);
{$EXTERNALSYM MCMADM_I_NO_EVENTS}
//
// MessageId: MCMADM_E_REGKEY_NOT_FOUND
//
// MessageText:
//
// The key was not found in the registry.%0
//
MCMADM_E_REGKEY_NOT_FOUND = HRESULT($C00D006A);
{$EXTERNALSYM MCMADM_E_REGKEY_NOT_FOUND}
//
// MessageId: NS_E_NO_FORMATS
//
// MessageText:
//
// The publishing point cannot be started because the server does not have the appropriate stream formats. Use the Multicast Announcement Wizard to create a new announcement for this publishing point.%0
//
NS_E_NO_FORMATS = HRESULT($C00D006B);
{$EXTERNALSYM NS_E_NO_FORMATS}
//
// MessageId: NS_E_NO_REFERENCES
//
// MessageText:
//
// No reference URLs were found in an ASX file.%0
//
NS_E_NO_REFERENCES = HRESULT($C00D006C);
{$EXTERNALSYM NS_E_NO_REFERENCES}
//
// MessageId: NS_E_WAVE_OPEN
//
// MessageText:
//
// Error opening wave device, the device might be in use.%0
//
NS_E_WAVE_OPEN = HRESULT($C00D006D);
{$EXTERNALSYM NS_E_WAVE_OPEN}
//
// MessageId: NS_I_LOGGING_FAILED
//
// MessageText:
//
// The logging operation failed.
//
NS_I_LOGGING_FAILED = HRESULT($400D006E);
{$EXTERNALSYM NS_I_LOGGING_FAILED}
//
// MessageId: NS_E_CANNOTCONNECTEVENTS
//
// MessageText:
//
// Unable to establish a connection to the NetShow event monitor service.%0
//
NS_E_CANNOTCONNECTEVENTS = HRESULT($C00D006F);
{$EXTERNALSYM NS_E_CANNOTCONNECTEVENTS}
//
// MessageId: NS_I_LIMIT_BANDWIDTH
//
// MessageText:
//
// A NetShow administrator at network location %1 set the maximum bandwidth limit to %2 bps.%0
//
NS_I_LIMIT_BANDWIDTH = HRESULT($400D0070);
{$EXTERNALSYM NS_I_LIMIT_BANDWIDTH}
//
// MessageId: NS_E_NO_DEVICE
//
// MessageText:
//
// No device driver is present on the system.%0
//
NS_E_NO_DEVICE = HRESULT($C00D0071);
{$EXTERNALSYM NS_E_NO_DEVICE}
//
// MessageId: NS_E_NO_SPECIFIED_DEVICE
//
// MessageText:
//
// No specified device driver is present.%0
//
NS_E_NO_SPECIFIED_DEVICE = HRESULT($C00D0072);
{$EXTERNALSYM NS_E_NO_SPECIFIED_DEVICE}
// NOTENOTE!!!
//
// Due to legacy problems these error codes live inside the ASF error code range
//
//
// MessageId: NS_E_NOTHING_TO_DO
//
// MessageText:
//
// NS_E_NOTHING_TO_DO
//
NS_E_NOTHING_TO_DO = HRESULT($C00D07F1);
{$EXTERNALSYM NS_E_NOTHING_TO_DO}
//
// MessageId: NS_E_NO_MULTICAST
//
// MessageText:
//
// Not receiving data from the server.%0
//
NS_E_NO_MULTICAST = HRESULT($C00D07F2);
{$EXTERNALSYM NS_E_NO_MULTICAST}
/////////////////////////////////////////////////////////////////////////
//
// NETSHOW Error Events
//
// IdRange = 200..399
//
/////////////////////////////////////////////////////////////////////////
//
// MessageId: NS_E_MONITOR_GIVEUP
//
// MessageText:
//
// Netshow Events Monitor is not operational and has been disconnected.%0
//
NS_E_MONITOR_GIVEUP = HRESULT($C00D00C8);
{$EXTERNALSYM NS_E_MONITOR_GIVEUP}
//
// MessageId: NS_E_REMIRRORED_DISK
//
// MessageText:
//
// Disk %1 is remirrored.%0
//
NS_E_REMIRRORED_DISK = HRESULT($C00D00C9);
{$EXTERNALSYM NS_E_REMIRRORED_DISK}
//
// MessageId: NS_E_INSUFFICIENT_DATA
//
// MessageText:
//
// Insufficient data found.%0
//
NS_E_INSUFFICIENT_DATA = HRESULT($C00D00CA);
{$EXTERNALSYM NS_E_INSUFFICIENT_DATA}
//
// MessageId: NS_E_ASSERT
//
// MessageText:
//
// %1 failed in file %2 line %3.%0
//
NS_E_ASSERT = HRESULT($C00D00CB);
{$EXTERNALSYM NS_E_ASSERT}
//
// MessageId: NS_E_BAD_ADAPTER_NAME
//
// MessageText:
//
// The specified adapter name is invalid.%0
//
NS_E_BAD_ADAPTER_NAME = HRESULT($C00D00CC);
{$EXTERNALSYM NS_E_BAD_ADAPTER_NAME}
//
// MessageId: NS_E_NOT_LICENSED
//
// MessageText:
//
// The application is not licensed for this feature.%0
//
NS_E_NOT_LICENSED = HRESULT($C00D00CD);
{$EXTERNALSYM NS_E_NOT_LICENSED}
//
// MessageId: NS_E_NO_SERVER_CONTACT
//
// MessageText:
//
// Unable to contact the server.%0
//
NS_E_NO_SERVER_CONTACT = HRESULT($C00D00CE);
{$EXTERNALSYM NS_E_NO_SERVER_CONTACT}
//
// MessageId: NS_E_TOO_MANY_TITLES
//
// MessageText:
//
// Maximum number of titles exceeded.%0
//
NS_E_TOO_MANY_TITLES = HRESULT($C00D00CF);
{$EXTERNALSYM NS_E_TOO_MANY_TITLES}
//
// MessageId: NS_E_TITLE_SIZE_EXCEEDED
//
// MessageText:
//
// Maximum size of a title exceeded.%0
//
NS_E_TITLE_SIZE_EXCEEDED = HRESULT($C00D00D0);
{$EXTERNALSYM NS_E_TITLE_SIZE_EXCEEDED}
//
// MessageId: NS_E_UDP_DISABLED
//
// MessageText:
//
// UDP protocol not enabled. Not trying %1!ls!.%0
//
NS_E_UDP_DISABLED = HRESULT($C00D00D1);
{$EXTERNALSYM NS_E_UDP_DISABLED}
//
// MessageId: NS_E_TCP_DISABLED
//
// MessageText:
//
// TCP protocol not enabled. Not trying %1!ls!.%0
//
NS_E_TCP_DISABLED = HRESULT($C00D00D2);
{$EXTERNALSYM NS_E_TCP_DISABLED}
//
// MessageId: NS_E_HTTP_DISABLED
//
// MessageText:
//
// HTTP protocol not enabled. Not trying %1!ls!.%0
//
NS_E_HTTP_DISABLED = HRESULT($C00D00D3);
{$EXTERNALSYM NS_E_HTTP_DISABLED}
//
// MessageId: NS_E_LICENSE_EXPIRED
//
// MessageText:
//
// The product license has expired.%0
//
NS_E_LICENSE_EXPIRED = HRESULT($C00D00D4);
{$EXTERNALSYM NS_E_LICENSE_EXPIRED}
//
// MessageId: NS_E_TITLE_BITRATE
//
// MessageText:
//
// Source file exceeds the per title maximum bitrate. See NetShow Theater documentation for more information.%0
//
NS_E_TITLE_BITRATE = HRESULT($C00D00D5);
{$EXTERNALSYM NS_E_TITLE_BITRATE}
//
// MessageId: NS_E_EMPTY_PROGRAM_NAME
//
// MessageText:
//
// The program name cannot be empty.%0
//
NS_E_EMPTY_PROGRAM_NAME = HRESULT($C00D00D6);
{$EXTERNALSYM NS_E_EMPTY_PROGRAM_NAME}
//
// MessageId: NS_E_MISSING_CHANNEL
//
// MessageText:
//
// Station %1 does not exist.%0
//
NS_E_MISSING_CHANNEL = HRESULT($C00D00D7);
{$EXTERNALSYM NS_E_MISSING_CHANNEL}
//
// MessageId: NS_E_NO_CHANNELS
//
// MessageText:
//
// You need to define at least one station before this operation can complete.%0
//
NS_E_NO_CHANNELS = HRESULT($C00D00D8);
{$EXTERNALSYM NS_E_NO_CHANNELS}
/////////////////////////////////////////////////////////////////////
// This error message is to replace previous NS_E_INVALID_INDEX which
// takes an index value for the error message string. For some application
// obtain the idex value at reporting error time is very difficult, so we
// use this string to avoid the problem.
//////////////////////////////////////////////////////////////////////
//
// MessageId: NS_E_INVALID_INDEX2
//
// MessageText:
//
// The index specified is invalid.%0
//
NS_E_INVALID_INDEX2 = HRESULT($C00D00D9);
{$EXTERNALSYM NS_E_INVALID_INDEX2}
/////////////////////////////////////////////////////////////////////////
//
// NETSHOW Monitor Events
//
// IdRange = 400..599
//
// Admin Events:
//
// Alerts:
//
// Title Server:
// %1 is the Title Server name
//
// Content Server:
// %1 is the Content Server ID
// %2 is the Content Server name
// %3 is the Peer Content Server name (optiona);
//
// Disks:
// %1 is the Title Server disk ID
// %2 is the device name
// %3 is the Content Server ID
//
/////////////////////////////////////////////////////////////////////////
//
// MessageId: NS_E_CUB_FAIL_LINK
//
// MessageText:
//
// Content Server %1 (%2) has failed its link to Content Server %3.%0
//
NS_E_CUB_FAIL_LINK = HRESULT($C00D0190);
{$EXTERNALSYM NS_E_CUB_FAIL_LINK}
//
// MessageId: NS_I_CUB_UNFAIL_LINK
//
// MessageText:
//
// Content Server %1 (%2) has established its link to Content Server %3.%0
//
NS_I_CUB_UNFAIL_LINK = HRESULT($400D0191);
{$EXTERNALSYM NS_I_CUB_UNFAIL_LINK}
//
// MessageId: NS_E_BAD_CUB_UID
//
// MessageText:
//
// Content Server %1 (%2) has incorrect uid %3.%0
//
NS_E_BAD_CUB_UID = HRESULT($C00D0192);
{$EXTERNALSYM NS_E_BAD_CUB_UID}
//
// MessageId: NS_I_RESTRIPE_START
//
// MessageText:
//
// Restripe operation has started.%0
//
NS_I_RESTRIPE_START = HRESULT($400D0193);
{$EXTERNALSYM NS_I_RESTRIPE_START}
//
// MessageId: NS_I_RESTRIPE_DONE
//
// MessageText:
//
// Restripe operation has completed.%0
//
NS_I_RESTRIPE_DONE = HRESULT($400D0194);
{$EXTERNALSYM NS_I_RESTRIPE_DONE}
//
// MessageId: NS_E_GLITCH_MODE
//
// MessageText:
//
// Server unreliable because multiple components failed.%0
//
NS_E_GLITCH_MODE = HRESULT($C00D0195);
{$EXTERNALSYM NS_E_GLITCH_MODE}
//
// MessageId: NS_I_RESTRIPE_DISK_OUT
//
// MessageText:
//
// Content disk %1 (%2) on Content Server %3 has been restriped out.%0
//
NS_I_RESTRIPE_DISK_OUT = HRESULT($400D0196);
{$EXTERNALSYM NS_I_RESTRIPE_DISK_OUT}
//
// MessageId: NS_I_RESTRIPE_CUB_OUT
//
// MessageText:
//
// Content server %1 (%2) has been restriped out.%0
//
NS_I_RESTRIPE_CUB_OUT = HRESULT($400D0197);
{$EXTERNALSYM NS_I_RESTRIPE_CUB_OUT}
//
// MessageId: NS_I_DISK_STOP
//
// MessageText:
//
// Disk %1 ( %2 ) on Content Server %3, has been offlined.%0
//
NS_I_DISK_STOP = HRESULT($400D0198);
{$EXTERNALSYM NS_I_DISK_STOP}
//
// MessageId: NS_I_CATATONIC_FAILURE
//
// MessageText:
//
// Disk %1 ( %2 ) on Content Server %3, will be failed because it is catatonic.%0
//
NS_I_CATATONIC_FAILURE = HRESULT($800D0199);
{$EXTERNALSYM NS_I_CATATONIC_FAILURE}
//
// MessageId: NS_I_CATATONIC_AUTO_UNFAIL
//
// MessageText:
//
// Disk %1 ( %2 ) on Content Server %3, auto online from catatonic state.%0
//
NS_I_CATATONIC_AUTO_UNFAIL = HRESULT($800D019A);
{$EXTERNALSYM NS_I_CATATONIC_AUTO_UNFAIL}
//
// MessageId: NS_E_NO_MEDIA_PROTOCOL
//
// MessageText:
//
// Content Server %1 (%2) is unable to communicate with the Media System Network Protocol.%0
//
NS_E_NO_MEDIA_PROTOCOL = HRESULT($C00D019B);
{$EXTERNALSYM NS_E_NO_MEDIA_PROTOCOL}
//
// Advanced Streaming Format (ASF) codes occupy MessageIds 2000-2999
//
// See ASFErr.mc for more details - please do not define any symbols
// in that range in this file.
//
/////////////////////////////////////////////////////////////////////////
//
// Windows Media SDK Errors
//
// IdRange = 3000-3199
//
/////////////////////////////////////////////////////////////////////////
//
// MessageId: NS_E_INVALID_INPUT_FORMAT
//
// MessageText:
//
// The input media format is invalid.%0
//
NS_E_INVALID_INPUT_FORMAT = HRESULT($C00D0BB8);
{$EXTERNALSYM NS_E_INVALID_INPUT_FORMAT}
//
// MessageId: NS_E_MSAUDIO_NOT_INSTALLED
//
// MessageText:
//
// The MSAudio codec is not installed on this system.%0
//
NS_E_MSAUDIO_NOT_INSTALLED = HRESULT($C00D0BB9);
{$EXTERNALSYM NS_E_MSAUDIO_NOT_INSTALLED}
//
// MessageId: NS_E_UNEXPECTED_MSAUDIO_ERROR
//
// MessageText:
//
// An unexpected error occurred with the MSAudio codec.%0
//
NS_E_UNEXPECTED_MSAUDIO_ERROR = HRESULT($C00D0BBA);
{$EXTERNALSYM NS_E_UNEXPECTED_MSAUDIO_ERROR}
//
// MessageId: NS_E_INVALID_OUTPUT_FORMAT
//
// MessageText:
//
// The output media format is invalid.%0
//
NS_E_INVALID_OUTPUT_FORMAT = HRESULT($C00D0BBB);
{$EXTERNALSYM NS_E_INVALID_OUTPUT_FORMAT}
//
// MessageId: NS_E_NOT_CONFIGURED
//
// MessageText:
//
// The object must be fully configured before audio samples can be processed.%0
//
NS_E_NOT_CONFIGURED = HRESULT($C00D0BBC);
{$EXTERNALSYM NS_E_NOT_CONFIGURED}
//
// MessageId: NS_E_PROTECTED_CONTENT
//
// MessageText:
//
// You need a license to perform the requested operation on this media file.%0
//
NS_E_PROTECTED_CONTENT = HRESULT($C00D0BBD);
{$EXTERNALSYM NS_E_PROTECTED_CONTENT}
//
// MessageId: NS_E_LICENSE_REQUIRED
//
// MessageText:
//
// You need a license to perform the requested operation on this media file.%0
//
NS_E_LICENSE_REQUIRED = HRESULT($C00D0BBE);
{$EXTERNALSYM NS_E_LICENSE_REQUIRED}
//
// MessageId: NS_E_TAMPERED_CONTENT
//
// MessageText:
//
// This media file is corrupted or invalid. Contact the content provider for a new file.%0
//
NS_E_TAMPERED_CONTENT = HRESULT($C00D0BBF);
{$EXTERNALSYM NS_E_TAMPERED_CONTENT}
//
// MessageId: NS_E_LICENSE_OUTOFDATE
//
// MessageText:
//
// The license for this media file has expired. Get a new license or contact the content provider for further assistance.%0
//
NS_E_LICENSE_OUTOFDATE = HRESULT($C00D0BC0);
{$EXTERNALSYM NS_E_LICENSE_OUTOFDATE}
//
// MessageId: NS_E_LICENSE_INCORRECT_RIGHTS
//
// MessageText:
//
// You are not allowed to open this file. Contact the content provider for further assistance.%0
//
NS_E_LICENSE_INCORRECT_RIGHTS = HRESULT($C00D0BC1);
{$EXTERNALSYM NS_E_LICENSE_INCORRECT_RIGHTS}
//
// MessageId: NS_E_AUDIO_CODEC_NOT_INSTALLED
//
// MessageText:
//
// The requested audio codec is not installed on this system.%0
//
NS_E_AUDIO_CODEC_NOT_INSTALLED = HRESULT($C00D0BC2);
{$EXTERNALSYM NS_E_AUDIO_CODEC_NOT_INSTALLED}
//
// MessageId: NS_E_AUDIO_CODEC_ERROR
//
// MessageText:
//
// An unexpected error occurred with the audio codec.%0
//
NS_E_AUDIO_CODEC_ERROR = HRESULT($C00D0BC3);
{$EXTERNALSYM NS_E_AUDIO_CODEC_ERROR}
//
// MessageId: NS_E_VIDEO_CODEC_NOT_INSTALLED
//
// MessageText:
//
// The requested video codec is not installed on this system.%0
//
NS_E_VIDEO_CODEC_NOT_INSTALLED = HRESULT($C00D0BC4);
{$EXTERNALSYM NS_E_VIDEO_CODEC_NOT_INSTALLED}
//
// MessageId: NS_E_VIDEO_CODEC_ERROR
//
// MessageText:
//
// An unexpected error occurred with the video codec.%0
//
NS_E_VIDEO_CODEC_ERROR = HRESULT($C00D0BC5);
{$EXTERNALSYM NS_E_VIDEO_CODEC_ERROR}
//
// MessageId: NS_E_INVALIDPROFILE
//
// MessageText:
//
// The Profile is invalid.%0
//
NS_E_INVALIDPROFILE = HRESULT($C00D0BC6);
{$EXTERNALSYM NS_E_INVALIDPROFILE}
//
// MessageId: NS_E_INCOMPATIBLE_VERSION
//
// MessageText:
//
// A new version of the SDK is needed to play the requested content.%0
//
NS_E_INCOMPATIBLE_VERSION = HRESULT($C00D0BC7);
{$EXTERNALSYM NS_E_INCOMPATIBLE_VERSION}
//
// MessageId: NS_S_REBUFFERING
//
// MessageText:
//
// The requested operation has caused the source to rebuffer.%0
//
NS_S_REBUFFERING = HRESULT($000D0BC8);
{$EXTERNALSYM NS_S_REBUFFERING}
//
// MessageId: NS_S_DEGRADING_QUALITY
//
// MessageText:
//
// The requested operation has caused the source to degrade codec quality.%0
//
NS_S_DEGRADING_QUALITY = HRESULT($000D0BC9);
{$EXTERNALSYM NS_S_DEGRADING_QUALITY}
//
// MessageId: NS_E_OFFLINE_MODE
//
// MessageText:
//
// The requested URL is not available in offline mode.%0
//
NS_E_OFFLINE_MODE = HRESULT($C00D0BCA);
{$EXTERNALSYM NS_E_OFFLINE_MODE}
//
// MessageId: NS_E_NOT_CONNECTED
//
// MessageText:
//
// The requested URL cannot be accessed because there is no network connection.%0
//
NS_E_NOT_CONNECTED = HRESULT($C00D0BCB);
{$EXTERNALSYM NS_E_NOT_CONNECTED}
//
// MessageId: NS_E_TOO_MUCH_DATA
//
// MessageText:
//
// The encoding process was unable to keep up with the amount of supplied data.%0
//
NS_E_TOO_MUCH_DATA = HRESULT($C00D0BCC);
{$EXTERNALSYM NS_E_TOO_MUCH_DATA}
//
// MessageId: NS_E_UNSUPPORTED_PROPERTY
//
// MessageText:
//
// The given property is not supported.%0
//
NS_E_UNSUPPORTED_PROPERTY = HRESULT($C00D0BCD);
{$EXTERNALSYM NS_E_UNSUPPORTED_PROPERTY}
//
// MessageId: NS_E_8BIT_WAVE_UNSUPPORTED
//
// MessageText:
//
// Windows Media Player cannot copy the files to the CD because they are 8-bit. Convert the files to 16-bit, 44-kHz stereo files by using Sound Recorder or another audio-processing program, and then try again.%0
//
NS_E_8BIT_WAVE_UNSUPPORTED = HRESULT($C00D0BCE);
{$EXTERNALSYM NS_E_8BIT_WAVE_UNSUPPORTED}
//
// MessageId: NS_E_NO_MORE_SAMPLES
//
// MessageText:
//
// There are no more samples in the current range.%0
//
NS_E_NO_MORE_SAMPLES = HRESULT($C00D0BCF);
{$EXTERNALSYM NS_E_NO_MORE_SAMPLES}
//
// MessageId: NS_E_INVALID_SAMPLING_RATE
//
// MessageText:
//
// The given sampling rate is invalid.%0
//
NS_E_INVALID_SAMPLING_RATE = HRESULT($C00D0BD0);
{$EXTERNALSYM NS_E_INVALID_SAMPLING_RATE}
//
// MessageId: NS_E_MAX_PACKET_SIZE_TOO_SMALL
//
// MessageText:
//
// The given maximum packet size is too small to accommodate this profile
//
NS_E_MAX_PACKET_SIZE_TOO_SMALL = HRESULT($C00D0BD1);
{$EXTERNALSYM NS_E_MAX_PACKET_SIZE_TOO_SMALL}
//
// MessageId: NS_E_LATE_PACKET
//
// MessageText:
//
// The packet arrived too late to be of use
//
NS_E_LATE_PACKET = HRESULT($C00D0BD2);
{$EXTERNALSYM NS_E_LATE_PACKET}
//
// MessageId: NS_E_DUPLICATE_PACKET
//
// MessageText:
//
// The packet is a duplicate of one received before
//
NS_E_DUPLICATE_PACKET = HRESULT($C00D0BD3);
{$EXTERNALSYM NS_E_DUPLICATE_PACKET}
//
// MessageId: NS_E_SDK_BUFFERTOOSMALL
//
// MessageText:
//
// Supplied buffer is too small
//
NS_E_SDK_BUFFERTOOSMALL = HRESULT($C00D0BD4);
{$EXTERNALSYM NS_E_SDK_BUFFERTOOSMALL}
//
// MessageId: NS_E_INVALID_NUM_PASSES
//
// MessageText:
//
// The wrong number of preprocessing passes was used for the stream's output type
//
NS_E_INVALID_NUM_PASSES = HRESULT($C00D0BD5);
{$EXTERNALSYM NS_E_INVALID_NUM_PASSES}
//
// MessageId: NS_E_ATTRIBUTE_READ_ONLY
//
// MessageText:
//
// An attempt was made to add, modify, or delete a read only attribute
//
NS_E_ATTRIBUTE_READ_ONLY = HRESULT($C00D0BD6);
{$EXTERNALSYM NS_E_ATTRIBUTE_READ_ONLY}
//
// MessageId: NS_E_ATTRIBUTE_NOT_ALLOWED
//
// MessageText:
//
// An attempt was made to add attribute that is not allowed for the given media type
//
NS_E_ATTRIBUTE_NOT_ALLOWED = HRESULT($C00D0BD7);
{$EXTERNALSYM NS_E_ATTRIBUTE_NOT_ALLOWED}
//
// MessageId: NS_E_INVALID_EDL
//
// MessageText:
//
// The EDL provided is invalid
//
NS_E_INVALID_EDL = HRESULT($C00D0BD8);
{$EXTERNALSYM NS_E_INVALID_EDL}
//
// MessageId: NS_E_DATA_UNIT_EXTENSION_TOO_LARGE
//
// MessageText:
//
// The Data Unit Extension data was too large to be used.%0
//
NS_E_DATA_UNIT_EXTENSION_TOO_LARGE = HRESULT($C00D0BD9);
{$EXTERNALSYM NS_E_DATA_UNIT_EXTENSION_TOO_LARGE}
//
// MessageId: NS_E_CODEC_DMO_ERROR
//
// MessageText:
//
// An unexpected error occurred with a DMO codec.%0
//
NS_E_CODEC_DMO_ERROR = HRESULT($C00D0BDA);
{$EXTERNALSYM NS_E_CODEC_DMO_ERROR}
/////////////////////////////////////////////////////////////////////////
//
// Windows Media Player Errors
//
// IdRange = 4000 - 4999
//
/////////////////////////////////////////////////////////////////////////
//
// WMP CD Filter Error codes
//
//
// MessageId: NS_E_NO_CD
//
// MessageText:
//
// There is no CD in the CD-ROM drive. Insert a CD, and try again.%0
//
NS_E_NO_CD = HRESULT($C00D0FA0);
{$EXTERNALSYM NS_E_NO_CD}
//
// MessageId: NS_E_CANT_READ_DIGITAL
//
// MessageText:
//
// Unable to perform digital reads on this compact disc drive. Please try analog playback via the Tools Options menu.%0
//
NS_E_CANT_READ_DIGITAL = HRESULT($C00D0FA1);
{$EXTERNALSYM NS_E_CANT_READ_DIGITAL}
//
// MessageId: NS_E_DEVICE_DISCONNECTED
//
// MessageText:
//
// Windows Media Player no longer detects a connected portable device. Reconnect your portable device, and then try copying the file again.%0
//
NS_E_DEVICE_DISCONNECTED = HRESULT($C00D0FA2);
{$EXTERNALSYM NS_E_DEVICE_DISCONNECTED}
//
// MessageId: NS_E_DEVICE_NOT_SUPPORT_FORMAT
//
// MessageText:
//
// Windows Media Player cannot play the file. The portable device does not support the specified format.%0
//
NS_E_DEVICE_NOT_SUPPORT_FORMAT = HRESULT($C00D0FA3);
{$EXTERNALSYM NS_E_DEVICE_NOT_SUPPORT_FORMAT}
//
// MessageId: NS_E_SLOW_READ_DIGITAL
//
// MessageText:
//
// Windows Media Player encountered a problem while attempting to play the CD using digital playback. The Player has automatically switched the CD-ROM drive to analog playback. To switch back to digital CD playback, use the Devices tab.%0
//
NS_E_SLOW_READ_DIGITAL = HRESULT($C00D0FA4);
{$EXTERNALSYM NS_E_SLOW_READ_DIGITAL}
//
// MessageId: NS_E_MIXER_INVALID_LINE
//
// MessageText:
//
// An invalid line error occurred in the mixer.%0
//
NS_E_MIXER_INVALID_LINE = HRESULT($C00D0FA5);
{$EXTERNALSYM NS_E_MIXER_INVALID_LINE}
//
// MessageId: NS_E_MIXER_INVALID_CONTROL
//
// MessageText:
//
// An invalid control error occurred in the mixer.%0
//
NS_E_MIXER_INVALID_CONTROL = HRESULT($C00D0FA6);
{$EXTERNALSYM NS_E_MIXER_INVALID_CONTROL}
//
// MessageId: NS_E_MIXER_INVALID_VALUE
//
// MessageText:
//
// An invalid value error occurred in the mixer.%0
//
NS_E_MIXER_INVALID_VALUE = HRESULT($C00D0FA7);
{$EXTERNALSYM NS_E_MIXER_INVALID_VALUE}
//
// MessageId: NS_E_MIXER_UNKNOWN_MMRESULT
//
// MessageText:
//
// An unrecognized MMRESULT occurred in the mixer.%0
//
NS_E_MIXER_UNKNOWN_MMRESULT = HRESULT($C00D0FA8);
{$EXTERNALSYM NS_E_MIXER_UNKNOWN_MMRESULT}
//
// MessageId: NS_E_USER_STOP
//
// MessageText:
//
// User has stopped the operation.%0
//
NS_E_USER_STOP = HRESULT($C00D0FA9);
{$EXTERNALSYM NS_E_USER_STOP}
//
// MessageId: NS_E_MP3_FORMAT_NOT_FOUND
//
// MessageText:
//
// Windows Media Player cannot copy the file because a compatible MP3 encoder is not installed on your computer. Install a compatible MP3 encoder, or choose a different format to copy to (such as Windows Media Audio).%0
//
NS_E_MP3_FORMAT_NOT_FOUND = HRESULT($C00D0FAA);
{$EXTERNALSYM NS_E_MP3_FORMAT_NOT_FOUND}
//
// MessageId: NS_E_CD_READ_ERROR_NO_CORRECTION
//
// MessageText:
//
// Windows Media Player cannot read the CD. It may contain flaws. Turn on error correction and try again.%0
//
NS_E_CD_READ_ERROR_NO_CORRECTION = HRESULT($C00D0FAB);
{$EXTERNALSYM NS_E_CD_READ_ERROR_NO_CORRECTION}
//
// MessageId: NS_E_CD_READ_ERROR
//
// MessageText:
//
// Windows Media Player cannot read the CD. Be sure the CD is free of dirt and scratches and the CD-ROM drive is functioning properly.%0
//
NS_E_CD_READ_ERROR = HRESULT($C00D0FAC);
{$EXTERNALSYM NS_E_CD_READ_ERROR}
//
// MessageId: NS_E_CD_SLOW_COPY
//
// MessageText:
//
// To speed up the copy process, do not play CD tracks while copying.%0
//
NS_E_CD_SLOW_COPY = HRESULT($C00D0FAD);
{$EXTERNALSYM NS_E_CD_SLOW_COPY}
//
// MessageId: NS_E_CD_COPYTO_CD
//
// MessageText:
//
// Cannot copy directly from a CDROM to a CD drive.%0
//
NS_E_CD_COPYTO_CD = HRESULT($C00D0FAE);
{$EXTERNALSYM NS_E_CD_COPYTO_CD}
//
// MessageId: NS_E_MIXER_NODRIVER
//
// MessageText:
//
// Could not open a sound mixer driver.%0
//
NS_E_MIXER_NODRIVER = HRESULT($C00D0FAF);
{$EXTERNALSYM NS_E_MIXER_NODRIVER}
//
// MessageId: NS_E_REDBOOK_ENABLED_WHILE_COPYING
//
// MessageText:
//
// Windows Media Player has detected that a setting for the CD-ROM drive will cause audio CDs to copy incorrectly; no audio is copied. Change the CD-ROM drive setting in Device Manager, and then try again.%0
//
NS_E_REDBOOK_ENABLED_WHILE_COPYING = HRESULT($C00D0FB0);
{$EXTERNALSYM NS_E_REDBOOK_ENABLED_WHILE_COPYING}
//
// MessageId: NS_E_CD_REFRESH
//
// MessageText:
//
// Trying to refresh the CD playlist.%0
//
NS_E_CD_REFRESH = HRESULT($C00D0FB1);
{$EXTERNALSYM NS_E_CD_REFRESH}
//
// MessageId: NS_E_CD_DRIVER_PROBLEM
//
// MessageText:
//
// Windows Media Player must switch to analog mode because there is a problem reading the CD-ROM drive in digital mode. Verify that the CD-ROM drive is installed correctly or try to update the drivers for the CD-ROM drive, and then try to use digital mode again.%0
//
NS_E_CD_DRIVER_PROBLEM = HRESULT($C00D0FB2);
{$EXTERNALSYM NS_E_CD_DRIVER_PROBLEM}
//
// MessageId: NS_E_WONT_DO_DIGITAL
//
// MessageText:
//
// Windows Media Player must switch to analog mode because there is a problem reading the CD-ROM drive in digital mode.%0
//
NS_E_WONT_DO_DIGITAL = HRESULT($C00D0FB3);
{$EXTERNALSYM NS_E_WONT_DO_DIGITAL}
//
// WMP IWMPXMLParser Error codes
//
//
// MessageId: NS_E_WMPXML_NOERROR
//
// MessageText:
//
// A call was made to GetParseError on the XML parser but there was no error to retrieve.%0
//
NS_E_WMPXML_NOERROR = HRESULT($C00D0FB4);
{$EXTERNALSYM NS_E_WMPXML_NOERROR}
//
// MessageId: NS_E_WMPXML_ENDOFDATA
//
// MessageText:
//
// The XML Parser ran out of data while parsing.%0
//
NS_E_WMPXML_ENDOFDATA = HRESULT($C00D0FB5);
{$EXTERNALSYM NS_E_WMPXML_ENDOFDATA}
//
// MessageId: NS_E_WMPXML_PARSEERROR
//
// MessageText:
//
// A generic parse error occurred in the XML parser but no information is available.%0
//
NS_E_WMPXML_PARSEERROR = HRESULT($C00D0FB6);
{$EXTERNALSYM NS_E_WMPXML_PARSEERROR}
//
// MessageId: NS_E_WMPXML_ATTRIBUTENOTFOUND
//
// MessageText:
//
// A call get GetNamedAttribute or GetNamedAttributeIndex on the XML parser resulted in the index not being found.%0
//
NS_E_WMPXML_ATTRIBUTENOTFOUND = HRESULT($C00D0FB7);
{$EXTERNALSYM NS_E_WMPXML_ATTRIBUTENOTFOUND}
//
// MessageId: NS_E_WMPXML_PINOTFOUND
//
// MessageText:
//
// A call was made go GetNamedPI on the XML parser, but the requested Processing Instruction was not found.%0
//
NS_E_WMPXML_PINOTFOUND = HRESULT($C00D0FB8);
{$EXTERNALSYM NS_E_WMPXML_PINOTFOUND}
//
// MessageId: NS_E_WMPXML_EMPTYDOC
//
// MessageText:
//
// Persist was called on the XML parser, but the parser has no data to persist.%0
//
NS_E_WMPXML_EMPTYDOC = HRESULT($C00D0FB9);
{$EXTERNALSYM NS_E_WMPXML_EMPTYDOC}
//
// Miscellaneous Media Player Error codes
//
//
// MessageId: NS_E_WMP_WINDOWSAPIFAILURE
//
// MessageText:
//
// A Windows API call failed but no error information was available.%0
//
NS_E_WMP_WINDOWSAPIFAILURE = HRESULT($C00D0FC8);
{$EXTERNALSYM NS_E_WMP_WINDOWSAPIFAILURE}
//
// MessageId: NS_E_WMP_RECORDING_NOT_ALLOWED
//
// MessageText:
//
// Windows Media Player cannot copy the file. Either the license restricts copying, or you must obtain a license to copy the file.%0
//
NS_E_WMP_RECORDING_NOT_ALLOWED = HRESULT($C00D0FC9);
{$EXTERNALSYM NS_E_WMP_RECORDING_NOT_ALLOWED}
//
// MessageId: NS_E_DEVICE_NOT_READY
//
// MessageText:
//
// Windows Media Player no longer detects a connected portable device. Reconnect your portable device, and try again.%0
//
NS_E_DEVICE_NOT_READY = HRESULT($C00D0FCA);
{$EXTERNALSYM NS_E_DEVICE_NOT_READY}
//
// MessageId: NS_E_DAMAGED_FILE
//
// MessageText:
//
// Windows Media Player cannot play the file because it is either damaged or corrupt.%0
//
NS_E_DAMAGED_FILE = HRESULT($C00D0FCB);
{$EXTERNALSYM NS_E_DAMAGED_FILE}
//
// MessageId: NS_E_MPDB_GENERIC
//
// MessageText:
//
// An error occurred when the Player was attempting to access information in your media library. Try closing and then reopening the Player.%0
//
NS_E_MPDB_GENERIC = HRESULT($C00D0FCC);
{$EXTERNALSYM NS_E_MPDB_GENERIC}
//
// MessageId: NS_E_FILE_FAILED_CHECKS
//
// MessageText:
//
// The file cannot be added to Media Library because it is smaller than the minimum-size requirement. Adjust the size requirements, and then try again.%0
//
NS_E_FILE_FAILED_CHECKS = HRESULT($C00D0FCD);
{$EXTERNALSYM NS_E_FILE_FAILED_CHECKS}
//
// MessageId: NS_E_MEDIA_LIBRARY_FAILED
//
// MessageText:
//
// Windows Media Player could not create Media Library. Check with your system administrator to get the necessary permissions to create Media Library on your computer, and then try installing the Player again.%0
//
NS_E_MEDIA_LIBRARY_FAILED = HRESULT($C00D0FCE);
{$EXTERNALSYM NS_E_MEDIA_LIBRARY_FAILED}
//
// MessageId: NS_E_SHARING_VIOLATION
//
// MessageText:
//
// The file is already in use. Close other programs that may be using the file, or stop playing the file, and try again.%0
//
NS_E_SHARING_VIOLATION = HRESULT($C00D0FCF);
{$EXTERNALSYM NS_E_SHARING_VIOLATION}
//
// MessageId: NS_E_NO_ERROR_STRING_FOUND
//
// MessageText:
//
// Windows Media Player has encountered an unknown error.%0
//
NS_E_NO_ERROR_STRING_FOUND = HRESULT($C00D0FD0);
{$EXTERNALSYM NS_E_NO_ERROR_STRING_FOUND}
//
// MessageId: NS_E_WMPOCX_NO_REMOTE_CORE
//
// MessageText:
//
// The Windows Media Player control was unable to connect to remote media services, but will continue with local media services.%0
//
NS_E_WMPOCX_NO_REMOTE_CORE = HRESULT($C00D0FD1);
{$EXTERNALSYM NS_E_WMPOCX_NO_REMOTE_CORE}
//
// MessageId: NS_E_WMPOCX_NO_ACTIVE_CORE
//
// MessageText:
//
// The requested method or property is not available because the Windows Media Player control has not been properly activated.%0
//
NS_E_WMPOCX_NO_ACTIVE_CORE = HRESULT($C00D0FD2);
{$EXTERNALSYM NS_E_WMPOCX_NO_ACTIVE_CORE}
//
// MessageId: NS_E_WMPOCX_NOT_RUNNING_REMOTELY
//
// MessageText:
//
// Windows Media Player ActiveX control is not running in remote mode.%0
//
NS_E_WMPOCX_NOT_RUNNING_REMOTELY = HRESULT($C00D0FD3);
{$EXTERNALSYM NS_E_WMPOCX_NOT_RUNNING_REMOTELY}
//
// MessageId: NS_E_WMPOCX_NO_REMOTE_WINDOW
//
// MessageText:
//
// An error occurred when trying to get remote Windows Media Player window.%0
//
NS_E_WMPOCX_NO_REMOTE_WINDOW = HRESULT($C00D0FD4);
{$EXTERNALSYM NS_E_WMPOCX_NO_REMOTE_WINDOW}
//
// MessageId: NS_E_WMPOCX_ERRORMANAGERNOTAVAILABLE
//
// MessageText:
//
// Windows Media Player has encountered an unknown error.%0
//
NS_E_WMPOCX_ERRORMANAGERNOTAVAILABLE = HRESULT($C00D0FD5);
{$EXTERNALSYM NS_E_WMPOCX_ERRORMANAGERNOTAVAILABLE}
//
// MessageId: NS_E_PLUGIN_NOTSHUTDOWN
//
// MessageText:
//
// Windows Media Player was not closed properly. A damaged or incompatible plug-in may have caused the problem to occur. As a precaution, all third-party plug-ins have been disabled.%0
//
NS_E_PLUGIN_NOTSHUTDOWN = HRESULT($C00D0FD6);
{$EXTERNALSYM NS_E_PLUGIN_NOTSHUTDOWN}
//
// MessageId: NS_E_WMP_CANNOT_FIND_FOLDER
//
// MessageText:
//
// Windows Media Player cannot find the specified path. Be sure the path is typed correctly. If it is, the path does not exist in the specified location, or the computer where the path is located is offline.%0
//
NS_E_WMP_CANNOT_FIND_FOLDER = HRESULT($C00D0FD7);
{$EXTERNALSYM NS_E_WMP_CANNOT_FIND_FOLDER}
//
// MessageId: NS_E_WMP_STREAMING_RECORDING_NOT_ALLOWED
//
// MessageText:
//
// Windows Media Player cannot copy streaming media.%0
//
NS_E_WMP_STREAMING_RECORDING_NOT_ALLOWED = HRESULT($C00D0FD8);
{$EXTERNALSYM NS_E_WMP_STREAMING_RECORDING_NOT_ALLOWED}
//
// MessageId: NS_E_WMP_PLUGINDLL_NOTFOUND
//
// MessageText:
//
// Windows Media Player cannot find the selected plug-in. The Player will try to remove it from the menu. To use this plug-in, install it again.%0
//
NS_E_WMP_PLUGINDLL_NOTFOUND = HRESULT($C00D0FD9);
{$EXTERNALSYM NS_E_WMP_PLUGINDLL_NOTFOUND}
//
// MessageId: NS_E_NEED_TO_ASK_USER
//
// MessageText:
//
// Action requires input from the user.%0
//
NS_E_NEED_TO_ASK_USER = HRESULT($C00D0FDA);
{$EXTERNALSYM NS_E_NEED_TO_ASK_USER}
//
// MessageId: NS_E_WMPOCX_PLAYER_NOT_DOCKED
//
// MessageText:
//
// The Windows Media Player control must be in a docked state for this action to succeed.%0
//
NS_E_WMPOCX_PLAYER_NOT_DOCKED = HRESULT($C00D0FDB);
{$EXTERNALSYM NS_E_WMPOCX_PLAYER_NOT_DOCKED}
//
// MessageId: NS_E_WMP_EXTERNAL_NOTREADY
//
// MessageText:
//
// Media Player external object is not ready.%0
//
NS_E_WMP_EXTERNAL_NOTREADY = HRESULT($C00D0FDC);
{$EXTERNALSYM NS_E_WMP_EXTERNAL_NOTREADY}
//
// MessageId: NS_E_WMP_MLS_STALE_DATA
//
// MessageText:
//
// Metadata is stale. The operation failed.%0
//
NS_E_WMP_MLS_STALE_DATA = HRESULT($C00D0FDD);
{$EXTERNALSYM NS_E_WMP_MLS_STALE_DATA}
//
// Generic Media PlayerUI error codes
//
//
// MessageId: NS_E_WMP_UI_SUBCONTROLSNOTSUPPORTED
//
// MessageText:
//
// The control (%s) does not support creation of sub-controls, yet (%d) sub-controls have been specified.%0
//
NS_E_WMP_UI_SUBCONTROLSNOTSUPPORTED = HRESULT($C00D0FDE);
{$EXTERNALSYM NS_E_WMP_UI_SUBCONTROLSNOTSUPPORTED}
//
// MessageId: NS_E_WMP_UI_VERSIONMISMATCH
//
// MessageText:
//
// Version mismatch: (%.1f required, %.1f found).%0
//
NS_E_WMP_UI_VERSIONMISMATCH = HRESULT($C00D0FDF);
{$EXTERNALSYM NS_E_WMP_UI_VERSIONMISMATCH}
//
// MessageId: NS_E_WMP_UI_NOTATHEMEFILE
//
// MessageText:
//
// The layout manager was given valid XML that wasn't a theme file.%0
//
NS_E_WMP_UI_NOTATHEMEFILE = HRESULT($C00D0FE0);
{$EXTERNALSYM NS_E_WMP_UI_NOTATHEMEFILE}
//
// MessageId: NS_E_WMP_UI_SUBELEMENTNOTFOUND
//
// MessageText:
//
// The %s subelement could not be found on the %s object.%0
//
NS_E_WMP_UI_SUBELEMENTNOTFOUND = HRESULT($C00D0FE1);
{$EXTERNALSYM NS_E_WMP_UI_SUBELEMENTNOTFOUND}
//
// MessageId: NS_E_WMP_UI_VERSIONPARSE
//
// MessageText:
//
// An error occurred parsing the version tag.nValid version tags are of the form:nnt<?wmp version='1.0'?>.%0
//
NS_E_WMP_UI_VERSIONPARSE = HRESULT($C00D0FE2);
{$EXTERNALSYM NS_E_WMP_UI_VERSIONPARSE}
//
// MessageId: NS_E_WMP_UI_VIEWIDNOTFOUND
//
// MessageText:
//
// The view specified in for the 'currentViewID' property (%s) was not found in this theme file.%0
//
NS_E_WMP_UI_VIEWIDNOTFOUND = HRESULT($C00D0FE3);
{$EXTERNALSYM NS_E_WMP_UI_VIEWIDNOTFOUND}
//
// MessageId: NS_E_WMP_UI_PASSTHROUGH
//
// MessageText:
//
// This error used internally for hit testing.%0
//
NS_E_WMP_UI_PASSTHROUGH = HRESULT($C00D0FE4);
{$EXTERNALSYM NS_E_WMP_UI_PASSTHROUGH}
//
// MessageId: NS_E_WMP_UI_OBJECTNOTFOUND
//
// MessageText:
//
// Attributes were specified for the %s object, but the object was not available to send them to.%0
//
NS_E_WMP_UI_OBJECTNOTFOUND = HRESULT($C00D0FE5);
{$EXTERNALSYM NS_E_WMP_UI_OBJECTNOTFOUND}
//
// MessageId: NS_E_WMP_UI_SECONDHANDLER
//
// MessageText:
//
// The %s event already has a handler, the second handler was ignored.%0
//
NS_E_WMP_UI_SECONDHANDLER = HRESULT($C00D0FE6);
{$EXTERNALSYM NS_E_WMP_UI_SECONDHANDLER}
//
// MessageId: NS_E_WMP_UI_NOSKININZIP
//
// MessageText:
//
// No .wms file found in skin archive.%0
//
NS_E_WMP_UI_NOSKININZIP = HRESULT($C00D0FE7);
{$EXTERNALSYM NS_E_WMP_UI_NOSKININZIP}
//
// MessageId: NS_S_WMP_UI_VERSIONMISMATCH
//
// MessageText:
//
// An upgrade may be needed for the theme manager to correctly show this skin. Skin reports version: %.1f.%0
//
NS_S_WMP_UI_VERSIONMISMATCH = HRESULT($000D0FE8);
{$EXTERNALSYM NS_S_WMP_UI_VERSIONMISMATCH}
//
// MessageId: NS_S_WMP_EXCEPTION
//
// MessageText:
//
// An error occurred in one of the UI components.%0
//
NS_S_WMP_EXCEPTION = HRESULT($000D0FE9);
{$EXTERNALSYM NS_S_WMP_EXCEPTION}
//
// MessageId: NS_E_WMP_URLDOWNLOADFAILED
//
// MessageText:
//
// Windows Media Player cannot save the file.%0
//
NS_E_WMP_URLDOWNLOADFAILED = HRESULT($C00D0FEA);
{$EXTERNALSYM NS_E_WMP_URLDOWNLOADFAILED}
//
// MessageId: NS_E_WMPOCX_UNABLE_TO_LOAD_SKIN
//
// MessageText:
//
// The Windows Media Player Control was unable to load the requested uiMode and could not successfully roll back to the existing uiMode.%0
//
NS_E_WMPOCX_UNABLE_TO_LOAD_SKIN = HRESULT($C00D0FEB);
{$EXTERNALSYM NS_E_WMPOCX_UNABLE_TO_LOAD_SKIN}
//
// MessageId: NS_E_WMP_INVALID_SKIN
//
// MessageText:
//
// The skin file is invalid.%0
//
NS_E_WMP_INVALID_SKIN = HRESULT($C00D0FEC);
{$EXTERNALSYM NS_E_WMP_INVALID_SKIN}
//
// MessageId: NS_E_WMP_SENDMAILFAILED
//
// MessageText:
//
// Windows Media Player cannot send the link because your e-mail program is not responding. Verify that your e-mail program is configured properly, and then try again. For more information about e-mail, see Windows Help%0
//
NS_E_WMP_SENDMAILFAILED = HRESULT($C00D0FED);
{$EXTERNALSYM NS_E_WMP_SENDMAILFAILED}
//Save As
//
// MessageId: NS_E_WMP_SAVEAS_READONLY
//
// MessageText:
//
// The Windows Media Player cannot overwrite a read only file. Choose another file to save as or change the file attributes.%0
//
NS_E_WMP_SAVEAS_READONLY = HRESULT($C00D0FF0);
{$EXTERNALSYM NS_E_WMP_SAVEAS_READONLY}
//
// WMP Regional button control
//
//
// MessageId: NS_E_WMP_RBC_JPGMAPPINGIMAGE
//
// MessageText:
//
// JPG Images are not recommended for use as a mappingImage.%0
//
NS_E_WMP_RBC_JPGMAPPINGIMAGE = HRESULT($C00D1004);
{$EXTERNALSYM NS_E_WMP_RBC_JPGMAPPINGIMAGE}
//
// MessageId: NS_E_WMP_JPGTRANSPARENCY
//
// MessageText:
//
// JPG Images are not recommended when using a transparencyColor.%0
//
NS_E_WMP_JPGTRANSPARENCY = HRESULT($C00D1005);
{$EXTERNALSYM NS_E_WMP_JPGTRANSPARENCY}
//
// WMP Slider control
//
//
// MessageId: NS_E_WMP_INVALID_MAX_VAL
//
// MessageText:
//
// The Max property cannot be less than Min property.%0
//
NS_E_WMP_INVALID_MAX_VAL = HRESULT($C00D1009);
{$EXTERNALSYM NS_E_WMP_INVALID_MAX_VAL}
//
// MessageId: NS_E_WMP_INVALID_MIN_VAL
//
// MessageText:
//
// The Min property cannot be greater than Max property.%0
//
NS_E_WMP_INVALID_MIN_VAL = HRESULT($C00D100A);
{$EXTERNALSYM NS_E_WMP_INVALID_MIN_VAL}
//
// WMP CustomSlider control
//
//
// MessageId: NS_E_WMP_CS_JPGPOSITIONIMAGE
//
// MessageText:
//
// JPG Images are not recommended for use as a positionImage.%0
//
NS_E_WMP_CS_JPGPOSITIONIMAGE = HRESULT($C00D100E);
{$EXTERNALSYM NS_E_WMP_CS_JPGPOSITIONIMAGE}
//
// MessageId: NS_E_WMP_CS_NOTEVENLYDIVISIBLE
//
// MessageText:
//
// The (%s) image's size is not evenly divisible by the positionImage's size.%0
//
NS_E_WMP_CS_NOTEVENLYDIVISIBLE = HRESULT($C00D100F);
{$EXTERNALSYM NS_E_WMP_CS_NOTEVENLYDIVISIBLE}
//
// WMP ZIP Decoder
//
//
// MessageId: NS_E_WMPZIP_NOTAZIPFILE
//
// MessageText:
//
// The ZIP reader opened a file and its signature didn't match that of ZIP files.%0
//
NS_E_WMPZIP_NOTAZIPFILE = HRESULT($C00D1018);
{$EXTERNALSYM NS_E_WMPZIP_NOTAZIPFILE}
//
// MessageId: NS_E_WMPZIP_CORRUPT
//
// MessageText:
//
// The ZIP reader has detected that the file is corrupt.%0
//
NS_E_WMPZIP_CORRUPT = HRESULT($C00D1019);
{$EXTERNALSYM NS_E_WMPZIP_CORRUPT}
//
// MessageId: NS_E_WMPZIP_FILENOTFOUND
//
// MessageText:
//
// GetFileStream, SaveToFile, or SaveTemp file was called on the ZIP reader with a filename that was not found in the zip file.%0
//
NS_E_WMPZIP_FILENOTFOUND = HRESULT($C00D101A);
{$EXTERNALSYM NS_E_WMPZIP_FILENOTFOUND}
//
// WMP Image Decoding Error codes
//
//
// MessageId: NS_E_WMP_IMAGE_FILETYPE_UNSUPPORTED
//
// MessageText:
//
// Image type not supported.%0
//
NS_E_WMP_IMAGE_FILETYPE_UNSUPPORTED = HRESULT($C00D1022);
{$EXTERNALSYM NS_E_WMP_IMAGE_FILETYPE_UNSUPPORTED}
//
// MessageId: NS_E_WMP_IMAGE_INVALID_FORMAT
//
// MessageText:
//
// Image file may be corrupt.%0
//
NS_E_WMP_IMAGE_INVALID_FORMAT = HRESULT($C00D1023);
{$EXTERNALSYM NS_E_WMP_IMAGE_INVALID_FORMAT}
//
// MessageId: NS_E_WMP_GIF_UNEXPECTED_ENDOFFILE
//
// MessageText:
//
// Unexpected end of file. GIF file may be corrupt.%0
//
NS_E_WMP_GIF_UNEXPECTED_ENDOFFILE = HRESULT($C00D1024);
{$EXTERNALSYM NS_E_WMP_GIF_UNEXPECTED_ENDOFFILE}
//
// MessageId: NS_E_WMP_GIF_INVALID_FORMAT
//
// MessageText:
//
// Invalid GIF file.%0
//
NS_E_WMP_GIF_INVALID_FORMAT = HRESULT($C00D1025);
{$EXTERNALSYM NS_E_WMP_GIF_INVALID_FORMAT}
//
// MessageId: NS_E_WMP_GIF_BAD_VERSION_NUMBER
//
// MessageText:
//
// Invalid GIF version. Only 87a or 89a supported.%0
//
NS_E_WMP_GIF_BAD_VERSION_NUMBER = HRESULT($C00D1026);
{$EXTERNALSYM NS_E_WMP_GIF_BAD_VERSION_NUMBER}
//
// MessageId: NS_E_WMP_GIF_NO_IMAGE_IN_FILE
//
// MessageText:
//
// No images found in GIF file.%0
//
NS_E_WMP_GIF_NO_IMAGE_IN_FILE = HRESULT($C00D1027);
{$EXTERNALSYM NS_E_WMP_GIF_NO_IMAGE_IN_FILE}
//
// MessageId: NS_E_WMP_PNG_INVALIDFORMAT
//
// MessageText:
//
// Invalid PNG image file format.%0
//
NS_E_WMP_PNG_INVALIDFORMAT = HRESULT($C00D1028);
{$EXTERNALSYM NS_E_WMP_PNG_INVALIDFORMAT}
//
// MessageId: NS_E_WMP_PNG_UNSUPPORTED_BITDEPTH
//
// MessageText:
//
// PNG bitdepth not supported.%0
//
NS_E_WMP_PNG_UNSUPPORTED_BITDEPTH = HRESULT($C00D1029);
{$EXTERNALSYM NS_E_WMP_PNG_UNSUPPORTED_BITDEPTH}
//
// MessageId: NS_E_WMP_PNG_UNSUPPORTED_COMPRESSION
//
// MessageText:
//
// Compression format defined in PNG file not supported,%0
//
NS_E_WMP_PNG_UNSUPPORTED_COMPRESSION = HRESULT($C00D102A);
{$EXTERNALSYM NS_E_WMP_PNG_UNSUPPORTED_COMPRESSION}
//
// MessageId: NS_E_WMP_PNG_UNSUPPORTED_FILTER
//
// MessageText:
//
// Filter method defined in PNG file not supported.%0
//
NS_E_WMP_PNG_UNSUPPORTED_FILTER = HRESULT($C00D102B);
{$EXTERNALSYM NS_E_WMP_PNG_UNSUPPORTED_FILTER}
//
// MessageId: NS_E_WMP_PNG_UNSUPPORTED_INTERLACE
//
// MessageText:
//
// Interlace method defined in PNG file not supported.%0
//
NS_E_WMP_PNG_UNSUPPORTED_INTERLACE = HRESULT($C00D102C);
{$EXTERNALSYM NS_E_WMP_PNG_UNSUPPORTED_INTERLACE}
//
// MessageId: NS_E_WMP_PNG_UNSUPPORTED_BAD_CRC
//
// MessageText:
//
// Bad CRC in PNG file.%0
//
NS_E_WMP_PNG_UNSUPPORTED_BAD_CRC = HRESULT($C00D102D);
{$EXTERNALSYM NS_E_WMP_PNG_UNSUPPORTED_BAD_CRC}
//
// MessageId: NS_E_WMP_BMP_INVALID_BITMASK
//
// MessageText:
//
// Invalid bitmask in BMP file.%0
//
NS_E_WMP_BMP_INVALID_BITMASK = HRESULT($C00D102E);
{$EXTERNALSYM NS_E_WMP_BMP_INVALID_BITMASK}
//
// MessageId: NS_E_WMP_BMP_TOPDOWN_DIB_UNSUPPORTED
//
// MessageText:
//
// Topdown DIB not supported.%0
//
NS_E_WMP_BMP_TOPDOWN_DIB_UNSUPPORTED = HRESULT($C00D102F);
{$EXTERNALSYM NS_E_WMP_BMP_TOPDOWN_DIB_UNSUPPORTED}
//
// MessageId: NS_E_WMP_BMP_BITMAP_NOT_CREATED
//
// MessageText:
//
// Bitmap could not be created.%0
//
NS_E_WMP_BMP_BITMAP_NOT_CREATED = HRESULT($C00D1030);
{$EXTERNALSYM NS_E_WMP_BMP_BITMAP_NOT_CREATED}
//
// MessageId: NS_E_WMP_BMP_COMPRESSION_UNSUPPORTED
//
// MessageText:
//
// Compression format defined in BMP not supported.%0
//
NS_E_WMP_BMP_COMPRESSION_UNSUPPORTED = HRESULT($C00D1031);
{$EXTERNALSYM NS_E_WMP_BMP_COMPRESSION_UNSUPPORTED}
//
// MessageId: NS_E_WMP_BMP_INVALID_FORMAT
//
// MessageText:
//
// Invalid Bitmap format.%0
//
NS_E_WMP_BMP_INVALID_FORMAT = HRESULT($C00D1032);
{$EXTERNALSYM NS_E_WMP_BMP_INVALID_FORMAT}
//
// MessageId: NS_E_WMP_JPG_JERR_ARITHCODING_NOTIMPL
//
// MessageText:
//
// JPEG Arithmetic coding not supported.%0
//
NS_E_WMP_JPG_JERR_ARITHCODING_NOTIMPL = HRESULT($C00D1033);
{$EXTERNALSYM NS_E_WMP_JPG_JERR_ARITHCODING_NOTIMPL}
//
// MessageId: NS_E_WMP_JPG_INVALID_FORMAT
//
// MessageText:
//
// Invalid JPEG format.%0
//
NS_E_WMP_JPG_INVALID_FORMAT = HRESULT($C00D1034);
{$EXTERNALSYM NS_E_WMP_JPG_INVALID_FORMAT}
//
// MessageId: NS_E_WMP_JPG_BAD_DCTSIZE
//
// MessageText:
//
// Invalid JPEG format.%0
//
NS_E_WMP_JPG_BAD_DCTSIZE = HRESULT($C00D1035);
{$EXTERNALSYM NS_E_WMP_JPG_BAD_DCTSIZE}
//
// MessageId: NS_E_WMP_JPG_BAD_VERSION_NUMBER
//
// MessageText:
//
// Internal version error. Unexpected JPEG library version.%0
//
NS_E_WMP_JPG_BAD_VERSION_NUMBER = HRESULT($C00D1036);
{$EXTERNALSYM NS_E_WMP_JPG_BAD_VERSION_NUMBER}
//
// MessageId: NS_E_WMP_JPG_BAD_PRECISION
//
// MessageText:
//
// Internal JPEG Library error. Unsupported JPEG data precision.%0
//
NS_E_WMP_JPG_BAD_PRECISION = HRESULT($C00D1037);
{$EXTERNALSYM NS_E_WMP_JPG_BAD_PRECISION}
//
// MessageId: NS_E_WMP_JPG_CCIR601_NOTIMPL
//
// MessageText:
//
// JPEG CCIR601 not supported.%0
//
NS_E_WMP_JPG_CCIR601_NOTIMPL = HRESULT($C00D1038);
{$EXTERNALSYM NS_E_WMP_JPG_CCIR601_NOTIMPL}
//
// MessageId: NS_E_WMP_JPG_NO_IMAGE_IN_FILE
//
// MessageText:
//
// No image found in JPEG file.%0
//
NS_E_WMP_JPG_NO_IMAGE_IN_FILE = HRESULT($C00D1039);
{$EXTERNALSYM NS_E_WMP_JPG_NO_IMAGE_IN_FILE}
//
// MessageId: NS_E_WMP_JPG_READ_ERROR
//
// MessageText:
//
// Could not read JPEG file.%0
//
NS_E_WMP_JPG_READ_ERROR = HRESULT($C00D103A);
{$EXTERNALSYM NS_E_WMP_JPG_READ_ERROR}
//
// MessageId: NS_E_WMP_JPG_FRACT_SAMPLE_NOTIMPL
//
// MessageText:
//
// JPEG Fractional sampling not supported.%0
//
NS_E_WMP_JPG_FRACT_SAMPLE_NOTIMPL = HRESULT($C00D103B);
{$EXTERNALSYM NS_E_WMP_JPG_FRACT_SAMPLE_NOTIMPL}
//
// MessageId: NS_E_WMP_JPG_IMAGE_TOO_BIG
//
// MessageText:
//
// JPEG image too large. Maximum image size supported is 65500 X 65500.%0
//
NS_E_WMP_JPG_IMAGE_TOO_BIG = HRESULT($C00D103C);
{$EXTERNALSYM NS_E_WMP_JPG_IMAGE_TOO_BIG}
//
// MessageId: NS_E_WMP_JPG_UNEXPECTED_ENDOFFILE
//
// MessageText:
//
// Unexpected end of file reached in JPEG file.%0
//
NS_E_WMP_JPG_UNEXPECTED_ENDOFFILE = HRESULT($C00D103D);
{$EXTERNALSYM NS_E_WMP_JPG_UNEXPECTED_ENDOFFILE}
//
// MessageId: NS_E_WMP_JPG_SOF_UNSUPPORTED
//
// MessageText:
//
// Unsupported JPEG SOF marker found.%0
//
NS_E_WMP_JPG_SOF_UNSUPPORTED = HRESULT($C00D103E);
{$EXTERNALSYM NS_E_WMP_JPG_SOF_UNSUPPORTED}
//
// MessageId: NS_E_WMP_JPG_UNKNOWN_MARKER
//
// MessageText:
//
// Unknown JPEG marker found.%0
//
NS_E_WMP_JPG_UNKNOWN_MARKER = HRESULT($C00D103F);
{$EXTERNALSYM NS_E_WMP_JPG_UNKNOWN_MARKER}
//
// MessageId: NS_S_WMP_LOADED_GIF_IMAGE
//
// MessageText:
//
// Successfully loaded a GIF file.%0
//
NS_S_WMP_LOADED_GIF_IMAGE = HRESULT($000D1040);
{$EXTERNALSYM NS_S_WMP_LOADED_GIF_IMAGE}
//
// MessageId: NS_S_WMP_LOADED_PNG_IMAGE
//
// MessageText:
//
// Successfully loaded a PNG file.%0
//
NS_S_WMP_LOADED_PNG_IMAGE = HRESULT($000D1041);
{$EXTERNALSYM NS_S_WMP_LOADED_PNG_IMAGE}
//
// MessageId: NS_S_WMP_LOADED_BMP_IMAGE
//
// MessageText:
//
// Successfully loaded a BMP file.%0
//
NS_S_WMP_LOADED_BMP_IMAGE = HRESULT($000D1042);
{$EXTERNALSYM NS_S_WMP_LOADED_BMP_IMAGE}
//
// MessageId: NS_S_WMP_LOADED_JPG_IMAGE
//
// MessageText:
//
// Successfully loaded a JPG file.%0
//
NS_S_WMP_LOADED_JPG_IMAGE = HRESULT($000D1043);
{$EXTERNALSYM NS_S_WMP_LOADED_JPG_IMAGE}
//
// WMP WM Runtime Error codes
//
//
// MessageId: NS_E_WMG_RATEUNAVAILABLE
//
// MessageText:
//
// The requested playback rate is unavailable on this content.%0
//
NS_E_WMG_RATEUNAVAILABLE = HRESULT($C00D104A);
{$EXTERNALSYM NS_E_WMG_RATEUNAVAILABLE}
//
// MessageId: NS_E_WMG_PLUGINUNAVAILABLE
//
// MessageText:
//
// The rendering or digital signal processing plugin could not be instantiated.%0
//
NS_E_WMG_PLUGINUNAVAILABLE = HRESULT($C00D104B);
{$EXTERNALSYM NS_E_WMG_PLUGINUNAVAILABLE}
//
// MessageId: NS_E_WMG_CANNOTQUEUE
//
// MessageText:
//
// The file cannot be queued for seamless playback.%0
//
NS_E_WMG_CANNOTQUEUE = HRESULT($C00D104C);
{$EXTERNALSYM NS_E_WMG_CANNOTQUEUE}
//
// MessageId: NS_E_WMG_PREROLLLICENSEACQUISITIONNOTALLOWED
//
// MessageText:
//
// Windows Media Player cannot acquire the license for a file that is being prerolled.%0
//
NS_E_WMG_PREROLLLICENSEACQUISITIONNOTALLOWED = HRESULT($C00D104D);
{$EXTERNALSYM NS_E_WMG_PREROLLLICENSEACQUISITIONNOTALLOWED}
//
// MessageId: NS_E_WMG_UNEXPECTEDPREROLLSTATUS
//
// MessageText:
//
// Windows Media Player received an unexpected message while attempting to preroll a file.%0
//
NS_E_WMG_UNEXPECTEDPREROLLSTATUS = HRESULT($C00D104E);
{$EXTERNALSYM NS_E_WMG_UNEXPECTEDPREROLLSTATUS}
//
// MessageId: NS_E_WMG_INVALIDSTATE
//
// MessageText:
//
// Operation attempted in an invalid graph state.%0
//
NS_E_WMG_INVALIDSTATE = HRESULT($C00D1054);
{$EXTERNALSYM NS_E_WMG_INVALIDSTATE}