:      !"#$%&'()*+,-./0123456789:;<=>?@AB C D E F GHIJ K L M N O P Q R STUVWX Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~  (c) Sven Panne 2003-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportable Safe-InferredThe abstract context type.The abstract device type.64-bit IEEE754 floating-point32-bit IEEE754 floating-pointEnumerated 32-bit value(Non-negatitve 32-bit binary integer sizeUnsigned 32-bit integer$Signed 32-bit 2's complement integerUnsigned 16-bit integer $Signed 16-bit 2's complement integer Unsigned 8-bit integer #Signed 8-bit 2's complement integer  Character  8-bit boolean64-bit IEEE754 floating-point32-bit IEEE754 floating-pointEnumerated 32-bit value(Non-negatitve 32-bit binary integer sizeUnsigned 32-bit integer$Signed 32-bit 2's complement integerUnsigned 16-bit integer$Signed 16-bit 2's complement integerUnsigned 8-bit integer#Signed 8-bit 2's complement integer Character 8-bit booleanm allows the application (i.e. the client program) to disconnect from a device (i.e. the server). It returns  for success and  for failure. Once closed, the  is invalid.Note:; Older OpenAL implementations will always report a success!+ ( ' (c) Sven Panne 2003-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportable Safe-Inferred  (c) Sven Panne 2003-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportable Safe-Inferred(c) Sven Panne 2003-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportable Safe-InferredUUU(c) Sven Panne 2003-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportable Safe-Inferred      (c) Sven Panne 2003-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportable Safe-InferredqTo verify that a given extension is available for the current context and the device it is associated with, use 9. For invalid and unsupported string tokens it contains . Using   as the device is acceptable. The extension name is not case sensitive: The implementation will convert the name to all upper-case internally (and will express extension names in upper-case).   !"   !"    !"(c) Sven Panne 2003-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportable Safe-Inferredu allows the application (i.e. the client program) to connect to a device (i.e. the server). If the function returns  ?, then no sound driver/device has been found. The argument to ? specifies a certain device or device configuration. If it is  L, the implementation will provide an implementation specific default, see . Otherwise it is #2 an implementation-dependent string. You can use , to get a list of the known OpenAL devices.Notes for Windows:h There are 3 possible device strings, each having a deprecated equivalent for legacy applications only:"Generic Hardware" (legacy string: "DirectSound3D")"Generic Software" (legacy string:  "DirectSound")"Generic Software Fallback" (legacy string:  "MMSYSTEM")Notes for Linux/*nix: If an  .openalrcN file is present in the user's home directory, it is loaded first, otherwise  /etc/openalrc% is tried. The bindings (if any) of devices,  direction,  sampling-rate, and  speaker-numj (see below) after loading one of these files take precedence over any bindings done via the argument to .qThe syntax of these files is lisp-based and a sequence of expressions, where an expression is one the following: A boolean value of the form #f or #t, which evaluate to false and true, respectively.XAn non-negative integer value, i.e. a sequence of decimal digits, evaluating to itself.6A (signed) floating point value, as recoginzed by C's atof(), evaluating to itself.A pointer value of the form #pnum, where numF can be an octal, decimal or hexadecimal value, as recoginzed by C`s strtol()E, evaluating to itself. This kind of expression is currently unused.jA string, i.e. a sequence of printable/whitespace characters between double quotes, evaluating to itself.}A symbol, i.e. a sequence of almost all characters which don't form a simple expression like the ones mentioned below, e.g. foo, bar1, 3baz?, ... The symbol evaluates to the value currently bound to it.#A function application of the form (symbol  expression...)J. The function bound to the symbol is applied to the evaluated arguments.A quotation of the form (quote  expression) or ' expression!, evaluating to the unevaluated  expression itself.A definition of the form (define symbol  expression) , binding symbol to the value of  expression2. The whole expression evaluates to the value of  expression, too.1A conjunction of boolean expressions of the form (and  expression...). Each  expression8 is evaluated in turn, and if one of them evaluates to false', the value of the whole expression is false. Otherwise the value is true.+An extension loading mechanism of the form (load-extension  libraryName), where  libraryNamej has to evaluate to a string. This tries to load the dynamic library with up to 3 special entry points: alExtension_03282000l (pointing to a mandatory NULL-terminated sequence of pairs of pointers to names and extension functions), alExtInit_03282000- (an optional initialization function), and alExtFini_03282000t (an optional cleanup function). If the extension could be loaded successfully, the whole expression evaluates to true, otherwise to false./Some symbols have a special meaning for OpenAL: devices Has the form (devspec...), where devspec3 is either a symbol/string specifying a device or (device  device-param...)n, specifying a device with additional parameters. These optional device parameters are stored in a variable  device-paramsT, but are currently unused. The first device which can successfully opened is used. directionType string or symbol: "read"e specifies that the device should be an input device, everything else means output device (default). sampling-rateTType integer or float: Specifies the internal mixing frequency, default is 44.1kHz. speaker-num\Type integer or float: Specifies the number of speakers, which can be 1, 2 (default), or 4. alsa-device Type string, alsa backend only: Specifies both alsa-out-device and alsa-in-device , default  "plughw:0,0".alsa-out-device Type string, alsaK backend only: Specifies the ALSA output device, defaults to the value of  alsa-device.alsa-in-device Type string, alsaJ backend only: Specifies the ALSA input device, defaults to the value of  alsa-device.native-in-device Type string, native backend on IRIX only.native-out-device Type string, native backend on IRIX only.native-rear-out-device Type string, native backend on IRIX only.native-use-selectType boolean, native backend on Linux only: If #tD, wait up to 0.8sec for the device to become ready for writing. If #f{, just try to write and hope it won't hang forever. The latter might be necessary for some drivers which don't implement select() , like some Aureal drivers. lin-dsp-path Type string, nativeF backend on Linux only: Path to DSP device for writing, tried before /dev/sound/dsp and  /dev/sound if set.lin-dsp-read-path Type string, nativeF backend on Linux only: Path to DSP device for reading, tried before /dev/sound/dsp and  /dev/sound# if set. Defaults to the value of  lin-dsp-path.native-backend-debugType boolean, native$ backend on Darwin only: If set to #fC, be a bit verbose on stderr about what's going on in the backend.source-rolloff-factorTType integer or float: Value of the initial rolloff factor for sources, default is 1.0.listener-positionRList of 3 integers or floats: Value of the initial listener position, default is (0 0 0).listener-velocityRList of 3 integers or floats: Value of the initial listener velocity, default is (0 0 0).listener-orientation]List of 6 integers or floats: Value of the initial listener orientation (at/up), default is (0 0 -1 0 1 0).The string given to  has to be of the form '((symbol  expression) ...)&, which means basically a sequence of define expressions. Example: 4"'((sampling-rate 8000) (native-backend-debug #f))" Note: The information above has been reverse-engineered from the OpenAL SI and could be inaccurate. Any corrections and/or additions are highly welcome. Contains #0 the specifier string for the default device or  & if there is no sound support at all.3Contains the specifier string for the given device.8Contains a list of specifiers for all available devices.$$(c) Sven Panne 2003-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportable Safe-Inferred 0Contains a list of available context extensions.!The application is expected to verify the applicability of an extension or core function entry point before requesting it by name, by use of 1. Extension entry points can be retrieved using !L. Entry points can be device specific, but are not context specific. Using  x as the device does not guarantee that the entry point is returned, even if available for one of the available devices."Enumeration/token values are device independent, but tokens defined for extensions might not be present for a given device. Using   as the device is legal, but only the tokens defined by the AL core are guaranteed. Availability of extension tokens depends on the ALC extension.#Contains the "major.minor1" specification revision for this implementation.%& !"#' !"# !"#%& !"#'(c) Sven Panne 2003-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportable Safe-Inferred$General ALC error categories.+UALC errors consist of a general error category and a description of what went wrong.-OpenAL detects only a subset of those conditions that could be considered errors. This is because in many cases error checking would adversely impact the performance of an error-free program. The state variable - is used to obtain error information. When an error is detected by ALC, a flag is set and the error code is recorded. Further errors, if they occur, do not affect this recorded code. When - is read, the error for the given device is returned and the flag is cleared, so that a further error will again record its code. If reading - returns []> then there has been no detectable error since the last time -% (or since the ALC was initialized).LWhen an error flag is set, results of ALC operations are undefined only if % has occurred. In other cases, the command generating the error is ignored so that it has no effect on ALC state or output buffer contents. If the error generating command returns a value, it returns zero. If the generating command modifies values through a pointer argument, no change is made to these values. These error semantics apply only to ALC errors, not to system errors such as memory access errors. $%&'()*+,()- $%&'()*+,- +,$*)('&%-$*)('&%+,()-(c) Sven Panne 2003-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportable Safe-Inferred.The application can choose to specify certain attributes for a context at context-creation time. Attributes not specified explicitly are set to implementation dependent defaults./QA hint indicating how many sources should be capable of supporting stereo data0OA hint indicating how many sources should be capable of supporting mono data1&Flag, indicating a synchronous context2!Refresh intervals, in units of Hz35Frequency for mixing output buffer, in units of Hz4Frequency, specified in samples per second, i.e. units of Hertz [Hz]. Note that the underlying OpenAL API currently uses integral frequencies only, but we want to mirror physical reality here more closely.5Create a context for a given device and given attributes. Context creation will fail in the following cases: a) if the application requests attributes that, by themselves, can not be provided b) if the combination of specified attributes can not be provided c) if a specified attribute, or the combination of attributes, does not match the default values for unspecified attributes If context creation fails,   will be returned, otherwise # the new context. Note that 5 does not< set the current context, this must be done separately via 6.6 Contains #; the current context with respect to OpenAL operation, or   if there is no current context. Setting it to the latter is useful when shutting OpenAL down. The state variable applies to the device that the context was created for. For each OS process (usually this means for each application), only one context can be current at any given time. All AL commands apply to the current context. Commands that affect objects shared among contexts (e.g. buffers) have side effects on other contexts.7oThe current context is the only context accessible to state changes by AL commands (aside from state changes affecting shared objects). However, multiple contexts can be processed at the same time. To indicate that a context should be processed (i.e. that internal execution state like offset increments are supposed to be performed), the application has to use 7. Repeated calls to 7z are legal, and do not affect a context that is already marked as processing. The default state of a context created by 5 is that it is processing.8 The application can suspend any context from processing (including the current one). To indicate that a context should be suspended from processing (i.e. that internal execution state like offset increments is not supposed to be changed), the application has to use 8. Repeated calls to 8M are legal, and do not affect a context that is already marked as suspended.9qDestroy the given context. Note that the the correct way to destroy a context is to first release it by setting 6 to  n. Applications should not attempt to destroy a current context, doing so will not work and will result in an ( error.: Contains #$ the device of the given context or   if the context is invalid.;MContains the attribute list for the current context of the specified device../01234*+,-./5601789:;2./0123456789:;4.3210/56789:;.3210/4*+,-./5601789:;2(c) Sven Panne 2003-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportable Safe-Inferred345634563456(c) Sven Panne 2003-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportable Safe-Inferred  (c) Sven Panne 2003-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportable Safe-Inferred<FValid sound formats. An implementation may expose other formats, see Sound.OpenAL.ALC.ExtensionsE for information on determining if additional formats are supported.<=>?@7A<=>?@7A<@?>=7A(c) Sven Panne 2003-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportable Safe-InferredB=Each source can be in one of four possible execution states: F, E, D, C. Sources that are either E or D* are considered active. Sources that are C or F are considered inactive. Only E sources are included in the processing. The implementation is free to skip those processing stages for sources that have no effect on the output (e.g. mixing for a source muted by zero gain, but not sample offset increments). Depending on the current state of a source certain (e.g. repeated) state transition commands are legal NOPs: they will be ignored, no error is generated.BCDEF8BCDEF8BFEDC8(c) Sven Panne 2003-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportable Safe-Inferred9G9G9G(c) Sven Panne 2003-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportable Safe-InferredHThe abstract buffer type.:A dummy buffer. H;<=>?:@IABCH;<@I H;<=>?:@IABC(c) Sven Panne 2003-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportable Safe-InferredDEDEDE(c) Sven Panne 2003-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportable Safe-Inferred&FGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijk$FGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgikFKJIHGLgfedcba`_^]\[ZYXWVUTSRQPONMhijk (c) Sven Panne 2003-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportable Safe-InferredJGeneral AL error categories.PTAL errors consist of a general error category and a description of what went wrong.ROpenAL detects only a subset of those conditions that could be considered errors. This is because in many cases error checking would adversely impact the performance of an error-free program. The state variable R is used to obtain error information. When an error is detected by AL, a flag is set and the error code is recorded. Further errors, if they occur, do not affect this recorded code. When Rz is read, the error is returned and the flag is cleared, so that a further error will again record its code. If reading R returns []> then there has been no detectable error since the last time R# (or since the AL was initialized).KWhen an error flag is set, results of AL operations are undefined only if K has occurred. In other cases, the command generating the error is ignored so that it has no effect on AL state or output buffer contents. If the error generating command returns a value, it returns zero. If the generating command modifies values through a pointer argument, no change is made to these values. These error semantics apply only to AL errors, not to system errors such as memory access errors. JKLMNOPQlmR JKLMNOPQR PQJONMLKRJONMLKPQlmR(c) Sven Panne 2003-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportable Safe-InferredWA special case of buffer state is the actual sound sample data stored in association with the buffer. Applications can specify sample data using W.The data specified is copied to an internal software, or if possible, hardware buffer. The implementation is free to apply decompression, conversion, resampling, and filtering as needed. The internal format of the buffer is not exposed to the application, and not accessible.3Buffers containing audio data with more than one channel will be played without 3D spatialization features, these formats are normally used for background music. Applications should always check for an error condition after attempting to specify buffer data in case an implementation has to generate an K or a conversion related NY error. The application is free to reuse the memory specified by the data pointer once WU is set. The implementation has to dereference, e.g. copy, the data while accessing W execution.nopqrSTUVstWuvwxy <=>?@HSTUVW HUV<@?>=STW nrqpoSTUVstWuvwxy (c) Sven Panne 2003-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportable Safe-Inferred_0Contains the name of the default capture device.`;Contains the specifier string for the given capture device.a@Contains a list of specifiers for all available capture devices.zX{|}~YZ[\]^_`a XYZ[\]^_`a XYZ[\]^_`azX{|}~YZ[\]^_`a (c) Sven Panne 2003-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportable Safe-Inferredb Contains the name of the vendor.c1Contains information about the specific renderer.bcbcbcbc (c) Sven Panne 2003-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportable Safe-InferreddA scalar amplitude multiplier.ee contains the current location of the listener in the world coordinate system. Any 3-tuple of valid float values is allowed. Implementation behavior on encountering NaN and infinity is not defined. The initial position is ( 0 0 0).ff contains current velocity (speed and direction) of the listener in the world coordinate system. Any 3-tuple of valid float values is allowed, and the initial velocity is ( 0 0 0). f does not affect eM. OpenAL does not calculate the velocity from subsequent position updates, nor does it adjust the position over time based on the specified velocity. Any such calculation is left to the application. For the purposes of sound processing, position and velocity are independent parameters affecting different aspects of the sounds.f is taken into account by the driver to synthesize the Doppler effect perceived by the listener for each source, based on the velocity of both source and listener, and the Doppler related parameters.gg contains a scalar amplitude multiplier, which is effectively applied to all sources in the current context. The initial value 1 means that the sound is unattenuated. A g value of 0.5 is equivalent to an attenuation of 6dB. The value zero equals silence (no output). Driver implementations are free to optimize this case and skip mixing and processing stages where applicable. The implementation is in charge of ensuring artifact-free (click-free) changes of gain values and is free to defer actual modification of the sound samples, within the limits of acceptable latencies.A g larger than 1 (amplification) is permitted. However, the implementation is free to clamp the total gain (effective gain per source times listener gain) to 1 to prevent overflow.hh contains an "at" vector and an "up" vector, where the "at" vector represents the "forward" direction of the listener and the orthogonal projection of the "up" vector into the subspace perpendicular to the "at" vector represents the "up" direction for the listener. OpenAL expects two vectors that are linearly independent. These vectors are not expected to be normalized. If the two vectors are linearly dependent, behavior is undefined. The initial orientation is ( 0 0 (-1), H 0 1 0), i.e. looking down the Z axis with the Y axis pointing upwards.defghdefghefdghdefgh (c) Sven Panne 2003-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportable Safe-InferrediGSpecifies what should happen when the end of a buffer queue is reached.l,When first created, a source will be in the o, state. If a buffer is then attached using z", then the source will enter the nD state. If the first buffer attached to a source is attached using !, then the source will enter the m9 state. A source of either state will be reset to state o by setting its z to  K, and attaching any buffer to a streaming source will change the state to nE. Attempting to queue a buffer on a static source will result in an M error.p*The entity to which the source attributes t, u and  are to be interpreted.sThe abstract buffer type.tt contains the current location of the source in the world coordinate system. Any 3-tuple of valid float values is allowed. Implementation behavior on encountering NaN and infinity is not defined. The initial position is ( 0 0 0).uu contains current velocity (speed and direction) of the source in the world coordinate system. Any 3-tuple of valid float values is allowed, and the initial velocity is ( 0 0 0). u does not affect tL. OpenAL does not calculate the velocity from subsequent position updates, nor does it adjust the position over time based on the specified velocity. Any such calculation is left to the application. For the purposes of sound processing, position and velocity are independent parameters affecting different aspects of the sounds.u is taken into account by the driver to synthesize the Doppler effect perceived by the listener for each source, based on the velocity of both source and listener, and the Doppler related parameters.vv{ contains a scalar amplitude multiplier for the given source. The initial value 1 means that the sound is unattenuated. A v value of 0.5 is equivalent to an attenuation of 6dB. The value zero equals silence (no output). Driver implementations are free to optimize this case and skip mixing and processing stages where applicable. The implementation is in charge of ensuring artifact-free (click-free) changes of gain values and is free to defer actual modification of the sound samples, within the limits of acceptable latencies.A v larger than 1 (amplification) is permitted. However, the implementation is free to clamp the total gain (effective gain per source times listener gain) to 1 to prevent overflow.wIf w contains q7, it indicates indicates that the values specified by t, u and Q are to be interpreted relative to the listener position. The initial value is rz, indicating that those source attributes are to be interpreted relative to the world, i.e. they are considered absolute.xx indicates whether a source is ready to queue buffers, ready to use a static buffer, or is in an undetermined state where it can be used for either streaming or static playback.yIf y contains j3, it indicates that the source will not be in the Ct state once it reaches the end of last buffer in the buffer queue. Instead, the source will immediately promote to F and E. The initial value is k. y\ can be changed on a source in any execution state. In particular, it can be changed on a E source.zz- contains the current buffer object. Setting z to #J a buffer object makes it the head entry in the source's queue. Setting zfor a source in the C or F[ state empties the entire queue, then appends the one buffer specified (or none at all if   was specified).For a source in the E or D state, setting z will result in the M error state being set. z( can be applied only to sources in the F and C states. Specifying an invalid buffer name (either because the buffer name doesn't exist or because that buffer can't be attached to the specified source) will result in an N> error while specifying an invalid source name results in an L error. Setting z to  H is a legal way to release the current buffer queue on a source in the F or CR state, whether the source has just one entry (current buffer) or more. Setting z to   still causes an M for any source in the E or DW state, consequently it cannot be used to mute or stop a source. The initial value is  .{{ contains the number of buffers in the queue of a given source. This includes those not yet played, the one currently playing, and the ones that have been played already. It will contain 0 if z has been set to  .|| contains the number of buffers that have been played by a given source. Indirectly, this gives the index of the buffer currently playing. It can be used to determine how much slots are needed for unqueuing them. On a source in the C7 state, all buffers are processed. On a source in the FQ state, no buffers are processed, all buffers are pending. It will contain 0 if z has been set to  .}}# contains two scalar amplitude thresholds between 0 and 1 (included): The minimum guaranteed gain for this source and the maximum gain permitted, with initial values 0 and 1, respectively At the end of the processing of various attenuation factors such as distance based attenuation and v<, the effective gain calculated is compared to these values:lIf the effective gain is lower than the minimum gain, the minimum gain is applied. This happens before the g[ is applied. If a zero minimum gain is set, then the effective gain will not be corrected.mIf the effective gain is higher than the maximum gain, the maximum gain is applied. This happens before the g is applied. If the g9 times the maximum gain still exceeds the maximum gain the implementation can handle, the implementation is free to clamp. If a zero maximum gain is set, then the source is effectively muted. The implementation is free to optimize for this situation, but no optimization is required or recommended as setting v- to zero is the proper way to mute a source.~~ is used for distance attenuation calculations based on inverse distance with rolloff. Depending on the distance model it will also act as a distance threshold below which gain is clamped. See Sound.OpenAL.AL.Attenuation% for details. The initial value is 1.s is used for distance attenuation calculations based on inverse distance with rolloff. For distances smaller than 5 (and, depending on the distance model, larger than ~M), this will scale the distance attenuation over the applicable range. See Sound.OpenAL.AL.Attenuationd for details how the attenuation is computed as a function of the distance. The initial value is 1.In particular,  can be set to zero for those sources that are supposed to be exempt from distance attenuation. The implementation is encouraged to optimize this case, bypassing distance attenuation calculation entirely on a persource basis. is used for distance attenuation calculations based on inverse distance with rolloff, if the inverse clamped distance model is used. In this case, distances greater than  will be clamped to . > based clamping is applied before minimum gain clamping (see }), so if the effective gain at  is larger than the minimum gain, the minimum gain will have no effect. No culling is supported. The initial value is the largest representable . contains the desired pitch shift, where 1 (the initial value) equals identity. Each reduction by 50 percent equals a pitch shift of -12 semitones (one octave reduction). Each doubling equals a pitch shift of 12 semitones (one octave increase). Zero is not a legal value. Implementations may clamp the actual output pitch range to any values subject to the implementation's own limits.If # does not contain the zero vector ( 0 0 0), the source is directional. The sound emission is presumed to be symmetric around the direction vector (cylinder symmetry). Sources are not oriented in full 3 degrees of freedom, only two angles are effectively needed.The zero vector is the initial value, indicating that a source is not directional. Specifying a non-zero vector will make the source directional. Specifying a zero vector for a directional source will effectively mark it as nondirectional.x contains the inner and outer angles of the sound cone, in degrees. The default of 360 for the inner cone angle means that it covers the entire world, which is equivalent to an omni-directional source. The default of 360 for the outer cone angle means that it covers the entire world. If the inner angle is also 360, then the zone for angle-dependent attenuation is zero. contains the factor with which v is multiplied to determine the effective gain outside the cone defined by the outer angle. The effective gain applied outside the outer cone is v times  . Changing v affects all directions, i.e. the source is attenuated in all directions, for any position of the listener. The application has to change - as well if a different behavior is desired.n contains the playback position, expressed in seconds (the value will loop back to zero for looping sources). When setting  on a source which is already playing, the playback will jump to the new offset unless the new offset is out of range, in which case an NZ error is set. If the source is not playing, then the offset will be applied on the next  call.The position is relative to the beginning of all the queued buffers for the source, and any queued buffers traversed by a set call will be marked as processed.This value is based on byte position, so a pitch-shifted source will have an exaggerated playback speed. For example, you can be 0.5 seconds into a buffer having taken only 0.25 seconds to get there if the pitch is set to 2. contains the playback position, expressed in samples (the value will loop back to zero for looping sources). For a compressed format, this value will represent an exact offset within the uncompressed data. When setting  on a source which is already playing, the playback will jump to the new offset unless the new offset is out of range, in which case an NZ error is set. If the source is not playing, then the offset will be applied on the next  call. A , , or a second ; call will reset the offset to the beginning of the buffer.The position is relative to the beginning of all the queued buffers for the source, and any queued buffers traversed by a set call will be marked as processed. contains the playback position, expressed in bytes (the value will loop back to zero for looping sources). For a compressed format, this value may represent an approximate offset within the compressed data buffer. When setting  on a source which is already playing, the playback will jump to the new offset unless the new offset is out of range, in which case an NZ error is set. If the source is not playing, then the offset will be applied on the next  call. A , , or a second ; call will reset the offset to the beginning of the buffer.The position is relative to the beginning of all the queued buffers for the source, and any queued buffers traversed by a set call will be marked as processed.AThe application can queue up one or multiple buffer names using O. The buffers will be queued in the sequence in which they appear in the list.rThis command is legal on a source in any playback state (to allow for streaming, queuing has to be possible on a E source).All buffers in a queue must have the same format and attributes. An attempt to mix formats or other buffer attributes will result in a failure and an N error will be thrown. If the queue operation fails, the source queue will remain unchanged (even if some of the buffers could have been queued).6Once a queue entry for a buffer has been appended to a queue and is pending processing, it should not be changed. Removal of a given queue entry is not possible unless either the source is stopped (in which case then entire queue is considered processed), or if the queue entry has already been processed (E or D* source). A playing source will enter the C state if it completes playback of the last buffer in its queue (the same behavior as when a single buffer has been attached to a source and has finished playback).The  command removes a number of buffers entries that have finished processing from the queue, returning the buffers that were unqueued. The operation will fail with an Nb error if more buffers are requested than available, leaving the destination arguments unchanged.^Contains the current execution state of the given source. The initial state of any source is F.Note that the F state is not necessarily identical to the initial state in which a source is created, because the other source attributes are not automatically reset to their initial values. F= merely indicates that the source can be executed using the  command. A C or F source can be reset into the default configuration by using a sequence of source commands as necessary. As the application has to specify all relevant state anyway to create a useful source configuration, no reset command is provided. applied to an F# source will promote the source to Eb, thus the data found in the buffer will be fed into the processing, starting at the beginning.  applied to a Ey source will restart the source from the beginning. It will not affect the configuration, and will leave the source in E9 state, but reset the sampling offset to the beginning.  applied to a DK source will resume processing using the source state as preserved at the  operation.  applied to a C source will propagate it to F then to E immediately. applied to an F source is a legal NOP.  applied to a E! source will change its state to DI. The source is exempt from processing, its current state is preserved.  applied to a D source is a legal NOP.  applied to a C source is a legal NOP. applied to an F source is a legal NOP.  applied to a E! source will change its state to CI. The source is exempt from processing, its current state is preserved.  applied to a D" source will change its state to C&, with the same consequences as on a E source.  applied to a C source is a legal NOP. applied to an F source is a legal NOP.  applied to a E! source will change its state to C then F. The source is exempt from processing: its current state is preserved, with the exception of the sampling offset, which is reset to the beginning.  applied to a D! source will change its state to F&, with the same consequences as on a E source.  applied to an C source promotes the source to F2, resetting the sampling offset to the beginning.Sijklmnopqrstuvwxyz{|}~+BCDEFijklmnopqrstuvwxyz{|}~+stuvprqwlonmxikjyz{|}~BFEDCEikjlonmprqstuvwxyz{|}~(c) Sven Panne 2003-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportable Safe-Inferred  OpenAL currently supports six modes of operation with respect to distance attenuation, including one that is similar to the IASIG I3DL2 model. The application chooses one of these models (or chooses to disable distance-dependent attenuation) on a per-context basis.gThe distance used in the formulas for the "clamped" modes below is clamped to be in the range between ~ and :clamped distance = max(~, min(distance, ))The linear models are not physically realistic, but do allow full attenuation of a source beyond a specified distance. The OpenAL implementation is still free to apply any range clamping as necessary.With all the distance models, if the formula can not be evaluated then the source will not be attenuated. For example, if a linear model is being used with ~ equal to y, then the gain equation will have a divide-by-zero error in it. In this case, there is no attenuation for that source.vExponential Distance clamped model, which is the exponential model, extended to guarantee that for distances below ~, gain is clamped.Exponential distance rolloff model, modeling an exponential dropoff in gain as distance increases between the source and listener.gain = (distance / ~) ** (- )lLinear Distance clamped model, which is the linear model, extended to guarantee that for distances below ~, gain is clamped.xLinear distance rolloff model, modeling a linear dropoff in gain as distance increases between the source and listener.gain = (1 -  * (distance - ~) / ( - ~))Inverse Distance clamped model, which is essentially the inverse distance rolloff model, extended to guarantee that for distances below ~P, gain is clamped. This mode is equivalent to the IASIG I3DL2 distance model.hInverse distance rolloff model, which is equivalent to the IASIG I3DL2 model with the exception that ~ does not imply any clamping.gain = ~ / (~ +  * (distance - ~))The ~ parameter used here is a per-source attribute which is the distance at which the listener will experience gain (unless the implementation had to clamp effective gain to the available dynamic range).  is per-source parameter the application can use to increase or decrease the range of a source by decreasing or increasing the attenuation, respectively. The default value is 1. The implementation is free to optimize for a x value of 0, which indicates that the application does not wish any distance attenuation on the respective source.zBypass all distance attenuation calculation for all sources. The implementation is expected to optimize this situation.0Contains the current per-context distance model.  (c) Sven Panne 2003-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportable Safe-Inferred*Contains the list of available extensions.(Contains a version string in the format "<spec major number>./<spec minor number> '<optional vendor version information>/".LTo verify that a given extension is available for the current context, use 9. For invalid and unsupported string tokens it contains . The extension name is not case sensitive: The implementation will convert the name to all upper-case internally (and will express extension names in upper-case).>To retrieving function entry addresses, applications can use . It contains V if no entry point with the given name can be found. Implementations are free to use  if an entry point is present, but not applicable for the current context. However the specification does not guarantee this behavior. Applications can use  to obtain core API entry points, not just extensions. This is the recommended way to dynamically load and unload OpenAL DLLs as sound drivers.ITo obtain enumeration values for extensions, the application has to use  of an extension token. Enumeration values are defined within the OpenAL name space and allocated according to specification of the core API and the extensions, thus they are context-independent.} contains 0 if the enumeration can not be found. The presence of an enum value does not guarantee the applicability of an extension to the current context. A non-zero value indicates merely that the implementation is aware of the existence of this extension. Implementations should not attempt to use 0 to indicate that the extensions is not supported for the current context.AGIGAI(c) Sven Panne 2003-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportable Safe-Inferred is a simple scaling of source and listener velocities to exaggerate or deemphasize the Doppler (pitch) shift resulting from the calculation. Setting ( to a negative value will result in an Nq error, the command is then ignored. The default value is 1. The implementation is free to optimize the case of ; containing zero, as this effectively disables the effect. allows the application to change the reference (propagation) speed used in the Doppler calculation. The source and listener velocities should be expressed in the same units as the speed of sound. Setting / to a negative or zero value will result in an N error, the command is ignored then. The default value is 343.3 (appropriate for velocity units of meters and air as the propagation medium).(c) Sven Panne 2003-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportable Safe-Inferred:  !"#$%&'()*+,-./0123456789:;XYZ[\]^_`a(c) Sven Panne 2003-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportable Safe-Inferrede<=>?@ABCDEFGHIJKLMNOPQRSTUVWbcdefghijklmnopqrstuvwxyz{|}~(c) Sven Panne 2003-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportable Safe-Inferred  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJJKLMNOPQQRSTUVWXYZ[\]^_`abcdef g h i j k l m m nooppq r s t u v w x y z { | } ~                    !"#$%&'()*+,C-./0123456789:;#$<=>?@ABCDEFGHIJKLMNOPQRSeTUVWXYZ[\]^g/_`abcdefghijklmnopqrstuvwxyz{|}~6  Q                                                             #OpenAL-1.6.0.1Sound.OpenAL.ALC.ContextSound.OpenAL.ALC.DeviceSound.OpenAL.ALC.BasicTypesSound.OpenAL.AL.BasicTypesSound.OpenAL.ALC.ExtensionsSound.OpenAL.ALC.ErrorsSound.OpenAL.AL.BufferSound.OpenAL.AL.ExtensionsSound.OpenAL.AL.SourceSound.OpenAL.AL.ErrorsSound.OpenAL.ALC.CaptureSound.OpenAL.AL.StringQueriesSound.OpenAL.AL.ListenerSound.OpenAL.AL.AttenuationSound.OpenAL.AL.DopplerSound.OpenAL.ConfigSound.OpenAL.ALC.StringSound.OpenAL.ConstantsSound.OpenAL.ALC.ALCbooleanSound.OpenAL.ALC.QueryUtilsSound.OpenAL.AL.PeekPokeSound.OpenAL.AL.FormatSound.OpenAL.AL.SourceStateSound.OpenAL.AL.ALbooleanSound.OpenAL.AL.BufferInternalSound.OpenAL.AL.StringSound.OpenAL.AL.QueryUtilsSound.OpenAL.ALCSound.OpenAL.AL Sound.OpenALContextDevice ALCdoubleALCfloatALCenumALCsizeiALCuintALCint ALCushortALCshortALCubyteALCbyteALCchar ALCbooleanALdoubleALfloatALenumALsizeiALuintALintALushortALshortALubyteALbyteALchar ALboolean closeDevicealcIsExtensionPresent openDevicedefaultDeviceSpecifierdeviceSpecifierallDeviceSpecifiers alcExtensionsalcProcAddress alcEnumValue alcVersionALCErrorCategoryALCOutOfMemoryALCInvalidContextALCInvalidDeviceALCInvalidOperationALCInvalidValueALCInvalidEnumALCError alcErrorsContextAttribute StereoSources MonoSourcesSyncRefresh Frequency createContextcurrentContextprocessContextsuspendContextdestroyContextcontextsDevice allAttributesFormatStereo16Stereo8Mono16Mono8unmarshalFormat SourceStateStoppedPausedPlayingInitialunmarshalALbooleanBufferunmarshalBufferALErrorCategory ALOutOfMemory ALInvalidNameALInvalidOperationALInvalidValue ALInvalidEnumALErroralErrors BufferData MemoryRegion bufferData NumSamplescaptureOpenDevice captureStartcaptureNumSamplescaptureSamples captureStopcaptureCloseDevicecaptureDefaultDeviceSpecifiercaptureDeviceSpecifierallCaptureDeviceSpecifiersalVendor alRendererGainlistenerPositionlistenerVelocity listenerGain orientation LoopingModeLoopingOneShot SourceType StreamingStatic UndeterminedSourceRelativeListenerWorldSourcesourcePositionsourceVelocity sourceGainsourceRelative sourceType loopingModebuffer buffersQueuedbuffersProcessed gainBoundsreferenceDistance rolloffFactor maxDistancepitch direction coneAngles coneOuterGain secOffset sampleOffset byteOffset queueBuffersunqueueBuffers sourceStateplaypausestoprewind DistanceModelExponentDistanceClampedExponentDistanceLinearDistanceClampedLinearDistanceInverseDistanceClampedInverseDistance NoAttenuation distanceModel alExtensions alVersionalIsExtensionPresent alProcAddress alEnumValue dopplerFactor speedOfSoundghc-prim GHC.TypesTrueFalse ALCcontext ALCdevicealcDestroyContextalcMakeContextCurrentalcProcessContextalcCloseDevice nullDevice marshalDeviceunmarshalDevice nullContextmarshalContextunmarshalContext withALCString peekALCStringpeekALCStringsal_FALSEal_TRUE al_NO_ERRORal_INVALID_NAMEal_INVALID_ENUMal_INVALID_VALUEal_INVALID_OPERATIONal_OUT_OF_MEMORYal_DISTANCE_MODELal_DOPPLER_FACTORal_SPEED_OF_SOUND al_VERSION al_RENDERER al_VENDOR al_EXTENSIONSal_NONEal_INVERSE_DISTANCEal_INVERSE_DISTANCE_CLAMPEDal_LINEAR_DISTANCEal_LINEAR_DISTANCE_CLAMPEDal_EXPONENT_DISTANCEal_EXPONENT_DISTANCE_CLAMPED al_POSITION al_VELOCITYal_GAINal_ORIENTATIONal_SOURCE_RELATIVEal_SOURCE_TYPE al_LOOPING al_BUFFERal_BUFFERS_QUEUEDal_BUFFERS_PROCESSED al_MIN_GAIN al_MAX_GAINal_REFERENCE_DISTANCEal_ROLLOFF_FACTORal_MAX_DISTANCEal_PITCH al_DIRECTIONal_CONE_INNER_ANGLEal_CONE_OUTER_ANGLEal_CONE_OUTER_GAIN al_SEC_OFFSETal_SAMPLE_OFFSETal_BYTE_OFFSETal_SOURCE_STATEal_UNDETERMINED al_STATIC al_STREAMING al_INITIAL al_PLAYING al_PAUSED al_STOPPED al_FREQUENCYal_SIZEal_BITS al_CHANNELSal_FORMAT_MONO8al_FORMAT_MONO16al_FORMAT_STEREO8al_FORMAT_STEREO16 alc_FALSEalc_TRUE alc_FREQUENCY alc_REFRESHalc_SYNCalc_MONO_SOURCESalc_STEREO_SOURCES alc_NO_ERRORalc_INVALID_DEVICEalc_INVALID_CONTEXTalc_INVALID_ENUMalc_INVALID_VALUEalc_INVALID_OPERATIONalc_OUT_OF_MEMORYalc_DEFAULT_DEVICE_SPECIFIERalc_DEVICE_SPECIFIERalc_EXTENSIONS$alc_CAPTURE_DEFAULT_DEVICE_SPECIFIERalc_CAPTURE_DEVICE_SPECIFIERalc_ATTRIBUTES_SIZEalc_ALL_ATTRIBUTESalc_MAJOR_VERSIONalc_MINOR_VERSIONalc_CAPTURE_SAMPLESmarshalALCbooleanunmarshalALCbooleanbase Data.MaybeNothingIntQueryCaptureSamples MinorVersion MajorVersion AllAttributesAttributesSize StringQueryCaptureDeviceSpecifierCaptureDefaultDeviceSpecifier ExtensionsDeviceSpecifierDefaultDeviceSpecifieralcIsExtensionPresent_alcGetIntegerv alcGetStringmarshalStringQuery getString getStringRawmarshalMaybeDevicemarshalIntQuery getInteger getIntegervJust alcOpenDevicealcGetEnumValuealcGetProcAddressmakeVersionString alcGetErrorunmarshalALCErrorCategoryalcGetContextsDevicealcSuspendContextalcGetCurrentContextalcCreateContextmarshalContextAttributeunmarshalContextAttributegetCurrentContextmakeContextCurrenttoContextAttributespoke1peek1peek3peek6 marshalFormatunmarshalSourceStatemarshalALboolean nullBufferbufferID alIsBufferalDeleteBuffers alGenBuffers marshalBuffer$fGeneratableObjectNameBuffer$fObjectNameBuffer$fStorableBuffer withALString peekALString StringNameVersionRendererVendorGetPNameGetSourceState GetByteOffsetGetSampleOffset GetSecOffsetGetConeOuterGainGetConeOuterAngleGetConeInnerAngle GetDirectionGetPitchGetMaxDistanceGetRolloffFactorGetReferenceDistance GetMaxGain GetMinGainGetBuffersProcessedGetBuffersQueued GetBuffer GetLooping GetSourceTypeGetSourceRelativeGetOrientationGetGain GetVelocity GetPositionGetSpeedOfSoundGetDopplerFactorGetDistanceModel alGetStringmarshalGetPNamemarshalStringName alGetErrorunmarshalALErrorCategory BufferQueryChannelsBitsSize alGetBufferi alBufferData getBufferData setBufferData makeFormatmarshalBufferQuery getBufferiInvokerinvokeCaptureCloseDeviceinvokeCaptureSamplesinvokeCaptureStartStopinvokeCaptureOpenDevicegetCaptureFunccaptureStartStopOpenGL-2.9.2.0#Graphics.Rendering.OpenGL.GL.TensorVertex3Vector3alGetListenerfv alListenerfv alListenerf listenerf listener3flistenerVector6 listenerfv getListenerfvmakeListenerVar DictionaryalGetteralSettersizepeekSizemarshalalSourceRewindv alSourceStopvalSourcePausev alSourcePlayvalSourceUnqueueBuffersalSourceQueueBuffers alSourcei alGetSourceiv alSourcefv alGetSourcefv alIsSourcealDeleteSources alGenSourcesmarshalSourceRelativeunmarshalSourceRelativeunmarshalSourceTypemarshalLoopingModeunmarshalLoopingMode pairStateVars dictALint dictALfloatdictSourceRelativedictSourceTypedictLoopingModedictSourceStatedictVertex3ALfloatdictVector3ALfloatdictMaybeBuffer makeGetter makeSettermakeSourceStateVarmakeSourceGettableStateVar alSourceivwithArraySizei$fGeneratableObjectNameSource$fObjectNameSource$fStorableSourcealDistanceModel alGetIntegervmarshalDistanceModelunmarshalDistanceModelGHC.Ptr nullFunPtralGetEnumValuealGetProcAddressalIsExtensionPresent_invokeWithFloat alGetFloatmakeDopplerVar'Graphics.Rendering.OpenGL.GL.ObjectNamedeleteObjectNamesdeleteObjectName isObjectName ObjectNamegenObjectNames genObjectNameGeneratableObjectName%Graphics.Rendering.OpenGL.GL.StateVar$~!$=!$~ makeStateVarmakeSettableStateVarmakeGettableStateVarget HasGetterGettableStateVar$= HasSetterSettableStateVarStateVar