Mercurial > audio-send

     1 #ifndef AL_AL_H

     2 #define AL_AL_H

     3 

     4 #if defined(__cplusplus)

     5 extern "C" {

     6 #endif

     7 

     8 #ifndef AL_API

     9  #if defined(AL_LIBTYPE_STATIC)

    10   #define AL_API

    11  #elif defined(_WIN32)

    12   #define AL_API __declspec(dllimport)

    13  #else

    14   #define AL_API extern

    15  #endif

    16 #endif

    17 

    18 #if defined(_WIN32)

    19  #define AL_APIENTRY __cdecl

    20 #else

    21  #define AL_APIENTRY

    22 #endif

    23 

    24 #if defined(TARGET_OS_MAC) && TARGET_OS_MAC

    25  #pragma export on

    26 #endif

    27 

    28 /*

    29  * The OPENAL, ALAPI, ALAPIENTRY, AL_INVALID, AL_ILLEGAL_ENUM, and

    30  * AL_ILLEGAL_COMMAND macros are deprecated, but are included for

    31  * applications porting code from AL 1.0

    32  */

    33 #define OPENAL

    34 #define ALAPI AL_API

    35 #define ALAPIENTRY AL_APIENTRY

    36 #define AL_INVALID                                (-1)

    37 #define AL_ILLEGAL_ENUM                           AL_INVALID_ENUM

    38 #define AL_ILLEGAL_COMMAND                        AL_INVALID_OPERATION

    39 

    40 #define AL_VERSION_1_0

    41 #define AL_VERSION_1_1

    42 

    43 

    44 /** 8-bit boolean */

    45 typedef char ALboolean;

    46 

    47 /** character */

    48 typedef char ALchar;

    49 

    50 /** signed 8-bit 2's complement integer */

    51 typedef signed char ALbyte;

    52 

    53 /** unsigned 8-bit integer */

    54 typedef unsigned char ALubyte;

    55 

    56 /** signed 16-bit 2's complement integer */

    57 typedef short ALshort;

    58 

    59 /** unsigned 16-bit integer */

    60 typedef unsigned short ALushort;

    61 

    62 /** signed 32-bit 2's complement integer */

    63 typedef int ALint;

    64 

    65 /** unsigned 32-bit integer */

    66 typedef unsigned int ALuint;

    67 

    68 /** non-negative 32-bit binary integer size */

    69 typedef int ALsizei;

    70 

    71 /** enumerated 32-bit value */

    72 typedef int ALenum;

    73 

    74 /** 32-bit IEEE754 floating-point */

    75 typedef float ALfloat;

    76 

    77 /** 64-bit IEEE754 floating-point */

    78 typedef double ALdouble;

    79 

    80 /** void type (for opaque pointers only) */

    81 typedef void ALvoid;

    82 

    83 

    84 /* Enumerant values begin at column 50. No tabs. */

    85 

    86 /* "no distance model" or "no buffer" */

    87 #define AL_NONE                                   0

    88 

    89 /* Boolean False. */

    90 #define AL_FALSE                                  0

    91 

    92 /** Boolean True. */

    93 #define AL_TRUE                                   1

    94 

    95 /** Indicate Source has relative coordinates. */

    96 #define AL_SOURCE_RELATIVE                        0x202

    97 

    98 

    99 

   100 /**

   101  * Directional source, inner cone angle, in degrees.

   102  * Range:    [0-360] 

   103  * Default:  360

   104  */

   105 #define AL_CONE_INNER_ANGLE                       0x1001

   106 

   107 /**

   108  * Directional source, outer cone angle, in degrees.

   109  * Range:    [0-360] 

   110  * Default:  360

   111  */

   112 #define AL_CONE_OUTER_ANGLE                       0x1002

   113 

   114 /**

   115  * Specify the pitch to be applied at source.

   116  * Range:   [0.5-2.0]

   117  * Default: 1.0

   118  */

   119 #define AL_PITCH                                  0x1003

   120   

   121 /** 

   122  * Specify the current location in three dimensional space.

   123  * OpenAL, like OpenGL, uses a right handed coordinate system,

   124  *  where in a frontal default view X (thumb) points right, 

   125  *  Y points up (index finger), and Z points towards the

   126  *  viewer/camera (middle finger). 

   127  * To switch from a left handed coordinate system, flip the

   128  *  sign on the Z coordinate.

   129  * Listener position is always in the world coordinate system.

   130  */ 

   131 #define AL_POSITION                               0x1004

   132   

   133 /** Specify the current direction. */

   134 #define AL_DIRECTION                              0x1005

   135   

   136 /** Specify the current velocity in three dimensional space. */

   137 #define AL_VELOCITY                               0x1006

   138 

   139 /**

   140  * Indicate whether source is looping.

   141  * Type: ALboolean?

   142  * Range:   [AL_TRUE, AL_FALSE]

   143  * Default: FALSE.

   144  */

   145 #define AL_LOOPING                                0x1007

   146 

   147 /**

   148  * Indicate the buffer to provide sound samples. 

   149  * Type: ALuint.

   150  * Range: any valid Buffer id.

   151  */

   152 #define AL_BUFFER                                 0x1009

   153   

   154 /**

   155  * Indicate the gain (volume amplification) applied. 

   156  * Type:   ALfloat.

   157  * Range:  ]0.0-  ]

   158  * A value of 1.0 means un-attenuated/unchanged.

   159  * Each division by 2 equals an attenuation of -6dB.

   160  * Each multiplicaton with 2 equals an amplification of +6dB.

   161  * A value of 0.0 is meaningless with respect to a logarithmic

   162  *  scale; it is interpreted as zero volume - the channel

   163  *  is effectively disabled.

   164  */

   165 #define AL_GAIN                                   0x100A

   166 

   167 /*

   168  * Indicate minimum source attenuation

   169  * Type: ALfloat

   170  * Range:  [0.0 - 1.0]

   171  *

   172  * Logarthmic

   173  */

   174 #define AL_MIN_GAIN                               0x100D

   175 

   176 /**

   177  * Indicate maximum source attenuation

   178  * Type: ALfloat

   179  * Range:  [0.0 - 1.0]

   180  *

   181  * Logarthmic

   182  */

   183 #define AL_MAX_GAIN                               0x100E

   184 

   185 /**

   186  * Indicate listener orientation.

   187  *

   188  * at/up 

   189  */

   190 #define AL_ORIENTATION                            0x100F

   191 

   192 /**

   193  * Source state information.

   194  */

   195 #define AL_SOURCE_STATE                           0x1010

   196 #define AL_INITIAL                                0x1011

   197 #define AL_PLAYING                                0x1012

   198 #define AL_PAUSED                                 0x1013

   199 #define AL_STOPPED                                0x1014

   200 

   201 /**

   202  * Buffer Queue params

   203  */

   204 #define AL_BUFFERS_QUEUED                         0x1015

   205 #define AL_BUFFERS_PROCESSED                      0x1016

   206 

   207 /**

   208  * Source buffer position information

   209  */

   210 #define AL_SEC_OFFSET                             0x1024

   211 #define AL_SAMPLE_OFFSET                          0x1025

   212 #define AL_BYTE_OFFSET                            0x1026

   213 

   214 /*

   215  * Source type (Static, Streaming or undetermined)

   216  * Source is Static if a Buffer has been attached using AL_BUFFER

   217  * Source is Streaming if one or more Buffers have been attached using alSourceQueueBuffers

   218  * Source is undetermined when it has the NULL buffer attached

   219  */

   220 #define AL_SOURCE_TYPE                            0x1027

   221 #define AL_STATIC                                 0x1028

   222 #define AL_STREAMING                              0x1029

   223 #define AL_UNDETERMINED                           0x1030

   224 

   225 /** Sound samples: format specifier. */

   226 #define AL_FORMAT_MONO8                           0x1100

   227 #define AL_FORMAT_MONO16                          0x1101

   228 #define AL_FORMAT_STEREO8                         0x1102

   229 #define AL_FORMAT_STEREO16                        0x1103

   230 

   231 /**

   232  * source specific reference distance

   233  * Type: ALfloat

   234  * Range:  0.0 - +inf

   235  *

   236  * At 0.0, no distance attenuation occurs.  Default is

   237  * 1.0.

   238  */

   239 #define AL_REFERENCE_DISTANCE                     0x1020

   240 

   241 /**

   242  * source specific rolloff factor

   243  * Type: ALfloat

   244  * Range:  0.0 - +inf

   245  *

   246  */

   247 #define AL_ROLLOFF_FACTOR                         0x1021

   248 

   249 /**

   250  * Directional source, outer cone gain.

   251  *

   252  * Default:  0.0

   253  * Range:    [0.0 - 1.0]

   254  * Logarithmic

   255  */

   256 #define AL_CONE_OUTER_GAIN                        0x1022

   257 

   258 /**

   259  * Indicate distance above which sources are not

   260  * attenuated using the inverse clamped distance model.

   261  *

   262  * Default: +inf

   263  * Type: ALfloat

   264  * Range:  0.0 - +inf

   265  */

   266 #define AL_MAX_DISTANCE                           0x1023

   267 

   268 /** 

   269  * Sound samples: frequency, in units of Hertz [Hz].

   270  * This is the number of samples per second. Half of the

   271  *  sample frequency marks the maximum significant

   272  *  frequency component.

   273  */

   274 #define AL_FREQUENCY                              0x2001

   275 #define AL_BITS                                   0x2002

   276 #define AL_CHANNELS                               0x2003

   277 #define AL_SIZE                                   0x2004

   278 

   279 /**

   280  * Buffer state.

   281  *

   282  * Not supported for public use (yet).

   283  */

   284 #define AL_UNUSED                                 0x2010

   285 #define AL_PENDING                                0x2011

   286 #define AL_PROCESSED                              0x2012

   287 

   288 

   289 /** Errors: No Error. */

   290 #define AL_NO_ERROR                               AL_FALSE

   291 

   292 /** 

   293  * Invalid Name paramater passed to AL call.

   294  */

   295 #define AL_INVALID_NAME                           0xA001

   296 

   297 /** 

   298  * Invalid parameter passed to AL call.

   299  */

   300 #define AL_INVALID_ENUM                           0xA002

   301 

   302 /** 

   303  * Invalid enum parameter value.

   304  */

   305 #define AL_INVALID_VALUE                          0xA003

   306 

   307 /** 

   308  * Illegal call.

   309  */

   310 #define AL_INVALID_OPERATION                      0xA004

   311 

   312   

   313 /**

   314  * No mojo.

   315  */

   316 #define AL_OUT_OF_MEMORY                          0xA005

   317 

   318 

   319 /** Context strings: Vendor Name. */

   320 #define AL_VENDOR                                 0xB001

   321 #define AL_VERSION                                0xB002

   322 #define AL_RENDERER                               0xB003

   323 #define AL_EXTENSIONS                             0xB004

   324 

   325 /** Global tweakage. */

   326 

   327 /**

   328  * Doppler scale.  Default 1.0

   329  */

   330 #define AL_DOPPLER_FACTOR                         0xC000

   331 

   332 /**

   333  * Tweaks speed of propagation.

   334  */

   335 #define AL_DOPPLER_VELOCITY                       0xC001

   336 

   337 /**

   338  * Speed of Sound in units per second

   339  */

   340 #define AL_SPEED_OF_SOUND                         0xC003

   341 

   342 /**

   343  * Distance models

   344  *

   345  * used in conjunction with DistanceModel

   346  *

   347  * implicit: NONE, which disances distance attenuation.

   348  */

   349 #define AL_DISTANCE_MODEL                         0xD000

   350 #define AL_INVERSE_DISTANCE                       0xD001

   351 #define AL_INVERSE_DISTANCE_CLAMPED               0xD002

   352 #define AL_LINEAR_DISTANCE                        0xD003

   353 #define AL_LINEAR_DISTANCE_CLAMPED                0xD004

   354 #define AL_EXPONENT_DISTANCE                      0xD005

   355 #define AL_EXPONENT_DISTANCE_CLAMPED              0xD006

   356 

   357 /*

   358  * Renderer State management

   359  */

   360 AL_API void AL_APIENTRY alEnable( ALenum capability );

   361 

   362 AL_API void AL_APIENTRY alDisable( ALenum capability ); 

   363 

   364 AL_API ALboolean AL_APIENTRY alIsEnabled( ALenum capability ); 

   365 

   366 

   367 /*

   368  * State retrieval

   369  */

   370 AL_API const ALchar* AL_APIENTRY alGetString( ALenum param );

   371 

   372 AL_API void AL_APIENTRY alGetBooleanv( ALenum param, ALboolean* data );

   373 

   374 AL_API void AL_APIENTRY alGetIntegerv( ALenum param, ALint* data );

   375 

   376 AL_API void AL_APIENTRY alGetFloatv( ALenum param, ALfloat* data );

   377 

   378 AL_API void AL_APIENTRY alGetDoublev( ALenum param, ALdouble* data );

   379 

   380 AL_API ALboolean AL_APIENTRY alGetBoolean( ALenum param );

   381 

   382 AL_API ALint AL_APIENTRY alGetInteger( ALenum param );

   383 

   384 AL_API ALfloat AL_APIENTRY alGetFloat( ALenum param );

   385 

   386 AL_API ALdouble AL_APIENTRY alGetDouble( ALenum param );

   387 

   388 

   389 /*

   390  * Error support.

   391  * Obtain the most recent error generated in the AL state machine.

   392  */

   393 AL_API ALenum AL_APIENTRY alGetError( void );

   394 

   395 

   396 /* 

   397  * Extension support.

   398  * Query for the presence of an extension, and obtain any appropriate

   399  * function pointers and enum values.

   400  */

   401 AL_API ALboolean AL_APIENTRY alIsExtensionPresent( const ALchar* extname );

   402 

   403 AL_API void* AL_APIENTRY alGetProcAddress( const ALchar* fname );

   404 

   405 AL_API ALenum AL_APIENTRY alGetEnumValue( const ALchar* ename );

   406 

   407 

   408 /*

   409  * LISTENER

   410  * Listener represents the location and orientation of the

   411  * 'user' in 3D-space.

   412  *

   413  * Properties include: -

   414  *

   415  * Gain         AL_GAIN         ALfloat

   416  * Position     AL_POSITION     ALfloat[3]

   417  * Velocity     AL_VELOCITY     ALfloat[3]

   418  * Orientation  AL_ORIENTATION  ALfloat[6] (Forward then Up vectors)

   419 */

   420 

   421 /*

   422  * Set Listener parameters

   423  */

   424 AL_API void AL_APIENTRY alListenerf( ALenum param, ALfloat value );

   425 

   426 AL_API void AL_APIENTRY alListener3f( ALenum param, ALfloat value1, ALfloat value2, ALfloat value3 );

   427 

   428 AL_API void AL_APIENTRY alListenerfv( ALenum param, const ALfloat* values ); 

   429 

   430 AL_API void AL_APIENTRY alListeneri( ALenum param, ALint value );

   431 

   432 AL_API void AL_APIENTRY alListener3i( ALenum param, ALint value1, ALint value2, ALint value3 );

   433 

   434 AL_API void AL_APIENTRY alListeneriv( ALenum param, const ALint* values );

   435 

   436 /*

   437  * Get Listener parameters

   438  */

   439 AL_API void AL_APIENTRY alGetListenerf( ALenum param, ALfloat* value );

   440 

   441 AL_API void AL_APIENTRY alGetListener3f( ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3 );

   442 

   443 AL_API void AL_APIENTRY alGetListenerfv( ALenum param, ALfloat* values );

   444 

   445 AL_API void AL_APIENTRY alGetListeneri( ALenum param, ALint* value );

   446 

   447 AL_API void AL_APIENTRY alGetListener3i( ALenum param, ALint *value1, ALint *value2, ALint *value3 );

   448 

   449 AL_API void AL_APIENTRY alGetListeneriv( ALenum param, ALint* values );

   450 

   451 

   452 /**

   453  * SOURCE

   454  * Sources represent individual sound objects in 3D-space.

   455  * Sources take the PCM data provided in the specified Buffer,

   456  * apply Source-specific modifications, and then

   457  * submit them to be mixed according to spatial arrangement etc.

   458  * 

   459  * Properties include: -

   460  *

   461  * Gain                              AL_GAIN                 ALfloat

   462  * Min Gain                          AL_MIN_GAIN             ALfloat

   463  * Max Gain                          AL_MAX_GAIN             ALfloat

   464  * Position                          AL_POSITION             ALfloat[3]

   465  * Velocity                          AL_VELOCITY             ALfloat[3]

   466  * Direction                         AL_DIRECTION            ALfloat[3]

   467  * Head Relative Mode                AL_SOURCE_RELATIVE      ALint (AL_TRUE or AL_FALSE)

   468  * Reference Distance                AL_REFERENCE_DISTANCE   ALfloat

   469  * Max Distance                      AL_MAX_DISTANCE         ALfloat

   470  * RollOff Factor                    AL_ROLLOFF_FACTOR       ALfloat

   471  * Inner Angle                       AL_CONE_INNER_ANGLE     ALint or ALfloat

   472  * Outer Angle                       AL_CONE_OUTER_ANGLE     ALint or ALfloat

   473  * Cone Outer Gain                   AL_CONE_OUTER_GAIN      ALint or ALfloat

   474  * Pitch                             AL_PITCH                ALfloat

   475  * Looping                           AL_LOOPING              ALint (AL_TRUE or AL_FALSE)

   476  * MS Offset                         AL_MSEC_OFFSET          ALint or ALfloat

   477  * Byte Offset                       AL_BYTE_OFFSET          ALint or ALfloat

   478  * Sample Offset                     AL_SAMPLE_OFFSET        ALint or ALfloat

   479  * Attached Buffer                   AL_BUFFER               ALint

   480  * State (Query only)                AL_SOURCE_STATE         ALint

   481  * Buffers Queued (Query only)       AL_BUFFERS_QUEUED       ALint

   482  * Buffers Processed (Query only)    AL_BUFFERS_PROCESSED    ALint

   483  */

   484 

   485 /* Create Source objects */

   486 AL_API void AL_APIENTRY alGenSources( ALsizei n, ALuint* sources ); 

   487 

   488 /* Delete Source objects */

   489 AL_API void AL_APIENTRY alDeleteSources( ALsizei n, const ALuint* sources );

   490 

   491 /* Verify a handle is a valid Source */ 

   492 AL_API ALboolean AL_APIENTRY alIsSource( ALuint sid ); 

   493 

   494 /*

   495  * Set Source parameters

   496  */

   497 AL_API void AL_APIENTRY alSourcef( ALuint sid, ALenum param, ALfloat value ); 

   498 

   499 AL_API void AL_APIENTRY alSource3f( ALuint sid, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3 );

   500 

   501 AL_API void AL_APIENTRY alSourcefv( ALuint sid, ALenum param, const ALfloat* values ); 

   502 

   503 AL_API void AL_APIENTRY alSourcei( ALuint sid, ALenum param, ALint value ); 

   504 

   505 AL_API void AL_APIENTRY alSource3i( ALuint sid, ALenum param, ALint value1, ALint value2, ALint value3 );

   506 

   507 AL_API void AL_APIENTRY alSourceiv( ALuint sid, ALenum param, const ALint* values );

   508 

   509 /*

   510  * Get Source parameters

   511  */

   512 AL_API void AL_APIENTRY alGetSourcef( ALuint sid, ALenum param, ALfloat* value );

   513 

   514 AL_API void AL_APIENTRY alGetSource3f( ALuint sid, ALenum param, ALfloat* value1, ALfloat* value2, ALfloat* value3);

   515 

   516 AL_API void AL_APIENTRY alGetSourcefv( ALuint sid, ALenum param, ALfloat* values );

   517 

   518 AL_API void AL_APIENTRY alGetSourcei( ALuint sid,  ALenum param, ALint* value );

   519 

   520 AL_API void AL_APIENTRY alGetSource3i( ALuint sid, ALenum param, ALint* value1, ALint* value2, ALint* value3);

   521 

   522 AL_API void AL_APIENTRY alGetSourceiv( ALuint sid,  ALenum param, ALint* values );

   523 

   524 

   525 /*

   526  * Source vector based playback calls

   527  */

   528 

   529 /* Play, replay, or resume (if paused) a list of Sources */

   530 AL_API void AL_APIENTRY alSourcePlayv( ALsizei ns, const ALuint *sids );

   531 

   532 /* Stop a list of Sources */

   533 AL_API void AL_APIENTRY alSourceStopv( ALsizei ns, const ALuint *sids );

   534 

   535 /* Rewind a list of Sources */

   536 AL_API void AL_APIENTRY alSourceRewindv( ALsizei ns, const ALuint *sids );

   537 

   538 /* Pause a list of Sources */

   539 AL_API void AL_APIENTRY alSourcePausev( ALsizei ns, const ALuint *sids );

   540 

   541 /*

   542  * Source based playback calls

   543  */

   544 

   545 /* Play, replay, or resume a Source */

   546 AL_API void AL_APIENTRY alSourcePlay( ALuint sid );

   547 

   548 /* Stop a Source */

   549 AL_API void AL_APIENTRY alSourceStop( ALuint sid );

   550 

   551 /* Rewind a Source (set playback postiton to beginning) */

   552 AL_API void AL_APIENTRY alSourceRewind( ALuint sid );

   553 

   554 /* Pause a Source */

   555 AL_API void AL_APIENTRY alSourcePause( ALuint sid );

   556 

   557 /*

   558  * Source Queuing 

   559  */

   560 AL_API void AL_APIENTRY alSourceQueueBuffers( ALuint sid, ALsizei numEntries, const ALuint *bids );

   561 

   562 AL_API void AL_APIENTRY alSourceUnqueueBuffers( ALuint sid, ALsizei numEntries, ALuint *bids );

   563 

   564 

   565 /**

   566  * BUFFER

   567  * Buffer objects are storage space for sample data.

   568  * Buffers are referred to by Sources. One Buffer can be used

   569  * by multiple Sources.

   570  *

   571  * Properties include: -

   572  *

   573  * Frequency (Query only)    AL_FREQUENCY      ALint

   574  * Size (Query only)         AL_SIZE           ALint

   575  * Bits (Query only)         AL_BITS           ALint

   576  * Channels (Query only)     AL_CHANNELS       ALint

   577  */

   578 

   579 /* Create Buffer objects */

   580 AL_API void AL_APIENTRY alGenBuffers( ALsizei n, ALuint* buffers );

   581 

   582 /* Delete Buffer objects */

   583 AL_API void AL_APIENTRY alDeleteBuffers( ALsizei n, const ALuint* buffers );

   584 

   585 /* Verify a handle is a valid Buffer */

   586 AL_API ALboolean AL_APIENTRY alIsBuffer( ALuint bid );

   587 

   588 /* Specify the data to be copied into a buffer */

   589 AL_API void AL_APIENTRY alBufferData( ALuint bid, ALenum format, const ALvoid* data, ALsizei size, ALsizei freq );

   590 

   591 /*

   592  * Set Buffer parameters

   593  */

   594 AL_API void AL_APIENTRY alBufferf( ALuint bid, ALenum param, ALfloat value );

   595 

   596 AL_API void AL_APIENTRY alBuffer3f( ALuint bid, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3 );

   597 

   598 AL_API void AL_APIENTRY alBufferfv( ALuint bid, ALenum param, const ALfloat* values );

   599 

   600 AL_API void AL_APIENTRY alBufferi( ALuint bid, ALenum param, ALint value );

   601 

   602 AL_API void AL_APIENTRY alBuffer3i( ALuint bid, ALenum param, ALint value1, ALint value2, ALint value3 );

   603 

   604 AL_API void AL_APIENTRY alBufferiv( ALuint bid, ALenum param, const ALint* values );

   605 

   606 /*

   607  * Get Buffer parameters

   608  */

   609 AL_API void AL_APIENTRY alGetBufferf( ALuint bid, ALenum param, ALfloat* value );

   610 

   611 AL_API void AL_APIENTRY alGetBuffer3f( ALuint bid, ALenum param, ALfloat* value1, ALfloat* value2, ALfloat* value3);

   612 

   613 AL_API void AL_APIENTRY alGetBufferfv( ALuint bid, ALenum param, ALfloat* values );

   614 

   615 AL_API void AL_APIENTRY alGetBufferi( ALuint bid, ALenum param, ALint* value );

   616 

   617 AL_API void AL_APIENTRY alGetBuffer3i( ALuint bid, ALenum param, ALint* value1, ALint* value2, ALint* value3);

   618 

   619 AL_API void AL_APIENTRY alGetBufferiv( ALuint bid, ALenum param, ALint* values );

   620 

   621 

   622 /*

   623  * Global Parameters

   624  */

   625 AL_API void AL_APIENTRY alDopplerFactor( ALfloat value );

   626 

   627 AL_API void AL_APIENTRY alDopplerVelocity( ALfloat value );

   628 

   629 AL_API void AL_APIENTRY alSpeedOfSound( ALfloat value );

   630 

   631 AL_API void AL_APIENTRY alDistanceModel( ALenum distanceModel );

   632 

   633 /*

   634  * Pointer-to-function types, useful for dynamically getting AL entry points.

   635  */

   636 typedef void           (AL_APIENTRY *LPALENABLE)( ALenum capability );

   637 typedef void           (AL_APIENTRY *LPALDISABLE)( ALenum capability ); 

   638 typedef ALboolean      (AL_APIENTRY *LPALISENABLED)( ALenum capability ); 

   639 typedef const ALchar*  (AL_APIENTRY *LPALGETSTRING)( ALenum param );

   640 typedef void           (AL_APIENTRY *LPALGETBOOLEANV)( ALenum param, ALboolean* data );

   641 typedef void           (AL_APIENTRY *LPALGETINTEGERV)( ALenum param, ALint* data );

   642 typedef void           (AL_APIENTRY *LPALGETFLOATV)( ALenum param, ALfloat* data );

   643 typedef void           (AL_APIENTRY *LPALGETDOUBLEV)( ALenum param, ALdouble* data );

   644 typedef ALboolean      (AL_APIENTRY *LPALGETBOOLEAN)( ALenum param );

   645 typedef ALint          (AL_APIENTRY *LPALGETINTEGER)( ALenum param );

   646 typedef ALfloat        (AL_APIENTRY *LPALGETFLOAT)( ALenum param );

   647 typedef ALdouble       (AL_APIENTRY *LPALGETDOUBLE)( ALenum param );

   648 typedef ALenum         (AL_APIENTRY *LPALGETERROR)( void );

   649 typedef ALboolean      (AL_APIENTRY *LPALISEXTENSIONPRESENT)(const ALchar* extname );

   650 typedef void*          (AL_APIENTRY *LPALGETPROCADDRESS)( const ALchar* fname );

   651 typedef ALenum         (AL_APIENTRY *LPALGETENUMVALUE)( const ALchar* ename );

   652 typedef void           (AL_APIENTRY *LPALLISTENERF)( ALenum param, ALfloat value );

   653 typedef void           (AL_APIENTRY *LPALLISTENER3F)( ALenum param, ALfloat value1, ALfloat value2, ALfloat value3 );

   654 typedef void           (AL_APIENTRY *LPALLISTENERFV)( ALenum param, const ALfloat* values );

   655 typedef void           (AL_APIENTRY *LPALLISTENERI)( ALenum param, ALint value );

   656 typedef void           (AL_APIENTRY *LPALLISTENER3I)( ALenum param, ALint value1, ALint value2, ALint value3 );

   657 typedef void           (AL_APIENTRY *LPALLISTENERIV)( ALenum param, const ALint* values );

   658 typedef void           (AL_APIENTRY *LPALGETLISTENERF)( ALenum param, ALfloat* value );

   659 typedef void           (AL_APIENTRY *LPALGETLISTENER3F)( ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3 );

   660 typedef void           (AL_APIENTRY *LPALGETLISTENERFV)( ALenum param, ALfloat* values );

   661 typedef void           (AL_APIENTRY *LPALGETLISTENERI)( ALenum param, ALint* value );

   662 typedef void           (AL_APIENTRY *LPALGETLISTENER3I)( ALenum param, ALint *value1, ALint *value2, ALint *value3 );

   663 typedef void           (AL_APIENTRY *LPALGETLISTENERIV)( ALenum param, ALint* values );

   664 typedef void           (AL_APIENTRY *LPALGENSOURCES)( ALsizei n, ALuint* sources ); 

   665 typedef void           (AL_APIENTRY *LPALDELETESOURCES)( ALsizei n, const ALuint* sources );

   666 typedef ALboolean      (AL_APIENTRY *LPALISSOURCE)( ALuint sid ); 

   667 typedef void           (AL_APIENTRY *LPALSOURCEF)( ALuint sid, ALenum param, ALfloat value); 

   668 typedef void           (AL_APIENTRY *LPALSOURCE3F)( ALuint sid, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3 );

   669 typedef void           (AL_APIENTRY *LPALSOURCEFV)( ALuint sid, ALenum param, const ALfloat* values );

   670 typedef void           (AL_APIENTRY *LPALSOURCEI)( ALuint sid, ALenum param, ALint value); 

   671 typedef void           (AL_APIENTRY *LPALSOURCE3I)( ALuint sid, ALenum param, ALint value1, ALint value2, ALint value3 );

   672 typedef void           (AL_APIENTRY *LPALSOURCEIV)( ALuint sid, ALenum param, const ALint* values );

   673 typedef void           (AL_APIENTRY *LPALGETSOURCEF)( ALuint sid, ALenum param, ALfloat* value );

   674 typedef void           (AL_APIENTRY *LPALGETSOURCE3F)( ALuint sid, ALenum param, ALfloat* value1, ALfloat* value2, ALfloat* value3);

   675 typedef void           (AL_APIENTRY *LPALGETSOURCEFV)( ALuint sid, ALenum param, ALfloat* values );

   676 typedef void           (AL_APIENTRY *LPALGETSOURCEI)( ALuint sid, ALenum param, ALint* value );

   677 typedef void           (AL_APIENTRY *LPALGETSOURCE3I)( ALuint sid, ALenum param, ALint* value1, ALint* value2, ALint* value3);

   678 typedef void           (AL_APIENTRY *LPALGETSOURCEIV)( ALuint sid, ALenum param, ALint* values );

   679 typedef void           (AL_APIENTRY *LPALSOURCEPLAYV)( ALsizei ns, const ALuint *sids );

   680 typedef void           (AL_APIENTRY *LPALSOURCESTOPV)( ALsizei ns, const ALuint *sids );

   681 typedef void           (AL_APIENTRY *LPALSOURCEREWINDV)( ALsizei ns, const ALuint *sids );

   682 typedef void           (AL_APIENTRY *LPALSOURCEPAUSEV)( ALsizei ns, const ALuint *sids );

   683 typedef void           (AL_APIENTRY *LPALSOURCEPLAY)( ALuint sid );

   684 typedef void           (AL_APIENTRY *LPALSOURCESTOP)( ALuint sid );

   685 typedef void           (AL_APIENTRY *LPALSOURCEREWIND)( ALuint sid );

   686 typedef void           (AL_APIENTRY *LPALSOURCEPAUSE)( ALuint sid );

   687 typedef void           (AL_APIENTRY *LPALSOURCEQUEUEBUFFERS)(ALuint sid, ALsizei numEntries, const ALuint *bids );

   688 typedef void           (AL_APIENTRY *LPALSOURCEUNQUEUEBUFFERS)(ALuint sid, ALsizei numEntries, ALuint *bids );

   689 typedef void           (AL_APIENTRY *LPALGENBUFFERS)( ALsizei n, ALuint* buffers );

   690 typedef void           (AL_APIENTRY *LPALDELETEBUFFERS)( ALsizei n, const ALuint* buffers );

   691 typedef ALboolean      (AL_APIENTRY *LPALISBUFFER)( ALuint bid );

   692 typedef void           (AL_APIENTRY *LPALBUFFERDATA)( ALuint bid, ALenum format, const ALvoid* data, ALsizei size, ALsizei freq );

   693 typedef void           (AL_APIENTRY *LPALBUFFERF)( ALuint bid, ALenum param, ALfloat value);

   694 typedef void           (AL_APIENTRY *LPALBUFFER3F)( ALuint bid, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3 );

   695 typedef void           (AL_APIENTRY *LPALBUFFERFV)( ALuint bid, ALenum param, const ALfloat* values );

   696 typedef void           (AL_APIENTRY *LPALBUFFERI)( ALuint bid, ALenum param, ALint value);

   697 typedef void           (AL_APIENTRY *LPALBUFFER3I)( ALuint bid, ALenum param, ALint value1, ALint value2, ALint value3 );

   698 typedef void           (AL_APIENTRY *LPALBUFFERIV)( ALuint bid, ALenum param, const ALint* values );

   699 typedef void           (AL_APIENTRY *LPALGETBUFFERF)( ALuint bid, ALenum param, ALfloat* value );

   700 typedef void           (AL_APIENTRY *LPALGETBUFFER3F)( ALuint bid, ALenum param, ALfloat* value1, ALfloat* value2, ALfloat* value3);

   701 typedef void           (AL_APIENTRY *LPALGETBUFFERFV)( ALuint bid, ALenum param, ALfloat* values );

   702 typedef void           (AL_APIENTRY *LPALGETBUFFERI)( ALuint bid, ALenum param, ALint* value );

   703 typedef void           (AL_APIENTRY *LPALGETBUFFER3I)( ALuint bid, ALenum param, ALint* value1, ALint* value2, ALint* value3);

   704 typedef void           (AL_APIENTRY *LPALGETBUFFERIV)( ALuint bid, ALenum param, ALint* values );

   705 typedef void           (AL_APIENTRY *LPALDOPPLERFACTOR)( ALfloat value );

   706 typedef void           (AL_APIENTRY *LPALDOPPLERVELOCITY)( ALfloat value );

   707 typedef void           (AL_APIENTRY *LPALSPEEDOFSOUND)( ALfloat value );

   708 typedef void           (AL_APIENTRY *LPALDISTANCEMODEL)( ALenum distanceModel );

   709 

   710 #if defined(TARGET_OS_MAC) && TARGET_OS_MAC

   711  #pragma export off

   712 #endif

   713 

   714 #if defined(__cplusplus)

   715 }  /* extern "C" */

   716 #endif

   717 

   718 #endif /* AL_AL_H */
author	Robert McIntyre <rlm@mit.edu>
date	Tue, 25 Oct 2011 13:03:35 -0700
parents	f9476ff7637e
children