",
32 | "tabCapture",
33 | "activeTab"
34 | ],
35 | "web_accessible_resources": [
36 | "icon.png"
37 | ]
38 | }
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | The MIT License (MIT)
2 |
3 | Copyright (c) 2017 [Muaz Khan](https://github.com/muaz-khan)
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy of
6 | this software and associated documentation files (the "Software"), to deal in
7 | the Software without restriction, including without limitation the rights to
8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
9 | the Software, and to permit persons to whom the Software is furnished to do so,
10 | subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 |
--------------------------------------------------------------------------------
/tabCapture/manifest.json:
--------------------------------------------------------------------------------
1 | {
2 | "name" : "Tab Capturing & Sharing",
3 | "author": "Muaz Khan",
4 | "version" : "2.3",
5 | "manifest_version" : 2,
6 | "description" : "Capture & Share any tab privately with multiple users!",
7 | "homepage_url": "https://github.com/muaz-khan/Chrome-Extensions/tree/master/tabCapture",
8 | "background": {
9 | "scripts": ["socket.io.js", "RTCMultiConnection.min.js", "IceServersHandler.js", "CodecsHandler.js", "shareStreamUsingRTCMultiConnection.js", "tab-capturing.js"],
10 | "persistent": false
11 | },
12 | "permissions": [
13 | "tabCapture", "activeTab", "storage"
14 | ],
15 | "browser_action" : {
16 | "default_icon" : "images/tabCapture22.png",
17 | "default_title" : "Share this tab!"
18 | },
19 | "icons" : {
20 | "16" : "images/tabCapture16.png",
21 | "22" : "images/tabCapture22.png",
22 | "32" : "images/tabCapture32.png",
23 | "48" : "images/tabCapture48.png",
24 | "128": "images/tabCapture128.png"
25 | },
26 | "web_accessible_resources": [
27 | "images/tabCapture48.png"
28 | ],
29 | "options_ui": {
30 | "page": "options.html",
31 | "chrome_style": true
32 | }
33 | }
--------------------------------------------------------------------------------
/tabCapture/IceServersHandler.js:
--------------------------------------------------------------------------------
1 | // IceServersHandler.js
2 |
3 | var IceServersHandler = (function() {
4 | function getIceServers(connection) {
5 | // resiprocate: 3344+4433
6 | // pions: 7575
7 | var iceServers = [{
8 | 'urls': [
9 | 'stun:webrtcweb.com:7788'
10 | ],
11 | 'username': 'muazkh',
12 | 'credential': 'muazkh'
13 | },
14 | {
15 | 'urls': [
16 | 'turn:webrtcweb.com:7788', // coTURN 7788+8877
17 | 'turn:webrtcweb.com:8877',
18 | 'turn:webrtcweb.com:4455', // restund udp
19 | ],
20 | 'username': 'muazkh',
21 | 'credential': 'muazkh'
22 | },
23 | {
24 | 'urls': [
25 | 'stun:stun.l.google.com:19302',
26 | 'stun:stun1.l.google.com:19302',
27 | 'stun:stun2.l.google.com:19302',
28 | 'stun:stun.l.google.com:19302?transport=udp',
29 | ]
30 | }
31 | ];
32 |
33 | return iceServers;
34 | }
35 |
36 | return {
37 | getIceServers: getIceServers
38 | };
39 | })();
40 |
--------------------------------------------------------------------------------
/desktopCapture-p2p/background/helpers/IceServersHandler.js:
--------------------------------------------------------------------------------
1 | // IceServersHandler.js
2 |
3 | var IceServersHandler = (function() {
4 | function getIceServers(connection) {
5 | // resiprocate: 3344+4433
6 | // pions: 7575
7 | var iceServers = [{
8 | 'urls': [
9 | 'stun:webrtcweb.com:7788'
10 | ],
11 | 'username': 'muazkh',
12 | 'credential': 'muazkh'
13 | },
14 | {
15 | 'urls': [
16 | 'turn:webrtcweb.com:7788', // coTURN 7788+8877
17 | 'turn:webrtcweb.com:8877',
18 | 'turn:webrtcweb.com:4455', // restund udp
19 | ],
20 | 'username': 'muazkh',
21 | 'credential': 'muazkh'
22 | },
23 | {
24 | 'urls': [
25 | 'stun:stun.l.google.com:19302',
26 | 'stun:stun1.l.google.com:19302',
27 | 'stun:stun2.l.google.com:19302',
28 | 'stun:stun.l.google.com:19302?transport=udp',
29 | ]
30 | }
31 | ];
32 |
33 | return iceServers;
34 | }
35 |
36 | return {
37 | getIceServers: getIceServers
38 | };
39 | })();
40 |
--------------------------------------------------------------------------------
/desktopCapture-p2p/extension-pages/camera-mic.js:
--------------------------------------------------------------------------------
1 | document.write('The purpose of this page is to access your camera and microphone. ');
2 | document.write('You can REMOVE i.e. DELETE camera permissions anytime on these two pages: ');
3 | document.write('chrome://settings/content/camera?search=camera');
4 | document.write('chrome://settings/content/microphone?search=microphone');
5 |
6 | var constraints = {
7 | audio: true,
8 | video: true
9 | };
10 |
11 | navigator.mediaDevices.getUserMedia(constraints).then(function(stream) {
12 | document.write('Set Your Own Room ID:
40 | Set Room ID
41 |
44 | It will use your room-id instead of generating random string.
45 |
50 | Set File Chunk Size:
53 | Set Chunk Size
54 |
57 | If your file receivers are using Firefox, then set "15000" which is maximum reciving limit in Firefox.
58 |
59 | Wanna learn "how to use"?
62 |
63 |
--------------------------------------------------------------------------------
/desktopCapture-p2p/background/gotStream.js:
--------------------------------------------------------------------------------
1 | function gotStream(stream) {
2 | if (!stream) {
3 | setDefaults();
4 |
5 | chrome.windows.create({
6 | url: "data:text/html,Internal error occurred while capturing the screen. ",
7 | type: 'popup',
8 | width: screen.width / 2,
9 | height: 170
10 | });
11 | return;
12 | }
13 |
14 | chrome.browserAction.setTitle({
15 | title: 'Connecting to WebSockets server.'
16 | });
17 |
18 | chrome.browserAction.disable();
19 |
20 | addStreamStopListener(stream, function() {
21 | setDefaults();
22 | // chrome.runtime.reload();
23 | });
24 |
25 | // as it is reported that if you drag chrome screen's status-bar
26 | // and scroll up/down the screen-viewer page.
27 | // chrome auto-stops the screen without firing any 'onended' event.
28 | // chrome also hides screen status bar.
29 | chrome.windows.create({
30 | url: chrome.extension.getURL('_generated_background_page.html'),
31 | type: 'popup',
32 | focused: false,
33 | width: 1,
34 | height: 1,
35 | top: parseInt(screen.height),
36 | left: parseInt(screen.width)
37 | }, function(win) {
38 | var background_page_id = win.id;
39 |
40 | setTimeout(function() {
41 | // chrome.windows.remove(background_page_id);
42 | }, 3000);
43 | });
44 |
45 | setupWebRTCConnection(stream);
46 |
47 | chrome.browserAction.setIcon({
48 | path: 'images/pause22.png'
49 | });
50 | }
51 |
--------------------------------------------------------------------------------
/desktopCapture/different-api/background-script.js:
--------------------------------------------------------------------------------
1 | // this background script is used to invoke desktopCapture API
2 | // to capture screen-MediaStream.
3 |
4 | var screenOptions = ['screen', 'window'];
5 |
6 | chrome.runtime.onMessageExternal.addListener(function(message, sender, callback) {
7 | console.log(message);
8 |
9 | if (message == 'get-sourceId') {
10 | chrome.desktopCapture.chooseDesktopMedia(screenOptions, sender.tab, onAccessApproved);
11 | return;
12 | }
13 |
14 | if(!!message.screenOptions) {
15 | screenOptions = message.screenOptions;
16 | }
17 |
18 | if (message.getSourceId && message.requestURL) {
19 | // via code.google.com/p/chromium/issues/detail?id=425344
20 | sender.tab.url = message.requestURL;
21 | chrome.desktopCapture.chooseDesktopMedia(screenOptions, sender.tab, onAccessApproved);
22 | }
23 |
24 | if(message === 'are-you-there') {
25 | callback('rtcmulticonnection-extension-loaded');
26 | }
27 |
28 | // on getting sourceId
29 | // "sourceId" will be empty if permission is denied.
30 | function onAccessApproved(sourceId) {
31 | console.log('sourceId', sourceId);
32 |
33 | // if "cancel" button is clicked
34 | if (!sourceId || !sourceId.length || chrome.runtime.lastError) {
35 | return callback('PermissionDeniedError');
36 | }
37 |
38 | // "ok" button is clicked; share "sourceId" with the
39 | // content-script which will forward it to the webpage
40 | callback({
41 | sourceId: sourceId
42 | });
43 | }
44 | });
45 |
--------------------------------------------------------------------------------
/getUserMedia-on-http/camera-mic.js:
--------------------------------------------------------------------------------
1 | document.write('The purpose of this page is to access your camera and microphone. ');
2 |
3 | var port = chrome.runtime.connect();
4 |
5 | var hints = location.href.split('?hints=')[1];
6 | if (hints) {
7 | hints = JSON.parse(hints);
8 | } else {
9 | hints = {
10 | audio: true,
11 | video: true
12 | };
13 | }
14 | navigator.mediaDevices.getUserMedia(hints).then(function(stream) {
15 | stream.getTracks().forEach(function(track) {
16 | track.stop();
17 | });
18 | port.postMessage(hints);
19 | window.close();
20 | }).catch(function(e) {
21 | port.postMessage({
22 | error: e
23 | });
24 |
25 | var html = 'Unable to access your camera and microphone. ';
26 | html += 'Please go to following pages and remove "getUserMedia" from blocked-list:
';
27 | html += 'chrome://settings/content/microphone?search=camera ';
28 | html += 'chrome://settings/content/microphone?search=microphone ';
29 |
30 | if(e.message && e.message.toString().length) {
31 | html += 'Error Message: ' + e.message + ' Select Screen Resolutions:
40 |
41 | Fit Screen
42 | Full-HD (1080p)
43 | HD (720p)
44 | SD (360p)
45 |
46 | Set Bandwidth:
48 | Minimum Bandwidth
49 | Maximum Bandwidth
52 | Password Protected Room?
55 | Set Password
56 | Keep empty for NO password.
59 | Set Your Own Room ID:
61 | Set Room ID
62 |
65 | It will use your room-id instead of generating random string.
66 |
67 | ' + name + ':
' + message + '
';
23 | }
24 | else {
25 | div.innerHTML = '' + name + ':
' + message + '
';
26 | }
27 | chatMessages.appendChild(div);
28 |
29 | chatMessages.scrollTop = chatMessages.clientHeight;
30 | chatMessages.scrollTop = chatMessages.scrollHeight - chatMessages.scrollTop;
31 | }
32 |
33 | port.onMessage.addListener(function(message) {
34 | if (!message || !message.messageFromContentScript1234) {
35 | return;
36 | }
37 |
38 | if(message.newChatMessage) {
39 | appendChatMessage('Viewer', message.newChatMessage);
40 | }
41 |
42 | if(message.receivedChatMessage) {
43 | if(document.getElementById(message.checkmark_id)) {
44 | document.getElementById(message.checkmark_id).style.display = '';
45 | }
46 | }
47 | });
48 |
49 | window.onbeforeunload = function() {
50 | port.postMessage({
51 | messageFromContentScript1234: true,
52 | closeChat: true
53 | });
54 | };
55 |
--------------------------------------------------------------------------------
/desktopCapture-p2p/background/captureCamera.js:
--------------------------------------------------------------------------------
1 | function captureCamera(callback) {
2 | var supported = navigator.mediaDevices.getSupportedConstraints();
3 | var constraints = {};
4 |
5 | if (enableCamera) {
6 | constraints.video = {
7 | width: {
8 | min: 640,
9 | ideal: 1920,
10 | max: 1920
11 | },
12 | height: {
13 | min: 400,
14 | ideal: 1080
15 | }
16 | };
17 |
18 | if (supported.aspectRatio) {
19 | constraints.video.aspectRatio = 1.777777778;
20 | }
21 |
22 | if (supported.frameRate) {
23 | constraints.video.frameRate = {
24 | ideal: 30
25 | };
26 | }
27 |
28 | if (cameraDevice && cameraDevice.length) {
29 | constraints.video.deviceId = cameraDevice;
30 | }
31 | }
32 |
33 | if (enableMicrophone) {
34 | constraints.audio = {};
35 |
36 | if (microphoneDevice && microphoneDevice.length) {
37 | constraints.audio.deviceId = microphoneDevice;
38 | }
39 |
40 | if (supported.echoCancellation) {
41 | constraints.audio.echoCancellation = true;
42 | }
43 | }
44 |
45 | navigator.mediaDevices.getUserMedia(constraints).then(function(stream) {
46 | initVideoPlayer(stream);
47 | callback(stream);
48 |
49 | if (enableCamera && !enableScreen) {
50 | openVideoPreview(stream);
51 | }
52 | }).catch(function(error) {
53 | // error.message === 'Failed due to shutdown'
54 | chrome.tabs.create({
55 | url: 'extension-pages/camera-mic.html'
56 | });
57 |
58 | // setDefaults();
59 | chrome.storage.sync.set({
60 | enableTabCaptureAPI: 'false',
61 | enableMicrophone: 'false',
62 | enableCamera: 'false',
63 | enableScreen: 'false',
64 | isSharingOn: 'false',
65 | enableSpeakers: 'false'
66 | });
67 | });
68 | }
69 |
--------------------------------------------------------------------------------
/desktopCapture-p2p/background/shareStreamUsingAntMediaServer.js:
--------------------------------------------------------------------------------
1 | function shareStreamUsingAntMediaServer(stream) {
2 | var wrapper = new AntMediaWrapper();
3 | wrapper.callbacks('onopen', function() {
4 | var uid = room_id || (Math.random() * 100).toString().replace('.', '');
5 | wrapper.publish(stream, uid, function(isPublished, error) {
6 | if (isPublished === true) {
7 | var resultingURL = 'http://webrtcweb.com/screen/ant/?s=' + uid;
8 | var hlsURL = 'http://webrtcweb.com/screen/ant/?s=' + uid + '&hls=true';
9 |
10 | var html = "Unique Room URL Copy following private URL: ";
11 | html += "WebRTC URL:
";
12 | html += "HLS Live Stream URL:
";
13 |
14 | var popup_width = 600;
15 | var popup_height = 230;
16 |
17 | chrome.windows.create({
18 | url: "data:text/html," + html,
19 | type: 'popup',
20 | width: popup_width,
21 | height: popup_height,
22 | top: parseInt((screen.height / 2) - (popup_height / 2)),
23 | left: parseInt((screen.width / 2) - (popup_width / 2)),
24 | focused: true
25 | }, function(win) {
26 | popup_id = win.id;
27 | });
28 |
29 | chrome.browserAction.enable();
30 | setBadgeText(0);
31 | } else {
32 | alert(error);
33 | }
34 | });
35 | });
36 |
37 | wrapper.callbacks('onerror', function() {
38 | alert('Ant-Media Server is down or not reachable in the moment. Please go to options page and try other streaming method.');
39 | stream.getTracks().forEach(function(track) {
40 | track.stop();
41 | });
42 | setDefaults();
43 | });
44 | }
45 |
--------------------------------------------------------------------------------
/desktopCapture-p2p/server.js:
--------------------------------------------------------------------------------
1 | // http://127.0.0.1:9001
2 | // http://localhost:9001
3 |
4 | var server = require('http'),
5 | url = require('url'),
6 | path = require('path'),
7 | fs = require('fs');
8 |
9 | function serverHandler(request, response) {
10 | var uri = url.parse(request.url).pathname,
11 | filename = path.join(process.cwd(), uri);
12 |
13 | fs.exists(filename, function(exists) {
14 | if (!exists) {
15 | response.writeHead(404, {
16 | 'Content-Type': 'text/plain'
17 | });
18 | response.write('404 Not Found: ' + filename + '\n');
19 | response.end();
20 | return;
21 | }
22 |
23 | if (filename.indexOf('favicon.ico') !== -1) {
24 | return;
25 | }
26 |
27 | var isWin = !!process.platform.match(/^win/);
28 |
29 | if (fs.statSync(filename).isDirectory() && !isWin) {
30 | filename += '/index.html';
31 | } else if (fs.statSync(filename).isDirectory() && !!isWin) {
32 | filename += '\\index.html';
33 | }
34 |
35 | fs.readFile(filename, 'binary', function(err, file) {
36 | if (err) {
37 | response.writeHead(500, {
38 | 'Content-Type': 'text/plain'
39 | });
40 | response.write(err + '\n');
41 | response.end();
42 | return;
43 | }
44 |
45 | var contentType;
46 |
47 | if (filename.indexOf('.html') !== -1) {
48 | contentType = 'text/html';
49 | }
50 |
51 | if (filename.indexOf('.js') !== -1) {
52 | contentType = 'application/javascript';
53 | }
54 |
55 | if (contentType) {
56 | response.writeHead(200, {
57 | 'Content-Type': contentType
58 | });
59 | } else response.writeHead(200);
60 |
61 | response.write(file, 'binary');
62 | response.end();
63 | });
64 | });
65 | }
66 |
67 | var app;
68 |
69 | app = server.createServer(serverHandler);
70 |
71 | app = app.listen(process.env.PORT || 9001, process.env.IP || "0.0.0.0", function() {
72 | var addr = app.address();
73 | console.log("Server listening at", addr.address + ":" + addr.port);
74 | });
75 |
--------------------------------------------------------------------------------
/desktopCapture-p2p/extension-pages/chat.html:
--------------------------------------------------------------------------------
1 |
2 |
3 | Chat
5 |
6 |
84 |
85 |
86 |
87 | ",
52 | "activeTab",
53 | "tabCapture"
54 | ],
55 | "web_accessible_resources":[
56 | "images/desktopCapture48.png"
57 | ],
58 | "options_ui":{
59 | "page":"extension-pages/options.html",
60 | "chrome_style":true
61 | }
62 | }
--------------------------------------------------------------------------------
/screen-recording/camera-mic.js:
--------------------------------------------------------------------------------
1 | document.write('The purpose of this page is to access your camera and microphone. ');
2 |
3 | var port = chrome.runtime.connect();
4 |
5 | navigator.mediaDevices.getUserMedia({
6 | audio: true,
7 | video: true
8 | }).then(function(stream) {
9 | var tracksLength = stream.getTracks().length;
10 |
11 | stream.getTracks().forEach(function(track) {
12 | track.stop();
13 | });
14 |
15 | if(tracksLength <= 1) {
16 | throw new Error('Expected two tracks but received: ' + tracksLength);
17 | }
18 |
19 | port.postMessage({
20 | messageFromContentScript1234: true,
21 | startRecording: true
22 | });
23 | window.close();
24 | }).catch(function(e) {
25 | navigator.mediaDevices.getUserMedia({
26 | audio: true
27 | }).then(function(stream) {
28 | var tracksLength = stream.getTracks().length;
29 |
30 | stream.getTracks().forEach(function(track) {
31 | track.stop();
32 | });
33 |
34 | if(tracksLength < 1) {
35 | throw new Error('Expected at least one track but received: ' + tracksLength);
36 | }
37 |
38 | port.postMessage({
39 | messageFromContentScript1234: true,
40 | startRecording: true,
41 | onlyMicrophone: true
42 | });
43 | window.close();
44 | }).catch(function() {
45 | var html = 'Unable to access your camera and/or microphone. ';
46 | html += 'Please go to following pages and remove "RecordRTC" from blocked-list:
';
47 | html += 'chrome://settings/content/camera?search=camera ';
48 | html += 'chrome://settings/content/microphone?search=microphone ';
49 |
50 | if(e.message && e.message.toString().length) {
51 | html += 'Error Message: ' + e.message + ' Unexpected error: "
33 | ],
34 | "js":[
35 | "background/background.contentScript.js"
36 | ],
37 | "all_frames": true,
38 | "run_at": "document_start"
39 | }
40 | ],
41 | "browser_action":{
42 | "default_icon":"images/main-icon.png",
43 | "default_title":"Record Your Screen, Tab or Camera",
44 | "default_popup": "dropdown.html"
45 | },
46 | "icons":{
47 | "16":"images/main-icon.png",
48 | "22":"images/main-icon.png",
49 | "32":"images/main-icon.png",
50 | "48":"images/main-icon.png",
51 | "128":"images/main-icon.png"
52 | },
53 | "permissions":[
54 | "desktopCapture",
55 | "storage",
56 | "tabs",
57 | "tabCapture",
58 | "activeTab",
59 | "",
60 | "identity",
61 | "https://www.googleapis.com/*"
62 | ],
63 | "oauth2": {
64 | "client_id": "41556190767-99gorp1l5qij3hlsos4jms4vosbilrsa.apps.googleusercontent.com",
65 | "scopes": [
66 | "https://www.googleapis.com/auth/youtube.upload",
67 | "https://www.googleapis.com/auth/youtube"
68 | ]
69 | },
70 | "content_security_policy": "script-src 'self' https://apis.google.com; object-src 'self'",
71 | "web_accessible_resources":[
72 | "images/main-icon.png"
73 | ],
74 | "options_ui":{
75 | "page":"options.html",
76 | "chrome_style":false,
77 | "open_in_tab": true
78 | }
79 | }
--------------------------------------------------------------------------------
/desktopCapture-p2p/background/common.js:
--------------------------------------------------------------------------------
1 | function getAspectRatio(w, h) {
2 | function gcd(a, b) {
3 | return (b == 0) ? a : gcd(b, a % b);
4 | }
5 | var r = gcd(w, h);
6 | return (w / r) / (h / r);
7 | }
8 |
9 | function openVideoPreview(stream) {
10 | // var win = window.open("extension-pages/video.html?src=" + URL.createObjectURL(stream), "_blank", "top=0,left=0");
11 | var win = window.open("extension-pages/video.html", "_blank", "top=0,left=0");
12 | var timer = setInterval(function() {
13 | if (win.closed) {
14 | // captureDesktop();
15 | setDefaults();
16 |
17 | clearInterval(timer);
18 | }
19 | }, 1000);
20 | return win;
21 | }
22 |
23 | function initVideoPlayer(stream) {
24 | var videoPlayer = document.createElement('video');
25 | videoPlayer.muted = !enableTabCaptureAPI;
26 | videoPlayer.volume = !!enableTabCaptureAPI;
27 | videoPlayer.autoplay = true;
28 | videoPlayer.srcObject = stream;
29 | videoPlayers.push(videoPlayer);
30 | }
31 |
32 | function addStreamStopListener(stream, callback) {
33 | var streamEndedEvent = 'ended';
34 | if ('oninactive' in stream) {
35 | streamEndedEvent = 'inactive';
36 | }
37 | stream.addEventListener(streamEndedEvent, function() {
38 | callback();
39 | callback = function() {};
40 | }, false);
41 | stream.getAudioTracks().forEach(function(track) {
42 | track.addEventListener(streamEndedEvent, function() {
43 | callback();
44 | callback = function() {};
45 | }, false);
46 | });
47 | stream.getVideoTracks().forEach(function(track) {
48 | track.addEventListener(streamEndedEvent, function() {
49 | callback();
50 | callback = function() {};
51 | }, false);
52 | });
53 | }
54 |
55 | function getUserMediaError(e) {
56 | setDefaults();
57 |
58 | chrome.windows.create({
59 | url: "data:text/html,getUserMediaError: " + JSON.stringify(e, null, ' " + JSON.stringify(constraints, null, ' ',
60 | type: 'popup',
61 | width: screen.width / 2,
62 | height: 170
63 | });
64 | }
65 |
66 | function setBadgeText(text) {
67 | chrome.browserAction.setBadgeBackgroundColor({
68 | color: [255, 0, 0, 255]
69 | });
70 |
71 | chrome.browserAction.setBadgeText({
72 | text: text + ''
73 | });
74 |
75 | chrome.browserAction.setTitle({
76 | title: text + ' users are viewing your screen!'
77 | });
78 | }
79 |
80 | // sometimes extension unexpectedly crashes or reloads
81 | // in this case, making sure to remove "ON" status
82 | // chrome.storage.sync.set({ isSharingOn: 'false' });
83 |
--------------------------------------------------------------------------------
/get-any-webrtc-peer-stream/RTCPeerConnection-override.js:
--------------------------------------------------------------------------------
1 | var nativePeer;
2 |
3 | (function looper() {
4 | var RTC = window.RTCPeerConnection || window.webkitRTCPeerConnection;
5 |
6 | if (typeof RTC.prototype.addTrack !== 'undefined' && isFuncNative(RTC.prototype.addTrack)) {
7 | RTC.prototype._addTrack = RTC.prototype.addTrack;
8 | RTC.prototype.addTrack = function(track, stream) {
9 | nativePeer = this;
10 | nativePeer.streamEvent = 'track';
11 | this._addTrack(track, stream);
12 | };
13 | } else if (typeof RTC.prototype.addStream !== 'undefined' && isFuncNative(RTC.prototype.addStream)) {
14 | RTC.prototype._addStream = RTC.prototype.addStream;
15 | RTC.prototype.addStream = function(stream) {
16 | nativePeer = this;
17 | nativePeer.streamEvent = 'addstream';
18 | this._addStream(stream);
19 | };
20 | }
21 |
22 | if (typeof nativePeer === 'undefined' || typeof nativePeer.streamEvent === 'undefined') {
23 | // console.error('looper');
24 | setTimeout(looper, 1); // recheck
25 | return;
26 | }
27 |
28 | var dontDuplicate = {};
29 | nativePeer.addEventListener(nativePeer.streamEvent, function(event) {
30 | if (nativePeer.streamEvent === 'track') {
31 | event.stream = event.streams[0];
32 | }
33 |
34 | if(dontDuplicate[event.stream.id]) return;
35 | dontDuplicate[event.stream.id] = true;
36 |
37 | alert('Goto remote stream, creating offer');
38 |
39 | createOffer(event.stream);
40 | }, false);
41 | })();
42 |
43 | function isFuncNative(f) {
44 | return !!f && (typeof f).toLowerCase() == 'function' &&
45 | (f === Function.prototype ||
46 | /^\s*function\s*(\b[a-z$_][a-z0-9$_]*\b)*\s*\((|([a-z$_][a-z0-9$_]*)(\s*,[a-z$_][a-z0-9$_]*)*)\)\s*{\s*\[native code\]\s*}\s*$/i.test(String(f)));
47 | }
48 |
49 | window.addEventListener('message', function (event) {
50 | if(event.data && event.data.RTCPeerConnection_SDP) {
51 | peer.setRemoteDescription(new RTCSessionDescription(event.data.RTCPeerConnection_SDP));
52 | }
53 | });
54 |
55 | function createOffer(stream) {
56 | peer = new webkitRTCPeerConnection(null);
57 | peer.addStream(stream);
58 |
59 | peer.onicecandidate = function(event) {
60 | if (!event || !!event.candidate) return;
61 |
62 | window.postMessage({
63 | RTCPeerConnection_SDP: {
64 | sdp: peer.localDescription.sdp,
65 | type: peer.localDescription.type
66 | }
67 | }, '*');
68 | };
69 |
70 | peer.createOffer(function(sdp) {
71 | peer.setLocalDescription(sdp);
72 | }, function() {}, {
73 | optional: [],
74 | mandatory: {
75 | OfferToReceiveAudio: false,
76 | OfferToReceiveVideo: false
77 | }
78 | });
79 | }
80 |
--------------------------------------------------------------------------------
/screen-recording/background/background.badgeText.js:
--------------------------------------------------------------------------------
1 | function setVODRecordingBadgeText(text, title) {
2 | chrome.browserAction.setBadgeBackgroundColor({
3 | color: [203, 0, 15, 255]
4 | });
5 |
6 | chrome.browserAction.setBadgeText({
7 | text: text
8 | });
9 |
10 | chrome.browserAction.setTitle({
11 | title: title && title.length ? title + ' duration' : 'Record Screen'
12 | });
13 | }
14 |
15 | function msToTime(s) {
16 | function addZ(n) {
17 | return (n < 10 ? '0' : '') + n;
18 | }
19 |
20 | var ms = s % 1000;
21 | s = (s - ms) / 1000;
22 | var secs = s % 60;
23 | s = (s - secs) / 60;
24 | var mins = s % 60;
25 | var hrs = (s - mins) / 60;
26 |
27 | return addZ(hrs) + ':' + addZ(mins) + ':' + addZ(secs) + '.' + ms;
28 | }
29 |
30 | function convertTime(miliseconds) {
31 | var totalSeconds = Math.floor(miliseconds / 1000);
32 | var minutes = Math.floor(totalSeconds / 60);
33 | var seconds = totalSeconds - minutes * 60;
34 |
35 | minutes += '';
36 | seconds += '';
37 |
38 | if (minutes.length === 1) {
39 | // minutes = '0' + minutes;
40 | }
41 |
42 | if (seconds.length === 1) {
43 | seconds = '0' + seconds;
44 | }
45 |
46 | return minutes + ':' + seconds;
47 | }
48 |
49 |
50 | var initialTime, timer;
51 |
52 | function checkTime() {
53 | if (!initialTime || !isRecording) return;
54 | var timeDifference = Date.now() - initialTime;
55 | var formatted = convertTime(timeDifference);
56 | setBadgeText(formatted);
57 |
58 | chrome.browserAction.setTitle({
59 | title: 'Recording duration: ' + formatted
60 | });
61 | }
62 |
63 | function setBadgeText(text) {
64 | chrome.browserAction.setBadgeBackgroundColor({
65 | color: [255, 0, 0, 255]
66 | });
67 |
68 | chrome.browserAction.setBadgeText({
69 | text: text + ''
70 | });
71 | }
72 |
73 |
74 | var images = ['recordRTC-progress-1.png', 'recordRTC-progress-2.png', 'recordRTC-progress-3.png', 'recordRTC-progress-4.png', 'recordRTC-progress-5.png'];
75 | var imgIndex = 0;
76 | var reverse = false;
77 |
78 | function onRecording() {
79 | if(!isRecording) return;
80 |
81 | chrome.browserAction.setIcon({
82 | path: 'images/' + images[imgIndex]
83 | });
84 |
85 | if (!reverse) {
86 | imgIndex++;
87 |
88 | if (imgIndex > images.length - 1) {
89 | imgIndex = images.length - 1;
90 | reverse = true;
91 | }
92 | } else {
93 | imgIndex--;
94 |
95 | if (imgIndex < 0) {
96 | imgIndex = 1;
97 | reverse = false;
98 | }
99 | }
100 |
101 | if (isRecording) {
102 | setTimeout(onRecording, 800);
103 | return;
104 | }
105 |
106 | chrome.browserAction.setIcon({
107 | path: 'images/main-icon.png'
108 | });
109 | }
110 |
--------------------------------------------------------------------------------
/getUserMedia-on-http/example/index.js:
--------------------------------------------------------------------------------
1 | var logs = document.querySelector('#logs');
2 | function showLog(log) {
3 | var div = document.createElement('div');
4 | div.innerHTML = log;
5 | logs.appendChild(div);
6 | }
7 |
8 | var getUserMediaStreamObject;
9 |
10 | function getUserMedia() {
11 | if(typeof getUserMediaHttp !== 'function') {
12 | showLog('getUserMedia extension is not installed or disabled.');
13 | showLog('Please install this extension: https://chrome.google.com/webstore/detail/getusermedia/nbnpcmljmiinldficickhdoaiblgkggc ');
14 | return;
15 | }
16 |
17 | showLog('Calling getUserMediaHttp...');
18 |
19 | var hints = {
20 | audio: true,
21 | video: true
22 | };
23 |
24 | var checkedRadioId = document.querySelector('input[type=radio]:checked').id;
25 |
26 | if(checkedRadioId === 'camera') {
27 | hints = {
28 | audio: true,
29 | video: true
30 | };
31 | }
32 |
33 | if(checkedRadioId === 'microphone') {
34 | hints = {
35 | audio: true
36 | };
37 | }
38 |
39 | if(checkedRadioId === 'screen') {
40 | hints = {
41 | video: {
42 | mediaSource: 'screen'
43 | }
44 | };
45 | }
46 |
47 | showLog('getUserMediaHttp hints: ' + JSON.stringify(hints));
48 |
49 | navigator.mediaDevices.getUserMedia(hints).then(function(stream) {
50 | getUserMediaStreamObject = stream;
51 |
52 | showLog('Got stream from getUserMediaHttp...');
53 |
54 | stream.getTracks().forEach(function(track) {
55 | showLog(track.kind + ': ' + track.readyState);
56 | });
57 |
58 | document.querySelector('video').srcObject = stream;
59 | }).catch(function(e) {
60 | showLog('Message: ' + e.message);
61 | showLog('Stack: ' + e.stack);
62 | });
63 | }
64 |
65 | document.querySelector('#getUserMedia').onclick = function() {
66 | this.disabled = true;
67 |
68 | if(!getUserMediaStreamObject) {
69 | this.innerHTML = 'Stop getUserMedia Stream';
70 | getUserMedia();
71 | }
72 | else {
73 | this.innerHTML = 'getUserMedia';
74 |
75 | getUserMediaStreamObject.getTracks().forEach(function(track) {
76 | track.stop();
77 | });
78 |
79 | document.querySelector('video').srcObject = null;
80 | }
81 |
82 | setTimeout(function() {
83 | document.querySelector('#getUserMedia').disabled = false;
84 | }, 1000);
85 | };
86 |
87 | document.querySelectorAll('#radio-container input[type=radio]').forEach(function(radio) {
88 | radio.onclick = function() {
89 | document.querySelectorAll('#radio-container input[type=radio]:checked').forEach(function(radio) {
90 | radio.checked = false;
91 | });
92 | this.checked = true;
93 | };
94 | });
95 |
--------------------------------------------------------------------------------
/desktopCapture-p2p/screen-receivers/ant/index.html:
--------------------------------------------------------------------------------
1 |
13 |
14 | WebRTC AntMedia Broadcast Viewer
15 | 
4 |
5 | * https://chrome.google.com/webstore/detail/recordrtc/ndcljioonkecdnaaihodjgiliohngojp
6 |
7 |
78 |
79 |
80 | Screen Without Audio
81 |
84 |
85 | Screen + Microphone
86 |
89 |
90 | Screen + Speakers
91 |
94 |
95 | Screen + Microphone + Speakers
96 |
99 |
100 | Screen + Microphone + Speakers + Camera
101 |
104 |
105 | Chrome Tab + Speakers
106 |
109 |
110 | Screen + Camera
111 |
114 |
115 | Camera Only
116 |
122 |
123 |
124 |
125 |
126 | Open Chat Box
127 |
130 |
131 | Stop Sharing
132 |
134 |
135 |
136 |
137 |
138 |
--------------------------------------------------------------------------------
/desktopCapture-p2p/README.md:
--------------------------------------------------------------------------------
1 | # Chrome extension for WebRTC Screen Sharing
2 |
3 | RecordRTC Extension
75 |
76 |
77 |
78 |
79 |
80 | Screen Only (without audio)
81 |
84 |
85 | Screen + Microphone
86 |
89 |
90 | Screen + Speakers
91 |
94 |
95 | Screen + Microphone + Speakers
96 |
99 |
100 | Chrome Tab
101 |
104 |
105 | Chrome Tab (Audio Only)
106 |
109 |
110 | Full Screen + Camera
111 |
114 |
115 | Microphone + Camera
116 |
119 |
120 | Microphone + Speakers
121 |
124 |
125 | Microphone Only
126 |
129 |
130 | Speakers Only
131 |
140 |
141 |
142 |
143 |
144 | Stop Recording
145 |
147 |
148 |
149 |
150 |
151 |
--------------------------------------------------------------------------------
/screen-recording/preview.html:
--------------------------------------------------------------------------------
1 |
116 |
117 | RecordRTC Extension
118 |
120 |
124 |
128 |
129 |
130 |
132 |
133 |
135 |
136 |
137 |
Upload to Private Server
138 |
Upload to YouTube
139 |
142 |
143 |
146 |
147 |
148 |
149 |
150 |
151 |
152 |
153 |
--------------------------------------------------------------------------------
/desktopCapture-p2p/background/onAccessApproved.js:
--------------------------------------------------------------------------------
1 | function onAccessApproved(chromeMediaSourceId, opts) {
2 | if (!chromeMediaSourceId) {
3 | setDefaults();
4 | return;
5 | }
6 |
7 | var resolutions = opts.resolutions;
8 |
9 | chrome.storage.sync.get(null, function(items) {
10 | constraints = {
11 | audio: false,
12 | video: {
13 | mandatory: {
14 | chromeMediaSource: 'desktop',
15 | chromeMediaSourceId: chromeMediaSourceId,
16 | maxWidth: resolutions.maxWidth,
17 | maxHeight: resolutions.maxHeight,
18 | minWidth: resolutions.minWidth,
19 | minHeight: resolutions.minHeight,
20 | minAspectRatio: getAspectRatio(resolutions.maxWidth, resolutions.maxHeight),
21 | maxAspectRatio: getAspectRatio(resolutions.maxWidth, resolutions.maxHeight),
22 | minFrameRate: 64,
23 | maxFrameRate: 128
24 | },
25 | optional: []
26 | }
27 | };
28 |
29 | if (opts.canRequestAudioTrack === true) {
30 | constraints.audio = {
31 | mandatory: {
32 | chromeMediaSource: 'desktop',
33 | chromeMediaSourceId: chromeMediaSourceId,
34 | echoCancellation: true
35 | },
36 | optional: [{
37 | googDisableLocalEcho: false // https://www.chromestatus.com/feature/5056629556903936
38 | }]
39 | };
40 | }
41 |
42 | navigator.webkitGetUserMedia(constraints, function(screenStream) {
43 | var win;
44 | addStreamStopListener(screenStream, function() {
45 | if (win && !win.closed) {
46 | win.close();
47 | } else {
48 | captureDesktop();
49 | }
50 | });
51 |
52 | if (opts.stream) {
53 | if (enableCamera && opts.stream.getVideoTracks().length) {
54 | var cameraStream = opts.stream;
55 |
56 | screenStream.fullcanvas = true;
57 | screenStream.width = screen.width; // or 3840
58 | screenStream.height = screen.height; // or 2160
59 |
60 | cameraStream.width = parseInt((15 / 100) * screenStream.width);
61 | cameraStream.height = parseInt((15 / 100) * screenStream.height);
62 | cameraStream.top = screenStream.height - cameraStream.height - 20;
63 | cameraStream.left = screenStream.width - cameraStream.width - 20;
64 |
65 | var mixer = new MultiStreamsMixer([screenStream, cameraStream]);
66 |
67 | mixer.frameInterval = 1;
68 | mixer.startDrawingFrames();
69 |
70 | screenStream = mixer.getMixedStream();
71 | // win = openVideoPreview(screenStream);
72 | } else if (enableMicrophone && opts.stream.getAudioTracks().length) {
73 | var speakers = new MediaStream();
74 | screenStream.getAudioTracks().forEach(function(track) {
75 | speakers.addTrack(track);
76 | screenStream.removeTrack(track);
77 | });
78 |
79 | var mixer = new MultiStreamsMixer([speakers, opts.stream]);
80 | mixer.getMixedStream().getAudioTracks().forEach(function(track) {
81 | screenStream.addTrack(track);
82 | });
83 |
84 | screenStream.getVideoTracks().forEach(function(track) {
85 | track.onended = function() {
86 | if (win && !win.closed) {
87 | win.close();
88 | } else {
89 | captureDesktop();
90 | }
91 | };
92 | })
93 | }
94 | }
95 |
96 | gotStream(screenStream);
97 | }, getUserMediaError);
98 | });
99 | }
100 |
--------------------------------------------------------------------------------
/getUserMedia-on-http/content-script.js:
--------------------------------------------------------------------------------
1 | var port = chrome.runtime.connect();
2 | port.onMessage.addListener(function(message) {
3 | window.postMessage({
4 | 'get-user-media-http': message,
5 | 'from-background': true
6 | }, '*');
7 | });
8 |
9 | window.addEventListener('message', function(event) {
10 | if (event.source != window || !event.data['from-webpage'] || !event.data['get-user-media-http']) return;
11 | port.postMessage(event.data['get-user-media-http']);
12 | });
13 |
14 | function getUserMediaHttp() {
15 | if(location.protocol === 'https:' || location.protocol === 'chrome:' || document.domain === 'localhost' || document.domain === '127.0.0.1') {
16 | // ignore HTTPs and localhost and chrome
17 | return;
18 | }
19 |
20 | if(!navigator.mediaDevices) {
21 | navigator.mediaDevices = {};
22 | }
23 |
24 | var hints = {
25 | audio: true,
26 | video: true
27 | };
28 |
29 | var errorCallback = function(error) {
30 | console.error('getUserMediaHttp error', error);
31 | };
32 |
33 | var successCallback = function(stream) {
34 | stream.getTracks().forEach(function(track) {
35 | console.log('getUserMediaHttp stream', track.kind, track.readyState);
36 | });
37 | };
38 |
39 | navigator.mediaDevices.getUserMedia = function(_hints) {
40 | if (!_hints || (!_hints.audio && !_hints.video && !_hints.screen && !_hints.tab)) {
41 | _hints = {
42 | audio: true,
43 | video: true
44 | };
45 | }
46 |
47 | hints = _hints;
48 |
49 | getUserMedia();
50 |
51 | return {
52 | then: function(callback) {
53 | if(typeof callback !== 'function') {
54 | throw new Error('"callback" must be a function.');
55 | }
56 |
57 | successCallback = callback;
58 |
59 | return {
60 | catch: function(callback) {
61 | if(typeof callback !== 'function') {
62 | throw new Error('"callback" must be a function.');
63 | }
64 |
65 | errorCallback = callback;
66 | }
67 | }
68 | }
69 | }
70 | };
71 |
72 | function getUserMedia() {
73 | window.postMessage({
74 | 'get-user-media-http': hints,
75 | 'from-webpage': true
76 | }, '*');
77 | }
78 |
79 | window.addEventListener('message', function(event) {
80 | if (event.source != window || !event.data['from-background']) return;
81 |
82 | var hints = event.data['get-user-media-http'];
83 | if (!hints) return;
84 |
85 | if(hints.error) {
86 | errorCallback(hints.error);
87 | return;
88 | }
89 |
90 | if (hints.sdp && hints.sdp.type === 'offer') {
91 | var rtc = new webrtcHandler();
92 | rtc.createAnswer(hints.sdp, function(answer) {
93 | if (answer.sdp) {
94 | window.postMessage({
95 | 'get-user-media-http': {
96 | sdp: answer
97 | },
98 | 'from-webpage': true
99 | }, '*');
100 | }
101 |
102 | if (answer.stream) {
103 | answer.stream.oninactive = function() {
104 | window.postMessage({
105 | 'get-user-media-http': {
106 | 'stream-stop': answer.stream.id
107 | },
108 | 'from-webpage': true
109 | }, '*');
110 | rtc.peer.close();
111 | rtc.peer = null;
112 | };
113 | successCallback(answer.stream);
114 |
115 | window.addEventListener('beforeunload', function() {
116 | answer.stream.getTracks().forEach(function(track) {
117 | track.stop();
118 | });
119 | }, false);
120 | }
121 | });
122 | }
123 | });
124 | }
125 |
126 | var script = document.createElement('script');
127 | (document.head || document.body || document.documentElement).appendChild(script).text = getUserMediaHttp.toString() + ';' + webrtcHandler.toString() + ';getUserMediaHttp();';
128 | script.remove();
129 |
--------------------------------------------------------------------------------
/screen-recording/preview/preview.php.upload.js:
--------------------------------------------------------------------------------
1 | var server_url = 'https://your-domain.com/f/';
2 |
3 | document.querySelector('#btn-php-upload').onclick = function() {
4 | if (!file) {
5 | fname.innerHTML = 'You did NOT record anything yet.';
6 | return;
7 | }
8 |
9 | this.disabled = true;
10 |
11 | fresolutions.innerHTML = fsize.innerHTML = fduration.innerHTML = browserCache.innerHTML = '';
12 | fname.innerHTML = 'Upload started...';
13 |
14 | uploadToPHPServer(file, function(progress, videoURL) {
15 | browserCache.innerHTML = '';
16 |
17 | if (progress === 'ended' || videoURL) {
18 | showPHPURL(videoURL);
19 | document.title = 'Upload successful';
20 | return;
21 | }
22 |
23 | if (progress != 'Upload started...') {
24 | fname.innerHTML = 'Upload Progress: ' + progress + '%';
25 | browserCache.innerHTML = 'Upload failed. ') === 0) {
93 | fname.innerHTML = request.responseText;
94 | header.style.height = 'auto';
95 | header.style.color = 'red';
96 | callback('upload-faild');
97 | return;
98 | }
99 |
100 | if (request.responseText && request.responseText.toString().indexOf('deleted successfully') !== -1) {
101 | callback('deleted')
102 | return;
103 | }
104 |
105 | if (request.responseText && request.responseText.toString() === 'Problem deleting file.') {
106 | callback(request.responseText)
107 | return;
108 | }
109 |
110 | callback('http-response-200');
111 | }
112 | };
113 |
114 | request.upload.onloadstart = function() {
115 | callback('Upload started...');
116 | };
117 |
118 | request.upload.onprogress = function(event) {
119 | callback(Math.round(event.loaded / event.total * 100));
120 | };
121 |
122 | request.upload.onload = function() {
123 | callback('progress-about-to-end');
124 | };
125 |
126 | request.upload.onload = function() {
127 | callback('progress-ended');
128 | };
129 |
130 | request.upload.onerror = function(error) {
131 | callback('Failed to upload to server');
132 | };
133 |
134 | request.upload.onabort = function(error) {
135 | callback('Upload aborted.');
136 | };
137 |
138 | request.open('POST', url);
139 | request.send(data);
140 | }
141 |
--------------------------------------------------------------------------------
/desktopCapture-p2p/extension-pages/options.html:
--------------------------------------------------------------------------------
1 |
117 | WebRTC Desktop Sharing
118 | Loading configuration
123 |
Resolutions:
124 |
125 |
126 | Fit Screen
127 | 4K (2160p)
128 | Full-HD (1080p)
129 | HD (720p)
130 | SD (480p)
131 | SD (360p)
132 |
133 |
134 |
137 |
Codecs:
138 |
139 |
140 | Default
141 | VP8
142 | VP9
143 | H264
144 |
145 |
146 |
149 |
Streaming Methods:
150 |
151 |
152 | Peer-to-Peer
153 | Media Server
154 |
155 |
156 |
159 |
Bandwidth:
160 |
161 |
162 |
E.g. 8192 or 1048 or 512 or any digit.
163 |
166 |
Room Password:
167 |
168 |
169 |
Keep empty for normal rooms. Currently works only for Peer-to-Peer streaming method.
170 |
173 |
Room Unique ID:
174 |
175 |
176 |
Set Your Own Room-ID (to make it secure & protected & reusable). Keep empty for random room-id.
177 |
180 |
Room URL box:
181 |
182 |
183 |
You can ignore/hide the link box. For reusable room-ids: we do not need to show popup again and again.
184 |
Unique Room URL Copy following private URL: You can share this private-session URI with fellows using email or social networks.
",
149 | type: 'popup',
150 | width: popup_width,
151 | height: popup_height,
152 | top: parseInt((screen.height / 2) - (popup_height / 2)),
153 | left: parseInt((screen.width / 2) - (popup_width / 2)),
154 | focused: true
155 | }, function(win) {
156 | // popup_id = win.id;
157 | });
158 | }
159 |
160 | connection.socket.on(connection.socketCustomEvent, function(message) {
161 | if (message.receivedYourScreen) {
162 | setBadgeText(connection.isInitiator ? connection.getAllParticipants().length : '');
163 | }
164 | });
165 | }
166 |
167 | connection.open(connection.sessionid, roomOpenCallback);
168 |
169 | connection.onleave = connection.onPeerStateChanged = function() {
170 | setBadgeText(connection.isInitiator ? connection.getAllParticipants().length : '');
171 | };
172 | }
173 |
--------------------------------------------------------------------------------
/screen-recording/options.html:
--------------------------------------------------------------------------------
1 |
107 |
108 | RecordRTC Extension
109 |
110 | Applying Changes...
111 |
112 |
113 | Customize RecordRTC Extension
114 |
115 |
227 |
228 |
229 |
230 |
231 |
232 |
--------------------------------------------------------------------------------
/screen-recording/background/background.common.js:
--------------------------------------------------------------------------------
1 | var recorder;
2 | var isRecording = false;
3 | var bitsPerSecond = 0;
4 | var isChrome = true; // used by RecordRTC
5 |
6 | var enableTabCaptureAPI = false;
7 | var enableTabCaptureAPIAudioOnly = false;
8 |
9 | var enableScreen = true;
10 | var enableMicrophone = false;
11 | var enableCamera = false;
12 | var cameraStream = false;
13 |
14 | var enableSpeakers = true;
15 |
16 | var videoCodec = 'Default';
17 | var videoMaxFrameRates = '';
18 | var videoResolutions = '1920x1080';
19 |
20 | var startedVODRecordedAt = (new Date).getTime();
21 |
22 | var startRecordingCallback = function() {};
23 | var stopRecordingCallback = function(file) {};
24 | var openPreviewOnStopRecording = true;
25 | var openCameraPreviewDuringRecording = true;
26 |
27 | var fixVideoSeekingIssues = false;
28 |
29 | function isMediaRecorderCompatible() {
30 | return true;
31 | }
32 |
33 | function isMimeTypeSupported(mimeType) {
34 | if (typeof MediaRecorder.isTypeSupported !== 'function') {
35 | return true;
36 | }
37 |
38 | return MediaRecorder.isTypeSupported(mimeType);
39 | }
40 |
41 | function bytesToSize(bytes) {
42 | var k = 1000;
43 | var sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
44 | if (bytes === 0) {
45 | return '0 Bytes';
46 | }
47 | var i = parseInt(Math.floor(Math.log(bytes) / Math.log(k)), 10);
48 | return (bytes / Math.pow(k, i)).toPrecision(3) + ' ' + sizes[i];
49 | }
50 |
51 | var Storage = {};
52 |
53 | if (typeof AudioContext !== 'undefined') {
54 | Storage.AudioContext = AudioContext;
55 | } else if (typeof webkitAudioContext !== 'undefined') {
56 | Storage.AudioContext = webkitAudioContext;
57 | }
58 |
59 | MediaStream.prototype.stop = function() {
60 | this.getTracks().forEach(function(track) {
61 | track.stop();
62 | });
63 | };
64 |
65 | function getRandomString() {
66 | if (window.crypto && window.crypto.getRandomValues && navigator.userAgent.indexOf('Safari') === -1) {
67 | var a = window.crypto.getRandomValues(new Uint32Array(3)),
68 | token = '';
69 | for (var i = 0, l = a.length; i < l; i++) {
70 | token += a[i].toString(36);
71 | }
72 | return token;
73 | } else {
74 | return (Math.random() * new Date().getTime()).toString(36).replace(/\./g, '');
75 | }
76 | }
77 |
78 | function getFileName(fileExtension) {
79 | var str = getRandomString();
80 | str = str.substr(0, 5);
81 | return (new Date).toLocaleDateString().replace(/\//g,'-') + '-' + str + '.' + fileExtension;
82 | }
83 |
84 | function addStreamStopListener(stream, callback) {
85 | var streamEndedEvent = 'ended';
86 | if ('oninactive' in stream && !('onended' in stream)) {
87 | streamEndedEvent = 'inactive';
88 | }
89 | stream.addEventListener(streamEndedEvent, function() {
90 | callback();
91 | callback = function() {};
92 | });
93 | getTracks(stream, 'audio').forEach(function(track) {
94 | track.addEventListener(streamEndedEvent, function() {
95 | callback();
96 | callback = function() {};
97 | });
98 | });
99 | getTracks(stream, 'video').forEach(function(track) {
100 | track.addEventListener(streamEndedEvent, function() {
101 | callback();
102 | callback = function() {};
103 | });
104 | });
105 | }
106 |
107 | function getMixedAudioStream(arrayOfMediaStreams) {
108 | // via: @pehrsons
109 | if(typeof Storage === 'undefined') {
110 | window.Storage = {
111 | AudioContextConstructor: null,
112 | AudioContext: window.AudioContext || window.webkitAudioContext
113 | };
114 | }
115 |
116 | if (!Storage.AudioContextConstructor) {
117 | Storage.AudioContextConstructor = new Storage.AudioContext();
118 | }
119 |
120 | var context = Storage.AudioContextConstructor;
121 |
122 | var audioSources = [];
123 |
124 | var gainNode = context.createGain();
125 | gainNode.connect(context.destination);
126 | gainNode.gain.value = 0; // don't hear self
127 |
128 | var audioTracksLength = 0;
129 | arrayOfMediaStreams.forEach(function(stream) {
130 | if (!getTracks(stream, 'audio').length) {
131 | return;
132 | }
133 |
134 | audioTracksLength++;
135 |
136 | var audioSource = context.createMediaStreamSource(stream);
137 | audioSource.connect(gainNode);
138 | audioSources.push(audioSource);
139 | });
140 |
141 | if (!audioTracksLength) {
142 | return;
143 | }
144 |
145 | mediaStremDestination = context.createMediaStreamDestination();
146 | audioSources.forEach(function(audioSource) {
147 | audioSource.connect(mediaStremDestination);
148 | });
149 |
150 | return mediaStremDestination.stream;
151 | }
152 |
153 | function getTracks(stream, kind) {
154 | if (!stream || !stream.getTracks) {
155 | return [];
156 | }
157 |
158 | return stream.getTracks().filter(function(t) {
159 | return t.kind === (kind || 'audio');
160 | });
161 | }
162 |
163 | function getSeekableBlob(inputBlob, callback) {
164 | // EBML.js copyrights goes to: https://github.com/legokichi/ts-ebml
165 | if (typeof EBML === 'undefined') {
166 | throw new Error('Please link: https://cdn.webrtc-experiment.com/EBML.js');
167 | }
168 |
169 | var reader = new EBML.Reader();
170 | var decoder = new EBML.Decoder();
171 | var tools = EBML.tools;
172 |
173 | var fileReader = new FileReader();
174 | fileReader.onload = function(e) {
175 | var ebmlElms = decoder.decode(this.result);
176 | ebmlElms.forEach(function(element) {
177 | reader.read(element);
178 | });
179 | reader.stop();
180 | var refinedMetadataBuf = tools.makeMetadataSeekable(reader.metadatas, reader.duration, reader.cues);
181 | var body = this.result.slice(reader.metadataSize);
182 | var newBlob = new Blob([refinedMetadataBuf, body], {
183 | type: 'video/webm'
184 | });
185 |
186 | callback(newBlob);
187 | };
188 | fileReader.readAsArrayBuffer(inputBlob);
189 | }
190 |
--------------------------------------------------------------------------------
/desktopCapture-p2p/extension-pages/options.js:
--------------------------------------------------------------------------------
1 | function querySelectorAll(selector, element) {
2 | element = element || document;
3 | return Array.prototype.slice.call(element.querySelectorAll(selector));
4 | }
5 |
6 | var elements_ids = querySelectorAll('input, select').map(function(item) {
7 | return item.id;
8 | });
9 |
10 | var changes = document.getElementById('changes');
11 |
12 | chrome.storage.sync.get(null, function(items) {
13 | elements_ids.forEach(function(id) {
14 | if (!items[id]) return;
15 |
16 | var element = document.getElementById(id);
17 | if (items[id]) {
18 | if (element.type === 'checkbox') {
19 | element.checked = items[id] === 'true';
20 | } else {
21 | element.value = items[id];
22 | }
23 | } else {
24 | var item = {};
25 | item[element.id] = element.type === 'checkbox' ?
26 | (element.checked === true ? 'true' : 'false') :
27 | element.value;
28 |
29 | try {
30 | chrome.storage.sync.set(item);
31 | }
32 | catch(e) {
33 | location.reload();
34 | }
35 | }
36 | });
37 | setCustomSelectElements();
38 | setTimeout(function() {
39 | changes.style.display = 'none';
40 | }, 600);
41 | });
42 |
43 | elements_ids.forEach(function(id) {
44 | var element = document.getElementById(id);
45 | element.onchange = function(e) {
46 | e && e.stopPropagation();
47 | element.disabled = true;
48 |
49 | changes.querySelector('span').innerHTML = 'Saving Changes';
50 | changes.style.display = 'block';
51 |
52 | var item = {};
53 | item[element.id] = element.type === 'checkbox' ?
54 | (element.checked === true ? 'true' : 'false') :
55 | element.value;
56 |
57 | try {
58 | chrome.storage.sync.set(item, function() {
59 | element.disabled = false;
60 | setTimeout(function() {
61 | changes.style.display = 'none';
62 | }, 600);
63 | });
64 | }
65 | catch(e) {
66 | location.reload();
67 | }
68 | };
69 |
70 | if (element.type) {
71 | element.parentNode.onclick = function() {
72 | if (element.type !== 'checkbox') {
73 | element.focus();
74 | } else {
75 | element.checked = !element.checked;
76 | }
77 | };
78 |
79 | element.onclick = element.onfocus = function(e) {
80 | e && e.stopPropagation();
81 | };
82 | }
83 | });
84 |
85 | querySelectorAll('.help-icon').forEach(function(helpIcon) {
86 | var shown = false;
87 | helpIcon.onclick = function(e) {
88 | e.stopPropagation();
89 |
90 | var small = helpIcon.parentNode.querySelector('small');
91 | if(shown) {
92 | small.style.marginTop = '0px';
93 | setTimeout(function() {
94 | small.style.height = '0px';
95 | }, 500);
96 | shown = false;
97 | }
98 | else {
99 | small.style.height = 'auto';
100 | small.style.marginTop = '10px';
101 | shown = true;
102 | }
103 | };
104 | });
105 |
106 | /* custom select */
107 | function setCustomSelectElements() {
108 | var x, i, j, selElmnt, a, b, c;
109 | x = document.getElementsByClassName('custom-select');
110 | for (i = 0; i < x.length; i++) {
111 | selElmnt = x[i].getElementsByTagName('select')[0];
112 | a = document.createElement('DIV');
113 | a.setAttribute('class', 'select-selected');
114 | a.innerHTML = selElmnt.options[selElmnt.selectedIndex].innerHTML;
115 | x[i].appendChild(a);
116 | b = document.createElement('DIV');
117 | b.setAttribute('class', 'select-items select-hide');
118 |
119 | for (j = 0; j < selElmnt.length; j++) {
120 | c = document.createElement('DIV');
121 | c.innerHTML = selElmnt.options[j].innerHTML;
122 |
123 | c.setAttribute('data-value', selElmnt.options[j].value);
124 | c.setAttribute('data-target', selElmnt.id);
125 |
126 | c.onclick = function(e) {
127 | var y, i, k, s, h;
128 | s = this.parentNode.parentNode.getElementsByTagName('select')[0];
129 | h = this.parentNode.previousSibling;
130 | for (i = 0; i < s.length; i++) {
131 | if (s.options[i].innerHTML == this.innerHTML) {
132 | s.selectedIndex = i;
133 | h.innerHTML = this.innerHTML;
134 | y = this.parentNode.getElementsByClassName('same-as-selected');
135 | for (k = 0; k < y.length; k++) {
136 | y[k].removeAttribute('class');
137 | }
138 | this.setAttribute('class', 'same-as-selected');
139 | break;
140 | }
141 | }
142 | h.click();
143 |
144 | var value = this.getAttribute('data-value');
145 | var target = this.getAttribute('data-target');
146 | document.getElementById(target).value = value;
147 | document.getElementById(target).onchange();
148 | };
149 | b.appendChild(c);
150 | }
151 | x[i].appendChild(b);
152 | a.onclick = function(e) {
153 | e.stopPropagation();
154 | closeAllSelect(this);
155 | this.nextSibling.classList.toggle('select-hide');
156 | this.classList.toggle('select-arrow-active');
157 | };
158 | }
159 |
160 | function closeAllSelect(elmnt) {
161 | var x, y, i, arrNo = [];
162 | x = document.getElementsByClassName('select-items');
163 | y = document.getElementsByClassName('select-selected');
164 | for (i = 0; i < y.length; i++) {
165 | if (elmnt == y[i]) {
166 | arrNo.push(i)
167 | } else {
168 | y[i].classList.remove('select-arrow-active');
169 | }
170 | }
171 | for (i = 0; i < x.length; i++) {
172 | if (arrNo.indexOf(i)) {
173 | x[i].classList.add('select-hide');
174 | }
175 | }
176 | }
177 | document.onclick = closeAllSelect;
178 | }
179 |
--------------------------------------------------------------------------------
/desktopCapture-p2p/extension-pages/dropdown.js:
--------------------------------------------------------------------------------
1 | var runtimePort = chrome.runtime.connect({
2 | name: location.href.replace(/\/|:|#|\?|\$|\^|%|\.|`|~|!|\+|@|\[|\||]|\|*. /g, '').split('\n').join('').split('\r').join('')
3 | });
4 |
5 | runtimePort.onMessage.addListener(function(message) {
6 | if (!message || !message.messageFromContentScript1234) {
7 | return;
8 | }
9 | });
10 |
11 | document.getElementById('full-screen').onclick = function() {
12 | chrome.storage.sync.set({
13 | enableTabCaptureAPI: 'false',
14 | enableMicrophone: 'false',
15 | enableCamera: 'false',
16 | enableScreen: 'true', // TRUE
17 | isSharingOn: 'true', // TRUE
18 | enableSpeakers: 'false' // FALSE
19 | }, function() {
20 | runtimePort.postMessage({
21 | messageFromContentScript1234: true,
22 | startSharing: true
23 | });
24 | window.close();
25 | });
26 | };
27 |
28 | document.getElementById('full-screen-audio').onclick = function() {
29 | chrome.storage.sync.set({
30 | enableTabCaptureAPI: 'false',
31 | enableMicrophone: 'false',
32 | enableCamera: 'false',
33 | enableScreen: 'true', // TRUE
34 | isSharingOn: 'true', // TRUE
35 | enableSpeakers: 'true' // TRUE
36 | }, function() {
37 | runtimePort.postMessage({
38 | messageFromContentScript1234: true,
39 | startSharing: true
40 | });
41 | window.close();
42 | });
43 | };
44 |
45 | document.getElementById('full-screen-audio-microphone').onclick = function() {
46 | chrome.storage.sync.set({
47 | enableTabCaptureAPI: 'false',
48 | enableMicrophone: 'true', // TRUE
49 | enableCamera: 'false',
50 | enableScreen: 'true', // TRUE
51 | isSharingOn: 'true', // TRUE
52 | enableSpeakers: 'true' // TRUE
53 | }, function() {
54 | runtimePort.postMessage({
55 | messageFromContentScript1234: true,
56 | startSharing: true
57 | });
58 | window.close();
59 | });
60 | };
61 |
62 | document.getElementById('full-screen-audio-microphone-camera').onclick = function() {
63 | chrome.storage.sync.set({
64 | enableTabCaptureAPI: 'false',
65 | enableMicrophone: 'true', // TRUE
66 | enableCamera: 'true',
67 | enableScreen: 'true', // TRUE
68 | isSharingOn: 'true', // TRUE
69 | enableSpeakers: 'true' // TRUE
70 | }, function() {
71 | runtimePort.postMessage({
72 | messageFromContentScript1234: true,
73 | startSharing: true
74 | });
75 | window.close();
76 | });
77 | };
78 |
79 | document.getElementById('selected-tab').onclick = function() {
80 | chrome.storage.sync.set({
81 | enableTabCaptureAPI: 'true', // TRUE
82 | enableMicrophone: 'false',
83 | enableCamera: 'false',
84 | enableScreen: 'false',
85 | isSharingOn: 'true', // TRUE
86 | enableSpeakers: 'true'
87 | }, function() {
88 | runtimePort.postMessage({
89 | messageFromContentScript1234: true,
90 | startSharing: true
91 | });
92 | window.close();
93 | });
94 | };
95 |
96 | document.getElementById('microphone-screen').onclick = function() {
97 | chrome.storage.sync.set({
98 | enableTabCaptureAPI: 'false',
99 | enableMicrophone: 'true', // TRUE
100 | enableCamera: 'false',
101 | enableScreen: 'true', // TRUE
102 | isSharingOn: 'true', // TRUE
103 | enableSpeakers: 'false'
104 | }, function() {
105 | runtimePort.postMessage({
106 | messageFromContentScript1234: true,
107 | startSharing: true
108 | });
109 | window.close();
110 | });
111 | };
112 |
113 | document.getElementById('microphone-screen-camera').onclick = function() {
114 | chrome.storage.sync.set({
115 | enableTabCaptureAPI: 'false',
116 | enableMicrophone: 'true', // TRUE
117 | enableCamera: 'true', // TRUE
118 | enableScreen: 'true', // TRUE
119 | isSharingOn: 'true', // TRUE
120 | enableSpeakers: 'false'
121 | }, function() {
122 | runtimePort.postMessage({
123 | messageFromContentScript1234: true,
124 | startSharing: true
125 | });
126 | window.close();
127 | });
128 | };
129 |
130 | document.getElementById('microphone-webcam').onclick = function() {
131 | chrome.storage.sync.set({
132 | enableTabCaptureAPI: 'false',
133 | enableMicrophone: 'true', // TRUE
134 | enableCamera: 'true', // TRUE
135 | enableScreen: 'false', // FALSE
136 | isSharingOn: 'true', // TRUE
137 | enableSpeakers: 'false'
138 | }, function() {
139 | runtimePort.postMessage({
140 | messageFromContentScript1234: true,
141 | startSharing: true
142 | });
143 | window.close();
144 | });
145 | };
146 |
147 | document.getElementById('btn-options').onclick = function(e) {
148 | e.preventDefault();
149 | location.href = this.href;
150 | };
151 |
152 | function querySelectorAll(selector, element) {
153 | element = element || document;
154 | return Array.prototype.slice.call(element.querySelectorAll(selector));
155 | }
156 |
157 | chrome.storage.sync.get('isSharingOn', function(obj) {
158 | var isSharingOn = obj.isSharingOn === 'true';
159 |
160 | document.getElementById('default-section').style.display = isSharingOn ? 'none' : 'block';
161 | document.getElementById('stop-section').style.display = isSharingOn ? 'block' : 'none';
162 |
163 | // auto-stop-sharing
164 | if (isSharingOn) {
165 | // document.getElementById('stop-sharing').click();
166 | }
167 | });
168 |
169 | document.getElementById('stop-sharing').onclick = function() {
170 | chrome.storage.sync.set({
171 | isSharingOn: 'false'
172 | }, function() {
173 | runtimePort.postMessage({
174 | messageFromContentScript1234: true,
175 | stopSharing: true
176 | });
177 | window.close();
178 | });
179 | };
180 |
181 | document.getElementById('enable-chat').onclick = function() {
182 | var popup_width = 312;
183 | var popup_height = 400;
184 |
185 | runtimePort.postMessage({
186 | messageFromContentScript1234: true,
187 | openChat: true
188 | });
189 |
190 | window.open('chat.html','Chat','width='+popup_width+',height='+popup_height+',toolbar=0,menubar=0,location=0,status=1,scrollbars=1,resizable=0,top='+(screen.height - popup_height)+',left=' + (screen.width - popup_width - 30));
191 | window.close();
192 | };
193 |
--------------------------------------------------------------------------------
/screen-recording/RecordRTC/MultiStreamRecorder.js:
--------------------------------------------------------------------------------
1 | // ______________________
2 | // MultiStreamRecorder.js
3 |
4 | /*
5 | * Video conference recording, using captureStream API along with WebAudio and Canvas2D API.
6 | */
7 |
8 | /**
9 | * MultiStreamRecorder can record multiple videos in single container.
10 | * @summary Multi-videos recorder.
11 | * @license {@link https://github.com/muaz-khan/RecordRTC#license|MIT}
12 | * @author {@link http://www.MuazKhan.com|Muaz Khan}
13 | * @typedef MultiStreamRecorder
14 | * @class
15 | * @example
16 | * var options = {
17 | * mimeType: 'video/webm'
18 | * }
19 | * var recorder = new MultiStreamRecorder(ArrayOfMediaStreams, options);
20 | * recorder.record();
21 | * recorder.stop(function(blob) {
22 | * video.src = URL.createObjectURL(blob);
23 | *
24 | * // or
25 | * var blob = recorder.blob;
26 | * });
27 | * @see {@link https://github.com/muaz-khan/RecordRTC|RecordRTC Source Code}
28 | * @param {MediaStreams} mediaStreams - Array of MediaStreams.
29 | * @param {object} config - {disableLogs:true, frameInterval: 1, mimeType: "video/webm"}
30 | */
31 |
32 | function MultiStreamRecorder(arrayOfMediaStreams, options) {
33 | arrayOfMediaStreams = arrayOfMediaStreams || [];
34 | var self = this;
35 |
36 | var mixer;
37 | var mediaRecorder;
38 |
39 | options = options || {
40 | mimeType: 'video/webm',
41 | video: {
42 | width: 360,
43 | height: 240
44 | }
45 | };
46 |
47 | if (!options.frameInterval) {
48 | options.frameInterval = 10;
49 | }
50 |
51 | if (!options.video) {
52 | options.video = {};
53 | }
54 |
55 | if (!options.video.width) {
56 | options.video.width = 360;
57 | }
58 |
59 | if (!options.video.height) {
60 | options.video.height = 240;
61 | }
62 |
63 | /**
64 | * This method records all MediaStreams.
65 | * @method
66 | * @memberof MultiStreamRecorder
67 | * @example
68 | * recorder.record();
69 | */
70 | this.record = function() {
71 | // github/muaz-khan/MultiStreamsMixer
72 | mixer = new MultiStreamsMixer(arrayOfMediaStreams);
73 |
74 | if (getAllVideoTracks().length) {
75 | mixer.frameInterval = options.frameInterval || 10;
76 | mixer.width = options.video.width || 360;
77 | mixer.height = options.video.height || 240;
78 | mixer.startDrawingFrames();
79 | }
80 |
81 | if (options.previewStream && typeof options.previewStream === 'function') {
82 | options.previewStream(mixer.getMixedStream());
83 | }
84 |
85 | // record using MediaRecorder API
86 | mediaRecorder = new MediaStreamRecorder(mixer.getMixedStream(), options);
87 | mediaRecorder.record();
88 | };
89 |
90 | function getAllVideoTracks() {
91 | var tracks = [];
92 | arrayOfMediaStreams.forEach(function(stream) {
93 | getTracks(stream, 'video').forEach(function(track) {
94 | tracks.push(track);
95 | });
96 | });
97 | return tracks;
98 | }
99 |
100 | /**
101 | * This method stops recording MediaStream.
102 | * @param {function} callback - Callback function, that is used to pass recorded blob back to the callee.
103 | * @method
104 | * @memberof MultiStreamRecorder
105 | * @example
106 | * recorder.stop(function(blob) {
107 | * video.src = URL.createObjectURL(blob);
108 | * });
109 | */
110 | this.stop = function(callback) {
111 | if (!mediaRecorder) {
112 | return;
113 | }
114 |
115 | mediaRecorder.stop(function(blob) {
116 | self.blob = blob;
117 |
118 | callback(blob);
119 |
120 | self.clearRecordedData();
121 | });
122 | };
123 |
124 | /**
125 | * This method pauses the recording process.
126 | * @method
127 | * @memberof MultiStreamRecorder
128 | * @example
129 | * recorder.pause();
130 | */
131 | this.pause = function() {
132 | if (mediaRecorder) {
133 | mediaRecorder.pause();
134 | }
135 | };
136 |
137 | /**
138 | * This method resumes the recording process.
139 | * @method
140 | * @memberof MultiStreamRecorder
141 | * @example
142 | * recorder.resume();
143 | */
144 | this.resume = function() {
145 | if (mediaRecorder) {
146 | mediaRecorder.resume();
147 | }
148 | };
149 |
150 | /**
151 | * This method resets currently recorded data.
152 | * @method
153 | * @memberof MultiStreamRecorder
154 | * @example
155 | * recorder.clearRecordedData();
156 | */
157 | this.clearRecordedData = function() {
158 | if (mediaRecorder) {
159 | mediaRecorder.clearRecordedData();
160 | mediaRecorder = null;
161 | }
162 |
163 | if (mixer) {
164 | mixer.releaseStreams();
165 | mixer = null;
166 | }
167 | };
168 |
169 | /**
170 | * Add extra media-streams to existing recordings.
171 | * @method
172 | * @memberof MultiStreamRecorder
173 | * @param {MediaStreams} mediaStreams - Array of MediaStreams
174 | * @example
175 | * recorder.addStreams([newAudioStream, newVideoStream]);
176 | */
177 | this.addStreams = function(streams) {
178 | if (!streams) {
179 | throw 'First parameter is required.';
180 | }
181 |
182 | if (!(streams instanceof Array)) {
183 | streams = [streams];
184 | }
185 |
186 | arrayOfMediaStreams.concat(streams);
187 |
188 | if (!mediaRecorder || !mixer) {
189 | return;
190 | }
191 |
192 | mixer.appendStreams(streams);
193 | };
194 |
195 | /**
196 | * Reset videos during live recording. Replace old videos e.g. replace cameras with full-screen.
197 | * @method
198 | * @memberof MultiStreamRecorder
199 | * @param {MediaStreams} mediaStreams - Array of MediaStreams
200 | * @example
201 | * recorder.resetVideoStreams([newVideo1, newVideo2]);
202 | */
203 | this.resetVideoStreams = function(streams) {
204 | if (!mixer) {
205 | return;
206 | }
207 |
208 | if (streams && !(streams instanceof Array)) {
209 | streams = [streams];
210 | }
211 |
212 | mixer.resetVideoStreams(streams);
213 | };
214 |
215 | // for debugging
216 | this.name = 'MultiStreamRecorder';
217 | this.toString = function() {
218 | return this.name;
219 | };
220 | }
221 |
222 | if (typeof RecordRTC !== 'undefined') {
223 | RecordRTC.MultiStreamRecorder = MultiStreamRecorder;
224 | }
225 |
--------------------------------------------------------------------------------
121 | 
122 |
123 | 
162 | E.g. 8192 or 1048 or 512 or any digit.
163 |