Atom
xact3.h
1 /**************************************************************************
2  *
3  * Copyright (c) Microsoft Corporation. All rights reserved.
4  *
5  * Module Name:
6  *
7  * xact3.h
8  *
9  * Abstract:
10  *
11  * XACT public interfaces, functions and data types
12  *
13  **************************************************************************/
14 
15 #pragma once
16 
17 #ifndef _XACT3_H_
18 #define _XACT3_H_
19 
20 //------------------------------------------------------------------------------
21 // XACT class and interface IDs (Version 3.7)
22 //------------------------------------------------------------------------------
23 #ifndef _XBOX // XACT COM support only exists on Windows
24  #include <comdecl.h> // For DEFINE_CLSID, DEFINE_IID and DECLARE_INTERFACE
25  DEFINE_CLSID(XACTEngine, bcc782bc, 6492, 4c22, 8c, 35, f5, d7, 2f, e7, 3c, 6e);
26  DEFINE_CLSID(XACTAuditionEngine, 9ecdd80d, 0e81, 40d8, 89, 03, 2b, f7, b1, 31, ac, 43);
27  DEFINE_CLSID(XACTDebugEngine, 02860630, bf3b, 42a8, b1, 4e, 91, ed, a2, f5, 1e, a5);
28  DEFINE_IID(IXACT3Engine, b1ee676a, d9cd, 4d2a, 89, a8, fa, 53, eb, 9e, 48, 0b);
29 #endif
30 
31 // Ignore the rest of this header if only the GUID definitions were requested:
32 #ifndef GUID_DEFS_ONLY
33 
34 //------------------------------------------------------------------------------
35 // Includes
36 //------------------------------------------------------------------------------
37 
38 #ifndef _XBOX
39  #include <windows.h>
40  #include <objbase.h>
41  #include <float.h>
42 #endif
43 #include <limits.h>
44 #include <xact3wb.h>
45 #include <xaudio2.h>
46 
47 //------------------------------------------------------------------------------
48 // Forward Declarations
49 //------------------------------------------------------------------------------
50 
51 typedef struct IXACT3SoundBank IXACT3SoundBank;
52 typedef struct IXACT3WaveBank IXACT3WaveBank;
53 typedef struct IXACT3Cue IXACT3Cue;
54 typedef struct IXACT3Wave IXACT3Wave;
55 typedef struct IXACT3Engine IXACT3Engine;
56 typedef struct XACT_NOTIFICATION XACT_NOTIFICATION;
57 
58 
59 //------------------------------------------------------------------------------
60 // Typedefs
61 //------------------------------------------------------------------------------
62 
63 typedef WORD XACTINDEX; // All normal indices
64 typedef BYTE XACTNOTIFICATIONTYPE; // Notification type
65 typedef FLOAT XACTVARIABLEVALUE; // Variable value
66 typedef WORD XACTVARIABLEINDEX; // Variable index
67 typedef WORD XACTCATEGORY; // Sound category
68 typedef BYTE XACTCHANNEL; // Audio channel
69 typedef FLOAT XACTVOLUME; // Volume value
70 typedef LONG XACTTIME; // Time (in ms)
71 typedef SHORT XACTPITCH; // Pitch value
72 typedef BYTE XACTLOOPCOUNT; // For all loops / recurrences
73 typedef BYTE XACTVARIATIONWEIGHT; // Variation weight
74 typedef BYTE XACTPRIORITY; // Sound priority
75 typedef BYTE XACTINSTANCELIMIT; // Instance limitations
76 
77 //------------------------------------------------------------------------------
78 // Standard win32 multimedia definitions
79 //------------------------------------------------------------------------------
80 #ifndef WAVE_FORMAT_IEEE_FLOAT
81  #define WAVE_FORMAT_IEEE_FLOAT 0x0003
82 #endif
83 
84 #ifndef WAVE_FORMAT_EXTENSIBLE
85  #define WAVE_FORMAT_EXTENSIBLE 0xFFFE
86 #endif
87 
88 #ifndef _WAVEFORMATEX_
89 #define _WAVEFORMATEX_
90  #pragma pack(push, 1)
91  typedef struct tWAVEFORMATEX
92  {
93  WORD wFormatTag; // format type
94  WORD nChannels; // number of channels (i.e. mono, stereo...)
95  DWORD nSamplesPerSec; // sample rate
96  DWORD nAvgBytesPerSec; // for buffer estimation
97  WORD nBlockAlign; // block size of data
98  WORD wBitsPerSample; // Number of bits per sample of mono data
99  WORD cbSize; // The count in bytes of the size of extra information (after cbSize)
100 
101  } WAVEFORMATEX, *PWAVEFORMATEX;
102  typedef WAVEFORMATEX NEAR *NPWAVEFORMATEX;
103  typedef WAVEFORMATEX FAR *LPWAVEFORMATEX;
104  #pragma pack(pop)
105 #endif
106 
107 #ifndef _WAVEFORMATEXTENSIBLE_
108 #define _WAVEFORMATEXTENSIBLE_
109  #pragma pack(push, 1)
110  typedef struct
111  {
112  WAVEFORMATEX Format; // WAVEFORMATEX data
113 
114  union
115  {
116  WORD wValidBitsPerSample; // Bits of precision
117  WORD wSamplesPerBlock; // Samples per block of audio data, valid if wBitsPerSample==0
118  WORD wReserved; // Unused -- If neither applies, set to zero.
119  } Samples;
120 
121  DWORD dwChannelMask; // Speaker usage bitmask
122  GUID SubFormat; // Sub-format identifier
123  } WAVEFORMATEXTENSIBLE, *PWAVEFORMATEXTENSIBLE;
124  #pragma pack(pop)
125 #endif
126 
127 //------------------------------------------------------------------------------
128 // Constants
129 //------------------------------------------------------------------------------
130 static const XACTTIME XACTTIME_MIN = LONG_MIN;
131 static const XACTTIME XACTTIME_MAX = LONG_MAX; // 24 days 20:31:23.647
132 static const XACTTIME XACTTIME_INFINITE = LONG_MAX;
133 static const XACTINSTANCELIMIT XACTINSTANCELIMIT_INFINITE = 0xff;
134 static const XACTINSTANCELIMIT XACTINSTANCELIMIT_MIN = 0x00; // == 1 instance total (0 additional instances)
135 static const XACTINSTANCELIMIT XACTINSTANCELIMIT_MAX = 0xfe; // == 255 instances total (254 additional instances)
136 static const XACTINDEX XACTINDEX_MIN = 0x0;
137 static const XACTINDEX XACTINDEX_MAX = 0xfffe;
138 static const XACTINDEX XACTINDEX_INVALID = 0xffff;
139 static const XACTNOTIFICATIONTYPE XACTNOTIFICATIONTYPE_MIN = 0x00;
140 static const XACTNOTIFICATIONTYPE XACTNOTIFICATIONTYPE_MAX = 0xff;
141 static const XACTVARIABLEVALUE XACTVARIABLEVALUE_MIN = -FLT_MAX;
142 static const XACTVARIABLEVALUE XACTVARIABLEVALUE_MAX = FLT_MAX;
143 static const XACTVARIABLEINDEX XACTVARIABLEINDEX_MIN = 0x0000;
144 static const XACTVARIABLEINDEX XACTVARIABLEINDEX_MAX = 0xfffe;
145 static const XACTVARIABLEINDEX XACTVARIABLEINDEX_INVALID = 0xffff;
146 static const XACTCATEGORY XACTCATEGORY_MIN = 0x0;
147 static const XACTCATEGORY XACTCATEGORY_MAX = 0xfffe;
148 static const XACTCATEGORY XACTCATEGORY_INVALID = 0xffff;
149 static const XACTCHANNEL XACTCHANNEL_MIN = 0;
150 static const XACTCHANNEL XACTCHANNEL_MAX = 0xFF;
151 static const XACTPITCH XACTPITCH_MIN = -1200; // pitch change allowable per individual content field
152 static const XACTPITCH XACTPITCH_MAX = 1200;
153 static const XACTPITCH XACTPITCH_MIN_TOTAL = -2400; // total allowable pitch change, use with IXACTWave.SetPitch()
154 static const XACTPITCH XACTPITCH_MAX_TOTAL = 2400;
155 static const XACTVOLUME XACTVOLUME_MIN = 0.0f;
156 static const XACTVOLUME XACTVOLUME_MAX = 16777216.0f; // Maximum acceptable volume level (2^24) - matches XAudio2 max volume
157 static const XACTVARIABLEVALUE XACTPARAMETERVALUE_MIN = -FLT_MAX;
158 static const XACTVARIABLEVALUE XACTPARAMETERVALUE_MAX = FLT_MAX;
159 static const XACTLOOPCOUNT XACTLOOPCOUNT_MIN = 0x0;
160 static const XACTLOOPCOUNT XACTLOOPCOUNT_MAX = 0xfe;
161 static const XACTLOOPCOUNT XACTLOOPCOUNT_INFINITE = 0xff;
162 static const DWORD XACTWAVEALIGNMENT_MIN = 2048;
163 #ifdef _XBOX
164 static const BYTE XACTMAXOUTPUTVOICECOUNT = 3;
165 #endif // _XBOX
166 
167 
168 // -----------------------------------------------------------------------------
169 // Cue friendly name length
170 // -----------------------------------------------------------------------------
171 #define XACT_CUE_NAME_LENGTH 0xFF
172 
173 // -----------------------------------------------------------------------------
174 // Current Content Tool Version
175 // -----------------------------------------------------------------------------
176 #define XACT_CONTENT_VERSION 46
177 
178 // -----------------------------------------------------------------------------
179 // XACT Stop Flags
180 // -----------------------------------------------------------------------------
181 static const DWORD XACT_FLAG_STOP_RELEASE = 0x00000000; // Stop with release envelope (or as authored), for looping waves this acts as break loop.
182 static const DWORD XACT_FLAG_STOP_IMMEDIATE = 0x00000001; // Stop immediately
183 
184 // -----------------------------------------------------------------------------
185 // XACT Manage Data Flag - XACT will manage the lifetime of this data
186 // -----------------------------------------------------------------------------
187 static const DWORD XACT_FLAG_MANAGEDATA = 0x00000001;
188 
189 // -----------------------------------------------------------------------------
190 // XACT Content Preparation Flags
191 // -----------------------------------------------------------------------------
192 static const DWORD XACT_FLAG_BACKGROUND_MUSIC = 0x00000002; // Marks the waves as background music.
193 static const DWORD XACT_FLAG_UNITS_MS = 0x00000004; // Indicates that the units passed in are in milliseconds.
194 static const DWORD XACT_FLAG_UNITS_SAMPLES = 0x00000008; // Indicates that the units passed in are in samples.
195 
196 // -----------------------------------------------------------------------------
197 // XACT State flags
198 // -----------------------------------------------------------------------------
199 static const DWORD XACT_STATE_CREATED = 0x00000001; // Created, but nothing else
200 static const DWORD XACT_STATE_PREPARING = 0x00000002; // In the middle of preparing
201 static const DWORD XACT_STATE_PREPARED = 0x00000004; // Prepared, but not yet played
202 static const DWORD XACT_STATE_PLAYING = 0x00000008; // Playing (though could be paused)
203 static const DWORD XACT_STATE_STOPPING = 0x00000010; // Stopping
204 static const DWORD XACT_STATE_STOPPED = 0x00000020; // Stopped
205 static const DWORD XACT_STATE_PAUSED = 0x00000040; // Paused (Can be combined with some of the other state flags above)
206 static const DWORD XACT_STATE_INUSE = 0x00000080; // Object is in use (used by wavebanks and soundbanks).
207 static const DWORD XACT_STATE_PREPAREFAILED = 0x80000000; // Object preparation failed.
208 
209 //------------------------------------------------------------------------------
210 // XACT Parameters
211 //------------------------------------------------------------------------------
212 
213 #define XACT_FLAG_GLOBAL_SETTINGS_MANAGEDATA XACT_FLAG_MANAGEDATA
214 
215 // -----------------------------------------------------------------------------
216 // File IO Callbacks
217 // -----------------------------------------------------------------------------
218 typedef BOOL (__stdcall * XACT_READFILE_CALLBACK)(__in HANDLE hFile, __out_bcount(nNumberOfBytesToRead) LPVOID lpBuffer, DWORD nNumberOfBytesToRead, __out LPDWORD lpNumberOfBytesRead, __inout LPOVERLAPPED lpOverlapped);
219 typedef BOOL (__stdcall * XACT_GETOVERLAPPEDRESULT_CALLBACK)(__in HANDLE hFile, __inout LPOVERLAPPED lpOverlapped, __out LPDWORD lpNumberOfBytesTransferred, BOOL bWait);
220 
221 typedef struct XACT_FILEIO_CALLBACKS
222 {
223  XACT_READFILE_CALLBACK readFileCallback;
224  XACT_GETOVERLAPPEDRESULT_CALLBACK getOverlappedResultCallback;
225 
226 } XACT_FILEIO_CALLBACKS, *PXACT_FILEIO_CALLBACKS;
227 typedef const XACT_FILEIO_CALLBACKS *PCXACT_FILEIO_CALLBACKS;
228 
229 // -----------------------------------------------------------------------------
230 // Notification Callback
231 // -----------------------------------------------------------------------------
232 typedef void (__stdcall * XACT_NOTIFICATION_CALLBACK)(__in const XACT_NOTIFICATION* pNotification);
233 
234 #define XACT_RENDERER_ID_LENGTH 0xff // Maximum number of characters allowed in the renderer ID
235 #define XACT_RENDERER_NAME_LENGTH 0xff // Maximum number of characters allowed in the renderer display name.
236 
237 // -----------------------------------------------------------------------------
238 // Renderer Details
239 // -----------------------------------------------------------------------------
240 typedef struct XACT_RENDERER_DETAILS
241 {
242  WCHAR rendererID[XACT_RENDERER_ID_LENGTH]; // The string ID for the rendering device.
243  WCHAR displayName[XACT_RENDERER_NAME_LENGTH]; // A friendly name suitable for display to a human.
244  BOOL defaultDevice; // Set to TRUE if this device is the primary audio device on the system.
245 
246 } XACT_RENDERER_DETAILS, *LPXACT_RENDERER_DETAILS;
247 
248 // -----------------------------------------------------------------------------
249 // Engine Look-Ahead Time
250 // -----------------------------------------------------------------------------
251 #define XACT_ENGINE_LOOKAHEAD_DEFAULT 250 // Default look-ahead time of 250ms can be used during XACT engine initialization.
252 
253 // -----------------------------------------------------------------------------
254 // Runtime (engine) parameters
255 // -----------------------------------------------------------------------------
256 typedef struct XACT_RUNTIME_PARAMETERS
257 {
258  DWORD lookAheadTime; // Time in ms
259  void* pGlobalSettingsBuffer; // Buffer containing the global settings file
260  DWORD globalSettingsBufferSize; // Size of global settings buffer
261  DWORD globalSettingsFlags; // Flags for global settings
262  DWORD globalSettingsAllocAttributes; // Global settings buffer allocation attributes (see XMemAlloc)
263  XACT_FILEIO_CALLBACKS fileIOCallbacks; // File I/O callbacks
264  XACT_NOTIFICATION_CALLBACK fnNotificationCallback; // Callback that receives notifications.
265  PWSTR pRendererID; // Ptr to the ID for the audio renderer the engine should connect to.
266  IXAudio2* pXAudio2; // XAudio2 object to be used by the engine (NULL if one needs to be created)
267  IXAudio2MasteringVoice* pMasteringVoice; // Mastering voice to be used by the engine, if pXAudio2 is not NULL.
268 
269 } XACT_RUNTIME_PARAMETERS, *LPXACT_RUNTIME_PARAMETERS;
270 typedef const XACT_RUNTIME_PARAMETERS *LPCXACT_RUNTIME_PARAMETERS;
271 
272 //------------------------------------------------------------------------------
273 // Streaming Parameters
274 //------------------------------------------------------------------------------
275 
276 typedef struct XACT_STREAMING_PARAMETERS
277 {
278  HANDLE file; // File handle associated with wavebank data
279  DWORD offset; // Offset within file of wavebank header (must be sector aligned)
280  DWORD flags; // Flags (none currently)
281  WORD packetSize; // Stream packet size (in sectors) to use for each stream (min = 2)
282  // number of sectors (DVD = 2048 bytes: 2 = 4096, 3 = 6144, 4 = 8192 etc.)
283  // optimal DVD size is a multiple of 16 (DVD block = 16 DVD sectors)
284 
285 } XACT_WAVEBANK_STREAMING_PARAMETERS, *LPXACT_WAVEBANK_STREAMING_PARAMETERS, XACT_STREAMING_PARAMETERS, *LPXACT_STREAMING_PARAMETERS;
286 typedef const XACT_STREAMING_PARAMETERS *LPCXACT_STREAMING_PARAMETERS;
287 typedef const XACT_WAVEBANK_STREAMING_PARAMETERS *LPCXACT_WAVEBANK_STREAMING_PARAMETERS;
288 
289 // Structure used to report cue properties back to the client.
290 typedef struct XACT_CUE_PROPERTIES
291 {
292  CHAR friendlyName[XACT_CUE_NAME_LENGTH]; // Empty if the soundbank doesn't contain any friendly names
293  BOOL interactive; // TRUE if an IA cue; FALSE otherwise
294  XACTINDEX iaVariableIndex; // Only valid for IA cues; XACTINDEX_INVALID otherwise
295  XACTINDEX numVariations; // Number of variations in the cue
296  XACTINSTANCELIMIT maxInstances; // Number of maximum instances for this cue
297  XACTINSTANCELIMIT currentInstances; // Current active instances of this cue
298 
299 } XACT_CUE_PROPERTIES, *LPXACT_CUE_PROPERTIES;
300 
301 // Strucutre used to return the track properties.
302 typedef struct XACT_TRACK_PROPERTIES
303 {
304  XACTTIME duration; // Duration of the track in ms
305  XACTINDEX numVariations; // Number of wave variations in the track
306  XACTCHANNEL numChannels; // Number of channels for the active wave variation on this track
307  XACTINDEX waveVariation; // Index of the active wave variation
308  XACTLOOPCOUNT loopCount; // Current loop count on this track
309 
310 } XACT_TRACK_PROPERTIES, *LPXACT_TRACK_PROPERTIES;
311 
312 // Structure used to return the properties of a variation.
313 typedef struct XACT_VARIATION_PROPERTIES
314 {
315  XACTINDEX index; // Index of the variation in the cue's variation list
316  XACTVARIATIONWEIGHT weight; // Weight for the active variation. Valid only for complex cues
317  XACTVARIABLEVALUE iaVariableMin; // Valid only for IA cues
318  XACTVARIABLEVALUE iaVariableMax; // Valid only for IA cues
319  BOOL linger; // Valid only for IA cues
320 
321 } XACT_VARIATION_PROPERTIES, *LPXACT_VARIATION_PROPERTIES;
322 
323 // Structure used to return the properties of the sound referenced by a variation.
324 typedef struct XACT_SOUND_PROPERTIES
325 {
326  XACTCATEGORY category; // Category this sound belongs to
327  BYTE priority; // Priority of this variation
328  XACTPITCH pitch; // Current pitch set on the active variation
329  XACTVOLUME volume; // Current volume set on the active variation
330  XACTINDEX numTracks; // Number of tracks in the active variation
331  XACT_TRACK_PROPERTIES arrTrackProperties[1]; // Array of active track properties (has numTracks number of elements)
332 
333 } XACT_SOUND_PROPERTIES, *LPXACT_SOUND_PROPERTIES;
334 
335 // Structure used to return the properties of the active variation and the sound referenced.
336 typedef struct XACT_SOUND_VARIATION_PROPERTIES
337 {
338  XACT_VARIATION_PROPERTIES variationProperties;// Properties for this variation
339  XACT_SOUND_PROPERTIES soundProperties; // Proeprties for the sound referenced by this variation
340 
341 } XACT_SOUND_VARIATION_PROPERTIES, *LPXACT_SOUND_VARIATION_PROPERTIES;
342 
343 // Structure used to return the properties of an active cue instance.
344 typedef struct XACT_CUE_INSTANCE_PROPERTIES
345 {
346  DWORD allocAttributes; // Buffer allocation attributes (see XMemAlloc)
347  XACT_CUE_PROPERTIES cueProperties; // Properties of the cue that are shared by all instances.
348  XACT_SOUND_VARIATION_PROPERTIES activeVariationProperties; // Properties if the currently active variation.
349 
350 } XACT_CUE_INSTANCE_PROPERTIES, *LPXACT_CUE_INSTANCE_PROPERTIES;
351 
352 // Structure used to return the common wave properties.
353 typedef struct XACT_WAVE_PROPERTIES
354 {
355  char friendlyName[WAVEBANK_ENTRYNAME_LENGTH]; // Friendly name for the wave; empty if the wavebank doesn't contain friendly names.
356  WAVEBANKMINIWAVEFORMAT format; // Format for the wave.
357  DWORD durationInSamples; // Duration of the wave in units of one sample
358  WAVEBANKSAMPLEREGION loopRegion; // Loop region defined in samples.
359  BOOL streaming; // Set to TRUE if the wave is streaming; FALSE otherwise.
360 
361 } XACT_WAVE_PROPERTIES, *LPXACT_WAVE_PROPERTIES;
362 typedef const XACT_WAVE_PROPERTIES* LPCXACT_WAVE_PROPERTIES;
363 
364 // Structure used to return the properties specific to a wave instance.
365 typedef struct XACT_WAVE_INSTANCE_PROPERTIES
366 {
367  XACT_WAVE_PROPERTIES properties; // Static properties common to all the wave instances.
368  BOOL backgroundMusic; // Set to TRUE if the wave is tagged as background music; FALSE otherwise.
369 
370 } XACT_WAVE_INSTANCE_PROPERTIES, *LPXACT_WAVE_INSTANCE_PROPERTIES;
371 typedef const XACT_WAVE_INSTANCE_PROPERTIES* LPCXACT_WAVE_INSTANCE_PROPERTIES;
372 
373 //------------------------------------------------------------------------------
374 // Channel Mapping / Speaker Panning
375 //------------------------------------------------------------------------------
376 
377 typedef struct XACTCHANNELMAPENTRY
378 {
379  XACTCHANNEL InputChannel;
380  XACTCHANNEL OutputChannel;
381  XACTVOLUME Volume;
382 
383 } XACTCHANNELMAPENTRY, *LPXACTCHANNELMAPENTRY;
384 typedef const XACTCHANNELMAPENTRY *LPCXACTCHANNELMAPENTRY;
385 
386 typedef struct XACTCHANNELMAP
387 {
388  XACTCHANNEL EntryCount;
389  XACTCHANNELMAPENTRY* paEntries;
390 
391 } XACTCHANNELMAP, *LPXACTCHANNELMAP;
392 typedef const XACTCHANNELMAP *LPCXACTCHANNELMAP;
393 
394 typedef struct XACTCHANNELVOLUMEENTRY
395 {
396  XACTCHANNEL EntryIndex;
397  XACTVOLUME Volume;
398 
399 } XACTCHANNELVOLUMEENTRY, *LPXACTCHANNELVOLUMEENTRY;
400 typedef const XACTCHANNELVOLUMEENTRY *LPCXACTCHANNELVOLUMEENTRY;
401 
402 typedef struct XACTCHANNELVOLUME
403 {
404  XACTCHANNEL EntryCount;
405  XACTCHANNELVOLUMEENTRY* paEntries;
406 
407 } XACTCHANNELVOLUME, *LPXACTCHANNELVOLUME;
408 typedef const XACTCHANNELVOLUME *LPCXACTCHANNELVOLUME;
409 
410 //------------------------------------------------------------------------------
411 // Notifications
412 //------------------------------------------------------------------------------
413 
414 static const XACTNOTIFICATIONTYPE XACTNOTIFICATIONTYPE_CUEPREPARED = 1; // None, SoundBank, SoundBank & cue index, cue instance
415 static const XACTNOTIFICATIONTYPE XACTNOTIFICATIONTYPE_CUEPLAY = 2; // None, SoundBank, SoundBank & cue index, cue instance
416 static const XACTNOTIFICATIONTYPE XACTNOTIFICATIONTYPE_CUESTOP = 3; // None, SoundBank, SoundBank & cue index, cue instance
417 static const XACTNOTIFICATIONTYPE XACTNOTIFICATIONTYPE_CUEDESTROYED = 4; // None, SoundBank, SoundBank & cue index, cue instance
418 static const XACTNOTIFICATIONTYPE XACTNOTIFICATIONTYPE_MARKER = 5; // None, SoundBank, SoundBank & cue index, cue instance
419 static const XACTNOTIFICATIONTYPE XACTNOTIFICATIONTYPE_SOUNDBANKDESTROYED = 6; // None, SoundBank
420 static const XACTNOTIFICATIONTYPE XACTNOTIFICATIONTYPE_WAVEBANKDESTROYED = 7; // None, WaveBank
421 static const XACTNOTIFICATIONTYPE XACTNOTIFICATIONTYPE_LOCALVARIABLECHANGED = 8; // None, SoundBank, SoundBank & cue index, cue instance
422 static const XACTNOTIFICATIONTYPE XACTNOTIFICATIONTYPE_GLOBALVARIABLECHANGED = 9; // None
423 static const XACTNOTIFICATIONTYPE XACTNOTIFICATIONTYPE_GUICONNECTED = 10; // None
424 static const XACTNOTIFICATIONTYPE XACTNOTIFICATIONTYPE_GUIDISCONNECTED = 11; // None
425 static const XACTNOTIFICATIONTYPE XACTNOTIFICATIONTYPE_WAVEPREPARED = 12; // None, WaveBank & wave index, wave instance.
426 static const XACTNOTIFICATIONTYPE XACTNOTIFICATIONTYPE_WAVEPLAY = 13; // None, SoundBank, SoundBank & cue index, cue instance, WaveBank, wave instance
427 static const XACTNOTIFICATIONTYPE XACTNOTIFICATIONTYPE_WAVESTOP = 14; // None, SoundBank, SoundBank & cue index, cue instance, WaveBank, wave instance
428 static const XACTNOTIFICATIONTYPE XACTNOTIFICATIONTYPE_WAVELOOPED = 15; // None, SoundBank, SoundBank & cue index, cue instance, WaveBank, wave instance
429 static const XACTNOTIFICATIONTYPE XACTNOTIFICATIONTYPE_WAVEDESTROYED = 16; // None, WaveBank & wave index, wave instance.
430 static const XACTNOTIFICATIONTYPE XACTNOTIFICATIONTYPE_WAVEBANKPREPARED = 17; // None, WaveBank
431 static const XACTNOTIFICATIONTYPE XACTNOTIFICATIONTYPE_WAVEBANKSTREAMING_INVALIDCONTENT = 18; // None, WaveBank
432 
433 static const BYTE XACT_FLAG_NOTIFICATION_PERSIST = 0x01;
434 
435 // Pack the notification structures
436 #pragma pack(push, 1)
437 
438 // Notification description used for registering, un-registering and flushing notifications
439 typedef struct XACT_NOTIFICATION_DESCRIPTION
440 {
441  XACTNOTIFICATIONTYPE type; // Notification type
442  BYTE flags; // Flags
443  IXACT3SoundBank* pSoundBank; // SoundBank instance
444  IXACT3WaveBank* pWaveBank; // WaveBank instance
445  IXACT3Cue* pCue; // Cue instance
446  IXACT3Wave* pWave; // Wave instance
447  XACTINDEX cueIndex; // Cue index
448  XACTINDEX waveIndex; // Wave index
449  PVOID pvContext; // User context (optional)
450 
451 } XACT_NOTIFICATION_DESCRIPTION, *LPXACT_NOTIFICATION_DESCRIPTION;
452 typedef const XACT_NOTIFICATION_DESCRIPTION *LPCXACT_NOTIFICATION_DESCRIPTION;
453 
454 // Notification structure for all XACTNOTIFICATIONTYPE_CUE* notifications
455 typedef struct XACT_NOTIFICATION_CUE
456 {
457  XACTINDEX cueIndex; // Cue index
458  IXACT3SoundBank* pSoundBank; // SoundBank instance
459  IXACT3Cue* pCue; // Cue instance
460 
461 } XACT_NOTIFICATION_CUE, *LPXACT_NOTIFICATION_CUE;
462 typedef const XACT_NOTIFICATION_CUE *LPCXACT_NOTIFICATION_CUE;
463 
464 // Notification structure for all XACTNOTIFICATIONTYPE_MARKER* notifications
465 typedef struct XACT_NOTIFICATION_MARKER
466 {
467  XACTINDEX cueIndex; // Cue index
468  IXACT3SoundBank* pSoundBank; // SoundBank instance
469  IXACT3Cue* pCue; // Cue instance
470  DWORD marker; // Marker value
471 
472 } XACT_NOTIFICATION_MARKER, *LPXACT_NOTIFICATION_MARKER;
473 typedef const XACT_NOTIFICATION_MARKER *LPCXACT_NOTIFICATION_MARKER;
474 
475 // Notification structure for all XACTNOTIFICATIONTYPE_SOUNDBANK* notifications
476 typedef struct XACT_NOTIFICATION_SOUNDBANK
477 {
478  IXACT3SoundBank* pSoundBank; // SoundBank instance
479 
480 } XACT_NOTIFICATION_SOUNDBANK, *LPXACT_NOTIFICATION_SOUNDBANK;
481 typedef const XACT_NOTIFICATION_SOUNDBANK *LPCXACT_NOTIFICATION_SOUNDBANK;
482 
483 // Notification structure for all XACTNOTIFICATIONTYPE_WAVEBANK* notifications
484 typedef struct XACT_NOTIFICATION_WAVEBANK
485 {
486  IXACT3WaveBank* pWaveBank; // WaveBank instance
487 
488 } XACT_NOTIFICATION_WAVEBANK, *LPXACT_NOTIFICATION_WAVEBANK;
489 typedef const XACT_NOTIFICATION_WAVEBANK *LPCXACT_NOTIFICATION_WAVEBANK;
490 
491 // Notification structure for all XACTNOTIFICATIONTYPE_*VARIABLE* notifications
492 typedef struct XACT_NOTIFICATION_VARIABLE
493 {
494  XACTINDEX cueIndex; // Cue index
495  IXACT3SoundBank* pSoundBank; // SoundBank instance
496  IXACT3Cue* pCue; // Cue instance
497  XACTVARIABLEINDEX variableIndex; // Variable index
498  XACTVARIABLEVALUE variableValue; // Variable value
499  BOOL local; // TRUE if a local variable
500 
501 } XACT_NOTIFICATION_VARIABLE, *LPXACT_NOTIFICATION_VARIABLE;
502 typedef const XACT_NOTIFICATION_VARIABLE *LPCXACT_NOTIFICATION_VARIABLE;
503 
504 // Notification structure for all XACTNOTIFICATIONTYPE_GUI* notifications
505 typedef struct XACT_NOTIFICATION_GUI
506 {
507  DWORD reserved; // Reserved
508 } XACT_NOTIFICATION_GUI, *LPXACT_NOTIFICATION_GUI;
509 typedef const XACT_NOTIFICATION_GUI *LPCXACT_NOTIFICATION_GUI;
510 
511 // Notification structure for all XACTNOTIFICATIONTYPE_WAVE* notifications
512 typedef struct XACT_NOTIFICATION_WAVE
513 {
514  IXACT3WaveBank* pWaveBank; // WaveBank
515  XACTINDEX waveIndex; // Wave index
516  XACTINDEX cueIndex; // Cue index
517  IXACT3SoundBank* pSoundBank; // SoundBank instance
518  IXACT3Cue* pCue; // Cue instance
519  IXACT3Wave* pWave; // Wave instance
520 
521 } XACT_NOTIFICATION_WAVE, *LPXACT_NOTIFICATION_WAVE;
522 typedef const XACT_NOTIFICATION_WAVE *LPCXACT_NOTIFICATION_WAVE;
523 
524 // General notification structure
525 typedef struct XACT_NOTIFICATION
526 {
527  XACTNOTIFICATIONTYPE type; // Notification type
528  LONG timeStamp; // Timestamp of notification (milliseconds)
529  PVOID pvContext; // User context (optional)
530  union
531  {
532  XACT_NOTIFICATION_CUE cue; // XACTNOTIFICATIONTYPE_CUE*
533  XACT_NOTIFICATION_MARKER marker; // XACTNOTIFICATIONTYPE_MARKER*
534  XACT_NOTIFICATION_SOUNDBANK soundBank; // XACTNOTIFICATIONTYPE_SOUNDBANK*
535  XACT_NOTIFICATION_WAVEBANK waveBank; // XACTNOTIFICATIONTYPE_WAVEBANK*
536  XACT_NOTIFICATION_VARIABLE variable; // XACTNOTIFICATIONTYPE_VARIABLE*
537  XACT_NOTIFICATION_GUI gui; // XACTNOTIFICATIONTYPE_GUI*
538  XACT_NOTIFICATION_WAVE wave; // XACTNOTIFICATIONTYPE_WAVE*
539  };
540 
541 } XACT_NOTIFICATION, *LPXACT_NOTIFICATION;
542 typedef const XACT_NOTIFICATION *LPCXACT_NOTIFICATION;
543 
544 #pragma pack(pop)
545 
546 //------------------------------------------------------------------------------
547 // IXACT3SoundBank
548 //------------------------------------------------------------------------------
549 
550 #define XACT_FLAG_SOUNDBANK_STOP_IMMEDIATE XACT_FLAG_STOP_IMMEDIATE
551 #define XACT_SOUNDBANKSTATE_INUSE XACT_STATE_INUSE
552 
553 STDAPI_(XACTINDEX) IXACT3SoundBank_GetCueIndex(__in IXACT3SoundBank* pSoundBank, __in PCSTR szFriendlyName);
554 STDAPI IXACT3SoundBank_GetNumCues(__in IXACT3SoundBank* pSoundBank, __out XACTINDEX* pnNumCues);
555 STDAPI IXACT3SoundBank_GetCueProperties(__in IXACT3SoundBank* pSoundBank, XACTINDEX nCueIndex, __out LPXACT_CUE_PROPERTIES pProperties);
556 STDAPI IXACT3SoundBank_Prepare(__in IXACT3SoundBank* pSoundBank, XACTINDEX nCueIndex, DWORD dwFlags, XACTTIME timeOffset, __deref_out IXACT3Cue** ppCue);
557 STDAPI IXACT3SoundBank_Play(__in IXACT3SoundBank* pSoundBank, XACTINDEX nCueIndex, DWORD dwFlags, XACTTIME timeOffset, __deref_opt_out IXACT3Cue** ppCue);
558 STDAPI IXACT3SoundBank_Stop(__in IXACT3SoundBank* pSoundBank, XACTINDEX nCueIndex, DWORD dwFlags);
559 STDAPI IXACT3SoundBank_Destroy(__in IXACT3SoundBank* pSoundBank);
560 STDAPI IXACT3SoundBank_GetState(__in IXACT3SoundBank* pSoundBank, __out DWORD* pdwState);
561 
562 #undef INTERFACE
563 #define INTERFACE IXACT3SoundBank
564 
565 DECLARE_INTERFACE(IXACT3SoundBank)
566 {
567  STDMETHOD_(XACTINDEX, GetCueIndex)(THIS_ __in PCSTR szFriendlyName) PURE;
568  STDMETHOD(GetNumCues)(THIS_ __out XACTINDEX* pnNumCues) PURE;
569  STDMETHOD(GetCueProperties)(THIS_ XACTINDEX nCueIndex, __out LPXACT_CUE_PROPERTIES pProperties) PURE;
570  STDMETHOD(Prepare)(THIS_ XACTINDEX nCueIndex, DWORD dwFlags, XACTTIME timeOffset, __deref_out IXACT3Cue** ppCue) PURE;
571  STDMETHOD(Play)(THIS_ XACTINDEX nCueIndex, DWORD dwFlags, XACTTIME timeOffset, __deref_opt_out IXACT3Cue** ppCue) PURE;
572  STDMETHOD(Stop)(THIS_ XACTINDEX nCueIndex, DWORD dwFlags) PURE;
573  STDMETHOD(Destroy)(THIS) PURE;
574  STDMETHOD(GetState)(THIS_ __out DWORD* pdwState) PURE;
575 };
576 
577 #ifdef __cplusplus
578 
579 __inline HRESULT __stdcall IXACT3SoundBank_Destroy(__in IXACT3SoundBank* pSoundBank)
580 {
581  return pSoundBank->Destroy();
582 }
583 
584 __inline XACTINDEX __stdcall IXACT3SoundBank_GetCueIndex(__in IXACT3SoundBank* pSoundBank, __in PCSTR szFriendlyName)
585 {
586  return pSoundBank->GetCueIndex(szFriendlyName);
587 }
588 
589 __inline HRESULT __stdcall IXACT3SoundBank_GetNumCues(__in IXACT3SoundBank* pSoundBank, __out XACTINDEX* pnNumCues)
590 {
591  return pSoundBank->GetNumCues(pnNumCues);
592 }
593 
594 __inline HRESULT __stdcall IXACT3SoundBank_GetCueProperties(__in IXACT3SoundBank* pSoundBank, XACTINDEX nCueIndex, __out LPXACT_CUE_PROPERTIES pProperties)
595 {
596  return pSoundBank->GetCueProperties(nCueIndex, pProperties);
597 }
598 
599 __inline HRESULT __stdcall IXACT3SoundBank_Prepare(__in IXACT3SoundBank* pSoundBank, XACTINDEX nCueIndex, DWORD dwFlags, XACTTIME timeOffset, __deref_out IXACT3Cue** ppCue)
600 {
601  return pSoundBank->Prepare(nCueIndex, dwFlags, timeOffset, ppCue);
602 }
603 
604 __inline HRESULT __stdcall IXACT3SoundBank_Play(__in IXACT3SoundBank* pSoundBank, XACTINDEX nCueIndex, DWORD dwFlags, XACTTIME timeOffset, __deref_opt_out IXACT3Cue** ppCue)
605 {
606  return pSoundBank->Play(nCueIndex, dwFlags, timeOffset, ppCue);
607 }
608 
609 __inline HRESULT __stdcall IXACT3SoundBank_Stop(__in IXACT3SoundBank* pSoundBank, XACTINDEX nCueIndex, DWORD dwFlags)
610 {
611  return pSoundBank->Stop(nCueIndex, dwFlags);
612 }
613 
614 __inline HRESULT __stdcall IXACT3SoundBank_GetState(__in IXACT3SoundBank* pSoundBank, __out DWORD* pdwState)
615 {
616  return pSoundBank->GetState(pdwState);
617 }
618 
619 #else // __cplusplus
620 
621 __inline HRESULT __stdcall IXACT3SoundBank_Destroy(__in IXACT3SoundBank* pSoundBank)
622 {
623  return pSoundBank->lpVtbl->Destroy(pSoundBank);
624 }
625 
626 __inline XACTINDEX __stdcall IXACT3SoundBank_GetCueIndex(__in IXACT3SoundBank* pSoundBank, __in PCSTR szFriendlyName)
627 {
628  return pSoundBank->lpVtbl->GetCueIndex(pSoundBank, szFriendlyName);
629 }
630 
631 __inline HRESULT __stdcall IXACT3SoundBank_GetNumCues(__in IXACT3SoundBank* pSoundBank, __out XACTINDEX* pnNumCues)
632 {
633  return pSoundBank->lpVtbl->GetNumCues(pSoundBank, pnNumCues);
634 }
635 
636 __inline HRESULT __stdcall IXACT3SoundBank_GetCueProperties(__in IXACT3SoundBank* pSoundBank, XACTINDEX nCueIndex, __out LPXACT_CUE_PROPERTIES pProperties)
637 {
638  return pSoundBank->lpVtbl->GetCueProperties(pSoundBank, nCueIndex, pProperties);
639 }
640 
641 __inline HRESULT __stdcall IXACT3SoundBank_Prepare(__in IXACT3SoundBank* pSoundBank, XACTINDEX nCueIndex, DWORD dwFlags, XACTTIME timeOffset, __deref_out IXACT3Cue** ppCue)
642 {
643  return pSoundBank->lpVtbl->Prepare(pSoundBank, nCueIndex, dwFlags, timeOffset, ppCue);
644 }
645 
646 __inline HRESULT __stdcall IXACT3SoundBank_Play(__in IXACT3SoundBank* pSoundBank, XACTINDEX nCueIndex, DWORD dwFlags, XACTTIME timeOffset, __deref_opt_out IXACT3Cue** ppCue)
647 {
648  return pSoundBank->lpVtbl->Play(pSoundBank, nCueIndex, dwFlags, timeOffset, ppCue);
649 }
650 
651 __inline HRESULT __stdcall IXACT3SoundBank_Stop(__in IXACT3SoundBank* pSoundBank, XACTINDEX nCueIndex, DWORD dwFlags)
652 {
653  return pSoundBank->lpVtbl->Stop(pSoundBank, nCueIndex, dwFlags);
654 }
655 
656 __inline HRESULT __stdcall IXACT3SoundBank_GetState(__in IXACT3SoundBank* pSoundBank, __out DWORD* pdwState)
657 {
658  return pSoundBank->lpVtbl->GetState(pSoundBank, pdwState);
659 }
660 
661 #endif // __cplusplus
662 
663 //------------------------------------------------------------------------------
664 // IXACT3WaveBank
665 //------------------------------------------------------------------------------
666 #define XACT_WAVEBANKSTATE_INUSE XACT_STATE_INUSE // Currently in-use
667 #define XACT_WAVEBANKSTATE_PREPARED XACT_STATE_PREPARED // Prepared
668 #define XACT_WAVEBANKSTATE_PREPAREFAILED XACT_STATE_PREPAREFAILED // Prepare failed.
669 
670 
671 STDAPI IXACT3WaveBank_Destroy(__in IXACT3WaveBank* pWaveBank);
672 STDAPI IXACT3WaveBank_GetState(__in IXACT3WaveBank* pWaveBank, __out DWORD* pdwState);
673 STDAPI IXACT3WaveBank_GetNumWaves(__in IXACT3WaveBank* pWaveBank, __out XACTINDEX* pnNumWaves);
674 STDAPI_(XACTINDEX) IXACT3WaveBank_GetWaveIndex(__in IXACT3WaveBank* pWaveBank, __in PCSTR szFriendlyName);
675 STDAPI IXACT3WaveBank_GetWaveProperties(__in IXACT3WaveBank* pWaveBank, XACTINDEX nWaveIndex, __out LPXACT_WAVE_PROPERTIES pWaveProperties);
676 STDAPI IXACT3WaveBank_Prepare(__in IXACT3WaveBank* pWaveBank, XACTINDEX nWaveIndex, DWORD dwFlags, DWORD dwPlayOffset, XACTLOOPCOUNT nLoopCount, __deref_out IXACT3Wave** ppWave);
677 STDAPI IXACT3WaveBank_Play(__in IXACT3WaveBank* pWaveBank, XACTINDEX nWaveIndex, DWORD dwFlags, DWORD dwPlayOffset, XACTLOOPCOUNT nLoopCount, __deref_out IXACT3Wave** ppWave);
678 STDAPI IXACT3WaveBank_Stop(__in IXACT3WaveBank* pWaveBank, XACTINDEX nWaveIndex, DWORD dwFlags);
679 
680 #undef INTERFACE
681 #define INTERFACE IXACT3WaveBank
682 
683 DECLARE_INTERFACE(IXACT3WaveBank)
684 {
685  STDMETHOD(Destroy)(THIS) PURE;
686  STDMETHOD(GetNumWaves)(THIS_ __out XACTINDEX* pnNumWaves) PURE;
687  STDMETHOD_(XACTINDEX, GetWaveIndex)(THIS_ __in PCSTR szFriendlyName) PURE;
688  STDMETHOD(GetWaveProperties)(THIS_ XACTINDEX nWaveIndex, __out LPXACT_WAVE_PROPERTIES pWaveProperties) PURE;
689  STDMETHOD(Prepare)(THIS_ XACTINDEX nWaveIndex, DWORD dwFlags, DWORD dwPlayOffset, XACTLOOPCOUNT nLoopCount, __deref_out IXACT3Wave** ppWave) PURE;
690  STDMETHOD(Play)(THIS_ XACTINDEX nWaveIndex, DWORD dwFlags, DWORD dwPlayOffset, XACTLOOPCOUNT nLoopCount, __deref_out IXACT3Wave** ppWave) PURE;
691  STDMETHOD(Stop)(THIS_ XACTINDEX nWaveIndex, DWORD dwFlags) PURE;
692  STDMETHOD(GetState)(THIS_ __out DWORD* pdwState) PURE;
693 };
694 
695 #ifdef __cplusplus
696 
697 __inline HRESULT __stdcall IXACT3WaveBank_Destroy(__in IXACT3WaveBank* pWaveBank)
698 {
699  return pWaveBank->Destroy();
700 }
701 
702 __inline HRESULT __stdcall IXACT3WaveBank_GetNumWaves(__in IXACT3WaveBank* pWaveBank, __out XACTINDEX* pnNumWaves)
703 {
704  return pWaveBank->GetNumWaves(pnNumWaves);
705 }
706 
707 __inline XACTINDEX __stdcall IXACT3WaveBank_GetWaveIndex(__in IXACT3WaveBank* pWaveBank, __in PCSTR szFriendlyName)
708 {
709  return pWaveBank->GetWaveIndex(szFriendlyName);
710 }
711 
712 __inline HRESULT __stdcall IXACT3WaveBank_GetWaveProperties(__in IXACT3WaveBank* pWaveBank, XACTINDEX nWaveIndex, __out LPXACT_WAVE_PROPERTIES pWaveProperties)
713 {
714  return pWaveBank->GetWaveProperties(nWaveIndex, pWaveProperties);
715 }
716 
717 __inline HRESULT __stdcall IXACT3WaveBank_Prepare(__in IXACT3WaveBank* pWaveBank, XACTINDEX nWaveIndex, DWORD dwFlags, DWORD dwPlayOffset, XACTLOOPCOUNT nLoopCount, __deref_out IXACT3Wave** ppWave)
718 {
719  return pWaveBank->Prepare(nWaveIndex, dwFlags, dwPlayOffset, nLoopCount, ppWave);
720 }
721 
722 __inline HRESULT __stdcall IXACT3WaveBank_Play(__in IXACT3WaveBank* pWaveBank, XACTINDEX nWaveIndex, DWORD dwFlags, DWORD dwPlayOffset, XACTLOOPCOUNT nLoopCount, __deref_out IXACT3Wave** ppWave)
723 {
724  return pWaveBank->Play(nWaveIndex, dwFlags, dwPlayOffset, nLoopCount, ppWave);
725 }
726 
727 __inline HRESULT __stdcall IXACT3WaveBank_Stop(__in IXACT3WaveBank* pWaveBank, XACTINDEX nWaveIndex, DWORD dwFlags)
728 {
729  return pWaveBank->Stop(nWaveIndex, dwFlags);
730 }
731 
732 __inline HRESULT __stdcall IXACT3WaveBank_GetState(__in IXACT3WaveBank* pWaveBank, __out DWORD* pdwState)
733 {
734  return pWaveBank->GetState(pdwState);
735 }
736 
737 #else // __cplusplus
738 
739 __inline HRESULT __stdcall IXACT3WaveBank_Destroy(__in IXACT3WaveBank* pWaveBank)
740 {
741  return pWaveBank->lpVtbl->Destroy(pWaveBank);
742 }
743 
744 __inline HRESULT __stdcall IXACT3WaveBank_GetNumWaves(__in IXACT3WaveBank* pWaveBank, __out XACTINDEX* pnNumWaves)
745 {
746  return pWaveBank->lpVtbl->GetNumWaves(pWaveBank, pnNumWaves);
747 }
748 
749 __inline XACTINDEX __stdcall IXACT3WaveBank_GetWaveIndex(__in IXACT3WaveBank* pWaveBank, __in PCSTR szFriendlyName)
750 {
751  return pWaveBank->lpVtbl->GetWaveIndex(pWaveBank, szFriendlyName);
752 }
753 
754 __inline HRESULT __stdcall IXACT3WaveBank_GetWaveProperties(__in IXACT3WaveBank* pWaveBank, XACTINDEX nWaveIndex, __out LPXACT_WAVE_PROPERTIES pWaveProperties)
755 {
756  return pWaveBank->lpVtbl->GetWaveProperties(pWaveBank, nWaveIndex, pWaveProperties);
757 }
758 
759 __inline HRESULT __stdcall IXACT3WaveBank_Prepare(__in IXACT3WaveBank* pWaveBank, XACTINDEX nWaveIndex, DWORD dwFlags, DWORD dwPlayOffset, XACTLOOPCOUNT nLoopCount, __deref_out IXACT3Wave** ppWave)
760 {
761  return pWaveBank->lpVtbl->Prepare(pWaveBank, nWaveIndex, dwFlags, dwPlayOffset, nLoopCount, ppWave);
762 }
763 
764 __inline HRESULT __stdcall IXACT3WaveBank_Play(__in IXACT3WaveBank* pWaveBank, XACTINDEX nWaveIndex, DWORD dwFlags, DWORD dwPlayOffset, XACTLOOPCOUNT nLoopCount, __deref_out IXACT3Wave** ppWave)
765 {
766  return pWaveBank->lpVtbl->Play(pWaveBank, nWaveIndex, dwFlags, dwPlayOffset, nLoopCount, ppWave);
767 }
768 
769 __inline HRESULT __stdcall IXACT3WaveBank_Stop(__in IXACT3WaveBank* pWaveBank, XACTINDEX nWaveIndex, DWORD dwFlags)
770 {
771  return pWaveBank->lpVtbl->Stop(pWaveBank, nWaveIndex, dwFlags);
772 }
773 
774 __inline HRESULT __stdcall IXACT3WaveBank_GetState(__in IXACT3WaveBank* pWaveBank, __out DWORD* pdwState)
775 {
776  return pWaveBank->lpVtbl->GetState(pWaveBank, pdwState);
777 }
778 #endif // __cplusplus
779 
780 
781 //------------------------------------------------------------------------------
782 // IXACT3Wave
783 //------------------------------------------------------------------------------
784 
785 STDAPI IXACT3Wave_Destroy(__in IXACT3Wave* pWave);
786 STDAPI IXACT3Wave_Play(__in IXACT3Wave* pWave);
787 STDAPI IXACT3Wave_Stop(__in IXACT3Wave* pWave, DWORD dwFlags);
788 STDAPI IXACT3Wave_Pause(__in IXACT3Wave* pWave, BOOL fPause);
789 STDAPI IXACT3Wave_GetState(__in IXACT3Wave* pWave, __out DWORD* pdwState);
790 STDAPI IXACT3Wave_SetPitch(__in IXACT3Wave* pWave, XACTPITCH pitch);
791 STDAPI IXACT3Wave_SetVolume(__in IXACT3Wave* pWave, XACTVOLUME volume);
792 STDAPI IXACT3Wave_SetMatrixCoefficients(__in IXACT3Wave* pWave, UINT32 uSrcChannelCount, UINT32 uDstChannelCount, __in float* pMatrixCoefficients);
793 STDAPI IXACT3Wave_GetProperties(__in IXACT3Wave* pWave, __out LPXACT_WAVE_INSTANCE_PROPERTIES pProperties);
794 
795 #undef INTERFACE
796 #define INTERFACE IXACT3Wave
797 
798 DECLARE_INTERFACE(IXACT3Wave)
799 {
800  STDMETHOD(Destroy)(THIS) PURE;
801  STDMETHOD(Play)(THIS) PURE;
802  STDMETHOD(Stop)(THIS_ DWORD dwFlags) PURE;
803  STDMETHOD(Pause)(THIS_ BOOL fPause) PURE;
804  STDMETHOD(GetState)(THIS_ __out DWORD* pdwState) PURE;
805  STDMETHOD(SetPitch)(THIS_ XACTPITCH pitch) PURE;
806  STDMETHOD(SetVolume)(THIS_ XACTVOLUME volume) PURE;
807  STDMETHOD(SetMatrixCoefficients)(THIS_ UINT32 uSrcChannelCount, UINT32 uDstChannelCount, __in float* pMatrixCoefficients) PURE;
808  STDMETHOD(GetProperties)(THIS_ __out LPXACT_WAVE_INSTANCE_PROPERTIES pProperties) PURE;
809 };
810 
811 #ifdef __cplusplus
812 
813 __inline HRESULT __stdcall IXACT3Wave_Destroy(__in IXACT3Wave* pWave)
814 {
815  return pWave->Destroy();
816 }
817 
818 __inline HRESULT __stdcall IXACT3Wave_Play(__in IXACT3Wave* pWave)
819 {
820  return pWave->Play();
821 }
822 
823 __inline HRESULT __stdcall IXACT3Wave_Stop(__in IXACT3Wave* pWave, DWORD dwFlags)
824 {
825  return pWave->Stop(dwFlags);
826 }
827 
828 __inline HRESULT __stdcall IXACT3Wave_Pause(__in IXACT3Wave* pWave, BOOL fPause)
829 {
830  return pWave->Pause(fPause);
831 }
832 
833 __inline HRESULT __stdcall IXACT3Wave_GetState(__in IXACT3Wave* pWave, __out DWORD* pdwState)
834 {
835  return pWave->GetState(pdwState);
836 }
837 
838 __inline HRESULT __stdcall IXACT3Wave_SetPitch(__in IXACT3Wave* pWave, XACTPITCH pitch)
839 {
840  return pWave->SetPitch(pitch);
841 }
842 
843 __inline HRESULT __stdcall IXACT3Wave_SetVolume(__in IXACT3Wave* pWave, XACTVOLUME volume)
844 {
845  return pWave->SetVolume(volume);
846 }
847 
848 __inline HRESULT __stdcall IXACT3Wave_SetMatrixCoefficients(__in IXACT3Wave* pWave, UINT32 uSrcChannelCount, UINT32 uDstChannelCount, __in float* pMatrixCoefficients)
849 {
850  return pWave->SetMatrixCoefficients(uSrcChannelCount, uDstChannelCount, pMatrixCoefficients);
851 }
852 
853 __inline HRESULT __stdcall IXACT3Wave_GetProperties(__in IXACT3Wave* pWave, __out LPXACT_WAVE_INSTANCE_PROPERTIES pProperties)
854 {
855  return pWave->GetProperties(pProperties);
856 }
857 
858 #else // __cplusplus
859 
860 __inline HRESULT __stdcall IXACT3Wave_Destroy(__in IXACT3Wave* pWave)
861 {
862  return pWave->lpVtbl->Destroy(pWave);
863 }
864 
865 __inline HRESULT __stdcall IXACT3Wave_Play(__in IXACT3Wave* pWave)
866 {
867  return pWave->lpVtbl->Play(pWave);
868 }
869 
870 __inline HRESULT __stdcall IXACT3Wave_Stop(__in IXACT3Wave* pWave, DWORD dwFlags)
871 {
872  return pWave->lpVtbl->Stop(pWave, dwFlags);
873 }
874 
875 __inline HRESULT __stdcall IXACT3Wave_Pause(__in IXACT3Wave* pWave, BOOL fPause)
876 {
877  return pWave->lpVtbl->Pause(pWave, fPause);
878 }
879 
880 __inline HRESULT __stdcall IXACT3Wave_GetState(__in IXACT3Wave* pWave, __out DWORD* pdwState)
881 {
882  return pWave->lpVtbl->GetState(pWave, pdwState);
883 }
884 
885 __inline HRESULT __stdcall IXACT3Wave_SetPitch(__in IXACT3Wave* pWave, XACTPITCH pitch)
886 {
887  return pWave->lpVtbl->SetPitch(pWave, pitch);
888 }
889 
890 __inline HRESULT __stdcall IXACT3Wave_SetVolume(__in IXACT3Wave* pWave, XACTVOLUME volume)
891 {
892  return pWave->lpVtbl->SetVolume(pWave, volume);
893 }
894 
895 __inline HRESULT __stdcall IXACT3Wave_SetMatrixCoefficients(__in IXACT3Wave* pWave, UINT32 uSrcChannelCount, UINT32 uDstChannelCount, __in float* pMatrixCoefficients)
896 {
897  return pWave->lpVtbl->SetMatrixCoefficients(pWave, uSrcChannelCount, uDstChannelCount, pMatrixCoefficients);
898 }
899 
900 __inline HRESULT __stdcall IXACT3Wave_GetProperties(__in IXACT3Wave* pWave, __out LPXACT_WAVE_INSTANCE_PROPERTIES pProperties)
901 {
902  return pWave->lpVtbl->GetProperties(pWave, pProperties);
903 }
904 #endif // __cplusplus
905 
906 //------------------------------------------------------------------------------
907 // IXACT3Cue
908 //------------------------------------------------------------------------------
909 
910 // Cue Flags
911 #define XACT_FLAG_CUE_STOP_RELEASE XACT_FLAG_STOP_RELEASE
912 #define XACT_FLAG_CUE_STOP_IMMEDIATE XACT_FLAG_STOP_IMMEDIATE
913 
914 // Mutually exclusive states
915 #define XACT_CUESTATE_CREATED XACT_STATE_CREATED // Created, but nothing else
916 #define XACT_CUESTATE_PREPARING XACT_STATE_PREPARING // In the middle of preparing
917 #define XACT_CUESTATE_PREPARED XACT_STATE_PREPARED // Prepared, but not yet played
918 #define XACT_CUESTATE_PLAYING XACT_STATE_PLAYING // Playing (though could be paused)
919 #define XACT_CUESTATE_STOPPING XACT_STATE_STOPPING // Stopping
920 #define XACT_CUESTATE_STOPPED XACT_STATE_STOPPED // Stopped
921 #define XACT_CUESTATE_PAUSED XACT_STATE_PAUSED // Paused (can be combined with other states)
922 
923 STDAPI IXACT3Cue_Destroy(__in IXACT3Cue* pCue);
924 STDAPI IXACT3Cue_Play(__in IXACT3Cue* pCue);
925 STDAPI IXACT3Cue_Stop(__in IXACT3Cue* pCue, DWORD dwFlags);
926 STDAPI IXACT3Cue_GetState(__in IXACT3Cue* pCue, __out DWORD* pdwState);
927 STDAPI IXACT3Cue_SetMatrixCoefficients(__in IXACT3Cue*, UINT32 uSrcChannelCount, UINT32 uDstChannelCount, __in float* pMatrixCoefficients);
928 STDAPI_(XACTVARIABLEINDEX) IXACT3Cue_GetVariableIndex(__in IXACT3Cue* pCue, __in PCSTR szFriendlyName);
929 STDAPI IXACT3Cue_SetVariable(__in IXACT3Cue* pCue, XACTVARIABLEINDEX nIndex, XACTVARIABLEVALUE nValue);
930 STDAPI IXACT3Cue_GetVariable(__in IXACT3Cue* pCue, XACTVARIABLEINDEX nIndex, __out XACTVARIABLEVALUE* nValue);
931 STDAPI IXACT3Cue_Pause(__in IXACT3Cue* pCue, BOOL fPause);
932 STDAPI IXACT3Cue_GetProperties(__in IXACT3Cue* pCue, __out LPXACT_CUE_INSTANCE_PROPERTIES* ppProperties);
933 STDAPI IXACT3Cue_SetOutputVoices(__in IXACT3Cue* pCue, __in_opt const XAUDIO2_VOICE_SENDS* pSendList);
934 STDAPI IXACT3Cue_SetOutputVoiceMatrix(__in IXACT3Cue* pCue, __in_opt IXAudio2Voice* pDestinationVoice, UINT32 SourceChannels, UINT32 DestinationChannels, __in_ecount(SourceChannels * DestinationChannels) const float* pLevelMatrix);
935 
936 #undef INTERFACE
937 #define INTERFACE IXACT3Cue
938 
939 DECLARE_INTERFACE(IXACT3Cue)
940 {
941  STDMETHOD(Play)(THIS) PURE;
942  STDMETHOD(Stop)(THIS_ DWORD dwFlags) PURE;
943  STDMETHOD(GetState)(THIS_ __out DWORD* pdwState) PURE;
944  STDMETHOD(Destroy)(THIS) PURE;
945  STDMETHOD(SetMatrixCoefficients)(THIS_ UINT32 uSrcChannelCount, UINT32 uDstChannelCount, __in float* pMatrixCoefficients) PURE;
946  STDMETHOD_(XACTVARIABLEINDEX, GetVariableIndex)(THIS_ __in PCSTR szFriendlyName) PURE;
947  STDMETHOD(SetVariable)(THIS_ XACTVARIABLEINDEX nIndex, XACTVARIABLEVALUE nValue) PURE;
948  STDMETHOD(GetVariable)(THIS_ XACTVARIABLEINDEX nIndex, __out XACTVARIABLEVALUE* nValue) PURE;
949  STDMETHOD(Pause)(THIS_ BOOL fPause) PURE;
950  STDMETHOD(GetProperties)(THIS_ __out LPXACT_CUE_INSTANCE_PROPERTIES* ppProperties) PURE;
951  STDMETHOD(SetOutputVoices)(THIS_ __in_opt const XAUDIO2_VOICE_SENDS* pSendList) PURE;
952  STDMETHOD(SetOutputVoiceMatrix)(THIS_ __in_opt IXAudio2Voice* pDestinationVoice, UINT32 SourceChannels, UINT32 DestinationChannels, __in_ecount(SourceChannels * DestinationChannels) const float* pLevelMatrix) PURE;
953 };
954 
955 #ifdef __cplusplus
956 
957 __inline HRESULT __stdcall IXACT3Cue_Play(__in IXACT3Cue* pCue)
958 {
959  return pCue->Play();
960 }
961 
962 __inline HRESULT __stdcall IXACT3Cue_Stop(__in IXACT3Cue* pCue, DWORD dwFlags)
963 {
964  return pCue->Stop(dwFlags);
965 }
966 
967 __inline HRESULT __stdcall IXACT3Cue_GetState(__in IXACT3Cue* pCue, __out DWORD* pdwState)
968 {
969  return pCue->GetState(pdwState);
970 }
971 
972 __inline HRESULT __stdcall IXACT3Cue_Destroy(__in IXACT3Cue* pCue)
973 {
974  return pCue->Destroy();
975 }
976 
977 __inline HRESULT __stdcall IXACT3Cue_SetMatrixCoefficients(__in IXACT3Cue* pCue, UINT32 uSrcChannelCount, UINT32 uDstChannelCount, __in float* pMatrixCoefficients)
978 {
979  return pCue->SetMatrixCoefficients(uSrcChannelCount, uDstChannelCount, pMatrixCoefficients);
980 }
981 
982 __inline XACTVARIABLEINDEX __stdcall IXACT3Cue_GetVariableIndex(__in IXACT3Cue* pCue, __in PCSTR szFriendlyName)
983 {
984  return pCue->GetVariableIndex(szFriendlyName);
985 }
986 
987 __inline HRESULT __stdcall IXACT3Cue_SetVariable(__in IXACT3Cue* pCue, XACTVARIABLEINDEX nIndex, XACTVARIABLEVALUE nValue)
988 {
989  return pCue->SetVariable(nIndex, nValue);
990 }
991 
992 __inline HRESULT __stdcall IXACT3Cue_GetVariable(__in IXACT3Cue* pCue, XACTVARIABLEINDEX nIndex, __out XACTVARIABLEVALUE* pnValue)
993 {
994  return pCue->GetVariable(nIndex, pnValue);
995 }
996 
997 __inline HRESULT __stdcall IXACT3Cue_Pause(__in IXACT3Cue* pCue, BOOL fPause)
998 {
999  return pCue->Pause(fPause);
1000 }
1001 
1002 __inline HRESULT __stdcall IXACT3Cue_GetProperties(__in IXACT3Cue* pCue, __out LPXACT_CUE_INSTANCE_PROPERTIES* ppProperties)
1003 {
1004  return pCue->GetProperties(ppProperties);
1005 }
1006 
1007 __inline HRESULT __stdcall IXACT3Cue_SetOutputVoices(__in IXACT3Cue* pCue, __in_opt const XAUDIO2_VOICE_SENDS* pSendList)
1008 {
1009  return pCue->SetOutputVoices(pSendList);
1010 }
1011 
1012 __inline HRESULT __stdcall IXACT3Cue_SetOutputVoiceMatrix(__in IXACT3Cue* pCue, __in_opt IXAudio2Voice* pDestinationVoice, UINT32 SourceChannels, UINT32 DestinationChannels, __in_ecount(SourceChannels * DestinationChannels) const float* pLevelMatrix)
1013 {
1014  return pCue->SetOutputVoiceMatrix(pDestinationVoice, SourceChannels, DestinationChannels, pLevelMatrix);
1015 }
1016 
1017 #else // __cplusplus
1018 
1019 __inline HRESULT __stdcall IXACT3Cue_Play(__in IXACT3Cue* pCue)
1020 {
1021  return pCue->lpVtbl->Play(pCue);
1022 }
1023 
1024 __inline HRESULT __stdcall IXACT3Cue_Stop(__in IXACT3Cue* pCue, DWORD dwFlags)
1025 {
1026  return pCue->lpVtbl->Stop(pCue, dwFlags);
1027 }
1028 
1029 __inline HRESULT __stdcall IXACT3Cue_GetState(__in IXACT3Cue* pCue, __out DWORD* pdwState)
1030 {
1031  return pCue->lpVtbl->GetState(pCue, pdwState);
1032 }
1033 
1034 __inline HRESULT __stdcall IXACT3Cue_Destroy(__in IXACT3Cue* pCue)
1035 {
1036  return pCue->lpVtbl->Destroy(pCue);
1037 }
1038 
1039 __inline HRESULT __stdcall IXACT3Cue_SetMatrixCoefficients(__in IXACT3Cue* pCue, UINT32 uSrcChannelCount, UINT32 uDstChannelCount, __in float* pMatrixCoefficients)
1040 {
1041  return pCue->lpVtbl->SetMatrixCoefficients(pCue, uSrcChannelCount, uDstChannelCount, pMatrixCoefficients);
1042 }
1043 
1044 __inline XACTVARIABLEINDEX __stdcall IXACT3Cue_GetVariableIndex(__in IXACT3Cue* pCue, __in PCSTR szFriendlyName)
1045 {
1046  return pCue->lpVtbl->GetVariableIndex(pCue, szFriendlyName);
1047 }
1048 
1049 __inline HRESULT __stdcall IXACT3Cue_SetVariable(__in IXACT3Cue* pCue, XACTVARIABLEINDEX nIndex, XACTVARIABLEVALUE nValue)
1050 {
1051  return pCue->lpVtbl->SetVariable(pCue, nIndex, nValue);
1052 }
1053 
1054 __inline HRESULT __stdcall IXACT3Cue_GetVariable(__in IXACT3Cue* pCue, XACTVARIABLEINDEX nIndex, __out XACTVARIABLEVALUE* pnValue)
1055 {
1056  return pCue->lpVtbl->GetVariable(pCue, nIndex, pnValue);
1057 }
1058 
1059 __inline HRESULT __stdcall IXACT3Cue_Pause(__in IXACT3Cue* pCue, BOOL fPause)
1060 {
1061  return pCue->lpVtbl->Pause(pCue, fPause);
1062 }
1063 
1064 __inline HRESULT __stdcall IXACT3Cue_GetProperties(__in IXACT3Cue* pCue, __out LPXACT_CUE_INSTANCE_PROPERTIES* ppProperties)
1065 {
1066  return pCue->lpVtbl->GetProperties(pCue, ppProperties);
1067 }
1068 
1069 __inline HRESULT __stdcall IXACT3Cue_SetOutputVoices(__in IXACT3Cue* pCue, __in_opt const XAUDIO2_VOICE_SENDS* pSendList)
1070 {
1071  return pCue->lpVtbl->SetOutputVoices(pSendList);
1072 }
1073 
1074 __inline HRESULT __stdcall IXACT3Cue_SetOutputVoiceMatrix(__in IXACT3Cue* pCue, __in_opt IXAudio2Voice* pDestinationVoice, UINT32 SourceChannels, UINT32 DestinationChannels, __in_ecount(SourceChannels * DestinationChannels) const float* pLevelMatrix)
1075 {
1076  return pCue->lpVtbl->SetOutputVoiceMatrix(pDestinationVoice, SourceChannels, DestinationChannels, pLevelMatrix);
1077 }
1078 
1079 #endif // __cplusplus
1080 
1081 //------------------------------------------------------------------------------
1082 // IXACT3Engine
1083 //------------------------------------------------------------------------------
1084 
1085 // Engine flags
1086 #define XACT_FLAG_ENGINE_CREATE_MANAGEDATA XACT_FLAG_MANAGEDATA
1087 #define XACT_FLAG_ENGINE_STOP_IMMEDIATE XACT_FLAG_STOP_IMMEDIATE
1088 
1089 STDAPI_(ULONG) IXACT3Engine_AddRef(__in IXACT3Engine* pEngine);
1090 STDAPI_(ULONG) IXACT3Engine_Release(__in IXACT3Engine* pEngine);
1091 STDAPI IXACT3Engine_GetRendererCount(__in IXACT3Engine* pEngine, __out XACTINDEX* pnRendererCount);
1092 STDAPI IXACT3Engine_GetRendererDetails(__in IXACT3Engine* pEngine, XACTINDEX nRendererIndex, __out LPXACT_RENDERER_DETAILS pRendererDetails);
1093 STDAPI IXACT3Engine_GetFinalMixFormat(__in IXACT3Engine* pEngine, __out WAVEFORMATEXTENSIBLE* pFinalMixFormat);
1094 STDAPI IXACT3Engine_Initialize(__in IXACT3Engine* pEngine, __in const XACT_RUNTIME_PARAMETERS* pParams);
1095 STDAPI IXACT3Engine_ShutDown(__in IXACT3Engine* pEngine);
1096 STDAPI IXACT3Engine_DoWork(__in IXACT3Engine* pEngine);
1097 STDAPI IXACT3Engine_CreateSoundBank(__in IXACT3Engine* pEngine, __in const void* pvBuffer, DWORD dwSize, DWORD dwFlags, DWORD dwAllocAttributes, __deref_out IXACT3SoundBank** ppSoundBank);
1098 STDAPI IXACT3Engine_CreateInMemoryWaveBank(__in IXACT3Engine* pEngine, __in const void* pvBuffer, DWORD dwSize, DWORD dwFlags, DWORD dwAllocAttributes, __deref_out IXACT3WaveBank** ppWaveBank);
1099 STDAPI IXACT3Engine_CreateStreamingWaveBank(__in IXACT3Engine* pEngine, __in const XACT_WAVEBANK_STREAMING_PARAMETERS* pParms, __deref_out IXACT3WaveBank** ppWaveBank);
1100 STDAPI IXACT3Engine_PrepareWave(__in IXACT3Engine* pEngine, DWORD dwFlags, __in PCSTR szWavePath, WORD wStreamingPacketSize, DWORD dwAlignment, DWORD dwPlayOffset, XACTLOOPCOUNT nLoopCount, __deref_out IXACT3Wave** ppWave);
1101 STDAPI IXACT3Engine_PrepareInMemoryWave(__in IXACT3Engine* pEngine, DWORD dwFlags, WAVEBANKENTRY entry, __in_opt DWORD* pdwSeekTable, __in_opt BYTE* pbWaveData, DWORD dwPlayOffset, XACTLOOPCOUNT nLoopCount, __deref_out IXACT3Wave** ppWave);
1102 STDAPI IXACT3Engine_PrepareStreamingWave(__in IXACT3Engine* pEngine, DWORD dwFlags, WAVEBANKENTRY entry, XACT_STREAMING_PARAMETERS streamingParams, DWORD dwAlignment, __in_opt DWORD* pdwSeekTable, DWORD dwPlayOffset, XACTLOOPCOUNT nLoopCount, __deref_out IXACT3Wave** ppWave);
1103 STDAPI IXACT3Engine_RegisterNotification(__in IXACT3Engine* pEngine, __in const XACT_NOTIFICATION_DESCRIPTION* pNotificationDesc);
1104 STDAPI IXACT3Engine_UnRegisterNotification(__in IXACT3Engine* pEngine, __in const XACT_NOTIFICATION_DESCRIPTION* pNotificationDesc);
1105 STDAPI_(XACTCATEGORY) IXACT3Engine_GetCategory(__in IXACT3Engine* pEngine, __in PCSTR szFriendlyName);
1106 STDAPI IXACT3Engine_Stop(__in IXACT3Engine* pEngine, XACTCATEGORY nCategory, DWORD dwFlags);
1107 STDAPI IXACT3Engine_SetVolume(__in IXACT3Engine* pEngine, XACTCATEGORY nCategory, XACTVOLUME nVolume);
1108 STDAPI IXACT3Engine_Pause(__in IXACT3Engine* pEngine, XACTCATEGORY nCategory, BOOL fPause);
1109 STDAPI_(XACTVARIABLEINDEX) IXACT3Engine_GetGlobalVariableIndex(__in IXACT3Engine* pEngine, __in PCSTR szFriendlyName);
1110 STDAPI IXACT3Engine_SetGlobalVariable(__in IXACT3Engine* pEngine, XACTVARIABLEINDEX nIndex, XACTVARIABLEVALUE nValue);
1111 STDAPI IXACT3Engine_GetGlobalVariable(__in IXACT3Engine* pEngine, XACTVARIABLEINDEX nIndex, __out XACTVARIABLEVALUE* pnValue);
1112 
1113 #undef INTERFACE
1114 #define INTERFACE IXACT3Engine
1115 
1116 #ifdef _XBOX
1117 DECLARE_INTERFACE(IXACT3Engine)
1118 {
1119 #else
1120 DECLARE_INTERFACE_(IXACT3Engine, IUnknown)
1121 {
1122  STDMETHOD(QueryInterface)(THIS_ __in REFIID riid, __deref_out void** ppvObj) PURE;
1123 #endif
1124 
1125  STDMETHOD_(ULONG, AddRef)(THIS) PURE;
1126  STDMETHOD_(ULONG, Release)(THIS) PURE;
1127 
1128  STDMETHOD(GetRendererCount)(THIS_ __out XACTINDEX* pnRendererCount) PURE;
1129  STDMETHOD(GetRendererDetails)(THIS_ XACTINDEX nRendererIndex, __out LPXACT_RENDERER_DETAILS pRendererDetails) PURE;
1130 
1131  STDMETHOD(GetFinalMixFormat)(THIS_ __out WAVEFORMATEXTENSIBLE* pFinalMixFormat) PURE;
1132  STDMETHOD(Initialize)(THIS_ __in const XACT_RUNTIME_PARAMETERS* pParams) PURE;
1133  STDMETHOD(ShutDown)(THIS) PURE;
1134 
1135  STDMETHOD(DoWork)(THIS) PURE;
1136 
1137  STDMETHOD(CreateSoundBank)(THIS_ __in const void* pvBuffer, DWORD dwSize, DWORD dwFlags, DWORD dwAllocAttributes, __deref_out IXACT3SoundBank** ppSoundBank) PURE;
1138  STDMETHOD(CreateInMemoryWaveBank)(THIS_ __in const void* pvBuffer, DWORD dwSize, DWORD dwFlags, DWORD dwAllocAttributes, __deref_out IXACT3WaveBank** ppWaveBank) PURE;
1139  STDMETHOD(CreateStreamingWaveBank)(THIS_ __in const XACT_WAVEBANK_STREAMING_PARAMETERS* pParms, __deref_out IXACT3WaveBank** ppWaveBank) PURE;
1140 
1141  STDMETHOD(PrepareWave)(THIS_ DWORD dwFlags, __in PCSTR szWavePath, WORD wStreamingPacketSize, DWORD dwAlignment, DWORD dwPlayOffset, XACTLOOPCOUNT nLoopCount, __deref_out IXACT3Wave** ppWave) PURE;
1142  STDMETHOD(PrepareInMemoryWave)(THIS_ DWORD dwFlags, WAVEBANKENTRY entry, __in_opt DWORD* pdwSeekTable, __in_opt BYTE* pbWaveData, DWORD dwPlayOffset, XACTLOOPCOUNT nLoopCount, __deref_out IXACT3Wave** ppWave) PURE;
1143  STDMETHOD(PrepareStreamingWave)(THIS_ DWORD dwFlags, WAVEBANKENTRY entry, XACT_STREAMING_PARAMETERS streamingParams, DWORD dwAlignment, __in_opt DWORD* pdwSeekTable, DWORD dwPlayOffset, XACTLOOPCOUNT nLoopCount, __deref_out IXACT3Wave** ppWave) PURE;
1144 
1145  STDMETHOD(RegisterNotification)(THIS_ __in const XACT_NOTIFICATION_DESCRIPTION* pNotificationDesc) PURE;
1146  STDMETHOD(UnRegisterNotification)(THIS_ __in const XACT_NOTIFICATION_DESCRIPTION* pNotificationDesc) PURE;
1147 
1148  STDMETHOD_(XACTCATEGORY, GetCategory)(THIS_ __in PCSTR szFriendlyName) PURE;
1149  STDMETHOD(Stop)(THIS_ XACTCATEGORY nCategory, DWORD dwFlags) PURE;
1150  STDMETHOD(SetVolume)(THIS_ XACTCATEGORY nCategory, XACTVOLUME nVolume) PURE;
1151  STDMETHOD(Pause)(THIS_ XACTCATEGORY nCategory, BOOL fPause) PURE;
1152 
1153  STDMETHOD_(XACTVARIABLEINDEX, GetGlobalVariableIndex)(THIS_ __in PCSTR szFriendlyName) PURE;
1154  STDMETHOD(SetGlobalVariable)(THIS_ XACTVARIABLEINDEX nIndex, XACTVARIABLEVALUE nValue) PURE;
1155  STDMETHOD(GetGlobalVariable)(THIS_ XACTVARIABLEINDEX nIndex, __out XACTVARIABLEVALUE* nValue) PURE;
1156 };
1157 
1158 #ifdef __cplusplus
1159 
1160 __inline ULONG __stdcall IXACT3Engine_AddRef(__in IXACT3Engine* pEngine)
1161 {
1162  return pEngine->AddRef();
1163 }
1164 
1165 __inline ULONG __stdcall IXACT3Engine_Release(__in IXACT3Engine* pEngine)
1166 {
1167  return pEngine->Release();
1168 }
1169 
1170 __inline HRESULT __stdcall IXACT3Engine_GetRendererCount(__in IXACT3Engine* pEngine, __out XACTINDEX* pnRendererCount)
1171 {
1172  return pEngine->GetRendererCount(pnRendererCount);
1173 }
1174 
1175 __inline HRESULT __stdcall IXACT3Engine_GetRendererDetails(__in IXACT3Engine* pEngine, XACTINDEX nRendererIndex, __out LPXACT_RENDERER_DETAILS pRendererDetails)
1176 {
1177  return pEngine->GetRendererDetails(nRendererIndex, pRendererDetails);
1178 }
1179 
1180 __inline HRESULT __stdcall IXACT3Engine_GetFinalMixFormat(__in IXACT3Engine* pEngine, __out WAVEFORMATEXTENSIBLE* pFinalMixFormat)
1181 {
1182  return pEngine->GetFinalMixFormat(pFinalMixFormat);
1183 }
1184 
1185 __inline HRESULT __stdcall IXACT3Engine_Initialize(__in IXACT3Engine* pEngine, __in const XACT_RUNTIME_PARAMETERS* pParams)
1186 {
1187  return pEngine->Initialize(pParams);
1188 }
1189 
1190 __inline HRESULT __stdcall IXACT3Engine_ShutDown(__in IXACT3Engine* pEngine)
1191 {
1192  return pEngine->ShutDown();
1193 }
1194 
1195 __inline HRESULT __stdcall IXACT3Engine_DoWork(__in IXACT3Engine* pEngine)
1196 {
1197  return pEngine->DoWork();
1198 }
1199 
1200 __inline HRESULT __stdcall IXACT3Engine_CreateSoundBank(__in IXACT3Engine* pEngine, __in const void* pvBuffer, DWORD dwSize, DWORD dwFlags, DWORD dwAllocAttributes, __deref_out IXACT3SoundBank** ppSoundBank)
1201 {
1202  return pEngine->CreateSoundBank(pvBuffer, dwSize, dwFlags, dwAllocAttributes, ppSoundBank);
1203 }
1204 
1205 __inline HRESULT __stdcall IXACT3Engine_CreateInMemoryWaveBank(__in IXACT3Engine* pEngine, __in const void* pvBuffer, DWORD dwSize, DWORD dwFlags, DWORD dwAllocAttributes, __deref_out IXACT3WaveBank** ppWaveBank)
1206 {
1207  return pEngine->CreateInMemoryWaveBank(pvBuffer, dwSize, dwFlags, dwAllocAttributes, ppWaveBank);
1208 }
1209 
1210 __inline HRESULT __stdcall IXACT3Engine_CreateStreamingWaveBank(__in IXACT3Engine* pEngine, __in const XACT_WAVEBANK_STREAMING_PARAMETERS* pParms, __deref_out IXACT3WaveBank** ppWaveBank)
1211 {
1212  return pEngine->CreateStreamingWaveBank(pParms, ppWaveBank);
1213 }
1214 
1215 __inline HRESULT __stdcall IXACT3Engine_PrepareWave(__in IXACT3Engine* pEngine, DWORD dwFlags, __in PCSTR szWavePath, WORD wStreamingPacketSize, DWORD dwAlignment, DWORD dwPlayOffset, XACTLOOPCOUNT nLoopCount, __deref_out IXACT3Wave** ppWave)
1216 {
1217  return pEngine->PrepareWave(dwFlags, szWavePath, wStreamingPacketSize, dwAlignment, dwPlayOffset, nLoopCount, ppWave);
1218 }
1219 
1220 __inline HRESULT __stdcall IXACT3Engine_PrepareInMemoryWave(__in IXACT3Engine* pEngine, DWORD dwFlags, WAVEBANKENTRY entry, __in_opt DWORD* pdwSeekTable, __in_opt BYTE* pbWaveData, DWORD dwPlayOffset, XACTLOOPCOUNT nLoopCount, __deref_out IXACT3Wave** ppWave)
1221 {
1222  return pEngine->PrepareInMemoryWave(dwFlags, entry, pdwSeekTable, pbWaveData, dwPlayOffset, nLoopCount, ppWave);
1223 }
1224 
1225 __inline HRESULT __stdcall IXACT3Engine_PrepareStreamingWave(__in IXACT3Engine* pEngine, DWORD dwFlags, WAVEBANKENTRY entry, XACT_STREAMING_PARAMETERS streamingParams, DWORD dwAlignment, __in_opt DWORD* pdwSeekTable, DWORD dwPlayOffset, XACTLOOPCOUNT nLoopCount, __deref_out IXACT3Wave** ppWave)
1226 {
1227  return pEngine->PrepareStreamingWave(dwFlags, entry, streamingParams, dwAlignment, pdwSeekTable, dwPlayOffset, nLoopCount, ppWave);
1228 }
1229 
1230 __inline HRESULT __stdcall IXACT3Engine_RegisterNotification(__in IXACT3Engine* pEngine, __in const XACT_NOTIFICATION_DESCRIPTION* pNotificationDesc)
1231 {
1232  return pEngine->RegisterNotification(pNotificationDesc);
1233 }
1234 
1235 __inline HRESULT __stdcall IXACT3Engine_UnRegisterNotification(__in IXACT3Engine* pEngine, __in const XACT_NOTIFICATION_DESCRIPTION* pNotificationDesc)
1236 {
1237  return pEngine->UnRegisterNotification(pNotificationDesc);
1238 }
1239 
1240 __inline XACTCATEGORY __stdcall IXACT3Engine_GetCategory(__in IXACT3Engine* pEngine, __in PCSTR szFriendlyName)
1241 {
1242  return pEngine->GetCategory(szFriendlyName);
1243 }
1244 
1245 __inline HRESULT __stdcall IXACT3Engine_Stop(__in IXACT3Engine* pEngine, XACTCATEGORY nCategory, DWORD dwFlags)
1246 {
1247  return pEngine->Stop(nCategory, dwFlags);
1248 }
1249 
1250 __inline HRESULT __stdcall IXACT3Engine_SetVolume(__in IXACT3Engine* pEngine, XACTCATEGORY nCategory, XACTVOLUME nVolume)
1251 {
1252  return pEngine->SetVolume(nCategory, nVolume);
1253 }
1254 
1255 __inline HRESULT __stdcall IXACT3Engine_Pause(__in IXACT3Engine* pEngine, XACTCATEGORY nCategory, BOOL fPause)
1256 {
1257  return pEngine->Pause(nCategory, fPause);
1258 }
1259 
1260 __inline XACTVARIABLEINDEX __stdcall IXACT3Engine_GetGlobalVariableIndex(__in IXACT3Engine* pEngine, __in PCSTR szFriendlyName)
1261 {
1262  return pEngine->GetGlobalVariableIndex(szFriendlyName);
1263 }
1264 
1265 __inline HRESULT __stdcall IXACT3Engine_SetGlobalVariable(__in IXACT3Engine* pEngine, XACTVARIABLEINDEX nIndex, XACTVARIABLEVALUE nValue)
1266 {
1267  return pEngine->SetGlobalVariable(nIndex, nValue);
1268 }
1269 
1270 __inline HRESULT __stdcall IXACT3Engine_GetGlobalVariable(__in IXACT3Engine* pEngine, XACTVARIABLEINDEX nIndex, __out XACTVARIABLEVALUE* nValue)
1271 {
1272  return pEngine->GetGlobalVariable(nIndex, nValue);
1273 }
1274 
1275 #else // __cplusplus
1276 
1277 __inline ULONG __stdcall IXACT3Engine_AddRef(__in IXACT3Engine* pEngine)
1278 {
1279  return pEngine->lpVtbl->AddRef(pEngine);
1280 }
1281 
1282 __inline ULONG __stdcall IXACT3Engine_Release(__in IXACT3Engine* pEngine)
1283 {
1284  return pEngine->lpVtbl->Release(pEngine);
1285 }
1286 
1287 __inline HRESULT __stdcall IXACT3Engine_GetRendererCount(__in IXACT3Engine* pEngine, __out XACTINDEX* pnRendererCount)
1288 {
1289  return pEngine->lpVtbl->GetRendererCount(pEngine, pnRendererCount);
1290 }
1291 
1292 __inline HRESULT __stdcall IXACT3Engine_GetRendererDetails(__in IXACT3Engine* pEngine, XACTINDEX nRendererIndex, __out LPXACT_RENDERER_DETAILS pRendererDetails)
1293 {
1294  return pEngine->lpVtbl->GetRendererDetails(pEngine, nRendererIndex, pRendererDetails);
1295 }
1296 
1297 __inline HRESULT __stdcall IXACT3Engine_GetFinalMixFormat(__in IXACT3Engine* pEngine, __out WAVEFORMATEXTENSIBLE* pFinalMixFormat)
1298 {
1299  return pEngine->lpVtbl->GetFinalMixFormat(pEngine, pFinalMixFormat);
1300 }
1301 
1302 __inline HRESULT __stdcall IXACT3Engine_Initialize(__in IXACT3Engine* pEngine, __in const XACT_RUNTIME_PARAMETERS* pParams)
1303 {
1304  return pEngine->lpVtbl->Initialize(pEngine, pParams);
1305 }
1306 
1307 __inline HRESULT __stdcall IXACT3Engine_ShutDown(__in IXACT3Engine* pEngine)
1308 {
1309  return pEngine->lpVtbl->ShutDown(pEngine);
1310 }
1311 
1312 __inline HRESULT __stdcall IXACT3Engine_DoWork(__in IXACT3Engine* pEngine)
1313 {
1314  return pEngine->lpVtbl->DoWork(pEngine);
1315 }
1316 
1317 __inline HRESULT __stdcall IXACT3Engine_CreateSoundBank(__in IXACT3Engine* pEngine, __in const void* pvBuffer, DWORD dwSize, DWORD dwFlags, DWORD dwAllocAttributes, __deref_out IXACT3SoundBank** ppSoundBank)
1318 {
1319  return pEngine->lpVtbl->CreateSoundBank(pEngine, pvBuffer, dwSize, dwFlags, dwAllocAttributes, ppSoundBank);
1320 }
1321 
1322 __inline HRESULT __stdcall IXACT3Engine_CreateInMemoryWaveBank(__in IXACT3Engine* pEngine, __in const void* pvBuffer, DWORD dwSize, DWORD dwFlags, DWORD dwAllocAttributes, __deref_out IXACT3WaveBank** ppWaveBank)
1323 {
1324  return pEngine->lpVtbl->CreateInMemoryWaveBank(pEngine, pvBuffer, dwSize, dwFlags, dwAllocAttributes, ppWaveBank);
1325 }
1326 
1327 __inline HRESULT __stdcall IXACT3Engine_CreateStreamingWaveBank(__in IXACT3Engine* pEngine, __in const XACT_WAVEBANK_STREAMING_PARAMETERS* pParms, __deref_out IXACT3WaveBank** ppWaveBank)
1328 {
1329  return pEngine->lpVtbl->CreateStreamingWaveBank(pEngine, pParms, ppWaveBank);
1330 }
1331 
1332 __inline HRESULT __stdcall IXACT3Engine_PrepareWave(__in IXACT3Engine* pEngine, DWORD dwFlags, __in PCSTR szWavePath, WORD wStreamingPacketSize, DWORD dwAlignment, DWORD dwPlayOffset, XACTLOOPCOUNT nLoopCount, __deref_out IXACT3Wave** ppWave)
1333 {
1334  return pEngine->lpVtbl->PrepareWave(pEngine, dwFlags, szWavePath, wStreamingPacketSize, dwAlignment, dwPlayOffset, nLoopCount, ppWave);
1335 }
1336 
1337 __inline HRESULT __stdcall IXACT3Engine_PrepareInMemoryWave(__in IXACT3Engine* pEngine, DWORD dwFlags, WAVEBANKENTRY entry, __in_opt DWORD* pdwSeekTable, __in_opt BYTE* pbWaveData, DWORD dwPlayOffset, XACTLOOPCOUNT nLoopCount, __deref_out IXACT3Wave** ppWave)
1338 {
1339  return pEngine->lpVtbl->PrepareInMemoryWave(pEngine, dwFlags, entry, pdwSeekTable, pbWaveData, dwPlayOffset, nLoopCount, ppWave);
1340 }
1341 
1342 __inline HRESULT __stdcall IXACT3Engine_PrepareStreamingWave(__in IXACT3Engine* pEngine, DWORD dwFlags, WAVEBANKENTRY entry, XACT_STREAMING_PARAMETERS streamingParams, DWORD dwAlignment, __in_opt DWORD* pdwSeekTable, DWORD dwPlayOffset, XACTLOOPCOUNT nLoopCount, __deref_out IXACT3Wave** ppWave)
1343 {
1344  return pEngine->lpVtbl->PrepareStreamingWave(pEngine, dwFlags, entry, streamingParams, dwAlignment, pdwSeekTable, dwPlayOffset, nLoopCount, ppWave);
1345 }
1346 
1347 
1348 __inline HRESULT __stdcall IXACT3Engine_RegisterNotification(__in IXACT3Engine* pEngine, __in const XACT_NOTIFICATION_DESCRIPTION* pNotificationDesc)
1349 {
1350  return pEngine->lpVtbl->RegisterNotification(pEngine, pNotificationDesc);
1351 }
1352 
1353 __inline HRESULT __stdcall IXACT3Engine_UnRegisterNotification(__in IXACT3Engine* pEngine, __in const XACT_NOTIFICATION_DESCRIPTION* pNotificationDesc)
1354 {
1355  return pEngine->lpVtbl->UnRegisterNotification(pEngine, pNotificationDesc);
1356 }
1357 
1358 __inline XACTCATEGORY __stdcall IXACT3Engine_GetCategory(__in IXACT3Engine* pEngine, __in PCSTR szFriendlyName)
1359 {
1360  return pEngine->lpVtbl->GetCategory(pEngine, szFriendlyName);
1361 }
1362 
1363 __inline HRESULT __stdcall IXACT3Engine_Stop(__in IXACT3Engine* pEngine, XACTCATEGORY nCategory, DWORD dwFlags)
1364 {
1365  return pEngine->lpVtbl->Stop(pEngine, nCategory, dwFlags);
1366 }
1367 
1368 __inline HRESULT __stdcall IXACT3Engine_SetVolume(__in IXACT3Engine* pEngine, XACTCATEGORY nCategory, XACTVOLUME nVolume)
1369 {
1370  return pEngine->lpVtbl->SetVolume(pEngine, nCategory, nVolume);
1371 }
1372 
1373 __inline HRESULT __stdcall IXACT3Engine_Pause(__in IXACT3Engine* pEngine, XACTCATEGORY nCategory, BOOL fPause)
1374 {
1375  return pEngine->lpVtbl->Pause(pEngine, nCategory, fPause);
1376 }
1377 
1378 __inline XACTVARIABLEINDEX __stdcall IXACT3Engine_GetGlobalVariableIndex(__in IXACT3Engine* pEngine, __in PCSTR szFriendlyName)
1379 {
1380  return pEngine->lpVtbl->GetGlobalVariableIndex(pEngine, szFriendlyName);
1381 }
1382 
1383 __inline HRESULT __stdcall IXACT3Engine_SetGlobalVariable(__in IXACT3Engine* pEngine, XACTVARIABLEINDEX nIndex, XACTVARIABLEVALUE nValue)
1384 {
1385  return pEngine->lpVtbl->SetGlobalVariable(pEngine, nIndex, nValue);
1386 }
1387 
1388 __inline HRESULT __stdcall IXACT3Engine_GetGlobalVariable(__in IXACT3Engine* pEngine, XACTVARIABLEINDEX nIndex, __out XACTVARIABLEVALUE* nValue)
1389 {
1390  return pEngine->lpVtbl->GetGlobalVariable(pEngine, nIndex, nValue);
1391 }
1392 
1393 #endif // __cplusplus
1394 
1395 //------------------------------------------------------------------------------
1396 // Create Engine
1397 //------------------------------------------------------------------------------
1398 
1399 // Flags used only in XACT3CreateEngine below. These flags are valid but ignored
1400 // when building for Xbox 360; to enable auditioning on that platform you must
1401 // link explicitly to an auditioning version of the XACT static library.
1402 static const DWORD XACT_FLAG_API_AUDITION_MODE = 0x00000001;
1403 static const DWORD XACT_FLAG_API_DEBUG_MODE = 0x00000002;
1404 
1405 #ifdef _XBOX
1406 
1407 STDAPI XACT3CreateEngine(DWORD dwCreationFlags, __deref_out IXACT3Engine** ppEngine);
1408 
1409 #else // #ifdef _XBOX
1410 
1411 #define XACT_DEBUGENGINE_REGISTRY_KEY TEXT("Software\\Microsoft\\XACT")
1412 #define XACT_DEBUGENGINE_REGISTRY_VALUE TEXT("DebugEngine")
1413 
1414 
1415 #ifdef __cplusplus
1416 
1417 __inline HRESULT __stdcall XACT3CreateEngine(DWORD dwCreationFlags, __deref_out IXACT3Engine** ppEngine)
1418 {
1419  HRESULT hr;
1420  HKEY key;
1421  DWORD data;
1422  DWORD type = REG_DWORD;
1423  DWORD dataSize = sizeof(DWORD);
1424  BOOL debug = (dwCreationFlags & XACT_FLAG_API_DEBUG_MODE) ? TRUE : FALSE;
1425  BOOL audition = (dwCreationFlags & XACT_FLAG_API_AUDITION_MODE) ? TRUE : FALSE;
1426 
1427  // If neither the debug nor audition flags are set, see if the debug registry key is set
1428  if(!debug && !audition &&
1429  (RegOpenKeyEx(HKEY_LOCAL_MACHINE, XACT_DEBUGENGINE_REGISTRY_KEY, 0, KEY_READ, &key) == ERROR_SUCCESS))
1430  {
1431  if(RegQueryValueEx(key, XACT_DEBUGENGINE_REGISTRY_VALUE, NULL, &type, (LPBYTE)&data, &dataSize) == ERROR_SUCCESS)
1432  {
1433  if(data)
1434  {
1435  debug = TRUE;
1436  }
1437  }
1438  RegCloseKey(key);
1439  }
1440 
1441  // Priority order: Audition, Debug, Retail
1442  hr = CoCreateInstance(audition ? __uuidof(XACTAuditionEngine)
1443  : (debug ? __uuidof(XACTDebugEngine) : __uuidof(XACTEngine)),
1444  NULL, CLSCTX_INPROC_SERVER, __uuidof(IXACT3Engine), (void**)ppEngine);
1445 
1446  // If debug engine does not exist fallback to retail version
1447  if(FAILED(hr) && debug && !audition)
1448  {
1449  hr = CoCreateInstance(__uuidof(XACTEngine), NULL, CLSCTX_INPROC_SERVER, __uuidof(IXACT3Engine), (void**)ppEngine);
1450  }
1451 
1452  return hr;
1453 }
1454 
1455 #else // #ifdef __cplusplus
1456 
1457 __inline HRESULT __stdcall XACT3CreateEngine(DWORD dwCreationFlags, __deref_out IXACT3Engine** ppEngine)
1458 {
1459  HRESULT hr;
1460  HKEY key;
1461  DWORD data;
1462  DWORD type = REG_DWORD;
1463  DWORD dataSize = sizeof(DWORD);
1464  BOOL debug = (dwCreationFlags & XACT_FLAG_API_DEBUG_MODE) ? TRUE : FALSE;
1465  BOOL audition = (dwCreationFlags & XACT_FLAG_API_AUDITION_MODE) ? TRUE : FALSE;
1466 
1467  // If neither the debug nor audition flags are set, see if the debug registry key is set
1468  if(!debug && !audition &&
1469  (RegOpenKeyEx(HKEY_LOCAL_MACHINE, XACT_DEBUGENGINE_REGISTRY_KEY, 0, KEY_READ, &key) == ERROR_SUCCESS))
1470  {
1471  if(RegQueryValueEx(key, XACT_DEBUGENGINE_REGISTRY_VALUE, NULL, &type, (LPBYTE)&data, &dataSize) == ERROR_SUCCESS)
1472  {
1473  if(data)
1474  {
1475  debug = TRUE;
1476  }
1477  }
1478  RegCloseKey(key);
1479  }
1480 
1481  // Priority order: Audition, Debug, Retail
1482  hr = CoCreateInstance(audition ? &CLSID_XACTAuditionEngine
1483  : (debug ? &CLSID_XACTDebugEngine : &CLSID_XACTEngine),
1484  NULL, CLSCTX_INPROC_SERVER, &IID_IXACT3Engine, (void**)ppEngine);
1485 
1486  // If debug engine does not exist fallback to retail version
1487  if(FAILED(hr) && debug && !audition)
1488  {
1489  hr = CoCreateInstance(&CLSID_XACTEngine, NULL, CLSCTX_INPROC_SERVER, &IID_IXACT3Engine, (void**)ppEngine);
1490  }
1491 
1492  return hr;
1493 }
1494 
1495 #endif // #ifdef __cplusplus
1496 
1497 #endif // #ifdef _XBOX
1498 
1499 //------------------------------------------------------------------------------
1500 // XACT specific error codes
1501 //------------------------------------------------------------------------------
1502 
1503 #define FACILITY_XACTENGINE 0xAC7
1504 #define XACTENGINEERROR(n) MAKE_HRESULT(SEVERITY_ERROR, FACILITY_XACTENGINE, n)
1505 
1506 #define XACTENGINE_E_OUTOFMEMORY E_OUTOFMEMORY // Out of memory
1507 #define XACTENGINE_E_INVALIDARG E_INVALIDARG // Invalid arg
1508 #define XACTENGINE_E_NOTIMPL E_NOTIMPL // Not implemented
1509 #define XACTENGINE_E_FAIL E_FAIL // Unknown error
1510 
1511 #define XACTENGINE_E_ALREADYINITIALIZED XACTENGINEERROR(0x001) // The engine is already initialized
1512 #define XACTENGINE_E_NOTINITIALIZED XACTENGINEERROR(0x002) // The engine has not been initialized
1513 #define XACTENGINE_E_EXPIRED XACTENGINEERROR(0x003) // The engine has expired (demo or pre-release version)
1514 #define XACTENGINE_E_NONOTIFICATIONCALLBACK XACTENGINEERROR(0x004) // No notification callback
1515 #define XACTENGINE_E_NOTIFICATIONREGISTERED XACTENGINEERROR(0x005) // Notification already registered
1516 #define XACTENGINE_E_INVALIDUSAGE XACTENGINEERROR(0x006) // Invalid usage
1517 #define XACTENGINE_E_INVALIDDATA XACTENGINEERROR(0x007) // Invalid data
1518 #define XACTENGINE_E_INSTANCELIMITFAILTOPLAY XACTENGINEERROR(0x008) // Fail to play due to instance limit
1519 #define XACTENGINE_E_NOGLOBALSETTINGS XACTENGINEERROR(0x009) // Global Settings not loaded
1520 #define XACTENGINE_E_INVALIDVARIABLEINDEX XACTENGINEERROR(0x00a) // Invalid variable index
1521 #define XACTENGINE_E_INVALIDCATEGORY XACTENGINEERROR(0x00b) // Invalid category
1522 #define XACTENGINE_E_INVALIDCUEINDEX XACTENGINEERROR(0x00c) // Invalid cue index
1523 #define XACTENGINE_E_INVALIDWAVEINDEX XACTENGINEERROR(0x00d) // Invalid wave index
1524 #define XACTENGINE_E_INVALIDTRACKINDEX XACTENGINEERROR(0x00e) // Invalid track index
1525 #define XACTENGINE_E_INVALIDSOUNDOFFSETORINDEX XACTENGINEERROR(0x00f) // Invalid sound offset or index
1526 #define XACTENGINE_E_READFILE XACTENGINEERROR(0x010) // Error reading a file
1527 #define XACTENGINE_E_UNKNOWNEVENT XACTENGINEERROR(0x011) // Unknown event type
1528 #define XACTENGINE_E_INCALLBACK XACTENGINEERROR(0x012) // Invalid call of method of function from callback
1529 #define XACTENGINE_E_NOWAVEBANK XACTENGINEERROR(0x013) // No wavebank exists for desired operation
1530 #define XACTENGINE_E_SELECTVARIATION XACTENGINEERROR(0x014) // Unable to select a variation
1531 #define XACTENGINE_E_MULTIPLEAUDITIONENGINES XACTENGINEERROR(0x015) // There can be only one audition engine
1532 #define XACTENGINE_E_WAVEBANKNOTPREPARED XACTENGINEERROR(0x016) // The wavebank is not prepared
1533 #define XACTENGINE_E_NORENDERER XACTENGINEERROR(0x017) // No audio device found on.
1534 #define XACTENGINE_E_INVALIDENTRYCOUNT XACTENGINEERROR(0x018) // Invalid entry count for channel maps
1535 #define XACTENGINE_E_SEEKTIMEBEYONDCUEEND XACTENGINEERROR(0x019) // Time offset for seeking is beyond the cue end.
1536 #define XACTENGINE_E_SEEKTIMEBEYONDWAVEEND XACTENGINEERROR(0x01a) // Time offset for seeking is beyond the wave end.
1537 #define XACTENGINE_E_NOFRIENDLYNAMES XACTENGINEERROR(0x01b) // Friendly names are not included in the bank.
1538 
1539 #define XACTENGINE_E_AUDITION_WRITEFILE XACTENGINEERROR(0x101) // Error writing a file during auditioning
1540 #define XACTENGINE_E_AUDITION_NOSOUNDBANK XACTENGINEERROR(0x102) // Missing a soundbank
1541 #define XACTENGINE_E_AUDITION_INVALIDRPCINDEX XACTENGINEERROR(0x103) // Missing an RPC curve
1542 #define XACTENGINE_E_AUDITION_MISSINGDATA XACTENGINEERROR(0x104) // Missing data for an audition command
1543 #define XACTENGINE_E_AUDITION_UNKNOWNCOMMAND XACTENGINEERROR(0x105) // Unknown command
1544 #define XACTENGINE_E_AUDITION_INVALIDDSPINDEX XACTENGINEERROR(0x106) // Missing a DSP parameter
1545 #define XACTENGINE_E_AUDITION_MISSINGWAVE XACTENGINEERROR(0x107) // Wave does not exist in auditioned wavebank
1546 #define XACTENGINE_E_AUDITION_CREATEDIRECTORYFAILED XACTENGINEERROR(0x108) // Failed to create a directory for streaming wavebank data
1547 #define XACTENGINE_E_AUDITION_INVALIDSESSION XACTENGINEERROR(0x109) // Invalid audition session
1548 
1549 #endif // #ifndef GUID_DEFS_ONLY
1550 
1551 #endif // #ifndef _XACT3_H_
XACT_NOTIFICATION
Definition: xact3.h:525
XACT_STREAMING_PARAMETERS
Definition: xact3.h:276
XACT_WAVE_INSTANCE_PROPERTIES
Definition: xact3.h:365
XACT_CUE_PROPERTIES
Definition: xact3.h:290
_GUID
Definition: guiddef.h:43
XACT_NOTIFICATION_DESCRIPTION
Definition: xact3.h:439
XACTCHANNELMAP
Definition: xact3.h:386
XACT_TRACK_PROPERTIES
Definition: xact3.h:302
XACTCHANNELVOLUMEENTRY
Definition: xact3.h:394
WAVEBANKSAMPLEREGION
Definition: xact3wb.h:202
XACT_VARIATION_PROPERTIES
Definition: xact3.h:313
XACT_RUNTIME_PARAMETERS
Definition: xact3.h:256
XACT_CUE_INSTANCE_PROPERTIES
Definition: xact3.h:344
XACT_NOTIFICATION_WAVE
Definition: xact3.h:512
WAVEBANKMINIWAVEFORMAT
Definition: xact3wb.h:306
XAUDIO2_VOICE_SENDS
Definition: XAudio2.h:262
XACT_NOTIFICATION_GUI
Definition: xact3.h:505
XACT_RENDERER_DETAILS
Definition: xact3.h:240
XACT_NOTIFICATION_SOUNDBANK
Definition: xact3.h:476
XACTCHANNELVOLUME
Definition: xact3.h:402
XACT_WAVE_PROPERTIES
Definition: xact3.h:353
tWAVEFORMATEX
Definition: audiodefs.h:40
XACT_FILEIO_CALLBACKS
Definition: xact3.h:221
XACTCHANNELMAPENTRY
Definition: xact3.h:377
XACT_NOTIFICATION_CUE
Definition: xact3.h:455
XACT_NOTIFICATION_VARIABLE
Definition: xact3.h:492
XACT_NOTIFICATION_MARKER
Definition: xact3.h:465
XACT_SOUND_VARIATION_PROPERTIES
Definition: xact3.h:336
WAVEBANKENTRY
Definition: xact3wb.h:450
XACT_NOTIFICATION_WAVEBANK
Definition: xact3.h:484
XACT_SOUND_PROPERTIES
Definition: xact3.h:324
WAVEFORMATEXTENSIBLE
Definition: audiodefs.h:74
Generated by   doxygen 1.8.12