719 lines
23 KiB
JavaScript
719 lines
23 KiB
JavaScript
|
|
// source code from: http://typedarray.org/wp-content/projects/WebAudioRecorder/script.js
|
||
|
|
// https://github.com/mattdiamond/Recorderjs#license-mit
|
||
|
|
// ______________________
|
||
|
|
// StereoAudioRecorder.js
|
||
|
|
|
||
|
|
/**
|
||
|
|
* StereoAudioRecorder is a standalone class used by {@link RecordRTC} to bring "stereo" audio-recording in chrome.
|
||
|
|
* @summary JavaScript standalone object for stereo audio recording.
|
||
|
|
* @license {@link https://github.com/muaz-khan/RecordRTC#license|MIT}
|
||
|
|
* @author {@link http://www.MuazKhan.com|Muaz Khan}
|
||
|
|
* @typedef StereoAudioRecorder
|
||
|
|
* @class
|
||
|
|
* @example
|
||
|
|
* var recorder = new StereoAudioRecorder(MediaStream, {
|
||
|
|
* sampleRate: 44100,
|
||
|
|
* bufferSize: 4096
|
||
|
|
* });
|
||
|
|
* recorder.record();
|
||
|
|
* recorder.stop(function(blob) {
|
||
|
|
* video.src = URL.createObjectURL(blob);
|
||
|
|
* });
|
||
|
|
* @see {@link https://github.com/muaz-khan/RecordRTC|RecordRTC Source Code}
|
||
|
|
* @param {MediaStream} mediaStream - MediaStream object fetched using getUserMedia API or generated using captureStreamUntilEnded or WebAudio API.
|
||
|
|
* @param {object} config - {sampleRate: 44100, bufferSize: 4096, numberOfAudioChannels: 1, etc.}
|
||
|
|
*/
|
||
|
|
|
||
|
|
function StereoAudioRecorder(mediaStream, config) {
|
||
|
|
if (!getTracks(mediaStream, 'audio').length) {
|
||
|
|
throw 'Your stream has no audio tracks.';
|
||
|
|
}
|
||
|
|
|
||
|
|
config = config || {};
|
||
|
|
|
||
|
|
var self = this;
|
||
|
|
|
||
|
|
// variables
|
||
|
|
var leftchannel = [];
|
||
|
|
var rightchannel = [];
|
||
|
|
var recording = false;
|
||
|
|
var recordingLength = 0;
|
||
|
|
var jsAudioNode;
|
||
|
|
|
||
|
|
var numberOfAudioChannels = 2;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Set sample rates such as 8K or 16K. Reference: http://stackoverflow.com/a/28977136/552182
|
||
|
|
* @property {number} desiredSampRate - Desired Bits per sample * 1000
|
||
|
|
* @memberof StereoAudioRecorder
|
||
|
|
* @instance
|
||
|
|
* @example
|
||
|
|
* var recorder = StereoAudioRecorder(mediaStream, {
|
||
|
|
* desiredSampRate: 16 * 1000 // bits-per-sample * 1000
|
||
|
|
* });
|
||
|
|
*/
|
||
|
|
var desiredSampRate = config.desiredSampRate;
|
||
|
|
|
||
|
|
// backward compatibility
|
||
|
|
if (config.leftChannel === true) {
|
||
|
|
numberOfAudioChannels = 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (config.numberOfAudioChannels === 1) {
|
||
|
|
numberOfAudioChannels = 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!numberOfAudioChannels || numberOfAudioChannels < 1) {
|
||
|
|
numberOfAudioChannels = 2;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!config.disableLogs) {
|
||
|
|
console.log('StereoAudioRecorder is set to record number of channels: ' + numberOfAudioChannels);
|
||
|
|
}
|
||
|
|
|
||
|
|
// if any Track within the MediaStream is muted or not enabled at any time,
|
||
|
|
// the browser will only record black frames
|
||
|
|
// or silence since that is the content produced by the Track
|
||
|
|
// so we need to stopRecording as soon as any single track ends.
|
||
|
|
if (typeof config.checkForInactiveTracks === 'undefined') {
|
||
|
|
config.checkForInactiveTracks = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
function isMediaStreamActive() {
|
||
|
|
if (config.checkForInactiveTracks === false) {
|
||
|
|
// always return "true"
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ('active' in mediaStream) {
|
||
|
|
if (!mediaStream.active) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
} else if ('ended' in mediaStream) { // old hack
|
||
|
|
if (mediaStream.ended) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* This method records MediaStream.
|
||
|
|
* @method
|
||
|
|
* @memberof StereoAudioRecorder
|
||
|
|
* @example
|
||
|
|
* recorder.record();
|
||
|
|
*/
|
||
|
|
this.record = function() {
|
||
|
|
if (isMediaStreamActive() === false) {
|
||
|
|
throw 'Please make sure MediaStream is active.';
|
||
|
|
}
|
||
|
|
|
||
|
|
resetVariables();
|
||
|
|
|
||
|
|
isAudioProcessStarted = isPaused = false;
|
||
|
|
recording = true;
|
||
|
|
|
||
|
|
if (typeof config.timeSlice !== 'undefined') {
|
||
|
|
looper();
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
function mergeLeftRightBuffers(config, callback) {
|
||
|
|
function mergeAudioBuffers(config, cb) {
|
||
|
|
var numberOfAudioChannels = config.numberOfAudioChannels;
|
||
|
|
|
||
|
|
// todo: "slice(0)" --- is it causes loop? Should be removed?
|
||
|
|
var leftBuffers = config.leftBuffers.slice(0);
|
||
|
|
var rightBuffers = config.rightBuffers.slice(0);
|
||
|
|
var sampleRate = config.sampleRate;
|
||
|
|
var internalInterleavedLength = config.internalInterleavedLength;
|
||
|
|
var desiredSampRate = config.desiredSampRate;
|
||
|
|
|
||
|
|
if (numberOfAudioChannels === 2) {
|
||
|
|
leftBuffers = mergeBuffers(leftBuffers, internalInterleavedLength);
|
||
|
|
rightBuffers = mergeBuffers(rightBuffers, internalInterleavedLength);
|
||
|
|
|
||
|
|
if (desiredSampRate) {
|
||
|
|
leftBuffers = interpolateArray(leftBuffers, desiredSampRate, sampleRate);
|
||
|
|
rightBuffers = interpolateArray(rightBuffers, desiredSampRate, sampleRate);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (numberOfAudioChannels === 1) {
|
||
|
|
leftBuffers = mergeBuffers(leftBuffers, internalInterleavedLength);
|
||
|
|
|
||
|
|
if (desiredSampRate) {
|
||
|
|
leftBuffers = interpolateArray(leftBuffers, desiredSampRate, sampleRate);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// set sample rate as desired sample rate
|
||
|
|
if (desiredSampRate) {
|
||
|
|
sampleRate = desiredSampRate;
|
||
|
|
}
|
||
|
|
|
||
|
|
// for changing the sampling rate, reference:
|
||
|
|
// http://stackoverflow.com/a/28977136/552182
|
||
|
|
function interpolateArray(data, newSampleRate, oldSampleRate) {
|
||
|
|
var fitCount = Math.round(data.length * (newSampleRate / oldSampleRate));
|
||
|
|
var newData = [];
|
||
|
|
var springFactor = Number((data.length - 1) / (fitCount - 1));
|
||
|
|
newData[0] = data[0];
|
||
|
|
for (var i = 1; i < fitCount - 1; i++) {
|
||
|
|
var tmp = i * springFactor;
|
||
|
|
var before = Number(Math.floor(tmp)).toFixed();
|
||
|
|
var after = Number(Math.ceil(tmp)).toFixed();
|
||
|
|
var atPoint = tmp - before;
|
||
|
|
newData[i] = linearInterpolate(data[before], data[after], atPoint);
|
||
|
|
}
|
||
|
|
newData[fitCount - 1] = data[data.length - 1];
|
||
|
|
return newData;
|
||
|
|
}
|
||
|
|
|
||
|
|
function linearInterpolate(before, after, atPoint) {
|
||
|
|
return before + (after - before) * atPoint;
|
||
|
|
}
|
||
|
|
|
||
|
|
function mergeBuffers(channelBuffer, rLength) {
|
||
|
|
var result = new Float64Array(rLength);
|
||
|
|
var offset = 0;
|
||
|
|
var lng = channelBuffer.length;
|
||
|
|
|
||
|
|
for (var i = 0; i < lng; i++) {
|
||
|
|
var buffer = channelBuffer[i];
|
||
|
|
result.set(buffer, offset);
|
||
|
|
offset += buffer.length;
|
||
|
|
}
|
||
|
|
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
function interleave(leftChannel, rightChannel) {
|
||
|
|
var length = leftChannel.length + rightChannel.length;
|
||
|
|
|
||
|
|
var result = new Float64Array(length);
|
||
|
|
|
||
|
|
var inputIndex = 0;
|
||
|
|
|
||
|
|
for (var index = 0; index < length;) {
|
||
|
|
result[index++] = leftChannel[inputIndex];
|
||
|
|
result[index++] = rightChannel[inputIndex];
|
||
|
|
inputIndex++;
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
function writeUTFBytes(view, offset, string) {
|
||
|
|
var lng = string.length;
|
||
|
|
for (var i = 0; i < lng; i++) {
|
||
|
|
view.setUint8(offset + i, string.charCodeAt(i));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// interleave both channels together
|
||
|
|
var interleaved;
|
||
|
|
|
||
|
|
if (numberOfAudioChannels === 2) {
|
||
|
|
interleaved = interleave(leftBuffers, rightBuffers);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (numberOfAudioChannels === 1) {
|
||
|
|
interleaved = leftBuffers;
|
||
|
|
}
|
||
|
|
|
||
|
|
var interleavedLength = interleaved.length;
|
||
|
|
|
||
|
|
// create wav file
|
||
|
|
var resultingBufferLength = 44 + interleavedLength * 2;
|
||
|
|
|
||
|
|
var buffer = new ArrayBuffer(resultingBufferLength);
|
||
|
|
|
||
|
|
var view = new DataView(buffer);
|
||
|
|
|
||
|
|
// RIFF chunk descriptor/identifier
|
||
|
|
writeUTFBytes(view, 0, 'RIFF');
|
||
|
|
|
||
|
|
// RIFF chunk length
|
||
|
|
// changed "44" to "36" via #401
|
||
|
|
view.setUint32(4, 36 + interleavedLength * 2, true);
|
||
|
|
|
||
|
|
// RIFF type
|
||
|
|
writeUTFBytes(view, 8, 'WAVE');
|
||
|
|
|
||
|
|
// format chunk identifier
|
||
|
|
// FMT sub-chunk
|
||
|
|
writeUTFBytes(view, 12, 'fmt ');
|
||
|
|
|
||
|
|
// format chunk length
|
||
|
|
view.setUint32(16, 16, true);
|
||
|
|
|
||
|
|
// sample format (raw)
|
||
|
|
view.setUint16(20, 1, true);
|
||
|
|
|
||
|
|
// stereo (2 channels)
|
||
|
|
view.setUint16(22, numberOfAudioChannels, true);
|
||
|
|
|
||
|
|
// sample rate
|
||
|
|
view.setUint32(24, sampleRate, true);
|
||
|
|
|
||
|
|
// byte rate (sample rate * block align)
|
||
|
|
view.setUint32(28, sampleRate * 2, true);
|
||
|
|
|
||
|
|
// block align (channel count * bytes per sample)
|
||
|
|
view.setUint16(32, numberOfAudioChannels * 2, true);
|
||
|
|
|
||
|
|
// bits per sample
|
||
|
|
view.setUint16(34, 16, true);
|
||
|
|
|
||
|
|
// data sub-chunk
|
||
|
|
// data chunk identifier
|
||
|
|
writeUTFBytes(view, 36, 'data');
|
||
|
|
|
||
|
|
// data chunk length
|
||
|
|
view.setUint32(40, interleavedLength * 2, true);
|
||
|
|
|
||
|
|
// write the PCM samples
|
||
|
|
var lng = interleavedLength;
|
||
|
|
var index = 44;
|
||
|
|
var volume = 1;
|
||
|
|
for (var i = 0; i < lng; i++) {
|
||
|
|
view.setInt16(index, interleaved[i] * (0x7FFF * volume), true);
|
||
|
|
index += 2;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (cb) {
|
||
|
|
return cb({
|
||
|
|
buffer: buffer,
|
||
|
|
view: view
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
postMessage({
|
||
|
|
buffer: buffer,
|
||
|
|
view: view
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
if (config.noWorker) {
|
||
|
|
mergeAudioBuffers(config, function(data) {
|
||
|
|
callback(data.buffer, data.view);
|
||
|
|
});
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
var webWorker = processInWebWorker(mergeAudioBuffers);
|
||
|
|
|
||
|
|
webWorker.onmessage = function(event) {
|
||
|
|
callback(event.data.buffer, event.data.view);
|
||
|
|
|
||
|
|
// release memory
|
||
|
|
URL.revokeObjectURL(webWorker.workerURL);
|
||
|
|
|
||
|
|
// kill webworker (or Chrome will kill your page after ~25 calls)
|
||
|
|
webWorker.terminate();
|
||
|
|
};
|
||
|
|
|
||
|
|
webWorker.postMessage(config);
|
||
|
|
}
|
||
|
|
|
||
|
|
function processInWebWorker(_function) {
|
||
|
|
var workerURL = URL.createObjectURL(new Blob([_function.toString(),
|
||
|
|
';this.onmessage = function (eee) {' + _function.name + '(eee.data);}'
|
||
|
|
], {
|
||
|
|
type: 'application/javascript'
|
||
|
|
}));
|
||
|
|
|
||
|
|
var worker = new Worker(workerURL);
|
||
|
|
worker.workerURL = workerURL;
|
||
|
|
return worker;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* This method stops recording MediaStream.
|
||
|
|
* @param {function} callback - Callback function, that is used to pass recorded blob back to the callee.
|
||
|
|
* @method
|
||
|
|
* @memberof StereoAudioRecorder
|
||
|
|
* @example
|
||
|
|
* recorder.stop(function(blob) {
|
||
|
|
* video.src = URL.createObjectURL(blob);
|
||
|
|
* });
|
||
|
|
*/
|
||
|
|
this.stop = function(callback) {
|
||
|
|
callback = callback || function() {};
|
||
|
|
|
||
|
|
// stop recording
|
||
|
|
recording = false;
|
||
|
|
|
||
|
|
mergeLeftRightBuffers({
|
||
|
|
desiredSampRate: desiredSampRate,
|
||
|
|
sampleRate: sampleRate,
|
||
|
|
numberOfAudioChannels: numberOfAudioChannels,
|
||
|
|
internalInterleavedLength: recordingLength,
|
||
|
|
leftBuffers: leftchannel,
|
||
|
|
rightBuffers: numberOfAudioChannels === 1 ? [] : rightchannel,
|
||
|
|
noWorker: config.noWorker
|
||
|
|
}, function(buffer, view) {
|
||
|
|
/**
|
||
|
|
* @property {Blob} blob - The recorded blob object.
|
||
|
|
* @memberof StereoAudioRecorder
|
||
|
|
* @example
|
||
|
|
* recorder.stop(function(){
|
||
|
|
* var blob = recorder.blob;
|
||
|
|
* });
|
||
|
|
*/
|
||
|
|
self.blob = new Blob([view], {
|
||
|
|
type: 'audio/wav'
|
||
|
|
});
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @property {ArrayBuffer} buffer - The recorded buffer object.
|
||
|
|
* @memberof StereoAudioRecorder
|
||
|
|
* @example
|
||
|
|
* recorder.stop(function(){
|
||
|
|
* var buffer = recorder.buffer;
|
||
|
|
* });
|
||
|
|
*/
|
||
|
|
self.buffer = new ArrayBuffer(view.buffer.byteLength);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @property {DataView} view - The recorded data-view object.
|
||
|
|
* @memberof StereoAudioRecorder
|
||
|
|
* @example
|
||
|
|
* recorder.stop(function(){
|
||
|
|
* var view = recorder.view;
|
||
|
|
* });
|
||
|
|
*/
|
||
|
|
self.view = view;
|
||
|
|
|
||
|
|
self.sampleRate = desiredSampRate || sampleRate;
|
||
|
|
self.bufferSize = bufferSize;
|
||
|
|
|
||
|
|
// recorded audio length
|
||
|
|
self.length = recordingLength;
|
||
|
|
|
||
|
|
isAudioProcessStarted = false;
|
||
|
|
|
||
|
|
if (callback) {
|
||
|
|
callback(self.blob);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
};
|
||
|
|
|
||
|
|
if (typeof Storage === 'undefined') {
|
||
|
|
var Storage = {
|
||
|
|
AudioContextConstructor: null,
|
||
|
|
AudioContext: window.AudioContext || window.webkitAudioContext
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!Storage.AudioContextConstructor) {
|
||
|
|
Storage.AudioContextConstructor = new Storage.AudioContext();
|
||
|
|
}
|
||
|
|
|
||
|
|
var context = Storage.AudioContextConstructor;
|
||
|
|
|
||
|
|
// creates an audio node from the microphone incoming stream
|
||
|
|
var audioInput = context.createMediaStreamSource(mediaStream);
|
||
|
|
|
||
|
|
var legalBufferValues = [0, 256, 512, 1024, 2048, 4096, 8192, 16384];
|
||
|
|
|
||
|
|
/**
|
||
|
|
* From the spec: This value controls how frequently the audioprocess event is
|
||
|
|
* dispatched and how many sample-frames need to be processed each call.
|
||
|
|
* Lower values for buffer size will result in a lower (better) latency.
|
||
|
|
* Higher values will be necessary to avoid audio breakup and glitches
|
||
|
|
* The size of the buffer (in sample-frames) which needs to
|
||
|
|
* be processed each time onprocessaudio is called.
|
||
|
|
* Legal values are (256, 512, 1024, 2048, 4096, 8192, 16384).
|
||
|
|
* @property {number} bufferSize - Buffer-size for how frequently the audioprocess event is dispatched.
|
||
|
|
* @memberof StereoAudioRecorder
|
||
|
|
* @example
|
||
|
|
* recorder = new StereoAudioRecorder(mediaStream, {
|
||
|
|
* bufferSize: 4096
|
||
|
|
* });
|
||
|
|
*/
|
||
|
|
|
||
|
|
// "0" means, let chrome decide the most accurate buffer-size for current platform.
|
||
|
|
var bufferSize = typeof config.bufferSize === 'undefined' ? 4096 : config.bufferSize;
|
||
|
|
|
||
|
|
if (legalBufferValues.indexOf(bufferSize) === -1) {
|
||
|
|
if (!config.disableLogs) {
|
||
|
|
console.log('Legal values for buffer-size are ' + JSON.stringify(legalBufferValues, null, '\t'));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (context.createJavaScriptNode) {
|
||
|
|
jsAudioNode = context.createJavaScriptNode(bufferSize, numberOfAudioChannels, numberOfAudioChannels);
|
||
|
|
} else if (context.createScriptProcessor) {
|
||
|
|
jsAudioNode = context.createScriptProcessor(bufferSize, numberOfAudioChannels, numberOfAudioChannels);
|
||
|
|
} else {
|
||
|
|
throw 'WebAudio API has no support on this browser.';
|
||
|
|
}
|
||
|
|
|
||
|
|
// connect the stream to the script processor
|
||
|
|
audioInput.connect(jsAudioNode);
|
||
|
|
|
||
|
|
if (!config.bufferSize) {
|
||
|
|
bufferSize = jsAudioNode.bufferSize; // device buffer-size
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The sample rate (in sample-frames per second) at which the
|
||
|
|
* AudioContext handles audio. It is assumed that all AudioNodes
|
||
|
|
* in the context run at this rate. In making this assumption,
|
||
|
|
* sample-rate converters or "varispeed" processors are not supported
|
||
|
|
* in real-time processing.
|
||
|
|
* The sampleRate parameter describes the sample-rate of the
|
||
|
|
* linear PCM audio data in the buffer in sample-frames per second.
|
||
|
|
* An implementation must support sample-rates in at least
|
||
|
|
* the range 22050 to 96000.
|
||
|
|
* @property {number} sampleRate - Buffer-size for how frequently the audioprocess event is dispatched.
|
||
|
|
* @memberof StereoAudioRecorder
|
||
|
|
* @example
|
||
|
|
* recorder = new StereoAudioRecorder(mediaStream, {
|
||
|
|
* sampleRate: 44100
|
||
|
|
* });
|
||
|
|
*/
|
||
|
|
var sampleRate = typeof config.sampleRate !== 'undefined' ? config.sampleRate : context.sampleRate || 44100;
|
||
|
|
|
||
|
|
if (sampleRate < 22050 || sampleRate > 96000) {
|
||
|
|
// Ref: http://stackoverflow.com/a/26303918/552182
|
||
|
|
if (!config.disableLogs) {
|
||
|
|
console.log('sample-rate must be under range 22050 and 96000.');
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!config.disableLogs) {
|
||
|
|
if (config.desiredSampRate) {
|
||
|
|
console.log('Desired sample-rate: ' + config.desiredSampRate);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
var isPaused = false;
|
||
|
|
/**
|
||
|
|
* This method pauses the recording process.
|
||
|
|
* @method
|
||
|
|
* @memberof StereoAudioRecorder
|
||
|
|
* @example
|
||
|
|
* recorder.pause();
|
||
|
|
*/
|
||
|
|
this.pause = function() {
|
||
|
|
isPaused = true;
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* This method resumes the recording process.
|
||
|
|
* @method
|
||
|
|
* @memberof StereoAudioRecorder
|
||
|
|
* @example
|
||
|
|
* recorder.resume();
|
||
|
|
*/
|
||
|
|
this.resume = function() {
|
||
|
|
if (isMediaStreamActive() === false) {
|
||
|
|
throw 'Please make sure MediaStream is active.';
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!recording) {
|
||
|
|
if (!config.disableLogs) {
|
||
|
|
console.log('Seems recording has been restarted.');
|
||
|
|
}
|
||
|
|
this.record();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
isPaused = false;
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* This method resets currently recorded data.
|
||
|
|
* @method
|
||
|
|
* @memberof StereoAudioRecorder
|
||
|
|
* @example
|
||
|
|
* recorder.clearRecordedData();
|
||
|
|
*/
|
||
|
|
this.clearRecordedData = function() {
|
||
|
|
config.checkForInactiveTracks = false;
|
||
|
|
|
||
|
|
if (recording) {
|
||
|
|
this.stop(clearRecordedDataCB);
|
||
|
|
}
|
||
|
|
|
||
|
|
clearRecordedDataCB();
|
||
|
|
};
|
||
|
|
|
||
|
|
function resetVariables() {
|
||
|
|
leftchannel = [];
|
||
|
|
rightchannel = [];
|
||
|
|
recordingLength = 0;
|
||
|
|
isAudioProcessStarted = false;
|
||
|
|
recording = false;
|
||
|
|
isPaused = false;
|
||
|
|
context = null;
|
||
|
|
|
||
|
|
self.leftchannel = leftchannel;
|
||
|
|
self.rightchannel = rightchannel;
|
||
|
|
self.numberOfAudioChannels = numberOfAudioChannels;
|
||
|
|
self.desiredSampRate = desiredSampRate;
|
||
|
|
self.sampleRate = sampleRate;
|
||
|
|
self.recordingLength = recordingLength;
|
||
|
|
|
||
|
|
intervalsBasedBuffers = {
|
||
|
|
left: [],
|
||
|
|
right: [],
|
||
|
|
recordingLength: 0
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
function clearRecordedDataCB() {
|
||
|
|
if (jsAudioNode) {
|
||
|
|
jsAudioNode.onaudioprocess = null;
|
||
|
|
jsAudioNode.disconnect();
|
||
|
|
jsAudioNode = null;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (audioInput) {
|
||
|
|
audioInput.disconnect();
|
||
|
|
audioInput = null;
|
||
|
|
}
|
||
|
|
|
||
|
|
resetVariables();
|
||
|
|
}
|
||
|
|
|
||
|
|
// for debugging
|
||
|
|
this.name = 'StereoAudioRecorder';
|
||
|
|
this.toString = function() {
|
||
|
|
return this.name;
|
||
|
|
};
|
||
|
|
|
||
|
|
var isAudioProcessStarted = false;
|
||
|
|
|
||
|
|
function onAudioProcessDataAvailable(e) {
|
||
|
|
if (isPaused) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (isMediaStreamActive() === false) {
|
||
|
|
if (!config.disableLogs) {
|
||
|
|
console.log('MediaStream seems stopped.');
|
||
|
|
}
|
||
|
|
jsAudioNode.disconnect();
|
||
|
|
recording = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!recording) {
|
||
|
|
if (audioInput) {
|
||
|
|
audioInput.disconnect();
|
||
|
|
audioInput = null;
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* This method is called on "onaudioprocess" event's first invocation.
|
||
|
|
* @method {function} onAudioProcessStarted
|
||
|
|
* @memberof StereoAudioRecorder
|
||
|
|
* @example
|
||
|
|
* recorder.onAudioProcessStarted: function() { };
|
||
|
|
*/
|
||
|
|
if (!isAudioProcessStarted) {
|
||
|
|
isAudioProcessStarted = true;
|
||
|
|
if (config.onAudioProcessStarted) {
|
||
|
|
config.onAudioProcessStarted();
|
||
|
|
}
|
||
|
|
|
||
|
|
if (config.initCallback) {
|
||
|
|
config.initCallback();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
var left = e.inputBuffer.getChannelData(0);
|
||
|
|
|
||
|
|
// we clone the samples
|
||
|
|
var chLeft = new Float32Array(left);
|
||
|
|
leftchannel.push(chLeft);
|
||
|
|
|
||
|
|
if (numberOfAudioChannels === 2) {
|
||
|
|
var right = e.inputBuffer.getChannelData(1);
|
||
|
|
var chRight = new Float32Array(right);
|
||
|
|
rightchannel.push(chRight);
|
||
|
|
}
|
||
|
|
|
||
|
|
recordingLength += bufferSize;
|
||
|
|
|
||
|
|
// export raw PCM
|
||
|
|
self.recordingLength = recordingLength;
|
||
|
|
|
||
|
|
if (typeof config.timeSlice !== 'undefined') {
|
||
|
|
intervalsBasedBuffers.recordingLength += bufferSize;
|
||
|
|
intervalsBasedBuffers.left.push(chLeft);
|
||
|
|
|
||
|
|
if (numberOfAudioChannels === 2) {
|
||
|
|
intervalsBasedBuffers.right.push(chRight);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
jsAudioNode.onaudioprocess = onAudioProcessDataAvailable;
|
||
|
|
|
||
|
|
// to prevent self audio to be connected with speakers
|
||
|
|
if (context.createMediaStreamDestination) {
|
||
|
|
jsAudioNode.connect(context.createMediaStreamDestination());
|
||
|
|
} else {
|
||
|
|
jsAudioNode.connect(context.destination);
|
||
|
|
}
|
||
|
|
|
||
|
|
// export raw PCM
|
||
|
|
this.leftchannel = leftchannel;
|
||
|
|
this.rightchannel = rightchannel;
|
||
|
|
this.numberOfAudioChannels = numberOfAudioChannels;
|
||
|
|
this.desiredSampRate = desiredSampRate;
|
||
|
|
this.sampleRate = sampleRate;
|
||
|
|
self.recordingLength = recordingLength;
|
||
|
|
|
||
|
|
// helper for intervals based blobs
|
||
|
|
var intervalsBasedBuffers = {
|
||
|
|
left: [],
|
||
|
|
right: [],
|
||
|
|
recordingLength: 0
|
||
|
|
};
|
||
|
|
|
||
|
|
// this looper is used to support intervals based blobs (via timeSlice+ondataavailable)
|
||
|
|
function looper() {
|
||
|
|
if (!recording || typeof config.ondataavailable !== 'function' || typeof config.timeSlice === 'undefined') {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (intervalsBasedBuffers.left.length) {
|
||
|
|
mergeLeftRightBuffers({
|
||
|
|
desiredSampRate: desiredSampRate,
|
||
|
|
sampleRate: sampleRate,
|
||
|
|
numberOfAudioChannels: numberOfAudioChannels,
|
||
|
|
internalInterleavedLength: intervalsBasedBuffers.recordingLength,
|
||
|
|
leftBuffers: intervalsBasedBuffers.left,
|
||
|
|
rightBuffers: numberOfAudioChannels === 1 ? [] : intervalsBasedBuffers.right
|
||
|
|
}, function(buffer, view) {
|
||
|
|
var blob = new Blob([view], {
|
||
|
|
type: 'audio/wav'
|
||
|
|
});
|
||
|
|
config.ondataavailable(blob);
|
||
|
|
|
||
|
|
setTimeout(looper, config.timeSlice);
|
||
|
|
});
|
||
|
|
|
||
|
|
intervalsBasedBuffers = {
|
||
|
|
left: [],
|
||
|
|
right: [],
|
||
|
|
recordingLength: 0
|
||
|
|
};
|
||
|
|
} else {
|
||
|
|
setTimeout(looper, config.timeSlice);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (typeof RecordRTC !== 'undefined') {
|
||
|
|
RecordRTC.StereoAudioRecorder = StereoAudioRecorder;
|
||
|
|
}
|