~chronoscz/tunneler/trunk

FSOUND_GetNumHWChannels: function (var Num2D: Integer; var Num3D: Integer; var Total: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

137

FSOUND_GetChannelsPlaying: function: Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

138

FSOUND_GetCPUUsage: function: Single; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

139

FSOUND_GetMemoryStats: Procedure (var CurrentAlloced: Cardinal; var MaxAlloced: Cardinal); {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

140

141

{ =================================== }

142

{ Sample management / load functions. }

143

{ =================================== }

144

145

{

146

Sample creation and management functions

147

Note : Use FSOUND_LOADMEMORY flag with FSOUND_Sample_Load to load from memory.

148

Use FSOUND_LOADRAW flag with FSOUND_Sample_Load to treat as as raw pcm data.

149

}

150

151

var

152

FSOUND_Sample_Load: function (Index: Integer; const NameOrData: PChar; Mode: Cardinal; Offset: Integer; Length: Integer): PFSoundSample; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

153

FSOUND_Sample_Alloc: function (Index: Integer; Length: Integer; Mode: Cardinal; DefFreq: Integer; DefVol: Integer; DefPan: Integer; DefPri: Integer): PFSoundSample; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

154

FSOUND_Sample_Free: procedure (Sptr: PFSoundSample); {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

155

FSOUND_Sample_Upload: function (Sptr: PFSoundSample; SrcData: Pointer; Mode: Cardinal): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

156

FSOUND_Sample_Lock: function (Sptr: PFSoundSample; Offset: Integer; Length: Integer; var Ptr1: Pointer; var Ptr2: Pointer; var Len1: Cardinal; var Len2: Cardinal): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

157

FSOUND_Sample_Unlock: function (Sptr: PFSoundSample; Ptr1: Pointer; Ptr2: Pointer; Len1: Cardinal; Len2: Cardinal): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

158

159

{

160

Sample control functions

161

}

162

163

var

164

FSOUND_Sample_SetMode: function (Sptr: PFSoundSample; Mode: Cardinal): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

165

FSOUND_Sample_SetLoopPoints: function (Sptr: PFSoundSample; LoopStart, LoopEnd: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

166

FSOUND_Sample_SetDefaults: function (Sptr: PFSoundSample; DefFreq, DefVol, DefPan, DefPri: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

167

FSOUND_Sample_SetDefaultsEx: function (Sptr: PFSoundSample; DefFreq, DefVol, DefPan, DefPri, VarFreq, VarVol, VarPan: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

168

FSOUND_Sample_SetMinMaxDistance: function (Sptr: PFSoundSample; Min, Max: Single): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

169

FSOUND_Sample_SetMaxPlaybacks: function (Sptr: PFSoundSample; Max: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

170

171

{

172

Sample information functions

173

}

174

175

var

176

FSOUND_Sample_Get: function (SampNo: Integer): PFSoundSample; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

177

FSOUND_Sample_GetName: function (Sptr: PFSoundSample): PCHAR; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

178

FSOUND_Sample_GetLength: function (Sptr: PFSoundSample): Cardinal; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

179

FSOUND_Sample_GetLoopPoints: function (Sptr: PFSoundSample; var LoopStart: Integer; var LoopEnd: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

180

FSOUND_Sample_GetDefaults: function (Sptr: PFSoundSample; var DefFreq: Integer; var DefVol: Integer; var DefPan: Integer; var DefPri: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

181

FSOUND_Sample_GetDefaultsEx: function (Sptr: PFSoundSample; var DefFreq: Integer; var DefVol: Integer; var DefPan: Integer; var DefPri: Integer; var VarFreq: Integer; var VarVol: Integer; var VarPan): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

182

FSOUND_Sample_GetMode: function (Sptr: PFSoundSample): Cardinal; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

183

FSOUND_Sample_GetMinMaxDistance: function (Sptr: PFSoundSample; var Min: Single; var Max: Single): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

184

185

{ ============================ }

186

{ Channel control functions. }

187

{ ============================ }

188

189

{

190

Playing and stopping sounds.

191

Note : Use FSOUND_FREE as the 'channel' variable, to let FMOD pick a free channel for you.

192

Use FSOUND_ALL as the 'channel' variable to control ALL channels with one function call!

193

}

194

195

var

196

FSOUND_PlaySound: function (Channel: Integer; Sptr: PFSoundSample): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

197

FSOUND_PlaySoundEx: function (Channel: Integer; Sptr: PFSoundSample; Dsp: PFSoundDSPUnit; StartPaused: ByteBool): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

198

FSOUND_StopSound: function (Channel: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

199

200

{

201

Functions to control playback of a channel.

202

}

203

204

var

205

FSOUND_SetFrequency: function (Channel: Integer; Freq: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

206

FSOUND_SetVolume: function (Channel: Integer; Vol: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

207

FSOUND_SetVolumeAbsolute: function (Channel: Integer; Vol: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

208

FSOUND_SetPan: function (Channel: Integer; Pan: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

209

FSOUND_SetSurround: function (Channel: Integer; Surround: ByteBool): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

210

FSOUND_SetMute: function (Channel: Integer; Mute: ByteBool): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

211

FSOUND_SetPriority: function (Channel: Integer; Priority: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

212

FSOUND_SetReserved: function (Channel: Integer; Reserved: ByteBool): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

213

FSOUND_SetPaused: function (Channel: Integer; Paused: ByteBool): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

214

FSOUND_SetLoopMode: function (Channel: Integer; LoopMode: Cardinal): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

215

FSOUND_SetCurrentPosition: function (Channel: Integer; Offset: Cardinal): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

216

FSOUND_3D_SetAttributes: function (Channel: Integer; Pos: PFSoundVector; Vel: PFSoundVector): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

217

FSOUND_3D_SetMinMaxDistance: function (Channel: Integer; Min: Single; Max: Single): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

218

219

{

220

Channel information functions

221

}

222

223

var

224

FSOUND_IsPlaying: function (Channel: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

225

FSOUND_GetFrequency: function (Channel: Integer): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

226

FSOUND_GetVolume: function (Channel: Integer): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

227

FSOUND_GetAmplitude: function (Channel: Integer): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

228

FSOUND_GetPan: function (Channel: Integer): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

229

FSOUND_GetSurround: function (Channel: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

230

FSOUND_GetMute: function (Channel: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

231

FSOUND_GetPriority: function (Channel: Integer): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

232

FSOUND_GetReserved: function (Channel: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

233

FSOUND_GetPaused: function (Channel: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

234

FSOUND_GetLoopMode: function (Channel: Integer): Cardinal; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

235

FSOUND_GetCurrentPosition: function (Channel: Integer): Cardinal; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

236

FSOUND_GetCurrentSample: function (Channel: Integer): PFSoundSample; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

237

FSOUND_GetCurrentLevels: function (Channel: Integer; L, R: PSingle): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

238

FSOUND_GetNumSubChannels: function (Channel: Integer): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

239

FSOUND_GetSubChannel: function (Channel: Integer; SubChannel: Integer): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

240

FSOUND_3D_GetAttributes: function (Channel: Integer; Pos: PFSoundVector; Vel: PFSoundVector): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

241

FSOUND_3D_GetMinMaxDistance: function (Channel: Integer; var Min: Single; var Max: Single): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

242

243

{ =================== }

244

{ 3D sound functions. }

245

{ =================== }

246

247

{

248

See also 3d sample and channel based functions above.

249

Call FSOUND_Update once a frame to process 3d information.

250

}

251

252

var

253

FSOUND_3D_Listener_SetCurrent: procedure (current: Integer); {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

254

FSOUND_3D_Listener_SetAttributes: procedure (Pos: PFSoundVector; Vel: PFSoundVector;

255

fx: Single; fy: Single; fz: Single;

256

tx: Single; ty: Single; tz: Single); {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

257

FSOUND_3D_Listener_GetAttributes: procedure (Pos: PFSoundVector; Vel: PFSoundVector;

258

fx: PSingle; fy: PSingle; fz: PSingle;

259

tx: PSingle; ty: PSingle; tz: PSingle); {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

260

FSOUND_3D_SetDopplerFactor: procedure (Scale: Single); {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

261

FSOUND_3D_SetDistanceFactor: procedure (Scale: Single); {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

262

FSOUND_3D_SetRolloffFactor: procedure (Scale: Single); {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

263

264

{ =================== }

265

{ FX functions. }

266

{ =================== }

267

268

{

269

Functions to control DX8 only effects processing.

270

271

- FX enabled samples can only be played once at a time, not multiple times at once.

272

- Sounds have to be created with FSOUND_HW2D or FSOUND_HW3D for this to work.

273

- FSOUND_INIT_ENABLESYSTEMCHANNELFX can be used to apply hardware effect processing to the

274

global mixed output of FMOD's software channels.

275

- FSOUND_FX_Enable returns an FX handle that you can use to alter fx parameters.

276

- FSOUND_FX_Enable can be called multiple times in a row, even on the same FX type,

277

it will return a unique handle for each FX.

278

- FSOUND_FX_Enable cannot be called if the sound is playing or locked.

279

- Stopping or starting a sound resets all FX and they must be re-enabled each time

280

if this happens.

281

}

282

283

var

284

FSOUND_FX_Enable: function (Channel: Integer; Fx: TFSoundFXModes): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF}; { Set bits to enable following fx }

285

FSOUND_FX_Disable: function (Channel: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

286

287

FSOUND_FX_SetChorus: function (FXId: Integer; WetDryMix, Depth, Feedback, Frequency: Single; Waveform: Integer; Delay: Single; Phase: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

288

FSOUND_FX_SetCompressor: function (FXId: Integer; Gain, Attack, Release, Threshold, Ratio, Predelay: Single): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

289

FSOUND_FX_SetDistortion: function (FXId: Integer; Gain, Edge, PostEQCenterFrequency, PostEQBandwidth, PreLowpassCutoff: Single): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

290

FSOUND_FX_SetEcho: function (FXId: Integer; WetDryMix, Feedback, LeftDelay, RightDelay: Single; PanDelay: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

291

FSOUND_FX_SetFlanger: function (FXId: Integer; WetDryMix, Depth, Feedback, Frequency: Single; Waveform: Integer; Delay: Single; Phase: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

292

FSOUND_FX_SetGargle: function (FXId, RateHz, WaveShape: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

293

FSOUND_FX_SetI3DL2Reverb: function (FXId, Room, RoomHF: Integer; RoomRolloffFactor, DecayTime, DecayHFRatio: Single; Reflections: Integer; ReflectionsDelay: Single; Reverb: Integer; ReverbDelay, Diffusion, Density, HFReference: Single): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

294

FSOUND_FX_SetParamEQ: function (FXId: Integer; Center, Bandwidth, Gain: Single): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

295

FSOUND_FX_SetWavesReverb: function (FXId: Integer; InGain, ReverbMix, ReverbTime, HighFreqRTRatio: Single): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

296

297

{ ========================= }

298

{ File Streaming functions. }

299

{ ========================= }

300

301

{

302

Note : Use FSOUND_LOADMEMORY flag with FSOUND_Stream_Open to stream from memory.

303

Use FSOUND_LOADRAW flag with FSOUND_Stream_Open to treat stream as raw pcm data.

304

Use FSOUND_MPEGACCURATE flag with FSOUND_Stream_Open to open mpegs in 'accurate mode' for settime/gettime/getlengthms.

305

Use FSOUND_FREE as the 'channel' variable, to let FMOD pick a free channel for you.

306

}

307

308

var

309

// call this before opening streams, not after

310

FSOUND_Stream_SetBufferSize: function (Ms: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

311

312

FSOUND_Stream_Open: function(const name_or_data: PChar; Mode: Cardinal; Offset: Integer; Length: Integer): PFSoundStream; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

313

FSOUND_Stream_Create: function (Callback: TFSoundStreamCallback; Length: Integer; Mode: Cardinal; SampleRate: Integer; UserData: Integer): PFSoundStream; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

314

FSOUND_Stream_Close: function(Stream: PFSoundStream): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

315

316

FSOUND_Stream_Play: function(Channel: Integer; Stream: PFSoundStream): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

317

FSOUND_Stream_PlayEx: function (Channel: Integer; Stream: PFSoundStream; Dsp: PFSoundDSPUnit; StartPaused: ByteBool): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

318

FSOUND_Stream_Stop: function(Stream: PFSoundStream): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

319

320

FSOUND_Stream_SetPosition: function (Stream: PFSoundStream; Position: Cardinal): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

321

FSOUND_Stream_GetPosition: function (Stream: PFSoundStream): Cardinal; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

322

FSOUND_Stream_SetTime: function (Stream: PFSoundStream; Ms: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

323

FSOUND_Stream_GetTime: function (Stream: PFSoundStream): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

324

FSOUND_Stream_GetLength: function (Stream: PFSoundStream): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

325

FSOUND_Stream_GetLengthMs: function (Stream: PFSoundStream): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

326

327

FSOUND_Stream_SetMode: function (Stream: PFSoundStream; mode: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

328

FSOUND_Stream_GetMode: function (Stream: PFSoundStream): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

329

FSOUND_Stream_SetLoopPoints: function (Stream: PFSoundStream; LoopStartPCM, LoopEndPCM: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

330

FSOUND_Stream_SetLoopCount: function (Stream: PFSoundStream; Count: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

331

FSOUND_Stream_GetOpenState: function (Stream: PFSoundStream): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

332

FSOUND_Stream_GetSample: function (Stream: PFSoundStream): PFSoundSample; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF}; { Every stream contains a sample to play back on }

333

FSOUND_Stream_CreateDSP: function (Stream: PFSoundStream; Callback: TFSoundDSPCallback; Priority: Integer; Param: Integer): PFSoundDSPUnit; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

334

335

FSOUND_Stream_SetEndCallback: function (Stream: PFSoundStream; Callback: TFSoundStreamCallback; UserData: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

336

FSOUND_Stream_SetSyncCallback: function (Stream: PFSoundStream; Callback: TFSoundStreamCallback; UserData: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

337

338

FSOUND_Stream_AddSyncPoint: function (Stream: PFSoundStream; PCMOffset: Cardinal; Name: PChar): PFSyncPoint; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

339

FSOUND_Stream_DeleteSyncPoint: function (Point: PFSyncPoint): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

340

FSOUND_Stream_GetNumSyncPoints: function (Stream: PFSoundStream): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

341

FSOUND_Stream_GetSyncPoint: function (Stream: PFSoundStream; Index: Integer): PFSyncPoint; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

342

FSOUND_Stream_GetSyncPointInfo: function (Point: PFSyncPoint; var PCMOffset: Cardinal): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

343

344

FSOUND_Stream_SetSubStream: function (Stream: PFSoundStream; Index: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

345

FSOUND_Stream_GetNumSubStreams: function (Stream: PFSoundStream): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

346

FSOUND_Stream_SetSubStreamSentence: function (Stream: PFSoundStream; var sentencelist: Cardinal; numitems: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

347

348

FSOUND_Stream_GetNumTagFields: function (Stream: PFSoundStream; var Num: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

349

FSOUND_Stream_GetTagField: function (Stream: PFSoundStream; Num: Integer; var _Type: TFSoundTagFieldType; var Name: PCHAR; var Value: Pointer; var Length: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

350

FSOUND_Stream_FindTagField: function (Stream: PFSoundStream; _Type: TFSoundTagFieldType; Name: PChar; var Value: Pointer; var Length: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

351

352

FSOUND_Stream_Net_SetProxy: function (Proxy: PChar): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

353

FSOUND_Stream_Net_GetLastServerStatus: function: PChar; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

354

FSOUND_Stream_Net_SetBufferProperties: function (BufferSize: Integer; PreBuffer_Percent: Integer; ReBuffer_Percent: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

355

FSOUND_Stream_Net_GetBufferProperties: function (var Buffersize: Integer; var PreBuffer_Percent: Integer; var ReBuffer_Percent: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

356

FSOUND_Stream_Net_SetMetadataCallback: function (Stream: PFSoundStream; Callback: TFMetaDataCallback; UserData: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

357

FSOUND_Stream_Net_GetStatus: function (Stream: PFSoundStream; var Status: TFSoundStreamNetStatus; var BufferPercentUsed: Integer; var BitRate: Integer; var Flags: Cardinal): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

358

359

{ =================== }

360

{ CD audio functions. }

361

{ =================== }

362

363

{

364

Note : 0 = default cdrom. Otherwise specify the drive letter, for example. 'D'.

365

}

366

367

var

368

FSOUND_CD_Play: function (Drive: Byte; Track: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

369

FSOUND_CD_SetPlayMode: procedure (Drive: Byte; Mode: Integer); {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

370

FSOUND_CD_Stop: function (Drive: Byte): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

371

FSOUND_CD_SetPaused: function (Drive: Byte; Paused: ByteBool): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

372

FSOUND_CD_SetVolume: function (Drive: Byte; Volume: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

373

FSOUND_CD_SetTrackTime: function (Drive: Byte; ms: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

374

FSOUND_CD_OpenTray: function (Drive: Byte; Open: Byte): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

375

376

var

377

FSOUND_CD_GetPaused: function (Drive: Byte): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

378

FSOUND_CD_GetTrack: function (Drive: Byte): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

379

FSOUND_CD_GetNumTracks: function (Drive: Byte): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

380

FSOUND_CD_GetVolume: function (Drive: Byte): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

381

FSOUND_CD_GetTrackLength: function (Drive: Byte; Track: Integer): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

382

FSOUND_CD_GetTrackTime: function (Drive: Byte): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

383

384

{ ============== }

385

{ DSP functions. }

386

{ ============== }

387

388

{

389

DSP Unit control and information functions.

390

}

391

392

var

393

FSOUND_DSP_Create: function (Callback: TFSoundDSPCallback; Priority: Integer; Param: Integer): PFSoundDSPUnit; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

394

FSOUND_DSP_Free: procedure (DSPUnit: PFSoundDSPUnit); {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

395

FSOUND_DSP_SetPriority: procedure (DSPUnit: PFSoundDSPUnit; Priority: Integer); {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

396

FSOUND_DSP_GetPriority: function (DSPUnit: PFSoundDSPUnit): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

397

FSOUND_DSP_SetActive: procedure (DSPUnit: PFSoundDSPUnit; Active: ByteBool); {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

398

FSOUND_DSP_GetActive: function (DSPUnit: PFSoundDSPUnit): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

399

400

{

401

Functions to get hold of FSOUND 'system DSP unit' handles.

402

}

403

404

var

405

FSOUND_DSP_GetClearUnit: function: PFSoundDSPUnit; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

406

FSOUND_DSP_GetSFXUnit: function: PFSoundDSPUnit; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

407

FSOUND_DSP_GetMusicUnit: function: PFSoundDSPUnit; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

408

FSOUND_DSP_GetClipAndCopyUnit: function: PFSoundDSPUnit; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

409

FSOUND_DSP_GetFFTUnit: function: PFSoundDSPUnit; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

410

411

{

412

Miscellaneous DSP functions

413

Note for the spectrum analysis function to work, you have to enable the FFT DSP unit with

414

the following code FSOUND_DSP_SetActive(FSOUND_DSP_GetFFTUnit(), TRUE);

415

It is off by default to save cpu usage.

416

}

417

418

var

419

FSOUND_DSP_MixBuffers: function (DestBuffer: Pointer; SrcBuffer: Pointer; Len: Integer; Freq: Integer; Vol: Integer; Pan: Integer; Mode: Cardinal): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

420

FSOUND_DSP_ClearMixBuffer: procedure; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

421

FSOUND_DSP_GetBufferLength: function: Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF}; { Length of each DSP update }

422

FSOUND_DSP_GetBufferLengthTotal: function: Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF}; { Total buffer length due to FSOUND_SetBufferSize }

423

FSOUND_DSP_GetSpectrum: function: PSingle; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF}; { Array of 512 floats - call FSOUND_DSP_SetActive(FSOUND_DSP_GetFFTUnit(), TRUE)) for this to work. }

424

425

{ ========================================================================== }

426

{ Reverb functions. (eax2/eax3 reverb) (NOT SUPPORTED IN UNIX/CE) }

427

{ ========================================================================== }

428

429

{

430

See structures above for definitions and information on the reverb parameters.

431

}

432

433

var

434

FSOUND_Reverb_SetProperties: function (const Prop: TFSoundReverbProperties): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

435

FSOUND_Reverb_GetProperties: function (var Prop: TFSoundReverbProperties): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

436

FSOUND_Reverb_SetChannelProperties: function (Channel: Integer; var Prop: TFSoundReverbChannelProperties): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

437

FSOUND_Reverb_GetChannelProperties: function (Channel: Integer; var Prop: TFSoundReverbChannelProperties): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

438

439

{ ================================================ }

440

{ Recording functions (NOT SUPPORTED IN UNIX/MAC) }

441

{ ================================================ }

442

443

{

444

Recording initialization functions

445

}

446

447

var

448

FSOUND_Record_SetDriver: function (OutputType: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

449

FSOUND_Record_GetNumDrivers: function: Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

450

FSOUND_Record_GetDriverName: function (Id: Integer): PChar; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

451

FSOUND_Record_GetDriver: function: Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

452

453

{

454

Recording functionality. Only one recording session will work at a time.

455

}

456

457

var

458

FSOUND_Record_StartSample: function (Sptr: PFSoundSample; Loop: ByteBool): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

459

FSOUND_Record_Stop: function: ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

460

FSOUND_Record_GetPosition: function: Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

461

462

{ ============================================================================================= }

463

{ FMUSIC API (MOD,S3M,XM,IT,MIDI PLAYBACK) }

464

{ ============================================================================================= }

465

466

{

467

Song management / playback functions.

468

}

469

470

var

471

FMUSIC_LoadSong: function (const Name: PChar): PFMusicModule; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

472

FMUSIC_LoadSongEx: function (Name_Or_Data: Pointer; Offset: Integer; Length: Integer; Mode: Cardinal; var SampleList: Integer; SampleListNum: Integer): PFMusicModule; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

473

FMUSIC_GetOpenState: function (Module: PFMusicModule): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

474

FMUSIC_FreeSong: function (Module: PFMusicModule): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

475

FMUSIC_PlaySong: function (Module: PFMusicModule): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

476

FMUSIC_StopSong: function (Module: PFMusicModule): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

477

FMUSIC_StopAllSongs: procedure; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

478

479

var

480

FMUSIC_SetZxxCallback: function (Module: PFMusicModule; Callback: TFMusicCallback): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

481

FMUSIC_SetRowCallback: function (Module: PFMusicModule; Callback: TFMusicCallback; RowStep: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

482

FMUSIC_SetOrderCallback: function (Module: PFMusicModule; Callback: TFMusicCallback; OrderStep: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

483

FMUSIC_SetInstCallback: function (Module: PFMusicModule; Callback: TFMusicCallback; Instrument: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

484

485

var

486

FMUSIC_SetSample: function (Module: PFMusicModule; SampNo: Integer; Sptr: PFSoundSample): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

487

FMUSIC_SetUserData: function (Module: PFMusicModule; userdata: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

488

FMUSIC_OptimizeChannels: function (Module: PFMusicModule; MaxChannels: Integer; MinVolume: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

489

490

{

491

Runtime song functions.

492

}

493

494

var

495

FMUSIC_SetReverb: function (Reverb: ByteBool): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

496

FMUSIC_SetLooping: function (Module: PFMusicModule; Looping: ByteBool): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

497

FMUSIC_SetOrder: function (Module: PFMusicModule; Order: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

498

FMUSIC_SetPaused: function (Module: PFMusicModule; Pause: ByteBool): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

499

FMUSIC_SetMasterVolume: function (Module: PFMusicModule; Volume: Integer): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

500

FMUSIC_SetMasterSpeed: function (Module: PFMusicModule; Speed: Single): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

501

FMUSIC_SetPanSeperation: function (Module: PFMusicModule; PanSep: Single): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

502

503

{

504

Static song information functions.

505

}

506

507

var

508

FMUSIC_GetName: function (Module: PFMusicModule): PCHAR; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

509

FMUSIC_GetType: function (Module: PFMusicModule): TFMusicTypes; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

510

FMUSIC_GetNumOrders: function (Module: PFMusicModule): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

511

FMUSIC_GetNumPatterns: function (Module: PFMusicModule): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

512

FMUSIC_GetNumInstruments: function (Module: PFMusicModule): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

513

FMUSIC_GetNumSamples: function (Module: PFMusicModule): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

514

FMUSIC_GetNumChannels: function (Module: PFMusicModule): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

515

FMUSIC_GetSample: function (Module: PFMusicModule; SampNo: Integer): PFSoundSample; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

516

FMUSIC_GetPatternLength: function (Module: PFMusicModule; OrderNo: Integer): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

517

518

{

519

Runtime song information.

520

}

521

522

var

523

FMUSIC_IsFinished: function (Module: PFMusicModule): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

524

FMUSIC_IsPlaying: function (Module: PFMusicModule): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

525

FMUSIC_GetMasterVolume: function (Module: PFMusicModule): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

526

FMUSIC_GetGlobalVolume: function (Module: PFMusicModule): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

527

FMUSIC_GetOrder: function (Module: PFMusicModule): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

528

FMUSIC_GetPattern: function (Module: PFMusicModule): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

529

FMUSIC_GetSpeed: function (Module: PFMusicModule): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

530

FMUSIC_GetBPM: function (Module: PFMusicModule): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

531

FMUSIC_GetRow: function (Module: PFMusicModule): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

532

FMUSIC_GetPaused: function (Module: PFMusicModule): ByteBool; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

533

FMUSIC_GetTime: function (Module: PFMusicModule): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

534

FMUSIC_GetRealChannel: function (Module: PFMusicModule; ModChannel: Integer): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

535

FMUSIC_GetUserData: function (Module: PFMusicModule): Integer; {$IFDEF UNIX} cdecl {$ELSE} stdcall {$ENDIF};

536

537

implementation

538

539

{$IFDEF UNIX}

540

uses

541

dl; //Libc;

542

{$ENDIF}

543

544

const

545

{$IFDEF UNIX}

546

FMOD_DLL = 'libfmod.so';

547

{$ENDIF}

548

{$IFDEF WINDOWS}

549

FMOD_DLL = 'fmod.dll';

550

{$ENDIF}

551

552

type

553

{$IFDEF UNIX}

554

TFMODModuleHandle = Pointer;

555

{$ELSE}

556

TFMODModuleHandle = HINST;

557

{$ENDIF}

558

559

const

560

{$IFDEF UNIX}

561

INVALID_MODULEHANDLE_VALUE = TFMODModuleHandle(nil);

562

{$ELSE}

563

INVALID_MODULEHANDLE_VALUE = TFMODModuleHandle(0);

564

{$ENDIF}

565

566

var

567

FMODHandle: TFMODModuleHandle;

568

569

function GetAddress(Handle: TFMODModuleHandle; FuncName: PChar): Pointer;

570

begin

571

{$IFDEF WINDOWS}

572

Result := GetProcAddress(Handle, FuncName);

573

{$ELSE}

574

Result := dlsym(Handle, FuncName);

575

{$ENDIF}

576

Assert(Result <> nil, 'Failed to find ' + FuncName + ' in ' + FMOD_DLL);

577

end;

578

579

function FMOD_Load(LibName: PChar): Boolean;

580

begin

581

Result := False;

582

583

{ Make sure the previous library is unloaded }

584

FMOD_Unload;

585

586

{ If no library name given, use the default library names }

587

if (LibName = nil) or (LibName='') then

588

LibName := FMOD_DLL;

589

writeln('loading');

590

{ Load the library }

591

{$IFDEF WINDOWS}

592

FMODHandle := LoadLibrary(LibName);

593

{$ELSE}

594

FMODHandle := dlopen(LibName, RTLD_NOW);

595

{$ENDIF}

596

597

if FMODHandle = INVALID_MODULEHANDLE_VALUE then

598

Exit;

599

600

{$IFDEF WINDOWS}

601

{ Get all the function addresses from the library }

602

pointer(FSOUND_SetOutput) := GetAddress(FMODHandle, '_FSOUND_SetOutput@4');

603

pointer(FSOUND_SetDriver) := GetAddress(FMODHandle, '_FSOUND_SetDriver@4');

604

pointer(FSOUND_SetMixer) := GetAddress(FMODHandle, '_FSOUND_SetMixer@4');

605

pointer(FSOUND_SetBufferSize) := GetAddress(FMODHandle, '_FSOUND_SetBufferSize@4');

606

pointer(FSOUND_SetHWND) := GetAddress(FMODHandle, '_FSOUND_SetHWND@4');

607

pointer(FSOUND_SetMinHardwareChannels) := GetAddress(FMODHandle, '_FSOUND_SetMinHardwareChannels@4');

608

pointer(FSOUND_SetMaxHardwareChannels) := GetAddress(FMODHandle, '_FSOUND_SetMaxHardwareChannels@4');

609

pointer(FSOUND_SetMemorySystem) := GetAddress(FMODHandle, '_FSOUND_SetMemorySystem@20');

610

pointer(FSOUND_Init) := GetAddress(FMODHandle, '_FSOUND_Init@12');

611

pointer(FSOUND_Close) := GetAddress(FMODHandle, '_FSOUND_Close@0');

612

pointer(FSOUND_Update) := GetAddress(FMODHandle, '_FSOUND_Update@0');

613

pointer(FSOUND_SetSpeakerMode) := GetAddress(FMODHandle, '_FSOUND_SetSpeakerMode@4');

614

pointer(FSOUND_SetSFXMasterVolume) := GetAddress(FMODHandle, '_FSOUND_SetSFXMasterVolume@4');

615

pointer(FSOUND_SetPanSeperation) := GetAddress(FMODHandle, '_FSOUND_SetPanSeperation@4');

616

pointer(FSOUND_GetError) := GetAddress(FMODHandle, '_FSOUND_GetError@0');

617

pointer(FSOUND_GetVersion) := GetAddress(FMODHandle, '_FSOUND_GetVersion@0');

618

pointer(FSOUND_GetOutput) := GetAddress(FMODHandle, '_FSOUND_GetOutput@0');

619

pointer(FSOUND_GetOutputHandle) := GetAddress(FMODHandle, '_FSOUND_GetOutputHandle@0');

620

pointer(FSOUND_GetDriver) := GetAddress(FMODHandle, '_FSOUND_GetDriver@0');

621

pointer(FSOUND_GetMixer) := GetAddress(FMODHandle, '_FSOUND_GetMixer@0');

622

pointer(FSOUND_GetNumDrivers) := GetAddress(FMODHandle, '_FSOUND_GetNumDrivers@0');

623

pointer(FSOUND_GetDriverName) := GetAddress(FMODHandle, '_FSOUND_GetDriverName@4');

624

pointer(FSOUND_GetDriverCaps) := GetAddress(FMODHandle, '_FSOUND_GetDriverCaps@8');

625

pointer(FSOUND_GetOutputRate) := GetAddress(FMODHandle, '_FSOUND_GetOutputRate@0');

626

pointer(FSOUND_GetMaxChannels) := GetAddress(FMODHandle, '_FSOUND_GetMaxChannels@0');

627

pointer(FSOUND_GetMaxSamples) := GetAddress(FMODHandle, '_FSOUND_GetMaxSamples@0');

628

pointer(FSOUND_GetSpeakerMode) := GetAddress(FMODHandle, '_FSOUND_GetSpeakerMode@0');

629

pointer(FSOUND_GetSFXMasterVolume) := GetAddress(FMODHandle, '_FSOUND_GetSFXMasterVolume@0');

630

pointer(FSOUND_GetNumHWChannels) := GetAddress(FMODHandle, '_FSOUND_GetNumHWChannels@12');

631

pointer(FSOUND_GetChannelsPlaying) := GetAddress(FMODHandle, '_FSOUND_GetChannelsPlaying@0');

632

pointer(FSOUND_GetCPUUsage) := GetAddress(FMODHandle, '_FSOUND_GetCPUUsage@0');

633

pointer(FSOUND_GetMemoryStats) := GetAddress(FMODHandle, '_FSOUND_GetMemoryStats@8');

634

pointer(FSOUND_Sample_Load) := GetAddress(FMODHandle, '_FSOUND_Sample_Load@20');

635

pointer(FSOUND_Sample_Alloc) := GetAddress(FMODHandle, '_FSOUND_Sample_Alloc@28');

636

pointer(FSOUND_Sample_Free) := GetAddress(FMODHandle, '_FSOUND_Sample_Free@4');

637

pointer(FSOUND_Sample_Upload) := GetAddress(FMODHandle, '_FSOUND_Sample_Upload@12');

638

pointer(FSOUND_Sample_Lock) := GetAddress(FMODHandle, '_FSOUND_Sample_Lock@28');

639

pointer(FSOUND_Sample_Unlock) := GetAddress(FMODHandle, '_FSOUND_Sample_Unlock@20');

640

pointer(FSOUND_Sample_SetMode) := GetAddress(FMODHandle, '_FSOUND_Sample_SetMode@8');

641

pointer(FSOUND_Sample_SetLoopPoints) := GetAddress(FMODHandle, '_FSOUND_Sample_SetLoopPoints@12');

642

pointer(FSOUND_Sample_SetDefaults) := GetAddress(FMODHandle, '_FSOUND_Sample_SetDefaults@20');

643

pointer(FSOUND_Sample_SetDefaultsEx) := GetAddress(FMODHandle, '_FSOUND_Sample_SetDefaultsEx@32');

644

pointer(FSOUND_Sample_SetMinMaxDistance) := GetAddress(FMODHandle, '_FSOUND_Sample_SetMinMaxDistance@12');

645

pointer(FSOUND_Sample_SetMaxPlaybacks) := GetAddress(FMODHandle, '_FSOUND_Sample_SetMaxPlaybacks@8');

646

pointer(FSOUND_Sample_Get) := GetAddress(FMODHandle, '_FSOUND_Sample_Get@4');

647

pointer(FSOUND_Sample_GetName) := GetAddress(FMODHandle, '_FSOUND_Sample_GetName@4');

648

pointer(FSOUND_Sample_GetLength) := GetAddress(FMODHandle, '_FSOUND_Sample_GetLength@4');

649

pointer(FSOUND_Sample_GetLoopPoints) := GetAddress(FMODHandle, '_FSOUND_Sample_GetLoopPoints@12');

650

pointer(FSOUND_Sample_GetDefaults) := GetAddress(FMODHandle, '_FSOUND_Sample_GetDefaults@20');

651

pointer(FSOUND_Sample_GetDefaultsEx) := GetAddress(FMODHandle, '_FSOUND_Sample_GetDefaultsEx@32');

652

pointer(FSOUND_Sample_GetMode) := GetAddress(FMODHandle, '_FSOUND_Sample_GetMode@4');

653

pointer(FSOUND_Sample_GetMinMaxDistance) := GetAddress(FMODHandle, '_FSOUND_Sample_GetMinMaxDistance@12');

654

pointer(FSOUND_PlaySound) := GetAddress(FMODHandle, '_FSOUND_PlaySound@8');

655

pointer(FSOUND_PlaySoundEx) := GetAddress(FMODHandle, '_FSOUND_PlaySoundEx@16');

656

pointer(FSOUND_StopSound) := GetAddress(FMODHandle, '_FSOUND_StopSound@4');

657

pointer(FSOUND_SetFrequency) := GetAddress(FMODHandle, '_FSOUND_SetFrequency@8');

658

pointer(FSOUND_SetVolume) := GetAddress(FMODHandle, '_FSOUND_SetVolume@8');

659

pointer(FSOUND_SetVolumeAbsolute) := GetAddress(FMODHandle, '_FSOUND_SetVolumeAbsolute@8');

660

pointer(FSOUND_SetPan) := GetAddress(FMODHandle, '_FSOUND_SetPan@8');

661

pointer(FSOUND_SetSurround) := GetAddress(FMODHandle, '_FSOUND_SetSurround@8');

662

pointer(FSOUND_SetMute) := GetAddress(FMODHandle, '_FSOUND_SetMute@8');

663

pointer(FSOUND_SetPriority) := GetAddress(FMODHandle, '_FSOUND_SetPriority@8');

664

pointer(FSOUND_SetReserved) := GetAddress(FMODHandle, '_FSOUND_SetReserved@8');

665

pointer(FSOUND_SetPaused) := GetAddress(FMODHandle, '_FSOUND_SetPaused@8');

666

pointer(FSOUND_SetLoopMode) := GetAddress(FMODHandle, '_FSOUND_SetLoopMode@8');

667

pointer(FSOUND_SetCurrentPosition) := GetAddress(FMODHandle, '_FSOUND_SetCurrentPosition@8');

668

pointer(FSOUND_3D_SetAttributes) := GetAddress(FMODHandle, '_FSOUND_3D_SetAttributes@12');

669

pointer(FSOUND_3D_SetMinMaxDistance) := GetAddress(FMODHandle, '_FSOUND_3D_SetMinMaxDistance@12');

670

pointer(FSOUND_IsPlaying) := GetAddress(FMODHandle, '_FSOUND_IsPlaying@4');

671

pointer(FSOUND_GetFrequency) := GetAddress(FMODHandle, '_FSOUND_GetFrequency@4');

672

pointer(FSOUND_GetVolume) := GetAddress(FMODHandle, '_FSOUND_GetVolume@4');

673

pointer(FSOUND_GetAmplitude) := GetAddress(FMODHandle, '_FSOUND_GetAmplitude@4');

674

pointer(FSOUND_GetPan) := GetAddress(FMODHandle, '_FSOUND_GetPan@4');

675

pointer(FSOUND_GetSurround) := GetAddress(FMODHandle, '_FSOUND_GetSurround@4');

676

pointer(FSOUND_GetMute) := GetAddress(FMODHandle, '_FSOUND_GetMute@4');

677

pointer(FSOUND_GetPriority) := GetAddress(FMODHandle, '_FSOUND_GetPriority@4');

678

pointer(FSOUND_GetReserved) := GetAddress(FMODHandle, '_FSOUND_GetReserved@4');

679

pointer(FSOUND_GetPaused) := GetAddress(FMODHandle, '_FSOUND_GetPaused@4');

680

pointer(FSOUND_GetLoopMode) := GetAddress(FMODHandle, '_FSOUND_GetLoopMode@4');

681

pointer(FSOUND_GetCurrentPosition) := GetAddress(FMODHandle, '_FSOUND_GetCurrentPosition@4');

682

pointer(FSOUND_GetCurrentSample) := GetAddress(FMODHandle, '_FSOUND_GetCurrentSample@4');

683

pointer(FSOUND_GetCurrentLevels) := GetAddress(FMODHandle, '_FSOUND_GetCurrentLevels@12');

684

pointer(FSOUND_GetNumSubChannels) := GetAddress(FMODHandle, '_FSOUND_GetNumSubChannels@4');

685

pointer(FSOUND_GetSubChannel) := GetAddress(FMODHandle, '_FSOUND_GetSubChannel@8');

686

pointer(FSOUND_3D_GetAttributes) := GetAddress(FMODHandle, '_FSOUND_3D_GetAttributes@12');

687

pointer(FSOUND_3D_GetMinMaxDistance) := GetAddress(FMODHandle, '_FSOUND_3D_GetMinMaxDistance@12');

688

pointer(FSOUND_3D_Listener_SetCurrent) := GetAddress(FMODHandle, '_FSOUND_3D_Listener_SetCurrent@8');

689

pointer(FSOUND_3D_Listener_SetAttributes) := GetAddress(FMODHandle, '_FSOUND_3D_Listener_SetAttributes@32');

690

pointer(FSOUND_3D_Listener_GetAttributes) := GetAddress(FMODHandle, '_FSOUND_3D_Listener_GetAttributes@32');

691

pointer(FSOUND_3D_SetDopplerFactor) := GetAddress(FMODHandle, '_FSOUND_3D_SetDopplerFactor@4');

692

pointer(FSOUND_3D_SetDistanceFactor) := GetAddress(FMODHandle, '_FSOUND_3D_SetDistanceFactor@4');

693

pointer(FSOUND_3D_SetRolloffFactor) := GetAddress(FMODHandle, '_FSOUND_3D_SetRolloffFactor@4');

694

pointer(FSOUND_FX_Enable) := GetAddress(FMODHandle, '_FSOUND_FX_Enable@8');

695

pointer(FSOUND_FX_SetChorus) := GetAddress(FMODHandle, '_FSOUND_FX_SetChorus@32');

696

pointer(FSOUND_FX_SetCompressor) := GetAddress(FMODHandle, '_FSOUND_FX_SetCompressor@28');

697

pointer(FSOUND_FX_SetDistortion) := GetAddress(FMODHandle, '_FSOUND_FX_SetDistortion@24');

698

pointer(FSOUND_FX_SetEcho) := GetAddress(FMODHandle, '_FSOUND_FX_SetEcho@24');

699

pointer(FSOUND_FX_SetFlanger) := GetAddress(FMODHandle, '_FSOUND_FX_SetFlanger@32');

700

pointer(FSOUND_FX_SetGargle) := GetAddress(FMODHandle, '_FSOUND_FX_SetGargle@12');

701

pointer(FSOUND_FX_SetI3DL2Reverb) := GetAddress(FMODHandle, '_FSOUND_FX_SetI3DL2Reverb@52');

702

pointer(FSOUND_FX_SetParamEQ) := GetAddress(FMODHandle, '_FSOUND_FX_SetParamEQ@16');

703

pointer(FSOUND_FX_SetWavesReverb) := GetAddress(FMODHandle, '_FSOUND_FX_SetWavesReverb@20');

704

pointer(FSOUND_Stream_Open) := GetAddress(FMODHandle, '_FSOUND_Stream_Open@16');

705

pointer(FSOUND_Stream_Create) := GetAddress(FMODHandle, '_FSOUND_Stream_Create@20');

706

pointer(FSOUND_Stream_Close) := GetAddress(FMODHandle, '_FSOUND_Stream_Close@4');

707

pointer(FSOUND_Stream_Play) := GetAddress(FMODHandle, '_FSOUND_Stream_Play@8');

708

pointer(FSOUND_Stream_PlayEx) := GetAddress(FMODHandle, '_FSOUND_Stream_PlayEx@16');

709

pointer(FSOUND_Stream_Stop) := GetAddress(FMODHandle, '_FSOUND_Stream_Stop@4');

710

pointer(FSOUND_Stream_SetEndCallback) := GetAddress(FMODHandle, '_FSOUND_Stream_SetEndCallback@12');

711

pointer(FSOUND_Stream_SetSyncCallback) := GetAddress(FMODHandle, '_FSOUND_Stream_SetSyncCallback@12');

712

pointer(FSOUND_Stream_GetSample) := GetAddress(FMODHandle, '_FSOUND_Stream_GetSample@4');

713

pointer(FSOUND_Stream_CreateDSP) := GetAddress(FMODHandle, '_FSOUND_Stream_CreateDSP@16');

714

pointer(FSOUND_Stream_SetBufferSize) := GetAddress(FMODHandle, '_FSOUND_Stream_SetBufferSize@4');

715

pointer(FSOUND_Stream_SetPosition) := GetAddress(FMODHandle, '_FSOUND_Stream_SetPosition@8');

716

pointer(FSOUND_Stream_GetPosition) := GetAddress(FMODHandle, '_FSOUND_Stream_GetPosition@4');

717

pointer(FSOUND_Stream_SetTime) := GetAddress(FMODHandle, '_FSOUND_Stream_SetTime@8');

718

pointer(FSOUND_Stream_GetTime) := GetAddress(FMODHandle, '_FSOUND_Stream_GetTime@4');

719

pointer(FSOUND_Stream_GetLength) := GetAddress(FMODHandle, '_FSOUND_Stream_GetLength@4');

720

pointer(FSOUND_Stream_GetLengthMs) := GetAddress(FMODHandle, '_FSOUND_Stream_GetLengthMs@4');

721

pointer(FSOUND_Stream_SetMode) := GetAddress(FMODHandle, '_FSOUND_Stream_SetMode@8');

722

pointer(FSOUND_Stream_GetMode) := GetAddress(FMODHandle, '_FSOUND_Stream_GetMode@4');

723

pointer(FSOUND_Stream_SetLoopPoints) := GetAddress(FMODHandle, '_FSOUND_Stream_SetLoopPoints@12');

724

pointer(FSOUND_Stream_SetLoopCount) := GetAddress(FMODHandle, '_FSOUND_Stream_SetLoopCount@8');

725

pointer(FSOUND_Stream_GetOpenState) := GetAddress(FMODHandle, '_FSOUND_Stream_GetOpenState@4');

726

pointer(FSOUND_Stream_AddSyncPoint) := GetAddress(FMODHandle, '_FSOUND_Stream_AddSyncPoint@12');

727

pointer(FSOUND_Stream_DeleteSyncPoint) := GetAddress(FMODHandle, '_FSOUND_Stream_DeleteSyncPoint@4');

728

pointer(FSOUND_Stream_GetNumSyncPoints) := GetAddress(FMODHandle, '_FSOUND_Stream_GetNumSyncPoints@4');

729

pointer(FSOUND_Stream_GetSyncPoint) := GetAddress(FMODHandle, '_FSOUND_Stream_GetSyncPoint@8');

730

pointer(FSOUND_Stream_GetSyncPointInfo) := GetAddress(FMODHandle, '_FSOUND_Stream_GetSyncPointInfo@8');

731

pointer(FSOUND_Stream_SetSubStream) := GetAddress(FMODHandle, '_FSOUND_Stream_SetSubStream@8');

732

pointer(FSOUND_Stream_GetNumSubStreams) := GetAddress(FMODHandle, '_FSOUND_Stream_GetNumSubStreams@4');

733

pointer(FSOUND_Stream_SetSubStreamSentence) := GetAddress(FMODHandle, '_FSOUND_Stream_SetSubStreamSentence@12');

734

pointer(FSOUND_Stream_GetNumTagFields) := GetAddress(FMODHandle, '_FSOUND_Stream_GetNumTagFields@8');

735

pointer(FSOUND_Stream_GetTagField) := GetAddress(FMODHandle, '_FSOUND_Stream_GetTagField@24');

736

pointer(FSOUND_Stream_FindTagField) := GetAddress(FMODHandle, '_FSOUND_Stream_FindTagField@20');

737

pointer(FSOUND_Stream_Net_SetProxy) := GetAddress(FMODHandle, '_FSOUND_Stream_Net_SetProxy@4');

738

pointer(FSOUND_Stream_Net_GetLastServerStatus) := GetAddress(FMODHandle, '_FSOUND_Stream_Net_GetLastServerStatus@0');

739

pointer(FSOUND_Stream_Net_SetBufferProperties) := GetAddress(FMODHandle, '_FSOUND_Stream_Net_SetBufferProperties@12');

740

pointer(FSOUND_Stream_Net_GetBufferProperties) := GetAddress(FMODHandle, '_FSOUND_Stream_Net_GetBufferProperties@12');

741

pointer(FSOUND_Stream_Net_SetMetadataCallback) := GetAddress(FMODHandle, '_FSOUND_Stream_Net_SetMetadataCallback@12');

742

pointer(FSOUND_Stream_Net_GetStatus) := GetAddress(FMODHandle, '_FSOUND_Stream_Net_GetStatus@20');

743

pointer(FSOUND_CD_Play) := GetAddress(FMODHandle, '_FSOUND_CD_Play@8');

744

pointer(FSOUND_CD_SetPlayMode) := GetAddress(FMODHandle, '_FSOUND_CD_SetPlayMode@8');

745

pointer(FSOUND_CD_Stop) := GetAddress(FMODHandle, '_FSOUND_CD_Stop@4');

746

pointer(FSOUND_CD_SetPaused) := GetAddress(FMODHandle, '_FSOUND_CD_SetPaused@8');

747

pointer(FSOUND_CD_SetVolume) := GetAddress(FMODHandle, '_FSOUND_CD_SetVolume@8');

748

pointer(FSOUND_CD_SetTrackTime) := GetAddress(FMODHandle, '_FSOUND_CD_SetTrackTime@8');

749

pointer(FSOUND_CD_OpenTray) := GetAddress(FMODHandle, '_FSOUND_CD_OpenTray@8');

750

pointer(FSOUND_CD_GetPaused) := GetAddress(FMODHandle, '_FSOUND_CD_GetPaused@4');

751

pointer(FSOUND_CD_GetTrack) := GetAddress(FMODHandle, '_FSOUND_CD_GetTrack@4');

752

pointer(FSOUND_CD_GetNumTracks) := GetAddress(FMODHandle, '_FSOUND_CD_GetNumTracks@4');

753

pointer(FSOUND_CD_GetVolume) := GetAddress(FMODHandle, '_FSOUND_CD_GetVolume@4');

754

pointer(FSOUND_CD_GetTrackLength) := GetAddress(FMODHandle, '_FSOUND_CD_GetTrackLength@8');

755

pointer(FSOUND_CD_GetTrackTime) := GetAddress(FMODHandle, '_FSOUND_CD_GetTrackTime@4');

756

pointer(FSOUND_DSP_Create) := GetAddress(FMODHandle, '_FSOUND_DSP_Create@12');

757

pointer(FSOUND_DSP_Free) := GetAddress(FMODHandle, '_FSOUND_DSP_Free@4');

758

pointer(FSOUND_DSP_SetPriority) := GetAddress(FMODHandle, '_FSOUND_DSP_SetPriority@8');

759

pointer(FSOUND_DSP_GetPriority) := GetAddress(FMODHandle, '_FSOUND_DSP_GetPriority@4');

760

pointer(FSOUND_DSP_SetActive) := GetAddress(FMODHandle, '_FSOUND_DSP_SetActive@8');

761

pointer(FSOUND_DSP_GetActive) := GetAddress(FMODHandle, '_FSOUND_DSP_GetActive@4');

762

pointer(FSOUND_DSP_GetClearUnit) := GetAddress(FMODHandle, '_FSOUND_DSP_GetClearUnit@0');

763

pointer(FSOUND_DSP_GetSFXUnit) := GetAddress(FMODHandle, '_FSOUND_DSP_GetSFXUnit@0');

764

pointer(FSOUND_DSP_GetMusicUnit) := GetAddress(FMODHandle, '_FSOUND_DSP_GetMusicUnit@0');

765

pointer(FSOUND_DSP_GetClipAndCopyUnit) := GetAddress(FMODHandle, '_FSOUND_DSP_GetClipAndCopyUnit@0');

766

pointer(FSOUND_DSP_GetFFTUnit) := GetAddress(FMODHandle, '_FSOUND_DSP_GetFFTUnit@0');

767

pointer(FSOUND_DSP_MixBuffers) := GetAddress(FMODHandle, '_FSOUND_DSP_MixBuffers@28');

768

pointer(FSOUND_DSP_ClearMixBuffer) := GetAddress(FMODHandle, '_FSOUND_DSP_ClearMixBuffer@0');

769

pointer(FSOUND_DSP_GetBufferLength) := GetAddress(FMODHandle, '_FSOUND_DSP_GetBufferLength@0');

770

pointer(FSOUND_DSP_GetBufferLengthTotal) := GetAddress(FMODHandle, '_FSOUND_DSP_GetBufferLengthTotal@0');

771

pointer(FSOUND_DSP_GetSpectrum) := GetAddress(FMODHandle, '_FSOUND_DSP_GetSpectrum@0');

772

pointer(FSOUND_Reverb_SetProperties) := GetAddress(FMODHandle, '_FSOUND_Reverb_SetProperties@4');

773

pointer(FSOUND_Reverb_GetProperties) := GetAddress(FMODHandle, '_FSOUND_Reverb_GetProperties@4');

774

pointer(FSOUND_Reverb_SetChannelProperties) := GetAddress(FMODHandle, '_FSOUND_Reverb_SetChannelProperties@8');

775

pointer(FSOUND_Reverb_GetChannelProperties) := GetAddress(FMODHandle, '_FSOUND_Reverb_GetChannelProperties@8');

776

pointer(FSOUND_Record_SetDriver) := GetAddress(FMODHandle, '_FSOUND_Record_SetDriver@4');

777

pointer(FSOUND_Record_GetNumDrivers) := GetAddress(FMODHandle, '_FSOUND_Record_GetNumDrivers@0');

778

pointer(FSOUND_Record_GetDriverName) := GetAddress(FMODHandle, '_FSOUND_Record_GetDriverName@4');

779

pointer(FSOUND_Record_GetDriver) := GetAddress(FMODHandle, '_FSOUND_Record_GetDriver@0');

780

pointer(FSOUND_Record_StartSample) := GetAddress(FMODHandle, '_FSOUND_Record_StartSample@8');

781

pointer(FSOUND_Record_Stop) := GetAddress(FMODHandle, '_FSOUND_Record_Stop@0');

782

pointer(FSOUND_Record_GetPosition) := GetAddress(FMODHandle, '_FSOUND_Record_GetPosition@0');

783

pointer(FSOUND_File_SetCallbacks) := GetAddress(FMODHandle, '_FSOUND_File_SetCallbacks@20');

784

pointer(FMUSIC_LoadSong) := GetAddress(FMODHandle, '_FMUSIC_LoadSong@4');

785

pointer(FMUSIC_LoadSongEx) := GetAddress(FMODHandle, '_FMUSIC_LoadSongEx@24');

786

pointer(FMUSIC_GetOpenState) := GetAddress(FMODHandle, '_FMUSIC_GetOpenState@4');

787

pointer(FMUSIC_FreeSong) := GetAddress(FMODHandle, '_FMUSIC_FreeSong@4');

788

pointer(FMUSIC_PlaySong) := GetAddress(FMODHandle, '_FMUSIC_PlaySong@4');

789

pointer(FMUSIC_StopSong) := GetAddress(FMODHandle, '_FMUSIC_StopSong@4');

790

pointer(FMUSIC_StopAllSongs) := GetAddress(FMODHandle, '_FMUSIC_StopAllSongs@0');

791

pointer(FMUSIC_SetZxxCallback) := GetAddress(FMODHandle, '_FMUSIC_SetZxxCallback@8');

792

pointer(FMUSIC_SetRowCallback) := GetAddress(FMODHandle, '_FMUSIC_SetRowCallback@12');

793

pointer(FMUSIC_SetOrderCallback) := GetAddress(FMODHandle, '_FMUSIC_SetOrderCallback@12');

794

pointer(FMUSIC_SetInstCallback) := GetAddress(FMODHandle, '_FMUSIC_SetInstCallback@12');

795

pointer(FMUSIC_SetSample) := GetAddress(FMODHandle, '_FMUSIC_SetSample@12');

796

pointer(FMUSIC_SetUserData) := GetAddress(FMODHandle, '_FMUSIC_SetUserData@8');

797

pointer(FMUSIC_OptimizeChannels) := GetAddress(FMODHandle, '_FMUSIC_OptimizeChannels@12');

798

pointer(FMUSIC_SetReverb) := GetAddress(FMODHandle, '_FMUSIC_SetReverb@4');

799

pointer(FMUSIC_SetLooping) := GetAddress(FMODHandle, '_FMUSIC_SetLooping@8');

800

pointer(FMUSIC_SetOrder) := GetAddress(FMODHandle, '_FMUSIC_SetOrder@8');

801

pointer(FMUSIC_SetPaused) := GetAddress(FMODHandle, '_FMUSIC_SetPaused@8');

802

pointer(FMUSIC_SetMasterVolume) := GetAddress(FMODHandle, '_FMUSIC_SetMasterVolume@8');

803

pointer(FMUSIC_SetMasterSpeed) := GetAddress(FMODHandle, '_FMUSIC_SetMasterSpeed@8');

804

pointer(FMUSIC_SetPanSeperation) := GetAddress(FMODHandle, '_FMUSIC_SetPanSeperation@8');

805

pointer(FMUSIC_GetName) := GetAddress(FMODHandle, '_FMUSIC_GetName@4');

806

pointer(FMUSIC_GetType) := GetAddress(FMODHandle, '_FMUSIC_GetType@4');

807

pointer(FMUSIC_GetNumOrders) := GetAddress(FMODHandle, '_FMUSIC_GetNumOrders@4');

808

pointer(FMUSIC_GetNumPatterns) := GetAddress(FMODHandle, '_FMUSIC_GetNumPatterns@4');

809

pointer(FMUSIC_GetNumInstruments) := GetAddress(FMODHandle, '_FMUSIC_GetNumInstruments@4');

810

pointer(FMUSIC_GetNumSamples) := GetAddress(FMODHandle, '_FMUSIC_GetNumSamples@4');

811

pointer(FMUSIC_GetNumChannels) := GetAddress(FMODHandle, '_FMUSIC_GetNumChannels@4');

812

pointer(FMUSIC_GetSample) := GetAddress(FMODHandle, '_FMUSIC_GetSample@8');

813

pointer(FMUSIC_GetPatternLength) := GetAddress(FMODHandle, '_FMUSIC_GetPatternLength@8');

814

pointer(FMUSIC_IsFinished) := GetAddress(FMODHandle, '_FMUSIC_IsFinished@4');

815

pointer(FMUSIC_IsPlaying) := GetAddress(FMODHandle, '_FMUSIC_IsPlaying@4');

816

pointer(FMUSIC_GetMasterVolume) := GetAddress(FMODHandle, '_FMUSIC_GetMasterVolume@4');

817

pointer(FMUSIC_GetGlobalVolume) := GetAddress(FMODHandle, '_FMUSIC_GetGlobalVolume@4');

818

pointer(FMUSIC_GetOrder) := GetAddress(FMODHandle, '_FMUSIC_GetOrder@4');

819

pointer(FMUSIC_GetPattern) := GetAddress(FMODHandle, '_FMUSIC_GetPattern@4');

820

pointer(FMUSIC_GetSpeed) := GetAddress(FMODHandle, '_FMUSIC_GetSpeed@4');

821

pointer(FMUSIC_GetBPM) := GetAddress(FMODHandle, '_FMUSIC_GetBPM@4');

822

pointer(FMUSIC_GetRow) := GetAddress(FMODHandle, '_FMUSIC_GetRow@4');

823

pointer(FMUSIC_GetPaused) := GetAddress(FMODHandle, '_FMUSIC_GetPaused@4');

824

pointer(FMUSIC_GetTime) := GetAddress(FMODHandle, '_FMUSIC_GetTime@4');

825

pointer(FMUSIC_GetRealChannel) := GetAddress(FMODHandle, '_FMUSIC_GetRealChannel@8');

826

pointer(FMUSIC_GetUserData) := GetAddress(FMODHandle, '_FMUSIC_GetUserData@4');

827

{$ELSE}

828

pointer(FSOUND_SetOutput) := GetAddress(FMODHandle, 'FSOUND_SetOutput');

829

pointer(FSOUND_SetDriver) := GetAddress(FMODHandle, 'FSOUND_SetDriver');

830

pointer(FSOUND_SetMixer) := GetAddress(FMODHandle, 'FSOUND_SetMixer');

831

pointer(FSOUND_SetBufferSize) := GetAddress(FMODHandle, 'FSOUND_SetBufferSize');

832

pointer(FSOUND_SetHWND) := GetAddress(FMODHandle, 'FSOUND_SetHWND');

833

pointer(FSOUND_SetMinHardwareChannels) := GetAddress(FMODHandle, 'FSOUND_SetMinHardwareChannels');

834

pointer(FSOUND_SetMaxHardwareChannels) := GetAddress(FMODHandle, 'FSOUND_SetMaxHardwareChannels');

835

pointer(FSOUND_SetMemorySystem) := GetAddress(FMODHandle, 'FSOUND_SetMemorySystem');

836

pointer(FSOUND_Init) := GetAddress(FMODHandle, 'FSOUND_Init');

837

pointer(FSOUND_Close) := GetAddress(FMODHandle, 'FSOUND_Close');

838

pointer(FSOUND_Update) := GetAddress(FMODHandle, 'FSOUND_Update');

839

pointer(FSOUND_SetSpeakerMode) := GetAddress(FMODHandle, 'FSOUND_SetSpeakerMode');

840

pointer(FSOUND_SetSFXMasterVolume) := GetAddress(FMODHandle, 'FSOUND_SetSFXMasterVolume');

841

pointer(FSOUND_SetPanSeperation) := GetAddress(FMODHandle, 'FSOUND_SetPanSeperation');

842

pointer(FSOUND_GetError) := GetAddress(FMODHandle, 'FSOUND_GetError');

843

pointer(FSOUND_GetVersion) := GetAddress(FMODHandle, 'FSOUND_GetVersion');

844

pointer(FSOUND_GetOutput) := GetAddress(FMODHandle, 'FSOUND_GetOutput');

845

pointer(FSOUND_GetOutputHandle) := GetAddress(FMODHandle, 'FSOUND_GetOutputHandle');

846

pointer(FSOUND_GetDriver) := GetAddress(FMODHandle, 'FSOUND_GetDriver');

847

pointer(FSOUND_GetMixer) := GetAddress(FMODHandle, 'FSOUND_GetMixer');

848

pointer(FSOUND_GetNumDrivers) := GetAddress(FMODHandle, 'FSOUND_GetNumDrivers');

849

pointer(FSOUND_GetDriverName) := GetAddress(FMODHandle, 'FSOUND_GetDriverName');

850

pointer(FSOUND_GetDriverCaps) := GetAddress(FMODHandle, 'FSOUND_GetDriverCaps');

851

pointer(FSOUND_GetOutputRate) := GetAddress(FMODHandle, 'FSOUND_GetOutputRate');

852

pointer(FSOUND_GetMaxChannels) := GetAddress(FMODHandle, 'FSOUND_GetMaxChannels');

853

pointer(FSOUND_GetMaxSamples) := GetAddress(FMODHandle, 'FSOUND_GetMaxSamples');

854

pointer(FSOUND_GetSpeakerMode) := GetAddress(FMODHandle, 'FSOUND_GetSpeakerMode');

855

pointer(FSOUND_GetSFXMasterVolume) := GetAddress(FMODHandle, 'FSOUND_GetSFXMasterVolume');

856

pointer(FSOUND_GetNumHWChannels) := GetAddress(FMODHandle, 'FSOUND_GetNumHWChannels');

857

pointer(FSOUND_GetChannelsPlaying) := GetAddress(FMODHandle, 'FSOUND_GetChannelsPlaying');

858

pointer(FSOUND_GetCPUUsage) := GetAddress(FMODHandle, 'FSOUND_GetCPUUsage');

859

pointer(FSOUND_GetMemoryStats) := GetAddress(FMODHandle, 'FSOUND_GetMemoryStats');

860

pointer(FSOUND_Sample_Load) := GetAddress(FMODHandle, 'FSOUND_Sample_Load');

861

pointer(FSOUND_Sample_Alloc) := GetAddress(FMODHandle, 'FSOUND_Sample_Alloc');

862

pointer(FSOUND_Sample_Free) := GetAddress(FMODHandle, 'FSOUND_Sample_Free');

863

pointer(FSOUND_Sample_Upload) := GetAddress(FMODHandle, 'FSOUND_Sample_Upload');

864

pointer(FSOUND_Sample_Lock) := GetAddress(FMODHandle, 'FSOUND_Sample_Lock');

865

pointer(FSOUND_Sample_Unlock) := GetAddress(FMODHandle, 'FSOUND_Sample_Unlock');

866

pointer(FSOUND_Sample_SetMode) := GetAddress(FMODHandle, 'FSOUND_Sample_SetMode');

867

pointer(FSOUND_Sample_SetLoopPoints) := GetAddress(FMODHandle, 'FSOUND_Sample_SetLoopPoints');

868

pointer(FSOUND_Sample_SetDefaults) := GetAddress(FMODHandle, 'FSOUND_Sample_SetDefaults');

869

pointer(FSOUND_Sample_SetDefaultsEx) := GetAddress(FMODHandle, 'FSOUND_Sample_SetDefaultsEx');

870

pointer(FSOUND_Sample_SetMinMaxDistance) := GetAddress(FMODHandle, 'FSOUND_Sample_SetMinMaxDistance');

871

pointer(FSOUND_Sample_SetMaxPlaybacks) := GetAddress(FMODHandle, 'FSOUND_Sample_SetMaxPlaybacks');

872

pointer(FSOUND_Sample_Get) := GetAddress(FMODHandle, 'FSOUND_Sample_Get');

873

pointer(FSOUND_Sample_GetName) := GetAddress(FMODHandle, 'FSOUND_Sample_GetName');

874

pointer(FSOUND_Sample_GetLength) := GetAddress(FMODHandle, 'FSOUND_Sample_GetLength');

875

pointer(FSOUND_Sample_GetLoopPoints) := GetAddress(FMODHandle, 'FSOUND_Sample_GetLoopPoints');

876

pointer(FSOUND_Sample_GetDefaults) := GetAddress(FMODHandle, 'FSOUND_Sample_GetDefaults');

877

pointer(FSOUND_Sample_GetDefaultsEx) := GetAddress(FMODHandle, 'FSOUND_Sample_GetDefaultsEx');

878

pointer(FSOUND_Sample_GetMode) := GetAddress(FMODHandle, 'FSOUND_Sample_GetMode');

879

pointer(FSOUND_Sample_GetMinMaxDistance) := GetAddress(FMODHandle, 'FSOUND_Sample_GetMinMaxDistance');

880

pointer(FSOUND_PlaySound) := GetAddress(FMODHandle, 'FSOUND_PlaySound');

881

pointer(FSOUND_PlaySoundEx) := GetAddress(FMODHandle, 'FSOUND_PlaySoundEx');

882

pointer(FSOUND_StopSound) := GetAddress(FMODHandle, 'FSOUND_StopSound');

883

pointer(FSOUND_SetFrequency) := GetAddress(FMODHandle, 'FSOUND_SetFrequency');

884

pointer(FSOUND_SetVolume) := GetAddress(FMODHandle, 'FSOUND_SetVolume');

885

pointer(FSOUND_SetVolumeAbsolute) := GetAddress(FMODHandle, 'FSOUND_SetVolumeAbsolute');

886

pointer(FSOUND_SetPan) := GetAddress(FMODHandle, 'FSOUND_SetPan');

887

pointer(FSOUND_SetSurround) := GetAddress(FMODHandle, 'FSOUND_SetSurround');

888

pointer(FSOUND_SetMute) := GetAddress(FMODHandle, 'FSOUND_SetMute');

889

pointer(FSOUND_SetPriority) := GetAddress(FMODHandle, 'FSOUND_SetPriority');

890

pointer(FSOUND_SetReserved) := GetAddress(FMODHandle, 'FSOUND_SetReserved');

891

pointer(FSOUND_SetPaused) := GetAddress(FMODHandle, 'FSOUND_SetPaused');

892

pointer(FSOUND_SetLoopMode) := GetAddress(FMODHandle, 'FSOUND_SetLoopMode');

893

pointer(FSOUND_SetCurrentPosition) := GetAddress(FMODHandle, 'FSOUND_SetCurrentPosition');

894

pointer(FSOUND_3D_SetAttributes) := GetAddress(FMODHandle, 'FSOUND_3D_SetAttributes');

895

pointer(FSOUND_3D_SetMinMaxDistance) := GetAddress(FMODHandle, 'FSOUND_3D_SetMinMaxDistance');

896

pointer(FSOUND_IsPlaying) := GetAddress(FMODHandle, 'FSOUND_IsPlaying');

897

pointer(FSOUND_GetFrequency) := GetAddress(FMODHandle, 'FSOUND_GetFrequency');

898

pointer(FSOUND_GetVolume) := GetAddress(FMODHandle, 'FSOUND_GetVolume');

899

pointer(FSOUND_GetAmplitude) := GetAddress(FMODHandle, 'FSOUND_GetAmplitude');

900

pointer(FSOUND_GetPan) := GetAddress(FMODHandle, 'FSOUND_GetPan');

901

pointer(FSOUND_GetSurround) := GetAddress(FMODHandle, 'FSOUND_GetSurround');

902

pointer(FSOUND_GetMute) := GetAddress(FMODHandle, 'FSOUND_GetMute');

903

pointer(FSOUND_GetPriority) := GetAddress(FMODHandle, 'FSOUND_GetPriority');

904

pointer(FSOUND_GetReserved) := GetAddress(FMODHandle, 'FSOUND_GetReserved');

905

pointer(FSOUND_GetPaused) := GetAddress(FMODHandle, 'FSOUND_GetPaused');

906

pointer(FSOUND_GetLoopMode) := GetAddress(FMODHandle, 'FSOUND_GetLoopMode');

907

pointer(FSOUND_GetCurrentPosition) := GetAddress(FMODHandle, 'FSOUND_GetCurrentPosition');

908

pointer(FSOUND_GetCurrentSample) := GetAddress(FMODHandle, 'FSOUND_GetCurrentSample');

909

pointer(FSOUND_GetCurrentLevels) := GetAddress(FMODHandle, 'FSOUND_GetCurrentLevels');

910

pointer(FSOUND_GetNumSubChannels) := GetAddress(FMODHandle, 'FSOUND_GetNumSubChannels');

911

pointer(FSOUND_GetSubChannel) := GetAddress(FMODHandle, 'FSOUND_GetSubChannel');

912

pointer(FSOUND_3D_GetAttributes) := GetAddress(FMODHandle, 'FSOUND_3D_GetAttributes');

913

pointer(FSOUND_3D_GetMinMaxDistance) := GetAddress(FMODHandle, 'FSOUND_3D_GetMinMaxDistance');

914

pointer(FSOUND_3D_Listener_SetCurrent) := GetAddress(FMODHandle, 'FSOUND_3D_Listener_SetCurrent');

915

pointer(FSOUND_3D_Listener_SetAttributes) := GetAddress(FMODHandle, 'FSOUND_3D_Listener_SetAttributes');

916

pointer(FSOUND_3D_Listener_GetAttributes) := GetAddress(FMODHandle, 'FSOUND_3D_Listener_GetAttributes');

917

pointer(FSOUND_3D_SetDopplerFactor) := GetAddress(FMODHandle, 'FSOUND_3D_SetDopplerFactor');

918

pointer(FSOUND_3D_SetDistanceFactor) := GetAddress(FMODHandle, 'FSOUND_3D_SetDistanceFactor');

919

pointer(FSOUND_3D_SetRolloffFactor) := GetAddress(FMODHandle, 'FSOUND_3D_SetRolloffFactor');

920

pointer(FSOUND_FX_Enable) := GetAddress(FMODHandle, 'FSOUND_FX_Enable');

921

pointer(FSOUND_FX_SetChorus) := GetAddress(FMODHandle, 'FSOUND_FX_SetChorus');

922

pointer(FSOUND_FX_SetCompressor) := GetAddress(FMODHandle, 'FSOUND_FX_SetCompressor');

923

pointer(FSOUND_FX_SetDistortion) := GetAddress(FMODHandle, 'FSOUND_FX_SetDistortion');

924

pointer(FSOUND_FX_SetEcho) := GetAddress(FMODHandle, 'FSOUND_FX_SetEcho');

925

pointer(FSOUND_FX_SetFlanger) := GetAddress(FMODHandle, 'FSOUND_FX_SetFlanger');

926

pointer(FSOUND_FX_SetGargle) := GetAddress(FMODHandle, 'FSOUND_FX_SetGargle');

927

pointer(FSOUND_FX_SetI3DL2Reverb) := GetAddress(FMODHandle, 'FSOUND_FX_SetI3DL2Reverb');

928

pointer(FSOUND_FX_SetParamEQ) := GetAddress(FMODHandle, 'FSOUND_FX_SetParamEQ');

929

pointer(FSOUND_FX_SetWavesReverb) := GetAddress(FMODHandle, 'FSOUND_FX_SetWavesReverb');

930

pointer(FSOUND_Stream_Open) := GetAddress(FMODHandle, 'FSOUND_Stream_Open');

931

pointer(FSOUND_Stream_Create) := GetAddress(FMODHandle, 'FSOUND_Stream_Create');

932

pointer(FSOUND_Stream_Close) := GetAddress(FMODHandle, 'FSOUND_Stream_Close');

933

pointer(FSOUND_Stream_Play) := GetAddress(FMODHandle, 'FSOUND_Stream_Play');

934

pointer(FSOUND_Stream_PlayEx) := GetAddress(FMODHandle, 'FSOUND_Stream_PlayEx');

935

pointer(FSOUND_Stream_Stop) := GetAddress(FMODHandle, 'FSOUND_Stream_Stop');

936

pointer(FSOUND_Stream_SetEndCallback) := GetAddress(FMODHandle, 'FSOUND_Stream_SetEndCallback');

937

pointer(FSOUND_Stream_SetSyncCallback) := GetAddress(FMODHandle, 'FSOUND_Stream_SetSyncCallback');

938

pointer(FSOUND_Stream_GetSample) := GetAddress(FMODHandle, 'FSOUND_Stream_GetSample');

939

pointer(FSOUND_Stream_CreateDSP) := GetAddress(FMODHandle, 'FSOUND_Stream_CreateDSP');

940

pointer(FSOUND_Stream_SetBufferSize) := GetAddress(FMODHandle, 'FSOUND_Stream_SetBufferSize');

941

pointer(FSOUND_Stream_SetPosition) := GetAddress(FMODHandle, 'FSOUND_Stream_SetPosition');

942

pointer(FSOUND_Stream_GetPosition) := GetAddress(FMODHandle, 'FSOUND_Stream_GetPosition');

943

pointer(FSOUND_Stream_SetTime) := GetAddress(FMODHandle, 'FSOUND_Stream_SetTime');

944

pointer(FSOUND_Stream_GetTime) := GetAddress(FMODHandle, 'FSOUND_Stream_GetTime');

945

pointer(FSOUND_Stream_GetLength) := GetAddress(FMODHandle, 'FSOUND_Stream_GetLength');

946

pointer(FSOUND_Stream_GetLengthMs) := GetAddress(FMODHandle, 'FSOUND_Stream_GetLengthMs');

947

pointer(FSOUND_Stream_SetMode) := GetAddress(FMODHandle, 'FSOUND_Stream_SetMode');

948

pointer(FSOUND_Stream_GetMode) := GetAddress(FMODHandle, 'FSOUND_Stream_GetMode');

949

pointer(FSOUND_Stream_SetLoopPoints) := GetAddress(FMODHandle, 'FSOUND_Stream_SetLoopPoints');

950

pointer(FSOUND_Stream_SetLoopCount) := GetAddress(FMODHandle, 'FSOUND_Stream_SetLoopCount');

951

pointer(FSOUND_Stream_GetOpenState) := GetAddress(FMODHandle, 'FSOUND_Stream_GetOpenState');

952

pointer(FSOUND_Stream_AddSyncPoint) := GetAddress(FMODHandle, 'FSOUND_Stream_AddSyncPoint');

953

pointer(FSOUND_Stream_DeleteSyncPoint) := GetAddress(FMODHandle, 'FSOUND_Stream_DeleteSyncPoint');

954

pointer(FSOUND_Stream_GetNumSyncPoints) := GetAddress(FMODHandle, 'FSOUND_Stream_GetNumSyncPoints');

955

pointer(FSOUND_Stream_GetSyncPoint) := GetAddress(FMODHandle, 'FSOUND_Stream_GetSyncPoint');

956

pointer(FSOUND_Stream_GetSyncPointInfo) := GetAddress(FMODHandle, 'FSOUND_Stream_GetSyncPointInfo');

957

pointer(FSOUND_Stream_SetSubStream) := GetAddress(FMODHandle, 'FSOUND_Stream_SetSubStream');

958

pointer(FSOUND_Stream_GetNumSubStreams) := GetAddress(FMODHandle, 'FSOUND_Stream_GetNumSubStreams');

959

pointer(FSOUND_Stream_SetSubStreamSentence) := GetAddress(FMODHandle, 'FSOUND_Stream_SetSubStreamSentence');

960

pointer(FSOUND_Stream_GetNumTagFields) := GetAddress(FMODHandle, 'FSOUND_Stream_GetNumTagFields');

961

pointer(FSOUND_Stream_GetTagField) := GetAddress(FMODHandle, 'FSOUND_Stream_GetTagField');

962

pointer(FSOUND_Stream_FindTagField) := GetAddress(FMODHandle, 'FSOUND_Stream_FindTagField');

963

pointer(FSOUND_Stream_Net_SetProxy) := GetAddress(FMODHandle, 'FSOUND_Stream_Net_SetProxy');

964

pointer(FSOUND_Stream_Net_GetLastServerStatus) := GetAddress(FMODHandle, 'FSOUND_Stream_Net_GetLastServerStatus');

965

pointer(FSOUND_Stream_Net_SetBufferProperties) := GetAddress(FMODHandle, 'FSOUND_Stream_Net_SetBufferProperties');

966

pointer(FSOUND_Stream_Net_GetBufferProperties) := GetAddress(FMODHandle, 'FSOUND_Stream_Net_GetBufferProperties');

967

pointer(FSOUND_Stream_Net_SetMetadataCallback) := GetAddress(FMODHandle, 'FSOUND_Stream_Net_SetMetadataCallback');

968

pointer(FSOUND_Stream_Net_GetStatus) := GetAddress(FMODHandle, 'FSOUND_Stream_Net_GetStatus');

969

pointer(FSOUND_CD_Play) := GetAddress(FMODHandle, 'FSOUND_CD_Play');

970

pointer(FSOUND_CD_SetPlayMode) := GetAddress(FMODHandle, 'FSOUND_CD_SetPlayMode');

971

pointer(FSOUND_CD_Stop) := GetAddress(FMODHandle, 'FSOUND_CD_Stop');

972

pointer(FSOUND_CD_SetPaused) := GetAddress(FMODHandle, 'FSOUND_CD_SetPaused');

973

pointer(FSOUND_CD_SetVolume) := GetAddress(FMODHandle, 'FSOUND_CD_SetVolume');

974

pointer(FSOUND_CD_SetTrackTime) := GetAddress(FMODHandle, 'FSOUND_CD_SetTrackTime');

975

pointer(FSOUND_CD_OpenTray) := GetAddress(FMODHandle, 'FSOUND_CD_OpenTray');

976

pointer(FSOUND_CD_GetPaused) := GetAddress(FMODHandle, 'FSOUND_CD_GetPaused');

977

pointer(FSOUND_CD_GetTrack) := GetAddress(FMODHandle, 'FSOUND_CD_GetTrack');

978

pointer(FSOUND_CD_GetNumTracks) := GetAddress(FMODHandle, 'FSOUND_CD_GetNumTracks');

979

pointer(FSOUND_CD_GetVolume) := GetAddress(FMODHandle, 'FSOUND_CD_GetVolume');

980

pointer(FSOUND_CD_GetTrackLength) := GetAddress(FMODHandle, 'FSOUND_CD_GetTrackLength');

981

pointer(FSOUND_CD_GetTrackTime) := GetAddress(FMODHandle, 'FSOUND_CD_GetTrackTime');

982

pointer(FSOUND_DSP_Create) := GetAddress(FMODHandle, 'FSOUND_DSP_Create');

983

pointer(FSOUND_DSP_Free) := GetAddress(FMODHandle, 'FSOUND_DSP_Free');

984

pointer(FSOUND_DSP_SetPriority) := GetAddress(FMODHandle, 'FSOUND_DSP_SetPriority');

985

pointer(FSOUND_DSP_GetPriority) := GetAddress(FMODHandle, 'FSOUND_DSP_GetPriority');

986

pointer(FSOUND_DSP_SetActive) := GetAddress(FMODHandle, 'FSOUND_DSP_SetActive');

987

pointer(FSOUND_DSP_GetActive) := GetAddress(FMODHandle, 'FSOUND_DSP_GetActive');

988

pointer(FSOUND_DSP_GetClearUnit) := GetAddress(FMODHandle, 'FSOUND_DSP_GetClearUnit');

989

pointer(FSOUND_DSP_GetSFXUnit) := GetAddress(FMODHandle, 'FSOUND_DSP_GetSFXUnit');

990

pointer(FSOUND_DSP_GetMusicUnit) := GetAddress(FMODHandle, 'FSOUND_DSP_GetMusicUnit');

991

pointer(FSOUND_DSP_GetClipAndCopyUnit) := GetAddress(FMODHandle, 'FSOUND_DSP_GetClipAndCopyUnit');

992

pointer(FSOUND_DSP_GetFFTUnit) := GetAddress(FMODHandle, 'FSOUND_DSP_GetFFTUnit');

993

pointer(FSOUND_DSP_MixBuffers) := GetAddress(FMODHandle, 'FSOUND_DSP_MixBuffers');

994

pointer(FSOUND_DSP_ClearMixBuffer) := GetAddress(FMODHandle, 'FSOUND_DSP_ClearMixBuffer');

995

pointer(FSOUND_DSP_GetBufferLength) := GetAddress(FMODHandle, 'FSOUND_DSP_GetBufferLength');

996

pointer(FSOUND_DSP_GetBufferLengthTotal) := GetAddress(FMODHandle, 'FSOUND_DSP_GetBufferLengthTotal');

997

pointer(FSOUND_DSP_GetSpectrum) := GetAddress(FMODHandle, 'FSOUND_DSP_GetSpectrum');

998

pointer(FSOUND_Reverb_SetProperties) := GetAddress(FMODHandle, 'FSOUND_Reverb_SetProperties');

999

pointer(FSOUND_Reverb_GetProperties) := GetAddress(FMODHandle, 'FSOUND_Reverb_GetProperties');

1000

pointer(FSOUND_Reverb_SetChannelProperties) := GetAddress(FMODHandle, 'FSOUND_Reverb_SetChannelProperties');

1001

pointer(FSOUND_Reverb_GetChannelProperties) := GetAddress(FMODHandle, 'FSOUND_Reverb_GetChannelProperties');

1002

pointer(FSOUND_Record_SetDriver) := GetAddress(FMODHandle, 'FSOUND_Record_SetDriver');

1003

pointer(FSOUND_Record_GetNumDrivers) := GetAddress(FMODHandle, 'FSOUND_Record_GetNumDrivers');

1004

pointer(FSOUND_Record_GetDriverName) := GetAddress(FMODHandle, 'FSOUND_Record_GetDriverName');

1005

pointer(FSOUND_Record_GetDriver) := GetAddress(FMODHandle, 'FSOUND_Record_GetDriver');

1006

pointer(FSOUND_Record_StartSample) := GetAddress(FMODHandle, 'FSOUND_Record_StartSample');

1007

pointer(FSOUND_Record_Stop) := GetAddress(FMODHandle, 'FSOUND_Record_Stop');

1008

pointer(FSOUND_Record_GetPosition) := GetAddress(FMODHandle, 'FSOUND_Record_GetPosition');

1009

pointer(FSOUND_File_SetCallbacks) := GetAddress(FMODHandle, 'FSOUND_File_SetCallbacks');

1010

pointer(FMUSIC_LoadSong) := GetAddress(FMODHandle, 'FMUSIC_LoadSong');

1011

pointer(FMUSIC_LoadSongEx) := GetAddress(FMODHandle, 'FMUSIC_LoadSongEx');

1012

pointer(FMUSIC_GetOpenState) := GetAddress(FMODHandle, 'FMUSIC_GetOpenState');

1013

pointer(FMUSIC_FreeSong) := GetAddress(FMODHandle, 'FMUSIC_FreeSong');

1014

pointer(FMUSIC_PlaySong) := GetAddress(FMODHandle, 'FMUSIC_PlaySong');

1015

pointer(FMUSIC_StopSong) := GetAddress(FMODHandle, 'FMUSIC_StopSong');

1016

pointer(FMUSIC_StopAllSongs) := GetAddress(FMODHandle, 'FMUSIC_StopAllSongs');

1017

pointer(FMUSIC_SetZxxCallback) := GetAddress(FMODHandle, 'FMUSIC_SetZxxCallback');

1018

pointer(FMUSIC_SetRowCallback) := GetAddress(FMODHandle, 'FMUSIC_SetRowCallback');

1019

pointer(FMUSIC_SetOrderCallback) := GetAddress(FMODHandle, 'FMUSIC_SetOrderCallback');

1020

pointer(FMUSIC_SetInstCallback) := GetAddress(FMODHandle, 'FMUSIC_SetInstCallback');

1021

pointer(FMUSIC_SetSample) := GetAddress(FMODHandle, 'FMUSIC_SetSample');

1022

pointer(FMUSIC_SetUserData) := GetAddress(FMODHandle, 'FMUSIC_SetUserData');

1023

pointer(FMUSIC_OptimizeChannels) := GetAddress(FMODHandle, 'FMUSIC_OptimizeChannels');

1024

pointer(FMUSIC_SetReverb) := GetAddress(FMODHandle, 'FMUSIC_SetReverb');

1025

pointer(FMUSIC_SetLooping) := GetAddress(FMODHandle, 'FMUSIC_SetLooping');

1026

pointer(FMUSIC_SetOrder) := GetAddress(FMODHandle, 'FMUSIC_SetOrder');

1027

pointer(FMUSIC_SetPaused) := GetAddress(FMODHandle, 'FMUSIC_SetPaused');

1028

pointer(FMUSIC_SetMasterVolume) := GetAddress(FMODHandle, 'FMUSIC_SetMasterVolume');

1029

pointer(FMUSIC_SetMasterSpeed) := GetAddress(FMODHandle, 'FMUSIC_SetMasterSpeed');

1030

pointer(FMUSIC_SetPanSeperation) := GetAddress(FMODHandle, 'FMUSIC_SetPanSeperation');

1031

pointer(FMUSIC_GetName) := GetAddress(FMODHandle, 'FMUSIC_GetName');

1032

pointer(FMUSIC_GetType) := GetAddress(FMODHandle, 'FMUSIC_GetType');

1033

pointer(FMUSIC_GetNumOrders) := GetAddress(FMODHandle, 'FMUSIC_GetNumOrders');

1034

pointer(FMUSIC_GetNumPatterns) := GetAddress(FMODHandle, 'FMUSIC_GetNumPatterns');

1035

pointer(FMUSIC_GetNumInstruments) := GetAddress(FMODHandle, 'FMUSIC_GetNumInstruments');

1036

pointer(FMUSIC_GetNumSamples) := GetAddress(FMODHandle, 'FMUSIC_GetNumSamples');

1037

pointer(FMUSIC_GetNumChannels) := GetAddress(FMODHandle, 'FMUSIC_GetNumChannels');

1038

pointer(FMUSIC_GetSample) := GetAddress(FMODHandle, 'FMUSIC_GetSample');

1039

pointer(FMUSIC_GetPatternLength) := GetAddress(FMODHandle, 'FMUSIC_GetPatternLength');

1040

pointer(FMUSIC_IsFinished) := GetAddress(FMODHandle, 'FMUSIC_IsFinished');

1041

pointer(FMUSIC_IsPlaying) := GetAddress(FMODHandle, 'FMUSIC_IsPlaying');

1042

pointer(FMUSIC_GetMasterVolume) := GetAddress(FMODHandle, 'FMUSIC_GetMasterVolume');

1043

pointer(FMUSIC_GetGlobalVolume) := GetAddress(FMODHandle, 'FMUSIC_GetGlobalVolume');

1044

pointer(FMUSIC_GetOrder) := GetAddress(FMODHandle, 'FMUSIC_GetOrder');

1045

pointer(FMUSIC_GetPattern) := GetAddress(FMODHandle, 'FMUSIC_GetPattern');

1046

pointer(FMUSIC_GetSpeed) := GetAddress(FMODHandle, 'FMUSIC_GetSpeed');

1047

pointer(FMUSIC_GetBPM) := GetAddress(FMODHandle, 'FMUSIC_GetBPM');

1048

pointer(FMUSIC_GetRow) := GetAddress(FMODHandle, 'FMUSIC_GetRow');

1049

pointer(FMUSIC_GetPaused) := GetAddress(FMODHandle, 'FMUSIC_GetPaused');

1050

pointer(FMUSIC_GetTime) := GetAddress(FMODHandle, 'FMUSIC_GetTime');

1051

pointer(FMUSIC_GetRealChannel) := GetAddress(FMODHandle, 'FMUSIC_GetRealChannel');

1052

pointer(FMUSIC_GetUserData) := GetAddress(FMODHandle, 'FMUSIC_GetUserData');

1053

1054

{$ENDIF}

1055

Result := True;

1056

end;

1057

1058

procedure FMOD_Unload;

1059

begin

1060

{ Only free the library if it was already loaded }

1061

if FMODHandle <> INVALID_MODULEHANDLE_VALUE then

1062

{$IFDEF WINDOWS}

1063

FreeLibrary(FMODHandle);

1064

{$ELSE}

1065

dlclose(FMODHandle);

1066

{$ENDIF}

1067

FMODHandle := INVALID_MODULEHANDLE_VALUE;

1068

end;

1069

1070

var

1071

Saved8087CW: Word;

1072

1073

{{$ifdef FPC} //FPC do not have this function in its RTL

1074

const

1075

Default8087CW = $1332; //according to the FPC site it's the value used in the

1076

//startup code.

1077

procedure Set8087CW( value :word ); Assembler;

1078

asm

1079

FLDCW value

1080

end;

1081

{$endif}

1082

}

1083

initialization

1084

FMODHandle := INVALID_MODULEHANDLE_VALUE;

1085

1086

{ Save the current FPU state and then disable FPU exceptions }

1087

Saved8087CW := Default8087CW;

1088

Set8087CW($133f); { Disable all fpu exceptions }

1089

1090

finalization

1091

{ Make sure the library is unloaded }

1092

FMOD_Unload;

1093

1094

{ Reset the FPU to the previous state }

1095

Set8087CW(Saved8087CW);

1096

end.

Older »