source: gs3-extensions/web-audio/trunk/js-mad/sink.js-master/sink-light.js@ 28388

var Sink = this.Sink = function (global) {

/**
 * Creates a Sink according to specified parameters, if possible.
 *
 * @class
 *
 * @arg =!readFn
 * @arg =!channelCount
 * @arg =!bufferSize
 * @arg =!sampleRate
 *
 * @param {Function} readFn A callback to handle the buffer fills.
 * @param {Number} channelCount Channel count.
 * @param {Number} bufferSize (Optional) Specifies a pre-buffer size to control the amount of latency.
 * @param {Number} sampleRate Sample rate (ms).
 * @param {Number} default=0 writePosition Write position of the sink, as in how many samples have been written per channel.
 * @param {String} default=async writeMode The default mode of writing to the sink.
 * @param {String} default=interleaved channelMode The mode in which the sink asks the sample buffers to be channeled in.
 * @param {Number} default=0 previousHit The previous time of a callback.
 * @param {Buffer} default=null ringBuffer The ring buffer array of the sink. If null, ring buffering will not be applied.
 * @param {Number} default=0 ringOffset The current position of the ring buffer.
*/
function Sink (readFn, channelCount, bufferSize, sampleRate) {
    var sinks   = Sink.sinks.list,
        i;
    for (i=0; i<sinks.length; i++) {
        if (sinks[i].enabled) {
            try {
                return new sinks[i](readFn, channelCount, bufferSize, sampleRate);
            } catch(e1){}
        }
    }

    throw Sink.Error(0x02);
}

function SinkClass () {
}

Sink.SinkClass = SinkClass;

SinkClass.prototype = Sink.prototype = {
    sampleRate: 44100,
    channelCount: 2,
    bufferSize: 4096,

    writePosition: 0,
    previousHit: 0,
    ringOffset: 0,

    channelMode: 'interleaved',
    isReady: false,

/**
 * Does the initialization of the sink.
 * @method Sink
*/
    start: function (readFn, channelCount, bufferSize, sampleRate) {
        this.channelCount   = isNaN(channelCount) || channelCount === null ? this.channelCount: channelCount;
        this.bufferSize     = isNaN(bufferSize) || bufferSize === null ? this.bufferSize : bufferSize;
        this.sampleRate     = isNaN(sampleRate) || sampleRate === null ? this.sampleRate : sampleRate;
        this.readFn     = readFn;
        this.activeRecordings   = [];
        this.previousHit    = +new Date();
        Sink.EventEmitter.call(this);
        Sink.emit('init', [this].concat([].slice.call(arguments)));
    },
/**
 * The method which will handle all the different types of processing applied on a callback.
 * @method Sink
*/
    process: function (soundData, channelCount) {
        this.emit('preprocess', arguments);

        if (this.ringBuffer) {
            (this.channelMode === 'interleaved' ? this.ringSpin : this.ringSpinInterleaved).apply(this, arguments);
        }

        if (this.channelMode === 'interleaved') {
            this.emit('audioprocess', arguments);

            if (this.readFn) {
                this.readFn.apply(this, arguments);
            }
        } else {
            var soundDataSplit  = Sink.deinterleave(soundData, this.channelCount),
                args        = [soundDataSplit].concat([].slice.call(arguments, 1));
            this.emit('audioprocess', args);

            if (this.readFn) {
                this.readFn.apply(this, args);
            }

            Sink.interleave(soundDataSplit, this.channelCount, soundData);
        }
        this.emit('postprocess', arguments);
        this.previousHit = +new Date();
        this.writePosition += soundData.length / channelCount;
    },
/**
 * Get the current output position, defaults to writePosition - bufferSize.
 *
 * @method Sink
 *
 * @return {Number} The position of the write head, in samples, per channel.
*/
    getPlaybackTime: function () {
        return this.writePosition - this.bufferSize;
    },
/**
 * Internal method to send the ready signal if not ready yet.
 * @method Sink
*/
    ready: function () {
        if (this.isReady) return;

        this.isReady = true;
        this.emit('ready', []);
    }
};

/**
 * The container for all the available sinks. Also a decorator function for creating a new Sink class and binding it.
 *
 * @method Sink
 * @static
 *
 * @arg {String} type The name / type of the Sink.
 * @arg {Function} constructor The constructor function for the Sink.
 * @arg {Object} prototype The prototype of the Sink. (optional)
 * @arg {Boolean} disabled Whether the Sink should be disabled at first.
*/

function sinks (type, constructor, prototype, disabled, priority) {
    prototype = prototype || constructor.prototype;
    constructor.prototype = new Sink.SinkClass();
    constructor.prototype.type = type;
    constructor.enabled = !disabled;

    var k;
    for (k in prototype) {
        if (prototype.hasOwnProperty(k)) {
            constructor.prototype[k] = prototype[k];
        }
    }

    sinks[type] = constructor;
    sinks.list[priority ? 'unshift' : 'push'](constructor);
}

Sink.sinks = Sink.devices = sinks;
Sink.sinks.list = [];

Sink.singleton = function () {
    var sink = Sink.apply(null, arguments);

    Sink.singleton = function () {
        return sink;
    };

    return sink;
};

global.Sink = Sink;

return Sink;

}(function (){ return this; }());
void function (Sink) {

/**
 * A light event emitter.
 *
 * @class
 * @static Sink
*/
function EventEmitter () {
    var k;
    for (k in EventEmitter.prototype) {
        if (EventEmitter.prototype.hasOwnProperty(k)) {
            this[k] = EventEmitter.prototype[k];
        }
    }
    this._listeners = {};
}

EventEmitter.prototype = {
    _listeners: null,
/**
 * Emits an event.
 *
 * @method EventEmitter
 *
 * @arg {String} name The name of the event to emit.
 * @arg {Array} args The arguments to pass to the event handlers.
*/
    emit: function (name, args) {
        if (this._listeners[name]) {
            for (var i=0; i<this._listeners[name].length; i++) {
                this._listeners[name][i].apply(this, args);
            }
        }
        return this;
    },
/**
 * Adds an event listener to an event.
 *
 * @method EventEmitter
 *
 * @arg {String} name The name of the event.
 * @arg {Function} listener The event listener to attach to the event.
*/
    on: function (name, listener) {
        this._listeners[name] = this._listeners[name] || [];
        this._listeners[name].push(listener);
        return this;
    },
/**
 * Adds an event listener to an event.
 *
 * @method EventEmitter
 *
 * @arg {String} name The name of the event.
 * @arg {Function} !listener The event listener to remove from the event. If not specified, will delete all.
*/
    off: function (name, listener) {
        if (this._listeners[name]) {
            if (!listener) {
                delete this._listeners[name];
                return this;
            }

            for (var i=0; i<this._listeners[name].length; i++) {
                if (this._listeners[name][i] === listener) {
                    this._listeners[name].splice(i--, 1);
                }
            }

            if (!this._listeners[name].length) {
                delete this._listeners[name];
            }
        }
        return this;
    }
};

Sink.EventEmitter = EventEmitter;

EventEmitter.call(Sink);

}(this.Sink);
void function (Sink) {

/**
 * Creates a timer with consistent (ie. not clamped) intervals even in background tabs.
 * Uses inline workers to achieve this. If not available, will revert to regular timers.
 *
 * @static Sink
 * @name doInterval
 *
 * @arg {Function} callback The callback to trigger on timer hit.
 * @arg {Number} timeout The interval between timer hits.
 *
 * @return {Function} A function to cancel the timer.
*/

Sink.doInterval = function (callback, timeout) {
    var timer, kill;

    function create (noWorker) {
        if (Sink.inlineWorker.working && !noWorker) {
            timer = Sink.inlineWorker('setInterval(function (){ postMessage("tic"); }, ' + timeout + ');');
            timer.onmessage = function (){
                callback();
            };
            kill = function () {
                timer.terminate();
            };
        } else {
            timer = setInterval(callback, timeout);
            kill = function (){
                clearInterval(timer);
            };
        }
    }

    if (Sink.inlineWorker.ready) {
        create();
    } else {
        Sink.inlineWorker.on('ready', function () {
            create();
        });
    }

    return function () {
        if (!kill) {
            if (!Sink.inlineWorker.ready) {
                Sink.inlineWorker.on('ready', function () {
                    if (kill) kill();
                });
            }
        } else {
            kill();
        }
    };
};

}(this.Sink);
void function (Sink) {

var _Blob, _BlobBuilder, _URL, _btoa;

void function (prefixes, urlPrefixes) {
    function find (name, prefixes) {
        var b, a = prefixes.slice();

        for (b=a.shift(); typeof b !== 'undefined'; b=a.shift()) {
            b = Function('return typeof ' + b + name + 
                '=== "undefined" ? undefined : ' +
                b + name)();

            if (b) return b;
        }
    }

    _Blob = find('Blob', prefixes);
    _BlobBuilder = find('BlobBuilder', prefixes);
    _URL = find('URL', urlPrefixes);
    _btoa = find('btoa', ['']);
}([
    '',
    'Moz',
    'WebKit',
    'MS'
], [
    '',
    'webkit'
]);

var createBlob = _Blob && _URL && function (content, type) {
    return _URL.createObjectURL(new _Blob([content], { type: type }));
};

var createBlobBuilder = _BlobBuilder && _URL && function (content, type) {
    var bb = new _BlobBuilder();
    bb.append(content);

    return _URL.createObjectURL(bb.getBlob(type));
};

var createData = _btoa && function (content, type) {
    return 'data:' + type + ';base64,' + _btoa(content);
};

var createDynURL =
    createBlob ||
    createBlobBuilder ||
    createData;

if (!createDynURL) return;

if (createBlob) createDynURL.createBlob = createBlob;
if (createBlobBuilder) createDynURL.createBlobBuilder = createBlobBuilder;
if (createData) createDynURL.createData = createData;

if (_Blob) createDynURL.Blob = _Blob;
if (_BlobBuilder) createDynURL.BlobBuilder = _BlobBuilder;
if (_URL) createDynURL.URL = _URL;

Sink.createDynURL = createDynURL;

Sink.revokeDynURL = function (url) {
    if (typeof url === 'string' && url.indexOf('data:') === 0) {
        return false;
    } else {
        return _URL.revokeObjectURL(url);
    }
};

}(this.Sink);
void function (Sink) {

/*
 * A Sink-specific error class.
 *
 * @class
 * @static Sink
 * @name Error
 *
 * @arg =code
 *
 * @param {Number} code The error code.
 * @param {String} message A brief description of the error.
 * @param {String} explanation A more verbose explanation of why the error occured and how to fix.
*/

function SinkError(code) {
    if (!SinkError.hasOwnProperty(code)) throw SinkError(1);
    if (!(this instanceof SinkError)) return new SinkError(code);

    var k;
    for (k in SinkError[code]) {
        if (SinkError[code].hasOwnProperty(k)) {
            this[k] = SinkError[code][k];
        }
    }

    this.code = code;
}

SinkError.prototype = new Error();

SinkError.prototype.toString = function () {
    return 'SinkError 0x' + this.code.toString(16) + ': ' + this.message;
};

SinkError[0x01] = {
    message: 'No such error code.',
    explanation: 'The error code does not exist.'
};
SinkError[0x02] = {
    message: 'No audio sink available.',
    explanation: 'The audio device may be busy, or no supported output API is available for this browser.'
};

SinkError[0x10] = {
    message: 'Buffer underflow.',
    explanation: 'Trying to recover...'
};
SinkError[0x11] = {
    message: 'Critical recovery fail.',
    explanation: 'The buffer underflow has reached a critical point, trying to recover, but will probably fail anyway.'
};
SinkError[0x12] = {
    message: 'Buffer size too large.',
    explanation: 'Unable to allocate the buffer due to excessive length, please try a smaller buffer. Buffer size should probably be smaller than the sample rate.'
};

Sink.Error = SinkError;

}(this.Sink);
void function (Sink) {

/**
 * Creates an inline worker using a data/blob URL, if possible.
 *
 * @static Sink
 *
 * @arg {String} script
 *
 * @return {Worker} A web worker, or null if impossible to create.
*/

var define = Object.defineProperty ? function (obj, name, value) {
    Object.defineProperty(obj, name, {
        value: value,
        configurable: true,
        writable: true
    });
} : function (obj, name, value) {
    obj[name] = value;
};

function terminate () {
    define(this, 'terminate', this._terminate);

    Sink.revokeDynURL(this._url);

    delete this._url;
    delete this._terminate;
    return this.terminate();
}

function inlineWorker (script) {
    function wrap (type, content, typeName) {
        try {
            var url = type(content, 'text/javascript');
            var worker = new Worker(url);

            define(worker, '_url', url);
            define(worker, '_terminate', worker.terminate);
            define(worker, 'terminate', terminate);

            if (inlineWorker.type) return worker;

            inlineWorker.type = typeName;
            inlineWorker.createURL = type;

            return worker;
        } catch (e) {
            return null;
        }
    }

    var createDynURL = Sink.createDynURL;

    if (!createDynURL) return null;

    var worker;

    if (inlineWorker.createURL) {
        return wrap(inlineWorker.createURL, script, inlineWorker.type);
    }

    worker = wrap(createDynURL.createBlob, script, 'blob');
    if (worker) return worker;

    worker = wrap(createDynURL.createBlobBuilder, script, 'blobbuilder');
    if (worker) return worker;

    worker = wrap(createDynURL.createData, script, 'data');

    return worker;
}

Sink.EventEmitter.call(inlineWorker);

inlineWorker.test = function () {
    inlineWorker.ready = inlineWorker.working = false;
    inlineWorker.type = '';
    inlineWorker.createURL = null;

    var worker = inlineWorker('this.onmessage=function(e){postMessage(e.data)}');
    var data = 'inlineWorker';

    function ready (success) {
        if (inlineWorker.ready) return;

        inlineWorker.ready = true;
        inlineWorker.working = success;
        inlineWorker.emit('ready', [success]);
        inlineWorker.off('ready');

        if (success && worker) {
            worker.terminate();
        }

        worker = null;
    }

    if (!worker) {
        setTimeout(function () {
            ready(false);
        }, 0);
    } else {
        worker.onmessage = function (e) {
            ready(e.data === data);
        };

        worker.postMessage(data);

        setTimeout(function () {
            ready(false);
        }, 1000);
    }
};

Sink.inlineWorker = inlineWorker;

inlineWorker.test();

}(this.Sink);
 (function (sinks, fixChrome82795) {

var AudioContext = typeof window === 'undefined' ? null : window.webkitAudioContext || window.AudioContext;

/**
 * A sink class for the Web Audio API
*/

sinks('webaudio', function (readFn, channelCount, bufferSize, sampleRate) {
    var self        = this,
        context     = sinks.webaudio.getContext(),
        node        = null,
        soundData   = null,
        zeroBuffer  = null;
    self.start.apply(self, arguments);
    node = context.createJavaScriptNode(self.bufferSize, self.channelCount, self.channelCount);

    function bufferFill(e) {
        var outputBuffer    = e.outputBuffer,
            channelCount    = outputBuffer.numberOfChannels,
            i, n, l     = outputBuffer.length,
            size        = outputBuffer.size,
            channels    = new Array(channelCount),
            tail;

        self.ready();
        
        soundData   = soundData && soundData.length === l * channelCount ? soundData : new Float32Array(l * channelCount);
        zeroBuffer  = zeroBuffer && zeroBuffer.length === soundData.length ? zeroBuffer : new Float32Array(l * channelCount);
        soundData.set(zeroBuffer);

        for (i=0; i<channelCount; i++) {
            channels[i] = outputBuffer.getChannelData(i);
        }

        self.process(soundData, self.channelCount);

        for (i=0; i<l; i++) {
            for (n=0; n < channelCount; n++) {
                channels[n][i] = soundData[i * self.channelCount + n];
            }
        }
    }

    self.sampleRate = context.sampleRate;

    node.onaudioprocess = bufferFill;
    node.connect(context.destination);

    self._context       = context;
    self._node      = node;
    self._callback      = bufferFill;
    /* Keep references in order to avoid garbage collection removing the listeners, working around http://code.google.com/p/chromium/issues/detail?id=82795 */
    // Thanks to @baffo32
    fixChrome82795.push(node);
}, {
    kill: function () {
        this._node.disconnect(0);

        for (var i=0; i<fixChrome82795.length; i++) {
            if (fixChrome82795[i] === this._node) {
                fixChrome82795.splice(i--, 1);
            }
        }

        this._node = this._context = null;
        this.emit('kill');
    },

    getPlaybackTime: function () {
        return this._context.currentTime * this.sampleRate;
    }
}, false, true);

sinks.webkit = sinks.webaudio;

sinks.webaudio.fix82795 = fixChrome82795;

sinks.webaudio.getContext = function () {
    // For now, we have to accept that the AudioContext is at 48000Hz, or whatever it decides.
    var context = new AudioContext(/*sampleRate*/);

    sinks.webaudio.getContext = function () {
        return context;
    };

    return context;
};

}(this.Sink.sinks, []));
void function (Sink) {

/**
 * A Sink class for the Mozilla Audio Data API.
*/

Sink.sinks('audiodata', function () {
    var self            = this,
        currentWritePosition    = 0,
        tail            = null,
        audioDevice     = new Audio(),
        written, currentPosition, available, soundData, prevPos,
        timer; // Fix for https://bugzilla.mozilla.org/show_bug.cgi?id=630117
    self.start.apply(self, arguments);
    self.preBufferSize = isNaN(arguments[4]) || arguments[4] === null ? this.preBufferSize : arguments[4];

    function bufferFill() {
        if (tail) {
            written = audioDevice.mozWriteAudio(tail);
            currentWritePosition += written;
            if (written < tail.length){
                tail = tail.subarray(written);
                return tail;
            }
            tail = null;
        }

        currentPosition = audioDevice.mozCurrentSampleOffset();
        available = Number(currentPosition + (prevPos !== currentPosition ? self.bufferSize : self.preBufferSize) * self.channelCount - currentWritePosition);

        if (currentPosition === prevPos) {
            self.emit('error', [Sink.Error(0x10)]);
        }

        if (available > 0 || prevPos === currentPosition){
            self.ready();

            try {
                soundData = new Float32Array(prevPos === currentPosition ? self.preBufferSize * self.channelCount :
                    self.forceBufferSize ? available < self.bufferSize * 2 ? self.bufferSize * 2 : available : available);
            } catch(e) {
                self.emit('error', [Sink.Error(0x12)]);
                self.kill();
                return;
            }
            self.process(soundData, self.channelCount);
            written = self._audio.mozWriteAudio(soundData);
            if (written < soundData.length){
                tail = soundData.subarray(written);
            }
            currentWritePosition += written;
        }
        prevPos = currentPosition;
    }

    audioDevice.mozSetup(self.channelCount, self.sampleRate);

    this._timers = [];

    this._timers.push(Sink.doInterval(function () {
        // Check for complete death of the output
        if (+new Date() - self.previousHit > 2000) {
            self._audio = audioDevice = new Audio();
            audioDevice.mozSetup(self.channelCount, self.sampleRate);
            currentWritePosition = 0;
            self.emit('error', [Sink.Error(0x11)]);
        }
    }, 1000));

    this._timers.push(Sink.doInterval(bufferFill, self.interval));

    self._bufferFill    = bufferFill;
    self._audio     = audioDevice;
}, {
    // These are somewhat safe values...
    bufferSize: 24576,
    preBufferSize: 24576,
    forceBufferSize: false,
    interval: 100,

    kill: function () {
        while (this._timers.length) {
            this._timers.shift()();
        }

        this.emit('kill');
    },

    getPlaybackTime: function () {
        return this._audio.mozCurrentSampleOffset() / this.channelCount;
    }
}, false, true);

Sink.sinks.moz = Sink.sinks.audiodata;

}(this.Sink);