openal.d

   1 /*
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 2008 by authors.
   4  * This library is free software; you can redistribute it and/or
   5  *  modify it under the terms of the GNU Library General Public
   6  *  License as published by the Free Software Foundation; either
   7  *  version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  *  Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  *  License along with this library; if not, write to the
  16  *  Free Software Foundation, Inc.,
  17  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  * Or go to http://www.gnu.org/copyleft/lgpl.html
  19  */
  20 module iv.openal;
  21 pragma(lib, "openal");
  22
  23 // version = openal_alut;
  24
  25 extern(C) nothrow @nogc:
  26
  27 /** Deprecated macro. */
  28 //#define OPENAL
  29 //#define ALAPI                                    AL_API
  30 //#define ALAPIENTRY                               AL_APIENTRY
  31 enum AL_INVALID = (-1);
  32 enum AL_ILLEGAL_ENUM = AL_INVALID_ENUM;
  33 enum AL_ILLEGAL_COMMAND = AL_INVALID_OPERATION;
  34
  35 /** Supported AL version. */
  36 enum AL_VERSION_1_0 = true;
  37 enum AL_VERSION_1_1 = true;
  38
  39 /** 8-bit boolean */
  40 alias ALboolean = ubyte;
  41
  42 /** character */
  43 alias ALchar = char;
  44
  45 /** signed 8-bit 2's complement integer */
  46 alias ALbyte = byte;
  47
  48 /** unsigned 8-bit integer */
  49 alias ALubyte = ubyte;
  50
  51 /** signed 16-bit 2's complement integer */
  52 alias ALshort = short;
  53
  54 /** unsigned 16-bit integer */
  55 alias ALushort = ushort;
  56
  57 /** signed 32-bit 2's complement integer */
  58 alias ALint = int;
  59
  60 /** unsigned 32-bit integer */
  61 alias ALuint = uint;
  62
  63 /** non-negative 32-bit binary integer size */
  64 alias ALsizei = int;
  65
  66 /** enumerated 32-bit value */
  67 alias ALenum = int;
  68
  69 /** 32-bit IEEE754 floating-point */
  70 alias ALfloat = float;
  71
  72 /** 64-bit IEEE754 floating-point */
  73 alias ALdouble = double;
  74
  75 /** void type (for opaque pointers only) */
  76 alias ALvoid = void;
  77
  78
  79 /* Enumerant values begin at column 50. No tabs. */
  80
  81 /** "no distance model" or "no buffer" */
  82 enum AL_NONE = 0;
  83
  84 /** Boolean False. */
  85 enum AL_FALSE = 0;
  86
  87 /** Boolean True. */
  88 enum AL_TRUE = 1;
  89
  90
  91 /**
  92  * Relative source.
  93  * Type:    ALboolean
  94  * Range:   [AL_TRUE, AL_FALSE]
  95  * Default: AL_FALSE
  96  *
  97  * Specifies if the Source has relative coordinates.
  98  */
  99 enum AL_SOURCE_RELATIVE = 0x202;
 100
 101
 102 /**
 103  * Inner cone angle, in degrees.
 104  * Type:    ALint, ALfloat
 105  * Range:   [0 - 360]
 106  * Default: 360
 107  *
 108  * The angle covered by the inner cone, where the source will not attenuate.
 109  */
 110 enum AL_CONE_INNER_ANGLE = 0x1001;
 111
 112 /**
 113  * Outer cone angle, in degrees.
 114  * Range:   [0 - 360]
 115  * Default: 360
 116  *
 117  * The angle covered by the outer cone, where the source will be fully
 118  * attenuated.
 119  */
 120 enum AL_CONE_OUTER_ANGLE = 0x1002;
 121
 122 /**
 123  * Source pitch.
 124  * Type:    ALfloat
 125  * Range:   [0.5 - 2.0]
 126  * Default: 1.0
 127  *
 128  * A multiplier for the frequency (sample rate) of the source's buffer.
 129  */
 130 enum AL_PITCH = 0x1003;
 131
 132 /**
 133  * Source or listener position.
 134  * Type:    ALfloat[3], ALint[3]
 135  * Default: {0, 0, 0}
 136  *
 137  * The source or listener location in three dimensional space.
 138  *
 139  * OpenAL, like OpenGL, uses a right handed coordinate system, where in a
 140  * frontal default view X (thumb) points right, Y points up (index finger), and
 141  * Z points towards the viewer/camera (middle finger).
 142  *
 143  * To switch from a left handed coordinate system, flip the sign on the Z
 144  * coordinate.
 145  */
 146 enum AL_POSITION = 0x1004;
 147
 148 /**
 149  * Source direction.
 150  * Type:    ALfloat[3], ALint[3]
 151  * Default: {0, 0, 0}
 152  *
 153  * Specifies the current direction in local space.
 154  * A zero-length vector specifies an omni-directional source (cone is ignored).
 155  */
 156 enum AL_DIRECTION = 0x1005;
 157
 158 /**
 159  * Source or listener velocity.
 160  * Type:    ALfloat[3], ALint[3]
 161  * Default: {0, 0, 0}
 162  *
 163  * Specifies the current velocity in local space.
 164  */
 165 enum AL_VELOCITY = 0x1006;
 166
 167 /**
 168  * Source looping.
 169  * Type:    ALboolean
 170  * Range:   [AL_TRUE, AL_FALSE]
 171  * Default: AL_FALSE
 172  *
 173  * Specifies whether source is looping.
 174  */
 175 enum AL_LOOPING = 0x1007;
 176
 177 /**
 178  * Source buffer.
 179  * Type:  ALuint
 180  * Range: any valid Buffer.
 181  *
 182  * Specifies the buffer to provide sound samples.
 183  */
 184 enum AL_BUFFER = 0x1009;
 185
 186 /**
 187  * Source or listener gain.
 188  * Type:  ALfloat
 189  * Range: [0.0 - ]
 190  *
 191  * A value of 1.0 means unattenuated. Each division by 2 equals an attenuation
 192  * of about -6dB. Each multiplicaton by 2 equals an amplification of about
 193  * +6dB.
 194  *
 195  * A value of 0.0 is meaningless with respect to a logarithmic scale; it is
 196  * silent.
 197  */
 198 enum AL_GAIN = 0x100A;
 199
 200 /**
 201  * Minimum source gain.
 202  * Type:  ALfloat
 203  * Range: [0.0 - 1.0]
 204  *
 205  * The minimum gain allowed for a source, after distance and cone attenation is
 206  * applied (if applicable).
 207  */
 208 enum AL_MIN_GAIN = 0x100D;
 209
 210 /**
 211  * Maximum source gain.
 212  * Type:  ALfloat
 213  * Range: [0.0 - 1.0]
 214  *
 215  * The maximum gain allowed for a source, after distance and cone attenation is
 216  * applied (if applicable).
 217  */
 218 enum AL_MAX_GAIN = 0x100E;
 219
 220 /**
 221  * Listener orientation.
 222  * Type: ALfloat[6]
 223  * Default: {0.0, 0.0, -1.0, 0.0, 1.0, 0.0}
 224  *
 225  * Effectively two three dimensional vectors. The first vector is the front (or
 226  * "at") and the second is the top (or "up").
 227  *
 228  * Both vectors are in local space.
 229  */
 230 enum AL_ORIENTATION = 0x100F;
 231
 232 /**
 233  * Source state (query only).
 234  * Type:  ALint
 235  * Range: [AL_INITIAL, AL_PLAYING, AL_PAUSED, AL_STOPPED]
 236  */
 237 enum AL_SOURCE_STATE = 0x1010;
 238
 239 /** Source state value. */
 240 enum AL_INITIAL = 0x1011;
 241 enum AL_PLAYING = 0x1012;
 242 enum AL_PAUSED = 0x1013;
 243 enum AL_STOPPED = 0x1014;
 244
 245 /**
 246  * Source Buffer Queue size (query only).
 247  * Type: ALint
 248  *
 249  * The number of buffers queued using alSourceQueueBuffers, minus the buffers
 250  * removed with alSourceUnqueueBuffers.
 251  */
 252 enum AL_BUFFERS_QUEUED = 0x1015;
 253
 254 /**
 255  * Source Buffer Queue processed count (query only).
 256  * Type: ALint
 257  *
 258  * The number of queued buffers that have been fully processed, and can be
 259  * removed with alSourceUnqueueBuffers.
 260  *
 261  * Looping sources will never fully process buffers because they will be set to
 262  * play again for when the source loops.
 263  */
 264 enum AL_BUFFERS_PROCESSED = 0x1016;
 265
 266 /**
 267  * Source reference distance.
 268  * Type:    ALfloat
 269  * Range:   [0.0 - ]
 270  * Default: 1.0
 271  *
 272  * The distance in units that no attenuation occurs.
 273  *
 274  * At 0.0, no distance attenuation ever occurs on non-linear attenuation models.
 275  */
 276 enum AL_REFERENCE_DISTANCE = 0x1020;
 277
 278 /**
 279  * Source rolloff factor.
 280  * Type:    ALfloat
 281  * Range:   [0.0 - ]
 282  * Default: 1.0
 283  *
 284  * Multiplier to exaggerate or diminish distance attenuation.
 285  *
 286  * At 0.0, no distance attenuation ever occurs.
 287  */
 288 enum AL_ROLLOFF_FACTOR = 0x1021;
 289
 290 /**
 291  * Outer cone gain.
 292  * Type:    ALfloat
 293  * Range:   [0.0 - 1.0]
 294  * Default: 0.0
 295  *
 296  * The gain attenuation applied when the listener is outside of the source's
 297  * outer cone.
 298  */
 299 enum AL_CONE_OUTER_GAIN = 0x1022;
 300
 301 /**
 302  * Source maximum distance.
 303  * Type:    ALfloat
 304  * Range:   [0.0 - ]
 305  * Default: +inf
 306  *
 307  * The distance above which the source is not attenuated any further with a
 308  * clamped distance model, or where attenuation reaches 0.0 gain for linear
 309  * distance models with a default rolloff factor.
 310  */
 311 enum AL_MAX_DISTANCE = 0x1023;
 312
 313 /** Source buffer position, in seconds */
 314 enum AL_SEC_OFFSET = 0x1024;
 315 /** Source buffer position, in sample frames */
 316 enum AL_SAMPLE_OFFSET = 0x1025;
 317 /** Source buffer position, in bytes */
 318 enum AL_BYTE_OFFSET = 0x1026;
 319
 320 /**
 321  * Source type (query only).
 322  * Type:  ALint
 323  * Range: [AL_STATIC, AL_STREAMING, AL_UNDETERMINED]
 324  *
 325  * A Source is Static if a Buffer has been attached using AL_BUFFER.
 326  *
 327  * A Source is Streaming if one or more Buffers have been attached using
 328  * alSourceQueueBuffers.
 329  *
 330  * A Source is Undetermined when it has the NULL buffer attached using
 331  * AL_BUFFER.
 332  */
 333 enum AL_SOURCE_TYPE = 0x1027;
 334
 335 /** Source type value. */
 336 enum AL_STATIC = 0x1028;
 337 enum AL_STREAMING = 0x1029;
 338 enum AL_UNDETERMINED = 0x1030;
 339
 340 /** Buffer format specifier. */
 341 enum AL_FORMAT_MONO8 = 0x1100;
 342 enum AL_FORMAT_MONO16 = 0x1101;
 343 enum AL_FORMAT_STEREO8 = 0x1102;
 344 enum AL_FORMAT_STEREO16 = 0x1103;
 345
 346 /** Buffer frequency (query only). */
 347 enum AL_FREQUENCY = 0x2001;
 348 /** Buffer bits per sample (query only). */
 349 enum AL_BITS = 0x2002;
 350 /** Buffer channel count (query only). */
 351 enum AL_CHANNELS = 0x2003;
 352 /** Buffer data size (query only). */
 353 enum AL_SIZE = 0x2004;
 354
 355 /**
 356  * Buffer state.
 357  *
 358  * Not for public use.
 359  */
 360 enum AL_UNUSED = 0x2010;
 361 enum AL_PENDING = 0x2011;
 362 enum AL_PROCESSED = 0x2012;
 363
 364
 365 /** No error. */
 366 enum AL_NO_ERROR = 0;
 367
 368 /** Invalid name paramater passed to AL call. */
 369 enum AL_INVALID_NAME = 0xA001;
 370
 371 /** Invalid enum parameter passed to AL call. */
 372 enum AL_INVALID_ENUM = 0xA002;
 373
 374 /** Invalid value parameter passed to AL call. */
 375 enum AL_INVALID_VALUE = 0xA003;
 376
 377 /** Illegal AL call. */
 378 enum AL_INVALID_OPERATION = 0xA004;
 379
 380 /** Not enough memory. */
 381 enum AL_OUT_OF_MEMORY = 0xA005;
 382
 383
 384 /** Context string: Vendor ID. */
 385 enum AL_VENDOR = 0xB001;
 386 /** Context string: Version. */
 387 enum AL_VERSION = 0xB002;
 388 /** Context string: Renderer ID. */
 389 enum AL_RENDERER = 0xB003;
 390 /** Context string: Space-separated extension list. */
 391 enum AL_EXTENSIONS = 0xB004;
 392
 393
 394 /**
 395  * Doppler scale.
 396  * Type:    ALfloat
 397  * Range:   [0.0 - ]
 398  * Default: 1.0
 399  *
 400  * Scale for source and listener velocities.
 401  */
 402 enum AL_DOPPLER_FACTOR = 0xC000;
 403 /*AL_API*/ void /*AL_APIENTRY*/ alDopplerFactor(ALfloat value);
 404
 405 /**
 406  * Doppler velocity (deprecated).
 407  *
 408  * A multiplier applied to the Speed of Sound.
 409  */
 410 enum AL_DOPPLER_VELOCITY = 0xC001;
 411 /*AL_API*/ void /*AL_APIENTRY*/ alDopplerVelocity(ALfloat value);
 412
 413 /**
 414  * Speed of Sound, in units per second.
 415  * Type:    ALfloat
 416  * Range:   [0.0001 - ]
 417  * Default: 343.3
 418  *
 419  * The speed at which sound waves are assumed to travel, when calculating the
 420  * doppler effect.
 421  */
 422 enum AL_SPEED_OF_SOUND = 0xC003;
 423 /*AL_API*/ void /*AL_APIENTRY*/ alSpeedOfSound(ALfloat value);
 424
 425 /**
 426  * Distance attenuation model.
 427  * Type:    ALint
 428  * Range:   [AL_NONE, AL_INVERSE_DISTANCE, AL_INVERSE_DISTANCE_CLAMPED,
 429  *           AL_LINEAR_DISTANCE, AL_LINEAR_DISTANCE_CLAMPED,
 430  *           AL_EXPONENT_DISTANCE, AL_EXPONENT_DISTANCE_CLAMPED]
 431  * Default: AL_INVERSE_DISTANCE_CLAMPED
 432  *
 433  * The model by which sources attenuate with distance.
 434  *
 435  * None     - No distance attenuation.
 436  * Inverse  - Doubling the distance halves the source gain.
 437  * Linear   - Linear gain scaling between the reference and max distances.
 438  * Exponent - Exponential gain dropoff.
 439  *
 440  * Clamped variations work like the non-clamped counterparts, except the
 441  * distance calculated is clamped between the reference and max distances.
 442  */
 443 enum AL_DISTANCE_MODEL = 0xD000;
 444 /*AL_API*/ void /*AL_APIENTRY*/ alDistanceModel(ALenum distanceModel);
 445
 446 /** Distance model value. */
 447 enum AL_INVERSE_DISTANCE = 0xD001;
 448 enum AL_INVERSE_DISTANCE_CLAMPED = 0xD002;
 449 enum AL_LINEAR_DISTANCE = 0xD003;
 450 enum AL_LINEAR_DISTANCE_CLAMPED = 0xD004;
 451 enum AL_EXPONENT_DISTANCE = 0xD005;
 452 enum AL_EXPONENT_DISTANCE_CLAMPED = 0xD006;
 453
 454 /** Renderer State management. */
 455 /*AL_API*/ void /*AL_APIENTRY*/ alEnable(ALenum capability);
 456 /*AL_API*/ void /*AL_APIENTRY*/ alDisable(ALenum capability);
 457 /*AL_API*/ ALboolean /*AL_APIENTRY*/ alIsEnabled(ALenum capability);
 458
 459 /** State retrieval. */
 460 /*AL_API*/ const(ALchar)* /*AL_APIENTRY*/ alGetString(ALenum param);
 461 /*AL_API*/ void /*AL_APIENTRY*/ alGetBooleanv(ALenum param, ALboolean* values);
 462 /*AL_API*/ void /*AL_APIENTRY*/ alGetIntegerv(ALenum param, ALint* values);
 463 /*AL_API*/ void /*AL_APIENTRY*/ alGetFloatv(ALenum param, ALfloat* values);
 464 /*AL_API*/ void /*AL_APIENTRY*/ alGetDoublev(ALenum param, ALdouble* values);
 465 /*AL_API*/ ALboolean /*AL_APIENTRY*/ alGetBoolean(ALenum param);
 466 /*AL_API*/ ALint /*AL_APIENTRY*/ alGetInteger(ALenum param);
 467 /*AL_API*/ ALfloat /*AL_APIENTRY*/ alGetFloat(ALenum param);
 468 /*AL_API*/ ALdouble /*AL_APIENTRY*/ alGetDouble(ALenum param);
 469
 470 /**
 471  * Error retrieval.
 472  *
 473  * Obtain the first error generated in the AL context since the last check.
 474  */
 475 /*AL_API*/ ALenum /*AL_APIENTRY*/ alGetError();
 476
 477 /**
 478  * Extension support.
 479  *
 480  * Query for the presence of an extension, and obtain any appropriate function
 481  * pointers and enum values.
 482  */
 483 /*AL_API*/ ALboolean /*AL_APIENTRY*/ alIsExtensionPresent(const(ALchar)* extname);
 484 /*AL_API*/ void* /*AL_APIENTRY*/ alGetProcAddress(const(ALchar)* fname);
 485 /*AL_API*/ ALenum /*AL_APIENTRY*/ alGetEnumValue(const(ALchar)* ename);
 486
 487
 488 /** Set Listener parameters */
 489 /*AL_API*/ void /*AL_APIENTRY*/ alListenerf(ALenum param, ALfloat value);
 490 /*AL_API*/ void /*AL_APIENTRY*/ alListener3f(ALenum param, ALfloat value1, ALfloat value2, ALfloat value3);
 491 /*AL_API*/ void /*AL_APIENTRY*/ alListenerfv(ALenum param, const(ALfloat)* values);
 492 /*AL_API*/ void /*AL_APIENTRY*/ alListeneri(ALenum param, ALint value);
 493 /*AL_API*/ void /*AL_APIENTRY*/ alListener3i(ALenum param, ALint value1, ALint value2, ALint value3);
 494 /*AL_API*/ void /*AL_APIENTRY*/ alListeneriv(ALenum param, const(ALint)* values);
 495
 496 /** Get Listener parameters */
 497 /*AL_API*/ void /*AL_APIENTRY*/ alGetListenerf(ALenum param, ALfloat* value);
 498 /*AL_API*/ void /*AL_APIENTRY*/ alGetListener3f(ALenum param, ALfloat* value1, ALfloat* value2, ALfloat* value3);
 499 /*AL_API*/ void /*AL_APIENTRY*/ alGetListenerfv(ALenum param, ALfloat* values);
 500 /*AL_API*/ void /*AL_APIENTRY*/ alGetListeneri(ALenum param, ALint* value);
 501 /*AL_API*/ void /*AL_APIENTRY*/ alGetListener3i(ALenum param, ALint* value1, ALint* value2, ALint* value3);
 502 /*AL_API*/ void /*AL_APIENTRY*/ alGetListeneriv(ALenum param, ALint* values);
 503
 504
 505 /** Create Source objects. */
 506 /*AL_API*/ void /*AL_APIENTRY*/ alGenSources(ALsizei n, ALuint* sources);
 507 /** Delete Source objects. */
 508 /*AL_API*/ void /*AL_APIENTRY*/ alDeleteSources(ALsizei n, const(ALuint)* sources);
 509 /** Verify a handle is a valid Source. */
 510 /*AL_API*/ ALboolean /*AL_APIENTRY*/ alIsSource(ALuint source);
 511
 512 /** Set Source parameters. */
 513 /*AL_API*/ void /*AL_APIENTRY*/ alSourcef(ALuint source, ALenum param, ALfloat value);
 514 /*AL_API*/ void /*AL_APIENTRY*/ alSource3f(ALuint source, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3);
 515 /*AL_API*/ void /*AL_APIENTRY*/ alSourcefv(ALuint source, ALenum param, const(ALfloat)* values);
 516 /*AL_API*/ void /*AL_APIENTRY*/ alSourcei(ALuint source, ALenum param, ALint value);
 517 /*AL_API*/ void /*AL_APIENTRY*/ alSource3i(ALuint source, ALenum param, ALint value1, ALint value2, ALint value3);
 518 /*AL_API*/ void /*AL_APIENTRY*/ alSourceiv(ALuint source, ALenum param, const(ALint)* values);
 519
 520 /** Get Source parameters. */
 521 /*AL_API*/ void /*AL_APIENTRY*/ alGetSourcef(ALuint source, ALenum param, ALfloat* value);
 522 /*AL_API*/ void /*AL_APIENTRY*/ alGetSource3f(ALuint source, ALenum param, ALfloat* value1, ALfloat* value2, ALfloat* value3);
 523 /*AL_API*/ void /*AL_APIENTRY*/ alGetSourcefv(ALuint source, ALenum param, ALfloat* values);
 524 /*AL_API*/ void /*AL_APIENTRY*/ alGetSourcei(ALuint source,  ALenum param, ALint* value);
 525 /*AL_API*/ void /*AL_APIENTRY*/ alGetSource3i(ALuint source, ALenum param, ALint* value1, ALint* value2, ALint* value3);
 526 /*AL_API*/ void /*AL_APIENTRY*/ alGetSourceiv(ALuint source,  ALenum param, ALint* values);
 527
 528
 529 /** Play, replay, or resume (if paused) a list of Sources */
 530 /*AL_API*/ void /*AL_APIENTRY*/ alSourcePlayv(ALsizei n, const(ALuint)* sources);
 531 /** Stop a list of Sources */
 532 /*AL_API*/ void /*AL_APIENTRY*/ alSourceStopv(ALsizei n, const(ALuint)* sources);
 533 /** Rewind a list of Sources */
 534 /*AL_API*/ void /*AL_APIENTRY*/ alSourceRewindv(ALsizei n, const(ALuint)* sources);
 535 /** Pause a list of Sources */
 536 /*AL_API*/ void /*AL_APIENTRY*/ alSourcePausev(ALsizei n, const(ALuint)* sources);
 537
 538 /** Play, replay, or resume a Source */
 539 /*AL_API*/ void /*AL_APIENTRY*/ alSourcePlay(ALuint source);
 540 /** Stop a Source */
 541 /*AL_API*/ void /*AL_APIENTRY*/ alSourceStop(ALuint source);
 542 /** Rewind a Source (set playback postiton to beginning) */
 543 /*AL_API*/ void /*AL_APIENTRY*/ alSourceRewind(ALuint source);
 544 /** Pause a Source */
 545 /*AL_API*/ void /*AL_APIENTRY*/ alSourcePause(ALuint source);
 546
 547 /** Queue buffers onto a source */
 548 /*AL_API*/ void /*AL_APIENTRY*/ alSourceQueueBuffers(ALuint source, ALsizei nb, const(ALuint)* buffers);
 549 /** Unqueue processed buffers from a source */
 550 /*AL_API*/ void /*AL_APIENTRY*/ alSourceUnqueueBuffers(ALuint source, ALsizei nb, ALuint* buffers);
 551
 552
 553 /** Create Buffer objects */
 554 /*AL_API*/ void /*AL_APIENTRY*/ alGenBuffers(ALsizei n, ALuint* buffers);
 555 /** Delete Buffer objects */
 556 /*AL_API*/ void /*AL_APIENTRY*/ alDeleteBuffers(ALsizei n, const(ALuint)* buffers);
 557 /** Verify a handle is a valid Buffer */
 558 /*AL_API*/ ALboolean /*AL_APIENTRY*/ alIsBuffer(ALuint buffer);
 559
 560 /** Specifies the data to be copied into a buffer */
 561 /*AL_API*/ void /*AL_APIENTRY*/ alBufferData(ALuint buffer, ALenum format, const(ALvoid)* data, ALsizei size, ALsizei freq);
 562
 563 /** Set Buffer parameters, */
 564 /*AL_API*/ void /*AL_APIENTRY*/ alBufferf(ALuint buffer, ALenum param, ALfloat value);
 565 /*AL_API*/ void /*AL_APIENTRY*/ alBuffer3f(ALuint buffer, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3);
 566 /*AL_API*/ void /*AL_APIENTRY*/ alBufferfv(ALuint buffer, ALenum param, const(ALfloat)* values);
 567 /*AL_API*/ void /*AL_APIENTRY*/ alBufferi(ALuint buffer, ALenum param, ALint value);
 568 /*AL_API*/ void /*AL_APIENTRY*/ alBuffer3i(ALuint buffer, ALenum param, ALint value1, ALint value2, ALint value3);
 569 /*AL_API*/ void /*AL_APIENTRY*/ alBufferiv(ALuint buffer, ALenum param, const(ALint)* values);
 570
 571 /** Get Buffer parameters. */
 572 /*AL_API*/ void /*AL_APIENTRY*/ alGetBufferf(ALuint buffer, ALenum param, ALfloat* value);
 573 /*AL_API*/ void /*AL_APIENTRY*/ alGetBuffer3f(ALuint buffer, ALenum param, ALfloat* value1, ALfloat* value2, ALfloat* value3);
 574 /*AL_API*/ void /*AL_APIENTRY*/ alGetBufferfv(ALuint buffer, ALenum param, ALfloat* values);
 575 /*AL_API*/ void /*AL_APIENTRY*/ alGetBufferi(ALuint buffer, ALenum param, ALint* value);
 576 /*AL_API*/ void /*AL_APIENTRY*/ alGetBuffer3i(ALuint buffer, ALenum param, ALint* value1, ALint* value2, ALint* value3);
 577 /*AL_API*/ void /*AL_APIENTRY*/ alGetBufferiv(ALuint buffer, ALenum param, ALint* values);
 578
 579 /** Pointer-to-function type, useful for dynamically getting AL entry points. */
 580 /+
 581 typedef void          (/*AL_APIENTRY*/ *LPALENABLE)(ALenum capability);
 582 typedef void          (/*AL_APIENTRY*/ *LPALDISABLE)(ALenum capability);
 583 typedef ALboolean     (/*AL_APIENTRY*/ *LPALISENABLED)(ALenum capability);
 584 typedef const(ALchar)* (/*AL_APIENTRY*/ *LPALGETSTRING)(ALenum param);
 585 typedef void          (/*AL_APIENTRY*/ *LPALGETBOOLEANV)(ALenum param, ALboolean *values);
 586 typedef void          (/*AL_APIENTRY*/ *LPALGETINTEGERV)(ALenum param, ALint *values);
 587 typedef void          (/*AL_APIENTRY*/ *LPALGETFLOATV)(ALenum param, ALfloat *values);
 588 typedef void          (/*AL_APIENTRY*/ *LPALGETDOUBLEV)(ALenum param, ALdouble *values);
 589 typedef ALboolean     (/*AL_APIENTRY*/ *LPALGETBOOLEAN)(ALenum param);
 590 typedef ALint         (/*AL_APIENTRY*/ *LPALGETINTEGER)(ALenum param);
 591 typedef ALfloat       (/*AL_APIENTRY*/ *LPALGETFLOAT)(ALenum param);
 592 typedef ALdouble      (/*AL_APIENTRY*/ *LPALGETDOUBLE)(ALenum param);
 593 typedef ALenum        (/*AL_APIENTRY*/ *LPALGETERROR)(void);
 594 typedef ALboolean     (/*AL_APIENTRY*/ *LPALISEXTENSIONPRESENT)(const(ALchar)* extname);
 595 typedef void*         (/*AL_APIENTRY*/ *LPALGETPROCADDRESS)(const(ALchar)* fname);
 596 typedef ALenum        (/*AL_APIENTRY*/ *LPALGETENUMVALUE)(const(ALchar)* ename);
 597 typedef void          (/*AL_APIENTRY*/ *LPALLISTENERF)(ALenum param, ALfloat value);
 598 typedef void          (/*AL_APIENTRY*/ *LPALLISTENER3F)(ALenum param, ALfloat value1, ALfloat value2, ALfloat value3);
 599 typedef void          (/*AL_APIENTRY*/ *LPALLISTENERFV)(ALenum param, const(ALfloat)* values);
 600 typedef void          (/*AL_APIENTRY*/ *LPALLISTENERI)(ALenum param, ALint value);
 601 typedef void          (/*AL_APIENTRY*/ *LPALLISTENER3I)(ALenum param, ALint value1, ALint value2, ALint value3);
 602 typedef void          (/*AL_APIENTRY*/ *LPALLISTENERIV)(ALenum param, const(ALint)* values);
 603 typedef void          (/*AL_APIENTRY*/ *LPALGETLISTENERF)(ALenum param, ALfloat *value);
 604 typedef void          (/*AL_APIENTRY*/ *LPALGETLISTENER3F)(ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3);
 605 typedef void          (/*AL_APIENTRY*/ *LPALGETLISTENERFV)(ALenum param, ALfloat *values);
 606 typedef void          (/*AL_APIENTRY*/ *LPALGETLISTENERI)(ALenum param, ALint *value);
 607 typedef void          (/*AL_APIENTRY*/ *LPALGETLISTENER3I)(ALenum param, ALint *value1, ALint *value2, ALint *value3);
 608 typedef void          (/*AL_APIENTRY*/ *LPALGETLISTENERIV)(ALenum param, ALint *values);
 609 typedef void          (/*AL_APIENTRY*/ *LPALGENSOURCES)(ALsizei n, ALuint *sources);
 610 typedef void          (/*AL_APIENTRY*/ *LPALDELETESOURCES)(ALsizei n, const(ALuint)* sources);
 611 typedef ALboolean     (/*AL_APIENTRY*/ *LPALISSOURCE)(ALuint source);
 612 typedef void          (/*AL_APIENTRY*/ *LPALSOURCEF)(ALuint source, ALenum param, ALfloat value);
 613 typedef void          (/*AL_APIENTRY*/ *LPALSOURCE3F)(ALuint source, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3);
 614 typedef void          (/*AL_APIENTRY*/ *LPALSOURCEFV)(ALuint source, ALenum param, const(ALfloat)* values);
 615 typedef void          (/*AL_APIENTRY*/ *LPALSOURCEI)(ALuint source, ALenum param, ALint value);
 616 typedef void          (/*AL_APIENTRY*/ *LPALSOURCE3I)(ALuint source, ALenum param, ALint value1, ALint value2, ALint value3);
 617 typedef void          (/*AL_APIENTRY*/ *LPALSOURCEIV)(ALuint source, ALenum param, const(ALint)* values);
 618 typedef void          (/*AL_APIENTRY*/ *LPALGETSOURCEF)(ALuint source, ALenum param, ALfloat *value);
 619 typedef void          (/*AL_APIENTRY*/ *LPALGETSOURCE3F)(ALuint source, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3);
 620 typedef void          (/*AL_APIENTRY*/ *LPALGETSOURCEFV)(ALuint source, ALenum param, ALfloat *values);
 621 typedef void          (/*AL_APIENTRY*/ *LPALGETSOURCEI)(ALuint source, ALenum param, ALint *value);
 622 typedef void          (/*AL_APIENTRY*/ *LPALGETSOURCE3I)(ALuint source, ALenum param, ALint *value1, ALint *value2, ALint *value3);
 623 typedef void          (/*AL_APIENTRY*/ *LPALGETSOURCEIV)(ALuint source, ALenum param, ALint *values);
 624 typedef void          (/*AL_APIENTRY*/ *LPALSOURCEPLAYV)(ALsizei n, const(ALuint)* sources);
 625 typedef void          (/*AL_APIENTRY*/ *LPALSOURCESTOPV)(ALsizei n, const(ALuint)* sources);
 626 typedef void          (/*AL_APIENTRY*/ *LPALSOURCEREWINDV)(ALsizei n, const(ALuint)* sources);
 627 typedef void          (/*AL_APIENTRY*/ *LPALSOURCEPAUSEV)(ALsizei n, const(ALuint)* sources);
 628 typedef void          (/*AL_APIENTRY*/ *LPALSOURCEPLAY)(ALuint source);
 629 typedef void          (/*AL_APIENTRY*/ *LPALSOURCESTOP)(ALuint source);
 630 typedef void          (/*AL_APIENTRY*/ *LPALSOURCEREWIND)(ALuint source);
 631 typedef void          (/*AL_APIENTRY*/ *LPALSOURCEPAUSE)(ALuint source);
 632 typedef void          (/*AL_APIENTRY*/ *LPALSOURCEQUEUEBUFFERS)(ALuint source, ALsizei nb, const(ALuint)* buffers);
 633 typedef void          (/*AL_APIENTRY*/ *LPALSOURCEUNQUEUEBUFFERS)(ALuint source, ALsizei nb, ALuint *buffers);
 634 typedef void          (/*AL_APIENTRY*/ *LPALGENBUFFERS)(ALsizei n, ALuint *buffers);
 635 typedef void          (/*AL_APIENTRY*/ *LPALDELETEBUFFERS)(ALsizei n, const(ALuint)* buffers);
 636 typedef ALboolean     (/*AL_APIENTRY*/ *LPALISBUFFER)(ALuint buffer);
 637 typedef void          (/*AL_APIENTRY*/ *LPALBUFFERDATA)(ALuint buffer, ALenum format, const(ALvoid)* data, ALsizei size, ALsizei freq);
 638 typedef void          (/*AL_APIENTRY*/ *LPALBUFFERF)(ALuint buffer, ALenum param, ALfloat value);
 639 typedef void          (/*AL_APIENTRY*/ *LPALBUFFER3F)(ALuint buffer, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3);
 640 typedef void          (/*AL_APIENTRY*/ *LPALBUFFERFV)(ALuint buffer, ALenum param, const(ALfloat)* values);
 641 typedef void          (/*AL_APIENTRY*/ *LPALBUFFERI)(ALuint buffer, ALenum param, ALint value);
 642 typedef void          (/*AL_APIENTRY*/ *LPALBUFFER3I)(ALuint buffer, ALenum param, ALint value1, ALint value2, ALint value3);
 643 typedef void          (/*AL_APIENTRY*/ *LPALBUFFERIV)(ALuint buffer, ALenum param, const(ALint)* values);
 644 typedef void          (/*AL_APIENTRY*/ *LPALGETBUFFERF)(ALuint buffer, ALenum param, ALfloat *value);
 645 typedef void          (/*AL_APIENTRY*/ *LPALGETBUFFER3F)(ALuint buffer, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3);
 646 typedef void          (/*AL_APIENTRY*/ *LPALGETBUFFERFV)(ALuint buffer, ALenum param, ALfloat *values);
 647 typedef void          (/*AL_APIENTRY*/ *LPALGETBUFFERI)(ALuint buffer, ALenum param, ALint *value);
 648 typedef void          (/*AL_APIENTRY*/ *LPALGETBUFFER3I)(ALuint buffer, ALenum param, ALint *value1, ALint *value2, ALint *value3);
 649 typedef void          (/*AL_APIENTRY*/ *LPALGETBUFFERIV)(ALuint buffer, ALenum param, ALint *values);
 650 typedef void          (/*AL_APIENTRY*/ *LPALDOPPLERFACTOR)(ALfloat value);
 651 typedef void          (/*AL_APIENTRY*/ *LPALDOPPLERVELOCITY)(ALfloat value);
 652 typedef void          (/*AL_APIENTRY*/ *LPALSPEEDOFSOUND)(ALfloat value);
 653 typedef void          (/*AL_APIENTRY*/ *LPALDISTANCEMODEL)(ALenum distanceModel);
 654 +/
 655
 656 /** Deprecated macro. */
 657 //enum ALCAPI = ALC_API;
 658 //enum ALCAPIENTRY = ALC_APIENTRY;
 659 enum ALC_INVALID = 0;
 660
 661 /** Supported ALC version? */
 662 enum ALC_VERSION_0_1 = 1;
 663
 664 /** Opaque device handle */
 665 //typedef struct ALCdevice_struct ALCdevice;
 666 struct ALCdevice {}
 667 /** Opaque context handle */
 668 //typedef struct ALCcontext_struct ALCcontext;
 669 struct ALCcontext {}
 670
 671 /** 8-bit boolean */
 672 alias ALCboolean = ubyte;
 673
 674 /** character */
 675 alias ALCchar = char;
 676
 677 /** signed 8-bit 2's complement integer */
 678 alias ALCbyte = byte;
 679
 680 /** unsigned 8-bit integer */
 681 alias ALCubyte = ubyte;
 682
 683 /** signed 16-bit 2's complement integer */
 684 alias ALCshort = short;
 685
 686 /** unsigned 16-bit integer */
 687 alias ALCushort = ushort;
 688
 689 /** signed 32-bit 2's complement integer */
 690 alias ALCint = int;
 691
 692 /** unsigned 32-bit integer */
 693 alias ALCuint = uint;
 694
 695 /** non-negative 32-bit binary integer size */
 696 alias ALCsizei = int;
 697
 698 /** enumerated 32-bit value */
 699 alias ALCenum = int;
 700
 701 /** 32-bit IEEE754 floating-point */
 702 alias ALCfloat = float;
 703
 704 /** 64-bit IEEE754 floating-point */
 705 alias ALCdouble = double;
 706
 707 /** void type (for opaque pointers only) */
 708 alias ALCvoid = void;
 709
 710
 711 /* Enumerant values begin at column 50. No tabs. */
 712
 713 /** Boolean False. */
 714 enum ALC_FALSE = 0;
 715
 716 /** Boolean True. */
 717 enum ALC_TRUE = 1;
 718
 719 /** Context attribute: <int> Hz. */
 720 enum ALC_FREQUENCY = 0x1007;
 721
 722 /** Context attribute: <int> Hz. */
 723 enum ALC_REFRESH = 0x1008;
 724
 725 /** Context attribute: AL_TRUE or AL_FALSE. */
 726 enum ALC_SYNC = 0x1009;
 727
 728 /** Context attribute: <int> requested Mono (3D) Sources. */
 729 enum ALC_MONO_SOURCES = 0x1010;
 730
 731 /** Context attribute: <int> requested Stereo Sources. */
 732 enum ALC_STEREO_SOURCES = 0x1011;
 733
 734 /** No error. */
 735 enum ALC_NO_ERROR = 0;
 736
 737 /** Invalid device handle. */
 738 enum ALC_INVALID_DEVICE = 0xA001;
 739
 740 /** Invalid context handle. */
 741 enum ALC_INVALID_CONTEXT = 0xA002;
 742
 743 /** Invalid enum parameter passed to an ALC call. */
 744 enum ALC_INVALID_ENUM = 0xA003;
 745
 746 /** Invalid value parameter passed to an ALC call. */
 747 enum ALC_INVALID_VALUE = 0xA004;
 748
 749 /** Out of memory. */
 750 enum ALC_OUT_OF_MEMORY = 0xA005;
 751
 752
 753 /** Runtime ALC version. */
 754 enum ALC_MAJOR_VERSION = 0x1000;
 755 enum ALC_MINOR_VERSION = 0x1001;
 756
 757 /** Context attribute list properties. */
 758 enum ALC_ATTRIBUTES_SIZE = 0x1002;
 759 enum ALC_ALL_ATTRIBUTES = 0x1003;
 760
 761 /** String for the default device specifier. */
 762 enum ALC_DEFAULT_DEVICE_SPECIFIER = 0x1004;
 763 /**
 764  * String for the given device's specifier.
 765  *
 766  * If device handle is NULL, it is instead a null-char separated list of
 767  * strings of known device specifiers (list ends with an empty string).
 768  */
 769 enum ALC_DEVICE_SPECIFIER = 0x1005;
 770 /** String for space-separated list of ALC extensions. */
 771 enum ALC_EXTENSIONS = 0x1006;
 772
 773
 774 /** Capture extension */
 775 enum ALC_EXT_CAPTURE = 1;
 776 /**
 777  * String for the given capture device's specifier.
 778  *
 779  * If device handle is NULL, it is instead a null-char separated list of
 780  * strings of known capture device specifiers (list ends with an empty string).
 781  */
 782 enum ALC_CAPTURE_DEVICE_SPECIFIER = 0x310;
 783 /** String for the default capture device specifier. */
 784 enum ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER = 0x311;
 785 /** Number of sample frames available for capture. */
 786 enum ALC_CAPTURE_SAMPLES = 0x312;
 787
 788
 789 /** Enumerate All extension */
 790 enum ALC_ENUMERATE_ALL_EXT = 1;
 791 /** String for the default extended device specifier. */
 792 enum ALC_DEFAULT_ALL_DEVICES_SPECIFIER = 0x1012;
 793 /**
 794  * String for the given extended device's specifier.
 795  *
 796  * If device handle is NULL, it is instead a null-char separated list of
 797  * strings of known extended device specifiers (list ends with an empty string).
 798  */
 799 enum ALC_ALL_DEVICES_SPECIFIER = 0x1013;
 800
 801
 802 /** Context management. */
 803 /*ALC_API*/ ALCcontext* /*ALC_APIENTRY*/ alcCreateContext(ALCdevice* device, const(ALCint)* attrlist);
 804 /*ALC_API*/ ALCboolean  /*ALC_APIENTRY*/ alcMakeContextCurrent(ALCcontext* context);
 805 /*ALC_API*/ void        /*ALC_APIENTRY*/ alcProcessContext(ALCcontext* context);
 806 /*ALC_API*/ void        /*ALC_APIENTRY*/ alcSuspendContext(ALCcontext* context);
 807 /*ALC_API*/ void        /*ALC_APIENTRY*/ alcDestroyContext(ALCcontext* context);
 808 /*ALC_API*/ ALCcontext* /*ALC_APIENTRY*/ alcGetCurrentContext();
 809 /*ALC_API*/ ALCdevice* /*ALC_APIENTRY*/ alcGetContextsDevice(ALCcontext* context);
 810
 811 /** Device management. */
 812 /*ALC_API*/ ALCdevice* /*ALC_APIENTRY*/ alcOpenDevice(const(ALCchar)* devicename);
 813 /*ALC_API*/ ALCboolean /*ALC_APIENTRY*/ alcCloseDevice(ALCdevice* device);
 814
 815
 816 /**
 817  * Error support.
 818  *
 819  * Obtain the most recent Device error.
 820  */
 821 /*ALC_API*/ ALCenum /*ALC_APIENTRY*/ alcGetError(ALCdevice* device);
 822
 823 /**
 824  * Extension support.
 825  *
 826  * Query for the presence of an extension, and obtain any appropriate
 827  * function pointers and enum values.
 828  */
 829 /*ALC_API*/ ALCboolean /*ALC_APIENTRY*/ alcIsExtensionPresent(ALCdevice* device, const(ALCchar)* extname);
 830 /*ALC_API*/ void* /*ALC_APIENTRY*/ alcGetProcAddress(ALCdevice* device, const(ALCchar)* funcname);
 831 /*ALC_API*/ ALCenum    /*ALC_APIENTRY*/ alcGetEnumValue(ALCdevice* device, const(ALCchar)* enumname);
 832
 833 /** Query function. */
 834 /*ALC_API*/ const(ALCchar)* /*ALC_APIENTRY*/ alcGetString(ALCdevice* device, ALCenum param);
 835 /*ALC_API*/ void           /*ALC_APIENTRY*/ alcGetIntegerv(ALCdevice* device, ALCenum param, ALCsizei size, ALCint* values);
 836
 837 /** Capture function. */
 838 /*ALC_API*/ ALCdevice* /*ALC_APIENTRY*/ alcCaptureOpenDevice(const(ALCchar)* devicename, ALCuint frequency, ALCenum format, ALCsizei buffersize);
 839 /*ALC_API*/ ALCboolean /*ALC_APIENTRY*/ alcCaptureCloseDevice(ALCdevice* device);
 840 /*ALC_API*/ void       /*ALC_APIENTRY*/ alcCaptureStart(ALCdevice* device);
 841 /*ALC_API*/ void       /*ALC_APIENTRY*/ alcCaptureStop(ALCdevice* device);
 842 /*ALC_API*/ void       /*ALC_APIENTRY*/ alcCaptureSamples(ALCdevice* device, ALCvoid* buffer, ALCsizei samples);
 843
 844 /** Pointer-to-function type, useful for dynamically getting ALC entry points. */
 845 /+
 846 typedef ALCcontext* (/*ALC_APIENTRY*/ *LPALCCREATECONTEXT)(ALCdevice* device, const(ALCint)* attrlist);
 847 typedef ALCboolean     (/*ALC_APIENTRY*/ *LPALCMAKECONTEXTCURRENT)(ALCcontext* context);
 848 typedef void           (/*ALC_APIENTRY*/ *LPALCPROCESSCONTEXT)(ALCcontext* context);
 849 typedef void           (/*ALC_APIENTRY*/ *LPALCSUSPENDCONTEXT)(ALCcontext* context);
 850 typedef void           (/*ALC_APIENTRY*/ *LPALCDESTROYCONTEXT)(ALCcontext* context);
 851 typedef ALCcontext* (/*ALC_APIENTRY*/ *LPALCGETCURRENTCONTEXT)(void);
 852 typedef ALCdevice* (/*ALC_APIENTRY*/ *LPALCGETCONTEXTSDEVICE)(ALCcontext* context);
 853 typedef ALCdevice* (/*ALC_APIENTRY*/ *LPALCOPENDEVICE)(const(ALCchar)* devicename);
 854 typedef ALCboolean     (/*ALC_APIENTRY*/ *LPALCCLOSEDEVICE)(ALCdevice* device);
 855 typedef ALCenum        (/*ALC_APIENTRY*/ *LPALCGETERROR)(ALCdevice* device);
 856 typedef ALCboolean     (/*ALC_APIENTRY*/ *LPALCISEXTENSIONPRESENT)(ALCdevice* device, const(ALCchar)* extname);
 857 typedef void*          (/*ALC_APIENTRY*/ *LPALCGETPROCADDRESS)(ALCdevice* device, const(ALCchar)* funcname);
 858 typedef ALCenum        (/*ALC_APIENTRY*/ *LPALCGETENUMVALUE)(ALCdevice* device, const(ALCchar)* enumname);
 859 typedef const(ALCchar)* (/*ALC_APIENTRY*/ *LPALCGETSTRING)(ALCdevice* device, ALCenum param);
 860 typedef void           (/*ALC_APIENTRY*/ *LPALCGETINTEGERV)(ALCdevice* device, ALCenum param, ALCsizei size, ALCint *values);
 861 typedef ALCdevice* (/*ALC_APIENTRY*/ *LPALCCAPTUREOPENDEVICE)(const(ALCchar)* devicename, ALCuint frequency, ALCenum format, ALCsizei buffersize);
 862 typedef ALCboolean     (/*ALC_APIENTRY*/ *LPALCCAPTURECLOSEDEVICE)(ALCdevice* device);
 863 typedef void           (/*ALC_APIENTRY*/ *LPALCCAPTURESTART)(ALCdevice* device);
 864 typedef void           (/*ALC_APIENTRY*/ *LPALCCAPTURESTOP)(ALCdevice* device);
 865 typedef void           (/*ALC_APIENTRY*/ *LPALCCAPTURESAMPLES)(ALCdevice* device, ALCvoid *buffer, ALCsizei samples);
 866 +/
 867
 868 enum AL_LOKI_IMA_ADPCM_format = true;
 869 enum AL_FORMAT_IMA_ADPCM_MONO16_EXT = 0x10000;
 870 enum AL_FORMAT_IMA_ADPCM_STEREO16_EXT = 0x10001;
 871
 872 enum AL_LOKI_WAVE_format = true;
 873 enum AL_FORMAT_WAVE_EXT = 0x10002;
 874
 875 enum AL_EXT_vorbis = true;
 876 enum AL_FORMAT_VORBIS_EXT = 0x10003;
 877
 878 enum AL_LOKI_quadriphonic = true;
 879 enum AL_FORMAT_QUAD8_LOKI = 0x10004;
 880 enum AL_FORMAT_QUAD16_LOKI = 0x10005;
 881
 882 enum AL_EXT_float32 = true;
 883 enum AL_FORMAT_MONO_FLOAT32 = 0x10010;
 884 enum AL_FORMAT_STEREO_FLOAT32 = 0x10011;
 885
 886 enum AL_EXT_double = true;
 887 enum AL_FORMAT_MONO_DOUBLE_EXT = 0x10012;
 888 enum AL_FORMAT_STEREO_DOUBLE_EXT = 0x10013;
 889
 890 enum AL_EXT_MULAW = true;
 891 enum AL_FORMAT_MONO_MULAW_EXT = 0x10014;
 892 enum AL_FORMAT_STEREO_MULAW_EXT = 0x10015;
 893
 894 enum AL_EXT_ALAW = true;
 895 enum AL_FORMAT_MONO_ALAW_EXT = 0x10016;
 896 enum AL_FORMAT_STEREO_ALAW_EXT = 0x10017;
 897
 898 enum ALC_LOKI_audio_channel = true;
 899 enum ALC_CHAN_MAIN_LOKI = 0x500001;
 900 enum ALC_CHAN_PCM_LOKI = 0x500002;
 901 enum ALC_CHAN_CD_LOKI = 0x500003;
 902
 903 enum AL_EXT_MCFORMATS = true;
 904 enum AL_FORMAT_QUAD8 = 0x1204;
 905 enum AL_FORMAT_QUAD16 = 0x1205;
 906 enum AL_FORMAT_QUAD32 = 0x1206;
 907 enum AL_FORMAT_REAR8 = 0x1207;
 908 enum AL_FORMAT_REAR16 = 0x1208;
 909 enum AL_FORMAT_REAR32 = 0x1209;
 910 enum AL_FORMAT_51CHN8 = 0x120A;
 911 enum AL_FORMAT_51CHN16 = 0x120B;
 912 enum AL_FORMAT_51CHN32 = 0x120C;
 913 enum AL_FORMAT_61CHN8 = 0x120D;
 914 enum AL_FORMAT_61CHN16 = 0x120E;
 915 enum AL_FORMAT_61CHN32 = 0x120F;
 916 enum AL_FORMAT_71CHN8 = 0x1210;
 917 enum AL_FORMAT_71CHN16 = 0x1211;
 918 enum AL_FORMAT_71CHN32 = 0x1212;
 919
 920 enum AL_EXT_MULAW_MCFORMATS = true;
 921 enum AL_FORMAT_MONO_MULAW = 0x10014;
 922 enum AL_FORMAT_STEREO_MULAW = 0x10015;
 923 enum AL_FORMAT_QUAD_MULAW = 0x10021;
 924 enum AL_FORMAT_REAR_MULAW = 0x10022;
 925 enum AL_FORMAT_51CHN_MULAW = 0x10023;
 926 enum AL_FORMAT_61CHN_MULAW = 0x10024;
 927 enum AL_FORMAT_71CHN_MULAW = 0x10025;
 928
 929 enum AL_EXT_IMA4 = true;
 930 enum AL_FORMAT_MONO_IMA4 = 0x1300;
 931 enum AL_FORMAT_STEREO_IMA4 = 0x1301;
 932
 933 enum AL_EXT_STATIC_BUFFER = true;
 934 //typedef ALvoid (/*AL_APIENTRY*/*PFNALBUFFERDATASTATICPROC)(const ALint,ALenum,ALvoid*,ALsizei,ALsizei);
 935 /*AL_API*/ ALvoid /*AL_APIENTRY*/ alBufferDataStatic(const ALint buffer, ALenum format, ALvoid* data, ALsizei len, ALsizei freq);
 936
 937 enum ALC_EXT_EFX = true;
 938 //#include "efx.h" // below
 939
 940 enum ALC_EXT_disconnect = true;
 941 enum ALC_CONNECTED = 0x313;
 942
 943 enum ALC_EXT_thread_local_context = true;
 944 //typedef ALCboolean  (/*ALC_APIENTRY*/*PFNALCSETTHREADCONTEXTPROC)(ALCcontext* context);
 945 //typedef ALCcontext* (/*ALC_APIENTRY*/*PFNALCGETTHREADCONTEXTPROC)(void);
 946 /*ALC_API*/ ALCboolean  /*ALC_APIENTRY*/ alcSetThreadContext(ALCcontext* context);
 947 /*ALC_API*/ ALCcontext* /*ALC_APIENTRY*/ alcGetThreadContext();
 948
 949 enum AL_EXT_source_distance_model = true;
 950 enum AL_SOURCE_DISTANCE_MODEL = 0x200;
 951
 952 enum AL_SOFT_buffer_sub_data = true;
 953 enum AL_BYTE_RW_OFFSETS_SOFT = 0x1031;
 954 enum AL_SAMPLE_RW_OFFSETS_SOFT = 0x1032;
 955 //typedef ALvoid (/*AL_APIENTRY*/*PFNALBUFFERSUBDATASOFTPROC)(ALuint,ALenum,const(ALvoid)* ,ALsizei,ALsizei);
 956 /*AL_API*/ ALvoid /*AL_APIENTRY*/ alBufferSubDataSOFT(ALuint buffer,ALenum format,const(ALvoid)* data,ALsizei offset,ALsizei length);
 957
 958 enum AL_SOFT_loop_points = true;
 959 enum AL_LOOP_POINTS_SOFT = 0x2015;
 960
 961 enum AL_EXT_FOLDBACK = true;
 962 enum AL_EXT_FOLDBACK_NAME = "AL_EXT_FOLDBACK";
 963 enum AL_FOLDBACK_EVENT_BLOCK = 0x4112;
 964 enum AL_FOLDBACK_EVENT_START = 0x4111;
 965 enum AL_FOLDBACK_EVENT_STOP = 0x4113;
 966 enum AL_FOLDBACK_MODE_MONO = 0x4101;
 967 enum AL_FOLDBACK_MODE_STEREO = 0x4102;
 968 //typedef void (/*AL_APIENTRY*/*LPALFOLDBACKCALLBACK)(ALenum,ALsizei);
 969 alias LPALFOLDBACKCALLBACK = void function (ALenum,ALsizei);
 970 //typedef void (/*AL_APIENTRY*/*LPALREQUESTFOLDBACKSTART)(ALenum,ALsizei,ALsizei,ALfloat*,LPALFOLDBACKCALLBACK);
 971 //typedef void (/*AL_APIENTRY*/*LPALREQUESTFOLDBACKSTOP)();
 972 /*AL_API*/ void /*AL_APIENTRY*/ alRequestFoldbackStart(ALenum mode,ALsizei count,ALsizei length,ALfloat* mem,LPALFOLDBACKCALLBACK callback);
 973 /*AL_API*/ void /*AL_APIENTRY*/ alRequestFoldbackStop();
 974
 975 enum ALC_EXT_DEDICATED = true;
 976 enum AL_DEDICATED_GAIN = 0x0001;
 977 enum AL_EFFECT_DEDICATED_DIALOGUE = 0x9001;
 978 enum AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT = 0x9000;
 979
 980 enum AL_SOFT_buffer_samples = false; //removed in OpenAL-soft
 981 /* Channel configurations */
 982 /*removed in OpenAL-soft:
 983 enum AL_MONO_SOFT = 0x1500;
 984 enum AL_STEREO_SOFT = 0x1501;
 985 enum AL_REAR_SOFT = 0x1502;
 986 enum AL_QUAD_SOFT = 0x1503;
 987 enum AL_5POINT1_SOFT = 0x1504;
 988 enum AL_6POINT1_SOFT = 0x1505;
 989 enum AL_7POINT1_SOFT = 0x1506;
 990 */
 991
 992 /* Sample types */
 993 /*removed in OpenAL-soft:
 994 enum AL_BYTE_SOFT = 0x1400;
 995 enum AL_UNSIGNED_BYTE_SOFT = 0x1401;
 996 enum AL_SHORT_SOFT = 0x1402;
 997 enum AL_UNSIGNED_SHORT_SOFT = 0x1403;
 998 enum AL_INT_SOFT = 0x1404;
 999 enum AL_UNSIGNED_INT_SOFT = 0x1405;
1000 enum AL_FLOAT_SOFT = 0x1406;
1001 enum AL_DOUBLE_SOFT = 0x1407;
1002 enum AL_BYTE3_SOFT = 0x1408;
1003 enum AL_UNSIGNED_BYTE3_SOFT = 0x1409;
1004 */
1005
1006 /* Storage formats */
1007 /*removed in OpenAL-soft:
1008 enum AL_MONO8_SOFT = 0x1100;
1009 enum AL_MONO16_SOFT = 0x1101;
1010 enum AL_MONO32F_SOFT = 0x10010;
1011 enum AL_STEREO8_SOFT = 0x1102;
1012 enum AL_STEREO16_SOFT = 0x1103;
1013 enum AL_STEREO32F_SOFT = 0x10011;
1014 enum AL_QUAD8_SOFT = 0x1204;
1015 enum AL_QUAD16_SOFT = 0x1205;
1016 enum AL_QUAD32F_SOFT = 0x1206;
1017 enum AL_REAR8_SOFT = 0x1207;
1018 enum AL_REAR16_SOFT = 0x1208;
1019 enum AL_REAR32F_SOFT = 0x1209;
1020 enum AL_5POINT1_8_SOFT = 0x120A;
1021 enum AL_5POINT1_16_SOFT = 0x120B;
1022 enum AL_5POINT1_32F_SOFT = 0x120C;
1023 enum AL_6POINT1_8_SOFT = 0x120D;
1024 enum AL_6POINT1_16_SOFT = 0x120E;
1025 enum AL_6POINT1_32F_SOFT = 0x120F;
1026 enum AL_7POINT1_8_SOFT = 0x1210;
1027 enum AL_7POINT1_16_SOFT = 0x1211;
1028 enum AL_7POINT1_32F_SOFT = 0x1212;
1029 */
1030
1031 /* Buffer attributes */
1032 enum AL_INTERNAL_FORMAT_SOFT = 0x2008;
1033 enum AL_BYTE_LENGTH_SOFT = 0x2009;
1034 enum AL_SAMPLE_LENGTH_SOFT = 0x200A;
1035 enum AL_SEC_LENGTH_SOFT = 0x200B;
1036
1037 //typedef void (/*AL_APIENTRY*/*LPALBUFFERSAMPLESSOFT)(ALuint,ALuint,ALenum,ALsizei,ALenum,ALenum,const(ALvoid)* );
1038 //typedef void (/*AL_APIENTRY*/*LPALBUFFERSUBSAMPLESSOFT)(ALuint,ALsizei,ALsizei,ALenum,ALenum,const(ALvoid)* );
1039 //typedef void (/*AL_APIENTRY*/*LPALGETBUFFERSAMPLESSOFT)(ALuint,ALsizei,ALsizei,ALenum,ALenum,ALvoid*);
1040 //typedef ALboolean (/*AL_APIENTRY*/*LPALISBUFFERFORMATSUPPORTEDSOFT)(ALenum);
1041 //removed in OpenAL-soft: /*AL_API*/ void /*AL_APIENTRY*/ alBufferSamplesSOFT(ALuint buffer, ALuint samplerate, ALenum internalformat, ALsizei samples, ALenum channels, ALenum type, const(ALvoid)* data);
1042 //removed in OpenAL-soft: /*AL_API*/ void /*AL_APIENTRY*/ alBufferSubSamplesSOFT(ALuint buffer, ALsizei offset, ALsizei samples, ALenum channels, ALenum type, const(ALvoid)* data);
1043 //removed in OpenAL-soft: /*AL_API*/ void /*AL_APIENTRY*/ alGetBufferSamplesSOFT(ALuint buffer, ALsizei offset, ALsizei samples, ALenum channels, ALenum type, ALvoid* data);
1044 //removed in OpenAL-soft: /*AL_API*/ ALboolean /*AL_APIENTRY*/ alIsBufferFormatSupportedSOFT(ALenum format);
1045
1046 enum AL_SOFT_direct_channels = true;
1047 enum AL_DIRECT_CHANNELS_SOFT = 0x1033;
1048
1049 enum ALC_SOFT_loopback = true;
1050 enum ALC_FORMAT_CHANNELS_SOFT = 0x1990;
1051 enum ALC_FORMAT_TYPE_SOFT = 0x1991;
1052
1053 /* Sample types */
1054 enum ALC_BYTE_SOFT = 0x1400;
1055 enum ALC_UNSIGNED_BYTE_SOFT = 0x1401;
1056 enum ALC_SHORT_SOFT = 0x1402;
1057 enum ALC_UNSIGNED_SHORT_SOFT = 0x1403;
1058 enum ALC_INT_SOFT = 0x1404;
1059 enum ALC_UNSIGNED_INT_SOFT = 0x1405;
1060 enum ALC_FLOAT_SOFT = 0x1406;
1061
1062 /* Channel configurations */
1063 enum ALC_MONO_SOFT = 0x1500;
1064 enum ALC_STEREO_SOFT = 0x1501;
1065 enum ALC_QUAD_SOFT = 0x1503;
1066 enum ALC_5POINT1_SOFT = 0x1504;
1067 enum ALC_6POINT1_SOFT = 0x1505;
1068 enum ALC_7POINT1_SOFT = 0x1506;
1069
1070 //typedef ALCdevice* (/*ALC_APIENTRY*/*LPALCLOOPBACKOPENDEVICESOFT)(const(ALCchar)* );
1071 //typedef ALCboolean (/*ALC_APIENTRY*/*LPALCISRENDERFORMATSUPPORTEDSOFT)(ALCdevice* ,ALCsizei,ALCenum,ALCenum);
1072 //typedef void (/*ALC_APIENTRY*/*LPALCRENDERSAMPLESSOFT)(ALCdevice* ,ALCvoid*,ALCsizei);
1073 /*ALC_API*/ ALCdevice* /*ALC_APIENTRY*/ alcLoopbackOpenDeviceSOFT(const(ALCchar)* deviceName);
1074 /*ALC_API*/ ALCboolean /*ALC_APIENTRY*/ alcIsRenderFormatSupportedSOFT(ALCdevice* device, ALCsizei freq, ALCenum channels, ALCenum type);
1075 /*ALC_API*/ void /*ALC_APIENTRY*/ alcRenderSamplesSOFT(ALCdevice* device, ALCvoid* buffer, ALCsizei samples);
1076
1077 enum AL_EXT_STEREO_ANGLES = true;
1078 enum AL_STEREO_ANGLES = 0x1030;
1079
1080 enum AL_EXT_SOURCE_RADIUS = true;
1081 enum AL_SOURCE_RADIUS = 0x1031;
1082
1083 enum AL_SOFT_source_latency = true;
1084 enum AL_SAMPLE_OFFSET_LATENCY_SOFT = 0x1200;
1085 enum AL_SEC_OFFSET_LATENCY_SOFT = 0x1201;
1086 alias ALint64SOFT = long;
1087 alias ALuint64SOFT = ulong;
1088 /+
1089 typedef void (/*AL_APIENTRY*/*LPALSOURCEDSOFT)(ALuint,ALenum,ALdouble);
1090 typedef void (/*AL_APIENTRY*/*LPALSOURCE3DSOFT)(ALuint,ALenum,ALdouble,ALdouble,ALdouble);
1091 typedef void (/*AL_APIENTRY*/*LPALSOURCEDVSOFT)(ALuint,ALenum,const(ALdouble)* );
1092 typedef void (/*AL_APIENTRY*/*LPALGETSOURCEDSOFT)(ALuint,ALenum,ALdouble*);
1093 typedef void (/*AL_APIENTRY*/*LPALGETSOURCE3DSOFT)(ALuint,ALenum,ALdouble*,ALdouble*,ALdouble*);
1094 typedef void (/*AL_APIENTRY*/*LPALGETSOURCEDVSOFT)(ALuint,ALenum,ALdouble*);
1095 typedef void (/*AL_APIENTRY*/*LPALSOURCEI64SOFT)(ALuint,ALenum,ALint64SOFT);
1096 typedef void (/*AL_APIENTRY*/*LPALSOURCE3I64SOFT)(ALuint,ALenum,ALint64SOFT,ALint64SOFT,ALint64SOFT);
1097 typedef void (/*AL_APIENTRY*/*LPALSOURCEI64VSOFT)(ALuint,ALenum,const ALint64SOFT*);
1098 typedef void (/*AL_APIENTRY*/*LPALGETSOURCEI64SOFT)(ALuint,ALenum,ALint64SOFT*);
1099 typedef void (/*AL_APIENTRY*/*LPALGETSOURCE3I64SOFT)(ALuint,ALenum,ALint64SOFT*,ALint64SOFT*,ALint64SOFT*);
1100 typedef void (/*AL_APIENTRY*/*LPALGETSOURCEI64VSOFT)(ALuint,ALenum,ALint64SOFT*);
1101 +/
1102 /*AL_API*/ void /*AL_APIENTRY*/ alSourcedSOFT(ALuint source, ALenum param, ALdouble value);
1103 /*AL_API*/ void /*AL_APIENTRY*/ alSource3dSOFT(ALuint source, ALenum param, ALdouble value1, ALdouble value2, ALdouble value3);
1104 /*AL_API*/ void /*AL_APIENTRY*/ alSourcedvSOFT(ALuint source, ALenum param, const(ALdouble)* values);
1105 /*AL_API*/ void /*AL_APIENTRY*/ alGetSourcedSOFT(ALuint source, ALenum param, ALdouble* value);
1106 /*AL_API*/ void /*AL_APIENTRY*/ alGetSource3dSOFT(ALuint source, ALenum param, ALdouble* value1, ALdouble* value2, ALdouble* value3);
1107 /*AL_API*/ void /*AL_APIENTRY*/ alGetSourcedvSOFT(ALuint source, ALenum param, ALdouble* values);
1108 /*AL_API*/ void /*AL_APIENTRY*/ alSourcei64SOFT(ALuint source, ALenum param, ALint64SOFT value);
1109 /*AL_API*/ void /*AL_APIENTRY*/ alSource3i64SOFT(ALuint source, ALenum param, ALint64SOFT value1, ALint64SOFT value2, ALint64SOFT value3);
1110 /*AL_API*/ void /*AL_APIENTRY*/ alSourcei64vSOFT(ALuint source, ALenum param, const ALint64SOFT *values);
1111 /*AL_API*/ void /*AL_APIENTRY*/ alGetSourcei64SOFT(ALuint source, ALenum param, ALint64SOFT *value);
1112 /*AL_API*/ void /*AL_APIENTRY*/ alGetSource3i64SOFT(ALuint source, ALenum param, ALint64SOFT *value1, ALint64SOFT *value2, ALint64SOFT *value3);
1113 /*AL_API*/ void /*AL_APIENTRY*/ alGetSourcei64vSOFT(ALuint source, ALenum param, ALint64SOFT *values);
1114
1115 enum ALC_EXT_DEFAULT_FILTER_ORDER = true;
1116 enum ALC_DEFAULT_FILTER_ORDER = 0x1100;
1117
1118 enum AL_SOFT_deferred_updates = true;
1119 enum AL_DEFERRED_UPDATES_SOFT = 0xC002;
1120 //typedef ALvoid (/*AL_APIENTRY*/*LPALDEFERUPDATESSOFT)();
1121 //typedef ALvoid (/*AL_APIENTRY*/*LPALPROCESSUPDATESSOFT)();
1122 /*AL_API*/ ALvoid /*AL_APIENTRY*/ alDeferUpdatesSOFT();
1123 /*AL_API*/ ALvoid /*AL_APIENTRY*/ alProcessUpdatesSOFT();
1124
1125 enum AL_SOFT_block_alignment = true;
1126 enum AL_UNPACK_BLOCK_ALIGNMENT_SOFT = 0x200C;
1127 enum AL_PACK_BLOCK_ALIGNMENT_SOFT = 0x200D;
1128
1129 enum AL_SOFT_MSADPCM = true;
1130 enum AL_FORMAT_MONO_MSADPCM_SOFT = 0x1302;
1131 enum AL_FORMAT_STEREO_MSADPCM_SOFT = 0x1303;
1132
1133 enum AL_SOFT_source_length = true;
1134 //??? it was commented in the original C header
1135 /*#define AL_BYTE_LENGTH_SOFT                      0x2009*/
1136 /*#define AL_SAMPLE_LENGTH_SOFT                    0x200A*/
1137 /*#define AL_SEC_LENGTH_SOFT                       0x200B*/
1138
1139 enum ALC_SOFT_pause_device = true;
1140 //typedef void (/*ALC_APIENTRY*/*LPALCDEVICEPAUSESOFT)(ALCdevice* device);
1141 //typedef void (/*ALC_APIENTRY*/*LPALCDEVICERESUMESOFT)(ALCdevice* device);
1142 /*ALC_API*/ void /*ALC_APIENTRY*/ alcDevicePauseSOFT(ALCdevice* device);
1143 /*ALC_API*/ void /*ALC_APIENTRY*/ alcDeviceResumeSOFT(ALCdevice* device);
1144
1145 enum AL_EXT_BFORMAT = true;
1146 enum AL_FORMAT_BFORMAT2D_8 = 0x20021;
1147 enum AL_FORMAT_BFORMAT2D_16 = 0x20022;
1148 enum AL_FORMAT_BFORMAT2D_FLOAT32 = 0x20023;
1149 enum AL_FORMAT_BFORMAT3D_8 = 0x20031;
1150 enum AL_FORMAT_BFORMAT3D_16 = 0x20032;
1151 enum AL_FORMAT_BFORMAT3D_FLOAT32 = 0x20033;
1152
1153 enum AL_EXT_MULAW_BFORMAT = true;
1154 enum AL_FORMAT_BFORMAT2D_MULAW = 0x10031;
1155 enum AL_FORMAT_BFORMAT3D_MULAW = 0x10032;
1156
1157 enum ALC_SOFT_HRTF = true;
1158 enum ALC_HRTF_SOFT = 0x1992;
1159 enum ALC_DONT_CARE_SOFT = 0x0002;
1160 enum ALC_HRTF_STATUS_SOFT = 0x1993;
1161 enum ALC_HRTF_DISABLED_SOFT = 0x0000;
1162 enum ALC_HRTF_ENABLED_SOFT = 0x0001;
1163 enum ALC_HRTF_DENIED_SOFT = 0x0002;
1164 enum ALC_HRTF_REQUIRED_SOFT = 0x0003;
1165 enum ALC_HRTF_HEADPHONES_DETECTED_SOFT = 0x0004;
1166 enum ALC_HRTF_UNSUPPORTED_FORMAT_SOFT = 0x0005;
1167 enum ALC_NUM_HRTF_SPECIFIERS_SOFT = 0x1994;
1168 enum ALC_HRTF_SPECIFIER_SOFT = 0x1995;
1169 enum ALC_HRTF_ID_SOFT = 0x1996;
1170 //typedef const(ALCchar)* (/*ALC_APIENTRY*/*LPALCGETSTRINGISOFT)(ALCdevice* device, ALCenum paramName, ALCsizei index);
1171 //typedef ALCboolean (/*ALC_APIENTRY*/*LPALCRESETDEVICESOFT)(ALCdevice* device, const(ALCint)* attribs);
1172 /*ALC_API*/ const(ALCchar)* /*ALC_APIENTRY*/ alcGetStringiSOFT(ALCdevice* device, ALCenum paramName, ALCsizei index);
1173 /*ALC_API*/ ALCboolean /*ALC_APIENTRY*/ alcResetDeviceSOFT(ALCdevice* device, const(ALCint)* attribs);
1174
1175 enum AL_SOFT_gain_clamp_ex = true;
1176 enum AL_GAIN_LIMIT_SOFT = 0x200E;
1177
1178 enum AL_SOFT_source_resampler = true;
1179 enum AL_NUM_RESAMPLERS_SOFT = 0x1210;
1180 enum AL_DEFAULT_RESAMPLER_SOFT = 0x1211;
1181 enum AL_SOURCE_RESAMPLER_SOFT = 0x1212;
1182 enum AL_RESAMPLER_NAME_SOFT = 0x1213;
1183 //typedef const(ALchar)* (/*AL_APIENTRY*/*LPALGETSTRINGISOFT)(ALenum pname, ALsizei index);
1184 /*AL_API*/ const(ALchar)* /*AL_APIENTRY*/ alGetStringiSOFT(ALenum pname, ALsizei index);
1185
1186 enum AL_SOFT_source_spatialize = true;
1187 enum AL_SOURCE_SPATIALIZE_SOFT = 0x1214;
1188 enum AL_AUTO_SOFT = 0x0002;
1189
1190 enum ALC_SOFT_output_limiter = true;
1191 enum ALC_OUTPUT_LIMITER_SOFT = 0x199A;
1192
1193
1194 // ////////////////////////////////////////////////////////////////////////// //
1195 // ALUT
1196 version(openal_alut) {
1197 pragma(lib, "alut");
1198 enum ALUT_API_MAJOR_VERSION = 1;
1199 enum ALUT_API_MINOR_VERSION = 1;
1200
1201 enum ALUT_ERROR_NO_ERROR = 0;
1202 enum ALUT_ERROR_OUT_OF_MEMORY = 0x200;
1203 enum ALUT_ERROR_INVALID_ENUM = 0x201;
1204 enum ALUT_ERROR_INVALID_VALUE = 0x202;
1205 enum ALUT_ERROR_INVALID_OPERATION = 0x203;
1206 enum ALUT_ERROR_NO_CURRENT_CONTEXT = 0x204;
1207 enum ALUT_ERROR_AL_ERROR_ON_ENTRY = 0x205;
1208 enum ALUT_ERROR_ALC_ERROR_ON_ENTRY = 0x206;
1209 enum ALUT_ERROR_OPEN_DEVICE = 0x207;
1210 enum ALUT_ERROR_CLOSE_DEVICE = 0x208;
1211 enum ALUT_ERROR_CREATE_CONTEXT = 0x209;
1212 enum ALUT_ERROR_MAKE_CONTEXT_CURRENT = 0x20A;
1213 enum ALUT_ERROR_DESTROY_CONTEXT = 0x20B;
1214 enum ALUT_ERROR_GEN_BUFFERS = 0x20C;
1215 enum ALUT_ERROR_BUFFER_DATA = 0x20D;
1216 enum ALUT_ERROR_IO_ERROR = 0x20E;
1217 enum ALUT_ERROR_UNSUPPORTED_FILE_TYPE = 0x20F;
1218 enum ALUT_ERROR_UNSUPPORTED_FILE_SUBTYPE = 0x210;
1219 enum ALUT_ERROR_CORRUPT_OR_TRUNCATED_DATA = 0x211;
1220
1221 enum ALUT_WAVEFORM_SINE = 0x100;
1222 enum ALUT_WAVEFORM_SQUARE = 0x101;
1223 enum ALUT_WAVEFORM_SAWTOOTH = 0x102;
1224 enum ALUT_WAVEFORM_WHITENOISE = 0x103;
1225 enum ALUT_WAVEFORM_IMPULSE = 0x104;
1226
1227 enum ALUT_LOADER_BUFFER = 0x300;
1228 enum ALUT_LOADER_MEMORY = 0x301;
1229
1230 /*ALUT_API*/ ALboolean /*ALUT_APIENTRY*/ alutInit (int* argcp, char** argv);
1231 /*ALUT_API*/ ALboolean /*ALUT_APIENTRY*/ alutInitWithoutContext (int* argcp, char** argv);
1232 /*ALUT_API*/ ALboolean /*ALUT_APIENTRY*/ alutExit ();
1233
1234 /*ALUT_API*/ ALenum /*ALUT_APIENTRY*/ alutGetError ();
1235 /*ALUT_API*/ const(char)* /*ALUT_APIENTRY*/ alutGetErrorString (ALenum error);
1236
1237 /*ALUT_API*/ ALuint /*ALUT_APIENTRY*/ alutCreateBufferFromFile (const(char)* fileName);
1238 /*ALUT_API*/ ALuint /*ALUT_APIENTRY*/ alutCreateBufferFromFileImage (const(ALvoid)* data, ALsizei length);
1239 /*ALUT_API*/ ALuint /*ALUT_APIENTRY*/ alutCreateBufferHelloWorld ();
1240 /*ALUT_API*/ ALuint /*ALUT_APIENTRY*/ alutCreateBufferWaveform (ALenum waveshape, ALfloat frequency, ALfloat phase, ALfloat duration);
1241
1242 /*ALUT_API*/ ALvoid* /*ALUT_APIENTRY*/ alutLoadMemoryFromFile (const(char)* fileName, ALenum* format, ALsizei* size, ALfloat* frequency);
1243 /*ALUT_API*/ ALvoid* /*ALUT_APIENTRY*/ alutLoadMemoryFromFileImage (const(ALvoid)* data, ALsizei length, ALenum* format, ALsizei* size, ALfloat* frequency);
1244 /*ALUT_API*/ ALvoid* /*ALUT_APIENTRY*/ alutLoadMemoryHelloWorld (ALenum* format, ALsizei* size, ALfloat* frequency);
1245 /*ALUT_API*/ ALvoid* /*ALUT_APIENTRY*/ alutLoadMemoryWaveform (ALenum waveshape, ALfloat frequency, ALfloat phase, ALfloat duration, ALenum* format, ALsizei* size, ALfloat* freq);
1246
1247 /*ALUT_API*/ const(char)* /*ALUT_APIENTRY*/ alutGetMIMETypes (ALenum loader);
1248
1249 /*ALUT_API*/ ALint /*ALUT_APIENTRY*/ alutGetMajorVersion ();
1250 /*ALUT_API*/ ALint /*ALUT_APIENTRY*/ alutGetMinorVersion ();
1251
1252 /*ALUT_API*/ ALboolean /*ALUT_APIENTRY*/ alutSleep (ALfloat duration);
1253
1254 /* Nasty Compatibility stuff, WARNING: THESE FUNCTIONS ARE STRONGLY DEPRECATED */
1255 /*ALUT_API*/ /*ALUT_ATTRIBUTE_DEPRECATED*/ deprecated void /*ALUT_APIENTRY*/ alutLoadWAVFile (ALbyte* fileName, ALenum* format, void** data, ALsizei* size, ALsizei* frequency, ALboolean* loop);
1256 /*ALUT_API*/ /*ALUT_ATTRIBUTE_DEPRECATED*/ deprecated void /*ALUT_APIENTRY*/ alutLoadWAVMemory (ALbyte* buffer, ALenum* format, void** data, ALsizei* size, ALsizei* frequency, ALboolean* loop);
1257 /*ALUT_API*/ /*ALUT_ATTRIBUTE_DEPRECATED*/ deprecated void /*ALUT_APIENTRY*/ alutUnloadWAV (ALenum format, ALvoid* data, ALsizei size, ALsizei frequency);
1258 }
1259 // ////////////////////////////////////////////////////////////////////////// //
1260
1261
1262 enum ALC_EXT_EFX_NAME = "ALC_EXT_EFX";
1263
1264 enum ALC_EFX_MAJOR_VERSION = 0x20001;
1265 enum ALC_EFX_MINOR_VERSION = 0x20002;
1266 enum ALC_MAX_AUXILIARY_SENDS = 0x20003;
1267
1268
1269 /* Listener properties. */
1270 enum AL_METERS_PER_UNIT = 0x20004;
1271
1272 /* Source properties. */
1273 enum AL_DIRECT_FILTER = 0x20005;
1274 enum AL_AUXILIARY_SEND_FILTER = 0x20006;
1275 enum AL_AIR_ABSORPTION_FACTOR = 0x20007;
1276 enum AL_ROOM_ROLLOFF_FACTOR = 0x20008;
1277 enum AL_CONE_OUTER_GAINHF = 0x20009;
1278 enum AL_DIRECT_FILTER_GAINHF_AUTO = 0x2000A;
1279 enum AL_AUXILIARY_SEND_FILTER_GAIN_AUTO = 0x2000B;
1280 enum AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO = 0x2000C;
1281
1282
1283 /* Effect properties. */
1284
1285 /* Reverb effect parameters */
1286 enum AL_REVERB_DENSITY = 0x0001;
1287 enum AL_REVERB_DIFFUSION = 0x0002;
1288 enum AL_REVERB_GAIN = 0x0003;
1289 enum AL_REVERB_GAINHF = 0x0004;
1290 enum AL_REVERB_DECAY_TIME = 0x0005;
1291 enum AL_REVERB_DECAY_HFRATIO = 0x0006;
1292 enum AL_REVERB_REFLECTIONS_GAIN = 0x0007;
1293 enum AL_REVERB_REFLECTIONS_DELAY = 0x0008;
1294 enum AL_REVERB_LATE_REVERB_GAIN = 0x0009;
1295 enum AL_REVERB_LATE_REVERB_DELAY = 0x000A;
1296 enum AL_REVERB_AIR_ABSORPTION_GAINHF = 0x000B;
1297 enum AL_REVERB_ROOM_ROLLOFF_FACTOR = 0x000C;
1298 enum AL_REVERB_DECAY_HFLIMIT = 0x000D;
1299
1300 /* EAX Reverb effect parameters */
1301 enum AL_EAXREVERB_DENSITY = 0x0001;
1302 enum AL_EAXREVERB_DIFFUSION = 0x0002;
1303 enum AL_EAXREVERB_GAIN = 0x0003;
1304 enum AL_EAXREVERB_GAINHF = 0x0004;
1305 enum AL_EAXREVERB_GAINLF = 0x0005;
1306 enum AL_EAXREVERB_DECAY_TIME = 0x0006;
1307 enum AL_EAXREVERB_DECAY_HFRATIO = 0x0007;
1308 enum AL_EAXREVERB_DECAY_LFRATIO = 0x0008;
1309 enum AL_EAXREVERB_REFLECTIONS_GAIN = 0x0009;
1310 enum AL_EAXREVERB_REFLECTIONS_DELAY = 0x000A;
1311 enum AL_EAXREVERB_REFLECTIONS_PAN = 0x000B;
1312 enum AL_EAXREVERB_LATE_REVERB_GAIN = 0x000C;
1313 enum AL_EAXREVERB_LATE_REVERB_DELAY = 0x000D;
1314 enum AL_EAXREVERB_LATE_REVERB_PAN = 0x000E;
1315 enum AL_EAXREVERB_ECHO_TIME = 0x000F;
1316 enum AL_EAXREVERB_ECHO_DEPTH = 0x0010;
1317 enum AL_EAXREVERB_MODULATION_TIME = 0x0011;
1318 enum AL_EAXREVERB_MODULATION_DEPTH = 0x0012;
1319 enum AL_EAXREVERB_AIR_ABSORPTION_GAINHF = 0x0013;
1320 enum AL_EAXREVERB_HFREFERENCE = 0x0014;
1321 enum AL_EAXREVERB_LFREFERENCE = 0x0015;
1322 enum AL_EAXREVERB_ROOM_ROLLOFF_FACTOR = 0x0016;
1323 enum AL_EAXREVERB_DECAY_HFLIMIT = 0x0017;
1324
1325 /* Chorus effect parameters */
1326 enum AL_CHORUS_WAVEFORM = 0x0001;
1327 enum AL_CHORUS_PHASE = 0x0002;
1328 enum AL_CHORUS_RATE = 0x0003;
1329 enum AL_CHORUS_DEPTH = 0x0004;
1330 enum AL_CHORUS_FEEDBACK = 0x0005;
1331 enum AL_CHORUS_DELAY = 0x0006;
1332
1333 /* Distortion effect parameters */
1334 enum AL_DISTORTION_EDGE = 0x0001;
1335 enum AL_DISTORTION_GAIN = 0x0002;
1336 enum AL_DISTORTION_LOWPASS_CUTOFF = 0x0003;
1337 enum AL_DISTORTION_EQCENTER = 0x0004;
1338 enum AL_DISTORTION_EQBANDWIDTH = 0x0005;
1339
1340 /* Echo effect parameters */
1341 enum AL_ECHO_DELAY = 0x0001;
1342 enum AL_ECHO_LRDELAY = 0x0002;
1343 enum AL_ECHO_DAMPING = 0x0003;
1344 enum AL_ECHO_FEEDBACK = 0x0004;
1345 enum AL_ECHO_SPREAD = 0x0005;
1346
1347 /* Flanger effect parameters */
1348 enum AL_FLANGER_WAVEFORM = 0x0001;
1349 enum AL_FLANGER_PHASE = 0x0002;
1350 enum AL_FLANGER_RATE = 0x0003;
1351 enum AL_FLANGER_DEPTH = 0x0004;
1352 enum AL_FLANGER_FEEDBACK = 0x0005;
1353 enum AL_FLANGER_DELAY = 0x0006;
1354
1355 /* Frequency shifter effect parameters */
1356 enum AL_FREQUENCY_SHIFTER_FREQUENCY = 0x0001;
1357 enum AL_FREQUENCY_SHIFTER_LEFT_DIRECTION = 0x0002;
1358 enum AL_FREQUENCY_SHIFTER_RIGHT_DIRECTION = 0x0003;
1359
1360 /* Vocal morpher effect parameters */
1361 enum AL_VOCAL_MORPHER_PHONEMEA = 0x0001;
1362 enum AL_VOCAL_MORPHER_PHONEMEA_COARSE_TUNING = 0x0002;
1363 enum AL_VOCAL_MORPHER_PHONEMEB = 0x0003;
1364 enum AL_VOCAL_MORPHER_PHONEMEB_COARSE_TUNING = 0x0004;
1365 enum AL_VOCAL_MORPHER_WAVEFORM = 0x0005;
1366 enum AL_VOCAL_MORPHER_RATE = 0x0006;
1367
1368 /* Pitchshifter effect parameters */
1369 enum AL_PITCH_SHIFTER_COARSE_TUNE = 0x0001;
1370 enum AL_PITCH_SHIFTER_FINE_TUNE = 0x0002;
1371
1372 /* Ringmodulator effect parameters */
1373 enum AL_RING_MODULATOR_FREQUENCY = 0x0001;
1374 enum AL_RING_MODULATOR_HIGHPASS_CUTOFF = 0x0002;
1375 enum AL_RING_MODULATOR_WAVEFORM = 0x0003;
1376
1377 /* Autowah effect parameters */
1378 enum AL_AUTOWAH_ATTACK_TIME = 0x0001;
1379 enum AL_AUTOWAH_RELEASE_TIME = 0x0002;
1380 enum AL_AUTOWAH_RESONANCE = 0x0003;
1381 enum AL_AUTOWAH_PEAK_GAIN = 0x0004;
1382
1383 /* Compressor effect parameters */
1384 enum AL_COMPRESSOR_ONOFF = 0x0001;
1385
1386 /* Equalizer effect parameters */
1387 enum AL_EQUALIZER_LOW_GAIN = 0x0001;
1388 enum AL_EQUALIZER_LOW_CUTOFF = 0x0002;
1389 enum AL_EQUALIZER_MID1_GAIN = 0x0003;
1390 enum AL_EQUALIZER_MID1_CENTER = 0x0004;
1391 enum AL_EQUALIZER_MID1_WIDTH = 0x0005;
1392 enum AL_EQUALIZER_MID2_GAIN = 0x0006;
1393 enum AL_EQUALIZER_MID2_CENTER = 0x0007;
1394 enum AL_EQUALIZER_MID2_WIDTH = 0x0008;
1395 enum AL_EQUALIZER_HIGH_GAIN = 0x0009;
1396 enum AL_EQUALIZER_HIGH_CUTOFF = 0x000A;
1397
1398 /* Effect type */
1399 enum AL_EFFECT_FIRST_PARAMETER = 0x0000;
1400 enum AL_EFFECT_LAST_PARAMETER = 0x8000;
1401 enum AL_EFFECT_TYPE = 0x8001;
1402
1403 /* Effect types, used with the AL_EFFECT_TYPE property */
1404 enum AL_EFFECT_NULL = 0x0000;
1405 enum AL_EFFECT_REVERB = 0x0001;
1406 enum AL_EFFECT_CHORUS = 0x0002;
1407 enum AL_EFFECT_DISTORTION = 0x0003;
1408 enum AL_EFFECT_ECHO = 0x0004;
1409 enum AL_EFFECT_FLANGER = 0x0005;
1410 enum AL_EFFECT_FREQUENCY_SHIFTER = 0x0006;
1411 enum AL_EFFECT_VOCAL_MORPHER = 0x0007;
1412 enum AL_EFFECT_PITCH_SHIFTER = 0x0008;
1413 enum AL_EFFECT_RING_MODULATOR = 0x0009;
1414 enum AL_EFFECT_AUTOWAH = 0x000A;
1415 enum AL_EFFECT_COMPRESSOR = 0x000B;
1416 enum AL_EFFECT_EQUALIZER = 0x000C;
1417 enum AL_EFFECT_EAXREVERB = 0x8000;
1418
1419 /* Auxiliary Effect Slot properties. */
1420 enum AL_EFFECTSLOT_EFFECT = 0x0001;
1421 enum AL_EFFECTSLOT_GAIN = 0x0002;
1422 enum AL_EFFECTSLOT_AUXILIARY_SEND_AUTO = 0x0003;
1423
1424 /* NULL Auxiliary Slot ID to disable a source send. */
1425 enum AL_EFFECTSLOT_NULL = 0x0000;
1426
1427
1428 /* Filter properties. */
1429
1430 /* Lowpass filter parameters */
1431 enum AL_LOWPASS_GAIN = 0x0001;
1432 enum AL_LOWPASS_GAINHF = 0x0002;
1433
1434 /* Highpass filter parameters */
1435 enum AL_HIGHPASS_GAIN = 0x0001;
1436 enum AL_HIGHPASS_GAINLF = 0x0002;
1437
1438 /* Bandpass filter parameters */
1439 enum AL_BANDPASS_GAIN = 0x0001;
1440 enum AL_BANDPASS_GAINLF = 0x0002;
1441 enum AL_BANDPASS_GAINHF = 0x0003;
1442
1443 /* Filter type */
1444 enum AL_FILTER_FIRST_PARAMETER = 0x0000;
1445 enum AL_FILTER_LAST_PARAMETER = 0x8000;
1446 enum AL_FILTER_TYPE = 0x8001;
1447
1448 /* Filter types, used with the AL_FILTER_TYPE property */
1449 enum AL_FILTER_NULL = 0x0000;
1450 enum AL_FILTER_LOWPASS = 0x0001;
1451 enum AL_FILTER_HIGHPASS = 0x0002;
1452 enum AL_FILTER_BANDPASS = 0x0003;
1453
1454
1455 /* Effect object function types. */
1456 /+
1457 typedef void (/*AL_APIENTRY*/ *LPALGENEFFECTS)(ALsizei, ALuint*);
1458 typedef void (/*AL_APIENTRY*/ *LPALDELETEEFFECTS)(ALsizei, const(ALuint)* );
1459 typedef ALboolean (/*AL_APIENTRY*/ *LPALISEFFECT)(ALuint);
1460 typedef void (/*AL_APIENTRY*/ *LPALEFFECTI)(ALuint, ALenum, ALint);
1461 typedef void (/*AL_APIENTRY*/ *LPALEFFECTIV)(ALuint, ALenum, const(ALint)* );
1462 typedef void (/*AL_APIENTRY*/ *LPALEFFECTF)(ALuint, ALenum, ALfloat);
1463 typedef void (/*AL_APIENTRY*/ *LPALEFFECTFV)(ALuint, ALenum, const(ALfloat)* );
1464 typedef void (/*AL_APIENTRY*/ *LPALGETEFFECTI)(ALuint, ALenum, ALint*);
1465 typedef void (/*AL_APIENTRY*/ *LPALGETEFFECTIV)(ALuint, ALenum, ALint*);
1466 typedef void (/*AL_APIENTRY*/ *LPALGETEFFECTF)(ALuint, ALenum, ALfloat*);
1467 typedef void (/*AL_APIENTRY*/ *LPALGETEFFECTFV)(ALuint, ALenum, ALfloat*);
1468
1469 /* Filter object function types. */
1470 typedef void (/*AL_APIENTRY*/ *LPALGENFILTERS)(ALsizei, ALuint*);
1471 typedef void (/*AL_APIENTRY*/ *LPALDELETEFILTERS)(ALsizei, const(ALuint)* );
1472 typedef ALboolean (/*AL_APIENTRY*/ *LPALISFILTER)(ALuint);
1473 typedef void (/*AL_APIENTRY*/ *LPALFILTERI)(ALuint, ALenum, ALint);
1474 typedef void (/*AL_APIENTRY*/ *LPALFILTERIV)(ALuint, ALenum, const(ALint)* );
1475 typedef void (/*AL_APIENTRY*/ *LPALFILTERF)(ALuint, ALenum, ALfloat);
1476 typedef void (/*AL_APIENTRY*/ *LPALFILTERFV)(ALuint, ALenum, const(ALfloat)* );
1477 typedef void (/*AL_APIENTRY*/ *LPALGETFILTERI)(ALuint, ALenum, ALint*);
1478 typedef void (/*AL_APIENTRY*/ *LPALGETFILTERIV)(ALuint, ALenum, ALint*);
1479 typedef void (/*AL_APIENTRY*/ *LPALGETFILTERF)(ALuint, ALenum, ALfloat*);
1480 typedef void (/*AL_APIENTRY*/ *LPALGETFILTERFV)(ALuint, ALenum, ALfloat*);
1481
1482 /* Auxiliary Effect Slot object function types. */
1483 typedef void (/*AL_APIENTRY*/ *LPALGENAUXILIARYEFFECTSLOTS)(ALsizei, ALuint*);
1484 typedef void (/*AL_APIENTRY*/ *LPALDELETEAUXILIARYEFFECTSLOTS)(ALsizei, const(ALuint)* );
1485 typedef ALboolean (/*AL_APIENTRY*/ *LPALISAUXILIARYEFFECTSLOT)(ALuint);
1486 typedef void (/*AL_APIENTRY*/ *LPALAUXILIARYEFFECTSLOTI)(ALuint, ALenum, ALint);
1487 typedef void (/*AL_APIENTRY*/ *LPALAUXILIARYEFFECTSLOTIV)(ALuint, ALenum, const(ALint)* );
1488 typedef void (/*AL_APIENTRY*/ *LPALAUXILIARYEFFECTSLOTF)(ALuint, ALenum, ALfloat);
1489 typedef void (/*AL_APIENTRY*/ *LPALAUXILIARYEFFECTSLOTFV)(ALuint, ALenum, const(ALfloat)* );
1490 typedef void (/*AL_APIENTRY*/ *LPALGETAUXILIARYEFFECTSLOTI)(ALuint, ALenum, ALint*);
1491 typedef void (/*AL_APIENTRY*/ *LPALGETAUXILIARYEFFECTSLOTIV)(ALuint, ALenum, ALint*);
1492 typedef void (/*AL_APIENTRY*/ *LPALGETAUXILIARYEFFECTSLOTF)(ALuint, ALenum, ALfloat*);
1493 typedef void (/*AL_APIENTRY*/ *LPALGETAUXILIARYEFFECTSLOTFV)(ALuint, ALenum, ALfloat*);
1494 +/
1495
1496 /*AL_API*/ ALvoid /*AL_APIENTRY*/ alGenEffects(ALsizei n, ALuint* effects);
1497 /*AL_API*/ ALvoid /*AL_APIENTRY*/ alDeleteEffects(ALsizei n, const(ALuint)* effects);
1498 /*AL_API*/ ALboolean /*AL_APIENTRY*/ alIsEffect(ALuint effect);
1499 /*AL_API*/ ALvoid /*AL_APIENTRY*/ alEffecti(ALuint effect, ALenum param, ALint iValue);
1500 /*AL_API*/ ALvoid /*AL_APIENTRY*/ alEffectiv(ALuint effect, ALenum param, const(ALint)* piValues);
1501 /*AL_API*/ ALvoid /*AL_APIENTRY*/ alEffectf(ALuint effect, ALenum param, ALfloat flValue);
1502 /*AL_API*/ ALvoid /*AL_APIENTRY*/ alEffectfv(ALuint effect, ALenum param, const(ALfloat)* pflValues);
1503 /*AL_API*/ ALvoid /*AL_APIENTRY*/ alGetEffecti(ALuint effect, ALenum param, ALint* piValue);
1504 /*AL_API*/ ALvoid /*AL_APIENTRY*/ alGetEffectiv(ALuint effect, ALenum param, ALint* piValues);
1505 /*AL_API*/ ALvoid /*AL_APIENTRY*/ alGetEffectf(ALuint effect, ALenum param, ALfloat* pflValue);
1506 /*AL_API*/ ALvoid /*AL_APIENTRY*/ alGetEffectfv(ALuint effect, ALenum param, ALfloat* pflValues);
1507
1508 /*AL_API*/ ALvoid /*AL_APIENTRY*/ alGenFilters(ALsizei n, ALuint* filters);
1509 /*AL_API*/ ALvoid /*AL_APIENTRY*/ alDeleteFilters(ALsizei n, const(ALuint)* filters);
1510 /*AL_API*/ ALboolean /*AL_APIENTRY*/ alIsFilter(ALuint filter);
1511 /*AL_API*/ ALvoid /*AL_APIENTRY*/ alFilteri(ALuint filter, ALenum param, ALint iValue);
1512 /*AL_API*/ ALvoid /*AL_APIENTRY*/ alFilteriv(ALuint filter, ALenum param, const(ALint)* piValues);
1513 /*AL_API*/ ALvoid /*AL_APIENTRY*/ alFilterf(ALuint filter, ALenum param, ALfloat flValue);
1514 /*AL_API*/ ALvoid /*AL_APIENTRY*/ alFilterfv(ALuint filter, ALenum param, const(ALfloat)* pflValues);
1515 /*AL_API*/ ALvoid /*AL_APIENTRY*/ alGetFilteri(ALuint filter, ALenum param, ALint* piValue);
1516 /*AL_API*/ ALvoid /*AL_APIENTRY*/ alGetFilteriv(ALuint filter, ALenum param, ALint* piValues);
1517 /*AL_API*/ ALvoid /*AL_APIENTRY*/ alGetFilterf(ALuint filter, ALenum param, ALfloat* pflValue);
1518 /*AL_API*/ ALvoid /*AL_APIENTRY*/ alGetFilterfv(ALuint filter, ALenum param, ALfloat* pflValues);
1519
1520 /*AL_API*/ ALvoid /*AL_APIENTRY*/ alGenAuxiliaryEffectSlots(ALsizei n, ALuint* effectslots);
1521 /*AL_API*/ ALvoid /*AL_APIENTRY*/ alDeleteAuxiliaryEffectSlots(ALsizei n, const(ALuint)* effectslots);
1522 /*AL_API*/ ALboolean /*AL_APIENTRY*/ alIsAuxiliaryEffectSlot(ALuint effectslot);
1523 /*AL_API*/ ALvoid /*AL_APIENTRY*/ alAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint iValue);
1524 /*AL_API*/ ALvoid /*AL_APIENTRY*/ alAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, const(ALint)* piValues);
1525 /*AL_API*/ ALvoid /*AL_APIENTRY*/ alAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat flValue);
1526 /*AL_API*/ ALvoid /*AL_APIENTRY*/ alAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, const(ALfloat)* pflValues);
1527 /*AL_API*/ ALvoid /*AL_APIENTRY*/ alGetAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint* piValue);
1528 /*AL_API*/ ALvoid /*AL_APIENTRY*/ alGetAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, ALint* piValues);
1529 /*AL_API*/ ALvoid /*AL_APIENTRY*/ alGetAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat* pflValue);
1530 /*AL_API*/ ALvoid /*AL_APIENTRY*/ alGetAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, ALfloat* pflValues);
1531
1532 /* Filter ranges and defaults. */
1533
1534 /* Lowpass filter */
1535 enum AL_LOWPASS_MIN_GAIN = (0.0f);
1536 enum AL_LOWPASS_MAX_GAIN = (1.0f);
1537 enum AL_LOWPASS_DEFAULT_GAIN = (1.0f);
1538
1539 enum AL_LOWPASS_MIN_GAINHF = (0.0f);
1540 enum AL_LOWPASS_MAX_GAINHF = (1.0f);
1541 enum AL_LOWPASS_DEFAULT_GAINHF = (1.0f);
1542
1543 /* Highpass filter */
1544 enum AL_HIGHPASS_MIN_GAIN = (0.0f);
1545 enum AL_HIGHPASS_MAX_GAIN = (1.0f);
1546 enum AL_HIGHPASS_DEFAULT_GAIN = (1.0f);
1547
1548 enum AL_HIGHPASS_MIN_GAINLF = (0.0f);
1549 enum AL_HIGHPASS_MAX_GAINLF = (1.0f);
1550 enum AL_HIGHPASS_DEFAULT_GAINLF = (1.0f);
1551
1552 /* Bandpass filter */
1553 enum AL_BANDPASS_MIN_GAIN = (0.0f);
1554 enum AL_BANDPASS_MAX_GAIN = (1.0f);
1555 enum AL_BANDPASS_DEFAULT_GAIN = (1.0f);
1556
1557 enum AL_BANDPASS_MIN_GAINHF = (0.0f);
1558 enum AL_BANDPASS_MAX_GAINHF = (1.0f);
1559 enum AL_BANDPASS_DEFAULT_GAINHF = (1.0f);
1560
1561 enum AL_BANDPASS_MIN_GAINLF = (0.0f);
1562 enum AL_BANDPASS_MAX_GAINLF = (1.0f);
1563 enum AL_BANDPASS_DEFAULT_GAINLF = (1.0f);
1564
1565
1566 /* Effect parameter ranges and defaults. */
1567
1568 /* Standard reverb effect */
1569 enum AL_REVERB_MIN_DENSITY = (0.0f);
1570 enum AL_REVERB_MAX_DENSITY = (1.0f);
1571 enum AL_REVERB_DEFAULT_DENSITY = (1.0f);
1572
1573 enum AL_REVERB_MIN_DIFFUSION = (0.0f);
1574 enum AL_REVERB_MAX_DIFFUSION = (1.0f);
1575 enum AL_REVERB_DEFAULT_DIFFUSION = (1.0f);
1576
1577 enum AL_REVERB_MIN_GAIN = (0.0f);
1578 enum AL_REVERB_MAX_GAIN = (1.0f);
1579 enum AL_REVERB_DEFAULT_GAIN = (0.32f);
1580
1581 enum AL_REVERB_MIN_GAINHF = (0.0f);
1582 enum AL_REVERB_MAX_GAINHF = (1.0f);
1583 enum AL_REVERB_DEFAULT_GAINHF = (0.89f);
1584
1585 enum AL_REVERB_MIN_DECAY_TIME = (0.1f);
1586 enum AL_REVERB_MAX_DECAY_TIME = (20.0f);
1587 enum AL_REVERB_DEFAULT_DECAY_TIME = (1.49f);
1588
1589 enum AL_REVERB_MIN_DECAY_HFRATIO = (0.1f);
1590 enum AL_REVERB_MAX_DECAY_HFRATIO = (2.0f);
1591 enum AL_REVERB_DEFAULT_DECAY_HFRATIO = (0.83f);
1592
1593 enum AL_REVERB_MIN_REFLECTIONS_GAIN = (0.0f);
1594 enum AL_REVERB_MAX_REFLECTIONS_GAIN = (3.16f);
1595 enum AL_REVERB_DEFAULT_REFLECTIONS_GAIN = (0.05f);
1596
1597 enum AL_REVERB_MIN_REFLECTIONS_DELAY = (0.0f);
1598 enum AL_REVERB_MAX_REFLECTIONS_DELAY = (0.3f);
1599 enum AL_REVERB_DEFAULT_REFLECTIONS_DELAY = (0.007f);
1600
1601 enum AL_REVERB_MIN_LATE_REVERB_GAIN = (0.0f);
1602 enum AL_REVERB_MAX_LATE_REVERB_GAIN = (10.0f);
1603 enum AL_REVERB_DEFAULT_LATE_REVERB_GAIN = (1.26f);
1604
1605 enum AL_REVERB_MIN_LATE_REVERB_DELAY = (0.0f);
1606 enum AL_REVERB_MAX_LATE_REVERB_DELAY = (0.1f);
1607 enum AL_REVERB_DEFAULT_LATE_REVERB_DELAY = (0.011f);
1608
1609 enum AL_REVERB_MIN_AIR_ABSORPTION_GAINHF = (0.892f);
1610 enum AL_REVERB_MAX_AIR_ABSORPTION_GAINHF = (1.0f);
1611 enum AL_REVERB_DEFAULT_AIR_ABSORPTION_GAINHF = (0.994f);
1612
1613 enum AL_REVERB_MIN_ROOM_ROLLOFF_FACTOR = (0.0f);
1614 enum AL_REVERB_MAX_ROOM_ROLLOFF_FACTOR = (10.0f);
1615 enum AL_REVERB_DEFAULT_ROOM_ROLLOFF_FACTOR = (0.0f);
1616
1617 enum AL_REVERB_MIN_DECAY_HFLIMIT = AL_FALSE;
1618 enum AL_REVERB_MAX_DECAY_HFLIMIT = AL_TRUE;
1619 enum AL_REVERB_DEFAULT_DECAY_HFLIMIT = AL_TRUE;
1620
1621 /* EAX reverb effect */
1622 enum AL_EAXREVERB_MIN_DENSITY = (0.0f);
1623 enum AL_EAXREVERB_MAX_DENSITY = (1.0f);
1624 enum AL_EAXREVERB_DEFAULT_DENSITY = (1.0f);
1625
1626 enum AL_EAXREVERB_MIN_DIFFUSION = (0.0f);
1627 enum AL_EAXREVERB_MAX_DIFFUSION = (1.0f);
1628 enum AL_EAXREVERB_DEFAULT_DIFFUSION = (1.0f);
1629
1630 enum AL_EAXREVERB_MIN_GAIN = (0.0f);
1631 enum AL_EAXREVERB_MAX_GAIN = (1.0f);
1632 enum AL_EAXREVERB_DEFAULT_GAIN = (0.32f);
1633
1634 enum AL_EAXREVERB_MIN_GAINHF = (0.0f);
1635 enum AL_EAXREVERB_MAX_GAINHF = (1.0f);
1636 enum AL_EAXREVERB_DEFAULT_GAINHF = (0.89f);
1637
1638 enum AL_EAXREVERB_MIN_GAINLF = (0.0f);
1639 enum AL_EAXREVERB_MAX_GAINLF = (1.0f);
1640 enum AL_EAXREVERB_DEFAULT_GAINLF = (1.0f);
1641
1642 enum AL_EAXREVERB_MIN_DECAY_TIME = (0.1f);
1643 enum AL_EAXREVERB_MAX_DECAY_TIME = (20.0f);
1644 enum AL_EAXREVERB_DEFAULT_DECAY_TIME = (1.49f);
1645
1646 enum AL_EAXREVERB_MIN_DECAY_HFRATIO = (0.1f);
1647 enum AL_EAXREVERB_MAX_DECAY_HFRATIO = (2.0f);
1648 enum AL_EAXREVERB_DEFAULT_DECAY_HFRATIO = (0.83f);
1649
1650 enum AL_EAXREVERB_MIN_DECAY_LFRATIO = (0.1f);
1651 enum AL_EAXREVERB_MAX_DECAY_LFRATIO = (2.0f);
1652 enum AL_EAXREVERB_DEFAULT_DECAY_LFRATIO = (1.0f);
1653
1654 enum AL_EAXREVERB_MIN_REFLECTIONS_GAIN = (0.0f);
1655 enum AL_EAXREVERB_MAX_REFLECTIONS_GAIN = (3.16f);
1656 enum AL_EAXREVERB_DEFAULT_REFLECTIONS_GAIN = (0.05f);
1657
1658 enum AL_EAXREVERB_MIN_REFLECTIONS_DELAY = (0.0f);
1659 enum AL_EAXREVERB_MAX_REFLECTIONS_DELAY = (0.3f);
1660 enum AL_EAXREVERB_DEFAULT_REFLECTIONS_DELAY = (0.007f);
1661
1662 enum AL_EAXREVERB_DEFAULT_REFLECTIONS_PAN_XYZ = (0.0f);
1663
1664 enum AL_EAXREVERB_MIN_LATE_REVERB_GAIN = (0.0f);
1665 enum AL_EAXREVERB_MAX_LATE_REVERB_GAIN = (10.0f);
1666 enum AL_EAXREVERB_DEFAULT_LATE_REVERB_GAIN = (1.26f);
1667
1668 enum AL_EAXREVERB_MIN_LATE_REVERB_DELAY = (0.0f);
1669 enum AL_EAXREVERB_MAX_LATE_REVERB_DELAY = (0.1f);
1670 enum AL_EAXREVERB_DEFAULT_LATE_REVERB_DELAY = (0.011f);
1671
1672 enum AL_EAXREVERB_DEFAULT_LATE_REVERB_PAN_XYZ = (0.0f);
1673
1674 enum AL_EAXREVERB_MIN_ECHO_TIME = (0.075f);
1675 enum AL_EAXREVERB_MAX_ECHO_TIME = (0.25f);
1676 enum AL_EAXREVERB_DEFAULT_ECHO_TIME = (0.25f);
1677
1678 enum AL_EAXREVERB_MIN_ECHO_DEPTH = (0.0f);
1679 enum AL_EAXREVERB_MAX_ECHO_DEPTH = (1.0f);
1680 enum AL_EAXREVERB_DEFAULT_ECHO_DEPTH = (0.0f);
1681
1682 enum AL_EAXREVERB_MIN_MODULATION_TIME = (0.04f);
1683 enum AL_EAXREVERB_MAX_MODULATION_TIME = (4.0f);
1684 enum AL_EAXREVERB_DEFAULT_MODULATION_TIME = (0.25f);
1685
1686 enum AL_EAXREVERB_MIN_MODULATION_DEPTH = (0.0f);
1687 enum AL_EAXREVERB_MAX_MODULATION_DEPTH = (1.0f);
1688 enum AL_EAXREVERB_DEFAULT_MODULATION_DEPTH = (0.0f);
1689
1690 enum AL_EAXREVERB_MIN_AIR_ABSORPTION_GAINHF = (0.892f);
1691 enum AL_EAXREVERB_MAX_AIR_ABSORPTION_GAINHF = (1.0f);
1692 enum AL_EAXREVERB_DEFAULT_AIR_ABSORPTION_GAINHF = (0.994f);
1693
1694 enum AL_EAXREVERB_MIN_HFREFERENCE = (1000.0f);
1695 enum AL_EAXREVERB_MAX_HFREFERENCE = (20000.0f);
1696 enum AL_EAXREVERB_DEFAULT_HFREFERENCE = (5000.0f);
1697
1698 enum AL_EAXREVERB_MIN_LFREFERENCE = (20.0f);
1699 enum AL_EAXREVERB_MAX_LFREFERENCE = (1000.0f);
1700 enum AL_EAXREVERB_DEFAULT_LFREFERENCE = (250.0f);
1701
1702 enum AL_EAXREVERB_MIN_ROOM_ROLLOFF_FACTOR = (0.0f);
1703 enum AL_EAXREVERB_MAX_ROOM_ROLLOFF_FACTOR = (10.0f);
1704 enum AL_EAXREVERB_DEFAULT_ROOM_ROLLOFF_FACTOR = (0.0f);
1705
1706 enum AL_EAXREVERB_MIN_DECAY_HFLIMIT = AL_FALSE;
1707 enum AL_EAXREVERB_MAX_DECAY_HFLIMIT = AL_TRUE;
1708 enum AL_EAXREVERB_DEFAULT_DECAY_HFLIMIT = AL_TRUE;
1709
1710 /* Chorus effect */
1711 enum AL_CHORUS_WAVEFORM_SINUSOID = (0);
1712 enum AL_CHORUS_WAVEFORM_TRIANGLE = (1);
1713
1714 enum AL_CHORUS_MIN_WAVEFORM = (0);
1715 enum AL_CHORUS_MAX_WAVEFORM = (1);
1716 enum AL_CHORUS_DEFAULT_WAVEFORM = (1);
1717
1718 enum AL_CHORUS_MIN_PHASE = (-180);
1719 enum AL_CHORUS_MAX_PHASE = (180);
1720 enum AL_CHORUS_DEFAULT_PHASE = (90);
1721
1722 enum AL_CHORUS_MIN_RATE = (0.0f);
1723 enum AL_CHORUS_MAX_RATE = (10.0f);
1724 enum AL_CHORUS_DEFAULT_RATE = (1.1f);
1725
1726 enum AL_CHORUS_MIN_DEPTH = (0.0f);
1727 enum AL_CHORUS_MAX_DEPTH = (1.0f);
1728 enum AL_CHORUS_DEFAULT_DEPTH = (0.1f);
1729
1730 enum AL_CHORUS_MIN_FEEDBACK = (-1.0f);
1731 enum AL_CHORUS_MAX_FEEDBACK = (1.0f);
1732 enum AL_CHORUS_DEFAULT_FEEDBACK = (0.25f);
1733
1734 enum AL_CHORUS_MIN_DELAY = (0.0f);
1735 enum AL_CHORUS_MAX_DELAY = (0.016f);
1736 enum AL_CHORUS_DEFAULT_DELAY = (0.016f);
1737
1738 /* Distortion effect */
1739 enum AL_DISTORTION_MIN_EDGE = (0.0f);
1740 enum AL_DISTORTION_MAX_EDGE = (1.0f);
1741 enum AL_DISTORTION_DEFAULT_EDGE = (0.2f);
1742
1743 enum AL_DISTORTION_MIN_GAIN = (0.01f);
1744 enum AL_DISTORTION_MAX_GAIN = (1.0f);
1745 enum AL_DISTORTION_DEFAULT_GAIN = (0.05f);
1746
1747 enum AL_DISTORTION_MIN_LOWPASS_CUTOFF = (80.0f);
1748 enum AL_DISTORTION_MAX_LOWPASS_CUTOFF = (24000.0f);
1749 enum AL_DISTORTION_DEFAULT_LOWPASS_CUTOFF = (8000.0f);
1750
1751 enum AL_DISTORTION_MIN_EQCENTER = (80.0f);
1752 enum AL_DISTORTION_MAX_EQCENTER = (24000.0f);
1753 enum AL_DISTORTION_DEFAULT_EQCENTER = (3600.0f);
1754
1755 enum AL_DISTORTION_MIN_EQBANDWIDTH = (80.0f);
1756 enum AL_DISTORTION_MAX_EQBANDWIDTH = (24000.0f);
1757 enum AL_DISTORTION_DEFAULT_EQBANDWIDTH = (3600.0f);
1758
1759 /* Echo effect */
1760 enum AL_ECHO_MIN_DELAY = (0.0f);
1761 enum AL_ECHO_MAX_DELAY = (0.207f);
1762 enum AL_ECHO_DEFAULT_DELAY = (0.1f);
1763
1764 enum AL_ECHO_MIN_LRDELAY = (0.0f);
1765 enum AL_ECHO_MAX_LRDELAY = (0.404f);
1766 enum AL_ECHO_DEFAULT_LRDELAY = (0.1f);
1767
1768 enum AL_ECHO_MIN_DAMPING = (0.0f);
1769 enum AL_ECHO_MAX_DAMPING = (0.99f);
1770 enum AL_ECHO_DEFAULT_DAMPING = (0.5f);
1771
1772 enum AL_ECHO_MIN_FEEDBACK = (0.0f);
1773 enum AL_ECHO_MAX_FEEDBACK = (1.0f);
1774 enum AL_ECHO_DEFAULT_FEEDBACK = (0.5f);
1775
1776 enum AL_ECHO_MIN_SPREAD = (-1.0f);
1777 enum AL_ECHO_MAX_SPREAD = (1.0f);
1778 enum AL_ECHO_DEFAULT_SPREAD = (-1.0f);
1779
1780 /* Flanger effect */
1781 enum AL_FLANGER_WAVEFORM_SINUSOID = (0);
1782 enum AL_FLANGER_WAVEFORM_TRIANGLE = (1);
1783
1784 enum AL_FLANGER_MIN_WAVEFORM = (0);
1785 enum AL_FLANGER_MAX_WAVEFORM = (1);
1786 enum AL_FLANGER_DEFAULT_WAVEFORM = (1);
1787
1788 enum AL_FLANGER_MIN_PHASE = (-180);
1789 enum AL_FLANGER_MAX_PHASE = (180);
1790 enum AL_FLANGER_DEFAULT_PHASE = (0);
1791
1792 enum AL_FLANGER_MIN_RATE = (0.0f);
1793 enum AL_FLANGER_MAX_RATE = (10.0f);
1794 enum AL_FLANGER_DEFAULT_RATE = (0.27f);
1795
1796 enum AL_FLANGER_MIN_DEPTH = (0.0f);
1797 enum AL_FLANGER_MAX_DEPTH = (1.0f);
1798 enum AL_FLANGER_DEFAULT_DEPTH = (1.0f);
1799
1800 enum AL_FLANGER_MIN_FEEDBACK = (-1.0f);
1801 enum AL_FLANGER_MAX_FEEDBACK = (1.0f);
1802 enum AL_FLANGER_DEFAULT_FEEDBACK = (-0.5f);
1803
1804 enum AL_FLANGER_MIN_DELAY = (0.0f);
1805 enum AL_FLANGER_MAX_DELAY = (0.004f);
1806 enum AL_FLANGER_DEFAULT_DELAY = (0.002f);
1807
1808 /* Frequency shifter effect */
1809 enum AL_FREQUENCY_SHIFTER_MIN_FREQUENCY = (0.0f);
1810 enum AL_FREQUENCY_SHIFTER_MAX_FREQUENCY = (24000.0f);
1811 enum AL_FREQUENCY_SHIFTER_DEFAULT_FREQUENCY = (0.0f);
1812
1813 enum AL_FREQUENCY_SHIFTER_MIN_LEFT_DIRECTION = (0);
1814 enum AL_FREQUENCY_SHIFTER_MAX_LEFT_DIRECTION = (2);
1815 enum AL_FREQUENCY_SHIFTER_DEFAULT_LEFT_DIRECTION = (0);
1816
1817 enum AL_FREQUENCY_SHIFTER_DIRECTION_DOWN = (0);
1818 enum AL_FREQUENCY_SHIFTER_DIRECTION_UP = (1);
1819 enum AL_FREQUENCY_SHIFTER_DIRECTION_OFF = (2);
1820
1821 enum AL_FREQUENCY_SHIFTER_MIN_RIGHT_DIRECTION = (0);
1822 enum AL_FREQUENCY_SHIFTER_MAX_RIGHT_DIRECTION = (2);
1823 enum AL_FREQUENCY_SHIFTER_DEFAULT_RIGHT_DIRECTION = (0);
1824
1825 /* Vocal morpher effect */
1826 enum AL_VOCAL_MORPHER_MIN_PHONEMEA = (0);
1827 enum AL_VOCAL_MORPHER_MAX_PHONEMEA = (29);
1828 enum AL_VOCAL_MORPHER_DEFAULT_PHONEMEA = (0);
1829
1830 enum AL_VOCAL_MORPHER_MIN_PHONEMEA_COARSE_TUNING = (-24);
1831 enum AL_VOCAL_MORPHER_MAX_PHONEMEA_COARSE_TUNING = (24);
1832 enum AL_VOCAL_MORPHER_DEFAULT_PHONEMEA_COARSE_TUNING = (0);
1833
1834 enum AL_VOCAL_MORPHER_MIN_PHONEMEB = (0);
1835 enum AL_VOCAL_MORPHER_MAX_PHONEMEB = (29);
1836 enum AL_VOCAL_MORPHER_DEFAULT_PHONEMEB = (10);
1837
1838 enum AL_VOCAL_MORPHER_MIN_PHONEMEB_COARSE_TUNING = (-24);
1839 enum AL_VOCAL_MORPHER_MAX_PHONEMEB_COARSE_TUNING = (24);
1840 enum AL_VOCAL_MORPHER_DEFAULT_PHONEMEB_COARSE_TUNING = (0);
1841
1842 enum AL_VOCAL_MORPHER_PHONEME_A = (0);
1843 enum AL_VOCAL_MORPHER_PHONEME_E = (1);
1844 enum AL_VOCAL_MORPHER_PHONEME_I = (2);
1845 enum AL_VOCAL_MORPHER_PHONEME_O = (3);
1846 enum AL_VOCAL_MORPHER_PHONEME_U = (4);
1847 enum AL_VOCAL_MORPHER_PHONEME_AA = (5);
1848 enum AL_VOCAL_MORPHER_PHONEME_AE = (6);
1849 enum AL_VOCAL_MORPHER_PHONEME_AH = (7);
1850 enum AL_VOCAL_MORPHER_PHONEME_AO = (8);
1851 enum AL_VOCAL_MORPHER_PHONEME_EH = (9);
1852 enum AL_VOCAL_MORPHER_PHONEME_ER = (10);
1853 enum AL_VOCAL_MORPHER_PHONEME_IH = (11);
1854 enum AL_VOCAL_MORPHER_PHONEME_IY = (12);
1855 enum AL_VOCAL_MORPHER_PHONEME_UH = (13);
1856 enum AL_VOCAL_MORPHER_PHONEME_UW = (14);
1857 enum AL_VOCAL_MORPHER_PHONEME_B = (15);
1858 enum AL_VOCAL_MORPHER_PHONEME_D = (16);
1859 enum AL_VOCAL_MORPHER_PHONEME_F = (17);
1860 enum AL_VOCAL_MORPHER_PHONEME_G = (18);
1861 enum AL_VOCAL_MORPHER_PHONEME_J = (19);
1862 enum AL_VOCAL_MORPHER_PHONEME_K = (20);
1863 enum AL_VOCAL_MORPHER_PHONEME_L = (21);
1864 enum AL_VOCAL_MORPHER_PHONEME_M = (22);
1865 enum AL_VOCAL_MORPHER_PHONEME_N = (23);
1866 enum AL_VOCAL_MORPHER_PHONEME_P = (24);
1867 enum AL_VOCAL_MORPHER_PHONEME_R = (25);
1868 enum AL_VOCAL_MORPHER_PHONEME_S = (26);
1869 enum AL_VOCAL_MORPHER_PHONEME_T = (27);
1870 enum AL_VOCAL_MORPHER_PHONEME_V = (28);
1871 enum AL_VOCAL_MORPHER_PHONEME_Z = (29);
1872
1873 enum AL_VOCAL_MORPHER_WAVEFORM_SINUSOID = (0);
1874 enum AL_VOCAL_MORPHER_WAVEFORM_TRIANGLE = (1);
1875 enum AL_VOCAL_MORPHER_WAVEFORM_SAWTOOTH = (2);
1876
1877 enum AL_VOCAL_MORPHER_MIN_WAVEFORM = (0);
1878 enum AL_VOCAL_MORPHER_MAX_WAVEFORM = (2);
1879 enum AL_VOCAL_MORPHER_DEFAULT_WAVEFORM = (0);
1880
1881 enum AL_VOCAL_MORPHER_MIN_RATE = (0.0f);
1882 enum AL_VOCAL_MORPHER_MAX_RATE = (10.0f);
1883 enum AL_VOCAL_MORPHER_DEFAULT_RATE = (1.41f);
1884
1885 /* Pitch shifter effect */
1886 enum AL_PITCH_SHIFTER_MIN_COARSE_TUNE = (-12);
1887 enum AL_PITCH_SHIFTER_MAX_COARSE_TUNE = (12);
1888 enum AL_PITCH_SHIFTER_DEFAULT_COARSE_TUNE = (12);
1889
1890 enum AL_PITCH_SHIFTER_MIN_FINE_TUNE = (-50);
1891 enum AL_PITCH_SHIFTER_MAX_FINE_TUNE = (50);
1892 enum AL_PITCH_SHIFTER_DEFAULT_FINE_TUNE = (0);
1893
1894 /* Ring modulator effect */
1895 enum AL_RING_MODULATOR_MIN_FREQUENCY = (0.0f);
1896 enum AL_RING_MODULATOR_MAX_FREQUENCY = (8000.0f);
1897 enum AL_RING_MODULATOR_DEFAULT_FREQUENCY = (440.0f);
1898
1899 enum AL_RING_MODULATOR_MIN_HIGHPASS_CUTOFF = (0.0f);
1900 enum AL_RING_MODULATOR_MAX_HIGHPASS_CUTOFF = (24000.0f);
1901 enum AL_RING_MODULATOR_DEFAULT_HIGHPASS_CUTOFF = (800.0f);
1902
1903 enum AL_RING_MODULATOR_SINUSOID = (0);
1904 enum AL_RING_MODULATOR_SAWTOOTH = (1);
1905 enum AL_RING_MODULATOR_SQUARE = (2);
1906
1907 enum AL_RING_MODULATOR_MIN_WAVEFORM = (0);
1908 enum AL_RING_MODULATOR_MAX_WAVEFORM = (2);
1909 enum AL_RING_MODULATOR_DEFAULT_WAVEFORM = (0);
1910
1911 /* Autowah effect */
1912 enum AL_AUTOWAH_MIN_ATTACK_TIME = (0.0001f);
1913 enum AL_AUTOWAH_MAX_ATTACK_TIME = (1.0f);
1914 enum AL_AUTOWAH_DEFAULT_ATTACK_TIME = (0.06f);
1915
1916 enum AL_AUTOWAH_MIN_RELEASE_TIME = (0.0001f);
1917 enum AL_AUTOWAH_MAX_RELEASE_TIME = (1.0f);
1918 enum AL_AUTOWAH_DEFAULT_RELEASE_TIME = (0.06f);
1919
1920 enum AL_AUTOWAH_MIN_RESONANCE = (2.0f);
1921 enum AL_AUTOWAH_MAX_RESONANCE = (1000.0f);
1922 enum AL_AUTOWAH_DEFAULT_RESONANCE = (1000.0f);
1923
1924 enum AL_AUTOWAH_MIN_PEAK_GAIN = (0.00003f);
1925 enum AL_AUTOWAH_MAX_PEAK_GAIN = (31621.0f);
1926 enum AL_AUTOWAH_DEFAULT_PEAK_GAIN = (11.22f);
1927
1928 /* Compressor effect */
1929 enum AL_COMPRESSOR_MIN_ONOFF = (0);
1930 enum AL_COMPRESSOR_MAX_ONOFF = (1);
1931 enum AL_COMPRESSOR_DEFAULT_ONOFF = (1);
1932
1933 /* Equalizer effect */
1934 enum AL_EQUALIZER_MIN_LOW_GAIN = (0.126f);
1935 enum AL_EQUALIZER_MAX_LOW_GAIN = (7.943f);
1936 enum AL_EQUALIZER_DEFAULT_LOW_GAIN = (1.0f);
1937
1938 enum AL_EQUALIZER_MIN_LOW_CUTOFF = (50.0f);
1939 enum AL_EQUALIZER_MAX_LOW_CUTOFF = (800.0f);
1940 enum AL_EQUALIZER_DEFAULT_LOW_CUTOFF = (200.0f);
1941
1942 enum AL_EQUALIZER_MIN_MID1_GAIN = (0.126f);
1943 enum AL_EQUALIZER_MAX_MID1_GAIN = (7.943f);
1944 enum AL_EQUALIZER_DEFAULT_MID1_GAIN = (1.0f);
1945
1946 enum AL_EQUALIZER_MIN_MID1_CENTER = (200.0f);
1947 enum AL_EQUALIZER_MAX_MID1_CENTER = (3000.0f);
1948 enum AL_EQUALIZER_DEFAULT_MID1_CENTER = (500.0f);
1949
1950 enum AL_EQUALIZER_MIN_MID1_WIDTH = (0.01f);
1951 enum AL_EQUALIZER_MAX_MID1_WIDTH = (1.0f);
1952 enum AL_EQUALIZER_DEFAULT_MID1_WIDTH = (1.0f);
1953
1954 enum AL_EQUALIZER_MIN_MID2_GAIN = (0.126f);
1955 enum AL_EQUALIZER_MAX_MID2_GAIN = (7.943f);
1956 enum AL_EQUALIZER_DEFAULT_MID2_GAIN = (1.0f);
1957
1958 enum AL_EQUALIZER_MIN_MID2_CENTER = (1000.0f);
1959 enum AL_EQUALIZER_MAX_MID2_CENTER = (8000.0f);
1960 enum AL_EQUALIZER_DEFAULT_MID2_CENTER = (3000.0f);
1961
1962 enum AL_EQUALIZER_MIN_MID2_WIDTH = (0.01f);
1963 enum AL_EQUALIZER_MAX_MID2_WIDTH = (1.0f);
1964 enum AL_EQUALIZER_DEFAULT_MID2_WIDTH = (1.0f);
1965
1966 enum AL_EQUALIZER_MIN_HIGH_GAIN = (0.126f);
1967 enum AL_EQUALIZER_MAX_HIGH_GAIN = (7.943f);
1968 enum AL_EQUALIZER_DEFAULT_HIGH_GAIN = (1.0f);
1969
1970 enum AL_EQUALIZER_MIN_HIGH_CUTOFF = (4000.0f);
1971 enum AL_EQUALIZER_MAX_HIGH_CUTOFF = (16000.0f);
1972 enum AL_EQUALIZER_DEFAULT_HIGH_CUTOFF = (6000.0f);
1973
1974
1975 /* Source parameter value ranges and defaults. */
1976 enum AL_MIN_AIR_ABSORPTION_FACTOR = (0.0f);
1977 enum AL_MAX_AIR_ABSORPTION_FACTOR = (10.0f);
1978 enum AL_DEFAULT_AIR_ABSORPTION_FACTOR = (0.0f);
1979
1980 enum AL_MIN_ROOM_ROLLOFF_FACTOR = (0.0f);
1981 enum AL_MAX_ROOM_ROLLOFF_FACTOR = (10.0f);
1982 enum AL_DEFAULT_ROOM_ROLLOFF_FACTOR = (0.0f);
1983
1984 enum AL_MIN_CONE_OUTER_GAINHF = (0.0f);
1985 enum AL_MAX_CONE_OUTER_GAINHF = (1.0f);
1986 enum AL_DEFAULT_CONE_OUTER_GAINHF = (1.0f);
1987
1988 enum AL_MIN_DIRECT_FILTER_GAINHF_AUTO = AL_FALSE;
1989 enum AL_MAX_DIRECT_FILTER_GAINHF_AUTO = AL_TRUE;
1990 enum AL_DEFAULT_DIRECT_FILTER_GAINHF_AUTO = AL_TRUE;
1991
1992 enum AL_MIN_AUXILIARY_SEND_FILTER_GAIN_AUTO = AL_FALSE;
1993 enum AL_MAX_AUXILIARY_SEND_FILTER_GAIN_AUTO = AL_TRUE;
1994 enum AL_DEFAULT_AUXILIARY_SEND_FILTER_GAIN_AUTO = AL_TRUE;
1995
1996 enum AL_MIN_AUXILIARY_SEND_FILTER_GAINHF_AUTO = AL_FALSE;
1997 enum AL_MAX_AUXILIARY_SEND_FILTER_GAINHF_AUTO = AL_TRUE;
1998 enum AL_DEFAULT_AUXILIARY_SEND_FILTER_GAINHF_AUTO = AL_TRUE;
1999
2000
2001 /* Listener parameter value ranges and defaults. */
2002 enum AL_MIN_METERS_PER_UNIT = /*FLT_MIN*/float.min_normal; //FIXME:k8:???
2003 enum AL_MAX_METERS_PER_UNIT = /*FLT_MAX*/float.max;
2004 enum AL_DEFAULT_METERS_PER_UNIT = (1.0f);