source: gs3-extensions/web-audio/trunk/js-mad/sink.js-master/src/utils/buffer-management.js@ 28388

(function (Sink) {

/**
 * Splits a sample buffer into those of different channels.
 *
 * @static Sink
 * @name deinterleave
 *
 * @arg {Buffer} buffer The sample buffer to split.
 * @arg {Number} channelCount The number of channels to split to.
 *
 * @return {Array} An array containing the resulting sample buffers.
*/

Sink.deinterleave = function (buffer, channelCount) {
    var l   = buffer.length,
        size    = l / channelCount,
        ret = [],
        i, n;
    for (i=0; i<channelCount; i++){
        ret[i] = new Float32Array(size);
        for (n=0; n<size; n++){
            ret[i][n] = buffer[n * channelCount + i];
        }
    }
    return ret;
};

/**
 * Joins an array of sample buffers into a single buffer.
 *
 * @static Sink
 * @name resample
 *
 * @arg {Array} buffers The buffers to join.
 * @arg {Number} !channelCount The number of channels. Defaults to buffers.length
 * @arg {Buffer} !buffer The output buffer.
 *
 * @return {Buffer} The interleaved buffer created.
*/

Sink.interleave = function (buffers, channelCount, buffer) {
    channelCount        = channelCount || buffers.length;
    var l       = buffers[0].length,
        bufferCount = buffers.length,
        i, n;
    buffer          = buffer || new Float32Array(l * channelCount);
    for (i=0; i<bufferCount; i++) {
        for (n=0; n<l; n++) {
            buffer[i + n * channelCount] = buffers[i][n];
        }
    }
    return buffer;
};

/**
 * Mixes two or more buffers down to one.
 *
 * @static Sink
 * @name mix
 *
 * @arg {Buffer} buffer The buffer to append the others to.
 * @arg {Buffer} bufferX The buffers to append from.
 *
 * @return {Buffer} The mixed buffer.
*/

Sink.mix = function (buffer) {
    var buffers = [].slice.call(arguments, 1),
        l, i, c;
    for (c=0; c<buffers.length; c++){
        l = Math.max(buffer.length, buffers[c].length);
        for (i=0; i<l; i++){
            buffer[i] += buffers[c][i];
        }
    }
    return buffer;
};

/**
 * Resets a buffer to all zeroes.
 *
 * @static Sink
 * @name resetBuffer
 *
 * @arg {Buffer} buffer The buffer to reset.
 *
 * @return {Buffer} The 0-reset buffer.
*/

Sink.resetBuffer = function (buffer) {
    var l   = buffer.length,
        i;
    for (i=0; i<l; i++){
        buffer[i] = 0;
    }
    return buffer;
};

/**
 * Copies the content of a buffer to another buffer.
 *
 * @static Sink
 * @name clone
 *
 * @arg {Buffer} buffer The buffer to copy from.
 * @arg {Buffer} !result The buffer to copy to.
 *
 * @return {Buffer} A clone of the buffer.
*/

Sink.clone = function (buffer, result) {
    var l   = buffer.length,
        i;
    result = result || new Float32Array(l);
    for (i=0; i<l; i++){
        result[i] = buffer[i];
    }
    return result;
};

/**
 * Creates an array of buffers of the specified length and the specified count.
 *
 * @static Sink
 * @name createDeinterleaved
 *
 * @arg {Number} length The length of a single channel.
 * @arg {Number} channelCount The number of channels.
 * @return {Array} The array of buffers.
*/

Sink.createDeinterleaved = function (length, channelCount) {
    var result  = new Array(channelCount),
        i;
    for (i=0; i<channelCount; i++){
        result[i] = new Float32Array(length);
    }
    return result;
};

Sink.memcpy = function (src, srcOffset, dst, dstOffset, length) {
    src = src.subarray || src.slice ? src : src.buffer;
    dst = dst.subarray || dst.slice ? dst : dst.buffer;

    src = srcOffset ? src.subarray ?
        src.subarray(srcOffset, length && srcOffset + length) :
        src.slice(srcOffset, length && srcOffset + length) : src;

    if (dst.set) {
        dst.set(src, dstOffset);
    } else {
        for (var i=0; i<src.length; i++) {
            dst[i + dstOffset] = src[i];
        }
    }

    return dst;
};

Sink.memslice = function (buffer, offset, length) {
    return buffer.subarray ? buffer.subarray(offset, length) : buffer.slice(offset, length);
};

Sink.mempad = function (buffer, out, offset) {
    out = out.length ? out : new (buffer.constructor)(out);
    Sink.memcpy(buffer, 0, out, offset);
    return out;
};

Sink.linspace = function (start, end, out) {
    var l, i, n, step;
    out = out.length ? (l=out.length) && out : Array(l=out);
    step    = (end - start) / --l;
    for (n=start+step, i=1; i<l; i++, n+=step) {
        out[i] = n;
    }
    out[0]  = start;
    out[l]  = end;
    return out;
};

Sink.ftoi = function (input, bitCount, output) {
    var i, mask = Math.pow(2, bitCount - 1);

    output = output || new (input.constructor)(input.length);

    for (i=0; i<input.length; i++) {
        output[i] = ~~(mask * input[i]);
    }

    return output;
};

}(this.Sink));