webruby 0.1.2 → 0.2.1

data/modules/emscripten/src/library_nodefs.js

@@ -0,0 +1,234 @@
+mergeInto(LibraryManager.library, {
+  $NODEFS__deps: ['$FS', '$PATH'],
+  $NODEFS__postset: 'if (ENVIRONMENT_IS_NODE) { var fs = require("fs"); }',
+  $NODEFS: {
+    mount: function (mount) {
+      assert(ENVIRONMENT_IS_NODE);
+      return NODEFS.createNode(null, '/', NODEFS.getMode(mount.opts.root), 0);
+    },
+    createNode: function (parent, name, mode, dev) {
+      if (!FS.isDir(mode) && !FS.isFile(mode) && !FS.isLink(mode)) {
+        throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+      }
+      var node = FS.createNode(parent, name, mode);
+      node.node_ops = NODEFS.node_ops;
+      node.stream_ops = NODEFS.stream_ops;
+      return node;
+    },
+    getMode: function (path) {
+      var stat;
+      try {
+        stat = fs.lstatSync(path);
+      } catch (e) {
+        if (!e.code) throw e;
+        throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+      }
+      return stat.mode;
+    },
+    realPath: function (node) {
+      var parts = [];
+      while (node.parent !== node) {
+        parts.push(node.name);
+        node = node.parent;
+      }
+      parts.push(node.mount.opts.root);
+      parts.reverse();
+      return PATH.join.apply(null, parts);
+    },
+    node_ops: {
+      getattr: function(node) {
+        var path = NODEFS.realPath(node);
+        var stat;
+        try {
+          stat = fs.lstatSync(path);
+        } catch (e) {
+          if (!e.code) throw e;
+          throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+        }
+        return {
+          dev: stat.dev,
+          ino: stat.ino,
+          mode: stat.mode,
+          nlink: stat.nlink,
+          uid: stat.uid,
+          gid: stat.gid,
+          rdev: stat.rdev,
+          size: stat.size,
+          atime: stat.atime,
+          mtime: stat.mtime,
+          ctime: stat.ctime,
+          blksize: stat.blksize,
+          blocks: stat.blocks
+        };
+      },
+      setattr: function(node, attr) {
+        var path = NODEFS.realPath(node);
+        try {
+          if (attr.mode !== undefined) {
+            fs.chmodSync(path, attr.mode);
+            // update the common node structure mode as well
+            node.mode = attr.mode;
+          }
+          if (attr.timestamp !== undefined) {
+            var date = new Date(attr.timestamp);
+            fs.utimesSync(path, date, date);
+          }
+          if (attr.size !== undefined) {
+            fs.truncateSync(path, attr.size);
+          }
+        } catch (e) {
+          if (!e.code) throw e;
+          throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+        }
+      },
+      lookup: function (parent, name) {
+        var path = PATH.join(NODEFS.realPath(parent), name);
+        var mode = NODEFS.getMode(path);
+        return NODEFS.createNode(parent, name, mode);
+      },
+      mknod: function (parent, name, mode, dev) {
+        var node = NODEFS.createNode(parent, name, mode, dev);
+        // create the backing node for this in the fs root as well
+        var path = NODEFS.realPath(node);
+        try {
+          if (FS.isDir(node.mode)) {
+            fs.mkdirSync(path, node.mode);
+          } else {
+            fs.writeFileSync(path, '', { mode: node.mode });
+          }
+        } catch (e) {
+          if (!e.code) throw e;
+          throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+        }
+        return node;
+      },
+      rename: function (oldNode, newDir, newName) {
+        var oldPath = NODEFS.realPath(oldNode);
+        var newPath = PATH.join(NODEFS.realPath(newDir), newName);
+        try {
+          fs.renameSync(oldPath, newPath);
+        } catch (e) {
+          if (!e.code) throw e;
+          throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+        }
+      },
+      unlink: function(parent, name) {
+        var path = PATH.join(NODEFS.realPath(parent), name);
+        try {
+          fs.unlinkSync(path);
+        } catch (e) {
+          if (!e.code) throw e;
+          throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+        }
+      },
+      rmdir: function(parent, name) {
+        var path = PATH.join(NODEFS.realPath(parent), name);
+        try {
+          fs.rmdirSync(path);
+        } catch (e) {
+          if (!e.code) throw e;
+          throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+        }
+      },
+      readdir: function(node) {
+        var path = NODEFS.realPath(node);
+        try {
+          return fs.readdirSync(path);
+        } catch (e) {
+          if (!e.code) throw e;
+          throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+        }
+      },
+      symlink: function(parent, newName, oldPath) {
+        var newPath = PATH.join(NODEFS.realPath(parent), newName);
+        try {
+          fs.symlinkSync(oldPath, newPath);
+        } catch (e) {
+          if (!e.code) throw e;
+          throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+        }
+      },
+      readlink: function(node) {
+        var path = NODEFS.realPath(node);
+        try {
+          return fs.readlinkSync(path);
+        } catch (e) {
+          if (!e.code) throw e;
+          throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+        }
+      },
+    },
+    stream_ops: {
+      open: function (stream) {
+        var path = NODEFS.realPath(stream.node);
+        try {
+          if (FS.isFile(stream.node.mode)) {
+            stream.nfd = fs.openSync(path, stream.flags);
+          }
+        } catch (e) {
+          if (!e.code) throw e;
+          throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+        }
+      },
+      close: function (stream) {
+        try {
+          if (FS.isFile(stream.node.mode)) {
+            fs.closeSync(stream.nfd);
+          }
+        } catch (e) {
+          if (!e.code) throw e;
+          throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+        }
+      },
+      read: function (stream, buffer, offset, length, position) {
+        // FIXME this is terrible.
+        var nbuffer = new Buffer(length);
+        var res;
+        try {
+          res = fs.readSync(stream.nfd, nbuffer, 0, length, position);
+        } catch (e) {
+          throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+        }
+        if (res > 0) {
+          for (var i = 0; i < res; i++) {
+            buffer[offset + i] = nbuffer[i];
+          }
+        }
+        return res;
+      },
+      write: function (stream, buffer, offset, length, position) {
+        // FIXME this is terrible.
+        var nbuffer = new Buffer(buffer.subarray(offset, offset + length));
+        var res;
+        try {
+          res = fs.writeSync(stream.nfd, nbuffer, 0, length, position);
+        } catch (e) {
+          throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+        }
+        return res;
+      },
+      llseek: function (stream, offset, whence) {
+        var position = offset;
+        if (whence === 1) {  // SEEK_CUR.
+          position += stream.position;
+        } else if (whence === 2) {  // SEEK_END.
+          if (FS.isFile(stream.node.mode)) {
+            try {
+              var stat = fs.fstatSync(stream.nfd);
+              position += stat.size;
+            } catch (e) {
+              throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+            }
+          }
+        }
+
+        if (position < 0) {
+          throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+        }
+
+        stream.position = position;
+        return position;
+      }
+    }
+  }
+});

