GNU Info

(openal.info)Built in

---

Next: Making your own Prev: Loki specific tokens Up: Extensions

---

Enter node , (file) or (file)node

   Here's a list of extensions which are built into the Loki OpenAL
implementation.  The prefix is included in this section for clarify.

`void alAttenuationScale_LOKI(ALfloat param)'
     `alAttenuationScale_LOKI' scales the units of the simulation.
     Without a call to this function, it is very likely that your
     application will not sound correct.

     The default scaling factor in Loki's OpenAL is such that a listener
     placed at the origin will hear sounds attenuated until that point
     that the sounds are `ALMAXDISTANCE' units away.  `ALMAXDISTANCE' is
     an arbitrary constant defined when including `AL/alkludge.h'.

     It is almost assured that the default scaling factor will be
     incorrect for most applications.  That is why this call is so
     important.  Usage will generally follow:

                  /* create context, load data, and define some value radius
                   * to be the radius of your world simulation.
                   */
          
                  setScale = (void (*)(ALfloat ))
                                  alGetProcAddress("alAttenuationScale_LOKI");
                  if(setScale != NULL) {
                          setScale(radius / ALMAXDISTANCE);
                  }

     It is highly recommended you explicitly use this function, and do
     not assume that the default units will be useful to you.

`ALfloat alcGetAudioChannel_LOKI(ALuint channel)'
     `alcGetAudioChannel_LOKI' takes in a channel enumeration from the
     set `AL_CHAN_MAIN_LOKI', `AL_CHAN_PCM_LOKI', and
     `AL_CHAN_CD_LOKI', and returns a normalized ALfloat, corresponding
     to the volume associated with the channel on whatever backend the
     library is using.

`void alcSetAudioChannel_LOKI(ALuint channel, ALfloat volume)'
     `alcSetAudioChannel_LOKI' takes a channel specification from the
     set `AL_CHAN_MAIN_LOKI', `AL_CHAN_PCM_LOKI', and `AL_CHAN_CD_LOKI'
     and a normalized volume, and sets the hardware channel associated
     with the channel argument to the volume (the volume mapped to the
     settings appropriate for the backend, that is).

`void alMute_LOKI(ALvoid)'
     `alMute_LOKI' returns nothing and takes no argument.  After a call
     to `alMute_LOKI', the implementation ceased all audio output, while
     still updating state (so sources still play, you just can't hear
     them).  The audio setting is preserved so that a subsequent call to
     `alUnMute_LOKI' will restore the volume to its value prior to the
     `alMute_LOKI' call.

     This isn't really useful, as you can do the same with by just
     querying and setting the listener gain.

`void alUnMute_LOKI(ALvoid)'
     `alUnMute_LOKI' performs the inverse operation of `alMute_LOKI'.
     alUnMute_LOKI restores the volume of the simulation to that which
     is was before calling `alMute_LOKI'.

`void alReverbScale_LOKI(ALuint sid, ALfloat param)'
     `alReverbScale_LOKI' allows you to set a normalized value param,
     which represents the gain that is used when reverberating.  Don't
     use it.  It will be removed as soon as the IASIG extension is
     completed.

`void alReverbDelay_LOKI(ALuint sid, ALfloat param)'
     `alReverbScale_LOKI' allows you to set the delay associated with a
     reverberating source.  Don't use this.  It will be removed as soon
     as the IASIG extension is completed.

`ALboolean alBufferPitchHack_LOKI(ALuint bid, ALfloat pitch)'
     Don't use this.  You don't want it.

`void alBombOnError_LOKI(void)'
     `alBombOnError_LOKI', when called, will cause the implementation to
     abort on error, instead of just setting the per-context error and
     continuing.  This is useful only for debugging.  alc errors are not
     handled.

`void alBufferi_LOKI( ALuint bid, ALenum param, ALint value )'
     `alBufferi_LOKI' can be used to set a buffer's attributes.  Not
     recommended unless you know what you're doing.  Usually, you can
     use this to enable a "multichannel" buffer.

`void alBufferDataWithCallback_LOKI( ALuint bid, ALint (*callback)(ALuint sid, ALuint bid, ALshort *data, ALenum format, ALuint samples))'
     `alBufferDataWithCallback_LOKI' can be used to specify that the
     buffer `bid' should, instead of using a static chunk of data
     specified by `alBufferData', call the callback `callback' to fill
     a chunk of data as needed.

     The parameters for `callback' are as such:

          	`ALuint sid'
          	The source id that this request is associated with.  Since many
          	sources may share the same buffer, this sid allows the application
          	to keep track of offsets and other state associated with each
          	source instance.
          
          	`ALuint bid'
          	The buffer id that the callback is associated with.
          
          	`ALshort *data'
          	The memory area that the callback should populate
          
          	`ALenum format'
          	The format the the output data should be in.
          
          	`ALuint samples'
          	The number of *samples* required.