504 lines
16 KiB
JavaScript
504 lines
16 KiB
JavaScript
|
|
// _____________
|
||
|
|
// MRecordRTC.js
|
||
|
|
|
||
|
|
/**
|
||
|
|
* MRecordRTC runs on top of {@link RecordRTC} to bring multiple recordings in a single place, by providing simple API.
|
||
|
|
* @summary MRecordRTC stands for "Multiple-RecordRTC".
|
||
|
|
* @license {@link https://github.com/muaz-khan/RecordRTC#license|MIT}
|
||
|
|
* @author {@link http://www.MuazKhan.com|Muaz Khan}
|
||
|
|
* @typedef MRecordRTC
|
||
|
|
* @class
|
||
|
|
* @example
|
||
|
|
* var recorder = new MRecordRTC();
|
||
|
|
* recorder.addStream(MediaStream);
|
||
|
|
* recorder.mediaType = {
|
||
|
|
* audio: true, // or StereoAudioRecorder or MediaStreamRecorder
|
||
|
|
* video: true, // or WhammyRecorder or MediaStreamRecorder or WebAssemblyRecorder or CanvasRecorder
|
||
|
|
* gif: true // or GifRecorder
|
||
|
|
* };
|
||
|
|
* // mimeType is optional and should be set only in advance cases.
|
||
|
|
* recorder.mimeType = {
|
||
|
|
* audio: 'audio/wav',
|
||
|
|
* video: 'video/webm',
|
||
|
|
* gif: 'image/gif'
|
||
|
|
* };
|
||
|
|
* recorder.startRecording();
|
||
|
|
* @see For further information:
|
||
|
|
* @see {@link https://github.com/muaz-khan/RecordRTC/tree/master/MRecordRTC|MRecordRTC Source Code}
|
||
|
|
* @param {MediaStream} mediaStream - MediaStream object fetched using getUserMedia API or generated using captureStreamUntilEnded or WebAudio API.
|
||
|
|
* @requires {@link RecordRTC}
|
||
|
|
*/
|
||
|
|
|
||
|
|
function MRecordRTC(mediaStream) {
|
||
|
|
|
||
|
|
/**
|
||
|
|
* This method attaches MediaStream object to {@link MRecordRTC}.
|
||
|
|
* @param {MediaStream} mediaStream - A MediaStream object, either fetched using getUserMedia API, or generated using captureStreamUntilEnded or WebAudio API.
|
||
|
|
* @method
|
||
|
|
* @memberof MRecordRTC
|
||
|
|
* @example
|
||
|
|
* recorder.addStream(MediaStream);
|
||
|
|
*/
|
||
|
|
this.addStream = function(_mediaStream) {
|
||
|
|
if (_mediaStream) {
|
||
|
|
mediaStream = _mediaStream;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* This property can be used to set the recording type e.g. audio, or video, or gif, or canvas.
|
||
|
|
* @property {object} mediaType - {audio: true, video: true, gif: true}
|
||
|
|
* @memberof MRecordRTC
|
||
|
|
* @example
|
||
|
|
* var recorder = new MRecordRTC();
|
||
|
|
* recorder.mediaType = {
|
||
|
|
* audio: true, // TRUE or StereoAudioRecorder or MediaStreamRecorder
|
||
|
|
* video: true, // TRUE or WhammyRecorder or MediaStreamRecorder or WebAssemblyRecorder or CanvasRecorder
|
||
|
|
* gif : true // TRUE or GifRecorder
|
||
|
|
* };
|
||
|
|
*/
|
||
|
|
this.mediaType = {
|
||
|
|
audio: true,
|
||
|
|
video: true
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* This method starts recording.
|
||
|
|
* @method
|
||
|
|
* @memberof MRecordRTC
|
||
|
|
* @example
|
||
|
|
* recorder.startRecording();
|
||
|
|
*/
|
||
|
|
this.startRecording = function() {
|
||
|
|
var mediaType = this.mediaType;
|
||
|
|
var recorderType;
|
||
|
|
var mimeType = this.mimeType || {
|
||
|
|
audio: null,
|
||
|
|
video: null,
|
||
|
|
gif: null
|
||
|
|
};
|
||
|
|
|
||
|
|
if (typeof mediaType.audio !== 'function' && isMediaRecorderCompatible() && !getTracks(mediaStream, 'audio').length) {
|
||
|
|
mediaType.audio = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (typeof mediaType.video !== 'function' && isMediaRecorderCompatible() && !getTracks(mediaStream, 'video').length) {
|
||
|
|
mediaType.video = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (typeof mediaType.gif !== 'function' && isMediaRecorderCompatible() && !getTracks(mediaStream, 'video').length) {
|
||
|
|
mediaType.gif = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!mediaType.audio && !mediaType.video && !mediaType.gif) {
|
||
|
|
throw 'MediaStream must have either audio or video tracks.';
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!!mediaType.audio) {
|
||
|
|
recorderType = null;
|
||
|
|
if (typeof mediaType.audio === 'function') {
|
||
|
|
recorderType = mediaType.audio;
|
||
|
|
}
|
||
|
|
|
||
|
|
this.audioRecorder = new RecordRTC(mediaStream, {
|
||
|
|
type: 'audio',
|
||
|
|
bufferSize: this.bufferSize,
|
||
|
|
sampleRate: this.sampleRate,
|
||
|
|
numberOfAudioChannels: this.numberOfAudioChannels || 2,
|
||
|
|
disableLogs: this.disableLogs,
|
||
|
|
recorderType: recorderType,
|
||
|
|
mimeType: mimeType.audio,
|
||
|
|
timeSlice: this.timeSlice,
|
||
|
|
onTimeStamp: this.onTimeStamp
|
||
|
|
});
|
||
|
|
|
||
|
|
if (!mediaType.video) {
|
||
|
|
this.audioRecorder.startRecording();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!!mediaType.video) {
|
||
|
|
recorderType = null;
|
||
|
|
if (typeof mediaType.video === 'function') {
|
||
|
|
recorderType = mediaType.video;
|
||
|
|
}
|
||
|
|
|
||
|
|
var newStream = mediaStream;
|
||
|
|
|
||
|
|
if (isMediaRecorderCompatible() && !!mediaType.audio && typeof mediaType.audio === 'function') {
|
||
|
|
var videoTrack = getTracks(mediaStream, 'video')[0];
|
||
|
|
|
||
|
|
if (isFirefox) {
|
||
|
|
newStream = new MediaStream();
|
||
|
|
newStream.addTrack(videoTrack);
|
||
|
|
|
||
|
|
if (recorderType && recorderType === WhammyRecorder) {
|
||
|
|
// Firefox does NOT supports webp-encoding yet
|
||
|
|
// But Firefox do supports WebAssemblyRecorder
|
||
|
|
recorderType = MediaStreamRecorder;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
newStream = new MediaStream();
|
||
|
|
newStream.addTrack(videoTrack);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
this.videoRecorder = new RecordRTC(newStream, {
|
||
|
|
type: 'video',
|
||
|
|
video: this.video,
|
||
|
|
canvas: this.canvas,
|
||
|
|
frameInterval: this.frameInterval || 10,
|
||
|
|
disableLogs: this.disableLogs,
|
||
|
|
recorderType: recorderType,
|
||
|
|
mimeType: mimeType.video,
|
||
|
|
timeSlice: this.timeSlice,
|
||
|
|
onTimeStamp: this.onTimeStamp,
|
||
|
|
workerPath: this.workerPath,
|
||
|
|
webAssemblyPath: this.webAssemblyPath,
|
||
|
|
frameRate: this.frameRate, // used by WebAssemblyRecorder; values: usually 30; accepts any.
|
||
|
|
bitrate: this.bitrate // used by WebAssemblyRecorder; values: 0 to 1000+
|
||
|
|
});
|
||
|
|
|
||
|
|
if (!mediaType.audio) {
|
||
|
|
this.videoRecorder.startRecording();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!!mediaType.audio && !!mediaType.video) {
|
||
|
|
var self = this;
|
||
|
|
|
||
|
|
var isSingleRecorder = isMediaRecorderCompatible() === true;
|
||
|
|
|
||
|
|
if (mediaType.audio instanceof StereoAudioRecorder && !!mediaType.video) {
|
||
|
|
isSingleRecorder = false;
|
||
|
|
} else if (mediaType.audio !== true && mediaType.video !== true && mediaType.audio !== mediaType.video) {
|
||
|
|
isSingleRecorder = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (isSingleRecorder === true) {
|
||
|
|
self.audioRecorder = null;
|
||
|
|
self.videoRecorder.startRecording();
|
||
|
|
} else {
|
||
|
|
self.videoRecorder.initRecorder(function() {
|
||
|
|
self.audioRecorder.initRecorder(function() {
|
||
|
|
// Both recorders are ready to record things accurately
|
||
|
|
self.videoRecorder.startRecording();
|
||
|
|
self.audioRecorder.startRecording();
|
||
|
|
});
|
||
|
|
});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!!mediaType.gif) {
|
||
|
|
recorderType = null;
|
||
|
|
if (typeof mediaType.gif === 'function') {
|
||
|
|
recorderType = mediaType.gif;
|
||
|
|
}
|
||
|
|
this.gifRecorder = new RecordRTC(mediaStream, {
|
||
|
|
type: 'gif',
|
||
|
|
frameRate: this.frameRate || 200,
|
||
|
|
quality: this.quality || 10,
|
||
|
|
disableLogs: this.disableLogs,
|
||
|
|
recorderType: recorderType,
|
||
|
|
mimeType: mimeType.gif
|
||
|
|
});
|
||
|
|
this.gifRecorder.startRecording();
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* This method stops recording.
|
||
|
|
* @param {function} callback - Callback function is invoked when all encoders finished their jobs.
|
||
|
|
* @method
|
||
|
|
* @memberof MRecordRTC
|
||
|
|
* @example
|
||
|
|
* recorder.stopRecording(function(recording){
|
||
|
|
* var audioBlob = recording.audio;
|
||
|
|
* var videoBlob = recording.video;
|
||
|
|
* var gifBlob = recording.gif;
|
||
|
|
* });
|
||
|
|
*/
|
||
|
|
this.stopRecording = function(callback) {
|
||
|
|
callback = callback || function() {};
|
||
|
|
|
||
|
|
if (this.audioRecorder) {
|
||
|
|
this.audioRecorder.stopRecording(function(blobURL) {
|
||
|
|
callback(blobURL, 'audio');
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
if (this.videoRecorder) {
|
||
|
|
this.videoRecorder.stopRecording(function(blobURL) {
|
||
|
|
callback(blobURL, 'video');
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
if (this.gifRecorder) {
|
||
|
|
this.gifRecorder.stopRecording(function(blobURL) {
|
||
|
|
callback(blobURL, 'gif');
|
||
|
|
});
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* This method pauses recording.
|
||
|
|
* @method
|
||
|
|
* @memberof MRecordRTC
|
||
|
|
* @example
|
||
|
|
* recorder.pauseRecording();
|
||
|
|
*/
|
||
|
|
this.pauseRecording = function() {
|
||
|
|
if (this.audioRecorder) {
|
||
|
|
this.audioRecorder.pauseRecording();
|
||
|
|
}
|
||
|
|
|
||
|
|
if (this.videoRecorder) {
|
||
|
|
this.videoRecorder.pauseRecording();
|
||
|
|
}
|
||
|
|
|
||
|
|
if (this.gifRecorder) {
|
||
|
|
this.gifRecorder.pauseRecording();
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* This method resumes recording.
|
||
|
|
* @method
|
||
|
|
* @memberof MRecordRTC
|
||
|
|
* @example
|
||
|
|
* recorder.resumeRecording();
|
||
|
|
*/
|
||
|
|
this.resumeRecording = function() {
|
||
|
|
if (this.audioRecorder) {
|
||
|
|
this.audioRecorder.resumeRecording();
|
||
|
|
}
|
||
|
|
|
||
|
|
if (this.videoRecorder) {
|
||
|
|
this.videoRecorder.resumeRecording();
|
||
|
|
}
|
||
|
|
|
||
|
|
if (this.gifRecorder) {
|
||
|
|
this.gifRecorder.resumeRecording();
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* This method can be used to manually get all recorded blobs.
|
||
|
|
* @param {function} callback - All recorded blobs are passed back to the "callback" function.
|
||
|
|
* @method
|
||
|
|
* @memberof MRecordRTC
|
||
|
|
* @example
|
||
|
|
* recorder.getBlob(function(recording){
|
||
|
|
* var audioBlob = recording.audio;
|
||
|
|
* var videoBlob = recording.video;
|
||
|
|
* var gifBlob = recording.gif;
|
||
|
|
* });
|
||
|
|
* // or
|
||
|
|
* var audioBlob = recorder.getBlob().audio;
|
||
|
|
* var videoBlob = recorder.getBlob().video;
|
||
|
|
*/
|
||
|
|
this.getBlob = function(callback) {
|
||
|
|
var output = {};
|
||
|
|
|
||
|
|
if (this.audioRecorder) {
|
||
|
|
output.audio = this.audioRecorder.getBlob();
|
||
|
|
}
|
||
|
|
|
||
|
|
if (this.videoRecorder) {
|
||
|
|
output.video = this.videoRecorder.getBlob();
|
||
|
|
}
|
||
|
|
|
||
|
|
if (this.gifRecorder) {
|
||
|
|
output.gif = this.gifRecorder.getBlob();
|
||
|
|
}
|
||
|
|
|
||
|
|
if (callback) {
|
||
|
|
callback(output);
|
||
|
|
}
|
||
|
|
|
||
|
|
return output;
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Destroy all recorder instances.
|
||
|
|
* @method
|
||
|
|
* @memberof MRecordRTC
|
||
|
|
* @example
|
||
|
|
* recorder.destroy();
|
||
|
|
*/
|
||
|
|
this.destroy = function() {
|
||
|
|
if (this.audioRecorder) {
|
||
|
|
this.audioRecorder.destroy();
|
||
|
|
this.audioRecorder = null;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (this.videoRecorder) {
|
||
|
|
this.videoRecorder.destroy();
|
||
|
|
this.videoRecorder = null;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (this.gifRecorder) {
|
||
|
|
this.gifRecorder.destroy();
|
||
|
|
this.gifRecorder = null;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* This method can be used to manually get all recorded blobs' DataURLs.
|
||
|
|
* @param {function} callback - All recorded blobs' DataURLs are passed back to the "callback" function.
|
||
|
|
* @method
|
||
|
|
* @memberof MRecordRTC
|
||
|
|
* @example
|
||
|
|
* recorder.getDataURL(function(recording){
|
||
|
|
* var audioDataURL = recording.audio;
|
||
|
|
* var videoDataURL = recording.video;
|
||
|
|
* var gifDataURL = recording.gif;
|
||
|
|
* });
|
||
|
|
*/
|
||
|
|
this.getDataURL = function(callback) {
|
||
|
|
this.getBlob(function(blob) {
|
||
|
|
if (blob.audio && blob.video) {
|
||
|
|
getDataURL(blob.audio, function(_audioDataURL) {
|
||
|
|
getDataURL(blob.video, function(_videoDataURL) {
|
||
|
|
callback({
|
||
|
|
audio: _audioDataURL,
|
||
|
|
video: _videoDataURL
|
||
|
|
});
|
||
|
|
});
|
||
|
|
});
|
||
|
|
} else if (blob.audio) {
|
||
|
|
getDataURL(blob.audio, function(_audioDataURL) {
|
||
|
|
callback({
|
||
|
|
audio: _audioDataURL
|
||
|
|
});
|
||
|
|
});
|
||
|
|
} else if (blob.video) {
|
||
|
|
getDataURL(blob.video, function(_videoDataURL) {
|
||
|
|
callback({
|
||
|
|
video: _videoDataURL
|
||
|
|
});
|
||
|
|
});
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
function getDataURL(blob, callback00) {
|
||
|
|
if (typeof Worker !== 'undefined') {
|
||
|
|
var webWorker = processInWebWorker(function readFile(_blob) {
|
||
|
|
postMessage(new FileReaderSync().readAsDataURL(_blob));
|
||
|
|
});
|
||
|
|
|
||
|
|
webWorker.onmessage = function(event) {
|
||
|
|
callback00(event.data);
|
||
|
|
};
|
||
|
|
|
||
|
|
webWorker.postMessage(blob);
|
||
|
|
} else {
|
||
|
|
var reader = new FileReader();
|
||
|
|
reader.readAsDataURL(blob);
|
||
|
|
reader.onload = function(event) {
|
||
|
|
callback00(event.target.result);
|
||
|
|
};
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function processInWebWorker(_function) {
|
||
|
|
var blob = URL.createObjectURL(new Blob([_function.toString(),
|
||
|
|
'this.onmessage = function (eee) {' + _function.name + '(eee.data);}'
|
||
|
|
], {
|
||
|
|
type: 'application/javascript'
|
||
|
|
}));
|
||
|
|
|
||
|
|
var worker = new Worker(blob);
|
||
|
|
var url;
|
||
|
|
if (typeof URL !== 'undefined') {
|
||
|
|
url = URL;
|
||
|
|
} else if (typeof webkitURL !== 'undefined') {
|
||
|
|
url = webkitURL;
|
||
|
|
} else {
|
||
|
|
throw 'Neither URL nor webkitURL detected.';
|
||
|
|
}
|
||
|
|
url.revokeObjectURL(blob);
|
||
|
|
return worker;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* This method can be used to ask {@link MRecordRTC} to write all recorded blobs into IndexedDB storage.
|
||
|
|
* @method
|
||
|
|
* @memberof MRecordRTC
|
||
|
|
* @example
|
||
|
|
* recorder.writeToDisk();
|
||
|
|
*/
|
||
|
|
this.writeToDisk = function() {
|
||
|
|
RecordRTC.writeToDisk({
|
||
|
|
audio: this.audioRecorder,
|
||
|
|
video: this.videoRecorder,
|
||
|
|
gif: this.gifRecorder
|
||
|
|
});
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* This method can be used to invoke a save-as dialog for all recorded blobs.
|
||
|
|
* @param {object} args - {audio: 'audio-name', video: 'video-name', gif: 'gif-name'}
|
||
|
|
* @method
|
||
|
|
* @memberof MRecordRTC
|
||
|
|
* @example
|
||
|
|
* recorder.save({
|
||
|
|
* audio: 'audio-file-name',
|
||
|
|
* video: 'video-file-name',
|
||
|
|
* gif : 'gif-file-name'
|
||
|
|
* });
|
||
|
|
*/
|
||
|
|
this.save = function(args) {
|
||
|
|
args = args || {
|
||
|
|
audio: true,
|
||
|
|
video: true,
|
||
|
|
gif: true
|
||
|
|
};
|
||
|
|
|
||
|
|
if (!!args.audio && this.audioRecorder) {
|
||
|
|
this.audioRecorder.save(typeof args.audio === 'string' ? args.audio : '');
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!!args.video && this.videoRecorder) {
|
||
|
|
this.videoRecorder.save(typeof args.video === 'string' ? args.video : '');
|
||
|
|
}
|
||
|
|
if (!!args.gif && this.gifRecorder) {
|
||
|
|
this.gifRecorder.save(typeof args.gif === 'string' ? args.gif : '');
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* This method can be used to get all recorded blobs from IndexedDB storage.
|
||
|
|
* @param {string} type - 'all' or 'audio' or 'video' or 'gif'
|
||
|
|
* @param {function} callback - Callback function to get all stored blobs.
|
||
|
|
* @method
|
||
|
|
* @memberof MRecordRTC
|
||
|
|
* @example
|
||
|
|
* MRecordRTC.getFromDisk('all', function(dataURL, type){
|
||
|
|
* if(type === 'audio') { }
|
||
|
|
* if(type === 'video') { }
|
||
|
|
* if(type === 'gif') { }
|
||
|
|
* });
|
||
|
|
*/
|
||
|
|
MRecordRTC.getFromDisk = RecordRTC.getFromDisk;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* This method can be used to store recorded blobs into IndexedDB storage.
|
||
|
|
* @param {object} options - {audio: Blob, video: Blob, gif: Blob}
|
||
|
|
* @method
|
||
|
|
* @memberof MRecordRTC
|
||
|
|
* @example
|
||
|
|
* MRecordRTC.writeToDisk({
|
||
|
|
* audio: audioBlob,
|
||
|
|
* video: videoBlob,
|
||
|
|
* gif : gifBlob
|
||
|
|
* });
|
||
|
|
*/
|
||
|
|
MRecordRTC.writeToDisk = RecordRTC.writeToDisk;
|
||
|
|
|
||
|
|
if (typeof RecordRTC !== 'undefined') {
|
||
|
|
RecordRTC.MRecordRTC = MRecordRTC;
|
||
|
|
}
|