data/modules/emscripten/src/library_openal.js

@@ -6,7 +6,128 @@ var LibraryOpenAL = {
     contexts: [],
     currentContext: null,
     QUEUE_INTERVAL: 25,
-    QUEUE_LOOKAHEAD: 100
+    QUEUE_LOOKAHEAD: 100,
+
+    updateSources: function(context) {
+      for (var i = 0; i < context.src.length; i++) {
+        AL.updateSource(context.src[i]);
+      }
+    },
+
+    updateSource: function(src) {
+#if OPENAL_DEBUG
+      var idx = AL.currentContext.src.indexOf(src);
+#endif
+      if (src.state !== 0x1012 /* AL_PLAYING */) {
+        return;
+      }
+
+      var currentTime = AL.currentContext.ctx.currentTime;
+      var startTime = src.bufferPosition;
+
+      for (var i = src.buffersPlayed; i < src.queue.length; i++) {
+        var entry = src.queue[i];
+
+        var startOffset = startTime - currentTime;
+        var endTime = startTime + entry.buffer.duration;
+
+        // Clean up old buffers.
+        if (currentTime >= endTime) {
+          // Update our location in the queue.
+          src.bufferPosition = endTime;
+          src.buffersPlayed = i + 1;
+
+          // Stop / restart the source when we hit the end.
+          if (src.buffersPlayed >= src.queue.length) {
+            if (src.loop) {
+              AL.setSourceState(src, 0x1012 /* AL_PLAYING */);
+            } else {
+              AL.setSourceState(src, 0x1014 /* AL_STOPPED */);
+            }
+          }
+        }
+        // Process all buffers that'll be played before the next tick.
+        else if (startOffset < (AL.QUEUE_LOOKAHEAD / 1000) && !entry.src) {
+          // If the start offset is negative, we need to offset the actual buffer.
+          var offset = Math.abs(Math.min(startOffset, 0));
+
+          entry.src = AL.currentContext.ctx.createBufferSource();
+          entry.src.buffer = entry.buffer;
+          entry.src.connect(src.gain);
+          entry.src.start(startTime, offset);
+          
+#if OPENAL_DEBUG
+          console.log('updateSource queuing buffer ' + i + ' for source ' + idx + ' at ' + startTime + ' (offset by ' + offset + ')');
+#endif
+        }
+
+        startTime = endTime;
+      }
+    },
+
+    setSourceState: function(src, state) {
+#if OPENAL_DEBUG
+      var idx = AL.currentContext.src.indexOf(src);
+#endif
+      if (state === 0x1012 /* AL_PLAYING */) {
+        if (src.state !== 0x1013 /* AL_PAUSED */) {
+          src.state = 0x1012 /* AL_PLAYING */;
+          // Reset our position.
+          src.bufferPosition = AL.currentContext.ctx.currentTime;
+          src.buffersPlayed = 0;
+#if OPENAL_DEBUG
+          console.log('setSourceState resetting and playing source ' + idx);
+#endif
+        } else {
+          src.state = 0x1012 /* AL_PLAYING */;
+          // Use the current offset from src.bufferPosition to resume at the correct point.
+          src.bufferPosition = AL.currentContext.ctx.currentTime - src.bufferPosition;
+#if OPENAL_DEBUG
+          console.log('setSourceState resuming source ' + idx + ' at ' + src.bufferPosition.toFixed(4));
+#endif
+        }
+        AL.stopSourceQueue(src);
+        AL.updateSource(src);
+      } else if (state === 0x1013 /* AL_PAUSED */) {
+        if (src.state === 0x1012 /* AL_PLAYING */) {
+          src.state = 0x1013 /* AL_PAUSED */;
+          // Store off the current offset to restore with on resume.
+          src.bufferPosition = AL.currentContext.ctx.currentTime - src.bufferPosition;
+          AL.stopSourceQueue(src);
+#if OPENAL_DEBUG
+          console.log('setSourceState pausing source ' + idx + ' at ' + src.bufferPosition.toFixed(4));
+#endif
+        }
+      } else if (state === 0x1014 /* AL_STOPPED */) {
+        if (src.state !== 0x1011 /* AL_INITIAL */) {
+          src.state = 0x1014 /* AL_STOPPED */;
+          src.buffersPlayed = src.queue.length;
+          AL.stopSourceQueue(src);
+#if OPENAL_DEBUG
+          console.log('setSourceState stopping source ' + idx);
+#endif
+        }
+      } else if (state == 0x1011 /* AL_INITIAL */) {
+        if (src.state !== 0x1011 /* AL_INITIAL */) {
+          src.state = 0x1011 /* AL_INITIAL */;
+          src.bufferPosition = 0;
+          src.buffersPlayed = 0;
+#if OPENAL_DEBUG
+          console.log('setSourceState initializing source ' + idx);
+#endif
+        }
+      }
+    },
+
+    stopSourceQueue: function(src) {
+      for (var i = 0; i < src.queue.length; i++) {
+        var entry = src.queue[i];
+        if (entry.src) {
+          entry.src.stop(0);
+          entry.src = null;
+        }
+      }
+    }
   },
 
   alcProcessContext: function(context) {},
