GitHub-Mirror/G940LEDControl
1
0
Fork 0
mirror of synced 2024-11-05 11:09:17 +00:00
Code Issues Projects Releases Wiki Activity
aea5e66c0e
G940LEDControl/DirectX/xact.pas

1844 lines
83 KiB
ObjectPascal
Raw Normal View History

Initial commit
2012-01-04 19:11:07 +00:00
{******************************************************************************}
{* *}
{* Copyright (C) Microsoft Corporation. All Rights Reserved. *}
{* *}
{* Files: xact.h, xact2wb.h, xact3D.h *}
{* Content: XACT public interfaces, functions and data types; *}
{* XACT 2 wave bank definitions; XACT 3D support. *}
{* *}
{* DirectX 9.0 Delphi / FreePascal adaptation by Alexey Barkovoy *}
{* E-Mail: directx@clootie.ru *}
{* *}
{* Latest version can be downloaded from: *}
{* http://www.clootie.ru *}
{* http://sourceforge.net/projects/delphi-dx9sdk *}
{* *}
{*----------------------------------------------------------------------------*}
{* $Id: xact.pas,v 1.14 2007/04/14 20:57:43 clootie Exp $ }
{******************************************************************************}
{ }
{ Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI) }
{ }
{ The contents of this file are used with permission, subject to the Mozilla }
{ Public License Version 1.1 (the "License"); you may not use this file except }
{ in compliance with the License. You may obtain a copy of the License at }
{ http://www.mozilla.org/MPL/MPL-1.1.html }
{ }
{ Software distributed under the License is distributed on an "AS IS" basis, }
{ WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for }
{ the specific language governing rights and limitations under the License. }
{ }
{ Alternatively, the contents of this file may be used under the terms of the }
{ GNU Lesser General Public License (the "LGPL License"), in which case the }
{ provisions of the LGPL License are applicable instead of those above. }
{ If you wish to allow use of your version of this file only under the terms }
{ of the LGPL License and not to allow others to use your version of this file }
{ under the MPL, indicate your decision by deleting the provisions above and }
{ replace them with the notice and other provisions required by the LGPL }
{ License. If you do not delete the provisions above, a recipient may use }
{ your version of this file under either the MPL or the LGPL License. }
{ }
{ For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html }
{ }
{******************************************************************************}
{$I DirectX.inc}
unit xact;
interface
(*$HPPEMIT '#include "xact.h"' *)
(*$HPPEMIT '#include "xact2wb.h"' *)
(*$HPPEMIT '#include "xact3D.h"' *)
uses
{$IFDEF XBOX}XAudio, xauddefs{$ELSE}Windows, ActiveX{$ENDIF}, X3DAudio;
type
UINT32 = Longword;
(***************************************************************************
*
* Copyright (C) Microsoft Corporation. All Rights Reserved.
*
* File: xact2wb.h
* Content: XACT 2 wave bank definitions.
*
****************************************************************************)
{$MINENUMSIZE 1}
const
WAVEBANK_HEADER_SIGNATURE = 'DNBW'; // WaveBank RIFF chunk signature
{$EXTERNALSYM WAVEBANK_HEADER_SIGNATURE}
WAVEBANK_HEADER_VERSION = 42; // Current wavebank file version
{$EXTERNALSYM WAVEBANK_HEADER_VERSION}
WAVEBANK_BANKNAME_LENGTH = 64; // Wave bank friendly name length, in characters
{$EXTERNALSYM WAVEBANK_BANKNAME_LENGTH}
WAVEBANK_ENTRYNAME_LENGTH = 64; // Wave bank entry friendly name length, in characters
{$EXTERNALSYM WAVEBANK_ENTRYNAME_LENGTH}
WAVEBANK_MAX_DATA_SEGMENT_SIZE = $FFFFFFFF; // Maximum wave bank data segment size, in bytes
{$EXTERNALSYM WAVEBANK_MAX_DATA_SEGMENT_SIZE}
WAVEBANK_MAX_COMPACT_DATA_SEGMENT_SIZE = $001FFFFF; // Maximum compact wave bank data segment size, in bytes
{$EXTERNALSYM WAVEBANK_MAX_COMPACT_DATA_SEGMENT_SIZE}
type
WAVEBANKOFFSET = DWORD;
{$EXTERNALSYM WAVEBANKOFFSET}
TWavebankOffset = WAVEBANKOFFSET;
const
//
// Bank flags
//
WAVEBANK_TYPE_BUFFER = $00000000; // In-memory buffer
{$EXTERNALSYM WAVEBANK_TYPE_BUFFER}
WAVEBANK_TYPE_STREAMING = $00000001; // Streaming
{$EXTERNALSYM WAVEBANK_TYPE_STREAMING}
WAVEBANK_TYPE_MASK = $00000001;
{$EXTERNALSYM WAVEBANK_TYPE_MASK}
WAVEBANK_FLAGS_ENTRYNAMES = $00010000; // Bank includes entry names
{$EXTERNALSYM WAVEBANK_FLAGS_ENTRYNAMES}
WAVEBANK_FLAGS_COMPACT = $00020000; // Bank uses compact format
{$EXTERNALSYM WAVEBANK_FLAGS_COMPACT}
WAVEBANK_FLAGS_SYNC_DISABLED = $00040000; // Bank is disabled for audition sync
{$EXTERNALSYM WAVEBANK_FLAGS_SYNC_DISABLED}
WAVEBANK_FLAGS_SEEKTABLES = $00080000; // Bank includes seek tables.
{$EXTERNALSYM WAVEBANK_FLAGS_SEEKTABLES}
WAVEBANK_FLAGS_MASK = $000F0000;
{$EXTERNALSYM WAVEBANK_FLAGS_MASK}
//
// Entry flags
//
WAVEBANKENTRY_FLAGS_READAHEAD = $00000001; // Enable stream read-ahead
{$EXTERNALSYM WAVEBANKENTRY_FLAGS_READAHEAD}
WAVEBANKENTRY_FLAGS_LOOPCACHE = $00000002; // One or more looping sounds use this wave
{$EXTERNALSYM WAVEBANKENTRY_FLAGS_LOOPCACHE}
WAVEBANKENTRY_FLAGS_REMOVELOOPTAIL = $00000004; // Remove data after the end of the loop region
{$EXTERNALSYM WAVEBANKENTRY_FLAGS_REMOVELOOPTAIL}
WAVEBANKENTRY_FLAGS_IGNORELOOP = $00000008; // Used internally when the loop region can't be used
{$EXTERNALSYM WAVEBANKENTRY_FLAGS_IGNORELOOP}
WAVEBANKENTRY_FLAGS_MASK = $00000008;
{$EXTERNALSYM WAVEBANKENTRY_FLAGS_MASK}
//
// Entry wave format identifiers
//
WAVEBANKMINIFORMAT_TAG_PCM = $0; // PCM data
{$EXTERNALSYM WAVEBANKMINIFORMAT_TAG_PCM}
WAVEBANKMINIFORMAT_TAG_XMA = $1; // XMA data
{$EXTERNALSYM WAVEBANKMINIFORMAT_TAG_XMA}
WAVEBANKMINIFORMAT_TAG_ADPCM = $2; // ADPCM data
{$EXTERNALSYM WAVEBANKMINIFORMAT_TAG_ADPCM}
WAVEBANKMINIFORMAT_BITDEPTH_8 = $0; // 8-bit data (PCM only)
{$EXTERNALSYM WAVEBANKMINIFORMAT_BITDEPTH_8}
WAVEBANKMINIFORMAT_BITDEPTH_16 = $1; // 16-bit data (PCM only)
{$EXTERNALSYM WAVEBANKMINIFORMAT_BITDEPTH_16}
//
// Arbitrary fixed sizes
//
WAVEBANKENTRY_XMASTREAMS_MAX = 3; // enough for 5.1 channel audio
{$EXTERNALSYM WAVEBANKENTRY_XMASTREAMS_MAX}
WAVEBANKENTRY_XMACHANNELS_MAX = 6; // enough for 5.1 channel audio (cf. XAUDIOCHANNEL_SOURCEMAX)
{$EXTERNALSYM WAVEBANKENTRY_XMACHANNELS_MAX}
//
// DVD data sizes
//
WAVEBANK_DVD_SECTOR_SIZE = 2048;
{$EXTERNALSYM WAVEBANK_DVD_SECTOR_SIZE}
WAVEBANK_DVD_BLOCK_SIZE = (WAVEBANK_DVD_SECTOR_SIZE * 16);
{$EXTERNALSYM WAVEBANK_DVD_BLOCK_SIZE}
//
// Bank alignment presets
//
WAVEBANK_ALIGNMENT_MIN = 4; // Minimum alignment
{$EXTERNALSYM WAVEBANK_ALIGNMENT_MIN}
WAVEBANK_ALIGNMENT_DVD = WAVEBANK_DVD_SECTOR_SIZE; // DVD-optimized alignment
{$EXTERNALSYM WAVEBANK_ALIGNMENT_DVD}
type
//
// Wave bank segment identifiers
//
//todo: What is size of this ENUM ???
PWavebankSegIDX = ^TWavebankSegIDX;
WAVEBANKSEGIDX =
(
WAVEBANK_SEGIDX_BANKDATA{= 0}, // Bank data
WAVEBANK_SEGIDX_ENTRYMETADATA, // Entry meta-data
WAVEBANK_SEGIDX_SEEKTABLES, // Storage for seek tables for the encoded waves.
WAVEBANK_SEGIDX_ENTRYNAMES, // Entry friendly names
WAVEBANK_SEGIDX_ENTRYWAVEDATA // Entry wave data
// WAVEBANK_SEGIDX_COUNT
);
{$EXTERNALSYM WAVEBANKSEGIDX}
TWavebankSegIDX = WAVEBANKSEGIDX;
const
WAVEBANK_SEGIDX_COUNT = Ord(High(TWavebankSegIDX))+1;
{$EXTERNALSYM WAVEBANK_SEGIDX_COUNT}
//
// Endianness
//
procedure SwapBytes(_dw_: PDWORD); overload;
{$EXTERNALSYM SwapBytes}
procedure SwapBytes(w: PWORD); overload;
{$EXTERNALSYM SwapBytes}
//
// Wave bank region in bytes.
//
type
PWavebankRegion = ^TWavebankRegion;
WAVEBANKREGION = record
dwOffset: DWORD; // Region offset, in bytes.
dwLength: DWORD; // Region length, in bytes.
end;
{$EXTERNALSYM WAVEBANKREGION}
TWavebankRegion = WAVEBANKREGION;
//procedure TWavebankRegion_SwapBytes(var wbr: TWavebankRegion);
//
// Wave bank region in samples.
//
PWavebankSampleRegion = ^TWavebankSampleRegion;
WAVEBANKSAMPLEREGION = record
dwStartSample: DWORD; // Start sample for the region.
dwTotalSamples: DWORD; // Region length in samples.
(*
void SwapBytes(void)
{
XACTWaveBank::SwapBytes(dwStartSample);
XACTWaveBank::SwapBytes(dwTotalSamples);
} *)
end;
{$EXTERNALSYM WAVEBANKSAMPLEREGION}
TWavebankSampleRegion = WAVEBANKSAMPLEREGION;
//
// Wave bank file header
//
type
PWavebankHeader = ^TWavebankHeader;
WAVEBANKHEADER = record
dwSignature: DWORD; // File signature
dwVersion: DWORD; // Version of the tool that created the file
dwHeaderVersion: DWORD; // Version of the file format
Segments: array[0..WAVEBANK_SEGIDX_COUNT-1] of TWavebankRegion; // Segment lookup table
end;
{$EXTERNALSYM WAVEBANKHEADER}
TWavebankHeader = WAVEBANKHEADER;
//procedure TWavebankHeader_SwapBytes(var wbh: TWavebankHeader);
//
// Entry compressed data format
//
type
PWavebankMiniWaveFormat = ^TWavebankMiniWaveFormat;
WAVEBANKMINIWAVEFORMAT = record
//struct
{
DWORD wFormatTag : 2; // Format tag
DWORD nChannels : 3; // Channel count (1 - 6)
DWORD nSamplesPerSec : 18; // Sampling rate
DWORD wBlockAlign : 8; // Block alignment
DWORD wBitsPerSample : 1; // Bits per sample (8 vs. 16, PCM only)
}
dwValue: DWORD;
end;
{$EXTERNALSYM WAVEBANKMINIWAVEFORMAT}
TWavebankMiniWaveFormat = WAVEBANKMINIWAVEFORMAT;
//procedure TWavebankMiniWaveFormat_SwapBytes(var wbmwf: TWavebankMiniWaveFormat);
//function TWavebankMiniWaveFormat_BitsPerSample(): Word;
//function TWavebankMiniWaveFormat_BlockAlign(): DWPRD;
//
// Entry meta-data
//
PWavebankEntry = ^TWavebankEntry;
WAVEBANKENTRY = record
//union
//struct
{
// Entry flags
DWORD dwFlags : 4;
// Duration of the wave, in units of one sample.
// For instance, a ten second long wave sampled
// at 48KHz would have a duration of 480,000.
// This value is not affected by the number of
// channels, the number of bits per sample, or the
// compression format of the wave.
DWORD Duration : 28;
}
dwFlagsAndDuration: DWORD;
//};
Format: TWavebankMiniWaveFormat; // Entry format
PlayRegion: TWavebankRegion; // Region within the wave data segment that contains this entry
LoopRegion: TWavebankSampleRegion;// Region within the wave data (in samples) that should loop.
end;
{$EXTERNALSYM WAVEBANKENTRY}
TWavebankEntry = WAVEBANKENTRY;
//
// Compact entry meta-data
//
PWavebankEntryCompact = ^TWavebankEntryCompact;
WAVEBANKENTRYCOMPACT = record
{DWORD dwOffset : 21; // Data offset, in sectors
DWORD dwLengthDeviation : 11; // Data length deviation, in bytes}
dwValue: DWORD;
end;
{$EXTERNALSYM WAVEBANKENTRYCOMPACT}
TWavebankEntryCompact = WAVEBANKENTRYCOMPACT;
//
// Bank data segment
//
PWavebankData = ^TWavebankData;
WAVEBANKDATA = record
dwFlags: DWORD; // Bank flags
dwEntryCount: DWORD; // Number of entries in the bank
szBankName: array [0..WAVEBANK_BANKNAME_LENGTH-1] of Char; // Bank friendly name
dwEntryMetaDataElementSize: DWORD; // Size of each entry meta-data element, in bytes
dwEntryNameElementSize: DWORD; // Size of each entry name element, in bytes
dwAlignment: DWORD; // Entry alignment, in bytes
CompactFormat: TWavebankMiniWaveFormat; // Format data for compact bank
BuildTime: FILETIME; // Build timestamp
end;
{$EXTERNALSYM WAVEBANKDATA}
TWavebankData = WAVEBANKDATA;
{$MINENUMSIZE 4}
(***************************************************************************
*
* Copyright (C) Microsoft Corporation. All Rights Reserved.
*
* File: xact.h
* Content: XACT public interfaces, functions and data types
*
****************************************************************************)
{$IFDEF XBOX}
type
//XBox compatibility types - not needed in real XBox SDK
PXAudioVoiceOutput = Pointer;
PXAudioVoiceOutputVolume = Pointer;
PXACTCueProperties = Pointer;
{$ENDIF}
//------------------------------------------------------------------------------
// XACT class and interface IDs (Version 2.7)
//------------------------------------------------------------------------------
{$IFNDEF XBOX} // XACT COM support only exists on Windows
const
CLSID_XACTEngine: TGUID = '{cd0d66ec-8057-43f5-acbd-66dfb36fd78c}';
CLSID_XACTAuditionEngine: TGUID = '{9b94bf7a-ce0f-4c68-8b5e-d062cb3730c3}';
CLSID_XACTDebugEngine: TGUID = '{1bd54a4b-a1dc-4e4c-92a2-73ed33552148}';
// will be defined later -> IID_IXACTEngine: TGUID = '{c2f0af68-1f6d-40ed-964f-26256842edc4}';
{$EXTERNALSYM CLSID_XACTEngine}
{$EXTERNALSYM CLSID_XACTAuditionEngine}
{$EXTERNALSYM CLSID_XACTDebugEngine}
{$ENDIF}
//------------------------------------------------------------------------------
// Forward Declarations
//------------------------------------------------------------------------------
{$IFNDEF XBOX}
const
XACT_RENDERER_ID_LENGTH = $ff; // Maximum number of characters allowed in the renderer ID
{$EXTERNALSYM XACT_RENDERER_ID_LENGTH}
XACT_RENDERER_NAME_LENGTH = $ff; // Maximum number of characters allowed in the renderer display name.
{$EXTERNALSYM XACT_RENDERER_NAME_LENGTH}
// -----------------------------------------------------------------------------
// Engine Look-Ahead Time
// -----------------------------------------------------------------------------
XACT_ENGINE_LOOKAHEAD_DEFAULT = 250; // Default look-ahead time of 250ms can be used during XACT engine initialization.
{$EXTERNALSYM XACT_ENGINE_LOOKAHEAD_DEFAULT}
{$ENDIF}
// -----------------------------------------------------------------------------
// Cue friendly name length
// -----------------------------------------------------------------------------
XACT_CUE_NAME_LENGTH = $FF;
{$EXTERNALSYM XACT_CUE_NAME_LENGTH}
type
IXACTSoundBank = class;
IXACTWaveBank = class;
IXACTWave = class;
IXACTCue = class;
PXACT_Notification = ^TXACT_Notification;
PIXACTCue = ^IXACTCue;
//------------------------------------------------------------------------------
// Typedefs
//------------------------------------------------------------------------------
TXACTIndex = Word; // All normal indices
TXACTNotificationType = Byte; // Notification type
TXACTVariableValue = Single; // Variable value
TXACTVariableIndex = Word; // Variable index
TXACTCategory = Word; // Sound category
TXACTChannel = Byte; // Audio channel
TXACTVolume = Single; // Volume value
TXACTTime = Longint; // Time (in ms)
TXACTPitch = Smallint; // Pitch value
TXACTLoopCount = Byte; // For all loops / recurrences
TXACTVariationWeight = Byte; // Variation weight
TXACTPriority = Byte; // Sound priority
TXACTInstanceLimit = Byte; // Instance limitations
PXACTIndex = ^TXACTIndex;
PXACTNotificationType = ^TXACTNotificationType;
PXACTVariableValue = ^TXACTVariableValue;
PXACTVariableIndex = ^TXACTVariableIndex;
PXACTCategory = ^TXACTCategory;
PXACTChannel = ^TXACTChannel;
PXACTVolume = ^TXACTVolume;
PXACTTime = ^TXACTTime;
PXACTPitch = ^TXACTPitch;
PXACTLoopCount = ^TXACTLoopCount;
PXACTVariationWeight = ^TXACTVariationWeight;
PXACTPriority = ^TXACTPriority;
PXACTInstanceLimit = ^TXACTInstanceLimit;
XACTINDEX = TXACTIndex;
XACTNOTIFICATIONTYPE = TXACTNotificationType;
XACTVARIABLEVALUE = TXACTVariableValue;
XACTVARIABLEINDEX = TXACTVariableIndex;
XACTCATEGORY = TXACTCategory;
XACTCHANNEL = TXACTChannel;
XACTVOLUME = TXACTVolume;
XACTTIME = TXACTTime;
XACTPITCH = TXACTPitch;
XACTLOOPCOUNT = TXACTLoopCount;
XACTVARIATIONWEIGHT = TXACTVariationWeight;
XACTPRIORITY = TXACTPriority;
XACTINSTANCELIMIT = TXACTInstanceLimit;
{$NODEFINE XACTINDEX}
{$NODEFINE XACTNOTIFICATIONTYPE}
{$NODEFINE XACTVARIABLEVALUE}
{$NODEFINE XACTVARIABLEINDEX}
{$NODEFINE XACTCATEGORY}
{$NODEFINE XACTCHANNEL}
{$NODEFINE XACTVOLUME}
{$NODEFINE XACTTIME}
{$NODEFINE XACTPITCH}
{$NODEFINE XACTLOOPCOUNT}
{$NODEFINE XACTVARIATIONWEIGHT}
{$NODEFINE XACTPRIORITY}
{$NODEFINE XACTINSTANCELIMIT}
{$NODEFINE TXACTINDEX}
{$NODEFINE TXACTNOTIFICATIONTYPE}
{$NODEFINE TXACTVARIABLEVALUE}
{$NODEFINE TXACTVARIABLEINDEX}
{$NODEFINE TXACTCATEGORY}
{$NODEFINE TXACTCHANNEL}
{$NODEFINE TXACTVOLUME}
{$NODEFINE TXACTTIME}
{$NODEFINE TXACTPITCH}
{$NODEFINE TXACTLOOPCOUNT}
{$NODEFINE TXACTVARIATIONWEIGHT}
{$NODEFINE TXACTPRIORITY}
{$NODEFINE TXACTINSTANCELIMIT}
{$HPPEMIT 'typedef XACTINDEX TXACTIndex'}
{$HPPEMIT 'typedef XACTNOTIFICATIONTYPE TXACTNotificationType'}
{$HPPEMIT 'typedef XACTVARIABLEVALUE TXACTVariableValue'}
{$HPPEMIT 'typedef XACTVARIABLEINDEX TXACTVariableIndex'}
{$HPPEMIT 'typedef XACTCATEGORY TXACTCategory'}
{$HPPEMIT 'typedef XACTCHANNEL TXACTChanel'}
{$HPPEMIT 'typedef XACTVOLUME TXACTVolume'}
{$HPPEMIT 'typedef XACTTIME TXACTTime'}
{$HPPEMIT 'typedef XACTPITCH TXACTPitch'}
{$HPPEMIT 'typedef XACTLOOPCOUNT TXACTLoopCount'}
{$HPPEMIT 'typedef XACTVARIATIONWEIGHT TXACTVariationWeight'}
{$HPPEMIT 'typedef XACTPRIORITY TXACTPriority'}
{$HPPEMIT 'typedef XACTINSTANCELIMIT TXACTInstanceLimit'}
//------------------------------------------------------------------------------
// Standard win32 multimedia definitions
//------------------------------------------------------------------------------
PWaveFormatEx = ^TWaveFormatEx;
{$EXTERNALSYM tWAVEFORMATEX}
tWAVEFORMATEX = packed record
wFormatTag: Word; { format type }
nChannels: Word; { number of channels (i.e. mono, stereo, etc.) }
nSamplesPerSec: DWORD; { sample rate }
nAvgBytesPerSec: DWORD; { for buffer estimation }
nBlockAlign: Word; { block size of data }
wBitsPerSample: Word; { number of bits per sample of mono data }
cbSize: Word; { the count in bytes of the size of }
end;
//
// The WAVEFORMATEXTENSIBLE structure defines the format of waveform-audio data for formats having more than two channels.
// This structure is part of the Platform SDK and is not declared in Dsound.h. It is included here for convenience.
//
TWaveFormatExtensibleSamples = record
case byte of
0: (wValidBitsPerSample : Word); // bits of precision
1: (wSamplesPerBlock : Word); // valid if wBitsPerSample = 0
2: (wReserved : Word); // If neither applies, set to zero.
end;
{$EXTERNALSYM TWaveFormatExtensibleSamples}
//Clootie: TWaveFormatExtensible definition is borrowed from DirectShow.pas
PWaveFormatExtensible = ^TWaveFormatExtensible;
WAVEFORMATEXTENSIBLE = record
Format: TWaveFormatEx;
Samples: TWaveFormatExtensibleSamples;
dwChannelMask : DWORD; // which channels are present in stream
SubFormat : TGUID;
end;
{$EXTERNALSYM WAVEFORMATEXTENSIBLE}
TWaveFormatExtensible = WAVEFORMATEXTENSIBLE;
// -----------------------------------------------------------------------------
// File IO Callbacks
// -----------------------------------------------------------------------------
{$NODEFINE TXACT_ReadFile_Callback}
TXACT_ReadFile_Callback = function (hFile: THandle; lpBuffer: Pointer; nNumberOfBytesToRead: DWORD;
lpNumberOfBytesRead: PDWORD; lpOverlapped: POverlapped): BOOL; stdcall;
{$NODEFINE TXACT_GetOverlappedResult_Callback}
TXACT_GetOverlappedResult_Callback = function (hFile: THandle; lpOverlapped: POverlapped;
lpNumberOfBytesTransferred: PDWORD; bWait: BOOL): BOOL; stdcall;
PXACT_FileIO_Callbacks = ^TXACT_FileIO_Callbacks;
XACT_FILEIO_CALLBACKS = record
readFileCallback: TXACT_ReadFile_Callback;
getOverlappedResultCallback: TXACT_GetOverlappedResult_Callback;
end;
{$EXTERNALSYM XACT_FILEIO_CALLBACKS}
TXACT_FileIO_Callbacks = XACT_FILEIO_CALLBACKS;
// -----------------------------------------------------------------------------
// Notification Callback
// -----------------------------------------------------------------------------
TXACT_Notification_Callback = procedure (const pNotification: PXACT_Notification); stdcall;
{$EXTERNALSYM TXACT_Notification_Callback}
{$IFNDEF XBOX}
// -----------------------------------------------------------------------------
// Renderer Details
// -----------------------------------------------------------------------------
PXACT_Renderer_Details = ^TXACT_Renderer_Details;
XACT_RENDERER_DETAILS = record
rendererID: array[0..XACT_RENDERER_ID_LENGTH-1] of WideChar; // The string ID for the rendering device.
displayName: array[0..XACT_RENDERER_NAME_LENGTH-1] of WideChar; // A friendly name suitable for display to a human.
defaultDevice: BOOL; // Set to TRUE if this device is the primary audio device on the system.
end;
{$EXTERNALSYM XACT_RENDERER_DETAILS}
TXACT_Renderer_Details = XACT_RENDERER_DETAILS;
TXACTRendererDetails = XACT_RENDERER_DETAILS;
PXACTRendererDetails = PXACT_Renderer_Details;
{$ENDIF}
// -----------------------------------------------------------------------------
// Runtime (engine) parameters
// -----------------------------------------------------------------------------
PXACT_Runtime_Parameters = ^TXACT_Runtime_Parameters;
XACT_RUNTIME_PARAMETERS = record
lookAheadTime: DWORD; // Time in ms
pGlobalSettingsBuffer: Pointer; // Buffer containing the global settings file
globalSettingsBufferSize: DWORD; // Size of global settings buffer
globalSettingsFlags: DWORD; // Flags for global settings
globalSettingsAllocAttributes: DWORD; // Global settings buffer allocation attributes (see XMemAlloc)
fileIOCallbacks: TXACT_FileIO_Callbacks; // File I/O callbacks
fnNotificationCallback: TXACT_Notification_Callback; // Callback that receives notifications.
{$IFNDEF XBOX}
pRendererID: PWideChar; // Ptr to the ID for the audio renderer the engine should connect to.
{$ENDIF}
end;
{$EXTERNALSYM XACT_RUNTIME_PARAMETERS}
TXACT_Runtime_Parameters = XACT_RUNTIME_PARAMETERS;
//------------------------------------------------------------------------------
// Streaming Parameters
//------------------------------------------------------------------------------
PXACT_Streaming_Parameters = ^TXACT_Streaming_Parameters;
PXACT_Wavebank_Streaming_Parameters = ^TXACT_Wavebank_Streaming_Parameters;
XACT_STREAMING_PARAMETERS = record
file_: THandle; // File handle associated with wavebank data
offset: DWORD; // Offset within file of wavebank header (must be sector aligned)
flags: DWORD; // Flags (none currently)
packetSize: Word; // Stream packet size (in sectors) to use for each stream (min = 2)
// number of sectors (DVD = 2048 bytes: 2 = 4096, 3 = 6144, 4 = 8192 etc.)
// optimal DVD size is a multiple of 16 (DVD block = 16 DVD sectors)
end;
{$EXTERNALSYM XACT_STREAMING_PARAMETERS}
XACT_WAVEBANK_STREAMING_PARAMETERS = XACT_STREAMING_PARAMETERS;
{$EXTERNALSYM XACT_WAVEBANK_STREAMING_PARAMETERS}
TXACT_Streaming_Parameters = XACT_STREAMING_PARAMETERS;
TXACT_Wavebank_Streaming_Parameters = XACT_STREAMING_PARAMETERS;
// Structure used to report cue properties back to the client.
PXACT_Cue_Properties = ^TXACT_Cue_Properties;
XACT_CUE_PROPERTIES = record
friendlyName: array [0..XACT_CUE_NAME_LENGTH-1] of Char; // Empty if the soundbank doesn't contain any friendly names
interactive: BOOL; // TRUE if an IA cue; FALSE otherwise
iaVariableIndex: TXACTIndex; // Only valid for IA cues; XACTINDEX_INVALID otherwise
numVariations: TXACTIndex; // Number of variations in the cue
maxInstances: TXACTInstanceLimit; // Number of maximum instances for this cue
currentInstances: TXACTInstanceLimit; // Current active instances of this cue
end;
{$EXTERNALSYM XACT_CUE_PROPERTIES}
TXACT_Cue_Properties = XACT_CUE_PROPERTIES;
// Strucutre used to return the track properties.
PXACT_Track_Properties = ^TXACT_Track_Properties;
XACT_TRACK_PROPERTIES = record
duration: TXACTTime; // Duration of the track in ms
numVariations: TXACTIndex; // Number of wave variations in the track
numChannels: TXACTChannel; // Number of channels for the active wave variation on this track
waveVariation: TXACTIndex; // Index of the active wave variation
loopCount: TXACTLoopCount; // Current loop count on this track
end;
{$EXTERNALSYM XACT_TRACK_PROPERTIES}
TXACT_Track_Properties = XACT_TRACK_PROPERTIES;
// Structure used to return the properties of a variation.
PXACT_Variation_Properties = ^TXACT_Variation_Properties;
XACT_VARIATION_PROPERTIES = record
index: TXACTIndex; // Index of the variation in the cue's variation list
weight: TXACTVariationWeight; // Weight for the active variation. Valid only for complex cues
iaVariableMin: TXACTVariableValue; // Valid only for IA cues
iaVariableMax: TXACTVariableValue; // Valid only for IA cues
linger: BOOL; // Valid only for IA cues
end;
{$EXTERNALSYM XACT_VARIATION_PROPERTIES}
TXACT_Variation_Properties = XACT_VARIATION_PROPERTIES;
// Structure used to return the properties of the sound referenced by a variation.
PXACT_Sound_Properties = ^TXACT_Sound_Properties;
XACT_SOUND_PROPERTIES = record
category: TXACTCategory; // Category this sound belongs to
priority: Byte; // Priority of this variation
pitch: TXACTPitch; // Current pitch set on the active variation
volume: TXACTVolume; // Current volume set on the active variation
numTracks: TXACTIndex; // Number of tracks in the active variation
arrTrackProperties: array [0..0] of TXACT_Track_Properties; // Array of active track properties (has numTracks number of elements)
end;
{$EXTERNALSYM XACT_SOUND_PROPERTIES}
TXACT_Sound_Properties = XACT_SOUND_PROPERTIES;
// Structure used to return the properties of the active variation and the sound referenced.
PXACT_Sound_Variation_Properties = ^TXACT_Sound_Variation_Properties;
XACT_SOUND_VARIATION_PROPERTIES = record
variationProperties: TXACT_Variation_Properties; // Properties for this variation
soundProperties: TXACT_Sound_Properties; // Proeprties for the sound referenced by this variation
end;
{$EXTERNALSYM XACT_SOUND_VARIATION_PROPERTIES}
TXACT_Sound_Variation_Properties = XACT_SOUND_VARIATION_PROPERTIES;
// Structure used to return the properties of an active cue instance.
PXACT_Cue_Instance_Properties = ^TXACT_Cue_Instance_Properties;
XACT_CUE_INSTANCE_PROPERTIES = record
allocAttributes: DWORD; // Buffer allocation attributes (see XMemAlloc)
cueProperties: TXACT_Cue_Properties; // Properties of the cue that are shared by all instances.
activeVariationProperties: TXACT_Sound_Variation_Properties; // Properties if the currently active variation.
end;
{$EXTERNALSYM XACT_CUE_INSTANCE_PROPERTIES}
TXACT_Cue_Instance_Properties = XACT_CUE_INSTANCE_PROPERTIES;
// Structure used to return the common wave properties.
PXACT_Wave_Properties = ^TXACT_Wave_Properties;
XACT_WAVE_PROPERTIES = record
friendlyName: array[0..WAVEBANK_ENTRYNAME_LENGTH-1] of Char; // Friendly name for the wave; empty if the wavebank doesn't contain friendly names.
format: TWavebankMiniWaveFormat; // Format for the wave.
durationInSamples: DWORD; // Duration of the wave in units of one sample
loopRegion: TWavebankSampleRegion; // Loop region defined in samples.
streaming: BOOL; // Set to TRUE if the wave is streaming; FALSE otherwise.
end;
{$EXTERNALSYM XACT_WAVE_PROPERTIES}
TXACT_Wave_Properties = XACT_WAVE_PROPERTIES;
// Structure used to return the properties specific to a wave instance.
PXACT_Wave_Instance_Properties = ^TXACT_Wave_Instance_Properties;
XACT_WAVE_INSTANCE_PROPERTIES = record
properties: TXACT_Wave_Properties; // Static properties common to all the wave instances.
backgroundMusic: BOOL; // Set to TRUE if the wave is tagged as background music; FALSE otherwise.
end;
{$EXTERNALSYM XACT_WAVE_INSTANCE_PROPERTIES}
TXACT_Wave_Instance_Properties = XACT_WAVE_INSTANCE_PROPERTIES;
//------------------------------------------------------------------------------
// Channel Mapping / Speaker Panning
//------------------------------------------------------------------------------
PXACTChannelMapEntry = ^TXACTChannelMapEntry;
XACTCHANNELMAPENTRY = record
InputChannel: TXACTChannel;
OutputChannel: TXACTChannel;
Volume: TXACTVolume;
end;
{$EXTERNALSYM XACTCHANNELMAPENTRY}
TXACTChannelMapEntry = XACTCHANNELMAPENTRY;
PXACTChannelMap = ^TXACTChannelMap;
XACTCHANNELMAP = record
EntryCount: TXACTChannel;
paEntries: PXACTChannelMapEntry;
end;
{$EXTERNALSYM XACTCHANNELMAP}
TXACTChannelMap = XACTCHANNELMAP;
PXACTChannelVolumeEntry = ^TXACTChannelVolumeEntry;
XACTCHANNELVOLUMEENTRY = record
EntryIndex: TXACTChannel;
Volume: TXACTVolume;
end;
{$EXTERNALSYM XACTCHANNELVOLUMEENTRY}
TXACTChannelVolumeEntry = XACTCHANNELVOLUMEENTRY;
PXACTChannelVolume = ^TXACTChannelVolume;
XACTCHANNELVOLUME = record
EntryCount: TXACTChannel;
paEntries: PXACTChannelVolumeEntry;
end;
{$EXTERNALSYM XACTCHANNELVOLUME}
TXACTChannelVolume = XACTCHANNELVOLUME;
//------------------------------------------------------------------------------
// Notifications
//------------------------------------------------------------------------------
// Pack the notification structures
// Original C++ header: #pragma pack(push, 1)
// Notification description used for registering, un-registering and flushing notifications
PXACT_Notification_Description = ^TXACT_Notification_Description;
XACT_NOTIFICATION_DESCRIPTION = packed record
type_: TXACTNotificationType; // Notification type
flags: Byte; // Flags
pSoundBank: IXACTSoundBank; // SoundBank instance
pWaveBank: IXACTWaveBank; // WaveBank instance
pCue: IXACTCue; // Cue instance
pWave: IXACTWave; // Wave instance
cueIndex: TXACTIndex; // Cue index
waveIndex: TXACTIndex; // Wave index
pvContext: Pointer; // User context (optional)
end;
{$EXTERNALSYM XACT_NOTIFICATION_DESCRIPTION}
TXACT_Notification_Description = XACT_NOTIFICATION_DESCRIPTION;
// Notification structure for all XACTNOTIFICATIONTYPE_CUE* notifications
PXACT_Notification_Cue = ^TXACT_Notification_Cue;
XACT_NOTIFICATION_CUE = packed record
cueIndex: TXACTIndex; // Cue index
pSoundBank: IXACTSoundBank; // SoundBank instance
pCue: IXACTCue; // Cue instance
end;
{$EXTERNALSYM XACT_NOTIFICATION_CUE}
TXACT_Notification_Cue = XACT_NOTIFICATION_CUE;
// Notification structure for all XACTNOTIFICATIONTYPE_MARKER* notifications
PXACT_Notification_Marker = ^TXACT_Notification_Marker;
XACT_NOTIFICATION_MARKER = packed record
cueIndex: TXACTIndex; // Cue index
pSoundBank: IXACTSoundBank; // SoundBank instance
pCue: IXACTCue; // Cue instance
marker: DWORD; // Marker value
end;
{$EXTERNALSYM XACT_NOTIFICATION_MARKER}
TXACT_Notification_Marker = XACT_NOTIFICATION_MARKER;
// Notification structure for all XACTNOTIFICATIONTYPE_SOUNDBANK* notifications
PXACT_Notification_SoundBank = ^TXACT_Notification_SoundBank;
XACT_NOTIFICATION_SOUNDBANK = packed record
pSoundBank: IXACTSoundBank; // SoundBank instance
end;
{$EXTERNALSYM XACT_NOTIFICATION_SOUNDBANK}
TXACT_Notification_SoundBank = XACT_NOTIFICATION_SOUNDBANK;
// Notification structure for all XACTNOTIFICATIONTYPE_WAVEBANK* notifications
PXACT_Notification_WaveBank = ^TXACT_Notification_WaveBank;
XACT_NOTIFICATION_WAVEBANK = packed record
pWaveBank: IXACTWaveBank; // WaveBank instance
end;
{$EXTERNALSYM XACT_NOTIFICATION_WAVEBANK}
TXACT_Notification_WaveBank = XACT_NOTIFICATION_WAVEBANK;
// Notification structure for all XACTNOTIFICATIONTYPE_*VARIABLE* notifications
PXACT_Notification_Variable = ^TXACT_Notification_Variable;
XACT_NOTIFICATION_VARIABLE = packed record
cueIndex: TXACTIndex; // Cue index
pSoundBank: IXACTSoundBank; // SoundBank instance
pCue: IXACTCue; // Cue instance
variableIndex: TXACTVariableIndex; // Variable index
variableValue: TXACTVariableValue; // Variable value
local: BOOL; // TRUE if a local variable
end;
{$EXTERNALSYM XACT_NOTIFICATION_VARIABLE}
TXACT_Notification_Variable = XACT_NOTIFICATION_VARIABLE;
// Notification structure for all XACTNOTIFICATIONTYPE_GUI* notifications
PXACT_Notification_GUI = ^TXACT_Notification_GUI;
XACT_NOTIFICATION_GUI = packed record
reserved: DWORD; // Reserved
end;
{$EXTERNALSYM XACT_NOTIFICATION_GUI}
TXACT_Notification_GUI = XACT_NOTIFICATION_GUI;
// Notification structure for all XACTNOTIFICATIONTYPE_WAVE* notifications
PXACT_Notification_Wave = ^TXACT_Notification_Wave;
XACT_NOTIFICATION_WAVE = packed record
pWaveBank: IXACTWaveBank; // WaveBank
waveIndex: TXACTIndex; // Wave index
cueIndex: TXACTIndex; // Cue index
pSoundBank: IXACTSoundBank; // SoundBank instance
pCue: IXACTCue; // Cue instance
pWave: IXACTWave; // Wave instance
end;
{$EXTERNALSYM XACT_NOTIFICATION_WAVE}
TXACT_Notification_Wave = XACT_NOTIFICATION_WAVE;
// General notification structure
XACT_NOTIFICATION = packed record
type_: TXACTNotificationType; // Notification type
timeStamp: Longint; // Timestamp of notification (milliseconds)
pvContext: Pointer; // User context (optional)
case Byte of
1: (cue: TXACT_Notification_Cue); // XACTNOTIFICATIONTYPE_CUE*
2: (marker: TXACT_Notification_Marker); // XACTNOTIFICATIONTYPE_MARKER*
3: (soundBank: TXACT_Notification_SoundBank); // XACTNOTIFICATIONTYPE_SOUNDBANK*
4: (waveBank: TXACT_Notification_WaveBank); // XACTNOTIFICATIONTYPE_WAVEBANK*
5: (variable: TXACT_Notification_Variable); // XACTNOTIFICATIONTYPE_VARIABLE*
6: (gui: TXACT_Notification_GUI); // XACTNOTIFICATIONTYPE_GUI*
7: (wave: TXACT_Notification_Wave); // XACTNOTIFICATIONTYPE_WAVE*
end;
{$EXTERNALSYM XACT_NOTIFICATION}
TXACT_Notification = XACT_NOTIFICATION;
//Original C++ header: #pragma pack(pop)
//------------------------------------------------------------------------------
// IXACTSoundBank
//------------------------------------------------------------------------------
{$EXTERNALSYM IXACTSoundBank}
IXACTSoundBank = class
function GetCueIndex(szFriendlyName: PAnsiChar): TXACTIndex; virtual; stdcall; abstract;
function GetNumCues(pnNumCues: PXACTIndex): HResult; virtual; stdcall; abstract;
function GetCueProperties(nCueIndex: TXACTIndex; pProperties: PXACT_Cue_Properties): HResult; virtual; stdcall; abstract;
function Prepare(nCueIndex: TXACTIndex; dwFlags: DWORD; timeOffset: TXACTTime; out ppCue: IXACTCue): HResult; virtual; stdcall; abstract;
function Play(nCueIndex: TXACTIndex; dwFlags: DWORD; timeOffset: TXACTTime; ppCue: PIXACTCue): HResult; virtual; stdcall; abstract;
function Stop(nCueIndex: TXACTIndex; dwFlags: DWORD): HResult; virtual; stdcall; abstract;
{$WARNINGS OFF}
function Destroy: HResult; virtual; stdcall; abstract; //Clootie: This method is not related to Delphi TObject.Destroy
{$WARNINGS ON}
function GetState(out pdwState: DWORD): HResult; virtual; stdcall; abstract;
end;
//------------------------------------------------------------------------------
// IXACTWaveBank
//------------------------------------------------------------------------------
{$EXTERNALSYM IXACTWaveBank}
IXACTWaveBank = class
{$WARNINGS OFF}
function Destroy: HResult; virtual; stdcall; abstract; //Clootie: This method is not related to Delphi TObject.Destroy
{$WARNINGS ON}
function GetNumWaves(pnNumWaves: PXACTIndex): HResult; virtual; stdcall; abstract;
function GetWaveIndex(szFriendlyName: PAnsiChar): XACTINDEX; virtual; stdcall; abstract;
function GetWaveProperties(nWaveIndex: TXACTIndex; pWaveProperties: PXACT_Wave_Properties): HResult; virtual; stdcall; abstract;
function Prepare(nWaveIndex: TXACTIndex; dwFlags: DWORD; dwPlayOffset: DWORD; nLoopCount: TXACTLoopCount; out ppWave: IXACTWave): HResult; virtual; stdcall; abstract;
function Play(nWaveIndex: TXACTIndex; dwFlags: DWORD; dwPlayOffset: DWORD; nLoopCount: TXACTLoopCount; out ppWave: IXACTWave): HResult; virtual; stdcall; abstract;
function Stop(nWaveIndex: TXACTIndex; dwFlags: DWORD): HResult; virtual; stdcall; abstract;
function GetState(out pdwState: DWORD): HResult; virtual; stdcall; abstract;
end;
//------------------------------------------------------------------------------
// IXACTWave
//------------------------------------------------------------------------------
{$EXTERNALSYM IXACTWave}
IXACTWave = class
{$WARNINGS OFF}
function Destroy: HResult; virtual; stdcall; abstract; //Clootie: This method is not related to Delphi TObject.Destroy
{$WARNINGS ON}
function Play: HResult; virtual; stdcall; abstract;
function Stop(dwFlags: DWORD): HResult; virtual; stdcall; abstract;
function Pause(fPause: BOOL): HResult; virtual; stdcall; abstract;
function GetState(out pdwState: DWORD): HResult; virtual; stdcall; abstract;
function SetPitch(pitch: TXACTPitch): HResult; virtual; stdcall; abstract;
function SetVolume(volume: TXACTVolume): HResult; virtual; stdcall; abstract;
function SetMatrixCoefficients(uSrcChannelCount: UINT32; uDstChannelCount: UINT32; pMatrixCoefficients: PSingle): HResult; virtual; stdcall; abstract;
function GetProperties(out pProperties: TXACT_Wave_Instance_Properties): HResult; virtual; stdcall; abstract;
end;
//------------------------------------------------------------------------------
// IXACTCue
//------------------------------------------------------------------------------
{$EXTERNALSYM IXACTCue}
IXACTCue = class
function Play: HResult; virtual; stdcall; abstract;
function Stop(dwFlags: DWORD): HResult; virtual; stdcall; abstract;
function GetState(out pdwState: DWORD): HResult; virtual; stdcall; abstract;
{$WARNINGS OFF}
function Destroy: HResult; virtual; stdcall; abstract; //Clootie: This method is not related to Delphi TObject.Destroy
{$WARNINGS ON}
function GetChannelMap(pChannelMap: PXACTChannelMap; BufferSize: DWORD; pRequiredSize: PDWORD): HResult; virtual; stdcall; abstract;
function SetChannelMap(const pChannelMap: PXACTChannelMap): HResult; virtual; stdcall; abstract;
function GetChannelVolume(const pVolume: PXACTChannelVolume): HResult; virtual; stdcall; abstract;
function SetChannelVolume(const pVolume: PXACTChannelVolume): HResult; virtual; stdcall; abstract;
function SetMatrixCoefficients(uSrcChannelCount: LongWord; uDstChannelCount: LongWord; pMatrixCoefficients: PSingle): HResult; virtual; stdcall; abstract;
function GetVariableIndex(szFriendlyName: PAnsiChar): TXACTVariableIndex; virtual; stdcall; abstract;
function SetVariable(nIndex: TXACTVariableIndex; nValue: TXACTVariableValue): HResult; virtual; stdcall; abstract;
function GetVariable(nIndex: TXACTVariableIndex; out nValue: TXACTVariableValue): HResult; virtual; stdcall; abstract;
function Pause(fPause: BOOL): HResult; virtual; stdcall; abstract;
function GetProperties(out ppProperties: TXACT_Cue_Instance_Properties): HResult; virtual; stdcall; abstract;
{$IFDEF XBOX}
function SetVoiceOutput(pVoiceOutput: PXAudioVoiceOutput): HResult; virtual; stdcall; abstract;
function SetVoiceOutputVolume(pVolume: PXAudioVoiceOutputVolume): HResult; virtual; stdcall; abstract;
{$ENDIF} // _XBOX
end;
//------------------------------------------------------------------------------
// IXACTEngine
//------------------------------------------------------------------------------
{$EXTERNALSYM IXACTEngine}
{$IFDEF XBOX}
IXACTEngine = interface // !CORBA!
function AddRef: Cardinal; stdcall;
function Release: Cardinal; stdcall;
{$ELSE}
IXACTEngine = interface(IUnknown)
['{c2f0af68-1f6d-40ed-964f-26256842edc4}']
{$ENDIF}
{$IFNDEF XBOX}
function GetRendererCount(out pnRendererCount: TXACTIndex): HResult; stdcall;
function GetRendererDetails(nRendererIndex: TXACTIndex; out pRendererDetails: TXACTRendererDetails): HResult; stdcall;
{$ENDIF}
function GetFinalMixFormat(out pFinalMixFormat: TWaveFormatExtensible): HResult; stdcall;
function Initialize(const pParams: TXACT_Runtime_Parameters): HResult; stdcall;
function ShutDown: HResult; stdcall;
function DoWork: HResult; stdcall;
function CreateSoundBank(const pvBuffer: Pointer; dwSize: DWORD; dwFlags: DWORD; dwAllocAttributes: DWORD; out ppSoundBank: IXACTSoundBank): HResult; stdcall;
function CreateInMemoryWaveBank(const pvBuffer: Pointer; dwSize: DWORD; dwFlags: DWORD; dwAllocAttributes: DWORD; out ppWaveBank: IXACTWaveBank): HResult; stdcall;
function CreateStreamingWaveBank(const pParms: TXACT_Wavebank_Streaming_Parameters; out ppWaveBank: IXACTWaveBank): HResult; stdcall;
function PrepareWave(dwFlags: DWORD; szWavePath: PAnsiChar; wStreamingPacketSize: Word; dwAlignment: DWORD; dwPlayOffset: DWORD; nLoopCount: XACTLOOPCOUNT; out ppWave: IXACTWave): HResult; stdcall;
function PrepareInMemoryWave(dwFlags: DWORD; entry: TWavebankEntry; pdwSeekTable: PDWORD; pbWaveData: PByte; dwPlayOffset: DWORD; nLoopCount: XACTLOOPCOUNT; out ppWave: IXACTWave): HResult; stdcall;
function PrepareStreamingWave(dwFlags: DWORD; entry: TWavebankEntry; streamingParams: TXACT_Streaming_Parameters; dwAlignment: DWORD; pdwSeekTable: PDWORD; dwPlayOffset: DWORD; nLoopCount: TXACTLoopCount; out ppWave: IXACTWave): HResult; stdcall;
function RegisterNotification(const pNotificationDesc: TXACT_Notification_Description): HResult; stdcall;
function UnRegisterNotification(const pNotificationDesc: TXACT_Notification_Description): HResult; stdcall;
function GetCategory(szFriendlyName: PAnsiChar): TXACTCategory; stdcall;
function Stop(nCategory: TXACTCategory; dwFlags: DWORD): HResult; stdcall;
function SetVolume(nCategory: TXACTCategory; nVolume: TXACTVolume): HResult; stdcall;
function Pause(nCategory: TXACTCategory; fPause: BOOL): HResult; stdcall;
function GetGlobalVariableIndex(szFriendlyName: PAnsiChar): TXACTVariableIndex; stdcall;
function SetGlobalVariable(nIndex: TXACTVariableIndex; nValue: TXACTVariableValue): HResult; stdcall;
function GetGlobalVariable(nIndex: TXACTVariableIndex; out nValue: TXACTVariableValue): HResult; stdcall;
end;
IID_IXACTEngine = IXACTEngine;
{$EXTERNALSYM IID_IXACTEngine}
//------------------------------------------------------------------------------
// XACT API's (these are deprecated and will be removed in a future release)
//------------------------------------------------------------------------------
{$IFDEF XBOX}
(*
#define XACT_FLAG_API_CREATE_MANAGEDATA XACT_FLAG_MANAGEDATA
#define XACT_FLAG_API_STOP_IMMEDIATE XACT_FLAG_STOP_IMMEDIATE
STDAPI XACTInitialize(const XACT_RUNTIME_PARAMETERS* pParams);
STDAPI XACTShutDown(void);
STDAPI XACTDoWork(void);
STDAPI XACTCreateSoundBank(const void* pvBuffer, DWORD dwSize, DWORD dwFlags, DWORD dwAllocAttributes, IXACTSoundBank** ppSoundBank);
STDAPI XACTCreateInMemoryWaveBank(const void* pvBuffer, DWORD dwSize, DWORD dwFlags, DWORD dwAllocAttributes, IXACTWaveBank** ppWaveBank);
STDAPI XACTCreateStreamingWaveBank(const XACT_WAVEBANK_STREAMING_PARAMETERS* pParms, IXACTWaveBank** ppWaveBank);
STDAPI XACTRegisterNotification(const XACT_NOTIFICATION_DESCRIPTION* pNotificationDesc);
STDAPI XACTUnRegisterNotification(const XACT_NOTIFICATION_DESCRIPTION* pNotificationDesc);
STDAPI_(XACTCATEGORY) XACTGetCategory(PCSTR szFriendlyName);
STDAPI XACTStop(XACTCATEGORY nCategory, DWORD dwFlags);
STDAPI XACTSetVolume(XACTCATEGORY nCategory, XACTVOLUME nVolume);
STDAPI XACTPause(XACTCATEGORY nCategory, BOOL fPause);
STDAPI_(XACTVARIABLEINDEX) XACTGetGlobalVariableIndex(PCSTR szFriendlyName);
STDAPI XACTSetGlobalVariable(XACTVARIABLEINDEX nIndex, XACTVARIABLEVALUE nValue);
STDAPI XACTGetGlobalVariable(XACTVARIABLEINDEX nIndex, XACTVARIABLEVALUE* pnValue);
*)
{$ENDIF XBOX}
//------------------------------------------------------------------------------
// Create Engine
//------------------------------------------------------------------------------
// Flags used only in XACTCreateEngine below. These flags are valid but ignored
// when building for Xbox 360; to enable auditioning on that platform you must
// link explicitly to an auditioning version of the XACT static library.
const
XACT_FLAG_API_AUDITION_MODE = DWORD($00000001);
{$EXTERNALSYM XACT_FLAG_API_AUDITION_MODE}
XACT_FLAG_API_DEBUG_MODE = DWORD($00000002);
{$EXTERNALSYM XACT_FLAG_API_DEBUG_MODE}
function XACTCreateEngine(dwCreationFlags: DWORD; out ppEngine: IXACTEngine): HRESULT; stdcall; // inline
{$EXTERNALSYM XACTCreateEngine}
{$IFNDEF XBOX}
const
XACT_DEBUGENGINE_REGISTRY_KEY = 'Software\Microsoft\XACT';
{$EXTERNALSYM XACT_DEBUGENGINE_REGISTRY_KEY}
XACT_DEBUGENGINE_REGISTRY_VALUE = 'DebugEngine';
{$EXTERNALSYM XACT_DEBUGENGINE_REGISTRY_VALUE}
{$ENDIF}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// Standard win32 multimedia definitions
//------------------------------------------------------------------------------
const
WAVE_FORMAT_IEEE_FLOAT = $0003;
{$EXTERNALSYM WAVE_FORMAT_IEEE_FLOAT}
WAVE_FORMAT_EXTENSIBLE = $FFFE;
{$EXTERNALSYM WAVE_FORMAT_EXTENSIBLE}
//------------------------------------------------------------------------------
// Constants
//------------------------------------------------------------------------------
const
LONG_MIN = (-2147483647-1);
LONG_MAX = 2147483647;
const
XACTTIME_MIN = TXACTTime(LONG_MIN);
{$EXTERNALSYM XACTTIME_MIN}
XACTTIME_MAX = TXACTTime(LONG_MAX); // 24 days 20:31:23.647
{$EXTERNALSYM XACTTIME_MAX}
XACTTIME_INFINITE = TXACTTime(LONG_MAX);
{$EXTERNALSYM XACTTIME_INFINITE}
XACTINSTANCELIMIT_INFINITE = TXACTInstanceLimit($ff);
{$EXTERNALSYM XACTINSTANCELIMIT_INFINITE}
XACTINSTANCELIMIT_MIN = TXACTInstanceLimit($00); // == 1 instance total (0 additional instances)
{$EXTERNALSYM XACTINSTANCELIMIT_MIN}
XACTINSTANCELIMIT_MAX = TXACTInstanceLimit($fe); // == 255 instances total (254 additional instances)
{$EXTERNALSYM XACTINSTANCELIMIT_MAX}
XACTINDEX_MIN = TXACTIndex($0);
{$EXTERNALSYM XACTINDEX_MIN}
XACTINDEX_MAX = TXACTIndex($fffe);
{$EXTERNALSYM XACTINDEX_MAX}
XACTINDEX_INVALID = TXACTIndex($ffff);
{$EXTERNALSYM XACTINDEX_INVALID}
XACTNOTIFICATIONTYPE_MIN = TXACTNotificationType($00);
{$EXTERNALSYM XACTNOTIFICATIONTYPE_MIN}
XACTNOTIFICATIONTYPE_MAX = TXACTNotificationType($ff);
{$EXTERNALSYM XACTNOTIFICATIONTYPE_MAX}
XACTVARIABLEVALUE_MIN: TXACTVariableValue = -3.402823466e+38; // -FLT_MAX;
{$EXTERNALSYM XACTVARIABLEVALUE_MIN}
XACTVARIABLEVALUE_MAX: TXACTVariableValue = 3.402823466e+38; // FLT_MAX;
{$EXTERNALSYM XACTVARIABLEVALUE_MAX}
XACTVARIABLEINDEX_MIN = TXACTVariableIndex($0000);
{$EXTERNALSYM XACTVARIABLEINDEX_MIN}
XACTVARIABLEINDEX_MAX = TXACTVariableIndex($fffe);
{$EXTERNALSYM XACTVARIABLEINDEX_MAX}
XACTVARIABLEINDEX_INVALID = TXACTVariableIndex($ffff);
{$EXTERNALSYM XACTVARIABLEINDEX_INVALID}
XACTCATEGORY_MIN = TXACTCategory($0);
{$EXTERNALSYM XACTCATEGORY_MIN}
XACTCATEGORY_MAX = TXACTCategory($fffe);
{$EXTERNALSYM XACTCATEGORY_MAX}
XACTCATEGORY_INVALID = TXACTCategory($ffff);
{$EXTERNALSYM XACTCATEGORY_INVALID}
XACTCHANNEL_MIN = TXACTChannel(0);
{$EXTERNALSYM XACTCHANNEL_MIN}
XACTCHANNEL_MAX = TXACTChannel($FF);
{$EXTERNALSYM XACTCHANNEL_MAX}
XACTPITCH_MIN = TXACTPitch(-1200);
{$EXTERNALSYM XACTPITCH_MIN}
XACTPITCH_MAX = TXACTPitch( 1200);
{$EXTERNALSYM XACTPITCH_MAX}
XACTVOLUME_MIN = {TXACTVolume}(0.0);
{$EXTERNALSYM XACTVOLUME_MIN}
XACTVOLUME_MAX = {TXACTVolume}(3.402823466e+38); // FLT_MAX;
{$EXTERNALSYM XACTVOLUME_MAX}
XACTPARAMETERVALUE_MIN: TXACTVariableValue = -3.402823466e+38; // -FLT_MAX;
{$EXTERNALSYM XACTPARAMETERVALUE_MIN}
XACTPARAMETERVALUE_MAX: TXACTVariableValue = 3.402823466e+38; // FLT_MAX;
{$EXTERNALSYM XACTPARAMETERVALUE_MAX}
XACTLOOPCOUNT_MIN = TXACTLoopCount(0);
XACTLOOPCOUNT_MAX = TXACTLoopCount($fe);
XACTLOOPCOUNT_INFINITE = TXACTLoopCount($ff);
XACTWAVEALIGNMENT_MIN = 2048;
{$IFDEF XBOX}
XACTMAXOUTPUTVOICECOUNT: TXAudioVoiceIndex = 3;
{$EXTERNALSYM XACTMAXOUTPUTVOICECOUNT}
{$ENDIF} // XBOX
// -----------------------------------------------------------------------------
// Current Content Tool Version
// -----------------------------------------------------------------------------
XACT_CONTENT_VERSION = 42;
{$EXTERNALSYM XACT_CONTENT_VERSION}
// -----------------------------------------------------------------------------
// XACT Stop Flags
// -----------------------------------------------------------------------------
XACT_FLAG_STOP_RELEASE = DWORD($00000000); // Stop with release envelope (or as authored), for looping waves this acts as break loop.
{$EXTERNALSYM XACT_FLAG_STOP_RELEASE}
XACT_FLAG_STOP_IMMEDIATE = DWORD($00000001); // Stop immediately
{$EXTERNALSYM XACT_FLAG_STOP_IMMEDIATE}
// -----------------------------------------------------------------------------
// XACT Manage Data Flag - XACT will manage the lifetime of this data
// -----------------------------------------------------------------------------
XACT_FLAG_MANAGEDATA = DWORD($00000001);
{$EXTERNALSYM XACT_FLAG_MANAGEDATA}
// -----------------------------------------------------------------------------
// XACT Content Preparation Flags
// -----------------------------------------------------------------------------
XACT_FLAG_BACKGROUND_MUSIC = DWORD($00000002); // Marks the waves as background music.
{$EXTERNALSYM XACT_FLAG_BACKGROUND_MUSIC}
XACT_FLAG_UNITS_MS = DWORD($00000004); // Indicates that the units passed in are in milliseconds.
{$EXTERNALSYM XACT_FLAG_UNITS_MS}
XACT_FLAG_UNITS_SAMPLES = DWORD($00000008); // Indicates that the units passed in are in samples.
{$EXTERNALSYM XACT_FLAG_UNITS_SAMPLES}
// -----------------------------------------------------------------------------
// XACT State flags
// -----------------------------------------------------------------------------
XACT_STATE_CREATED = DWORD($00000001); // Created, but nothing else
{$EXTERNALSYM XACT_STATE_CREATED}
XACT_STATE_PREPARING = DWORD($00000002); // In the middle of preparing
{$EXTERNALSYM XACT_STATE_PREPARING}
XACT_STATE_PREPARED = DWORD($00000004); // Prepared, but not yet played
{$EXTERNALSYM XACT_STATE_PREPARED}
XACT_STATE_PLAYING = DWORD($00000008); // Playing (though could be paused)
{$EXTERNALSYM XACT_STATE_PLAYING}
XACT_STATE_STOPPING = DWORD($00000010); // Stopping
{$EXTERNALSYM XACT_STATE_STOPPING}
XACT_STATE_STOPPED = DWORD($00000020); // Stopped
{$EXTERNALSYM XACT_STATE_STOPPED}
XACT_STATE_PAUSED = DWORD($00000040); // Paused (Can be combined with some of the other state flags above)
{$EXTERNALSYM XACT_STATE_PAUSED}
XACT_STATE_INUSE = DWORD($00000080); // Object is in use (used by wavebanks and soundbanks).
{$EXTERNALSYM XACT_STATE_INUSE}
XACT_STATE_PREPAREFAILED = DWORD($80000000); // Object preparation failed.
{$EXTERNALSYM XACT_STATE_PREPAREFAILED}
//------------------------------------------------------------------------------
// XACT Parameters
//------------------------------------------------------------------------------
XACT_FLAG_GLOBAL_SETTINGS_MANAGEDATA = XACT_FLAG_MANAGEDATA;
{$EXTERNALSYM XACT_FLAG_GLOBAL_SETTINGS_MANAGEDATA}
//------------------------------------------------------------------------------
// Notifications
//------------------------------------------------------------------------------
XACTNOTIFICATIONTYPE_CUEPREPARED = TXACTNotificationType(1); // None, SoundBank, SoundBank & cue index, cue instance
{$EXTERNALSYM XACTNOTIFICATIONTYPE_CUEPREPARED}
XACTNOTIFICATIONTYPE_CUEPLAY = TXACTNotificationType(2); // None, SoundBank, SoundBank & cue index, cue instance
{$EXTERNALSYM XACTNOTIFICATIONTYPE_CUEPLAY}
XACTNOTIFICATIONTYPE_CUESTOP = TXACTNotificationType(3); // None, SoundBank, SoundBank & cue index, cue instance
{$EXTERNALSYM XACTNOTIFICATIONTYPE_CUESTOP}
XACTNOTIFICATIONTYPE_CUEDESTROYED = TXACTNotificationType(4); // None, SoundBank, SoundBank & cue index, cue instance
{$EXTERNALSYM XACTNOTIFICATIONTYPE_CUEDESTROYED}
XACTNOTIFICATIONTYPE_MARKER = TXACTNotificationType(5); // None, SoundBank, SoundBank & cue index, cue instance
{$EXTERNALSYM XACTNOTIFICATIONTYPE_MARKER}
XACTNOTIFICATIONTYPE_SOUNDBANKDESTROYED = TXACTNotificationType(6); // None, SoundBank
{$EXTERNALSYM XACTNOTIFICATIONTYPE_SOUNDBANKDESTROYED}
XACTNOTIFICATIONTYPE_WAVEBANKDESTROYED = TXACTNotificationType(7); // None, WaveBank
{$EXTERNALSYM XACTNOTIFICATIONTYPE_WAVEBANKDESTROYED}
XACTNOTIFICATIONTYPE_LOCALVARIABLECHANGED = TXACTNotificationType(8); // None, SoundBank, SoundBank & cue index, cue instance
{$EXTERNALSYM XACTNOTIFICATIONTYPE_LOCALVARIABLECHANGED}
XACTNOTIFICATIONTYPE_GLOBALVARIABLECHANGED = TXACTNotificationType(9); // None
{$EXTERNALSYM XACTNOTIFICATIONTYPE_GLOBALVARIABLECHANGED}
XACTNOTIFICATIONTYPE_GUICONNECTED = TXACTNotificationType(10); // None
{$EXTERNALSYM XACTNOTIFICATIONTYPE_GUICONNECTED}
XACTNOTIFICATIONTYPE_GUIDISCONNECTED = TXACTNotificationType(11); // None
{$EXTERNALSYM XACTNOTIFICATIONTYPE_GUIDISCONNECTED}
XACTNOTIFICATIONTYPE_WAVEPREPARED = TXACTNotificationType(12); // None, WaveBank & wave index, wave instance.
{$EXTERNALSYM XACTNOTIFICATIONTYPE_WAVEPREPARED}
XACTNOTIFICATIONTYPE_WAVEPLAY = TXACTNotificationType(13); // None, SoundBank, SoundBank & cue index, cue instance, WaveBank, wave instance
{$EXTERNALSYM XACTNOTIFICATIONTYPE_WAVEPLAY}
XACTNOTIFICATIONTYPE_WAVESTOP = TXACTNotificationType(14); // None, SoundBank, SoundBank & cue index, cue instance, WaveBank, wave instance
{$EXTERNALSYM XACTNOTIFICATIONTYPE_WAVESTOP}
XACTNOTIFICATIONTYPE_WAVELOOPED = TXACTNotificationType(15); // None, SoundBank, SoundBank & cue index, cue instance, WaveBank, wave instance
{$EXTERNALSYM XACTNOTIFICATIONTYPE_WAVELOOPED}
XACTNOTIFICATIONTYPE_WAVEDESTROYED = TXACTNotificationType(16); // None, WaveBank & wave index, wave instance.
{$EXTERNALSYM XACTNOTIFICATIONTYPE_WAVEDESTROYED}
XACTNOTIFICATIONTYPE_WAVEBANKPREPARED = TXACTNotificationType(17); // None, WaveBank
{$EXTERNALSYM XACTNOTIFICATIONTYPE_WAVEBANKPREPARED}
XACTNOTIFICATIONTYPE_WAVEBANKSTREAMING_INVALIDCONTENT = TXACTNotificationType(18); // None, WaveBank
{$EXTERNALSYM XACTNOTIFICATIONTYPE_WAVEBANKSTREAMING_INVALIDCONTENT}
XACT_FLAG_NOTIFICATION_PERSIST = $01;
{$EXTERNALSYM XACT_FLAG_NOTIFICATION_PERSIST}
//------------------------------------------------------------------------------
// IXACTSoundBank
//------------------------------------------------------------------------------
XACT_FLAG_SOUNDBANK_STOP_IMMEDIATE = XACT_FLAG_STOP_IMMEDIATE;
{$EXTERNALSYM XACT_FLAG_SOUNDBANK_STOP_IMMEDIATE}
XACT_SOUNDBANKSTATE_INUSE = XACT_STATE_INUSE;
{$EXTERNALSYM XACT_SOUNDBANKSTATE_INUSE}
//------------------------------------------------------------------------------
// IXACTWaveBank
//------------------------------------------------------------------------------
XACT_WAVEBANKSTATE_INUSE = XACT_STATE_INUSE; // Currently in-use
{$EXTERNALSYM XACT_WAVEBANKSTATE_INUSE}
XACT_WAVEBANKSTATE_PREPARED = XACT_STATE_PREPARED; // Prepared
{$EXTERNALSYM XACT_WAVEBANKSTATE_PREPARED}
XACT_WAVEBANKSTATE_PREPAREFAILED = XACT_STATE_PREPAREFAILED; // Prepare failed.
{$EXTERNALSYM XACT_WAVEBANKSTATE_PREPAREFAILED}
//------------------------------------------------------------------------------
// IXACTCue
//------------------------------------------------------------------------------
// Cue Flags
XACT_FLAG_CUE_STOP_RELEASE = XACT_FLAG_STOP_RELEASE;
{$EXTERNALSYM XACT_FLAG_CUE_STOP_RELEASE}
XACT_FLAG_CUE_STOP_IMMEDIATE = XACT_FLAG_STOP_IMMEDIATE;
{$EXTERNALSYM XACT_FLAG_CUE_STOP_IMMEDIATE}
// Mutually exclusive states
XACT_CUESTATE_CREATED = XACT_STATE_CREATED; // Created, but nothing else
{$EXTERNALSYM XACT_CUESTATE_CREATED}
XACT_CUESTATE_PREPARING = XACT_STATE_PREPARING; // In the middle of preparing
{$EXTERNALSYM XACT_CUESTATE_PREPARING}
XACT_CUESTATE_PREPARED = XACT_STATE_PREPARED; // Prepared, but not yet played
{$EXTERNALSYM XACT_CUESTATE_PREPARED}
XACT_CUESTATE_PLAYING = XACT_STATE_PLAYING; // Playing (though could be paused)
{$EXTERNALSYM XACT_CUESTATE_PLAYING}
XACT_CUESTATE_STOPPING = XACT_STATE_STOPPING; // Stopping
{$EXTERNALSYM XACT_CUESTATE_STOPPING}
XACT_CUESTATE_STOPPED = XACT_STATE_STOPPED; // Stopped
{$EXTERNALSYM XACT_CUESTATE_STOPPED}
XACT_CUESTATE_PAUSED = XACT_STATE_PAUSED; // Paused (can be combined with other states)
{$EXTERNALSYM XACT_CUESTATE_PAUSED}
//------------------------------------------------------------------------------
// IXACTEngine
//------------------------------------------------------------------------------
// Engine flags
XACT_FLAG_ENGINE_CREATE_MANAGEDATA = XACT_FLAG_MANAGEDATA;
{$EXTERNALSYM XACT_FLAG_ENGINE_CREATE_MANAGEDATA}
XACT_FLAG_ENGINE_STOP_IMMEDIATE = XACT_FLAG_STOP_IMMEDIATE;
{$EXTERNALSYM XACT_FLAG_ENGINE_STOP_IMMEDIATE}
//------------------------------------------------------------------------------
// XACT specific error codes
//------------------------------------------------------------------------------
const
FACILITY_XACTENGINE = $AC7;
{$EXTERNALSYM FACILITY_XACTENGINE}
// #define XACTENGINEERROR(n) MAKE_HRESULT(SEVERITY_ERROR, FACILITY_XACTENGINE, n)
// XACTENGINEERROR(n) = DWord((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or n;
XACTENGINE_E_OUTOFMEMORY = E_OUTOFMEMORY; // Out of memory
{$EXTERNALSYM XACTENGINE_E_OUTOFMEMORY}
XACTENGINE_E_INVALIDARG = E_INVALIDARG; // Invalid arg
{$EXTERNALSYM XACTENGINE_E_INVALIDARG}
XACTENGINE_E_NOTIMPL = E_NOTIMPL; // Not implemented
{$EXTERNALSYM XACTENGINE_E_NOTIMPL}
XACTENGINE_E_FAIL = E_FAIL; // Unknown error
{$EXTERNALSYM XACTENGINE_E_FAIL}
XACTENGINE_E_ALREADYINITIALIZED = DWord(((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or $001); // The engine is already initialized
{$EXTERNALSYM XACTENGINE_E_ALREADYINITIALIZED}
XACTENGINE_E_NOTINITIALIZED = DWord(((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or $002); // The engine has not been initialized
{$EXTERNALSYM XACTENGINE_E_NOTINITIALIZED}
XACTENGINE_E_EXPIRED = DWord(((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or $003); // The engine has expired (demo or pre-release version)
{$EXTERNALSYM XACTENGINE_E_EXPIRED}
XACTENGINE_E_NONOTIFICATIONCALLBACK = DWord(((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or $004); // No notification callback
{$EXTERNALSYM XACTENGINE_E_NONOTIFICATIONCALLBACK}
XACTENGINE_E_NOTIFICATIONREGISTERED = DWord(((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or $005); // Notification already registered
{$EXTERNALSYM XACTENGINE_E_NOTIFICATIONREGISTERED}
XACTENGINE_E_INVALIDUSAGE = DWord(((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or $006); // Invalid usage
{$EXTERNALSYM XACTENGINE_E_INVALIDUSAGE}
XACTENGINE_E_INVALIDDATA = DWord(((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or $007); // Invalid data
{$EXTERNALSYM XACTENGINE_E_INVALIDDATA}
XACTENGINE_E_INSTANCELIMITFAILTOPLAY = DWord(((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or $008); // Fail to play due to instance limit
{$EXTERNALSYM XACTENGINE_E_INSTANCELIMITFAILTOPLAY}
XACTENGINE_E_NOGLOBALSETTINGS = DWord(((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or $009); // Global Settings not loaded
{$EXTERNALSYM XACTENGINE_E_NOGLOBALSETTINGS}
XACTENGINE_E_INVALIDVARIABLEINDEX = DWord(((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or $00a); // Invalid variable index
{$EXTERNALSYM XACTENGINE_E_INVALIDVARIABLEINDEX}
XACTENGINE_E_INVALIDCATEGORY = DWord(((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or $00b); // Invalid category
{$EXTERNALSYM XACTENGINE_E_INVALIDCATEGORY}
XACTENGINE_E_INVALIDCUEINDEX = DWord(((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or $00c); // Invalid cue index
{$EXTERNALSYM XACTENGINE_E_INVALIDCUEINDEX}
XACTENGINE_E_INVALIDWAVEINDEX = DWord(((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or $00d); // Invalid wave index
{$EXTERNALSYM XACTENGINE_E_INVALIDWAVEINDEX}
XACTENGINE_E_INVALIDTRACKINDEX = DWord(((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or $00e); // Invalid track index
{$EXTERNALSYM XACTENGINE_E_INVALIDTRACKINDEX}
XACTENGINE_E_INVALIDSOUNDOFFSETORINDEX = DWord(((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or $00f); // Invalid sound offset or index
{$EXTERNALSYM XACTENGINE_E_INVALIDSOUNDOFFSETORINDEX}
XACTENGINE_E_READFILE = DWord(((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or $010); // Error reading a file
{$EXTERNALSYM XACTENGINE_E_READFILE}
XACTENGINE_E_UNKNOWNEVENT = DWord(((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or $011); // Unknown event type
{$EXTERNALSYM XACTENGINE_E_UNKNOWNEVENT}
XACTENGINE_E_INCALLBACK = DWord(((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or $012); // Invalid call of method of function from callback
{$EXTERNALSYM XACTENGINE_E_INCALLBACK}
XACTENGINE_E_NOWAVEBANK = DWord(((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or $013); // No wavebank exists for desired operation
{$EXTERNALSYM XACTENGINE_E_NOWAVEBANK}
XACTENGINE_E_SELECTVARIATION = DWord(((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or $014); // Unable to select a variation
{$EXTERNALSYM XACTENGINE_E_SELECTVARIATION}
XACTENGINE_E_MULTIPLEAUDITIONENGINES = DWord(((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or $015); // There can be only one audition engine
{$EXTERNALSYM XACTENGINE_E_MULTIPLEAUDITIONENGINES}
XACTENGINE_E_WAVEBANKNOTPREPARED = DWord(((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or $016); // The wavebank is not prepared
{$EXTERNALSYM XACTENGINE_E_WAVEBANKNOTPREPARED}
XACTENGINE_E_NORENDERER = DWord(((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or $017); // No audio device found on.
{$EXTERNALSYM XACTENGINE_E_NORENDERER}
XACTENGINE_E_INVALIDENTRYCOUNT = DWord(((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or $018); // Invalid entry count for channel maps
{$EXTERNALSYM XACTENGINE_E_INVALIDENTRYCOUNT}
XACTENGINE_E_SEEKTIMEBEYONDCUEEND = DWord(((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or $019); // Time offset for seeking is beyond the cue end.
{$EXTERNALSYM XACTENGINE_E_SEEKTIMEBEYONDCUEEND}
XACTENGINE_E_SEEKTIMEBEYONDWAVEEND = DWord(((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or $019); // Time offset for seeking is beyond the wave end.
{$EXTERNALSYM XACTENGINE_E_SEEKTIMEBEYONDWAVEEND}
XACTENGINE_E_NOFRIENDLYNAMES = DWord(((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or $01a); // Friendly names are not included in the bank.
{$EXTERNALSYM XACTENGINE_E_NOFRIENDLYNAMES}
XACTENGINE_E_AUDITION_WRITEFILE = DWord(((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or $101); // Error writing a file during auditioning
{$EXTERNALSYM XACTENGINE_E_AUDITION_WRITEFILE}
XACTENGINE_E_AUDITION_NOSOUNDBANK = DWord(((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or $102); // Missing a soundbank
{$EXTERNALSYM XACTENGINE_E_AUDITION_NOSOUNDBANK}
XACTENGINE_E_AUDITION_INVALIDRPCINDEX = DWord(((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or $103); // Missing an RPC curve
{$EXTERNALSYM XACTENGINE_E_AUDITION_INVALIDRPCINDEX}
XACTENGINE_E_AUDITION_MISSINGDATA = DWord(((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or $104); // Missing data for an audition command
{$EXTERNALSYM XACTENGINE_E_AUDITION_MISSINGDATA}
XACTENGINE_E_AUDITION_UNKNOWNCOMMAND = DWord(((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or $105); // Unknown command
{$EXTERNALSYM XACTENGINE_E_AUDITION_UNKNOWNCOMMAND}
XACTENGINE_E_AUDITION_INVALIDDSPINDEX = DWord(((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or $106); // Missing a DSP parameter
{$EXTERNALSYM XACTENGINE_E_AUDITION_INVALIDDSPINDEX}
XACTENGINE_E_AUDITION_MISSINGWAVE = DWord(((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or $107); // Wave does not exist in auditioned wavebank
{$EXTERNALSYM XACTENGINE_E_AUDITION_MISSINGWAVE}
XACTENGINE_E_AUDITION_CREATEDIRECTORYFAILED = DWord(((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or $108); // Failed to create a directory for streaming wavebank data
{$EXTERNALSYM XACTENGINE_E_AUDITION_CREATEDIRECTORYFAILED}
XACTENGINE_E_AUDITION_INVALIDSESSION = DWord(((1 shl 31) or (FACILITY_XACTENGINE shl 16)) or $109); // Invalid audition session
{$EXTERNALSYM XACTENGINE_E_AUDITION_INVALIDSESSION}
{*-========================================================================-_
| - XACT3D - |
| Copyright (c) Microsoft Corporation. All rights reserved. |
|~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~|
|VERSION: 0.1 MODEL: Unmanaged User-mode |
|CONTRACT: N / A EXCEPT: No Exceptions |
|PARENT: N / A MINREQ: Win2000, Xbox360 |
|PROJECT: XACT3D DIALECT: MS Visual C++ 7.0 |
|>------------------------------------------------------------------------<|
| DUTY: XACT 3D support |
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^
NOTES:
1. See X3DAudio.h for information regarding X3DAudio types. *}
//--------------<D-E-F-I-N-I-T-I-O-N-S>-------------------------------------//
const
// Supported speaker positions, represented as azimuth angles.
//
// Here's a picture of the azimuth angles for the 8 cardinal points,
// seen from above. The emitter's base position is at the origin 0.
//
// FRONT
// | 0 <-- azimuth
// |
// 7pi/4 \ | / pi/4
// \ | /
// LEFT \|/ RIGHT
// 3pi/2-------0-------pi/2
// /|\
// / | \
// 5pi/4 / | \ 3pi/4
// |
// | pi
// BACK
//
LEFT_AZIMUTH = (3*X3DAUDIO_PI/2);
{$EXTERNALSYM LEFT_AZIMUTH}
RIGHT_AZIMUTH = (X3DAUDIO_PI/2);
{$EXTERNALSYM RIGHT_AZIMUTH}
FRONT_LEFT_AZIMUTH = (7*X3DAUDIO_PI/4);
{$EXTERNALSYM FRONT_LEFT_AZIMUTH}
FRONT_RIGHT_AZIMUTH = (X3DAUDIO_PI/4);
{$EXTERNALSYM FRONT_RIGHT_AZIMUTH}
FRONT_CENTER_AZIMUTH = 0.0;
{$EXTERNALSYM FRONT_CENTER_AZIMUTH}
LOW_FREQUENCY_AZIMUTH = X3DAUDIO_2PI;
{$EXTERNALSYM LOW_FREQUENCY_AZIMUTH}
BACK_LEFT_AZIMUTH = (5*X3DAUDIO_PI/4);
{$EXTERNALSYM BACK_LEFT_AZIMUTH}
BACK_RIGHT_AZIMUTH = (3*X3DAUDIO_PI/4);
{$EXTERNALSYM BACK_RIGHT_AZIMUTH}
BACK_CENTER_AZIMUTH = X3DAUDIO_PI;
{$EXTERNALSYM BACK_CENTER_AZIMUTH}
FRONT_LEFT_OF_CENTER_AZIMUTH = (15*X3DAUDIO_PI/8);
{$EXTERNALSYM FRONT_LEFT_OF_CENTER_AZIMUTH}
FRONT_RIGHT_OF_CENTER_AZIMUTH = (X3DAUDIO_PI/8);
{$EXTERNALSYM FRONT_RIGHT_OF_CENTER_AZIMUTH}
//--------------<D-A-T-A---T-Y-P-E-S>---------------------------------------//
// Supported emitter channel layouts:
aStereoLayout: array[0..1] of Single =
(
LEFT_AZIMUTH,
RIGHT_AZIMUTH
);
{$EXTERNALSYM aStereoLayout}
a2Point1Layout: array[0..2] of Single =
(
LEFT_AZIMUTH,
RIGHT_AZIMUTH,
LOW_FREQUENCY_AZIMUTH
);
{$EXTERNALSYM a2Point1Layout}
aQuadLayout: array[0..3] of Single =
(
FRONT_LEFT_AZIMUTH,
FRONT_RIGHT_AZIMUTH,
BACK_LEFT_AZIMUTH,
BACK_RIGHT_AZIMUTH
);
{$EXTERNALSYM aQuadLayout}
a4Point1Layout: array[0..4] of Single =
(
FRONT_LEFT_AZIMUTH,
FRONT_RIGHT_AZIMUTH,
LOW_FREQUENCY_AZIMUTH,
BACK_LEFT_AZIMUTH,
BACK_RIGHT_AZIMUTH
);
{$EXTERNALSYM a4Point1Layout}
a5Point1Layout: array[0..5] of Single =
(
FRONT_LEFT_AZIMUTH,
FRONT_RIGHT_AZIMUTH,
FRONT_CENTER_AZIMUTH,
LOW_FREQUENCY_AZIMUTH,
BACK_LEFT_AZIMUTH,
BACK_RIGHT_AZIMUTH
);
{$EXTERNALSYM a5Point1Layout}
a7Point1Layout: array[0..7] of Single =
(
FRONT_LEFT_AZIMUTH,
FRONT_RIGHT_AZIMUTH,
FRONT_CENTER_AZIMUTH,
LOW_FREQUENCY_AZIMUTH,
BACK_LEFT_AZIMUTH,
BACK_RIGHT_AZIMUTH,
LEFT_AZIMUTH,
RIGHT_AZIMUTH
);
{$EXTERNALSYM a7Point1Layout}
const
DefaultCurvePoints: array[0..1] of TX3DAudioDistanceCurvePoint =
((Distance: 0.0; DSPSetting: 1.0), (Distance: 1.0; DSPSetting: 1.0));
DefaultCurve: TX3DAudioDistanceCurve = (pPoints: @DefaultCurvePoints; PointCount: 2);
//--------------<F-U-N-C-T-I-O-N-S>-----------------------------------------//
////
// DESCRIPTION:
// Initializes the 3D API's:
//
// REMARKS:
// This method only needs to be called once.
// X3DAudio will be initialized such that its speaker channel mask
// matches the format of the given XACT engine's final mix.
//
// PARAMETERS:
// pEngine - [in] XACT engine
// X3DInstance - [out] X3DAudio instance handle
//
// RETURN VALUE:
// HResult error code
////
function XACT3DInitialize(const pEngine: IXACTEngine; out X3DInstance: TX3DAudioHandle): HRESULT; cdecl;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}
{$EXTERNALSYM XACT3DInitialize}
////
// DESCRIPTION:
// Calculates DSP settings with respect to 3D parameters:
//
// REMARKS:
// Note the following flags are always specified for XACT3D calculation:
// X3DAUDIO_CALCULATE_MATRIX | X3DAUDIO_CALCULATE_DOPPLER | X3DAUDIO_CALCULATE_EMITTER_ANGLE
//
// This means the caller must set at least the following fields:
// X3DAUDIO_LISTENER.OrientFront
// X3DAUDIO_LISTENER.OrientTop
// X3DAUDIO_LISTENER.Position
// X3DAUDIO_LISTENER.Velocity
//
// X3DAUDIO_EMITTER.OrientFront
// X3DAUDIO_EMITTER.OrientTop, if emitter is multi-channel
// X3DAUDIO_EMITTER.Position
// X3DAUDIO_EMITTER.Velocity
// X3DAUDIO_EMITTER.ChannelCount
// X3DAUDIO_EMITTER.CurveDistanceScaler
// X3DAUDIO_EMITTER.DopplerScaler
//
// X3DAUDIO_DSP_SETTINGS.pMatrixCoefficients, the caller need only allocate space for SrcChannelCount*DstChannelCount elements
// X3DAUDIO_DSP_SETTINGS.SrcChannelCount
// X3DAUDIO_DSP_SETTINGS.DstChannelCount
//
// If X3DAUDIO_EMITTER.pChannelAzimuths is left NULL for multi-channel emitters,
// a default channel radius and channel azimuth array will be applied below.
// Distance curves such as X3DAUDIO_EMITTER.pVolumeCurve should be
// left NULL as XACT's native RPCs will be used to define DSP behaviour
// with respect to normalized distance.
//
// See X3DAudio.h for information regarding X3DAudio types.
//
// PARAMETERS:
// X3DInstance - [in] X3DAudio instance handle, returned from XACT3DInitialize()
// pListener - [in] point of 3D audio reception
// pEmitter - [in] 3D audio source
// pDSPSettings - [out] receives calculation results, applied to an XACT cue via XACT3DApply()
//
// RETURN VALUE:
// HResult error code
////
function XACT3DCalculate (const X3DInstance: TX3DAudioHandle; const pListener: TX3DAudioListener;
var pEmitter: TX3DAudioEmitter; var pDSPSettings: TX3DAudioDspSettings): HRESULT; cdecl;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}
{$EXTERNALSYM XACT3DCalculate}
////
// DESCRIPTION:
// Applies results from a call to XACT3DCalculate() to a cue.
//
// PARAMETERS:
// pDSPSettings - [in] calculation results generated by XACT3DCalculate()
// pCue - [in] cue to which to apply pDSPSettings
//
// RETURN VALUE:
// HResult error code
////
function XACT3DApply(const pDSPSettings: TX3DAudioDspSettings; const pCue: IXACTCue;
ChannelCount: LongWord): HRESULT; cdecl;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}
{$EXTERNALSYM XACT3DApply}
implementation
{.$IFDEF XBOX}
function XACTCreateEngine(dwCreationFlags: DWORD; out ppEngine: IXACTEngine): HRESULT; stdcall; // inline
var
key: HKEY;
data: DWORD;
type_: DWORD;
dataSize: DWORD;
debug: Boolean;
audition: Boolean;
guid: TGUID;
begin
type_ := REG_DWORD;
dataSize := SizeOf(DWORD);
debug := (dwCreationFlags and XACT_FLAG_API_DEBUG_MODE) <> 0;
audition := (dwCreationFlags and XACT_FLAG_API_AUDITION_MODE) <> 0;
// If neither the debug nor audition flags are set, see if the debug registry key is set
if (not debug and not audition and
(RegOpenKeyEx(HKEY_LOCAL_MACHINE, XACT_DEBUGENGINE_REGISTRY_KEY, 0, KEY_READ, key) = ERROR_SUCCESS)) then
begin
if RegQueryValueEx(key, XACT_DEBUGENGINE_REGISTRY_VALUE, nil, @type_, @data, @dataSize) = ERROR_SUCCESS
then debug := (data <> 0);
RegCloseKey(key);
end;
if audition then guid := CLSID_XACTAuditionEngine
else if debug then guid := CLSID_XACTDebugEngine
else guid := CLSID_XACTEngine;
// Priority order: Audition, Debug, Retail
Result:= CoCreateInstance(guid, nil, CLSCTX_INPROC_SERVER, IID_IXACTEngine, ppEngine);
// If debug engine does not exist fallback to retail version
if FAILED(Result) and debug and not audition then
begin
Result := CoCreateInstance(CLSID_XACTEngine, nil, CLSCTX_INPROC_SERVER, IID_IXACTEngine, ppEngine);
end;
end;
{.$ENDIF XBOX}
(***************************************************************************
* File: xact2wb.h
* Content: XACT 2 wave bank definitions.
****************************************************************************)
procedure SwapBytes(_dw_: PDWORD); overload;
asm
mov edi, _dw_
// mov edi, dw
mov eax, [edi]
bswap eax
mov [edi], eax
end;
// dw = _byteswap_ulong(dw); //todo: add inline in pure pascal case
procedure SwapBytes(w: PWORD); overload;
asm
mov edi, w
mov ax, [edi]
xchg ah, al
mov [edi], ax
end;
// w = _byteswap_ushort(w); //todo: add inline in pure pascal case
(***************************************************************************
* File: xact3d.h
* Content: XACT 3D support.
****************************************************************************)
////
// DESCRIPTION:
// Initializes the 3D API's:
//
// REMARKS:
// This method only needs to be called once
// The number of bits set in SpeakerChannelMask should equal the number of
// channels expected on the final mix.
//
// PARAMETERS:
// SpeakerChannelMask - [in] speaker geometry configuration on the final mix, specifies assignment of channels to speaker positions, defined as per WAVEFORMATEXTENSIBLE.dwChannelMask, must be != 0
// Currently only SPEAKER_STEREO and SPEAKER_5POINT1 is supported by X3DAudio.
// pEngine - [in] pointer to the XACT engine
// X3DInstance - [out] Handle to the X3DAudio instance
//
// RETURN VALUE:
// HResult error code
////
function XACT3DInitialize(const pEngine: IXACTEngine; out X3DInstance: TX3DAudioHandle): HRESULT; cdecl;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}
var
xactSpeedOfSoundID: TXACTVariableIndex;
nSpeedOfSound: TXACTVariableValue;
wfxFinalMixFormat: TWaveFormatExtensible;
begin
Result := S_OK;
if (pEngine = nil) then Result := E_POINTER;
if SUCCEEDED(Result) then
begin
xactSpeedOfSoundID := pEngine.GetGlobalVariableIndex('SpeedOfSound');
Result := pEngine.GetGlobalVariable(xactSpeedOfSoundID, nSpeedOfSound);
end;
if SUCCEEDED(Result) then
begin
Result := pEngine.GetFinalMixFormat(wfxFinalMixFormat);
if SUCCEEDED(Result)
then X3DAudioInitialize(wfxFinalMixFormat.dwChannelMask, nSpeedOfSound, X3DInstance);
end;
end;
////
// DESCRIPTION:
// Calculates DSP settings with respect to 3D parameters:
//
// PARAMETERS:
// X3DInstance - [in] X3DAudio instance (returned from XACT3DInitialize)
// pListener - [in] point of 3D audio reception
// pEmitter - [in] 3D audio source
// pDSPSettings - [out] receives calculation results, applied to an XACT cue via XACT3DApply
//
// RETURN VALUE:
// HResult error code
////
function XACT3DCalculate(const X3DInstance: TX3DAudioHandle; const pListener: TX3DAudioListener;
var pEmitter: TX3DAudioEmitter; var pDSPSettings: TX3DAudioDspSettings): HRESULT; cdecl;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}
begin
Result := S_OK;
{ if (pListener = nil) or (pEmitter = nil) or (pDSPSettings = nil)
then Result := E_POINTER; }
// if(SUCCEEDED(Result) then
if (pEmitter.ChannelCount > 1) and (pEmitter.pChannelAzimuths = nil) then
begin
pEmitter.ChannelRadius := 1.0;
case pEmitter.ChannelCount of
2: pEmitter.pChannelAzimuths := @aStereoLayout[0];
3: pEmitter.pChannelAzimuths := @a2Point1Layout[0];
4: pEmitter.pChannelAzimuths := @aQuadLayout[0];
5: pEmitter.pChannelAzimuths := @a4Point1Layout[0];
6: pEmitter.pChannelAzimuths := @a5Point1Layout[0];
8: pEmitter.pChannelAzimuths := @a7Point1Layout[0];
else
Result := E_FAIL;
end;
end;
if SUCCEEDED(Result) then
begin
if (pEmitter.pVolumeCurve = nil) then pEmitter.pVolumeCurve := @DefaultCurve;
if (pEmitter.pLFECurve = nil) then pEmitter.pLFECurve := @DefaultCurve;
X3DAudioCalculate(X3DInstance, pListener, pEmitter,
X3DAUDIO_CALCULATE_MATRIX or X3DAUDIO_CALCULATE_DOPPLER or X3DAUDIO_CALCULATE_EMITTER_ANGLE,
pDSPSettings);
end;
end;
////
// DESCRIPTION:
// Applies a 3D calculation returned by XACT3DCalculate to a cue:
//
// PARAMETERS:
// pDSPSettings - [in] calculation results generated by XACT3DCalculate
// pCue - [in] cue to which to apply pDSPSettings
// ChannelCount - [in] should be set equal to pDSPSettings->SrcChannelCount.
//
// RETURN VALUE:
// HResult error code
////
function XACT3DApply(const pDSPSettings: TX3DAudioDspSettings; const pCue: IXACTCue;
ChannelCount: LongWord): HRESULT; cdecl;{$IFDEF SUPPORTS_INLINE} inline;{$ENDIF}
var
xactDistanceID: TXACTVariableIndex;
xactDopplerID: TXACTVariableIndex;
xactOrientationID: TXACTVariableIndex;
begin
{ Result := S_OK;
if (pDSPSettings = nil) or )pCue = nil) then Result := E_POINTER;
if SUCCEEDED(Result) then }
Result := pCue.SetMatrixCoefficients(pDSPSettings.SrcChannelCount, pDSPSettings.DstChannelCount, pDSPSettings.pMatrixCoefficients);
if SUCCEEDED(Result) then
begin
xactDistanceID := pCue.GetVariableIndex('Distance');
Result := pCue.SetVariable(xactDistanceID, pDSPSettings.EmitterToListenerDistance);
end;
if SUCCEEDED(Result) then
begin
xactDopplerID := pCue.GetVariableIndex('DopplerPitchScalar');
Result := pCue.SetVariable(xactDopplerID, pDSPSettings.DopplerFactor);
end;
if SUCCEEDED(Result) then
begin
xactOrientationID := pCue.GetVariableIndex('OrientationAngle');
Result := pCue.SetVariable(xactOrientationID, pDSPSettings.EmitterToListenerAngle * (180.0 / X3DAUDIO_PI));
end;
end;
end.
Reference in New Issue Copy Permalink