source: gs3-extensions/web-audio/trunk/js-mad/sink.js-master/src/extra/write-buffers.js@ 28388

void function (Sink, proto) {

proto = Sink.prototype;

Sink.on('init', function (sink) {
    sink.asyncBuffers   = [];
    sink.syncBuffers    = [];
    sink.on('preprocess', sink.writeBuffersSync);
    sink.on('postprocess', sink.writeBuffersAsync);
});

proto.writeMode     = 'async';
proto.asyncBuffers  = proto.syncBuffers = null;

/**
 * Private method that handles the mixing of asynchronously written buffers.
 *
 * @method Sink
 * @name writeBuffersAsync
 *
 * @arg {Array} buffer The buffer to write to.
*/
proto.writeBuffersAsync = function (buffer) {
    var buffers     = this.asyncBuffers,
        l       = buffer.length,
        buf,
        bufLength,
        i, n, offset;
    if (buffers) {
        for (i=0; i<buffers.length; i++) {
            buf     = buffers[i];
            bufLength   = buf.b.length;
            offset      = buf.d;
            buf.d       -= Math.min(offset, l);
            
            for (n=0; n + offset < l && n < bufLength; n++) {
                buffer[n + offset] += buf.b[n];
            }
            buf.b = buf.b.subarray(n + offset);
            if (i >= bufLength) {
                buffers.splice(i--, 1);
            }
        }
    }
};

/**
 * A private method that handles mixing synchronously written buffers.
 *
 * @method Sink
 * @name writeBuffersSync
 *
 * @arg {Array} buffer The buffer to write to.
*/
proto.writeBuffersSync = function (buffer) {
    var buffers     = this.syncBuffers,
        l       = buffer.length,
        i       = 0,
        soff        = 0;
    for (;i<l && buffers.length; i++) {
        buffer[i] += buffers[0][soff];
        if (buffers[0].length <= soff){
            buffers.splice(0, 1);
            soff = 0;
            continue;
        }
        soff++;
    }
    if (buffers.length) {
        buffers[0] = buffers[0].subarray(soff);
    }
};

/**
 * Writes a buffer asynchronously on top of the existing signal, after a specified delay.
 *
 * @method Sink
 * @name writeBufferAsync
 *
 * @arg {Array} buffer The buffer to write.
 * @arg {Number} delay The delay to write after. If not specified, the Sink will calculate a delay to compensate the latency.
 * @return {Number} The number of currently stored asynchronous buffers.
*/
proto.writeBufferAsync = function (buffer, delay) {
    buffer          = this.mode === 'deinterleaved' ? Sink.interleave(buffer, this.channelCount) : buffer;
    var buffers     = this.asyncBuffers;
    buffers.push({
        b: buffer,
        d: isNaN(delay) ? ~~((+new Date() - this.previousHit) / 1000 * this.sampleRate) : delay
    });
    return buffers.length;
};

/**
 * Writes a buffer synchronously to the output.
 *
 * @method Sink
 * @name writeBufferSync
 *
 * @param {Array} buffer The buffer to write.
 * @return {Number} The number of currently stored synchronous buffers.
*/
proto.writeBufferSync = function (buffer) {
    buffer          = this.mode === 'deinterleaved' ? Sink.interleave(buffer, this.channelCount) : buffer;
    var buffers     = this.syncBuffers;
    buffers.push(buffer);
    return buffers.length;
};

/**
 * Writes a buffer, according to the write mode specified.
 *
 * @method Sink
 * @name writeBuffer
 *
 * @arg {Array} buffer The buffer to write.
 * @arg {Number} delay The delay to write after. If not specified, the Sink will calculate a delay to compensate the latency. (only applicable in asynchronous write mode)
 * @return {Number} The number of currently stored (a)synchronous buffers.
*/
proto.writeBuffer = function () {
    return this[this.writeMode === 'async' ? 'writeBufferAsync' : 'writeBufferSync'].apply(this, arguments);
};

/**
 * Gets the total amount of yet unwritten samples in the synchronous buffers.
 *
 * @method Sink
 * @name getSyncWriteOffset
 *
 * @return {Number} The total amount of yet unwritten samples in the synchronous buffers.
*/
proto.getSyncWriteOffset = function () {
    var buffers     = this.syncBuffers,
        offset      = 0,
        i;
    for (i=0; i<buffers.length; i++) {
        offset += buffers[i].length;
    }
    return offset;
};

} (this.Sink);