@@ -41,7 +162,7 @@ var LibraryOpenAL = {
 
   alcDestroyContext: function(context) {
     // Stop playback, etc
-    clearInterval(context.interval);
+    clearInterval(AL.contexts[context - 1].interval);
   },
 
   alcCloseDevice: function(device) {
@@ -85,7 +206,7 @@ var LibraryOpenAL = {
         err: 0,
         src: [],
         buf: [],
-        interval: setInterval(function() { _updateSources(context); }, AL.QUEUE_INTERVAL)
+        interval: setInterval(function() { AL.updateSources(context); }, AL.QUEUE_INTERVAL)
       };
       AL.contexts.push(context);
       return AL.contexts.length;
@@ -94,130 +215,6 @@ var LibraryOpenAL = {
     }
   },
 
-  updateSources__deps: ['updateSource'],
-  updateSources: function(context) {
-    for (var i = 0; i < context.src.length; i++) {
-      _updateSource(context.src[i]);
-    }
-  },
-
-  updateSource__deps: ['setSourceState'],
-  updateSource: function(src) {
-#if OPENAL_DEBUG
-    var idx = AL.currentContext.src.indexOf(src);
-#endif
-    if (src.state !== 0x1012 /* AL_PLAYING */) {
-      return;
-    }
-
-    var currentTime = AL.currentContext.ctx.currentTime;
-    var startTime = src.bufferPosition;
-
-    for (var i = src.buffersPlayed; i < src.queue.length; i++) {
-      var entry = src.queue[i];
-
-      var startOffset = startTime - currentTime;
-      var endTime = startTime + entry.buffer.duration;
-
-      // Clean up old buffers.
-      if (currentTime >= endTime) {
-        // Update our location in the queue.
-        src.bufferPosition = endTime;
-        src.buffersPlayed = i + 1;
-
-        // Stop / restart the source when we hit the end.
-        if (src.buffersPlayed >= src.queue.length) {
-          if (src.loop) {
-            _setSourceState(src, 0x1012 /* AL_PLAYING */);
-          } else {
-            _setSourceState(src, 0x1014 /* AL_STOPPED */);
-          }
-        }
-      }
-      // Process all buffers that'll be played before the next tick.
-      else if (startOffset < (AL.QUEUE_LOOKAHEAD / 1000) && !entry.src) {
-        // If the start offset is negative, we need to offset the actual buffer.
-        var offset = Math.abs(Math.min(startOffset, 0));
-
-        entry.src = AL.currentContext.ctx.createBufferSource();
-        entry.src.buffer = entry.buffer;
-        entry.src.connect(src.gain);
-        entry.src.start(startTime, offset);
-        
-#if OPENAL_DEBUG
-        console.log('updateSource queuing buffer ' + i + ' for source ' + idx + ' at ' + startTime + ' (offset by ' + offset + ')');
-#endif
-      }
-
-      startTime = endTime;
-    }
-  },
-
-  setSourceState__deps: ['updateSource', 'stopSourceQueue'],
-  setSourceState: function(src, state) {
-#if OPENAL_DEBUG
-    var idx = AL.currentContext.src.indexOf(src);
-#endif
-    if (state === 0x1012 /* AL_PLAYING */) {
-      if (src.state !== 0x1013 /* AL_PAUSED */) {
-        src.state = 0x1012 /* AL_PLAYING */;
-        // Reset our position.
-        src.bufferPosition = AL.currentContext.ctx.currentTime;
-        src.buffersPlayed = 0;
-#if OPENAL_DEBUG
-        console.log('setSourceState resetting and playing source ' + idx);
-#endif
-      } else {
-        src.state = 0x1012 /* AL_PLAYING */;
-        // Use the current offset from src.bufferPosition to resume at the correct point.
-        src.bufferPosition = AL.currentContext.ctx.currentTime - src.bufferPosition;
-#if OPENAL_DEBUG
-        console.log('setSourceState resuming source ' + idx + ' at ' + src.bufferPosition.toFixed(4));
-#endif
-      }
-      _stopSourceQueue(src);
-      _updateSource(src);
-    } else if (state === 0x1013 /* AL_PAUSED */) {
-      if (src.state === 0x1012 /* AL_PLAYING */) {
-        src.state = 0x1013 /* AL_PAUSED */;
-        // Store off the current offset to restore with on resume.
-        src.bufferPosition = AL.currentContext.ctx.currentTime - src.bufferPosition;
-        _stopSourceQueue(src);
-#if OPENAL_DEBUG
-        console.log('setSourceState pausing source ' + idx + ' at ' + src.bufferPosition.toFixed(4));
-#endif
-      }
-    } else if (state === 0x1014 /* AL_STOPPED */) {
-      if (src.state !== 0x1011 /* AL_INITIAL */) {
-        src.state = 0x1014 /* AL_STOPPED */;
-        src.buffersPlayed = src.queue.length;
-        _stopSourceQueue(src);
-#if OPENAL_DEBUG
-        console.log('setSourceState stopping source ' + idx);
-#endif
-      }
-    } else if (state == 0x1011 /* AL_INITIAL */) {
-      if (src.state !== 0x1011 /* AL_INITIAL */) {
-        src.state = 0x1011 /* AL_INITIAL */;
-        src.bufferPosition = 0;
-        src.buffersPlayed = 0;
-#if OPENAL_DEBUG
-        console.log('setSourceState initializing source ' + idx);
-#endif
-      }
-    }
-  },
-
-  stopSourceQueue: function(src) {
-    for (var i = 0; i < src.queue.length; i++) {
-      var entry = src.queue[i];
-      if (entry.src) {
-        entry.src.stop(0);
-        entry.src = null;
-      }
-    }
-  },
-
   alGetError: function() {
     if (!AL.currentContext) {
       return 0xA004 /* AL_INVALID_OPERATION */;
@@ -240,7 +237,6 @@ var LibraryOpenAL = {
 #if OPENAL_DEBUG
       console.error("alDeleteSources called without a valid context");
 #endif
-      AL.currentContext.err = 0xA004 /* AL_INVALID_OPERATION */;
       return;
     }
     for (var i = 0; i < count; ++i) {
@@ -254,7 +250,6 @@ var LibraryOpenAL = {
 #if OPENAL_DEBUG
       console.error("alGenSources called without a valid context");
 #endif
-      AL.currentContext.err = 0xA004 /* AL_INVALID_OPERATION */;
       return;
     }
     for (var i = 0; i < count; ++i) {
@@ -314,7 +309,6 @@ var LibraryOpenAL = {
 #if OPENAL_DEBUG
       console.error("alSourcei called without a valid context");
 #endif
-      AL.currentContext.err = 0xA004 /* AL_INVALID_OPERATION */;
       return;
     }
     var src = AL.currentContext.src[source - 1];
@@ -336,7 +330,7 @@ var LibraryOpenAL = {
       } else {
         src.queue = [{ buffer: buffer }];
       }
-      _updateSource(src);
+      AL.updateSource(src);
       break;
     case 0x202 /* AL_SOURCE_RELATIVE */:
       if (value === 1 /* AL_TRUE */) {
@@ -383,7 +377,6 @@ var LibraryOpenAL = {
 #if OPENAL_DEBUG
       console.error("alSourcef called without a valid context");
 #endif
-      AL.currentContext.err = 0xA004 /* AL_INVALID_OPERATION */;
       return;
     }
     var src = AL.currentContext.src[source - 1];
@@ -436,7 +429,6 @@ var LibraryOpenAL = {
 #if OPENAL_DEBUG
       console.error("alSource3f called without a valid context");
 #endif
-      AL.currentContext.err = 0xA004 /* AL_INVALID_OPERATION */;
       return;
     }
     var src = AL.currentContext.src[source - 1];
@@ -477,7 +469,6 @@ var LibraryOpenAL = {
 #if OPENAL_DEBUG
       console.error("alSourceQueueBuffers called without a valid context");
 #endif
-      AL.currentContext.err = 0xA004 /* AL_INVALID_OPERATION */;
       return;
     }
     var src = AL.currentContext.src[source - 1];
@@ -505,7 +496,7 @@ var LibraryOpenAL = {
       src.queue.push({ buffer: buffer, src: null });
     }
 
-    _updateSource(src);
+    AL.updateSource(src);
   },
 
   alSourceUnqueueBuffers__deps: ["updateSource"],
@@ -514,7 +505,6 @@ var LibraryOpenAL = {
 #if OPENAL_DEBUG
       console.error("alSourceUnqueueBuffers called without a valid context");
 #endif
-      AL.currentContext.err = 0xA004 /* AL_INVALID_OPERATION */;
       return;
     }
     var src = AL.currentContext.src[source - 1];
@@ -544,7 +534,7 @@ var LibraryOpenAL = {
       src.buffersPlayed--;
     }
 
-    _updateSource(src);
+    AL.updateSource(src);
   },
 
   alDeleteBuffers: function(count, buffers)
@@ -553,7 +543,6 @@ var LibraryOpenAL = {
 #if OPENAL_DEBUG
       console.error("alDeleteBuffers called without a valid context");
 #endif
-      AL.currentContext.err = 0xA004 /* AL_INVALID_OPERATION */;
       return;
     }
     if (count > AL.currentContext.buf.length) {
@@ -597,7 +586,6 @@ var LibraryOpenAL = {
 #if OPENAL_DEBUG
       console.error("alGenBuffers called without a valid context");
 #endif
-      AL.currentContext.err = 0xA004 /* AL_INVALID_OPERATION */;
       return;
     }
     for (var i = 0; i < count; ++i) {
@@ -611,7 +599,6 @@ var LibraryOpenAL = {
 #if OPENAL_DEBUG
       console.error("alBufferData called without a valid context");
 #endif
-      AL.currentContext.err = 0xA004 /* AL_INVALID_OPERATION */;
       return;
     }
     if (buffer > AL.currentContext.buf.length) {
@@ -676,7 +663,6 @@ var LibraryOpenAL = {
 #if OPENAL_DEBUG
       console.error("alSourcePlay called without a valid context");
 #endif
-      AL.currentContext.err = 0xA004 /* AL_INVALID_OPERATION */;
       return;
     }
     var src = AL.currentContext.src[source - 1];
@@ -687,7 +673,7 @@ var LibraryOpenAL = {
       AL.currentContext.err = 0xA001 /* AL_INVALID_NAME */;
       return;
     }
-    _setSourceState(src, 0x1012 /* AL_PLAYING */);
+    AL.setSourceState(src, 0x1012 /* AL_PLAYING */);
   },
 
   alSourceStop__deps: ['setSourceState'],
@@ -696,7 +682,6 @@ var LibraryOpenAL = {
 #if OPENAL_DEBUG
       console.error("alSourceStop called without a valid context");
 #endif
-      AL.currentContext.err = 0xA004 /* AL_INVALID_OPERATION */;
       return;
     }
     var src = AL.currentContext.src[source - 1];
@@ -707,7 +692,7 @@ var LibraryOpenAL = {
       AL.currentContext.err = 0xA001 /* AL_INVALID_NAME */;
       return;
     }
-    _setSourceState(src, 0x1014 /* AL_STOPPED */);
+    AL.setSourceState(src, 0x1014 /* AL_STOPPED */);
   },
 
   alSourcePause__deps: ['setSourceState'],
@@ -716,7 +701,6 @@ var LibraryOpenAL = {
 #if OPENAL_DEBUG
       console.error("alSourcePause called without a valid context");
 #endif
-      AL.currentContext.err = 0xA004 /* AL_INVALID_OPERATION */;
       return;
     }
     var src = AL.currentContext.src[source - 1];
@@ -727,7 +711,7 @@ var LibraryOpenAL = {
       AL.currentContext.err = 0xA001 /* AL_INVALID_NAME */;
       return;
     }
-    _setSourceState(src, 0x1013 /* AL_PAUSED */);
+    AL.setSourceState(src, 0x1013 /* AL_PAUSED */);
   },
 
   alGetSourcei__deps: ['updateSource'],
@@ -736,7 +720,6 @@ var LibraryOpenAL = {
 #if OPENAL_DEBUG
       console.error("alGetSourcei called without a valid context");
 #endif
-      AL.currentContext.err = 0xA004 /* AL_INVALID_OPERATION */;
       return;
     }
     var src = AL.currentContext.src[source - 1];
@@ -754,7 +737,7 @@ var LibraryOpenAL = {
     // so we also forcefully update the source when alGetSourcei is queried
     // to aid in the common scenario of application calling alGetSourcei(AL_BUFFERS_PROCESSED)
     // to recycle buffers.
-    _updateSource(src);
+    AL.updateSource(src);
 
     switch (param) {
     case 0x202 /* AL_SOURCE_RELATIVE */:
@@ -800,7 +783,6 @@ var LibraryOpenAL = {
 #if OPENAL_DEBUG
       console.error("alGetSourcef called without a valid context");
 #endif
-      AL.currentContext.err = 0xA004 /* AL_INVALID_OPERATION */;
       return;
     }
     var src = AL.currentContext.src[source - 1];
@@ -861,7 +843,6 @@ var LibraryOpenAL = {
 #if OPENAL_DEBUG
       console.error("alListenerfv called without a valid context");
 #endif
-      AL.currentContext.err = 0xA004 /* AL_INVALID_OPERATION */;
       return;
     }
     switch (param) {

data/modules/emscripten/src/library_path.js

@@ -68,6 +68,9 @@ mergeInto(LibraryManager.library, {
       }
       return f;
     },
+    extname: function(path) {
+      return PATH.splitPath(path)[3];
+    },
     join: function() {
       var paths = Array.prototype.slice.call(arguments, 0);
       return PATH.normalize(paths.filter(function(p, index) {