emsdk/upstream/emscripten/src/lib/libopenal.js

/**
 * @license
 * Copyright 2013 The Emscripten Authors
 * SPDX-License-Identifier: MIT
 */

//'use strict';

var LibraryOpenAL = {
  // ************************************************************************
  // ** INTERNALS
  // ************************************************************************

  $AL__deps: ['$MainLoop'],
  $AL: {
    // ------------------------------------------------------
    // -- Constants
    // ------------------------------------------------------

    QUEUE_INTERVAL: 25,
    QUEUE_LOOKAHEAD: 100.0 / 1000.0,

    DEVICE_NAME: 'Emscripten OpenAL',
    CAPTURE_DEVICE_NAME: 'Emscripten OpenAL capture',

    ALC_EXTENSIONS: {
      // TODO: 'ALC_EXT_EFX': true,
      'ALC_EXT_capture': true,
      'ALC_SOFT_pause_device': true,
      'ALC_SOFT_HRTF': true
    },
    AL_EXTENSIONS: {
      'AL_EXT_float32': true,
      'AL_SOFT_loop_points': true,
      'AL_SOFT_source_length': true,
      'AL_EXT_source_distance_model': true,
      'AL_SOFT_source_spatialize': true
    },

    // ------------------------------------------------------
    // -- ALC Fields
    // ------------------------------------------------------

    _alcErr: 0,
    get alcErr() {
      return this._alcErr;
    },
    set alcErr(val) {
      // Errors should not be overwritten by later errors until they are cleared by a query.
      if (this._alcErr === {{{ cDefs.ALC_NO_ERROR }}} || val === {{{ cDefs.ALC_NO_ERROR }}}) {
        this._alcErr = val;
      }
    },

    deviceRefCounts: {},
    alcStringCache: {},
    paused: false,

    // ------------------------------------------------------
    // -- AL Fields
    // ------------------------------------------------------

    stringCache: {},
    contexts: {},
    currentCtx: null,
    buffers: {
      // The zero buffer is legal to use, so create a placeholder for it
      '0': {
        id: 0,
        refCount: 0,
        audioBuf: null,
        frequency: 0,
        bytesPerSample: 2,
        channels: 1,
        length: 0
      }
    },
    paramArray: [], // Used to prevent allocating a new array for each param call

    _nextId: 1,
    newId: () => AL.freeIds.length > 0 ? AL.freeIds.pop() : AL._nextId++,
    freeIds: [],

    // ------------------------------------------------------
    // -- Mixing Logic
    // ------------------------------------------------------

    scheduleContextAudio: (ctx) => {
      // If we are animating using the requestAnimationFrame method, then the main loop does not run when in the background.
      // To give a perfect glitch-free audio stop when switching from foreground to background, we need to avoid updating
      // audio altogether when in the background, so detect that case and kill audio buffer streaming if so.
      if (MainLoop.timingMode === {{{ cDefs.EM_TIMING_RAF }}} && document['visibilityState'] != 'visible') {
        return;
      }

      for (var i in ctx.sources) {
        AL.scheduleSourceAudio(ctx.sources[i]);
      }
    },

    // This function is the core scheduler that queues web-audio buffers for output.
    // src.bufQueue represents the abstract OpenAL buffer queue, which is traversed to schedule
    // corresponding web-audio buffers. These buffers are stored in src.audioQueue, which
    // represents the queue of buffers scheduled for physical playback. These two queues are
    // distinct because of the differing semantics of OpenAL and web audio. Some changes
    // to OpenAL parameters, such as pitch, may require the web audio queue to be flushed and rescheduled.
    scheduleSourceAudio: (src, lookahead) => {
      // See comment on scheduleContextAudio above.
      if (MainLoop.timingMode === {{{ cDefs.EM_TIMING_RAF }}} && document['visibilityState'] != 'visible') {
        return;
      }
      if (src.state !== {{{ cDefs.AL_PLAYING }}}) {
        return;
      }

      var currentTime = AL.updateSourceTime(src);

      var startTime = src.bufStartTime;
      var startOffset = src.bufOffset;
      var bufCursor = src.bufsProcessed;

      // Advance past any audio that is already scheduled
      for (var i = 0; i < src.audioQueue.length; i++) {
        var audioSrc = src.audioQueue[i];
        startTime = audioSrc._startTime + audioSrc._duration;
        startOffset = 0.0;
        bufCursor += audioSrc._skipCount + 1;
      }

      if (!lookahead) {
        lookahead = AL.QUEUE_LOOKAHEAD;
      }
      var lookaheadTime = currentTime + lookahead;
      var skipCount = 0;
      while (startTime < lookaheadTime) {
        if (bufCursor >= src.bufQueue.length) {
          if (src.looping) {
            bufCursor %= src.bufQueue.length;
          } else {
            break;
          }
        }

        var buf = src.bufQueue[bufCursor % src.bufQueue.length];
        // If the buffer contains no data, skip it
        if (buf.length === 0) {
          skipCount++;
          // If we've gone through the whole queue and everything is 0 length, just give up
          if (skipCount === src.bufQueue.length) {
            break;
          }
        } else {
          var audioSrc = src.context.audioCtx.createBufferSource();
          audioSrc.buffer = buf.audioBuf;
          audioSrc.playbackRate.value = src.playbackRate;
          if (buf.audioBuf._loopStart || buf.audioBuf._loopEnd) {
            audioSrc.loopStart = buf.audioBuf._loopStart;
            audioSrc.loopEnd = buf.audioBuf._loopEnd;
          }

          var duration = 0.0;
          // If the source is a looping static buffer, use native looping for gapless playback
          if (src.type === {{{ cDefs.AL_STATIC }}} && src.looping) {
            duration = Number.POSITIVE_INFINITY;
            audioSrc.loop = true;
            if (buf.audioBuf._loopStart) {
              audioSrc.loopStart = buf.audioBuf._loopStart;
            }
            if (buf.audioBuf._loopEnd) {
              audioSrc.loopEnd = buf.audioBuf._loopEnd;
            }
          } else {
            duration = (buf.audioBuf.duration - startOffset) / src.playbackRate;
          }

          audioSrc._startOffset = startOffset;
          audioSrc._duration = duration;
          audioSrc._skipCount = skipCount;
          skipCount = 0;

          audioSrc.connect(src.gain);

          if (typeof audioSrc.start != 'undefined') {
            // Sample the current time as late as possible to mitigate drift
            startTime = Math.max(startTime, src.context.audioCtx.currentTime);
            audioSrc.start(startTime, startOffset);
          } else if (typeof audioSrc.noteOn != 'undefined') {
            startTime = Math.max(startTime, src.context.audioCtx.currentTime);
            audioSrc.noteOn(startTime);
#if OPENAL_DEBUG
            if (offset > 0.0) {
              warnOnce('The current browser does not support AudioBufferSourceNode.start(when, offset); method, so cannot play back audio with an offset '+startOffset+' secs! Audio glitches will occur!');
            }
#endif
          }
#if OPENAL_DEBUG
          else {
            warnOnce('Unable to start AudioBufferSourceNode playback! Not supported by the browser?');
          }

          dbg(`scheduleSourceAudio() queuing buffer ${buf.id} for source ${src.id} at ${startTime} (offset by ${startOffset})`);
#endif
          audioSrc._startTime = startTime;
          src.audioQueue.push(audioSrc);

          startTime += duration;
        }

        startOffset = 0.0;
        bufCursor++;
      }
    },

    // Advance the state of a source forward to the current time
    updateSourceTime: (src) => {
      var currentTime = src.context.audioCtx.currentTime;
      if (src.state !== {{{ cDefs.AL_PLAYING }}}) {
        return currentTime;
      }

      // if the start time is unset, determine it based on the current offset.
      // This will be the case when a source is resumed after being paused, and
      // allows us to pretend that the source actually started playing some time
      // in the past such that it would just now have reached the stored offset.
      if (!isFinite(src.bufStartTime)) {
        src.bufStartTime = currentTime - src.bufOffset / src.playbackRate;
        src.bufOffset = 0.0;
      }

      var nextStartTime = 0.0;
      while (src.audioQueue.length) {
        var audioSrc = src.audioQueue[0];
        src.bufsProcessed += audioSrc._skipCount;
        nextStartTime = audioSrc._startTime + audioSrc._duration; // n.b. audioSrc._duration already factors in playbackRate, so no divide by src.playbackRate on it.

        if (currentTime < nextStartTime) {
          break;
        }

        src.audioQueue.shift();
        src.bufStartTime = nextStartTime;
        src.bufOffset = 0.0;
        src.bufsProcessed++;
      }

      if (src.bufsProcessed >= src.bufQueue.length && !src.looping) {
        // The source has played its entire queue and is non-looping, so just mark it as stopped.
        AL.setSourceState(src, {{{ cDefs.AL_STOPPED }}});
      } else if (src.type === {{{ cDefs.AL_STATIC }}} && src.looping) {
        // If the source is a looping static buffer, determine the buffer offset based on the loop points
        var buf = src.bufQueue[0];
        if (buf.length === 0) {
          src.bufOffset = 0.0;
        } else {
          var delta = (currentTime - src.bufStartTime) * src.playbackRate;
          var loopStart = buf.audioBuf._loopStart || 0.0;
          var loopEnd = buf.audioBuf._loopEnd || buf.audioBuf.duration;
          if (loopEnd <= loopStart) {
            loopEnd = buf.audioBuf.duration;
          }

          if (delta < loopEnd) {
            src.bufOffset = delta;
          } else {
            src.bufOffset = loopStart + (delta - loopStart) % (loopEnd - loopStart);
          }
        }
      } else if (src.audioQueue[0]) {
        // The source is still actively playing, so we just need to calculate where we are in the current buffer
        // so it can be remembered if the source gets paused.
        src.bufOffset = (currentTime - src.audioQueue[0]._startTime) * src.playbackRate;
      } else {
        // The source hasn't finished yet, but there is no scheduled audio left for it. This can be because
        // the source has just been started/resumed, or due to an underrun caused by a long blocking operation.
        // We need to determine what state we would be in by this point in time so that when we next schedule
        // audio playback, it will be just as if no underrun occurred.

        if (src.type !== {{{ cDefs.AL_STATIC }}} && src.looping) {
          // if the source is a looping buffer queue, let's first calculate the queue duration, so we can
          // quickly fast forward past any full loops of the queue and only worry about the remainder.
          var srcDuration = AL.sourceDuration(src) / src.playbackRate;
          if (srcDuration > 0.0) {
            src.bufStartTime += Math.floor((currentTime - src.bufStartTime) / srcDuration) * srcDuration;
          }
        }

        // Since we've already skipped any full-queue loops if there were any, we just need to find
        // out where in the queue the remaining time puts us, which won't require stepping through the
        // entire queue more than once.
        for (var i = 0; i < src.bufQueue.length; i++) {
          if (src.bufsProcessed >= src.bufQueue.length) {
            if (src.looping) {
              src.bufsProcessed %= src.bufQueue.length;
            } else {
              AL.setSourceState(src, {{{ cDefs.AL_STOPPED }}});
              break;
            }
          }

          var buf = src.bufQueue[src.bufsProcessed];
          if (buf.length > 0) {
            nextStartTime = src.bufStartTime + buf.audioBuf.duration / src.playbackRate;

            if (currentTime < nextStartTime) {
              src.bufOffset = (currentTime - src.bufStartTime) * src.playbackRate;
              break;
            }

            src.bufStartTime = nextStartTime;
          }

          src.bufOffset = 0.0;
          src.bufsProcessed++;
        }
      }

      return currentTime;
    },

    cancelPendingSourceAudio: (src) => {
      AL.updateSourceTime(src);

      for (var i = 1; i < src.audioQueue.length; i++) {
        var audioSrc = src.audioQueue[i];
        audioSrc.stop();
      }

      if (src.audioQueue.length > 1) {
        src.audioQueue.length = 1;
      }
    },

    stopSourceAudio: (src) => {
      for (var i = 0; i < src.audioQueue.length; i++) {
        src.audioQueue[i].stop();
      }
      src.audioQueue.length = 0;
    },

    setSourceState: (src, state) => {
      if (state === {{{ cDefs.AL_PLAYING }}}) {
        if (src.state === {{{ cDefs.AL_PLAYING }}} || src.state == {{{ cDefs.AL_STOPPED }}}) {
          src.bufsProcessed = 0;
          src.bufOffset = 0.0;
#if OPENAL_DEBUG
          dbg(`setSourceState() resetting and playing source ${src.id}`);
#endif
        } else {
#if OPENAL_DEBUG
          dbg(`setSourceState() playing source ${src.id} at ${src.bufOffset}`);
#endif
        }

        AL.stopSourceAudio(src);

        src.state = {{{ cDefs.AL_PLAYING }}};
        src.bufStartTime = Number.NEGATIVE_INFINITY;
        AL.scheduleSourceAudio(src);
      } else if (state === {{{ cDefs.AL_PAUSED }}}) {
        if (src.state === {{{ cDefs.AL_PLAYING }}}) {
          // Store off the current offset to restore with on resume.
          AL.updateSourceTime(src);
          AL.stopSourceAudio(src);

          src.state = {{{ cDefs.AL_PAUSED }}};
#if OPENAL_DEBUG
          dbg(`setSourceState() pausing source ${src.id} at ${src.bufOffset}`);
#endif
        }
      } else if (state === {{{ cDefs.AL_STOPPED }}}) {
        if (src.state !== {{{ cDefs.AL_INITIAL }}}) {
          src.state = {{{ cDefs.AL_STOPPED }}};
          src.bufsProcessed = src.bufQueue.length;
          src.bufStartTime = Number.NEGATIVE_INFINITY;
          src.bufOffset = 0.0;
          AL.stopSourceAudio(src);
#if OPENAL_DEBUG
          dbg(`setSourceState() stopping source ${src.id}`);
#endif
        }
      } else if (state === {{{ cDefs.AL_INITIAL }}}) {
        if (src.state !== {{{ cDefs.AL_INITIAL }}}) {
          src.state = {{{ cDefs.AL_INITIAL }}};
          src.bufsProcessed = 0;
          src.bufStartTime = Number.NEGATIVE_INFINITY;
          src.bufOffset = 0.0;
          AL.stopSourceAudio(src);
#if OPENAL_DEBUG
          dbg(`setSourceState() initializing source ${src.id}`);
#endif
        }
      }
    },

    initSourcePanner: (src) => {
      if (src.type === 0x1030 /* AL_UNDETERMINED */) {
        return;
      }

      // Find the first non-zero buffer in the queue to determine the proper format
      var templateBuf = AL.buffers[0];
      for (var i = 0; i < src.bufQueue.length; i++) {
        if (src.bufQueue[i].id !== 0) {
          templateBuf = src.bufQueue[i];
          break;
        }
      }
      // Create a panner if AL_SOURCE_SPATIALIZE_SOFT is set to true, or alternatively if it's set to auto and the source is mono
      if (src.spatialize === {{{ cDefs.AL_TRUE }}} || (src.spatialize === 2 /* AL_AUTO_SOFT */ && templateBuf.channels === 1)) {
        if (src.panner) {
          return;
        }
        src.panner = src.context.audioCtx.createPanner();

        AL.updateSourceGlobal(src);
        AL.updateSourceSpace(src);

        src.panner.connect(src.context.gain);
        src.gain.disconnect();
        src.gain.connect(src.panner);
      } else {
        if (!src.panner) {
          return;
        }

        src.panner.disconnect();
        src.gain.disconnect();
        src.gain.connect(src.context.gain);
        src.panner = null;
      }
    },

    updateContextGlobal: (ctx) => {
      for (var i in ctx.sources) {
        AL.updateSourceGlobal(ctx.sources[i]);
      }
    },

    updateSourceGlobal: (src) => {
      var panner = src.panner;
      if (!panner) {
        return;
      }

      panner.refDistance = src.refDistance;
      panner.maxDistance = src.maxDistance;
      panner.rolloffFactor = src.rolloffFactor;

      panner.panningModel = src.context.hrtf ? 'HRTF' : 'equalpower';

      // Use the source's distance model if AL_SOURCE_DISTANCE_MODEL is enabled
      var distanceModel = src.context.sourceDistanceModel ? src.distanceModel : src.context.distanceModel;
      switch (distanceModel) {
      case {{{ cDefs.AL_NONE }}}:
        panner.distanceModel = 'inverse';
        panner.refDistance = 3.40282e38 /* FLT_MAX */;
        break;
      case 0xd001 /* AL_INVERSE_DISTANCE */:
      case 0xd002 /* AL_INVERSE_DISTANCE_CLAMPED */:
        panner.distanceModel = 'inverse';
        break;
      case 0xd003 /* AL_LINEAR_DISTANCE */:
      case 0xd004 /* AL_LINEAR_DISTANCE_CLAMPED */:
        panner.distanceModel = 'linear';
        break;
      case 0xd005 /* AL_EXPONENT_DISTANCE */:
      case 0xd006 /* AL_EXPONENT_DISTANCE_CLAMPED */:
        panner.distanceModel = 'exponential';
        break;
      }
    },

    updateListenerSpace: (ctx) => {
      var listener = ctx.audioCtx.listener;
      if (listener.positionX) {
        listener.positionX.value = ctx.listener.position[0];
        listener.positionY.value = ctx.listener.position[1];
        listener.positionZ.value = ctx.listener.position[2];
      } else {
#if OPENAL_DEBUG
        warnOnce('Listener position attributes are not present, falling back to setPosition()');
#endif
        listener.setPosition(ctx.listener.position[0], ctx.listener.position[1], ctx.listener.position[2]);
      }
      if (listener.forwardX) {
        listener.forwardX.value = ctx.listener.direction[0];
        listener.forwardY.value = ctx.listener.direction[1];
        listener.forwardZ.value = ctx.listener.direction[2];
        listener.upX.value = ctx.listener.up[0];
        listener.upY.value = ctx.listener.up[1];
        listener.upZ.value = ctx.listener.up[2];
      } else {
#if OPENAL_DEBUG
        warnOnce('Listener orientation attributes are not present, falling back to setOrientation()');
#endif
        listener.setOrientation(
          ctx.listener.direction[0], ctx.listener.direction[1], ctx.listener.direction[2],
          ctx.listener.up[0], ctx.listener.up[1], ctx.listener.up[2]);
      }

      // Update sources that are relative to the listener
      for (var i in ctx.sources) {
        AL.updateSourceSpace(ctx.sources[i]);
      }
    },

    updateSourceSpace: (src) => {
      if (!src.panner) {
        return;
      }
      var panner = src.panner;

      var posX = src.position[0];
      var posY = src.position[1];
      var posZ = src.position[2];
      var dirX = src.direction[0];
      var dirY = src.direction[1];
      var dirZ = src.direction[2];

      var listener = src.context.listener;
      var lPosX = listener.position[0];
      var lPosY = listener.position[1];
      var lPosZ = listener.position[2];

      // WebAudio does spatialization in world-space coordinates, meaning both the buffer sources and
      // the listener position are in the same absolute coordinate system relative to a fixed origin.
      // By default, OpenAL works this way as well, but it also provides a "listener relative" mode, where
      // a buffer source's coordinates are interpreted not in absolute world space, but as being relative
      // to the listener object itself, so as the listener moves the source appears to move with it
      // with no update required. Since web audio does not support this mode, we must transform the source
      // coordinates from listener-relative space to absolute world space.
      //
      // We do this via affine transformation matrices applied to the source position and source direction.
      // A change-of-basis converts from listener-space displacements to world-space displacements,
      // which must be done for both the source position and direction. Lastly, the source position must be
      // added to the listener position to get the final source position, since the source position represents
      // a displacement from the listener.
      if (src.relative) {
        // Negate the listener direction since forward is -Z.
        var lBackX = -listener.direction[0];
        var lBackY = -listener.direction[1];
        var lBackZ = -listener.direction[2];
        var lUpX = listener.up[0];
        var lUpY = listener.up[1];
        var lUpZ = listener.up[2];

        var inverseMagnitude = (x, y, z) => {
          var length = Math.sqrt(x * x + y * y + z * z);

          if (length < Number.EPSILON) {
            return 0.0;
          }

          return 1.0 / length;
        };

        // Normalize the Back vector
        var invMag = inverseMagnitude(lBackX, lBackY, lBackZ);
        lBackX *= invMag;
        lBackY *= invMag;
        lBackZ *= invMag;

        // ...and the Up vector
        invMag = inverseMagnitude(lUpX, lUpY, lUpZ);
        lUpX *= invMag;
        lUpY *= invMag;
        lUpZ *= invMag;

        // Calculate the Right vector as the cross product of the Up and Back vectors
        var lRightX = (lUpY * lBackZ - lUpZ * lBackY);
        var lRightY = (lUpZ * lBackX - lUpX * lBackZ);
        var lRightZ = (lUpX * lBackY - lUpY * lBackX);

        // Back and Up might not be exactly perpendicular, so the cross product also needs normalization
        invMag = inverseMagnitude(lRightX, lRightY, lRightZ);
        lRightX *= invMag;
        lRightY *= invMag;
        lRightZ *= invMag;

        // Recompute Up from the now orthonormal Right and Back vectors so we have a fully orthonormal basis
        lUpX = (lBackY * lRightZ - lBackZ * lRightY);
        lUpY = (lBackZ * lRightX - lBackX * lRightZ);
        lUpZ = (lBackX * lRightY - lBackY * lRightX);

        var oldX = dirX;
        var oldY = dirY;
        var oldZ = dirZ;

        // Use our 3 vectors to apply a change-of-basis matrix to the source direction
        dirX = oldX * lRightX + oldY * lUpX + oldZ * lBackX;
        dirY = oldX * lRightY + oldY * lUpY + oldZ * lBackY;
        dirZ = oldX * lRightZ + oldY * lUpZ + oldZ * lBackZ;

        oldX = posX;
        oldY = posY;
        oldZ = posZ;

        // ...and to the source position
        posX = oldX * lRightX + oldY * lUpX + oldZ * lBackX;
        posY = oldX * lRightY + oldY * lUpY + oldZ * lBackY;
        posZ = oldX * lRightZ + oldY * lUpZ + oldZ * lBackZ;

        // The change-of-basis corrects the orientation, but the origin is still the listener.
        // Translate the source position by the listener position to finish.
        posX += lPosX;
        posY += lPosY;
        posZ += lPosZ;
      }

      if (panner.positionX) {
        // Assigning to panner.positionX/Y/Z unnecessarily seems to cause performance issues
        // See https://github.com/emscripten-core/emscripten/issues/15847

        if (posX != panner.positionX.value) panner.positionX.value = posX;
        if (posY != panner.positionY.value) panner.positionY.value = posY;
        if (posZ != panner.positionZ.value) panner.positionZ.value = posZ;
      } else {
#if OPENAL_DEBUG
        warnOnce('Panner position attributes are not present, falling back to setPosition()');
#endif
        panner.setPosition(posX, posY, posZ);
      }
      if (panner.orientationX) {
        // Assigning to panner.orientation/Y/Z unnecessarily seems to cause performance issues
        // See https://github.com/emscripten-core/emscripten/issues/15847

        if (dirX != panner.orientationX.value) panner.orientationX.value = dirX;
        if (dirY != panner.orientationY.value) panner.orientationY.value = dirY;
        if (dirZ != panner.orientationZ.value) panner.orientationZ.value = dirZ;
      } else {
#if OPENAL_DEBUG
        warnOnce('Panner orientation attributes are not present, falling back to setOrientation()');
#endif
        panner.setOrientation(dirX, dirY, dirZ);
      }

      var oldShift = src.dopplerShift;
      var velX = src.velocity[0];
      var velY = src.velocity[1];
      var velZ = src.velocity[2];
      var lVelX = listener.velocity[0];
      var lVelY = listener.velocity[1];
      var lVelZ = listener.velocity[2];
      if (posX === lPosX && posY === lPosY && posZ === lPosZ
        || velX === lVelX && velY === lVelY && velZ === lVelZ)
      {
        src.dopplerShift = 1.0;
      } else {
        // Doppler algorithm from 1.1 spec
        var speedOfSound = src.context.speedOfSound;
        var dopplerFactor = src.context.dopplerFactor;

        var slX = lPosX - posX;
        var slY = lPosY - posY;
        var slZ = lPosZ - posZ;

        var magSl = Math.sqrt(slX * slX + slY * slY + slZ * slZ);
        var vls = (slX * lVelX + slY * lVelY + slZ * lVelZ) / magSl;
        var vss = (slX * velX + slY * velY + slZ * velZ) / magSl;

        vls = Math.min(vls, speedOfSound / dopplerFactor);
        vss = Math.min(vss, speedOfSound / dopplerFactor);

        src.dopplerShift = (speedOfSound - dopplerFactor * vls) / (speedOfSound - dopplerFactor * vss);
      }
      if (src.dopplerShift !== oldShift) {
        AL.updateSourceRate(src);
      }
    },

    updateSourceRate: (src) => {
      if (src.state === {{{ cDefs.AL_PLAYING }}}) {
        // clear scheduled buffers
        AL.cancelPendingSourceAudio(src);

        var audioSrc = src.audioQueue[0];
        if (!audioSrc) {
          return; // It is possible that AL.scheduleContextAudio() has not yet fed the next buffer, if so, skip.
        }

        var duration;
        if (src.type === {{{ cDefs.AL_STATIC }}} && src.looping) {
          duration = Number.POSITIVE_INFINITY;
        } else {
          // audioSrc._duration is expressed after factoring in playbackRate, so when changing playback rate, need
          // to recompute/rescale the rate to the new playback speed.
          duration = (audioSrc.buffer.duration - audioSrc._startOffset) / src.playbackRate;
        }

        audioSrc._duration = duration;
        audioSrc.playbackRate.value = src.playbackRate;

        // reschedule buffers with the new playbackRate
        AL.scheduleSourceAudio(src);
      }
    },

    sourceDuration: (src) => {
      var length = 0.0;
      for (var i = 0; i < src.bufQueue.length; i++) {
        var audioBuf = src.bufQueue[i].audioBuf;
        length += audioBuf ? audioBuf.duration : 0.0;
      }
      return length;
    },

    sourceTell: (src) => {
      AL.updateSourceTime(src);

      var offset = 0.0;
      for (var i = 0; i < src.bufsProcessed; i++) {
        if (src.bufQueue[i].audioBuf) {
          offset += src.bufQueue[i].audioBuf.duration;
        }
      }
      offset += src.bufOffset;

      return offset;
    },

    sourceSeek: (src, offset) => {
      var playing = src.state == {{{ cDefs.AL_PLAYING }}};
      if (playing) {
        AL.setSourceState(src, {{{ cDefs.AL_INITIAL }}});
      }

      if (src.bufQueue[src.bufsProcessed].audioBuf !== null) {
        src.bufsProcessed = 0;
        while (offset > src.bufQueue[src.bufsProcessed].audioBuf.duration) {
          offset -= src.bufQueue[src.bufsProcessed].audioBuf.duration;
          src.bufsProcessed++;
        }

        src.bufOffset = offset;
      }

      if (playing) {
        AL.setSourceState(src, {{{ cDefs.AL_PLAYING }}});
      }
    },

    // ------------------------------------------------------
    // -- Accessor Helpers
    // ------------------------------------------------------

    getGlobalParam: (funcname, param) => {
      if (!AL.currentCtx) {
#if OPENAL_DEBUG
        dbg(`${funcname}() called without a valid context`);
#endif
        return null;
      }

      switch (param) {
      case {{{ cDefs.AL_DOPPLER_FACTOR }}}:
        return AL.currentCtx.dopplerFactor;
      case {{{ cDefs.AL_SPEED_OF_SOUND }}}:
        return AL.currentCtx.speedOfSound;
      case {{{ cDefs.AL_DISTANCE_MODEL }}}:
        return AL.currentCtx.distanceModel;
      default:
#if OPENAL_DEBUG
        dbg(`${funcname}() param ${ptrToString(param)} is unknown or not implemented`);
#endif
        AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
        return null;
      }
    },

    setGlobalParam: (funcname, param, value) => {
      if (!AL.currentCtx) {
#if OPENAL_DEBUG
        dbg(`${funcname}() called without a valid context`);
#endif
        return;
      }

      switch (param) {
      case {{{ cDefs.AL_DOPPLER_FACTOR }}}:
        if (!Number.isFinite(value) || value < 0.0) { // Strictly negative values are disallowed
#if OPENAL_DEBUG
          dbg(`${funcname}() value ${value} is out of range`);
#endif
          AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
          return;
        }

        AL.currentCtx.dopplerFactor = value;
        AL.updateListenerSpace(AL.currentCtx);
        break;
      case {{{ cDefs.AL_SPEED_OF_SOUND }}}:
        if (!Number.isFinite(value) || value <= 0.0) { // Negative or zero values are disallowed
#if OPENAL_DEBUG
          dbg(`${funcname}() value ${value} is out of range`);
#endif
          AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
          return;
        }

        AL.currentCtx.speedOfSound = value;
        AL.updateListenerSpace(AL.currentCtx);
        break;
      case {{{ cDefs.AL_DISTANCE_MODEL }}}:
        switch (value) {
        case {{{ cDefs.AL_NONE }}}:
        case 0xd001 /* AL_INVERSE_DISTANCE */:
        case 0xd002 /* AL_INVERSE_DISTANCE_CLAMPED */:
        case 0xd003 /* AL_LINEAR_DISTANCE */:
        case 0xd004 /* AL_LINEAR_DISTANCE_CLAMPED */:
        case 0xd005 /* AL_EXPONENT_DISTANCE */:
        case 0xd006 /* AL_EXPONENT_DISTANCE_CLAMPED */:
          AL.currentCtx.distanceModel = value;
          AL.updateContextGlobal(AL.currentCtx);
          break;
        default:
#if OPENAL_DEBUG
          dbg(`${funcname}() value ${value} is out of range`);
#endif
          AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
          return;
        }
        break;
      default:
#if OPENAL_DEBUG
        dbg(`${funcname}() param ${ptrToString(param)} is unknown or not implemented`);
#endif
        AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
        return;
      }
    },

    getListenerParam: (funcname, param) => {
      if (!AL.currentCtx) {
#if OPENAL_DEBUG
        dbg(`${funcname}() called without a valid context`);
#endif
        return null;
      }

      switch (param) {
      case {{{ cDefs.AL_POSITION }}}:
        return AL.currentCtx.listener.position;
      case {{{ cDefs.AL_VELOCITY }}}:
        return AL.currentCtx.listener.velocity;
      case {{{ cDefs.AL_ORIENTATION }}}:
        return AL.currentCtx.listener.direction.concat(AL.currentCtx.listener.up);
      case {{{ cDefs.AL_GAIN }}}:
        return AL.currentCtx.gain.gain.value;
      default:
#if OPENAL_DEBUG
        dbg(`${funcname}() param ${ptrToString(param)} is unknown or not implemented`);
#endif
        AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
        return null;
      }
    },

    setListenerParam: (funcname, param, value) => {
      if (!AL.currentCtx) {
#if OPENAL_DEBUG
        dbg(`${funcname}() called without a valid context`);
#endif
        return;
      }
      if (value === null) {
#if OPENAL_DEBUG
        dbg(`${funcname}(): param ${ptrToString(param)} has wrong signature`);
#endif
        AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
        return;
      }

      var listener = AL.currentCtx.listener;
      switch (param) {
      case {{{ cDefs.AL_POSITION }}}:
        if (!Number.isFinite(value[0]) || !Number.isFinite(value[1]) || !Number.isFinite(value[2])) {
#if OPENAL_DEBUG
          dbg(`${funcname}() param AL_POSITION value ${value} is out of range`);
#endif
          AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
          return;
        }

        listener.position[0] = value[0];
        listener.position[1] = value[1];
        listener.position[2] = value[2];
        AL.updateListenerSpace(AL.currentCtx);
        break;
      case {{{ cDefs.AL_VELOCITY }}}:
        if (!Number.isFinite(value[0]) || !Number.isFinite(value[1]) || !Number.isFinite(value[2])) {
#if OPENAL_DEBUG
          dbg(`${funcname}() param AL_VELOCITY value ${value} is out of range`);
#endif
          AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
          return;
        }

        listener.velocity[0] = value[0];
        listener.velocity[1] = value[1];
        listener.velocity[2] = value[2];
        AL.updateListenerSpace(AL.currentCtx);
        break;
      case {{{ cDefs.AL_GAIN }}}:
        if (!Number.isFinite(value) || value < 0.0) {
#if OPENAL_DEBUG
          dbg(`${funcname}() param AL_GAIN value ${value} is out of range`);
#endif
          AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
          return;
        }

        AL.currentCtx.gain.gain.value = value;
        break;
      case {{{ cDefs.AL_ORIENTATION }}}:
        if (!Number.isFinite(value[0]) || !Number.isFinite(value[1]) || !Number.isFinite(value[2])
          || !Number.isFinite(value[3]) || !Number.isFinite(value[4]) || !Number.isFinite(value[5])
        ) {
#if OPENAL_DEBUG
          dbg(`${funcname}() param AL_ORIENTATION value ${value} is out of range`);
#endif
          AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
          return;
        }

        listener.direction[0] = value[0];
        listener.direction[1] = value[1];
        listener.direction[2] = value[2];
        listener.up[0] = value[3];
        listener.up[1] = value[4];
        listener.up[2] = value[5];
        AL.updateListenerSpace(AL.currentCtx);
        break;
      default:
#if OPENAL_DEBUG
        dbg(`${funcname}() param ${ptrToString(param)} is unknown or not implemented`);
#endif
        AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
        return;
      }
    },

    getBufferParam: (funcname, bufferId, param) => {
      if (!AL.currentCtx) {
#if OPENAL_DEBUG
        dbg(`${funcname}() called without a valid context`);
#endif
        return;
      }
      var buf = AL.buffers[bufferId];
      if (!buf || bufferId === 0) {
#if OPENAL_DEBUG
        dbg(`${funcname}() called with an invalid buffer`);
#endif
        AL.currentCtx.err = {{{ cDefs.AL_INVALID_NAME }}};
        return;
      }

      switch (param) {
      case 0x2001 /* AL_FREQUENCY */:
        return buf.frequency;
      case 0x2002 /* AL_BITS */:
        return buf.bytesPerSample * 8;
      case 0x2003 /* AL_CHANNELS */:
        return buf.channels;
      case 0x2004 /* AL_SIZE */:
        return buf.length * buf.bytesPerSample * buf.channels;
      case 0x2015 /* AL_LOOP_POINTS_SOFT */:
        if (buf.length === 0) {
          return [0, 0];
        }
        return [
          (buf.audioBuf._loopStart || 0.0) * buf.frequency,
          (buf.audioBuf._loopEnd || buf.length) * buf.frequency
        ];
      default:
#if OPENAL_DEBUG
        dbg(`${funcname}() param ${ptrToString(param)} is unknown or not implemented`);
#endif
        AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
        return null;
      }
    },

    setBufferParam: (funcname, bufferId, param, value) => {
      if (!AL.currentCtx) {
#if OPENAL_DEBUG
        dbg(`${funcname}() called without a valid context`);
#endif
        return;
      }
      var buf = AL.buffers[bufferId];
      if (!buf || bufferId === 0) {
#if OPENAL_DEBUG
        dbg(`${funcname}() called with an invalid buffer`);
#endif
        AL.currentCtx.err = {{{ cDefs.AL_INVALID_NAME }}};
        return;
      }
      if (value === null) {
#if OPENAL_DEBUG
        dbg(`${funcname}(): param ${ptrToString(param)} has wrong signature`);
#endif
        AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
        return;
      }

      switch (param) {
      case 0x2004 /* AL_SIZE */:
        if (value !== 0) {
#if OPENAL_DEBUG
          dbg(`${funcname}() param AL_SIZE value ${value} is out of range`);
#endif
          AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
          return;
        }

        // Per the spec, setting AL_SIZE to 0 is a legal NOP.
        break;
      case 0x2015 /* AL_LOOP_POINTS_SOFT */:
        if (value[0] < 0 || value[0] > buf.length || value[1] < 0 || value[1] > buf.Length || value[0] >= value[1]) {
#if OPENAL_DEBUG
          dbg(`${funcname}() param AL_LOOP_POINTS_SOFT value ${value} is out of range`);
#endif
          AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
          return;
        }
        if (buf.refCount > 0) {
#if OPENAL_DEBUG
          dbg(`${funcname}() param AL_LOOP_POINTS_SOFT set on bound buffer`);
#endif
          AL.currentCtx.err = {{{ cDefs.AL_INVALID_OPERATION }}};
          return;
        }

        if (buf.audioBuf) {
          buf.audioBuf._loopStart = value[0] / buf.frequency;
          buf.audioBuf._loopEnd = value[1] / buf.frequency;
        }
        break;
      default:
#if OPENAL_DEBUG
        dbg(`${funcname}() param ${ptrToString(param)}' is unknown or not implemented`);
#endif
        AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
        return;
      }
    },

    getSourceParam: (funcname, sourceId, param) => {
      if (!AL.currentCtx) {
#if OPENAL_DEBUG
        dbg(`${funcname}() called without a valid context`);
#endif
        return null;
      }
      var src = AL.currentCtx.sources[sourceId];
      if (!src) {
#if OPENAL_DEBUG
        dbg(`${funcname}() called with an invalid source`);
#endif
        AL.currentCtx.err = {{{ cDefs.AL_INVALID_NAME }}};
        return null;
      }

      switch (param) {
      case 0x202 /* AL_SOURCE_RELATIVE */:
        return src.relative;
      case 0x1001 /* AL_CONE_INNER_ANGLE */:
        return src.coneInnerAngle;
      case 0x1002 /* AL_CONE_OUTER_ANGLE */:
        return src.coneOuterAngle;
      case 0x1003 /* AL_PITCH */:
        return src.pitch;
      case {{{ cDefs.AL_POSITION }}}:
        return src.position;
      case {{{ cDefs.AL_DIRECTION }}}:
        return src.direction;
      case {{{ cDefs.AL_VELOCITY }}}:
        return src.velocity;
      case 0x1007 /* AL_LOOPING */:
        return src.looping;
      case 0x1009 /* AL_BUFFER */:
        if (src.type === {{{ cDefs.AL_STATIC }}}) {
          return src.bufQueue[0].id;
        }
        return 0;
      case {{{ cDefs.AL_GAIN }}}:
        return src.gain.gain.value;
       case 0x100D /* AL_MIN_GAIN */:
        return src.minGain;
      case 0x100E /* AL_MAX_GAIN */:
        return src.maxGain;
      case 0x1010 /* AL_SOURCE_STATE */:
        return src.state;
      case 0x1015 /* AL_BUFFERS_QUEUED */:
        if (src.bufQueue.length === 1 && src.bufQueue[0].id === 0) {
          return 0;
        }
        return src.bufQueue.length;
      case 0x1016 /* AL_BUFFERS_PROCESSED */:
        if ((src.bufQueue.length === 1 && src.bufQueue[0].id === 0) || src.looping) {
          return 0;
        }
        return src.bufsProcessed;
      case 0x1020 /* AL_REFERENCE_DISTANCE */:
        return src.refDistance;
      case 0x1021 /* AL_ROLLOFF_FACTOR */:
        return src.rolloffFactor;
      case 0x1022 /* AL_CONE_OUTER_GAIN */:
        return src.coneOuterGain;
      case 0x1023 /* AL_MAX_DISTANCE */:
        return src.maxDistance;
      case 0x1024 /* AL_SEC_OFFSET */:
        return AL.sourceTell(src);
      case 0x1025 /* AL_SAMPLE_OFFSET */:
        var offset = AL.sourceTell(src);
        if (offset > 0.0) {
          offset *= src.bufQueue[0].frequency;
        }
        return offset;
      case 0x1026 /* AL_BYTE_OFFSET */:
        var offset = AL.sourceTell(src);
        if (offset > 0.0) {
          offset *= src.bufQueue[0].frequency * src.bufQueue[0].bytesPerSample;
        }
        return offset;
      case 0x1027 /* AL_SOURCE_TYPE */:
        return src.type;
      case 0x1214 /* AL_SOURCE_SPATIALIZE_SOFT */:
        return src.spatialize;
      case 0x2009 /* AL_BYTE_LENGTH_SOFT */:
        var length = 0;
        var bytesPerFrame = 0;
        for (var i = 0; i < src.bufQueue.length; i++) {
          length += src.bufQueue[i].length;
          if (src.bufQueue[i].id !== 0) {
            bytesPerFrame = src.bufQueue[i].bytesPerSample * src.bufQueue[i].channels;
          }
        }
        return length * bytesPerFrame;
      case 0x200A /* AL_SAMPLE_LENGTH_SOFT */:
        var length = 0;
        for (var i = 0; i < src.bufQueue.length; i++) {
          length += src.bufQueue[i].length;
        }
        return length;
      case 0x200B /* AL_SEC_LENGTH_SOFT */:
        return AL.sourceDuration(src);
      case {{{ cDefs.AL_DISTANCE_MODEL }}}:
        return src.distanceModel;
      default:
#if OPENAL_DEBUG
        dbg(`${funcname}() param ${ptrToString(param)}' is unknown or not implemented`);
#endif
        AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
        return null;
      }
    },

    setSourceParam: (funcname, sourceId, param, value) => {
      if (!AL.currentCtx) {
#if OPENAL_DEBUG
        dbg(`${funcname}() called without a valid context`);
#endif
        return;
      }
      var src = AL.currentCtx.sources[sourceId];
      if (!src) {
#if OPENAL_DEBUG
        dbg('alSourcef() called with an invalid source');
#endif
        AL.currentCtx.err = {{{ cDefs.AL_INVALID_NAME }}};
        return;
      }
      if (value === null) {
#if OPENAL_DEBUG
        dbg(`${funcname}(): param ${ptrToString(param)}' has wrong signature`);
#endif
        AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
        return;
      }

      switch (param) {
      case 0x202 /* AL_SOURCE_RELATIVE */:
        if (value === {{{ cDefs.AL_TRUE }}}) {
          src.relative = true;
          AL.updateSourceSpace(src);
        } else if (value === {{{ cDefs.AL_FALSE }}}) {
          src.relative = false;
          AL.updateSourceSpace(src);
        } else {
#if OPENAL_DEBUG
          dbg(`${funcname}() param AL_SOURCE_RELATIVE value ${value} is out of range`);
#endif
          AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
          return;
        }
        break;
      case 0x1001 /* AL_CONE_INNER_ANGLE */:
        if (!Number.isFinite(value)) {
#if OPENAL_DEBUG
          dbg(`${funcname}() param AL_CONE_INNER_ANGLE value ${value} is out of range`);
#endif
          AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
          return;
        }

        src.coneInnerAngle = value;
        if (src.panner) {
          src.panner.coneInnerAngle = value % 360.0;
        }
        break;
      case 0x1002 /* AL_CONE_OUTER_ANGLE */:
        if (!Number.isFinite(value)) {
#if OPENAL_DEBUG
          dbg(`${funcname}() param AL_CONE_OUTER_ANGLE value ${value} is out of range`);
#endif
          AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
          return;
        }

        src.coneOuterAngle = value;
        if (src.panner) {
          src.panner.coneOuterAngle = value % 360.0;
        }
        break;
      case 0x1003 /* AL_PITCH */:
        if (!Number.isFinite(value) || value <= 0.0) {
#if OPENAL_DEBUG
          dbg(`${funcname}() param AL_PITCH value ${value} is out of range`);
#endif
          AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
          return;
        }

        if (src.pitch === value) {
          break;
        }

        src.pitch = value;
        AL.updateSourceRate(src);
        break;
      case {{{ cDefs.AL_POSITION }}}:
        if (!Number.isFinite(value[0]) || !Number.isFinite(value[1]) || !Number.isFinite(value[2])) {
#if OPENAL_DEBUG
          dbg(`${funcname}() param AL_POSITION value ${value} is out of range`);
#endif
          AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
          return;
        }

        src.position[0] = value[0];
        src.position[1] = value[1];
        src.position[2] = value[2];
        AL.updateSourceSpace(src);
        break;
      case {{{ cDefs.AL_DIRECTION }}}:
        if (!Number.isFinite(value[0]) || !Number.isFinite(value[1]) || !Number.isFinite(value[2])) {
#if OPENAL_DEBUG
          dbg(`${funcname}() param AL_DIRECTION value ${value} is out of range`);
#endif
          AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
          return;
        }

        src.direction[0] = value[0];
        src.direction[1] = value[1];
        src.direction[2] = value[2];
        AL.updateSourceSpace(src);
        break;
      case {{{ cDefs.AL_VELOCITY }}}:
        if (!Number.isFinite(value[0]) || !Number.isFinite(value[1]) || !Number.isFinite(value[2])) {
#if OPENAL_DEBUG
          dbg(`${funcname}() param AL_VELOCITY value ${value} is out of range`);
#endif
          AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
          return;
        }

        src.velocity[0] = value[0];
        src.velocity[1] = value[1];
        src.velocity[2] = value[2];
        AL.updateSourceSpace(src);
        break;
      case 0x1007 /* AL_LOOPING */:
        if (value === {{{ cDefs.AL_TRUE }}}) {
          src.looping = true;
          AL.updateSourceTime(src);
          if (src.type === {{{ cDefs.AL_STATIC }}} && src.audioQueue.length > 0) {
            var audioSrc  = src.audioQueue[0];
            audioSrc.loop = true;
            audioSrc._duration = Number.POSITIVE_INFINITY;
          }
        } else if (value === {{{ cDefs.AL_FALSE }}}) {
          src.looping = false;
          var currentTime = AL.updateSourceTime(src);
          if (src.type === {{{ cDefs.AL_STATIC }}} && src.audioQueue.length > 0) {
            var audioSrc  = src.audioQueue[0];
            audioSrc.loop = false;
            audioSrc._duration = src.bufQueue[0].audioBuf.duration / src.playbackRate;
            audioSrc._startTime = currentTime - src.bufOffset / src.playbackRate;
          }
        } else {
#if OPENAL_DEBUG
          dbg(`${funcname}() param AL_LOOPING value ${value} is out of range`);
#endif
          AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
          return;
        }
        break;
      case 0x1009 /* AL_BUFFER */:
        if (src.state === {{{ cDefs.AL_PLAYING }}} || src.state === {{{ cDefs.AL_PAUSED }}}) {
#if OPENAL_DEBUG
          dbg(`${funcname}(AL_BUFFER) called while source is playing or paused`);
#endif
          AL.currentCtx.err = {{{ cDefs.AL_INVALID_OPERATION }}};
          return;
        }

        if (value === 0) {
          for (var i in src.bufQueue) {
            src.bufQueue[i].refCount--;
          }
          src.bufQueue.length = 1;
          src.bufQueue[0] = AL.buffers[0];

          src.bufsProcessed = 0;
          src.type = 0x1030 /* AL_UNDETERMINED */;
        } else {
          var buf = AL.buffers[value];
          if (!buf) {
#if OPENAL_DEBUG
            dbg('alSourcei(AL_BUFFER) called with an invalid buffer');
#endif
            AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
            return;
          }

          for (var i in src.bufQueue) {
            src.bufQueue[i].refCount--;
          }
          src.bufQueue.length = 0;

          buf.refCount++;
          src.bufQueue = [buf];
          src.bufsProcessed = 0;
          src.type = {{{ cDefs.AL_STATIC }}};
        }

        AL.initSourcePanner(src);
        AL.scheduleSourceAudio(src);
        break;
      case {{{ cDefs.AL_GAIN }}}:
        if (!Number.isFinite(value) || value < 0.0) {
#if OPENAL_DEBUG
          dbg(`${funcname}() param AL_GAIN value ${value} is out of range`);
#endif
          AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
          return;
        }
        src.gain.gain.value = value;
        break;
      case 0x100D /* AL_MIN_GAIN */:
        if (!Number.isFinite(value) || value < 0.0 || value > Math.min(src.maxGain, 1.0)) {
#if OPENAL_DEBUG
          dbg(`${funcname}() param AL_MIN_GAIN value ${value} is out of range`);
#endif
          AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
          return;
        }
#if OPENAL_DEBUG
        warnOnce('AL_MIN_GAIN is not currently supported');
#endif
        src.minGain = value;
        break;
      case 0x100E /* AL_MAX_GAIN */:
        if (!Number.isFinite(value) || value < Math.max(0.0, src.minGain) || value > 1.0) {
#if OPENAL_DEBUG
          dbg(`${funcname}() param AL_MAX_GAIN value ${value} is out of range`);
#endif
          AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
          return;
        }
#if OPENAL_DEBUG
        warnOnce('AL_MAX_GAIN is not currently supported');
#endif
        src.maxGain = value;
        break;
      case 0x1020 /* AL_REFERENCE_DISTANCE */:
        if (!Number.isFinite(value) || value < 0.0) {
#if OPENAL_DEBUG
          dbg(`${funcname}() param AL_REFERENCE_DISTANCE value ${value} is out of range`);
#endif
          AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
          return;
        }
        src.refDistance = value;
        if (src.panner) {
          src.panner.refDistance = value;
        }
        break;
      case 0x1021 /* AL_ROLLOFF_FACTOR */:
        if (!Number.isFinite(value) || value < 0.0) {
#if OPENAL_DEBUG
          dbg(`${funcname}() param AL_ROLLOFF_FACTOR value ${value} is out of range`);
#endif
          AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
          return;
        }
        src.rolloffFactor = value;
        if (src.panner) {
          src.panner.rolloffFactor = value;
        }
        break;
      case 0x1022 /* AL_CONE_OUTER_GAIN */:
        if (!Number.isFinite(value) || value < 0.0 || value > 1.0) {
#if OPENAL_DEBUG
          dbg(`${funcname}() param AL_CORE_OUTER_GAIN value ${value} is out of range`);
#endif
          AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
          return;
        }
        src.coneOuterGain = value;
        if (src.panner) {
          src.panner.coneOuterGain = value;
        }
        break;
      case 0x1023 /* AL_MAX_DISTANCE */:
        if (!Number.isFinite(value) || value < 0.0) {
#if OPENAL_DEBUG
          dbg(`${funcname}() param AL_MAX_DISTANCE value ${value} is out of range`);
#endif
          AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
          return;
        }
        src.maxDistance = value;
        if (src.panner) {
          src.panner.maxDistance = value;
        }
        break;
      case 0x1024 /* AL_SEC_OFFSET */:
        if (value < 0.0 || value > AL.sourceDuration(src)) {
#if OPENAL_DEBUG
          dbg(`${funcname}() param AL_SEC_OFFSET value ${value} is out of range`);
#endif
          AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
          return;
        }

        AL.sourceSeek(src, value);
        break;
      case 0x1025 /* AL_SAMPLE_OFFSET */:
        var srcLen = AL.sourceDuration(src);
        if (srcLen > 0.0) {
          var frequency;
          for (var bufId in src.bufQueue) {
            if (bufId) {
              frequency = src.bufQueue[bufId].frequency;
              break;
            }
          }
          value /= frequency;
        }
        if (value < 0.0 || value > srcLen) {
#if OPENAL_DEBUG
          dbg(`${funcname}() param AL_SAMPLE_OFFSET value ${value} is out of range`);
#endif
          AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
          return;
        }

        AL.sourceSeek(src, value);
        break;
      case 0x1026 /* AL_BYTE_OFFSET */:
        var srcLen = AL.sourceDuration(src);
        if (srcLen > 0.0) {
          var bytesPerSec;
          for (var bufId in src.bufQueue) {
            if (bufId) {
              var buf = src.bufQueue[bufId];
              bytesPerSec = buf.frequency * buf.bytesPerSample * buf.channels;
              break;
            }
          }
          value /= bytesPerSec;
        }
        if (value < 0.0 || value > srcLen) {
#if OPENAL_DEBUG
          dbg(`${funcname}() param AL_BYTE_OFFSET value ${value} is out of range`);
#endif
          AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
          return;
        }

        AL.sourceSeek(src, value);
        break;
      case 0x1214 /* AL_SOURCE_SPATIALIZE_SOFT */:
        if (value !== {{{ cDefs.AL_FALSE }}} && value !== {{{ cDefs.AL_TRUE }}} && value !== 2 /* AL_AUTO_SOFT */) {
#if OPENAL_DEBUG
          dbg(`${funcname}() param AL_SOURCE_SPATIALIZE_SOFT value ${value} is out of range`);
#endif
          AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
          return;
        }

        src.spatialize = value;
        AL.initSourcePanner(src);
        break;
      case 0x2009 /* AL_BYTE_LENGTH_SOFT */:
      case 0x200A /* AL_SAMPLE_LENGTH_SOFT */:
      case 0x200B /* AL_SEC_LENGTH_SOFT */:
#if OPENAL_DEBUG
        dbg(`${funcname}() param AL_*_LENGTH_SOFT is read only`);
#endif
        AL.currentCtx.err = {{{ cDefs.AL_INVALID_OPERATION }}};
        break;
      case {{{ cDefs.AL_DISTANCE_MODEL }}}:
        switch (value) {
        case {{{ cDefs.AL_NONE }}}:
        case 0xd001 /* AL_INVERSE_DISTANCE */:
        case 0xd002 /* AL_INVERSE_DISTANCE_CLAMPED */:
        case 0xd003 /* AL_LINEAR_DISTANCE */:
        case 0xd004 /* AL_LINEAR_DISTANCE_CLAMPED */:
        case 0xd005 /* AL_EXPONENT_DISTANCE */:
        case 0xd006 /* AL_EXPONENT_DISTANCE_CLAMPED */:
          src.distanceModel = value;
          if (AL.currentCtx.sourceDistanceModel) {
            AL.updateContextGlobal(AL.currentCtx);
          }
          break;
        default:
#if OPENAL_DEBUG
          dbg(`${funcname}() param AL_DISTANCE_MODEL value ${value} is out of range`);
#endif
          AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
          return;
        }
        break;
      default:
#if OPENAL_DEBUG
        dbg(`${funcname}() param ${ptrToString(param)} is unknown or not implemented`);
#endif
        AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
        return;
      }
    },

    // -------------------------------------------------------
    // -- Capture
    // -------------------------------------------------------

    // A map of 'capture device contexts'.
    captures: {},

    sharedCaptureAudioCtx: null,

    // Helper which:
    // - Asserts that deviceId is both non-NULL AND a known device ID;
    // - Returns a reference to it, or null if not found.
    // - Sets alcErr accordingly.
    // Treat NULL and <invalid> separately because careless
    // people might assume that most alcCapture functions
    // accept NULL as a 'use the default' device.
    requireValidCaptureDevice: (deviceId, funcname) => {
      if (deviceId === 0) {
#if OPENAL_DEBUG
        dbg(`${funcname}() on a NULL device is an error`);
#endif
        AL.alcErr = {{{ cDefs.ALC_INVALID_DEVICE }}};
        return null;
      }
      var c = AL.captures[deviceId];
      if (!c) {
#if OPENAL_DEBUG
        dbg(`${funcname}() on an invalid device`);
#endif
        AL.alcErr = {{{ cDefs.ALC_INVALID_DEVICE }}};
        return null;
      }
      var err = c.mediaStreamError;
      if (err) {
#if OPENAL_DEBUG
        switch (err.name) {
        case 'PermissionDeniedError':
          dbg(`${funcname}() but the user denied access to the device`);
          break;
        case 'NotFoundError':
          dbg(`${funcname}() but no capture device was found`);
          break;
        default:
          dbg(`${funcname}() but a MediaStreamError was encountered: ${err}`);
          break;
        }
#endif
        AL.alcErr = {{{ cDefs.ALC_INVALID_DEVICE }}};
        return null;
      }
      return c;
    }

  },

  // ***************************************************************************
  // ** ALC API
  // ***************************************************************************

  // -------------------------------------------------------
  // -- ALC Capture
  // -------------------------------------------------------

  // bufferSize is actually 'number of sample frames', so was renamed
  // bufferFrameCapacity here for clarity.
  alcCaptureOpenDevice__deps: ['$autoResumeAudioContext'],
  alcCaptureOpenDevice__proxy: 'sync',
  alcCaptureOpenDevice: (pDeviceName, requestedSampleRate, format, bufferFrameCapacity) => {

    var resolvedDeviceName = AL.CAPTURE_DEVICE_NAME;

    // NULL is a valid device name here (resolves to default);
    if (pDeviceName !== 0) {
      resolvedDeviceName = UTF8ToString(pDeviceName);
      if (resolvedDeviceName !== AL.CAPTURE_DEVICE_NAME) {
#if OPENAL_DEBUG
        dbg(`alcCaptureOpenDevice() with invalid device name '${resolvedDeviceName}'`);
#endif
        // ALC_OUT_OF_MEMORY
        // From the programmer's guide, ALC_OUT_OF_MEMORY's meaning is
        // overloaded here, to mean:
        // 'The specified device is invalid, or can not capture audio.'
        // This may be misleading to API users, but well...
        AL.alcErr = 0xA005 /* ALC_OUT_OF_MEMORY */;
        return 0;
      }
    }

    // Otherwise it's probably okay (though useless) for bufferFrameCapacity to be zero.
    if (bufferFrameCapacity < 0) { // ALCsizei is signed int
#if OPENAL_DEBUG
      dbg('alcCaptureOpenDevice() with negative bufferSize');
#endif
      AL.alcErr = {{{ cDefs.ALC_INVALID_VALUE }}};
      return 0;
    }

    navigator.getUserMedia = navigator.getUserMedia
      || navigator.webkitGetUserMedia
      || navigator.mozGetUserMedia
      || navigator.msGetUserMedia;
    var has_getUserMedia = navigator.getUserMedia
      || (navigator.mediaDevices
      &&  navigator.mediaDevices.getUserMedia);

    if (!has_getUserMedia) {
#if OPENAL_DEBUG
      dbg('alcCaptureOpenDevice() cannot capture audio, because your browser lacks a `getUserMedia()` implementation');
#endif
      // See previously mentioned rationale for ALC_OUT_OF_MEMORY
      AL.alcErr = 0xA005 /* ALC_OUT_OF_MEMORY */;
      return 0;
    }

    var AudioContext = window.AudioContext || window.webkitAudioContext;

    if (!AL.sharedCaptureAudioCtx) {
      try {
        AL.sharedCaptureAudioCtx = new AudioContext();
      } catch(e) {
#if OPENAL_DEBUG
        dbg(`alcCaptureOpenDevice() could not create the shared capture AudioContext: ${e}`);
#endif
        // See previously mentioned rationale for ALC_OUT_OF_MEMORY
        AL.alcErr = 0xA005 /* ALC_OUT_OF_MEMORY */;
        return 0;
      }
    }

    autoResumeAudioContext(AL.sharedCaptureAudioCtx);

    var outputChannelCount;

    switch (format) {
    case 0x10010: /* AL_FORMAT_MONO_FLOAT32 */
    case 0x1101:  /* AL_FORMAT_MONO16 */
    case 0x1100:  /* AL_FORMAT_MONO8 */
      outputChannelCount = 1;
      break;
    case 0x10011: /* AL_FORMAT_STEREO_FLOAT32 */
    case 0x1103:  /* AL_FORMAT_STEREO16 */
    case 0x1102:  /* AL_FORMAT_STEREO8 */
      outputChannelCount = 2;
      break;
    default:
#if OPENAL_DEBUG
      dbg(`alcCaptureOpenDevice() with unsupported format ${format}`);
#endif
      AL.alcErr = {{{ cDefs.ALC_INVALID_VALUE }}};
      return 0;
    }

    function newF32Array(cap) { return new Float32Array(cap);}
    function newI16Array(cap) { return new Int16Array(cap);  }
    function newU8Array(cap)  { return new Uint8Array(cap);  }

    var requestedSampleType;
    var newSampleArray;

    switch (format) {
    case 0x10010: /* AL_FORMAT_MONO_FLOAT32 */
    case 0x10011: /* AL_FORMAT_STEREO_FLOAT32 */
      requestedSampleType = 'f32';
      newSampleArray = newF32Array;
      break;
    case 0x1101:  /* AL_FORMAT_MONO16 */
    case 0x1103:  /* AL_FORMAT_STEREO16 */
      requestedSampleType = 'i16';
      newSampleArray = newI16Array;
      break;
    case 0x1100:  /* AL_FORMAT_MONO8 */
    case 0x1102:  /* AL_FORMAT_STEREO8 */
      requestedSampleType = 'u8';
      newSampleArray = newU8Array;
      break;
    }

    var buffers = [];
    try {
      for (var chan=0; chan < outputChannelCount; ++chan) {
        buffers[chan] = newSampleArray(bufferFrameCapacity);
      }
    } catch(e) {
#if OPENAL_DEBUG
      dbg(`alcCaptureOpenDevice() failed to allocate internal buffers (is bufferSize low enough?): ${e}`);
#endif
      AL.alcErr = 0xA005 /* ALC_OUT_OF_MEMORY */;
      return 0;
    }


    // What we'll place into the `AL.captures` array in the end,
    // declared here for closures to access it
    var newCapture = {
      audioCtx: AL.sharedCaptureAudioCtx,
      deviceName: resolvedDeviceName,
      requestedSampleRate,
      requestedSampleType,
      outputChannelCount,
      inputChannelCount: null, // Not known until the getUserMedia() promise resolves
      mediaStreamError: null, // Used by other functions to return early and report an error.
      mediaStreamSourceNode: null,
      mediaStream: null,
      // Either one, or none of the below two, is active.
      mergerNode: null,
      splitterNode: null,
      scriptProcessorNode: null,
      isCapturing: false,
      buffers,
      get bufferFrameCapacity() {
        return buffers[0].length;
      },
      capturePlayhead: 0, // current write position, in sample frames
      captureReadhead: 0,
      capturedFrameCount: 0
    };

    // Preparing for getUserMedia()

    var onError = (mediaStreamError) => {
      newCapture.mediaStreamError = mediaStreamError;
#if OPENAL_DEBUG
      dbg(`navigator.getUserMedia() errored with: ${mediaStreamError}`);
#endif
    };
    var onSuccess = (mediaStream) => {
      newCapture.mediaStreamSourceNode = newCapture.audioCtx.createMediaStreamSource(mediaStream);
      newCapture.mediaStream = mediaStream;

      var inputChannelCount = 1;
      switch (newCapture.mediaStreamSourceNode.channelCountMode) {
      case 'max':
        inputChannelCount = outputChannelCount;
        break;
      case 'clamped-max':
        inputChannelCount = Math.min(outputChannelCount, newCapture.mediaStreamSourceNode.channelCount);
        break;
      case 'explicit':
        inputChannelCount = newCapture.mediaStreamSourceNode.channelCount;
        break;
      }

      newCapture.inputChannelCount = inputChannelCount;

#if OPENAL_DEBUG
      if (inputChannelCount > 2 || outputChannelCount > 2) {
        dbg('The number of input or output channels is too high, capture might not work as expected!');
      }
#endif

      // Have to pick a size from 256, 512, 1024, 2048, 4096, 8192, 16384.
      // One can also set it to zero, which leaves the decision up to the impl.
      // An extension could allow specifying this value.
      var processorFrameCount = 512;

      newCapture.scriptProcessorNode = newCapture.audioCtx.createScriptProcessor(
        processorFrameCount, inputChannelCount, outputChannelCount
      );

      if (inputChannelCount > outputChannelCount) {
        newCapture.mergerNode = newCapture.audioCtx.createChannelMerger(inputChannelCount);
        newCapture.mediaStreamSourceNode.connect(newCapture.mergerNode);
        newCapture.mergerNode.connect(newCapture.scriptProcessorNode);
      } else if (inputChannelCount < outputChannelCount) {
        newCapture.splitterNode = newCapture.audioCtx.createChannelSplitter(outputChannelCount);
        newCapture.mediaStreamSourceNode.connect(newCapture.splitterNode);
        newCapture.splitterNode.connect(newCapture.scriptProcessorNode);
      } else {
        newCapture.mediaStreamSourceNode.connect(newCapture.scriptProcessorNode);
      }

      newCapture.scriptProcessorNode.connect(newCapture.audioCtx.destination);

      newCapture.scriptProcessorNode.onaudioprocess = (audioProcessingEvent) => {
        if (!newCapture.isCapturing) {
          return;
        }

        var c = newCapture;
        var srcBuf = audioProcessingEvent.inputBuffer;

        // Actually just copy srcBuf's channel data into
        // c.buffers, optimizing for each case.
        switch (format) {
        case 0x10010: /* AL_FORMAT_MONO_FLOAT32 */
          var channel0 = srcBuf.getChannelData(0);
          for (var i = 0 ; i < srcBuf.length; ++i) {
            var wi = (c.capturePlayhead + i) % c.bufferFrameCapacity;
            c.buffers[0][wi] = channel0[i];
          }
          break;
        case 0x10011: /* AL_FORMAT_STEREO_FLOAT32 */
          var channel0 = srcBuf.getChannelData(0);
          var channel1 = srcBuf.getChannelData(1);
          for (var i = 0 ; i < srcBuf.length; ++i) {
            var wi = (c.capturePlayhead + i) % c.bufferFrameCapacity;
            c.buffers[0][wi] = channel0[i];
            c.buffers[1][wi] = channel1[i];
          }
          break;
        case 0x1101:  /* AL_FORMAT_MONO16 */
          var channel0 = srcBuf.getChannelData(0);
          for (var i = 0 ; i < srcBuf.length; ++i) {
            var wi = (c.capturePlayhead + i) % c.bufferFrameCapacity;
            c.buffers[0][wi] = channel0[i] * 32767;
          }
          break;
        case 0x1103:  /* AL_FORMAT_STEREO16 */
          var channel0 = srcBuf.getChannelData(0);
          var channel1 = srcBuf.getChannelData(1);
          for (var i = 0 ; i < srcBuf.length; ++i) {
            var wi = (c.capturePlayhead + i) % c.bufferFrameCapacity;
            c.buffers[0][wi] = channel0[i] * 32767;
            c.buffers[1][wi] = channel1[i] * 32767;
          }
          break;
        case 0x1100:  /* AL_FORMAT_MONO8 */
          var channel0 = srcBuf.getChannelData(0);
          for (var i = 0 ; i < srcBuf.length; ++i) {
            var wi = (c.capturePlayhead + i) % c.bufferFrameCapacity;
            c.buffers[0][wi] = (channel0[i] + 1.0) * 127;
          }
          break;
        case 0x1102:  /* AL_FORMAT_STEREO8 */
          var channel0 = srcBuf.getChannelData(0);
          var channel1 = srcBuf.getChannelData(1);
          for (var i = 0 ; i < srcBuf.length; ++i) {
            var wi = (c.capturePlayhead + i) % c.bufferFrameCapacity;
            c.buffers[0][wi] = (channel0[i] + 1.0) * 127;
            c.buffers[1][wi] = (channel1[i] + 1.0) * 127;
          }
          break;
        }

        c.capturePlayhead += srcBuf.length;
        c.capturePlayhead %= c.bufferFrameCapacity;
        c.capturedFrameCount += srcBuf.length;
        c.capturedFrameCount = Math.min(c.capturedFrameCount, c.bufferFrameCapacity);
      };
    };

    // The latest way to call getUserMedia()
    if (navigator.mediaDevices?.getUserMedia) {
      navigator.mediaDevices
           .getUserMedia({audio: true})
           .then(onSuccess)
           .catch(onError);
    } else { // The usual (now deprecated) way
      navigator.getUserMedia({audio: true}, onSuccess, onError);
    }

    var id = AL.newId();
    AL.captures[id] = newCapture;
    return id;
  },

  alcCaptureCloseDevice__proxy: 'sync',
  alcCaptureCloseDevice: (deviceId) => {
    var c = AL.requireValidCaptureDevice(deviceId, 'alcCaptureCloseDevice');
    if (!c) return false;

    delete AL.captures[deviceId];
    AL.freeIds.push(deviceId);

    // This clean-up might be unnecessary (paranoid) ?

    // May happen if user hasn't decided to grant or deny input
    c.mediaStreamSourceNode?.disconnect();
    c.mergerNode?.disconnect();
    c.splitterNode?.disconnect();
    // May happen if user hasn't decided to grant or deny input
    c.scriptProcessorNode?.disconnect();
    if (c.mediaStream) {
      // Disabling the microphone of the browser.
      // Without this operation, the red dot on the browser tab page will remain.
      c.mediaStream.getTracks().forEach((track) => track.stop());
    }

    delete c.buffers;

    c.capturedFrameCount = 0;
    c.isCapturing = false;

    return true;
  },

  alcCaptureStart__proxy: 'sync',
  alcCaptureStart: (deviceId) => {
    var c = AL.requireValidCaptureDevice(deviceId, 'alcCaptureStart');
    if (!c) return;

    if (c.isCapturing) {
#if OPENAL_DEBUG
      dbg('Redundant call to alcCaptureStart()');
#endif
      // NOTE: Spec says (emphasis mine):
      //     The amount of audio samples available after **restarting** a
      //     stopped capture device is reset to zero.
      // So redundant calls to alcCaptureStart() must have no effect.
      return;
    }
    c.isCapturing = true;
    c.capturedFrameCount = 0;
    c.capturePlayhead = 0;
  },

  alcCaptureStop__proxy: 'sync',
  alcCaptureStop: (deviceId) => {
    var c = AL.requireValidCaptureDevice(deviceId, 'alcCaptureStop');
    if (!c) return;

#if OPENAL_DEBUG
    if (!c.isCapturing) {
      dbg('Redundant call to alcCaptureStop()');
    }
#endif
    c.isCapturing = false;
  },

  // The OpenAL spec hints that implementations are allowed to
  // 'defer resampling and other conversions' up until this point.
  //
  // The last parameter is actually 'number of sample frames', so was
  // renamed accordingly here
  alcCaptureSamples__proxy: 'sync',
  alcCaptureSamples: (deviceId, pFrames, requestedFrameCount) => {
    var c = AL.requireValidCaptureDevice(deviceId, 'alcCaptureSamples');
    if (!c) return;

    // ALCsizei is actually 32-bit signed int, so could be negative
    // Also, spec says :
    //   Requesting more sample frames than are currently available is
    //   an error.

    var dstfreq = c.requestedSampleRate;
    var srcfreq = c.audioCtx.sampleRate;

    var fratio = srcfreq / dstfreq;

    if (requestedFrameCount < 0
    ||  requestedFrameCount > (c.capturedFrameCount / fratio))
    {
#if OPENAL_DEBUG
      dbg('alcCaptureSamples() with invalid bufferSize');
#endif
      AL.alcErr = {{{ cDefs.ALC_INVALID_VALUE }}};
      return;
    }

    function setF32Sample(i, sample) {
      {{{ makeSetValue('pFrames', '4*i', 'sample', 'float') }}};
    }
    function setI16Sample(i, sample) {
      {{{ makeSetValue('pFrames', '2*i', 'sample', 'i16') }}};
    }
    function setU8Sample(i, sample) {
      {{{ makeSetValue('pFrames', 'i', 'sample', 'i8') }}};
    }

    var setSample;

    switch (c.requestedSampleType) {
    case 'f32': setSample = setF32Sample; break;
    case 'i16': setSample = setI16Sample; break;
    case 'u8' : setSample = setU8Sample ; break;
    default:
#if OPENAL_DEBUG
      dbg(`Internal error: Unknown sample type '${c.requestedSampleType}'`);
#endif
      return;
    }

    // If fratio is an integer we don't need linear resampling, just skip samples
    if (Math.floor(fratio) == fratio) {
      for (var i = 0, frame_i = 0; frame_i < requestedFrameCount; ++frame_i) {
        for (var chan = 0; chan < c.buffers.length; ++chan, ++i) {
          setSample(i, c.buffers[chan][c.captureReadhead]);
        }
        c.captureReadhead = (fratio + c.captureReadhead) % c.bufferFrameCapacity;
      }
    } else {
      // Perform linear resampling.

      // There is room for improvement - right now we're fine with linear resampling.
      // We don't use OfflineAudioContexts for this: See the discussion at
      // https://github.com/jpernst/emscripten/issues/2#issuecomment-312729735
      // if you're curious about why.
      for (var i = 0, frame_i = 0; frame_i < requestedFrameCount; ++frame_i) {
        var lefti = Math.floor(c.captureReadhead);
        var righti = Math.ceil(c.captureReadhead);
        var d = c.captureReadhead - lefti;
        for (var chan = 0; chan < c.buffers.length; ++chan, ++i) {
          var lefts = c.buffers[chan][lefti];
          var rights = c.buffers[chan][righti];
          setSample(i, (1 - d) * lefts + d * rights);
        }
        c.captureReadhead = (c.captureReadhead + fratio) % c.bufferFrameCapacity;
      }
    }

    // Spec doesn't say if alcCaptureSamples() must zero the number
    // of available captured sample-frames, but not only would it
    // be insane not to do, OpenAL-Soft happens to do that as well.
    c.capturedFrameCount = 0;
  },


  // -------------------------------------------------------
  // -- ALC Resources
  // -------------------------------------------------------

  alcOpenDevice__proxy: 'sync',
  alcOpenDevice: (pDeviceName) => {
    if (pDeviceName) {
      var name = UTF8ToString(pDeviceName);
      if (name !== AL.DEVICE_NAME) {
        return 0;
      }
    }

    if (globalThis.AudioContext || globalThis.webkitAudioContext) {
      var deviceId = AL.newId();
      AL.deviceRefCounts[deviceId] = 0;
      return deviceId;
    }
    return 0;
  },

  alcCloseDevice__proxy: 'sync',
  alcCloseDevice: (deviceId) => {
    if (!(deviceId in AL.deviceRefCounts) || AL.deviceRefCounts[deviceId] > 0) {
      return {{{ cDefs.ALC_FALSE }}};
    }

    delete AL.deviceRefCounts[deviceId];
    AL.freeIds.push(deviceId);
    return {{{ cDefs.ALC_TRUE }}};
  },

  alcCreateContext__deps: ['$autoResumeAudioContext'],
  alcCreateContext__proxy: 'sync',
  alcCreateContext: (deviceId, pAttrList) => {
    if (!(deviceId in AL.deviceRefCounts)) {
#if OPENAL_DEBUG
      dbg('alcCreateContext() called with an invalid device');
#endif
      AL.alcErr = 0xA001; /* ALC_INVALID_DEVICE */
      return 0;
    }

    var options = null;
    var attrs = [];
    var hrtf = null;
    pAttrList >>= 2;
    if (pAttrList) {
      var attr = 0;
      var val = 0;
      while (true) {
        attr = HEAP32[pAttrList++];
        attrs.push(attr);
        if (attr === 0) {
          break;
        }
        val = HEAP32[pAttrList++];
        attrs.push(val);

        switch (attr) {
        case 0x1007 /* ALC_FREQUENCY */:
          if (!options) {
            options = {};
          }

          options.sampleRate = val;
          break;
        case 0x1010 /* ALC_MONO_SOURCES */: // fallthrough
        case 0x1011 /* ALC_STEREO_SOURCES */:
          // Do nothing; these hints are satisfied by default
          break
        case 0x1992 /* ALC_HRTF_SOFT */:
          switch (val) {
            case {{{ cDefs.ALC_FALSE }}}:
              hrtf = false;
              break;
            case {{{ cDefs.ALC_TRUE }}}:
              hrtf = true;
              break;
            case 2 /* ALC_DONT_CARE_SOFT */:
              break;
            default:
#if OPENAL_DEBUG
              dbg(`Unsupported ALC_HRTF_SOFT mode ${val}`);
#endif
              AL.alcErr = {{{ cDefs.ALC_INVALID_VALUE }}};
              return 0;
          }
          break;
        case 0x1996 /* ALC_HRTF_ID_SOFT */:
          if (val !== 0) {
#if OPENAL_DEBUG
            dbg(`Invalid ALC_HRTF_ID_SOFT index ${val}`);
#endif
            AL.alcErr = {{{ cDefs.ALC_INVALID_VALUE }}};
            return 0;
          }
          break;
        default:
#if OPENAL_DEBUG
          dbg(`Unsupported context attribute ${ptrToString(attr)}`);
#endif
          AL.alcErr = 0xA004; /* ALC_INVALID_VALUE */
          return 0;
        }
      }
    }

    var AudioContext = window.AudioContext || window.webkitAudioContext;
    var ac = null;
    try {
      // Only try to pass options if there are any, for compat with browsers that don't support this
      if (options) {
        ac = new AudioContext(options);
      } else {
        ac = new AudioContext();
      }
    } catch (e) {
      if (e.name === 'NotSupportedError') {
#if OPENAL_DEBUG
        dbg('Invalid or unsupported options');
#endif
        AL.alcErr = 0xA004; /* ALC_INVALID_VALUE */
      } else {
        AL.alcErr = 0xA001; /* ALC_INVALID_DEVICE */
      }

      return 0;
    }

    autoResumeAudioContext(ac);

    // Old Web Audio API (e.g. Safari 6.0.5) had an inconsistently named createGainNode function.
    if (typeof ac.createGain == 'undefined') {
      ac.createGain = ac.createGainNode;
    }

    var gain = ac.createGain();
    gain.connect(ac.destination);
    var ctx = {
      deviceId,
      id: AL.newId(),
      attrs,
      audioCtx: ac,
      listener: {
        position: [0.0, 0.0, 0.0],
        velocity: [0.0, 0.0, 0.0],
        direction: [0.0, 0.0, 0.0],
        up: [0.0, 0.0, 0.0]
      },
      sources: [],
      interval: setInterval(() => AL.scheduleContextAudio(ctx), AL.QUEUE_INTERVAL),
      gain,
      distanceModel: 0xd002 /* AL_INVERSE_DISTANCE_CLAMPED */,
      speedOfSound: 343.3,
      dopplerFactor: 1.0,
      sourceDistanceModel: false,
      hrtf: hrtf || false,

      _err: 0,
      get err() {
        return this._err;
      },
      set err(val) {
        // Errors should not be overwritten by later errors until they are cleared by a query.
        if (this._err === {{{ cDefs.AL_NO_ERROR }}} || val === {{{ cDefs.AL_NO_ERROR }}}) {
          this._err = val;
        }
      }
    };
    AL.deviceRefCounts[deviceId]++;
    AL.contexts[ctx.id] = ctx;

    if (hrtf !== null) {
      // Apply hrtf attrib to all contexts for this device
      for (var ctxId in AL.contexts) {
        var c = AL.contexts[ctxId];
        if (c.deviceId === deviceId) {
          c.hrtf = hrtf;
          AL.updateContextGlobal(c);
        }
      }
    }

    return ctx.id;
  },

  alcDestroyContext__proxy: 'sync',
  alcDestroyContext: (contextId) => {
    var ctx = AL.contexts[contextId];
    if (AL.currentCtx === ctx) {
#if OPENAL_DEBUG
      dbg('alcDestroyContext() called with an invalid context');
#endif
      AL.alcErr = 0xA002 /* ALC_INVALID_CONTEXT */;
      return;
    }

    // Stop playback, etc
    if (AL.contexts[contextId].interval) {
      clearInterval(AL.contexts[contextId].interval);
    }
    AL.deviceRefCounts[ctx.deviceId]--;
    delete AL.contexts[contextId];
    AL.freeIds.push(contextId);
  },

  // -------------------------------------------------------
  // -- ALC State
  // -------------------------------------------------------

  alcGetError__proxy: 'sync',
  alcGetError: (deviceId) => {
    var err = AL.alcErr;
    AL.alcErr = {{{ cDefs.ALC_NO_ERROR }}};
    return err;
  },

  alcGetCurrentContext__proxy: 'sync',
  alcGetCurrentContext: () => {
    if (AL.currentCtx !== null) {
      return AL.currentCtx.id;
    }
    return 0;
  },

  alcMakeContextCurrent__proxy: 'sync',
  alcMakeContextCurrent: (contextId) => {
    if (contextId === 0) {
      AL.currentCtx = null;
    } else {
      AL.currentCtx = AL.contexts[contextId];
    }
    return {{{ cDefs.ALC_TRUE }}};
  },

  alcGetContextsDevice__proxy: 'sync',
  alcGetContextsDevice: (contextId) => {
    if (contextId in AL.contexts) {
      return AL.contexts[contextId].deviceId;
    }
    return 0;
  },

  // The spec is vague about what these are actually supposed to do, and NOP is a reasonable implementation
  alcProcessContext: (contextId) => {},
  alcSuspendContext: (contextId) => {},

  alcIsExtensionPresent__proxy: 'sync',
  alcIsExtensionPresent: (deviceId, pExtName) => {
    var name = UTF8ToString(pExtName);

    return AL.ALC_EXTENSIONS[name] ? 1 : 0;
  },

  alcGetEnumValue__proxy: 'sync',
  alcGetEnumValue: (deviceId, pEnumName) => {
    // Spec says :
    // Using a NULL handle is legal, but only the
    // tokens defined by the AL core are guaranteed.
    if (deviceId !== 0 && !(deviceId in AL.deviceRefCounts)) {
#if OPENAL_DEBUG
      dbg('alcGetEnumValue() called with an invalid device');
#endif
      // ALC_INVALID_DEVICE is not listed as a possible error state for
      // this function, sadly.
      return 0;
    } else if (!pEnumName) {
      AL.alcErr = {{{ cDefs.ALC_INVALID_VALUE }}};
      return 0;
    }
    var name = UTF8ToString(pEnumName);
    // See alGetEnumValue(), but basically behave the same as OpenAL-Soft
    switch (name) {
    case 'ALC_NO_ERROR': return 0;
    case 'ALC_INVALID_DEVICE': return 0xA001;
    case 'ALC_INVALID_CONTEXT': return 0xA002;
    case 'ALC_INVALID_ENUM': return 0xA003;
    case 'ALC_INVALID_VALUE': return 0xA004;
    case 'ALC_OUT_OF_MEMORY': return 0xA005;
    case 'ALC_MAJOR_VERSION': return 0x1000;
    case 'ALC_MINOR_VERSION': return 0x1001;
    case 'ALC_ATTRIBUTES_SIZE': return 0x1002;
    case 'ALC_ALL_ATTRIBUTES': return 0x1003;
    case 'ALC_DEFAULT_DEVICE_SPECIFIER': return 0x1004;
    case 'ALC_DEVICE_SPECIFIER': return 0x1005;
    case 'ALC_EXTENSIONS': return 0x1006;
    case 'ALC_FREQUENCY': return 0x1007;
    case 'ALC_REFRESH': return 0x1008;
    case 'ALC_SYNC': return 0x1009;
    case 'ALC_MONO_SOURCES': return 0x1010;
    case 'ALC_STEREO_SOURCES': return 0x1011;
    case 'ALC_CAPTURE_DEVICE_SPECIFIER': return 0x310;
    case 'ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER': return 0x311;
    case 'ALC_CAPTURE_SAMPLES': return 0x312;

    /* Extensions */
    case 'ALC_HRTF_SOFT': return 0x1992;
    case 'ALC_HRTF_ID_SOFT': return 0x1996;
    case 'ALC_DONT_CARE_SOFT': return 0x0002;
    case 'ALC_HRTF_STATUS_SOFT': return 0x1993;
    case 'ALC_NUM_HRTF_SPECIFIERS_SOFT': return 0x1994;
    case 'ALC_HRTF_SPECIFIER_SOFT': return 0x1995;
    case 'ALC_HRTF_DISABLED_SOFT': return 0x0000;
    case 'ALC_HRTF_ENABLED_SOFT': return 0x0001;
    case 'ALC_HRTF_DENIED_SOFT': return 0x0002;
    case 'ALC_HRTF_REQUIRED_SOFT': return 0x0003;
    case 'ALC_HRTF_HEADPHONES_DETECTED_SOFT': return 0x0004;
    case 'ALC_HRTF_UNSUPPORTED_FORMAT_SOFT': return 0x0005;

    default:
#if OPENAL_DEBUG
      dbg(`No value for '${pEnumName}' is known by alcGetEnumValue()`);
#endif
      AL.alcErr = {{{ cDefs.ALC_INVALID_VALUE }}};
      return {{{ cDefs.AL_NONE }}};
    }
  },

  alcGetString__proxy: 'sync',
  alcGetString__deps: ['$stringToNewUTF8'],
  alcGetString: (deviceId, param) => {
    if (AL.alcStringCache[param]) {
      return AL.alcStringCache[param];
    }

    var ret;
    switch (param) {
    case {{{ cDefs.ALC_NO_ERROR }}}:
      ret = 'No Error';
      break;
    case {{{ cDefs.ALC_INVALID_DEVICE }}}:
      ret = 'Invalid Device';
      break;
    case 0xA002 /* ALC_INVALID_CONTEXT */:
      ret = 'Invalid Context';
      break;
    case {{{ cDefs.ALC_INVALID_ENUM }}}:
      ret = 'Invalid Enum';
      break;
    case {{{ cDefs.ALC_INVALID_VALUE }}}:
      ret = 'Invalid Value';
      break;
    case 0xA005 /* ALC_OUT_OF_MEMORY */:
      ret = 'Out of Memory';
      break;
    case 0x1004 /* ALC_DEFAULT_DEVICE_SPECIFIER */:
      if (globalThis.AudioContext || globalThis.webkitAudioContext) {
        ret = AL.DEVICE_NAME;
      } else {
        return 0;
      }
      break;
    case 0x1005 /* ALC_DEVICE_SPECIFIER */:
      if (globalThis.AudioContext || globalThis.webkitAudioContext) {
        ret = AL.DEVICE_NAME + '\0';
      } else {
        ret = '\0';
      }
      break;
    case 0x311 /* ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER */:
      ret = AL.CAPTURE_DEVICE_NAME;
      break;
    case 0x310 /* ALC_CAPTURE_DEVICE_SPECIFIER */:
      if (deviceId === 0) {
        ret = AL.CAPTURE_DEVICE_NAME + '\0';
      } else {
        var c = AL.requireValidCaptureDevice(deviceId, 'alcGetString');
        if (!c) {
          return 0;
        }
        ret = c.deviceName;
      }
      break;
    case 0x1006 /* ALC_EXTENSIONS */:
      if (!deviceId) {
        AL.alcErr = {{{ cDefs.ALC_INVALID_DEVICE }}};
        return 0;
      }

      ret = Object.keys(AL.ALC_EXTENSIONS).join(' ')
      break;
    default:
      AL.alcErr = {{{ cDefs.ALC_INVALID_ENUM }}};
      return 0;
    }

    ret = stringToNewUTF8(ret);
    AL.alcStringCache[param] = ret;
    return ret;
  },

  alcGetIntegerv__proxy: 'sync',
  alcGetIntegerv: (deviceId, param, size, pValues) => {
    if (size === 0 || !pValues) {
      // Ignore the query, per the spec
      return;
    }

    switch (param) {
    case 0x1000 /* ALC_MAJOR_VERSION */:
      {{{ makeSetValue('pValues', '0', '1', 'i32') }}};
      break;
    case 0x1001 /* ALC_MINOR_VERSION */:
      {{{ makeSetValue('pValues', '0', '1', 'i32') }}};
      break;
    case 0x1002 /* ALC_ATTRIBUTES_SIZE */:
      if (!(deviceId in AL.deviceRefCounts)) {
        AL.alcErr = {{{ cDefs.ALC_INVALID_DEVICE }}};
        return;
      }
      if (!AL.currentCtx) {
        AL.alcErr = 0xA002 /* ALC_INVALID_CONTEXT */;
        return;
      }

      {{{ makeSetValue('pValues', '0', 'AL.currentCtx.attrs.length', 'i32') }}};
      break;
    case 0x1003 /* ALC_ALL_ATTRIBUTES */:
      if (!(deviceId in AL.deviceRefCounts)) {
        AL.alcErr = {{{ cDefs.ALC_INVALID_DEVICE }}};
        return;
      }
      if (!AL.currentCtx) {
        AL.alcErr = 0xA002 /* ALC_INVALID_CONTEXT */;
        return;
      }

      for (var i = 0; i < AL.currentCtx.attrs.length; i++) {
        {{{ makeSetValue('pValues', 'i*4', 'AL.currentCtx.attrs[i]', 'i32') }}};
      }
      break;
    case 0x1007 /* ALC_FREQUENCY */:
      if (!(deviceId in AL.deviceRefCounts)) {
        AL.alcErr = {{{ cDefs.ALC_INVALID_DEVICE }}};
        return;
      }
      if (!AL.currentCtx) {
        AL.alcErr = 0xA002 /* ALC_INVALID_CONTEXT */;
        return;
      }

      {{{ makeSetValue('pValues', '0', 'AL.currentCtx.audioCtx.sampleRate', 'i32') }}};
      break;
    case 0x1010 /* ALC_MONO_SOURCES */:
    case 0x1011 /* ALC_STEREO_SOURCES */:
      if (!(deviceId in AL.deviceRefCounts)) {
        AL.alcErr = {{{ cDefs.ALC_INVALID_DEVICE }}};
        return;
      }
      if (!AL.currentCtx) {
        AL.alcErr = 0xA002 /* ALC_INVALID_CONTEXT */;
        return;
      }

      {{{ makeSetValue('pValues', '0', '0x7FFFFFFF', 'i32') }}};
      break;
    case 0x1992 /* ALC_HRTF_SOFT */:
    case 0x1993 /* ALC_HRTF_STATUS_SOFT */:
      if (!(deviceId in AL.deviceRefCounts)) {
        AL.alcErr = {{{ cDefs.ALC_INVALID_DEVICE }}};
        return;
      }

      var hrtfStatus = 0 /* ALC_HRTF_DISABLED_SOFT */;
      for (var ctxId in AL.contexts) {
        var ctx = AL.contexts[ctxId];
        if (ctx.deviceId === deviceId) {
          hrtfStatus = ctx.hrtf ? 1 /* ALC_HRTF_ENABLED_SOFT */ : 0 /* ALC_HRTF_DISABLED_SOFT */;
        }
      }
      {{{ makeSetValue('pValues', '0', 'hrtfStatus', 'i32') }}};
      break;
    case 0x1994 /* ALC_NUM_HRTF_SPECIFIERS_SOFT */:
      if (!(deviceId in AL.deviceRefCounts)) {
        AL.alcErr = {{{ cDefs.ALC_INVALID_DEVICE }}};
        return;
      }
      {{{ makeSetValue('pValues', '0', '1', 'i32') }}};
      break;
    case 0x20003 /* ALC_MAX_AUXILIARY_SENDS */:
      if (!(deviceId in AL.deviceRefCounts)) {
        AL.alcErr = {{{ cDefs.ALC_INVALID_DEVICE }}};
        return;
      }
      if (!AL.currentCtx) {
        AL.alcErr = 0xA002 /* ALC_INVALID_CONTEXT */;
        return;
      }

      {{{ makeSetValue('pValues', '0', '1', 'i32') }}};
    case 0x312 /* ALC_CAPTURE_SAMPLES */:
      var c = AL.requireValidCaptureDevice(deviceId, 'alcGetIntegerv');
      if (!c) {
        return;
      }
      var n = c.capturedFrameCount;
      var dstfreq = c.requestedSampleRate;
      var srcfreq = c.audioCtx.sampleRate;
      var nsamples = Math.floor(n * (dstfreq/srcfreq));
      {{{ makeSetValue('pValues', '0', 'nsamples', 'i32') }}};
      break;
    default:
#if OPENAL_DEBUG
      dbg(`alcGetIntegerv() with param ${ptrToString(param)} not implemented yet`);
#endif
      AL.alcErr = {{{ cDefs.ALC_INVALID_ENUM }}};
      return;
    }
  },

  emscripten_alcDevicePauseSOFT__proxy: 'sync',
  emscripten_alcDevicePauseSOFT__sig: 'vi',
  emscripten_alcDevicePauseSOFT: (deviceId) => {
    if (!(deviceId in AL.deviceRefCounts)) {
#if OPENAL_DEBUG
      dbg('alcDevicePauseSOFT() called with an invalid device');
#endif
      AL.alcErr = {{{ cDefs.ALC_INVALID_DEVICE }}};
      return;
    }

    if (AL.paused) {
      return;
    }
    AL.paused = true;

    for (var ctxId in AL.contexts) {
      var ctx = AL.contexts[ctxId];
      if (ctx.deviceId !== deviceId) {
        continue;
      }

      ctx.audioCtx.suspend();
      clearInterval(ctx.interval);
      ctx.interval = null;
    }
  },

  emscripten_alcDeviceResumeSOFT__proxy: 'sync',
  emscripten_alcDeviceResumeSOFT__sig: 'vi',
  emscripten_alcDeviceResumeSOFT: (deviceId) => {
    if (!(deviceId in AL.deviceRefCounts)) {
#if OPENAL_DEBUG
      dbg('alcDeviceResumeSOFT() called with an invalid device');
#endif
      AL.alcErr = {{{ cDefs.ALC_INVALID_DEVICE }}};
      return;
    }

    if (!AL.paused) {
      return;
    }
    AL.paused = false;

    for (var ctxId in AL.contexts) {
      var ctx = AL.contexts[ctxId];
      if (ctx.deviceId !== deviceId) {
        continue;
      }

      ctx.interval = setInterval(() => AL.scheduleContextAudio(ctx), AL.QUEUE_INTERVAL);
      ctx.audioCtx.resume();
    }
  },

  emscripten_alcGetStringiSOFT__proxy: 'sync',
  emscripten_alcGetStringiSOFT__sig: 'iiii',
  emscripten_alcGetStringiSOFT__deps: ['alcGetString', '$stringToNewUTF8'],
  emscripten_alcGetStringiSOFT: (deviceId, param, index) => {
    if (!(deviceId in AL.deviceRefCounts)) {
#if OPENAL_DEBUG
      dbg('alcGetStringiSOFT() called with an invalid device');
#endif
      AL.alcErr = {{{ cDefs.ALC_INVALID_DEVICE }}};
      return 0;
    }

    if (AL.alcStringCache[param]) {
      return AL.alcStringCache[param];
    }

    var ret;
    switch (param) {
    case 0x1995 /* ALC_HRTF_SPECIFIER_SOFT */:
      if (index === 0) {
        ret = 'Web Audio HRTF';
      } else {
#if OPENAL_DEBUG
        dbg(`alcGetStringiSOFT() with param ALC_HRTF_SPECIFIER_SOFT index ${index} is out of range`);
#endif
        AL.alcErr = {{{ cDefs.ALC_INVALID_VALUE }}};
        return 0;
      }
      break;
    default:
      if (index !== 0) {
#if OPENAL_DEBUG
        dbg(`alcGetStringiSOFT() with param ${ptrToString(param)} not implemented yet`);
#endif
        AL.alcErr = {{{ cDefs.ALC_INVALID_ENUM }}};
        return 0;
      }
      return _alcGetString(deviceId, param);
    }

    ret = stringToNewUTF8(ret);
    AL.alcStringCache[param] = ret;
    return ret;
  },

  emscripten_alcResetDeviceSOFT__proxy: 'sync',
  emscripten_alcResetDeviceSOFT__sig: 'iii',
  emscripten_alcResetDeviceSOFT: (deviceId, pAttrList) => {
    if (!(deviceId in AL.deviceRefCounts)) {
#if OPENAL_DEBUG
      dbg('alcResetDeviceSOFT() called with an invalid device');
#endif
      AL.alcErr = {{{ cDefs.ALC_INVALID_DEVICE }}};
      return {{{ cDefs.ALC_FALSE }}};
    }

    var hrtf = null;
    pAttrList >>= 2;
    if (pAttrList) {
      var attr = 0;
      var val = 0;
      while (true) {
        attr = HEAP32[pAttrList++];
        if (attr === 0) {
          break;
        }
        val = HEAP32[pAttrList++];

        switch (attr) {
        case 0x1992 /* ALC_HRTF_SOFT */:
          if (val === {{{ cDefs.ALC_TRUE }}}) {
            hrtf = true;
          } else if (val === {{{ cDefs.ALC_FALSE }}}) {
            hrtf = false;
          }
          break;
        }
      }
    }

    if (hrtf !== null) {
      // Apply hrtf attrib to all contexts for this device
      for (var ctxId in AL.contexts) {
        var ctx = AL.contexts[ctxId];
        if (ctx.deviceId === deviceId) {
          ctx.hrtf = hrtf;
          AL.updateContextGlobal(ctx);
        }
      }
    }

    return {{{ cDefs.ALC_TRUE }}};
  },

  // ***************************************************************************
  // ** AL API
  // ***************************************************************************

  // -------------------------------------------------------
  // -- AL Resources
  // -------------------------------------------------------

  alGenBuffers__proxy: 'sync',
  alGenBuffers: (count, pBufferIds) => {
    if (!AL.currentCtx) {
#if OPENAL_DEBUG
      dbg('alGenBuffers() called without a valid context');
#endif
      return;
    }

    for (var i = 0; i < count; ++i) {
      var buf = {
        deviceId: AL.currentCtx.deviceId,
        id: AL.newId(),
        refCount: 0,
        audioBuf: null,
        frequency: 0,
        bytesPerSample: 2,
        channels: 1,
        length: 0,
      };
      AL.deviceRefCounts[buf.deviceId]++;
      AL.buffers[buf.id] = buf;
      {{{ makeSetValue('pBufferIds', 'i*4', 'buf.id', 'i32') }}};
    }
  },

  alDeleteBuffers__proxy: 'sync',
  alDeleteBuffers: (count, pBufferIds) => {
    if (!AL.currentCtx) {
#if OPENAL_DEBUG
      dbg('alDeleteBuffers() called without a valid context');
#endif
      return;
    }

    for (var i = 0; i < count; ++i) {
      var bufId = {{{ makeGetValue('pBufferIds', 'i*4', 'i32') }}};
      /// Deleting the zero buffer is a legal NOP, so ignore it
      if (bufId === 0) {
        continue;
      }

      // Make sure the buffer index is valid.
      if (!AL.buffers[bufId]) {
#if OPENAL_DEBUG
        dbg('alDeleteBuffers() called with an invalid buffer');
#endif
        AL.currentCtx.err = {{{ cDefs.AL_INVALID_NAME }}};
        return;
      }

      // Make sure the buffer is no longer in use.
      if (AL.buffers[bufId].refCount) {
#if OPENAL_DEBUG
        dbg('alDeleteBuffers() called with a used buffer');
#endif
        AL.currentCtx.err = {{{ cDefs.AL_INVALID_OPERATION }}};
        return;
      }
    }

    for (var i = 0; i < count; ++i) {
      var bufId = {{{ makeGetValue('pBufferIds', 'i*4', 'i32') }}};
      if (bufId === 0) {
        continue;
      }

      AL.deviceRefCounts[AL.buffers[bufId].deviceId]--;
      delete AL.buffers[bufId];
      AL.freeIds.push(bufId);
    }
  },

  alGenSources__proxy: 'sync',
  alGenSources: (count, pSourceIds) => {
    if (!AL.currentCtx) {
#if OPENAL_DEBUG
      dbg('alGenSources() called without a valid context');
#endif
      return;
    }
    for (var i = 0; i < count; ++i) {
      var gain = AL.currentCtx.audioCtx.createGain();
      gain.connect(AL.currentCtx.gain);
      var src = {
        context: AL.currentCtx,
        id: AL.newId(),
        type: 0x1030 /* AL_UNDETERMINED */,
        state: {{{ cDefs.AL_INITIAL }}},
        bufQueue: [AL.buffers[0]],
        audioQueue: [],
        looping: false,
        pitch: 1.0,
        dopplerShift: 1.0,
        gain,
        minGain: 0.0,
        maxGain: 1.0,
        panner: null,
        bufsProcessed: 0,
        bufStartTime: Number.NEGATIVE_INFINITY,
        bufOffset: 0.0,
        relative: false,
        refDistance: 1.0,
        maxDistance: 3.40282e38 /* FLT_MAX */,
        rolloffFactor: 1.0,
        position: [0.0, 0.0, 0.0],
        velocity: [0.0, 0.0, 0.0],
        direction: [0.0, 0.0, 0.0],
        coneOuterGain: 0.0,
        coneInnerAngle: 360.0,
        coneOuterAngle: 360.0,
        distanceModel: 0xd002 /* AL_INVERSE_DISTANCE_CLAMPED */,
        spatialize: 2 /* AL_AUTO_SOFT */,

        get playbackRate() {
          return this.pitch * this.dopplerShift;
        }
      };
      AL.currentCtx.sources[src.id] = src;
      {{{ makeSetValue('pSourceIds', 'i*4', 'src.id', 'i32') }}};
    }
  },

  alDeleteSources__deps: ['alSourcei'],
  alDeleteSources__proxy: 'sync',
  alDeleteSources: (count, pSourceIds) => {
    if (!AL.currentCtx) {
#if OPENAL_DEBUG
      dbg('alDeleteSources() called without a valid context');
#endif
      return;
    }

    for (var i = 0; i < count; ++i) {
      var srcId = {{{ makeGetValue('pSourceIds', 'i*4', 'i32') }}};
      if (!AL.currentCtx.sources[srcId]) {
#if OPENAL_DEBUG
        dbg('alDeleteSources() called with an invalid source');
#endif
        AL.currentCtx.err = {{{ cDefs.AL_INVALID_NAME }}};
        return;
      }
    }

    for (var i = 0; i < count; ++i) {
      var srcId = {{{ makeGetValue('pSourceIds', 'i*4', 'i32') }}};
      AL.setSourceState(AL.currentCtx.sources[srcId], {{{ cDefs.AL_STOPPED }}});
      _alSourcei(srcId, 0x1009 /* AL_BUFFER */, 0);
      delete AL.currentCtx.sources[srcId];
      AL.freeIds.push(srcId);
    }
  },

  // -------------------------------------------------------
  // --- AL Context State
  // -------------------------------------------------------

  alGetError__proxy: 'sync',
  alGetError: () => {
    if (!AL.currentCtx) {
      return {{{ cDefs.AL_INVALID_OPERATION }}};
    }
    // Reset error on get.
    var err = AL.currentCtx.err;
    AL.currentCtx.err = {{{ cDefs.AL_NO_ERROR }}};
    return err;
  },

  alIsExtensionPresent__proxy: 'sync',
  alIsExtensionPresent: (pExtName) => {
    var name = UTF8ToString(pExtName);

    return AL.AL_EXTENSIONS[name] ? 1 : 0;
  },

  alGetEnumValue__proxy: 'sync',
  alGetEnumValue: (pEnumName) => {
    if (!AL.currentCtx) {
#if OPENAL_DEBUG
      dbg('alGetEnumValue() called without a valid context');
#endif
      return 0;
    }

    if (!pEnumName) {
#if OPENAL_DEBUG
      dbg('alGetEnumValue() called with null pointer');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
      return {{{ cDefs.AL_NONE }}};
    }
    var name = UTF8ToString(pEnumName);

    switch (name) {
    // Spec doesn't clearly state that alGetEnumValue() is required to
    // support _only_ extension tokens.
    // We should probably follow OpenAL-Soft's example and support all
    // of the names we know.
    // See http://repo.or.cz/openal-soft.git/blob/HEAD:/Alc/ALc.c
    case 'AL_BITS': return 0x2002;
    case 'AL_BUFFER': return 0x1009;
    case 'AL_BUFFERS_PROCESSED': return 0x1016;
    case 'AL_BUFFERS_QUEUED': return 0x1015;
    case 'AL_BYTE_OFFSET': return 0x1026;
    case 'AL_CHANNELS': return 0x2003;
    case 'AL_CONE_INNER_ANGLE': return 0x1001;
    case 'AL_CONE_OUTER_ANGLE': return 0x1002;
    case 'AL_CONE_OUTER_GAIN': return 0x1022;
    case 'AL_DIRECTION': return 0x1005;
    case 'AL_DISTANCE_MODEL': return 0xD000;
    case 'AL_DOPPLER_FACTOR': return 0xC000;
    case 'AL_DOPPLER_VELOCITY': return 0xC001;
    case 'AL_EXPONENT_DISTANCE': return 0xD005;
    case 'AL_EXPONENT_DISTANCE_CLAMPED': return 0xD006;
    case 'AL_EXTENSIONS': return 0xB004;
    case 'AL_FORMAT_MONO16': return 0x1101;
    case 'AL_FORMAT_MONO8': return 0x1100;
    case 'AL_FORMAT_STEREO16': return 0x1103;
    case 'AL_FORMAT_STEREO8': return 0x1102;
    case 'AL_FREQUENCY': return 0x2001;
    case 'AL_GAIN': return 0x100A;
    case 'AL_INITIAL': return 0x1011;
    case 'AL_INVALID': return -1;
    case 'AL_ILLEGAL_ENUM': // fallthrough
    case 'AL_INVALID_ENUM': return 0xA002;
    case 'AL_INVALID_NAME': return 0xA001;
    case 'AL_ILLEGAL_COMMAND': // fallthrough
    case 'AL_INVALID_OPERATION': return 0xA004;
    case 'AL_INVALID_VALUE': return 0xA003;
    case 'AL_INVERSE_DISTANCE': return 0xD001;
    case 'AL_INVERSE_DISTANCE_CLAMPED': return 0xD002;
    case 'AL_LINEAR_DISTANCE': return 0xD003;
    case 'AL_LINEAR_DISTANCE_CLAMPED': return 0xD004;
    case 'AL_LOOPING': return 0x1007;
    case 'AL_MAX_DISTANCE': return 0x1023;
    case 'AL_MAX_GAIN': return 0x100E;
    case 'AL_MIN_GAIN': return 0x100D;
    case 'AL_NONE': return 0;
    case 'AL_NO_ERROR': return 0;
    case 'AL_ORIENTATION': return 0x100F;
    case 'AL_OUT_OF_MEMORY': return 0xA005;
    case 'AL_PAUSED': return 0x1013;
    case 'AL_PENDING': return 0x2011;
    case 'AL_PITCH': return 0x1003;
    case 'AL_PLAYING': return 0x1012;
    case 'AL_POSITION': return 0x1004;
    case 'AL_PROCESSED': return 0x2012;
    case 'AL_REFERENCE_DISTANCE': return 0x1020;
    case 'AL_RENDERER': return 0xB003;
    case 'AL_ROLLOFF_FACTOR': return 0x1021;
    case 'AL_SAMPLE_OFFSET': return 0x1025;
    case 'AL_SEC_OFFSET': return 0x1024;
    case 'AL_SIZE': return 0x2004;
    case 'AL_SOURCE_RELATIVE': return 0x202;
    case 'AL_SOURCE_STATE': return 0x1010;
    case 'AL_SOURCE_TYPE': return 0x1027;
    case 'AL_SPEED_OF_SOUND': return 0xC003;
    case 'AL_STATIC': return 0x1028;
    case 'AL_STOPPED': return 0x1014;
    case 'AL_STREAMING': return 0x1029;
    case 'AL_UNDETERMINED': return 0x1030;
    case 'AL_UNUSED': return 0x2010;
    case 'AL_VELOCITY': return 0x1006;
    case 'AL_VENDOR': return 0xB001;
    case 'AL_VERSION': return 0xB002;

    /* Extensions */
    case 'AL_AUTO_SOFT': return 0x0002;
    case 'AL_SOURCE_DISTANCE_MODEL': return 0x200;
    case 'AL_SOURCE_SPATIALIZE_SOFT': return 0x1214;
    case 'AL_LOOP_POINTS_SOFT': return 0x2015;
    case 'AL_BYTE_LENGTH_SOFT': return 0x2009;
    case 'AL_SAMPLE_LENGTH_SOFT': return 0x200A;
    case 'AL_SEC_LENGTH_SOFT': return 0x200B;
    case 'AL_FORMAT_MONO_FLOAT32': return 0x10010;
    case 'AL_FORMAT_STEREO_FLOAT32': return 0x10011;

    default:
#if OPENAL_DEBUG
      dbg(`No value for '${name}' is known by alGetEnumValue()`);
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
      return 0;
    }
  },

  alGetString__proxy: 'sync',
  alGetString__deps: ['$stringToNewUTF8'],
  alGetString: (param) => {
    if (AL.stringCache[param]) {
      return AL.stringCache[param];
    }

    var ret;
    switch (param) {
    case {{{ cDefs.AL_NO_ERROR }}}:
      ret = 'No Error';
      break;
    case {{{ cDefs.AL_INVALID_NAME }}}:
      ret = 'Invalid Name';
      break;
    case {{{ cDefs.AL_INVALID_ENUM }}}:
      ret = 'Invalid Enum';
      break;
    case {{{ cDefs.AL_INVALID_VALUE }}}:
      ret = 'Invalid Value';
      break;
    case {{{ cDefs.AL_INVALID_OPERATION }}}:
      ret = 'Invalid Operation';
      break;
    case 0xA005 /* AL_OUT_OF_MEMORY */:
      ret = 'Out of Memory';
      break;
    case 0xB001 /* AL_VENDOR */:
      ret = 'Emscripten';
      break;
    case 0xB002 /* AL_VERSION */:
      ret = '1.1';
      break;
    case 0xB003 /* AL_RENDERER */:
      ret = 'WebAudio';
      break;
    case 0xB004 /* AL_EXTENSIONS */:
      ret = Object.keys(AL.AL_EXTENSIONS).join(' ');
      break;
    default:
      if (AL.currentCtx) {
        AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
      } else {
  #if OPENAL_DEBUG
        dbg('alGetString() called without a valid context');
  #endif
      }
      return 0;
    }

    ret = stringToNewUTF8(ret);
    AL.stringCache[param] = ret;
    return ret;
  },

  alEnable__proxy: 'sync',
  alEnable: (param) => {
    if (!AL.currentCtx) {
#if OPENAL_DEBUG
      dbg('alEnable() called without a valid context');
#endif
      return;
    }
    switch (param) {
    case 0x200 /* AL_SOURCE_DISTANCE_MODEL */:
      AL.currentCtx.sourceDistanceModel = true;
      AL.updateContextGlobal(AL.currentCtx);
      break;
    default:
#if OPENAL_DEBUG
      dbg(`alEnable() with param ${ptrToString(param)} not implemented yet`);
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
      return;
    }
  },

  alDisable__proxy: 'sync',
  alDisable: (param) => {
    if (!AL.currentCtx) {
#if OPENAL_DEBUG
      dbg('alDisable() called without a valid context');
#endif
      return;
    }
    switch (param) {
    case 0x200 /* AL_SOURCE_DISTANCE_MODEL */:
      AL.currentCtx.sourceDistanceModel = false;
      AL.updateContextGlobal(AL.currentCtx);
      break;
    default:
#if OPENAL_DEBUG
      dbg(`alDisable() with param ${ptrToString(param)} not implemented yet`);
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
      return;
    }
  },

  alIsEnabled__proxy: 'sync',
  alIsEnabled: (param) => {
    if (!AL.currentCtx) {
#if OPENAL_DEBUG
      dbg('alIsEnabled() called without a valid context');
#endif
      return 0;
    }
    switch (param) {
    case 0x200 /* AL_SOURCE_DISTANCE_MODEL */:
      return AL.currentCtx.sourceDistanceModel ? {{{ cDefs.AL_FALSE }}} : {{{ cDefs.AL_TRUE }}};
    default:
#if OPENAL_DEBUG
      dbg(`alIsEnabled() with param ${ptrToString(param)} not implemented yet`);
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
      return 0;
    }
  },

  alGetDouble__proxy: 'sync',
  alGetDouble: (param) => {
    var val = AL.getGlobalParam('alGetDouble', param);
    if (val === null) {
      return 0.0;
    }

    switch (param) {
    case {{{ cDefs.AL_DOPPLER_FACTOR }}}:
    case {{{ cDefs.AL_SPEED_OF_SOUND }}}:
    case {{{ cDefs.AL_DISTANCE_MODEL }}}:
      return val;
    default:
#if OPENAL_DEBUG
      dbg(`alGetDouble(): param ${ptrToString(param)} has wrong signature`);
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
      return 0.0;
    }
  },

  alGetDoublev__proxy: 'sync',
  alGetDoublev: (param, pValues) => {
    var val = AL.getGlobalParam('alGetDoublev', param);
    // Silently ignore null destinations, as per the spec for global state functions
    if (val === null || !pValues) {
      return;
    }

    switch (param) {
    case {{{ cDefs.AL_DOPPLER_FACTOR }}}:
    case {{{ cDefs.AL_SPEED_OF_SOUND }}}:
    case {{{ cDefs.AL_DISTANCE_MODEL }}}:
      {{{ makeSetValue('pValues', '0', 'val', 'double') }}};
      break;
    default:
#if OPENAL_DEBUG
      dbg(`alGetDoublev(): param ${ptrToString(param)} has wrong signature`);
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
      return;
    }
  },

  alGetFloat__proxy: 'sync',
  alGetFloat: (param) => {
    var val = AL.getGlobalParam('alGetFloat', param);
    if (val === null) {
      return 0.0;
    }

    switch (param) {
    case {{{ cDefs.AL_DOPPLER_FACTOR }}}:
    case {{{ cDefs.AL_SPEED_OF_SOUND }}}:
    case {{{ cDefs.AL_DISTANCE_MODEL }}}:
      return val;
    default:
#if OPENAL_DEBUG
      dbg(`alGetFloat(): param ${ptrToString(param)} has wrong signature`);
#endif
      return 0.0;
    }
  },

  alGetFloatv__proxy: 'sync',
  alGetFloatv: (param, pValues) => {
    var val = AL.getGlobalParam('alGetFloatv', param);
    // Silently ignore null destinations, as per the spec for global state functions
    if (val === null || !pValues) {
      return;
    }

    switch (param) {
    case {{{ cDefs.AL_DOPPLER_FACTOR }}}:
    case {{{ cDefs.AL_SPEED_OF_SOUND }}}:
    case {{{ cDefs.AL_DISTANCE_MODEL }}}:
      {{{ makeSetValue('pValues', '0', 'val', 'float') }}};
      break;
    default:
#if OPENAL_DEBUG
      dbg(`alGetFloatv(): param ${ptrToString(param)} has wrong signature`);
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
      return;
    }
  },

  alGetInteger__proxy: 'sync',
  alGetInteger: (param) => {
    var val = AL.getGlobalParam('alGetInteger', param);
    if (val === null) {
      return 0;
    }

    switch (param) {
    case {{{ cDefs.AL_DOPPLER_FACTOR }}}:
    case {{{ cDefs.AL_SPEED_OF_SOUND }}}:
    case {{{ cDefs.AL_DISTANCE_MODEL }}}:
      return val;
    default:
#if OPENAL_DEBUG
      dbg(`alGetInteger(): param ${ptrToString(param)} has wrong signature`);
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
      return 0;
    }
  },

  alGetIntegerv__proxy: 'sync',
  alGetIntegerv: (param, pValues) => {
    var val = AL.getGlobalParam('alGetIntegerv', param);
    // Silently ignore null destinations, as per the spec for global state functions
    if (val === null || !pValues) {
      return;
    }

    switch (param) {
    case {{{ cDefs.AL_DOPPLER_FACTOR }}}:
    case {{{ cDefs.AL_SPEED_OF_SOUND }}}:
    case {{{ cDefs.AL_DISTANCE_MODEL }}}:
      {{{ makeSetValue('pValues', '0', 'val', 'i32') }}};
      break;
    default:
#if OPENAL_DEBUG
      dbg(`alGetIntegerv(): param ${ptrToString(param)} has wrong signature`);
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
      return;
    }
  },

  alGetBoolean__proxy: 'sync',
  alGetBoolean: (param) => {
    var val = AL.getGlobalParam('alGetBoolean', param);
    if (val === null) {
      return {{{ cDefs.AL_FALSE }}};
    }

    switch (param) {
    case {{{ cDefs.AL_DOPPLER_FACTOR }}}:
    case {{{ cDefs.AL_SPEED_OF_SOUND }}}:
    case {{{ cDefs.AL_DISTANCE_MODEL }}}:
      return val !== 0 ? {{{ cDefs.AL_TRUE }}} : {{{ cDefs.AL_FALSE }}};
    default:
#if OPENAL_DEBUG
      dbg(`alGetBoolean(): param ${ptrToString(param)} has wrong signature`);
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
      return {{{ cDefs.AL_FALSE }}};
    }
  },

  alGetBooleanv__proxy: 'sync',
  alGetBooleanv: (param, pValues) => {
    var val = AL.getGlobalParam('alGetBooleanv', param);
    // Silently ignore null destinations, as per the spec for global state functions
    if (val === null || !pValues) {
      return;
    }

    switch (param) {
    case {{{ cDefs.AL_DOPPLER_FACTOR }}}:
    case {{{ cDefs.AL_SPEED_OF_SOUND }}}:
    case {{{ cDefs.AL_DISTANCE_MODEL }}}:
      {{{ makeSetValue('pValues', '0', 'val', 'i8') }}};
      break;
    default:
#if OPENAL_DEBUG
      dbg(`alGetBooleanv(): param ${ptrToString(param)} has wrong signature`);
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
      return;
    }
  },

  alDistanceModel__proxy: 'sync',
  alDistanceModel: (model) => {
    AL.setGlobalParam('alDistanceModel', {{{ cDefs.AL_DISTANCE_MODEL }}}, model);
  },

  alSpeedOfSound__proxy: 'sync',
  alSpeedOfSound: (value) => {
    AL.setGlobalParam('alSpeedOfSound', {{{ cDefs.AL_SPEED_OF_SOUND }}}, value);
  },

  alDopplerFactor__proxy: 'sync',
  alDopplerFactor: (value) => {
    AL.setGlobalParam('alDopplerFactor', {{{ cDefs.AL_DOPPLER_FACTOR }}}, value);
  },

  // http://openal.996291.n3.nabble.com/alSpeedOfSound-or-alDopperVelocity-tp1960.html
  // alDopplerVelocity() sets a multiplier for the speed of sound.
  // It's deprecated since it's equivalent to directly calling
  // alSpeedOfSound() with an appropriately premultiplied value.
  alDopplerVelocity__proxy: 'sync',
  alDopplerVelocity: (value) => {
    warnOnce('alDopplerVelocity() is deprecated, and only kept for compatibility with OpenAL 1.0. Use alSpeedOfSound() instead.');
    if (!AL.currentCtx) {
#if OPENAL_DEBUG
      dbg('alDopplerVelocity() called without a valid context');
#endif
      return;
    }
    if (value <= 0) { // Negative or zero values are disallowed
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
      return;
    }
  },

  // -------------------------------------------------------
  // -- AL Listener State
  // -------------------------------------------------------

  alGetListenerf__proxy: 'sync',
  alGetListenerf: (param, pValue) => {
    var val = AL.getListenerParam('alGetListenerf', param);
    if (val === null) {
      return;
    }
    if (!pValue) {
#if OPENAL_DEBUG
      dbg('alGetListenerf() called with a null pointer');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
      return;
    }

    switch (param) {
    case {{{ cDefs.AL_GAIN }}}:
      {{{ makeSetValue('pValue', '0', 'val', 'float') }}};
      break;
    default:
#if OPENAL_DEBUG
      dbg(`alGetListenerf(): param ${ptrToString(param)} has wrong signature`);
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
      return;
    }
  },

  alGetListener3f__proxy: 'sync',
  alGetListener3f: (param, pValue0, pValue1, pValue2) => {
    var val = AL.getListenerParam('alGetListener3f', param);
    if (val === null) {
      return;
    }
    if (!pValue0 || !pValue1 || !pValue2) {
#if OPENAL_DEBUG
      dbg('alGetListener3f() called with a null pointer');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
      return;
    }

    switch (param) {
    case {{{ cDefs.AL_POSITION }}}:
    case {{{ cDefs.AL_VELOCITY }}}:
      {{{ makeSetValue('pValue0', '0', 'val[0]', 'float') }}};
      {{{ makeSetValue('pValue1', '0', 'val[1]', 'float') }}};
      {{{ makeSetValue('pValue2', '0', 'val[2]', 'float') }}};
      break;
    default:
#if OPENAL_DEBUG
      dbg(`alGetListener3f(): param ${ptrToString(param)} has wrong signature`);
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
      return;
    }
  },

  alGetListenerfv__proxy: 'sync',
  alGetListenerfv: (param, pValues) => {
    var val = AL.getListenerParam('alGetListenerfv', param);
    if (val === null) {
      return;
    }
    if (!pValues) {
#if OPENAL_DEBUG
      dbg('alGetListenerfv() called with a null pointer');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
      return;
    }

    switch (param) {
    case {{{ cDefs.AL_POSITION }}}:
    case {{{ cDefs.AL_VELOCITY }}}:
      {{{ makeSetValue('pValues', '0', 'val[0]', 'float') }}};
      {{{ makeSetValue('pValues', '4', 'val[1]', 'float') }}};
      {{{ makeSetValue('pValues', '8', 'val[2]', 'float') }}};
      break;
    case {{{ cDefs.AL_ORIENTATION }}}:
      {{{ makeSetValue('pValues', '0', 'val[0]', 'float') }}};
      {{{ makeSetValue('pValues', '4', 'val[1]', 'float') }}};
      {{{ makeSetValue('pValues', '8', 'val[2]', 'float') }}};
      {{{ makeSetValue('pValues', '12', 'val[3]', 'float') }}};
      {{{ makeSetValue('pValues', '16', 'val[4]', 'float') }}};
      {{{ makeSetValue('pValues', '20', 'val[5]', 'float') }}};
      break;
    default:
#if OPENAL_DEBUG
      dbg(`alGetListenerfv(): param ${ptrToString(param)} has wrong signature`);
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
      return;
    }
  },

  alGetListeneri__proxy: 'sync',
  alGetListeneri: (param, pValue) => {
    var val = AL.getListenerParam('alGetListeneri', param);
    if (val === null) {
      return;
    }
    if (!pValue) {
#if OPENAL_DEBUG
      dbg('alGetListeneri() called with a null pointer');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
      return;
    }

#if OPENAL_DEBUG
    dbg(`alGetListeneri(): param ${ptrToString(param)} has wrong signature`);
#endif
    AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
  },

  alGetListener3i__proxy: 'sync',
  alGetListener3i: (param, pValue0, pValue1, pValue2) => {
    var val = AL.getListenerParam('alGetListener3i', param);
    if (val === null) {
      return;
    }
    if (!pValue0 || !pValue1 || !pValue2) {
#if OPENAL_DEBUG
      dbg('alGetListener3i() called with a null pointer');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
      return;
    }

    switch (param) {
    case {{{ cDefs.AL_POSITION }}}:
    case {{{ cDefs.AL_VELOCITY }}}:
      {{{ makeSetValue('pValue0', '0', 'val[0]', 'i32') }}};
      {{{ makeSetValue('pValue1', '0', 'val[1]', 'i32') }}};
      {{{ makeSetValue('pValue2', '0', 'val[2]', 'i32') }}};
      break;
    default:
#if OPENAL_DEBUG
      dbg(`alGetListener3i(): param ${ptrToString(param)} has wrong signature`);
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
      return;
    }
  },

  alGetListeneriv__proxy: 'sync',
  alGetListeneriv: (param, pValues) => {
    var val = AL.getListenerParam('alGetListeneriv', param);
    if (val === null) {
      return;
    }
    if (!pValues) {
#if OPENAL_DEBUG
      dbg('alGetListeneriv() called with a null pointer');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
      return;
    }

    switch (param) {
    case {{{ cDefs.AL_POSITION }}}:
    case {{{ cDefs.AL_VELOCITY }}}:
      {{{ makeSetValue('pValues', '0', 'val[0]', 'i32') }}};
      {{{ makeSetValue('pValues', '4', 'val[1]', 'i32') }}};
      {{{ makeSetValue('pValues', '8', 'val[2]', 'i32') }}};
      break;
    case {{{ cDefs.AL_ORIENTATION }}}:
      {{{ makeSetValue('pValues', '0', 'val[0]', 'i32') }}};
      {{{ makeSetValue('pValues', '4', 'val[1]', 'i32') }}};
      {{{ makeSetValue('pValues', '8', 'val[2]', 'i32') }}};
      {{{ makeSetValue('pValues', '12', 'val[3]', 'i32') }}};
      {{{ makeSetValue('pValues', '16', 'val[4]', 'i32') }}};
      {{{ makeSetValue('pValues', '20', 'val[5]', 'i32') }}};
      break;
    default:
#if OPENAL_DEBUG
      dbg(`alGetListeneriv(): param ${ptrToString(param)} has wrong signature`);
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
      return;
    }
  },

  alListenerf__proxy: 'sync',
  alListenerf: (param, value) => {
    switch (param) {
    case {{{ cDefs.AL_GAIN }}}:
      AL.setListenerParam('alListenerf', param, value);
      break;
    default:
      AL.setListenerParam('alListenerf', param, null);
      break;
    }
  },

  alListener3f__proxy: 'sync',
  alListener3f: (param, value0, value1, value2) => {
    switch (param) {
    case {{{ cDefs.AL_POSITION }}}:
    case {{{ cDefs.AL_VELOCITY }}}:
      AL.paramArray[0] = value0;
      AL.paramArray[1] = value1;
      AL.paramArray[2] = value2;
      AL.setListenerParam('alListener3f', param, AL.paramArray);
      break;
    default:
      AL.setListenerParam('alListener3f', param, null);
      break;
    }
  },

  alListenerfv__proxy: 'sync',
  alListenerfv: (param, pValues) => {
    if (!AL.currentCtx) {
#if OPENAL_DEBUG
      dbg('alListenerfv() called without a valid context');
#endif
      return;
    }
    if (!pValues) {
#if OPENAL_DEBUG
      dbg('alListenerfv() called with a null pointer');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
      return;
    }

    switch (param) {
    case {{{ cDefs.AL_POSITION }}}:
    case {{{ cDefs.AL_VELOCITY }}}:
      AL.paramArray[0] = {{{ makeGetValue('pValues', '0', 'float') }}};
      AL.paramArray[1] = {{{ makeGetValue('pValues', '4', 'float') }}};
      AL.paramArray[2] = {{{ makeGetValue('pValues', '8', 'float') }}};
      AL.setListenerParam('alListenerfv', param, AL.paramArray);
      break;
    case {{{ cDefs.AL_ORIENTATION }}}:
      AL.paramArray[0] = {{{ makeGetValue('pValues', '0', 'float') }}};
      AL.paramArray[1] = {{{ makeGetValue('pValues', '4', 'float') }}};
      AL.paramArray[2] = {{{ makeGetValue('pValues', '8', 'float') }}};
      AL.paramArray[3] = {{{ makeGetValue('pValues', '12', 'float') }}};
      AL.paramArray[4] = {{{ makeGetValue('pValues', '16', 'float') }}};
      AL.paramArray[5] = {{{ makeGetValue('pValues', '20', 'float') }}};
      AL.setListenerParam('alListenerfv', param, AL.paramArray);
      break;
    default:
      AL.setListenerParam('alListenerfv', param, null);
      break;
    }
  },

  alListeneri__proxy: 'sync',
  alListeneri: (param, value) => {
    AL.setListenerParam('alListeneri', param, null);
  },

  alListener3i__proxy: 'sync',
  alListener3i: (param, value0, value1, value2) => {
    switch (param) {
    case {{{ cDefs.AL_POSITION }}}:
    case {{{ cDefs.AL_VELOCITY }}}:
      AL.paramArray[0] = value0;
      AL.paramArray[1] = value1;
      AL.paramArray[2] = value2;
      AL.setListenerParam('alListener3i', param, AL.paramArray);
      break;
    default:
      AL.setListenerParam('alListener3i', param, null);
      break;
    }
  },

  alListeneriv__proxy: 'sync',
  alListeneriv: (param, pValues) => {
    if (!AL.currentCtx) {
#if OPENAL_DEBUG
      dbg('alListeneriv() called without a valid context');
#endif
      return;
    }
    if (!pValues) {
#if OPENAL_DEBUG
      dbg('alListeneriv() called with a null pointer');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
      return;
    }

    switch (param) {
    case {{{ cDefs.AL_POSITION }}}:
    case {{{ cDefs.AL_VELOCITY }}}:
      AL.paramArray[0] = {{{ makeGetValue('pValues', '0', 'i32') }}};
      AL.paramArray[1] = {{{ makeGetValue('pValues', '4', 'i32') }}};
      AL.paramArray[2] = {{{ makeGetValue('pValues', '8', 'i32') }}};
      AL.setListenerParam('alListeneriv', param, AL.paramArray);
      break;
    case {{{ cDefs.AL_ORIENTATION }}}:
      AL.paramArray[0] = {{{ makeGetValue('pValues', '0', 'i32') }}};
      AL.paramArray[1] = {{{ makeGetValue('pValues', '4', 'i32') }}};
      AL.paramArray[2] = {{{ makeGetValue('pValues', '8', 'i32') }}};
      AL.paramArray[3] = {{{ makeGetValue('pValues', '12', 'i32') }}};
      AL.paramArray[4] = {{{ makeGetValue('pValues', '16', 'i32') }}};
      AL.paramArray[5] = {{{ makeGetValue('pValues', '20', 'i32') }}};
      AL.setListenerParam('alListeneriv', param, AL.paramArray);
      break;
    default:
      AL.setListenerParam('alListeneriv', param, null);
      break;
    }
  },

  // -------------------------------------------------------
  // -- AL Buffer State
  // -------------------------------------------------------

  alIsBuffer__proxy: 'sync',
  alIsBuffer: (bufferId) => {
    if (!AL.currentCtx) {
      return false;
    }
    if (bufferId > AL.buffers.length) {
      return false;
    }

    if (!AL.buffers[bufferId]) {
      return false;
    }
    return true;
  },

  alBufferData__proxy: 'sync',
  alBufferData: (bufferId, format, pData, size, freq) => {
    if (!AL.currentCtx) {
#if OPENAL_DEBUG
      dbg('alBufferData() called without a valid context');
#endif
      return;
    }
    var buf = AL.buffers[bufferId];
    if (!buf) {
#if OPENAL_DEBUG
      dbg('alBufferData() called with an invalid buffer');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
      return;
    }
    if (freq <= 0) {
#if OPENAL_DEBUG
      dbg('alBufferData() called with an invalid frequency');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
      return;
    }

    var audioBuf = null;
    try {
      switch (format) {
      case 0x1100 /* AL_FORMAT_MONO8 */:
        if (size > 0) {
          audioBuf = AL.currentCtx.audioCtx.createBuffer(1, size, freq);
          var channel0 = audioBuf.getChannelData(0);
          for (var i = 0; i < size; ++i) {
            channel0[i] = HEAPU8[pData++] * 0.0078125 /* 1/128 */ - 1.0;
          }
        }
        buf.bytesPerSample = 1;
        buf.channels = 1;
        buf.length = size;
        break;
      case 0x1101 /* AL_FORMAT_MONO16 */:
        if (size > 0) {
          audioBuf = AL.currentCtx.audioCtx.createBuffer(1, size >> 1, freq);
          var channel0 = audioBuf.getChannelData(0);
          pData >>= 1;
          for (var i = 0; i < size >> 1; ++i) {
            channel0[i] = HEAP16[pData++] * 0.000030517578125 /* 1/32768 */;
          }
        }
        buf.bytesPerSample = 2;
        buf.channels = 1;
        buf.length = size >> 1;
        break;
      case 0x1102 /* AL_FORMAT_STEREO8 */:
        if (size > 0) {
          audioBuf = AL.currentCtx.audioCtx.createBuffer(2, size >> 1, freq);
          var channel0 = audioBuf.getChannelData(0);
          var channel1 = audioBuf.getChannelData(1);
          for (var i = 0; i < size >> 1; ++i) {
            channel0[i] = HEAPU8[pData++] * 0.0078125 /* 1/128 */ - 1.0;
            channel1[i] = HEAPU8[pData++] * 0.0078125 /* 1/128 */ - 1.0;
          }
        }
        buf.bytesPerSample = 1;
        buf.channels = 2;
        buf.length = size >> 1;
        break;
      case 0x1103 /* AL_FORMAT_STEREO16 */:
        if (size > 0) {
          audioBuf = AL.currentCtx.audioCtx.createBuffer(2, size >> 2, freq);
          var channel0 = audioBuf.getChannelData(0);
          var channel1 = audioBuf.getChannelData(1);
          pData >>= 1;
          for (var i = 0; i < size >> 2; ++i) {
            channel0[i] = HEAP16[pData++] * 0.000030517578125 /* 1/32768 */;
            channel1[i] = HEAP16[pData++] * 0.000030517578125 /* 1/32768 */;
          }
        }
        buf.bytesPerSample = 2;
        buf.channels = 2;
        buf.length = size >> 2;
        break;
      case 0x10010 /* AL_FORMAT_MONO_FLOAT32 */:
        if (size > 0) {
          audioBuf = AL.currentCtx.audioCtx.createBuffer(1, size >> 2, freq);
          var channel0 = audioBuf.getChannelData(0);
          pData >>= 2;
          for (var i = 0; i < size >> 2; ++i) {
            channel0[i] = HEAPF32[pData++];
          }
        }
        buf.bytesPerSample = 4;
        buf.channels = 1;
        buf.length = size >> 2;
        break;
      case 0x10011 /* AL_FORMAT_STEREO_FLOAT32 */:
        if (size > 0) {
          audioBuf = AL.currentCtx.audioCtx.createBuffer(2, size >> 3, freq);
          var channel0 = audioBuf.getChannelData(0);
          var channel1 = audioBuf.getChannelData(1);
          pData >>= 2;
          for (var i = 0; i < size >> 3; ++i) {
            channel0[i] = HEAPF32[pData++];
            channel1[i] = HEAPF32[pData++];
          }
        }
        buf.bytesPerSample = 4;
        buf.channels = 2;
        buf.length = size >> 3;
        break;
      default:
#if OPENAL_DEBUG
        dbg(`alBufferData() called with invalid format ${format}`);
#endif
        AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
        return;
      }
      buf.frequency = freq;
      buf.audioBuf = audioBuf;
    } catch (e) {
#if OPENAL_DEBUG
      dbg(`alBufferData() upload failed with an exception ${e}`);
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
      return;
    }
  },

  alGetBufferf__proxy: 'sync',
  alGetBufferf: (bufferId, param, pValue) => {
    var val = AL.getBufferParam('alGetBufferf', bufferId, param);
    if (val === null) {
      return;
    }
    if (!pValue) {
#if OPENAL_DEBUG
      dbg('alGetBufferf() called with a null pointer');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
      return;
    }

#if OPENAL_DEBUG
    dbg(`alGetBufferf(): param ${ptrToString(param)} has wrong signature`);
#endif
    AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
  },

  alGetBuffer3f__proxy: 'sync',
  alGetBuffer3f: (bufferId, param, pValue0, pValue1, pValue2) => {
    var val = AL.getBufferParam('alGetBuffer3f', bufferId, param);
    if (val === null) {
      return;
    }
    if (!pValue0 || !pValue1 || !pValue2) {
#if OPENAL_DEBUG
      dbg('alGetBuffer3f() called with a null pointer');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
      return;
    }

#if OPENAL_DEBUG
    dbg(`alGetBuffer3f(): param ${ptrToString(param)} has wrong signature`);
#endif
    AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
  },

  alGetBufferfv__proxy: 'sync',
  alGetBufferfv: (bufferId, param, pValues) => {
    var val = AL.getBufferParam('alGetBufferfv', bufferId, param);
    if (val === null) {
      return;
    }
    if (!pValues) {
#if OPENAL_DEBUG
      dbg('alGetBufferfv() called with a null pointer');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
      return;
    }

#if OPENAL_DEBUG
    dbg(`alGetBufferfv(): param ${ptrToString(param)} has wrong signature`);
#endif
    AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
  },

  alGetBufferi__proxy: 'sync',
  alGetBufferi: (bufferId, param, pValue) => {
    var val = AL.getBufferParam('alGetBufferi', bufferId, param);
    if (val === null) {
      return;
    }
    if (!pValue) {
#if OPENAL_DEBUG
      dbg('alGetBufferi() called with a null pointer');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
      return;
    }

    switch (param) {
    case 0x2001 /* AL_FREQUENCY */:
    case 0x2002 /* AL_BITS */:
    case 0x2003 /* AL_CHANNELS */:
    case 0x2004 /* AL_SIZE */:
      {{{ makeSetValue('pValue', '0', 'val', 'i32') }}};
      break;
    default:
#if OPENAL_DEBUG
      dbg(`alGetBufferi(): param ${ptrToString(param)} has wrong signature`);
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
      return;
    }
  },

  alGetBuffer3i__proxy: 'sync',
  alGetBuffer3i: (bufferId, param, pValue0, pValue1, pValue2) => {
    var val = AL.getBufferParam('alGetBuffer3i', bufferId, param);
    if (val === null) {
      return;
    }
    if (!pValue0 || !pValue1 || !pValue2) {
#if OPENAL_DEBUG
      dbg('alGetBuffer3i() called with a null pointer');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
      return;
    }

#if OPENAL_DEBUG
    dbg(`alGetBuffer3i(): param ${ptrToString(param)} has wrong signature`);
#endif
    AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
  },

  alGetBufferiv__proxy: 'sync',
  alGetBufferiv: (bufferId, param, pValues) => {
    var val = AL.getBufferParam('alGetBufferiv', bufferId, param);
    if (val === null) {
      return;
    }
    if (!pValues) {
#if OPENAL_DEBUG
      dbg('alGetBufferiv() called with a null pointer');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
      return;
    }

    switch (param) {
    case 0x2001 /* AL_FREQUENCY */:
    case 0x2002 /* AL_BITS */:
    case 0x2003 /* AL_CHANNELS */:
    case 0x2004 /* AL_SIZE */:
      {{{ makeSetValue('pValues', '0', 'val', 'i32') }}};
      break;
    case 0x2015 /* AL_LOOP_POINTS_SOFT */:
      {{{ makeSetValue('pValues', '0', 'val[0]', 'i32') }}};
      {{{ makeSetValue('pValues', '4', 'val[1]', 'i32') }}};
      break;
    default:
#if OPENAL_DEBUG
      dbg(`alGetBufferiv(): param ${ptrToString(param)} has wrong signature`);
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
      return;
    }
  },

  // All of the remaining alBuffer* setters and getters are only of interest
  // to extensions which need them. Core OpenAL alone defines no valid
  // property for these.

  alBufferf__proxy: 'sync',
  alBufferf: (bufferId, param, value) => {
    AL.setBufferParam('alBufferf', bufferId, param, null);
  },

  alBuffer3f__proxy: 'sync',
  alBuffer3f: (bufferId, param, value0, value1, value2) => {
    AL.setBufferParam('alBuffer3f', bufferId, param, null);
  },

  alBufferfv__proxy: 'sync',
  alBufferfv: (bufferId, param, pValues) => {
    if (!AL.currentCtx) {
#if OPENAL_DEBUG
      dbg('alBufferfv() called without a valid context');
#endif
      return;
    }
    if (!pValues) {
#if OPENAL_DEBUG
      dbg('alBufferfv() called with a null pointer');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
      return;
    }

    AL.setBufferParam('alBufferfv', bufferId, param, null);
  },

  alBufferi__proxy: 'sync',
  alBufferi: (bufferId, param, value) => {
    AL.setBufferParam('alBufferi', bufferId, param, null);
  },

  alBuffer3i__proxy: 'sync',
  alBuffer3i: (bufferId, param, value0, value1, value2) => {
    AL.setBufferParam('alBuffer3i', bufferId, param, null);
  },

  alBufferiv__proxy: 'sync',
  alBufferiv: (bufferId, param, pValues) => {
    if (!AL.currentCtx) {
#if OPENAL_DEBUG
      dbg('alBufferiv() called without a valid context');
#endif
      return;
    }
    if (!pValues) {
#if OPENAL_DEBUG
      dbg('alBufferiv() called with a null pointer');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
      return;
    }

    switch (param) {
    case 0x2015 /* AL_LOOP_POINTS_SOFT */:
      AL.paramArray[0] = {{{ makeGetValue('pValues', '0', 'i32') }}};
      AL.paramArray[1] = {{{ makeGetValue('pValues', '4', 'i32') }}};
      AL.setBufferParam('alBufferiv', bufferId, param, AL.paramArray);
      break;
    default:
      AL.setBufferParam('alBufferiv', bufferId, param, null);
      break;
    }
  },

  // -------------------------------------------------------
  // -- AL Source State
  // -------------------------------------------------------

  alIsSource__proxy: 'sync',
  alIsSource: (sourceId) => {
    if (!AL.currentCtx) {
      return false;
    }

    if (!AL.currentCtx.sources[sourceId]) {
      return false;
    }
    return true;
  },

  alSourceQueueBuffers__proxy: 'sync',
  alSourceQueueBuffers: (sourceId, count, pBufferIds) => {
    if (!AL.currentCtx) {
#if OPENAL_DEBUG
      dbg('alSourceQueueBuffers() called without a valid context');
#endif
      return;
    }
    var src = AL.currentCtx.sources[sourceId];
    if (!src) {
#if OPENAL_DEBUG
      dbg('alSourceQueueBuffers() called with an invalid source');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_NAME }}};
      return;
    }
    if (src.type === {{{ cDefs.AL_STATIC }}}) {
#if OPENAL_DEBUG
      dbg('alSourceQueueBuffers() called while a static buffer is bound');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_OPERATION }}};
      return;
    }

    if (count === 0) {
      return;
    }

    // Find the first non-zero buffer in the queue to determine the proper format
    var templateBuf = AL.buffers[0];
    for (var buf of src.bufQueue) {
      if (buf.id !== 0) {
        templateBuf = buf;
        break;
      }
    }

    for (var i = 0; i < count; ++i) {
      var bufId = {{{ makeGetValue('pBufferIds', 'i*4', 'i32') }}};
      var buf = AL.buffers[bufId];
      if (!buf) {
#if OPENAL_DEBUG
        dbg('alSourceQueueBuffers() called with an invalid buffer');
#endif
        AL.currentCtx.err = {{{ cDefs.AL_INVALID_NAME }}};
        return;
      }

      // Check that the added buffer has the correct format. If the template is the zero buffer, any format is valid.
      if (templateBuf.id !== 0 && (
        buf.frequency !== templateBuf.frequency
        || buf.bytesPerSample !== templateBuf.bytesPerSample
        || buf.channels !== templateBuf.channels)
      ) {
#if OPENAL_DEBUG
        dbg('alSourceQueueBuffers() called with a buffer of different format');
#endif
        AL.currentCtx.err = {{{ cDefs.AL_INVALID_OPERATION }}};
      }
    }

    // If the only buffer in the queue is the zero buffer, clear the queue before we add anything.
    if (src.bufQueue.length === 1 && src.bufQueue[0].id === 0) {
      src.bufQueue.length = 0;
    }

    src.type = 0x1029 /* AL_STREAMING */;
    for (var i = 0; i < count; ++i) {
      var bufId = {{{ makeGetValue('pBufferIds', 'i*4', 'i32') }}};
      var buf = AL.buffers[bufId];
      buf.refCount++;
      src.bufQueue.push(buf);
    }

    // if the source is looping, cancel the schedule so we can reschedule the loop order
    if (src.looping) {
      AL.cancelPendingSourceAudio(src);
    }

    AL.initSourcePanner(src);
    AL.scheduleSourceAudio(src);
  },

  alSourceUnqueueBuffers__proxy: 'sync',
  alSourceUnqueueBuffers: (sourceId, count, pBufferIds) => {
    if (!AL.currentCtx) {
#if OPENAL_DEBUG
      dbg('alSourceUnqueueBuffers() called without a valid context');
#endif
      return;
    }
    var src = AL.currentCtx.sources[sourceId];
    if (!src) {
#if OPENAL_DEBUG
      dbg('alSourceUnqueueBuffers() called with an invalid source');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_NAME }}};
      return;
    }
    if (count > (src.bufQueue.length === 1 && src.bufQueue[0].id === 0 ? 0 : src.bufsProcessed)) {
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
      return;
    }

    if (count === 0) {
      return;
    }

    for (var i = 0; i < count; i++) {
      var buf = src.bufQueue.shift();
      buf.refCount--;
      // Write the buffers index out to the return list.
      {{{ makeSetValue('pBufferIds', 'i*4', 'buf.id', 'i32') }}};
      src.bufsProcessed--;
    }

    /// If the queue is empty, put the zero buffer back in
    if (src.bufQueue.length === 0) {
      src.bufQueue.push(AL.buffers[0]);
    }

    AL.initSourcePanner(src);
    AL.scheduleSourceAudio(src);
  },

  alSourcePlay__proxy: 'sync',
  alSourcePlay: (sourceId) => {
    if (!AL.currentCtx) {
#if OPENAL_DEBUG
      dbg('alSourcePlay() called without a valid context');
#endif
      return;
    }
    var src = AL.currentCtx.sources[sourceId];
    if (!src) {
#if OPENAL_DEBUG
      dbg('alSourcePlay() called with an invalid source');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_NAME }}};
      return;
    }
    AL.setSourceState(src, {{{ cDefs.AL_PLAYING }}});
  },

  alSourcePlayv__proxy: 'sync',
  alSourcePlayv: (count, pSourceIds) => {
    if (!AL.currentCtx) {
#if OPENAL_DEBUG
      dbg('alSourcePlayv() called without a valid context');
#endif
      return;
    }
    if (!pSourceIds) {
#if OPENAL_DEBUG
      dbg('alSourcePlayv() called with null pointer');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
    }
    for (var i = 0; i < count; ++i) {
      if (!AL.currentCtx.sources[{{{ makeGetValue('pSourceIds', 'i*4', 'i32') }}}]) {
#if OPENAL_DEBUG
        dbg('alSourcePlayv() called with an invalid source');
#endif
        AL.currentCtx.err = {{{ cDefs.AL_INVALID_NAME }}};
        return;
      }
    }

    for (var i = 0; i < count; ++i) {
      var srcId = {{{ makeGetValue('pSourceIds', 'i*4', 'i32') }}};
      AL.setSourceState(AL.currentCtx.sources[srcId], {{{ cDefs.AL_PLAYING }}});
    }
  },

  alSourceStop__proxy: 'sync',
  alSourceStop: (sourceId) => {
    if (!AL.currentCtx) {
#if OPENAL_DEBUG
      dbg('alSourceStop() called without a valid context');
#endif
      return;
    }
    var src = AL.currentCtx.sources[sourceId];
    if (!src) {
#if OPENAL_DEBUG
      dbg('alSourceStop() called with an invalid source');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_NAME }}};
      return;
    }
    AL.setSourceState(src, {{{ cDefs.AL_STOPPED }}});
  },

  alSourceStopv__proxy: 'sync',
  alSourceStopv: (count, pSourceIds) => {
    if (!AL.currentCtx) {
#if OPENAL_DEBUG
      dbg('alSourceStopv() called without a valid context');
#endif
      return;
    }
    if (!pSourceIds) {
#if OPENAL_DEBUG
      dbg('alSourceStopv() called with null pointer');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
    }
    for (var i = 0; i < count; ++i) {
      if (!AL.currentCtx.sources[{{{ makeGetValue('pSourceIds', 'i*4', 'i32') }}}]) {
#if OPENAL_DEBUG
        dbg('alSourceStopv() called with an invalid source');
#endif
        AL.currentCtx.err = {{{ cDefs.AL_INVALID_NAME }}};
        return;
      }
    }

    for (var i = 0; i < count; ++i) {
      var srcId = {{{ makeGetValue('pSourceIds', 'i*4', 'i32') }}};
      AL.setSourceState(AL.currentCtx.sources[srcId], {{{ cDefs.AL_STOPPED }}});
    }
  },

  alSourceRewind__proxy: 'sync',
  alSourceRewind: (sourceId) => {
    if (!AL.currentCtx) {
#if OPENAL_DEBUG
      dbg('alSourceRewind() called without a valid context');
#endif
      return;
    }
    var src = AL.currentCtx.sources[sourceId];
    if (!src) {
#if OPENAL_DEBUG
      dbg('alSourceRewind() called with an invalid source');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_NAME }}};
      return;
    }
    // Stop the source first to clear the source queue
    AL.setSourceState(src, {{{ cDefs.AL_STOPPED }}});
    // Now set the state of AL_INITIAL according to the specification
    AL.setSourceState(src, {{{ cDefs.AL_INITIAL }}});
  },

  alSourceRewindv__proxy: 'sync',
  alSourceRewindv: (count, pSourceIds) => {
    if (!AL.currentCtx) {
#if OPENAL_DEBUG
      dbg('alSourceRewindv() called without a valid context');
#endif
      return;
    }
    if (!pSourceIds) {
#if OPENAL_DEBUG
      dbg('alSourceRewindv() called with null pointer');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
    }
    for (var i = 0; i < count; ++i) {
      if (!AL.currentCtx.sources[{{{ makeGetValue('pSourceIds', 'i*4', 'i32') }}}]) {
#if OPENAL_DEBUG
        dbg('alSourceRewindv() called with an invalid source');
#endif
        AL.currentCtx.err = {{{ cDefs.AL_INVALID_NAME }}};
        return;
      }
    }

    for (var i = 0; i < count; ++i) {
      var srcId = {{{ makeGetValue('pSourceIds', 'i*4', 'i32') }}};
      AL.setSourceState(AL.currentCtx.sources[srcId], {{{ cDefs.AL_INITIAL }}});
    }
  },

  alSourcePause__proxy: 'sync',
  alSourcePause: (sourceId) => {
    if (!AL.currentCtx) {
#if OPENAL_DEBUG
      dbg('alSourcePause() called without a valid context');
#endif
      return;
    }
    var src = AL.currentCtx.sources[sourceId];
    if (!src) {
#if OPENAL_DEBUG
      dbg('alSourcePause() called with an invalid source');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_NAME }}};
      return;
    }
    AL.setSourceState(src, {{{ cDefs.AL_PAUSED }}});
  },

  alSourcePausev__proxy: 'sync',
  alSourcePausev: (count, pSourceIds) => {
    if (!AL.currentCtx) {
#if OPENAL_DEBUG
      dbg('alSourcePausev() called without a valid context');
#endif
      return;
    }
    if (!pSourceIds) {
#if OPENAL_DEBUG
      dbg('alSourcePausev() called with null pointer');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
    }
    for (var i = 0; i < count; ++i) {
      if (!AL.currentCtx.sources[{{{ makeGetValue('pSourceIds', 'i*4', 'i32') }}}]) {
#if OPENAL_DEBUG
        dbg('alSourcePausev() called with an invalid source');
#endif
        AL.currentCtx.err = {{{ cDefs.AL_INVALID_NAME }}};
        return;
      }
    }

    for (var i = 0; i < count; ++i) {
      var srcId = {{{ makeGetValue('pSourceIds', 'i*4', 'i32') }}};
      AL.setSourceState(AL.currentCtx.sources[srcId], {{{ cDefs.AL_PAUSED }}});
    }
  },

  alGetSourcef__proxy: 'sync',
  alGetSourcef: (sourceId, param, pValue) => {
    var val = AL.getSourceParam('alGetSourcef', sourceId, param);
    if (val === null) {
      return;
    }
    if (!pValue) {
#if OPENAL_DEBUG
      dbg('alGetSourcef() called with a null pointer');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
      return;
    }

    switch (param) {
    case 0x1001 /* AL_CONE_INNER_ANGLE */:
    case 0x1002 /* AL_CONE_OUTER_ANGLE */:
    case 0x1003 /* AL_PITCH */:
    case {{{ cDefs.AL_GAIN }}}:
    case 0x100D /* AL_MIN_GAIN */:
    case 0x100E /* AL_MAX_GAIN */:
    case 0x1020 /* AL_REFERENCE_DISTANCE */:
    case 0x1021 /* AL_ROLLOFF_FACTOR */:
    case 0x1022 /* AL_CONE_OUTER_GAIN */:
    case 0x1023 /* AL_MAX_DISTANCE */:
    case 0x1024 /* AL_SEC_OFFSET */:
    case 0x1025 /* AL_SAMPLE_OFFSET */:
    case 0x1026 /* AL_BYTE_OFFSET */:
    case 0x200B /* AL_SEC_LENGTH_SOFT */:
      {{{ makeSetValue('pValue', '0', 'val', 'float') }}};
      break;
    default:
#if OPENAL_DEBUG
      dbg(`alGetSourcef(): param ${ptrToString(param)} has wrong signature`);
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
      return;
    }
  },

  alGetSource3f__proxy: 'sync',
  alGetSource3f: (sourceId, param, pValue0, pValue1, pValue2) => {
    var val = AL.getSourceParam('alGetSource3f', sourceId, param);
    if (val === null) {
      return;
    }
    if (!pValue0 || !pValue1 || !pValue2) {
#if OPENAL_DEBUG
      dbg('alGetSource3f() called with a null pointer');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
      return;
    }

    switch (param) {
    case {{{ cDefs.AL_POSITION }}}:
    case {{{ cDefs.AL_DIRECTION }}}:
    case {{{ cDefs.AL_VELOCITY }}}:
      {{{ makeSetValue('pValue0', '0', 'val[0]', 'float') }}};
      {{{ makeSetValue('pValue1', '0', 'val[1]', 'float') }}};
      {{{ makeSetValue('pValue2', '0', 'val[2]', 'float') }}};
      break;
    default:
#if OPENAL_DEBUG
      dbg(`alGetSource3f(): param ${ptrToString(param)} has wrong signature`);
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
      return;
    }
  },

  alGetSourcefv__proxy: 'sync',
  alGetSourcefv: (sourceId, param, pValues) => {
    var val = AL.getSourceParam('alGetSourcefv', sourceId, param);
    if (val === null) {
      return;
    }
    if (!pValues) {
#if OPENAL_DEBUG
      dbg('alGetSourcefv() called with a null pointer');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
      return;
    }

    switch (param) {
    case 0x1001 /* AL_CONE_INNER_ANGLE */:
    case 0x1002 /* AL_CONE_OUTER_ANGLE */:
    case 0x1003 /* AL_PITCH */:
    case {{{ cDefs.AL_GAIN }}}:
    case 0x100D /* AL_MIN_GAIN */:
    case 0x100E /* AL_MAX_GAIN */:
    case 0x1020 /* AL_REFERENCE_DISTANCE */:
    case 0x1021 /* AL_ROLLOFF_FACTOR */:
    case 0x1022 /* AL_CONE_OUTER_GAIN */:
    case 0x1023 /* AL_MAX_DISTANCE */:
    case 0x1024 /* AL_SEC_OFFSET */:
    case 0x1025 /* AL_SAMPLE_OFFSET */:
    case 0x1026 /* AL_BYTE_OFFSET */:
    case 0x200B /* AL_SEC_LENGTH_SOFT */:
      {{{ makeSetValue('pValues', '0', 'val[0]', 'float') }}};
      break;
    case {{{ cDefs.AL_POSITION }}}:
    case {{{ cDefs.AL_DIRECTION }}}:
    case {{{ cDefs.AL_VELOCITY }}}:
      {{{ makeSetValue('pValues', '0', 'val[0]', 'float') }}};
      {{{ makeSetValue('pValues', '4', 'val[1]', 'float') }}};
      {{{ makeSetValue('pValues', '8', 'val[2]', 'float') }}};
      break;
    default:
#if OPENAL_DEBUG
      dbg(`alGetSourcefv(): param ${ptrToString(param)} has wrong signature`);
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
      return;
    }
  },

  alGetSourcei__proxy: 'sync',
  alGetSourcei: (sourceId, param, pValue) => {
    var val = AL.getSourceParam('alGetSourcei', sourceId, param);
    if (val === null) {
      return;
    }
    if (!pValue) {
#if OPENAL_DEBUG
      dbg('alGetSourcei() called with a null pointer');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
      return;
    }

    switch (param) {
    case 0x202 /* AL_SOURCE_RELATIVE */:
    case 0x1001 /* AL_CONE_INNER_ANGLE */:
    case 0x1002 /* AL_CONE_OUTER_ANGLE */:
    case 0x1007 /* AL_LOOPING */:
    case 0x1009 /* AL_BUFFER */:
    case 0x1010 /* AL_SOURCE_STATE */:
    case 0x1015 /* AL_BUFFERS_QUEUED */:
    case 0x1016 /* AL_BUFFERS_PROCESSED */:
    case 0x1020 /* AL_REFERENCE_DISTANCE */:
    case 0x1021 /* AL_ROLLOFF_FACTOR */:
    case 0x1023 /* AL_MAX_DISTANCE */:
    case 0x1024 /* AL_SEC_OFFSET */:
    case 0x1025 /* AL_SAMPLE_OFFSET */:
    case 0x1026 /* AL_BYTE_OFFSET */:
    case 0x1027 /* AL_SOURCE_TYPE */:
    case 0x1214 /* AL_SOURCE_SPATIALIZE_SOFT */:
    case 0x2009 /* AL_BYTE_LENGTH_SOFT */:
    case 0x200A /* AL_SAMPLE_LENGTH_SOFT */:
    case {{{ cDefs.AL_DISTANCE_MODEL }}}:
      {{{ makeSetValue('pValue', '0', 'val', 'i32') }}};
      break;
    default:
#if OPENAL_DEBUG
      dbg(`alGetSourcei(): param ${ptrToString(param)} has wrong signature`);
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
      return;
    }
  },

  alGetSource3i__proxy: 'sync',
  alGetSource3i: (sourceId, param, pValue0, pValue1, pValue2) => {
    var val = AL.getSourceParam('alGetSource3i', sourceId, param);
    if (val === null) {
      return;
    }
    if (!pValue0 || !pValue1 || !pValue2) {
#if OPENAL_DEBUG
      dbg('alGetSource3i() called with a null pointer');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
      return;
    }

    switch (param) {
    case {{{ cDefs.AL_POSITION }}}:
    case {{{ cDefs.AL_DIRECTION }}}:
    case {{{ cDefs.AL_VELOCITY }}}:
      {{{ makeSetValue('pValue0', '0', 'val[0]', 'i32') }}};
      {{{ makeSetValue('pValue1', '0', 'val[1]', 'i32') }}};
      {{{ makeSetValue('pValue2', '0', 'val[2]', 'i32') }}};
      break;
    default:
#if OPENAL_DEBUG
      dbg(`alGetSource3i(): param ${ptrToString(param)} has wrong signature`);
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
      return;
    }
  },

  alGetSourceiv__proxy: 'sync',
  alGetSourceiv: (sourceId, param, pValues) => {
    var val = AL.getSourceParam('alGetSourceiv', sourceId, param);
    if (val === null) {
      return;
    }
    if (!pValues) {
#if OPENAL_DEBUG
      dbg('alGetSourceiv() called with a null pointer');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
      return;
    }

    switch (param) {
    case 0x202 /* AL_SOURCE_RELATIVE */:
    case 0x1001 /* AL_CONE_INNER_ANGLE */:
    case 0x1002 /* AL_CONE_OUTER_ANGLE */:
    case 0x1007 /* AL_LOOPING */:
    case 0x1009 /* AL_BUFFER */:
    case 0x1010 /* AL_SOURCE_STATE */:
    case 0x1015 /* AL_BUFFERS_QUEUED */:
    case 0x1016 /* AL_BUFFERS_PROCESSED */:
    case 0x1020 /* AL_REFERENCE_DISTANCE */:
    case 0x1021 /* AL_ROLLOFF_FACTOR */:
    case 0x1023 /* AL_MAX_DISTANCE */:
    case 0x1024 /* AL_SEC_OFFSET */:
    case 0x1025 /* AL_SAMPLE_OFFSET */:
    case 0x1026 /* AL_BYTE_OFFSET */:
    case 0x1027 /* AL_SOURCE_TYPE */:
    case 0x1214 /* AL_SOURCE_SPATIALIZE_SOFT */:
    case 0x2009 /* AL_BYTE_LENGTH_SOFT */:
    case 0x200A /* AL_SAMPLE_LENGTH_SOFT */:
    case {{{ cDefs.AL_DISTANCE_MODEL }}}:
      {{{ makeSetValue('pValues', '0', 'val', 'i32') }}};
      break;
    case {{{ cDefs.AL_POSITION }}}:
    case {{{ cDefs.AL_DIRECTION }}}:
    case {{{ cDefs.AL_VELOCITY }}}:
      {{{ makeSetValue('pValues', '0', 'val[0]', 'i32') }}};
      {{{ makeSetValue('pValues', '4', 'val[1]', 'i32') }}};
      {{{ makeSetValue('pValues', '8', 'val[2]', 'i32') }}};
      break;
    default:
#if OPENAL_DEBUG
      dbg(`alGetSourceiv(): param ${ptrToString(param)} has wrong signature`);
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_ENUM }}};
      return;
    }
  },

  alSourcef__proxy: 'sync',
  alSourcef: (sourceId, param, value) => {
    switch (param) {
    case 0x1001 /* AL_CONE_INNER_ANGLE */:
    case 0x1002 /* AL_CONE_OUTER_ANGLE */:
    case 0x1003 /* AL_PITCH */:
    case {{{ cDefs.AL_GAIN }}}:
    case 0x100D /* AL_MIN_GAIN */:
    case 0x100E /* AL_MAX_GAIN */:
    case 0x1020 /* AL_REFERENCE_DISTANCE */:
    case 0x1021 /* AL_ROLLOFF_FACTOR */:
    case 0x1022 /* AL_CONE_OUTER_GAIN */:
    case 0x1023 /* AL_MAX_DISTANCE */:
    case 0x1024 /* AL_SEC_OFFSET */:
    case 0x1025 /* AL_SAMPLE_OFFSET */:
    case 0x1026 /* AL_BYTE_OFFSET */:
    case 0x200B /* AL_SEC_LENGTH_SOFT */:
      AL.setSourceParam('alSourcef', sourceId, param, value);
      break;
    default:
      AL.setSourceParam('alSourcef', sourceId, param, null);
      break;
    }
  },

  alSource3f__proxy: 'sync',
  alSource3f: (sourceId, param, value0, value1, value2) => {
    switch (param) {
    case {{{ cDefs.AL_POSITION }}}:
    case {{{ cDefs.AL_DIRECTION }}}:
    case {{{ cDefs.AL_VELOCITY }}}:
      AL.paramArray[0] = value0;
      AL.paramArray[1] = value1;
      AL.paramArray[2] = value2;
      AL.setSourceParam('alSource3f', sourceId, param, AL.paramArray);
      break;
    default:
      AL.setSourceParam('alSource3f', sourceId, param, null);
      break;
    }
  },

  alSourcefv__proxy: 'sync',
  alSourcefv: (sourceId, param, pValues) => {
    if (!AL.currentCtx) {
#if OPENAL_DEBUG
      dbg('alSourcefv() called without a valid context');
#endif
      return;
    }
    if (!pValues) {
#if OPENAL_DEBUG
      dbg('alSourcefv() called with a null pointer');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
      return;
    }

    switch (param) {
    case 0x1001 /* AL_CONE_INNER_ANGLE */:
    case 0x1002 /* AL_CONE_OUTER_ANGLE */:
    case 0x1003 /* AL_PITCH */:
    case {{{ cDefs.AL_GAIN }}}:
    case 0x100D /* AL_MIN_GAIN */:
    case 0x100E /* AL_MAX_GAIN */:
    case 0x1020 /* AL_REFERENCE_DISTANCE */:
    case 0x1021 /* AL_ROLLOFF_FACTOR */:
    case 0x1022 /* AL_CONE_OUTER_GAIN */:
    case 0x1023 /* AL_MAX_DISTANCE */:
    case 0x1024 /* AL_SEC_OFFSET */:
    case 0x1025 /* AL_SAMPLE_OFFSET */:
    case 0x1026 /* AL_BYTE_OFFSET */:
    case 0x200B /* AL_SEC_LENGTH_SOFT */:
      var val = {{{ makeGetValue('pValues', '0', 'float') }}};
      AL.setSourceParam('alSourcefv', sourceId, param, val);
      break;
    case {{{ cDefs.AL_POSITION }}}:
    case {{{ cDefs.AL_DIRECTION }}}:
    case {{{ cDefs.AL_VELOCITY }}}:
      AL.paramArray[0] = {{{ makeGetValue('pValues', '0', 'float') }}};
      AL.paramArray[1] = {{{ makeGetValue('pValues', '4', 'float') }}};
      AL.paramArray[2] = {{{ makeGetValue('pValues', '8', 'float') }}};
      AL.setSourceParam('alSourcefv', sourceId, param, AL.paramArray);
      break;
    default:
      AL.setSourceParam('alSourcefv', sourceId, param, null);
      break;
    }
  },

  alSourcei__proxy: 'sync',
  alSourcei: (sourceId, param, value) => {
    switch (param) {
    case 0x202 /* AL_SOURCE_RELATIVE */:
    case 0x1001 /* AL_CONE_INNER_ANGLE */:
    case 0x1002 /* AL_CONE_OUTER_ANGLE */:
    case 0x1007 /* AL_LOOPING */:
    case 0x1009 /* AL_BUFFER */:
    case 0x1020 /* AL_REFERENCE_DISTANCE */:
    case 0x1021 /* AL_ROLLOFF_FACTOR */:
    case 0x1023 /* AL_MAX_DISTANCE */:
    case 0x1024 /* AL_SEC_OFFSET */:
    case 0x1025 /* AL_SAMPLE_OFFSET */:
    case 0x1026 /* AL_BYTE_OFFSET */:
    case 0x1214 /* AL_SOURCE_SPATIALIZE_SOFT */:
    case 0x2009 /* AL_BYTE_LENGTH_SOFT */:
    case 0x200A /* AL_SAMPLE_LENGTH_SOFT */:
    case {{{ cDefs.AL_DISTANCE_MODEL }}}:
      AL.setSourceParam('alSourcei', sourceId, param, value);
      break;
    default:
      AL.setSourceParam('alSourcei', sourceId, param, null);
      break;
    }
  },

  alSource3i__proxy: 'sync',
  alSource3i: (sourceId, param, value0, value1, value2) => {
    switch (param) {
    case {{{ cDefs.AL_POSITION }}}:
    case {{{ cDefs.AL_DIRECTION }}}:
    case {{{ cDefs.AL_VELOCITY }}}:
      AL.paramArray[0] = value0;
      AL.paramArray[1] = value1;
      AL.paramArray[2] = value2;
      AL.setSourceParam('alSource3i', sourceId, param, AL.paramArray);
      break;
    default:
      AL.setSourceParam('alSource3i', sourceId, param, null);
      break;
    }
  },

  alSourceiv__proxy: 'sync',
  alSourceiv: (sourceId, param, pValues) => {
    if (!AL.currentCtx) {
#if OPENAL_DEBUG
      dbg('alSourceiv() called without a valid context');
#endif
      return;
    }
    if (!pValues) {
#if OPENAL_DEBUG
      dbg('alSourceiv() called with a null pointer');
#endif
      AL.currentCtx.err = {{{ cDefs.AL_INVALID_VALUE }}};
      return;
    }

    switch (param) {
    case 0x202 /* AL_SOURCE_RELATIVE */:
    case 0x1001 /* AL_CONE_INNER_ANGLE */:
    case 0x1002 /* AL_CONE_OUTER_ANGLE */:
    case 0x1007 /* AL_LOOPING */:
    case 0x1009 /* AL_BUFFER */:
    case 0x1020 /* AL_REFERENCE_DISTANCE */:
    case 0x1021 /* AL_ROLLOFF_FACTOR */:
    case 0x1023 /* AL_MAX_DISTANCE */:
    case 0x1024 /* AL_SEC_OFFSET */:
    case 0x1025 /* AL_SAMPLE_OFFSET */:
    case 0x1026 /* AL_BYTE_OFFSET */:
    case 0x1214 /* AL_SOURCE_SPATIALIZE_SOFT */:
    case 0x2009 /* AL_BYTE_LENGTH_SOFT */:
    case 0x200A /* AL_SAMPLE_LENGTH_SOFT */:
    case {{{ cDefs.AL_DISTANCE_MODEL }}}:
      var val = {{{ makeGetValue('pValues', '0', 'i32') }}};
      AL.setSourceParam('alSourceiv', sourceId, param, val);
      break;
    case {{{ cDefs.AL_POSITION }}}:
    case {{{ cDefs.AL_DIRECTION }}}:
    case {{{ cDefs.AL_VELOCITY }}}:
      AL.paramArray[0] = {{{ makeGetValue('pValues', '0', 'i32') }}};
      AL.paramArray[1] = {{{ makeGetValue('pValues', '4', 'i32') }}};
      AL.paramArray[2] = {{{ makeGetValue('pValues', '8', 'i32') }}};
      AL.setSourceParam('alSourceiv', sourceId, param, AL.paramArray);
      break;
    default:
      AL.setSourceParam('alSourceiv', sourceId, param, null);
      break;
    }
  }
};

autoAddDeps(LibraryOpenAL, '$AL');
addToLibrary(LibraryOpenAL);