├── .gitignore
├── examples
    ├── audio-video-loopback
    │   ├── server.js
    │   └── client.js
    ├── ping-pong
    │   ├── server.js
    │   └── client.js
    ├── broadcaster
    │   ├── server.js
    │   └── client.js
    ├── viewer
    │   ├── server.js
    │   └── client.js
    ├── sine-wave
    │   ├── server.js
    │   └── client.js
    ├── pitch-detector
    │   ├── server.js
    │   └── client.js
    ├── sine-wave-stereo
    │   ├── server.js
    │   └── client.js
    ├── record-audio-video-stream
    │   ├── client.js
    │   └── server.js
    ├── video-compositing
    │   ├── client.js
    │   └── server.js
    └── datachannel-buffer-limits
    │   ├── server.js
    │   └── client.js
├── lib
    ├── server
    │   ├── connections
    │   │   ├── connection.js
    │   │   ├── webrtcconnectionmanager.js
    │   │   ├── connectionmanager.js
    │   │   └── webrtcconnection.js
    │   ├── rest
    │   │   └── connectionsapi.js
    │   └── webrtc
    │   │   └── rtcaudiosourcesinewave.js
    ├── browser
    │   ├── webaudio
    │   │   ├── refcountedaudiocontext.js
    │   │   └── webaudiooscillatornodesinewave.js
    │   ├── example.js
    │   └── startstopbutton.js
    ├── common
    │   └── pitchdetector.js
    └── client
    │   └── index.js
├── test
    ├── integration
    │   ├── server
    │   │   ├── webrtc
    │   │   │   └── rtcaudiosourcesinewave.js
    │   │   └── rest
    │   │   │   └── connectionsapi.js
    │   └── client
    │   │   └── index.js
    ├── unit
    │   └── server
    │   │   └── connections
    │   │       ├── webrtcconnectionmanager.js
    │   │       ├── connectionmanager.js
    │   │       └── webrtcconnection.js
    └── lib
    │   └── testrtcpeerconnection.js
├── package.json
├── html
    └── index.html
├── index.js
├── .eslintrc
└── README.md


/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | package-lock.json
3 | 


--------------------------------------------------------------------------------
/examples/audio-video-loopback/server.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | function beforeOffer(peerConnection) {
 4 |   const audioTransceiver = peerConnection.addTransceiver('audio');
 5 |   const videoTransceiver = peerConnection.addTransceiver('video');
 6 |   return Promise.all([
 7 |     audioTransceiver.sender.replaceTrack(audioTransceiver.receiver.track),
 8 |     videoTransceiver.sender.replaceTrack(videoTransceiver.receiver.track)
 9 |   ]);
10 | }
11 | 
12 | module.exports = { beforeOffer };
13 | 


--------------------------------------------------------------------------------
/lib/server/connections/connection.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const EventEmitter = require('events');
 4 | 
 5 | class Connection extends EventEmitter {
 6 |   constructor(id) {
 7 |     super();
 8 |     this.id = id;
 9 |     this.state = 'open';
10 |   }
11 | 
12 |   close() {
13 |     this.state = 'closed';
14 |     this.emit('closed');
15 |   }
16 | 
17 |   toJSON() {
18 |     return {
19 |       id: this.id,
20 |       state: this.state
21 |     };
22 |   }
23 | }
24 | 
25 | module.exports = Connection;
26 | 


--------------------------------------------------------------------------------
/lib/browser/webaudio/refcountedaudiocontext.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | let audioContext = null;
 4 | let refCount = 0;
 5 | 
 6 | function acquireAudioContext() {
 7 |   refCount++;
 8 |   if (refCount && !audioContext) {
 9 |     audioContext = new AudioContext();
10 |   }
11 |   return audioContext;
12 | }
13 | 
14 | function releaseAudioContext() {
15 |   refCount--;
16 |   if (!refCount && audioContext) {
17 |     audioContext.close();
18 |     audioContext = null;
19 |   }
20 | }
21 | 
22 | exports.acquireAudioContext = acquireAudioContext;
23 | exports.releaseAudioContext = releaseAudioContext;
24 | 


--------------------------------------------------------------------------------
/examples/ping-pong/server.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | function beforeOffer(peerConnection) {
 4 |   const dataChannel = peerConnection.createDataChannel('ping-pong');
 5 | 
 6 |   function onMessage({ data }) {
 7 |     if (data === 'ping') {
 8 |       dataChannel.send('pong');
 9 |     }
10 |   }
11 | 
12 |   dataChannel.addEventListener('message', onMessage);
13 | 
14 |   // NOTE(mroberts): This is a hack so that we can get a callback when the
15 |   // RTCPeerConnection is closed. In the future, we can subscribe to
16 |   // "connectionstatechange" events.
17 |   const { close } = peerConnection;
18 |   peerConnection.close = function() {
19 |     dataChannel.removeEventListener('message', onMessage);
20 |     return close.apply(this, arguments);
21 |   };
22 | }
23 | 
24 | module.exports = { beforeOffer };
25 | 


--------------------------------------------------------------------------------
/examples/broadcaster/server.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const { EventEmitter } = require('events');
 4 | 
 5 | const broadcaster = new EventEmitter();
 6 | const { on } = broadcaster;
 7 | 
 8 | function beforeOffer(peerConnection) {
 9 |   const audioTrack = broadcaster.audioTrack = peerConnection.addTransceiver('audio').receiver.track;
10 |   const videoTrack = broadcaster.videoTrack = peerConnection.addTransceiver('video').receiver.track;
11 | 
12 |   broadcaster.emit('newBroadcast', {
13 |     audioTrack,
14 |     videoTrack
15 |   });
16 | 
17 |   const { close } = peerConnection;
18 |   peerConnection.close = function() {
19 |     audioTrack.stop()
20 |     videoTrack.stop()
21 |     return close.apply(this, arguments);
22 |   };
23 | }
24 | 
25 | module.exports = { 
26 |   beforeOffer,
27 |   broadcaster
28 | };
29 | 


--------------------------------------------------------------------------------
/examples/viewer/server.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const { broadcaster } = require('../broadcaster/server')
 4 | 
 5 | function beforeOffer(peerConnection) {
 6 |   const audioTransceiver = peerConnection.addTransceiver('audio');
 7 |   const videoTransceiver = peerConnection.addTransceiver('video');
 8 |   
 9 |   function onNewBroadcast({ audioTrack, videoTrack }) {
10 |     audioTransceiver.sender.replaceTrack(audioTrack),
11 |     videoTransceiver.sender.replaceTrack(videoTrack) 
12 |   }
13 | 
14 |   broadcaster.on('newBroadcast', onNewBroadcast)
15 | 
16 |   if (broadcaster.audioTrack && broadcaster.videoTrack) {
17 |     onNewBroadcast(broadcaster);
18 |   }
19 | 
20 |   const { close } = peerConnection;
21 |   peerConnection.close = function() {
22 |     broadcaster.removeListener('newBroadcast', onNewBroadcast);
23 |     return close.apply(this, arguments);
24 |   }
25 | }
26 | 
27 | module.exports = { beforeOffer };
28 | 


--------------------------------------------------------------------------------
/test/integration/server/webrtc/rtcaudiosourcesinewave.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const tape = require('tape');
 4 | const { RTCAudioSink } = require('wrtc').nonstandard;
 5 | 
 6 | const PitchDetector = require('../../../../lib/common/pitchdetector');
 7 | const RTCAudioSourceSineWave = require('../../../../lib/server/webrtc/rtcaudiosourcesinewave');
 8 | 
 9 | tape('RTCAudioSinkFrequencyDetector', t => {
10 |   t.test('it works', t => {
11 |     const source = new RTCAudioSourceSineWave();
12 |     const track = source.createTrack();
13 |     const sink = new RTCAudioSink(track);
14 |     const pitchDetector = new PitchDetector(track);
15 |     const e = 1;
16 |     sink.ondata = data => {
17 |       const frequency = pitchDetector.onData(data);
18 |       if (source.frequency - e <= frequency && frequency <= source.frequency + e) {
19 |         sink.stop();
20 |         track.stop();
21 |         source.close();
22 |         t.end();
23 |       }
24 |     };
25 |   });
26 |   t.end();
27 | });
28 | 


--------------------------------------------------------------------------------
/lib/browser/example.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const createStartStopButton = require('./startstopbutton');
 4 | const ConnectionClient = require('../client');
 5 | 
 6 | function createExample(name, description, options) {
 7 |   const nameTag = document.createElement('h2');
 8 |   nameTag.innerText = name;
 9 |   document.body.appendChild(nameTag);
10 | 
11 |   const descriptionTag = document.createElement('p');
12 |   descriptionTag.innerHTML = description;
13 |   document.body.appendChild(descriptionTag);
14 | 
15 |   const clickStartTag = document.createElement('p');
16 |   clickStartTag.innerHTML = 'Click &ldquo;Start&rdquo; to begin.';
17 |   document.body.appendChild(clickStartTag);
18 | 
19 |   const connectionClient = new ConnectionClient();
20 | 
21 |   let peerConnection = null;
22 | 
23 |   createStartStopButton(async () => {
24 |     peerConnection = await connectionClient.createConnection(options);
25 |     window.peerConnection = peerConnection;
26 |   }, () => {
27 |     peerConnection.close();
28 |   });
29 | }
30 | 
31 | module.exports = createExample;
32 | 


--------------------------------------------------------------------------------
/lib/browser/startstopbutton.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | function createStartStopButton(onStart, onStop) {
 4 |   const startButton = document.createElement('button');
 5 |   startButton.innerText = 'Start';
 6 |   document.body.appendChild(startButton);
 7 | 
 8 |   const stopButton = document.createElement('button');
 9 |   stopButton.innerText = 'Stop';
10 |   stopButton.disabled = true;
11 |   document.body.appendChild(stopButton);
12 | 
13 |   startButton.addEventListener('click', async () => {
14 |     startButton.disabled = true;
15 |     try {
16 |       await onStart();
17 |       stopButton.disabled = false;
18 |     } catch (error) {
19 |       startButton.disabled = false;
20 |       throw error;
21 |     }
22 |   });
23 | 
24 |   stopButton.addEventListener('click', async () => {
25 |     stopButton.disabled = true;
26 |     try {
27 |       await onStop();
28 |       startButton.disabled = false;
29 |     } catch (error) {
30 |       stopButton.disabled = false;
31 |       throw error;
32 |     }
33 |   });
34 | }
35 | 
36 | module.exports = createStartStopButton;
37 | 


--------------------------------------------------------------------------------
/examples/sine-wave/server.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const RTCAudioSourceSineWave = require('../../lib/server/webrtc/rtcaudiosourcesinewave');
 4 | 
 5 | function beforeOffer(peerConnection) {
 6 |   const source = new RTCAudioSourceSineWave();
 7 |   const track = source.createTrack();
 8 |   peerConnection.addTrack(track);
 9 | 
10 |   const dataChannel = peerConnection.createDataChannel('frequency');
11 | 
12 |   function onMessage({ data }) {
13 |     const frequency = Number.parseFloat(data);
14 |     source.setFrequency(frequency);
15 |   }
16 | 
17 |   dataChannel.addEventListener('message', onMessage);
18 | 
19 |   // NOTE(mroberts): This is a hack so that we can get a callback when the
20 |   // RTCPeerConnection is closed. In the future, we can subscribe to
21 |   // "connectionstatechange" events.
22 |   const { close } = peerConnection;
23 |   peerConnection.close = function() {
24 |     dataChannel.removeEventListener('message', onMessage);
25 |     track.stop();
26 |     source.close();
27 |     return close.apply(this, arguments);
28 |   };
29 | }
30 | 
31 | module.exports = { beforeOffer };
32 | 


--------------------------------------------------------------------------------
/examples/pitch-detector/server.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const { RTCAudioSink } = require('wrtc').nonstandard;
 4 | 
 5 | const PitchDetector = require('../../lib/common/pitchdetector');
 6 | 
 7 | function beforeOffer(peerConnection) {
 8 |   const { track } = peerConnection.addTransceiver('audio').receiver;
 9 |   const sink = new RTCAudioSink(track);
10 |   const pitchDetector = new PitchDetector();
11 | 
12 |   const dataChannel = peerConnection.createDataChannel('frequency');
13 | 
14 |   function onData(data) {
15 |     const frequency = pitchDetector.onData(data);
16 |     if (frequency && dataChannel.readyState === 'open') {
17 |       dataChannel.send(JSON.stringify(frequency));
18 |     }
19 |   }
20 | 
21 |   sink.ondata = onData;
22 | 
23 |   // NOTE(mroberts): This is a hack so that we can get a callback when the
24 |   // RTCPeerConnection is closed. In the future, we can subscribe to
25 |   // "connectionstatechange" events.
26 |   const { close } = peerConnection;
27 |   peerConnection.close = function() {
28 |     sink.stop();
29 |     return close.apply(this, arguments);
30 |   };
31 | }
32 | 
33 | module.exports = { beforeOffer };
34 | 


--------------------------------------------------------------------------------
/examples/sine-wave-stereo/server.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const RTCAudioSourceSineWave = require('../../lib/server/webrtc/rtcaudiosourcesinewave');
 4 | 
 5 | function beforeOffer(peerConnection) {
 6 |   const source = new RTCAudioSourceSineWave({
 7 |     channelCount: 2,
 8 |     panning: 50
 9 |   });
10 |   const track = source.createTrack();
11 |   peerConnection.addTrack(track);
12 | 
13 |   const dataChannel = peerConnection.createDataChannel('panning');
14 | 
15 |   function onMessage({ data }) {
16 |     const panning = Number.parseFloat(data);
17 |     source.setPanning(panning);
18 |   }
19 | 
20 |   dataChannel.addEventListener('message', onMessage);
21 | 
22 |   // NOTE(mroberts): This is a hack so that we can get a callback when the
23 |   // RTCPeerConnection is closed. In the future, we can subscribe to
24 |   // "connectionstatechange" events.
25 |   const { close } = peerConnection;
26 |   peerConnection.close = function() {
27 |     dataChannel.removeEventListener('message', onMessage);
28 |     track.stop();
29 |     source.close();
30 |     return close.apply(this, arguments);
31 |   };
32 | }
33 | 
34 | module.exports = { beforeOffer };
35 | 


--------------------------------------------------------------------------------
/lib/browser/webaudio/webaudiooscillatornodesinewave.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const { acquireAudioContext, releaseAudioContext } = require('./refcountedaudiocontext');
 4 | 
 5 | class WebAudioOscillatorNodeSineWave {
 6 |   constructor(options = {}) {
 7 |     options = {
 8 |       audioContext: null,
 9 |       frequency: 440,
10 |       ...options
11 |     };
12 | 
13 |     const isUsingDefaultAudioContext = !options.audioContext;
14 |     const audioContext = options.audioContext || acquireAudioContext();
15 | 
16 |     const oscillatorNode = audioContext.createOscillator();
17 |     oscillatorNode.frequency.setValueAtTime(options.frequency, audioContext.currentTime);
18 |     oscillatorNode.connect(audioContext.destination);
19 |     oscillatorNode.start();
20 | 
21 |     this.node = oscillatorNode;
22 | 
23 |     this.close = () => {
24 |       oscillatorNode.stop();
25 |       if (isUsingDefaultAudioContext) {
26 |         releaseAudioContext();
27 |       }
28 |     };
29 | 
30 |     this.setFrequency = frequency => {
31 |       oscillatorNode.frequency.setValueAtTime(frequency, audioContext.currentTime);
32 |     };
33 |   }
34 | }
35 | 
36 | module.exports = WebAudioOscillatorNodeSineWave;
37 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "node-webrtc-examples",
 3 |   "version": "0.1.0",
 4 |   "description": "This project presents a few example applications using node-webrtc.",
 5 |   "private": true,
 6 |   "main": "index.js",
 7 |   "scripts": {
 8 |     "lint": "eslint index.js examples lib test",
 9 |     "start": "node index.js",
10 |     "test": "npm run test:unit && npm run test:integration",
11 |     "test:unit": "tape 'test/unit/**/*.js'",
12 |     "test:integration": "tape 'test/integration/**/*.js'"
13 |   },
14 |   "keywords": [
15 |     "Web",
16 |     "Audio"
17 |   ],
18 |   "author": "Mark Andrus Roberts <markandrusroberts@gmail.com>",
19 |   "license": "BSD-3-Clause",
20 |   "dependencies": {
21 |     "@ffmpeg-installer/ffmpeg": "^1.0.20",
22 |     "Scope": "github:kevincennis/Scope",
23 |     "body-parser": "^1.18.3",
24 |     "browserify-middleware": "^8.1.1",
25 |     "canvas": "^2.4.1",
26 |     "color-space": "^1.16.0",
27 |     "express": "^4.16.4",
28 |     "fluent-ffmpeg": "^2.1.2",
29 |     "fluent-ffmpeg-multistream": "^1.0.0",
30 |     "node-fetch": "^2.3.0",
31 |     "uuid": "^3.3.2",
32 |     "wrtc": "^0.4.3"
33 |   },
34 |   "devDependencies": {
35 |     "eslint": "^5.15.1",
36 |     "tape": "^4.10.0"
37 |   }
38 | }


--------------------------------------------------------------------------------
/lib/server/connections/webrtcconnectionmanager.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const ConnectionManager = require('./connectionmanager');
 4 | const WebRtcConnection = require('./webrtcconnection');
 5 | 
 6 | class WebRtcConnectionManager {
 7 |   constructor(options = {}) {
 8 |     options = {
 9 |       Connection: WebRtcConnection,
10 |       ...options
11 |     };
12 | 
13 |     const connectionManager = new ConnectionManager(options);
14 | 
15 |     this.createConnection = async () => {
16 |       const connection = connectionManager.createConnection();
17 |       await connection.doOffer();
18 |       return connection;
19 |     };
20 | 
21 |     this.getConnection = id => {
22 |       return connectionManager.getConnection(id);
23 |     };
24 | 
25 |     this.getConnections = () => {
26 |       return connectionManager.getConnections();
27 |     };
28 |   }
29 | 
30 |   toJSON() {
31 |     return this.getConnections().map(connection => connection.toJSON());
32 |   }
33 | }
34 | 
35 | WebRtcConnectionManager.create = function create(options) {
36 |   return new WebRtcConnectionManager({
37 |     Connection: function(id) {
38 |       return new WebRtcConnection(id, options);
39 |     }
40 |   });
41 | };
42 | 
43 | module.exports = WebRtcConnectionManager;
44 | 


--------------------------------------------------------------------------------
/examples/viewer/client.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const createExample = require('../../lib/browser/example');
 4 | 
 5 | const description = 'View a broadcast. You should have already started the \
 6 | broadcast example. Although you can prototype such a system with  node-webrtc, \
 7 | you should consider using an \
 8 | <a href="https://webrtcglossary.com/sfu/" target="_blank">SFU</a>.';
 9 | 
10 | const remoteVideo = document.createElement('video');
11 | remoteVideo.autoplay = true;
12 | 
13 | async function beforeAnswer(peerConnection) {
14 |   const remoteStream = new MediaStream(peerConnection.getReceivers().map(receiver => receiver.track));
15 |   remoteVideo.srcObject = remoteStream;
16 | 
17 |   // NOTE(mroberts): This is a hack so that we can get a callback when the
18 |   // RTCPeerConnection is closed. In the future, we can subscribe to
19 |   // "connectionstatechange" events.
20 |   const { close } = peerConnection;
21 |   peerConnection.close = function() {
22 |     remoteVideo.srcObject = null;
23 |     return close.apply(this, arguments);
24 |   };
25 | }
26 | 
27 | createExample('viewer', description, { beforeAnswer });
28 | 
29 | const videos = document.createElement('div');
30 | videos.className = 'grid';
31 | videos.appendChild(remoteVideo);
32 | document.body.appendChild(videos);
33 | 


--------------------------------------------------------------------------------
/examples/record-audio-video-stream/client.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const createExample = require('../../lib/browser/example');
 4 | 
 5 | const description = 'Transcode and record audio and video into different video resolutions and then merge into single file.';
 6 | 
 7 | const localVideo = document.createElement('video');
 8 | localVideo.autoplay = true;
 9 | localVideo.muted = true;
10 | 
11 | async function beforeAnswer(peerConnection) {
12 |   const localStream = await window.navigator.mediaDevices.getUserMedia({
13 |     audio: true,
14 |     video: true
15 |   });
16 | 
17 |   localStream.getTracks().forEach(track => peerConnection.addTrack(track, localStream));
18 | 
19 |   localVideo.srcObject = localStream;
20 | 
21 |   // NOTE(mroberts): This is a hack so that we can get a callback when the
22 |   // RTCPeerConnection is closed. In the future, we can subscribe to
23 |   // "connectionstatechange" events.
24 |   const { close } = peerConnection;
25 |   peerConnection.close = function() {
26 |     localVideo.srcObject = null;
27 | 
28 |     localStream.getTracks().forEach(track => track.stop());
29 | 
30 |     return close.apply(this, arguments);
31 |   };
32 | }
33 | 
34 | createExample('record-audio-video-stream', description, { beforeAnswer });
35 | 
36 | const videos = document.createElement('div');
37 | videos.className = 'grid';
38 | videos.appendChild(localVideo);
39 | document.body.appendChild(videos);
40 | 


--------------------------------------------------------------------------------
/test/integration/client/index.js:
--------------------------------------------------------------------------------
 1 | /* eslint no-process-env:0 */
 2 | 'use strict';
 3 | 
 4 | const bodyParser = require('body-parser');
 5 | const express = require('express');
 6 | const tape = require('tape');
 7 | 
 8 | const ConnectionClient = require('../../../lib/client');
 9 | const WebRtcConnectionManager = require('../../../lib/server/connections/webrtcconnectionmanager');
10 | const connectionsApi = require('../../../lib/server/rest/connectionsapi');
11 | 
12 | tape('ConnectionsClient', t => {
13 |   t.test('typical usage', t => {
14 |     const app = express();
15 | 
16 |     app.use(bodyParser.json());
17 | 
18 |     const connectionManager = WebRtcConnectionManager.create({
19 |       beforeOffer(peerConnection) {
20 |         peerConnection.createDataChannel('test');
21 |       },
22 |       timeToReconnected: 0
23 |     });
24 | 
25 |     connectionsApi(app, connectionManager);
26 | 
27 |     const server = app.listen(3000, async () => {
28 |       const connectionClient = new ConnectionClient({
29 |         host: 'http://localhost:3000',
30 |         prefix: '/v1'
31 |       });
32 | 
33 |       const peerConnection = await connectionClient.createConnection();
34 | 
35 |       peerConnection.close();
36 | 
37 |       connectionManager.getConnections().forEach(connection => connection.close());
38 | 
39 |       server.close();
40 | 
41 |       t.end();
42 |     });
43 |   });
44 | 
45 |   t.end();
46 | });
47 | 


--------------------------------------------------------------------------------
/html/index.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html lang="en">
 3 | <head>
 4 | <style type="text/css">
 5 | body {
 6 |   font-family: Courier;
 7 |   max-width: 800px;
 8 |   margin: 0 auto;
 9 |   padding: 0 1em;
10 | }
11 | 
12 | label {
13 |   display: block;
14 |   margin-top: 1em;
15 | }
16 | 
17 | label > input {
18 |   margin-left: 1em;
19 | }
20 | 
21 | .grid {
22 |   margin-top: 1em;
23 |   display: grid;
24 |   grid-template-rows: 100%;
25 |   grid-template-columns: 50% 50%;
26 | }
27 | 
28 | .grid video {
29 |   width: 100%;
30 |   margin: auto 0;
31 | }
32 | 
33 | .grid canvas {
34 |   margin: auto auto;
35 |   max-width: 100%;
36 | }
37 | </style>
38 | <meta charset="utf-8">
39 | <title>node-webrtc Example</title>
40 | <body>
41 | <h1>node-webrtc examples</h1>
42 | <ul>
43 |   <li><a href="/audio-video-loopback/index.html">audio-video-loopback
44 |   <li><a href="/ping-pong/index.html">ping-pong
45 |   <li><a href="/pitch-detector/index.html">pitch-detector
46 |   <li><a href="/datachannel-buffer-limits/index.html">datachannel-buffer-limits
47 |   <li><a href="/sine-wave/index.html">sine-wave
48 |   <li><a href="/sine-wave-stereo/index.html">sine-wave-stereo
49 |   <li><a href="/video-compositing/index.html">video-compositing
50 |   <li><a href="/record-audio-video-stream/index.html">record-audio-video-stream
51 |   <li><a href="/broadcaster/index.html">broadcaster</a> &amp; <a href="/viewer/index.html">viewer
52 | <script src="index.js"></script>
53 | 


--------------------------------------------------------------------------------
/examples/broadcaster/client.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const createExample = require('../../lib/browser/example');
 4 | 
 5 | const description = 'Start a broadcast. Your stream will be forwarded to \
 6 | multiple viewers. Although you can prototype such a system with node-webrtc, \
 7 | you should consider using an \
 8 | <a href="https://webrtcglossary.com/sfu/" target="_blank">SFU</a>.';
 9 | 
10 | const localVideo = document.createElement('video');
11 | localVideo.autoplay = true;
12 | localVideo.muted = true;
13 | 
14 | async function beforeAnswer(peerConnection) {
15 |   const localStream = await window.navigator.mediaDevices.getUserMedia({
16 |     audio: true,
17 |     video: true
18 |   });
19 | 
20 |   localStream.getTracks().forEach(track => peerConnection.addTrack(track, localStream));
21 | 
22 |   localVideo.srcObject = localStream;
23 | 
24 |   // NOTE(mroberts): This is a hack so that we can get a callback when the
25 |   // RTCPeerConnection is closed. In the future, we can subscribe to
26 |   // "connectionstatechange" events.
27 |   const { close } = peerConnection;
28 |   peerConnection.close = function() {
29 |     localVideo.srcObject = null;
30 | 
31 |     localStream.getTracks().forEach(track => track.stop());
32 | 
33 |     return close.apply(this, arguments);
34 |   };
35 | }
36 | 
37 | createExample('broadcaster', description, { beforeAnswer });
38 | 
39 | const videos = document.createElement('div');
40 | videos.className = 'grid';
41 | videos.appendChild(localVideo);
42 | document.body.appendChild(videos);
43 | 


--------------------------------------------------------------------------------
/examples/ping-pong/client.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const createExample = require('../../lib/browser/example');
 4 | 
 5 | const description = 'This example sends a &ldquo;ping&rdquo; from the client \
 6 | over an RTCDataChannel. Upon receipt, node-webrtc responds with a \
 7 | &ldquo;pong&rdquo;. Open the Console to see the pings and pongs&hellip;';
 8 | 
 9 | function beforeAnswer(peerConnection) {
10 |   let dataChannel = null;
11 |   let interval = null;
12 | 
13 |   function onMessage({ data }) {
14 |     if (data === 'pong') {
15 |       console.log('received pong');
16 |     }
17 |   }
18 | 
19 |   function onDataChannel({ channel }) {
20 |     if (channel.label !== 'ping-pong') {
21 |       return;
22 |     }
23 | 
24 |     dataChannel = channel;
25 |     dataChannel.addEventListener('message', onMessage);
26 | 
27 |     interval = setInterval(() => {
28 |       console.log('sending ping');
29 |       dataChannel.send('ping');
30 |     }, 1000);
31 |   }
32 | 
33 |   peerConnection.addEventListener('datachannel', onDataChannel);
34 | 
35 |   // NOTE(mroberts): This is a hack so that we can get a callback when the
36 |   // RTCPeerConnection is closed. In the future, we can subscribe to
37 |   // "connectionstatechange" events.
38 |   const { close } = peerConnection;
39 |   peerConnection.close = function() {
40 |     if (dataChannel) {
41 |       dataChannel.removeEventListener('message', onMessage);
42 |     }
43 |     if (interval) {
44 |       clearInterval(interval);
45 |     }
46 |     return close.apply(this, arguments);
47 |   };
48 | }
49 | 
50 | createExample('ping-pong', description, { beforeAnswer });
51 | 


--------------------------------------------------------------------------------
/examples/audio-video-loopback/client.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const createExample = require('../../lib/browser/example');
 4 | 
 5 | const description = 'This example simply relays incoming audio and video using \
 6 | RTCRtpTransceivers.';
 7 | 
 8 | const localVideo = document.createElement('video');
 9 | localVideo.autoplay = true;
10 | localVideo.muted = true;
11 | 
12 | const remoteVideo = document.createElement('video');
13 | remoteVideo.autoplay = true;
14 | 
15 | async function beforeAnswer(peerConnection) {
16 |   const localStream = await window.navigator.mediaDevices.getUserMedia({
17 |     audio: true,
18 |     video: true
19 |   });
20 | 
21 |   localStream.getTracks().forEach(track => peerConnection.addTrack(track, localStream));
22 | 
23 |   localVideo.srcObject = localStream;
24 | 
25 |   const remoteStream = new MediaStream(peerConnection.getReceivers().map(receiver => receiver.track));
26 |   remoteVideo.srcObject = remoteStream;
27 | 
28 |   // NOTE(mroberts): This is a hack so that we can get a callback when the
29 |   // RTCPeerConnection is closed. In the future, we can subscribe to
30 |   // "connectionstatechange" events.
31 |   const { close } = peerConnection;
32 |   peerConnection.close = function() {
33 |     remoteVideo.srcObject = null;
34 | 
35 |     localVideo.srcObject = null;
36 | 
37 |     localStream.getTracks().forEach(track => track.stop());
38 | 
39 |     return close.apply(this, arguments);
40 |   };
41 | }
42 | 
43 | createExample('audio-video-loopback', description, { beforeAnswer });
44 | 
45 | const videos = document.createElement('div');
46 | videos.className = 'grid';
47 | videos.appendChild(localVideo);
48 | videos.appendChild(remoteVideo);
49 | document.body.appendChild(videos);
50 | 


--------------------------------------------------------------------------------
/test/unit/server/connections/webrtcconnectionmanager.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const tape = require('tape');
 4 | 
 5 | const Connection = require('../../../../lib/server/connections/connection');
 6 | const WebRtcConnectionManager = require('../../../../lib/server/connections/webrtcconnectionmanager');
 7 | 
 8 | const LOCAL_DESCRIPTION = { type: 'offer', sdp: 'offer' };
 9 | 
10 | class TestWebRtcConnection extends Connection {
11 |   constructor(id) {
12 |     super(id);
13 |     this.localDescription = null;
14 |     this.remoteDescription = null;
15 |   }
16 | 
17 |   async doOffer() {
18 |     this.localDescription = LOCAL_DESCRIPTION;
19 |   }
20 | 
21 |   async applyAnswer(answer) {
22 |     this.remoteDescription = answer;
23 |   }
24 | 
25 |   toJSON() {
26 |     return {
27 |       ...super.toJSON(),
28 |       localDescription: this.localDescription,
29 |       remoteDescription: this.remoteDescription
30 |     };
31 |   }
32 | }
33 | 
34 | tape('WebRtcConnectionManager', t => {
35 |   t.test('constructor', t => {
36 |     const connectionManager = new WebRtcConnectionManager();
37 |     t.ok(connectionManager instanceof WebRtcConnectionManager, 'returns an instance of WebRtcConnectionManager');
38 |     t.end();
39 |   });
40 | 
41 |   t.test('.createConnection()', async t => {
42 |     const connectionManager = new WebRtcConnectionManager({ Connection: TestWebRtcConnection });
43 |     const connection = await connectionManager.createConnection();
44 |     t.ok(connection instanceof TestWebRtcConnection, 'returns an instance of WebRtcConnection');
45 |     t.deepEqual(connection.localDescription, LOCAL_DESCRIPTION, 'the WebRtcConnection has its .localDescription set');
46 |     t.end();
47 |   });
48 | 
49 |   t.end();
50 | });
51 | 


--------------------------------------------------------------------------------
/test/lib/testrtcpeerconnection.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const EventEmitter = require('events');
 4 | 
 5 | const LOCAL_DESCRIPTION = { type: 'offer', sdp: 'offer' };
 6 | 
 7 | class TestRtcDescription {
 8 |   constructor(init) {
 9 |     this.type = init.type;
10 |     this.sdp = init.sdp;
11 |   }
12 | 
13 |   toJSON() {
14 |     return this;
15 |   }
16 | }
17 | 
18 | class TestRtcPeerConnection extends EventEmitter {
19 |   constructor() {
20 |     super();
21 |     this.iceConnectionState = 'new';
22 |     this.signalingState = 'stable';
23 |     this.localDescription = null;
24 |     this.remoteDescription = null;
25 |     TestRtcPeerConnection.peerConnections.push(this);
26 |   }
27 | 
28 |   close() {
29 |     this.signalingState = 'closed';
30 |   }
31 | 
32 |   createDataChannel() {
33 |     return {};
34 |   }
35 | 
36 |   async createOffer() {
37 |     return LOCAL_DESCRIPTION;
38 |   }
39 | 
40 |   async setLocalDescription(localDescription) {
41 |     this.localDescription = new TestRtcDescription(localDescription);
42 |     this.signalingState = 'have-local-offer';
43 |     setTimeout(() => {
44 |       this.emit('icecandidate', { candidate: null });
45 |     });
46 |   }
47 | 
48 |   async setRemoteDescription(remoteDescription) {
49 |     this.remoteDescription = new TestRtcDescription(remoteDescription);
50 |     this.signalingState = 'stable';
51 |   }
52 | 
53 |   addEventListener(event, listener) {
54 |     this.on(event, listener);
55 |   }
56 | 
57 |   removeEventListener(event, listener) {
58 |     this.removeListener(event, listener);
59 |   }
60 | 
61 |   updateIceConnectionState(iceConnectionState) {
62 |     this.iceConnectionState = iceConnectionState;
63 |     this.emit('iceconnectionstatechange');
64 |   }
65 | }
66 | 
67 | TestRtcPeerConnection.peerConnections = [];
68 | 
69 | module.exports = TestRtcPeerConnection;
70 | 


--------------------------------------------------------------------------------
/examples/video-compositing/client.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const createExample = require('../../lib/browser/example');
 4 | 
 5 | const description = 'This example uses node-webrtc&rsquo;s RTCVideoSource and \
 6 | RTCVideoSink along with <a href="https://github.com/Automattic/node-canvas">\
 7 | node-canvas</a> to superimpose a spinning, colorful animation on top of the \
 8 | incoming video.';
 9 | 
10 | const localVideo = document.createElement('video');
11 | localVideo.autoplay = true;
12 | localVideo.muted = true;
13 | 
14 | const remoteVideo = document.createElement('video');
15 | remoteVideo.autoplay = true;
16 | 
17 | async function beforeAnswer(peerConnection) {
18 |   const localStream = await window.navigator.mediaDevices.getUserMedia({
19 |     audio: true,
20 |     video: true
21 |   });
22 | 
23 |   localVideo.srcObject = localStream;
24 |   localStream.getTracks().forEach(track => peerConnection.addTrack(track, localStream));
25 | 
26 |   const remoteStream = new MediaStream(peerConnection.getReceivers().map(receiver => receiver.track));
27 |   remoteVideo.srcObject = remoteStream;
28 | 
29 |   // NOTE(mroberts): This is a hack so that we can get a callback when the
30 |   // RTCPeerConnection is closed. In the future, we can subscribe to
31 |   // "connectionstatechange" events.
32 |   const { close } = peerConnection;
33 |   peerConnection.close = function() {
34 |     remoteVideo.srcObject = null;
35 | 
36 |     localVideo.srcObject = null;
37 | 
38 |     localStream.getTracks().forEach(track => track.stop());
39 | 
40 |     return close.apply(this, arguments);
41 |   };
42 | }
43 | 
44 | createExample('video-compositing', description, { beforeAnswer });
45 | 
46 | const videos = document.createElement('div');
47 | videos.className = 'grid';
48 | videos.appendChild(localVideo);
49 | videos.appendChild(remoteVideo);
50 | document.body.appendChild(videos);
51 | 


--------------------------------------------------------------------------------
/index.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const bodyParser = require('body-parser');
 4 | const browserify = require('browserify-middleware');
 5 | const express = require('express');
 6 | const { readdirSync, statSync } = require('fs');
 7 | const { join } = require('path');
 8 | 
 9 | const { mount } = require('./lib/server/rest/connectionsapi');
10 | const WebRtcConnectionManager = require('./lib/server/connections/webrtcconnectionmanager');
11 | 
12 | const app = express();
13 | 
14 | app.use(bodyParser.json());
15 | 
16 | const examplesDirectory = join(__dirname, 'examples');
17 | 
18 | const examples = readdirSync(examplesDirectory).filter(path =>
19 |   statSync(join(examplesDirectory, path)).isDirectory());
20 | 
21 | function setupExample(example) {
22 |   const path = join(examplesDirectory, example);
23 |   const clientPath = join(path, 'client.js');
24 |   const serverPath = join(path, 'server.js');
25 | 
26 |   app.use(`/${example}/index.js`, browserify(clientPath));
27 |   app.get(`/${example}/index.html`, (req, res) => {
28 |     res.sendFile(join(__dirname, 'html', 'index.html'));
29 |   });
30 | 
31 |   const options = require(serverPath);
32 |   const connectionManager = WebRtcConnectionManager.create(options);
33 |   mount(app, connectionManager, `/${example}`);
34 | 
35 |   return connectionManager;
36 | }
37 | 
38 | app.get('/', (req, res) => res.redirect(`${examples[0]}/index.html`));
39 | 
40 | const connectionManagers = examples.reduce((connectionManagers, example) => {
41 |   const connectionManager = setupExample(example);
42 |   return connectionManagers.set(example, connectionManager);
43 | }, new Map());
44 | 
45 | const server = app.listen(3000, () => {
46 |   const address = server.address();
47 |   console.log(`http://localhost:${address.port}\n`);
48 | 
49 |   server.once('close', () => {
50 |     connectionManagers.forEach(connectionManager => connectionManager.close());
51 |   });
52 | });
53 | 


--------------------------------------------------------------------------------
/lib/server/connections/connectionmanager.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const uuidv4 = require('uuid/v4');
 4 | 
 5 | const DefaultConnection = require('./connection');
 6 | 
 7 | class ConnectionManager {
 8 |   constructor(options = {}) {
 9 |     options = {
10 |       Connection: DefaultConnection,
11 |       generateId: uuidv4,
12 |       ...options
13 |     };
14 | 
15 |     const {
16 |       Connection,
17 |       generateId
18 |     } = options;
19 | 
20 |     const connections = new Map();
21 |     const closedListeners = new Map();
22 | 
23 |     function createId() {
24 |       do {
25 |         const id = generateId();
26 |         if (!connections.has(id)) {
27 |           return id;
28 |         }
29 |       // eslint-disable-next-line
30 |       } while (true);
31 |     }
32 | 
33 |     function deleteConnection(connection) {
34 |       // 1. Remove "closed" listener.
35 |       const closedListener = closedListeners.get(connection);
36 |       closedListeners.delete(connection);
37 |       connection.removeListener('closed', closedListener);
38 | 
39 |       // 2. Remove the Connection from the Map.
40 |       connections.delete(connection.id);
41 |     }
42 | 
43 |     this.createConnection = () => {
44 |       const id = createId();
45 |       const connection = new Connection(id);
46 | 
47 |       // 1. Add the "closed" listener.
48 |       function closedListener() { deleteConnection(connection); }
49 |       closedListeners.set(connection, closedListener);
50 |       connection.once('closed', closedListener);
51 | 
52 |       // 2. Add the Connection to the Map.
53 |       connections.set(connection.id, connection);
54 | 
55 |       return connection;
56 |     };
57 | 
58 |     this.getConnection = id => {
59 |       return connections.get(id) || null;
60 |     };
61 | 
62 |     this.getConnections = () => {
63 |       return [...connections.values()];
64 |     };
65 |   }
66 | 
67 |   toJSON() {
68 |     return this.getConnections().map(connection => connection.toJSON());
69 |   }
70 | }
71 | 
72 | module.exports = ConnectionManager;
73 | 


--------------------------------------------------------------------------------
/lib/common/pitchdetector.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | class PitchDetector {
 4 |   constructor(options = {}) {
 5 |     options = {
 6 |       samples: 1024,
 7 |       ...options
 8 |     };
 9 | 
10 |     const { samples } = options;
11 |     if (samples.length < 2) {
12 |       throw new Error('samples must be greater than 2');
13 |     }
14 | 
15 |     const crossings = [];
16 | 
17 |     let changed = false;
18 |     let lastTime = 0;
19 |     let frequency = null;
20 |     let isPositive = true;
21 |     let sampleRate = null;
22 | 
23 |     this.onData = data => {
24 |       sampleRate = data.sampleRate;
25 |       const timePerSample = 1 / sampleRate;
26 |       const zero = data.unsigned ? (2 ** data.bitsPerSample) / 2 : 0;
27 |       data.samples.forEach((sample, i) => {
28 |         if (isPositive && sample < zero) {
29 |           changed = true;
30 |           isPositive = false;
31 |           const crossing = lastTime + i * timePerSample;
32 |           enqueue(crossings, crossing, samples);
33 |         } else if (!isPositive && sample > zero) {
34 |           isPositive = true;
35 |         }
36 |       });
37 |       lastTime += data.samples.length * timePerSample;
38 |       if (changed && crossings.length >= 2) {
39 |         changed = false;
40 |         const averagePeriod = averageDifference(crossings);
41 |         const averageFrequency = 1 / averagePeriod;
42 |         frequency = averageFrequency;
43 |         return frequency === null ? null : Math.floor(frequency);
44 |       }
45 |       return null;
46 |     };
47 | 
48 |     Object.defineProperties(this, {
49 |       frequency: {
50 |         get() {
51 |           return frequency;
52 |         }
53 |       },
54 |       sampleRate: {
55 |         get() {
56 |           return sampleRate;
57 |         }
58 |       }
59 |     });
60 |   }
61 | }
62 | 
63 | function averageDifference(xs) {
64 |   return pairs(xs).reduce((y, [x1, x2]) => (x2 - x1) + y, 0) / xs.length;
65 | }
66 | 
67 | function enqueue(xs, x, n) {
68 |   if (xs.length === n) {
69 |     xs.shift();
70 |   }
71 |   xs.push(x);
72 | }
73 | 
74 | function pairs(xs) {
75 |   return xs.slice(1).map((x, i) => [xs[i], x]);
76 | }
77 | 
78 | module.exports = PitchDetector;
79 | 


--------------------------------------------------------------------------------
/.eslintrc:
--------------------------------------------------------------------------------
 1 | root: true
 2 | 
 3 | env:
 4 |   es6: true
 5 |   node: true
 6 |   browser: true
 7 | 
 8 | parserOptions:
 9 |   ecmaVersion: 2018
10 | 
11 | extends:
12 |   'eslint:recommended'
13 | 
14 | rules:
15 |   array-bracket-spacing: 2
16 |   block-spacing: 2
17 |   callback-return: 0
18 |   camelcase: 2
19 |   comma-spacing: 2
20 |   comma-style: [2, last]
21 |   computed-property-spacing: 2
22 |   consistent-return: 1
23 |   consistent-this: [2, self]
24 |   dot-location: [2, property]
25 |   dot-notation: 2
26 |   eol-last: 2
27 |   eqeqeq: 2
28 |   func-style: [2, declaration]
29 |   handle-callback-err: 2
30 |   key-spacing: 2
31 |   linebreak-style: [2, unix]
32 |   new-cap: 2
33 |   new-parens: 2
34 |   no-alert: 2
35 |   no-caller: 2
36 |   no-console: 1
37 |   no-const-assign: 2
38 |   no-else-return: 2
39 |   no-eval: 2
40 |   no-extend-native: 2
41 |   no-extra-bind: 2
42 |   no-implicit-coercion: 0
43 |   no-implied-eval: 2
44 |   no-invalid-this: 2
45 |   no-iterator: 2
46 |   no-labels: 2
47 |   no-lone-blocks: 2
48 |   no-lonely-if: 2
49 |   no-loop-func: 2
50 |   no-multiple-empty-lines: 2
51 |   no-nested-ternary: 0
52 |   no-new-object: 2
53 |   no-new-require: 2
54 |   no-path-concat: 2
55 |   no-process-env: 2
56 |   no-process-exit: 2
57 |   no-proto: 2
58 |   no-return-assign: 2
59 |   no-shadow: 0
60 |   no-shadow-restricted-names: 2
61 |   no-script-url: 2
62 |   no-self-compare: 2
63 |   no-sequences: 2
64 |   no-spaced-func: 2
65 |   no-throw-literal: 2
66 |   no-trailing-spaces: 2
67 |   no-undef-init: 2
68 |   no-undefined: 2
69 |   no-unneeded-ternary: 2
70 |   no-unused-expressions: 2
71 |   no-use-before-define: [2, nofunc]
72 |   no-useless-call: 2
73 |   no-useless-concat: 2
74 |   no-warning-comments: 1
75 |   no-with: 1
76 |   object-curly-spacing: [2, always]
77 |   one-var: [2, never]
78 |   operator-assignment: [2, always]
79 |   quote-props: [2, consistent]
80 |   quotes: [2, single]
81 |   semi: [2, always]
82 |   keyword-spacing: 2
83 |   space-before-blocks: [2, always]
84 |   space-before-function-paren: [2, {
85 |     anonymous: 'never',
86 |     named: 'never',
87 |     asyncArrow: 'always'
88 |   }]
89 |   space-infix-ops: 2
90 |   space-unary-ops: 2
91 |   spaced-comment: 1
92 |   strict: [2, global]
93 | 


--------------------------------------------------------------------------------
/lib/server/rest/connectionsapi.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | function mount(app, connectionManager, prefix = '') {
 4 |   app.get(`${prefix}/connections`, (req, res) => {
 5 |     res.send(connectionManager.getConnections());
 6 |   });
 7 | 
 8 |   app.post(`${prefix}/connections`, async (req, res) => {
 9 |     try {
10 |       const connection = await connectionManager.createConnection();
11 |       res.send(connection);
12 |     } catch (error) {
13 |       console.error(error);
14 |       res.sendStatus(500);
15 |     }
16 |   });
17 | 
18 |   app.delete(`${prefix}/connections/:id`, (req, res) => {
19 |     const { id } = req.params;
20 |     const connection = connectionManager.getConnection(id);
21 |     if (!connection) {
22 |       res.sendStatus(404);
23 |       return;
24 |     }
25 |     connection.close();
26 |     res.send(connection);
27 |   });
28 | 
29 |   app.get(`${prefix}/connections/:id`, (req, res) => {
30 |     const { id } = req.params;
31 |     const connection = connectionManager.getConnection(id);
32 |     if (!connection) {
33 |       res.sendStatus(404);
34 |       return;
35 |     }
36 |     res.send(connection);
37 |   });
38 | 
39 |   app.get(`${prefix}/connections/:id/local-description`, (req, res) => {
40 |     const { id } = req.params;
41 |     const connection = connectionManager.getConnection(id);
42 |     if (!connection) {
43 |       res.sendStatus(404);
44 |       return;
45 |     }
46 |     res.send(connection.toJSON().localDescription);
47 |   });
48 | 
49 |   app.get(`${prefix}/connections/:id/remote-description`, (req, res) => {
50 |     const { id } = req.params;
51 |     const connection = connectionManager.getConnection(id);
52 |     if (!connection) {
53 |       res.sendStatus(404);
54 |       return;
55 |     }
56 |     res.send(connection.toJSON().remoteDescription);
57 |   });
58 | 
59 |   app.post(`${prefix}/connections/:id/remote-description`, async (req, res) => {
60 |     const { id } = req.params;
61 |     const connection = connectionManager.getConnection(id);
62 |     if (!connection) {
63 |       res.sendStatus(404);
64 |       return;
65 |     }
66 |     try {
67 |       await connection.applyAnswer(req.body);
68 |       res.send(connection.toJSON().remoteDescription);
69 |     } catch (error) {
70 |       res.sendStatus(400);
71 |     }
72 |   });
73 | }
74 | 
75 | function connectionsApi(app, connectionManager) {
76 |   mount(app, connectionManager, '/v1');
77 | }
78 | 
79 | module.exports = connectionsApi;
80 | module.exports.mount = mount;
81 | 


--------------------------------------------------------------------------------
/examples/datachannel-buffer-limits/server.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | function beforeOffer(peerConnection) {
 4 |   const dataChannel = peerConnection.createDataChannel('datachannel-buffer-limits');
 5 |   let uploadStartTime = 0;
 6 |   let uploadedBytesTotal = 0;
 7 |   let chunkSize = 64; // Default value, updated from the client
 8 | 
 9 |   function onMessage({ data }) {
10 |     if (/^#START/.test(data)) {
11 |       uploadStartTime = Date.now();
12 |       const value = parseInt(data.split(' ')[1]);
13 | 
14 |       if (!isNaN(value)) {
15 |         chunkSize = value;
16 |       }
17 | 
18 |       return;
19 |     }
20 | 
21 |     if (data === '#STOP') {
22 |       const uploadDuration = Date.now() - uploadStartTime;
23 | 
24 |       console.log('Client upload duration :', uploadDuration, 'ms');
25 |       console.log(`uploadedBytesTotal : ${uploadedBytesTotal}`);
26 | 
27 |       const queueStartTime = Date.now();
28 |       const chunkSizeInBytes = chunkSize*1024;
29 | 
30 |       const loops = uploadedBytesTotal / chunkSizeInBytes;
31 |       const rem = uploadedBytesTotal % chunkSizeInBytes;
32 |       const obuf = new Array(chunkSizeInBytes + 1).join('.');
33 | 
34 |       try {
35 |         dataChannel.send('#START ' + uploadDuration);
36 | 
37 |         for (let i = 0; i < loops; i++) {
38 |           dataChannel.send(obuf);
39 |         }
40 | 
41 |         if (rem) {
42 |           dataChannel.send(obuf);
43 |         }
44 | 
45 |         const queueDuration = Date.now() - queueStartTime;
46 | 
47 |         dataChannel.send('#STOP ' + queueDuration);
48 |         console.log(`Data sent back to client, queueDuration : ${queueDuration} ms`)
49 | 
50 |       } catch(e) {
51 |         console.log('Failed to send data :', e);
52 |         dataChannel.removeEventListener('message', onMessage);
53 |         dataChannel.close();
54 |         peerConnection.close();
55 |       }
56 | 
57 |       return;
58 |     }
59 | 
60 |     uploadedBytesTotal += Buffer.byteLength(data);
61 |   }
62 | 
63 |   function onConnectionStateChange(event) {
64 |     switch(peerConnection.connectionState) {
65 |       case "disconnected":
66 |       case "failed":
67 |       case "closed":
68 |         console.log('Received close event');
69 |         dataChannel.removeEventListener('message', onMessage);
70 |         dataChannel.close();
71 |         break;
72 |     }
73 |   }
74 | 
75 |   dataChannel.addEventListener('message', onMessage);
76 |   peerConnection.addEventListener('connectionstatechange', onConnectionStateChange);
77 | }
78 | 
79 | module.exports = { beforeOffer };
80 | 


--------------------------------------------------------------------------------
/test/unit/server/connections/connectionmanager.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const tape = require('tape');
 4 | 
 5 | const Connection = require('../../../../lib/server/connections/connection');
 6 | const ConnectionManager = require('../../../../lib/server/connections/connectionmanager');
 7 | 
 8 | tape('ConnectionManager', t => {
 9 |   t.test('constructor', t => {
10 |     const connectionManager = new ConnectionManager();
11 |     t.ok(connectionManager instanceof ConnectionManager, 'returns an instance of ConnectionManager');
12 |     t.end();
13 |   });
14 | 
15 |   t.test('.createConnection()', t => {
16 |     const ids = [1, 1, 1, 2];
17 |     function generateId() {
18 |       return ids.shift();
19 |     }
20 | 
21 |     const connectionManager = new ConnectionManager({ generateId });
22 | 
23 |     const connection1 = connectionManager.createConnection();
24 |     t.ok(connection1 instanceof Connection, 'returns an instance of Connection');
25 |     t.equal(connection1.id, 1, 'it sets the Connection\'s ID to the generated ID');
26 | 
27 |     const connection2 = connectionManager.createConnection();
28 |     t.ok(connection2.id, 2, 'it calls generateId() until a unique ID is returned');
29 | 
30 |     t.end();
31 |   });
32 | 
33 |   t.test('.getConnection(id)', t => {
34 |     const connectionManager = new ConnectionManager();
35 |     const connection = connectionManager.createConnection();
36 |     t.equal(connectionManager.getConnection('foo'), null, '.getConnection(id) with an unknown id returns null');
37 |     t.equal(connectionManager.getConnection(connection.id), connection, '.getConnection(id) with a known id returns a Connection');
38 |     connection.close();
39 |     t.equal(connectionManager.getConnection(connection.id), null, '.getConnection(id) returns null once the Connection with that ID closes');
40 |     t.end();
41 |   });
42 | 
43 |   t.test('.getConnections()', t => {
44 |     const connectionManager = new ConnectionManager();
45 |     t.deepEqual(connectionManager.getConnections(), [], '.getConnections() initially returns an empty array');
46 |     const connection1 = connectionManager.createConnection();
47 |     t.deepEqual(connectionManager.getConnections(), [connection1], '.getConnections() returns the expected result when 1 Connection is open');
48 |     const connection2 = connectionManager.createConnection();
49 |     t.deepEqual(connectionManager.getConnections(), [connection1, connection2], '.getConnections() returns the expected result when 2 Connections are open');
50 |     connection1.close();
51 |     connection2.close();
52 |     t.deepEqual(connectionManager.getConnections(), [], '.getConnections() returns an empty array when all Connections are closed');
53 |     t.end();
54 |   });
55 | 
56 |   t.end();
57 | });
58 | 


--------------------------------------------------------------------------------
/lib/server/webrtc/rtcaudiosourcesinewave.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | 
  3 | const { RTCAudioSource } = require('wrtc').nonstandard;
  4 | 
  5 | const twoPi = 2 * Math.PI;
  6 | 
  7 | class RTCAudioSourceSineWave {
  8 |   constructor(options = {}) {
  9 |     options = {
 10 |       frequency: 440,
 11 |       channelCount: 1,
 12 |       panning: null,
 13 |       sampleRate: 48000,
 14 |       schedule: setTimeout,
 15 |       unschedule: clearTimeout,
 16 |       ...options
 17 |     };
 18 | 
 19 |     const {
 20 |       channelCount,
 21 |       sampleRate
 22 |     } = options;
 23 | 
 24 |     if (channelCount !== 1 && channelCount !== 2) {
 25 |       throw new Error('channelCount must be 1 or 2');
 26 |     }
 27 | 
 28 |     const bitsPerSample = 16;
 29 |     const maxValue = Math.pow(2, bitsPerSample) / 2 - 1;
 30 |     const numberOfFrames = sampleRate / 100;
 31 |     const secondsPerSample = 1 / sampleRate;
 32 |     const source = new RTCAudioSource();
 33 |     const samples = new Int16Array(channelCount * numberOfFrames);
 34 | 
 35 |     const data = {
 36 |       samples,
 37 |       sampleRate,
 38 |       bitsPerSample,
 39 |       channelCount,
 40 |       numberOfFrames
 41 |     };
 42 | 
 43 |     const a = [1, 1];
 44 | 
 45 |     let {
 46 |       frequency,
 47 |       panning
 48 |     } = options;
 49 | 
 50 |     let time = 0;
 51 | 
 52 |     function next() {
 53 |       for (let i = 0; i < numberOfFrames; i++, time += secondsPerSample) {
 54 |         for (let j = 0; j < channelCount; j++) {
 55 |           samples[i * channelCount + j] = a[j] * Math.sin(twoPi * frequency * time) * maxValue;
 56 |         }
 57 |       }
 58 |       source.onData(data);
 59 |       // eslint-disable-next-line
 60 |       scheduled = options.schedule(next);
 61 |     }
 62 | 
 63 |     let scheduled = options.schedule(next);
 64 | 
 65 |     this.close = () => {
 66 |       options.unschedule(scheduled);
 67 |       scheduled = null;
 68 |     };
 69 | 
 70 |     this.createTrack = () => {
 71 |       return source.createTrack();
 72 |     };
 73 | 
 74 |     this.setFrequency = newFrequency => {
 75 |       frequency = newFrequency;
 76 |     };
 77 | 
 78 |     this.setPanning = newPanning => {
 79 |       if (channelCount === 1) {
 80 |         return;
 81 |       }
 82 |       panning = newPanning;
 83 |       a[0] = 1 - (panning / 100);
 84 |       a[1] = 1 - ((100 - panning) / 100);
 85 |     };
 86 | 
 87 |     this.setPanning(panning);
 88 | 
 89 |     Object.defineProperties(this, {
 90 |       frequency: {
 91 |         get() {
 92 |           return frequency;
 93 |         }
 94 |       },
 95 |       panning: {
 96 |         get() {
 97 |           return panning;
 98 |         }
 99 |       }
100 |     });
101 |   }
102 | }
103 | 
104 | module.exports = RTCAudioSourceSineWave;
105 | 


--------------------------------------------------------------------------------
/lib/client/index.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const fetch = require('node-fetch');
 4 | const DefaultRTCPeerConnection = require('wrtc').RTCPeerConnection;
 5 | const { RTCSessionDescription } = require('wrtc');
 6 | 
 7 | const TIME_TO_HOST_CANDIDATES = 3000;  // NOTE(mroberts): Too long.
 8 | 
 9 | class ConnectionClient {
10 |   constructor(options = {}) {
11 |     options = {
12 |       RTCPeerConnection: DefaultRTCPeerConnection,
13 |       clearTimeout,
14 |       host: '',
15 |       prefix: '.',
16 |       setTimeout,
17 |       timeToHostCandidates: TIME_TO_HOST_CANDIDATES,
18 |       ...options
19 |     };
20 | 
21 |     const {
22 |       RTCPeerConnection,
23 |       prefix,
24 |       host
25 |     } = options;
26 | 
27 |     this.createConnection = async (options = {}) => {
28 |       options = {
29 |         beforeAnswer() {},
30 |         stereo: false,
31 |         ...options
32 |       };
33 | 
34 |       const {
35 |         beforeAnswer,
36 |         stereo
37 |       } = options;
38 | 
39 |       const response1 = await fetch(`${host}${prefix}/connections`, {
40 |         method: 'POST'
41 |       });
42 | 
43 |       const remotePeerConnection = await response1.json();
44 |       const { id } = remotePeerConnection;
45 | 
46 |       const localPeerConnection = new RTCPeerConnection({
47 |         sdpSemantics: 'unified-plan'
48 |       });
49 | 
50 |       // NOTE(mroberts): This is a hack so that we can get a callback when the
51 |       // RTCPeerConnection is closed. In the future, we can subscribe to
52 |       // "connectionstatechange" events.
53 |       localPeerConnection.close = function() {
54 |         fetch(`${host}${prefix}/connections/${id}`, { method: 'delete' }).catch(() => {});
55 |         return RTCPeerConnection.prototype.close.apply(this, arguments);
56 |       };
57 | 
58 |       try {
59 |         await localPeerConnection.setRemoteDescription(remotePeerConnection.localDescription);
60 | 
61 |         await beforeAnswer(localPeerConnection);
62 | 
63 |         const originalAnswer = await localPeerConnection.createAnswer();
64 |         const updatedAnswer = new RTCSessionDescription({
65 |           type: 'answer',
66 |           sdp: stereo ? enableStereoOpus(originalAnswer.sdp) : originalAnswer.sdp
67 |         });
68 |         await localPeerConnection.setLocalDescription(updatedAnswer);
69 | 
70 |         await fetch(`${host}${prefix}/connections/${id}/remote-description`, {
71 |           method: 'POST',
72 |           body: JSON.stringify(localPeerConnection.localDescription),
73 |           headers: {
74 |             'Content-Type': 'application/json'
75 |           }
76 |         });
77 | 
78 |         return localPeerConnection;
79 |       } catch (error) {
80 |         localPeerConnection.close();
81 |         throw error;
82 |       }
83 |     };
84 |   }
85 | }
86 | 
87 | function enableStereoOpus(sdp) {
88 |   return sdp.replace(/a=fmtp:111/, 'a=fmtp:111 stereo=1\r\na=fmtp:111');
89 | }
90 | 
91 | module.exports = ConnectionClient;
92 | 


--------------------------------------------------------------------------------
/examples/video-compositing/server.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const { createCanvas, createImageData } = require('canvas');
 4 | const { hsv } = require('color-space');
 5 | const { performance } = require('perf_hooks');
 6 | 
 7 | const { RTCVideoSink, RTCVideoSource, i420ToRgba, rgbaToI420 } = require('wrtc').nonstandard;
 8 | 
 9 | const width = 640;
10 | const height = 480;
11 | 
12 | function beforeOffer(peerConnection) {
13 |   const source = new RTCVideoSource();
14 |   const track = source.createTrack();
15 |   const transceiver = peerConnection.addTransceiver(track);
16 |   const sink = new RTCVideoSink(transceiver.receiver.track);
17 | 
18 |   let lastFrame = null;
19 | 
20 |   function onFrame({ frame }) {
21 |     lastFrame = frame;
22 |   }
23 | 
24 |   sink.addEventListener('frame', onFrame);
25 | 
26 |   // TODO(mroberts): Is pixelFormat really necessary?
27 |   const canvas = createCanvas(width, height);
28 |   const context = canvas.getContext('2d');
29 |   context.fillStyle = 'white';
30 |   context.fillRect(0, 0, width, height);
31 | 
32 |   let hue = 0;
33 | 
34 |   const interval = setInterval(() => {
35 |     if (lastFrame) {
36 |       const lastFrameCanvas = createCanvas(lastFrame.width,  lastFrame.height);
37 |       const lastFrameContext = lastFrameCanvas.getContext('2d');
38 | 
39 |       const rgba = new Uint8ClampedArray(lastFrame.width *  lastFrame.height * 4);
40 |       const rgbaFrame = createImageData(rgba, lastFrame.width, lastFrame.height);
41 |       i420ToRgba(lastFrame, rgbaFrame);
42 | 
43 |       lastFrameContext.putImageData(rgbaFrame, 0, 0);
44 |       context.drawImage(lastFrameCanvas, 0, 0);
45 |     } else {
46 |       context.fillStyle = 'rgba(255, 255, 255, 0.025)';
47 |       context.fillRect(0, 0, width, height);
48 |     }
49 | 
50 |     hue = ++hue % 360;
51 |     const [r, g, b] = hsv.rgb([hue, 100, 100]);
52 |     const thisTime = performance.now();
53 | 
54 |     context.font = '60px Sans-serif';
55 |     context.strokeStyle = 'black';
56 |     context.lineWidth = 1;
57 |     context.fillStyle = `rgba(${Math.round(r)}, ${Math.round(g)}, ${Math.round(b)}, 1)`;
58 |     context.textAlign = 'center';
59 |     context.save();
60 |     context.translate(width / 2, height / 2);
61 |     context.rotate(thisTime / 1000);
62 |     context.strokeText('node-webrtc', 0, 0);
63 |     context.fillText('node-webrtc', 0, 0);
64 |     context.restore();
65 | 
66 |     const rgbaFrame = context.getImageData(0, 0, width, height);
67 |     const i420Frame = {
68 |       width,
69 |       height,
70 |       data: new Uint8ClampedArray(1.5 * width * height)
71 |     };
72 |     rgbaToI420(rgbaFrame, i420Frame);
73 |     source.onFrame(i420Frame);
74 |   });
75 | 
76 |   // NOTE(mroberts): This is a hack so that we can get a callback when the
77 |   // RTCPeerConnection is closed. In the future, we can subscribe to
78 |   // "connectionstatechange" events.
79 |   const { close } = peerConnection;
80 |   peerConnection.close = function() {
81 |     clearInterval(interval);
82 |     sink.stop();
83 |     track.stop();
84 |     return close.apply(this, arguments);
85 |   };
86 | }
87 | 
88 | module.exports = { beforeOffer };
89 | 


--------------------------------------------------------------------------------
/examples/sine-wave-stereo/client.js:
--------------------------------------------------------------------------------
 1 | /* global Scope */
 2 | 'use strict';
 3 | 
 4 | require('Scope/dist/Scope.js');
 5 | 
 6 | const createExample = require('../../lib/browser/example');
 7 | const { acquireAudioContext, releaseAudioContext } = require('../../lib/browser/webaudio/refcountedaudiocontext');
 8 | 
 9 | const description = 'This example uses node-webrtc&rsquo;s RTCAudioSource to \
10 | generate a stereo sine wave server-side. Use the number input to change the \
11 | panning of the server-generated sine wave. Panning changes are sent to the \
12 | server using RTCDataChannel.';
13 | 
14 | const panningInput = document.createElement('input');
15 | panningInput.type = 'number';
16 | panningInput.value = 50;
17 | panningInput.min = 0;
18 | panningInput.max = 100;
19 | 
20 | const canvases = document.createElement('div');
21 | canvases.className = 'grid';
22 | 
23 | async function beforeAnswer(peerConnection) {
24 |   const audioContext = acquireAudioContext();
25 | 
26 |   const remoteStream = new MediaStream(peerConnection.getReceivers().map(receiver => receiver.track));
27 | 
28 |   const remoteAudio = document.createElement('audio');
29 |   remoteAudio.srcObject = remoteStream;
30 |   remoteAudio.play();
31 |   document.body.appendChild(remoteAudio);
32 | 
33 |   const source = audioContext.createMediaStreamSource(remoteStream);
34 |   const splitter = audioContext.createChannelSplitter(2);
35 |   source.connect(splitter);
36 | 
37 |   const leftCanvas = document.createElement('canvas');
38 |   const rightCanvas = document.createElement('canvas');
39 |   const leftScope = new Scope(audioContext, leftCanvas);
40 |   const rightScope = new Scope(audioContext, rightCanvas);
41 |   splitter.connect(leftScope.input, 0, 0);
42 |   splitter.connect(rightScope.input, 1, 0);
43 |   leftScope.start();
44 |   rightScope.start();
45 |   canvases.appendChild(leftCanvas);
46 |   canvases.appendChild(rightCanvas);
47 | 
48 |   let dataChannel = null;
49 | 
50 |   function onDataChannel({ channel }) {
51 |     if (channel.label === 'panning') {
52 |       dataChannel = channel;
53 |     }
54 |   }
55 | 
56 |   peerConnection.addEventListener('datachannel', onDataChannel);
57 | 
58 |   function onChange() {
59 |     if (dataChannel.readyState === 'open') {
60 |       dataChannel.send(panningInput.value);
61 |     }
62 |   }
63 | 
64 |   panningInput.addEventListener('change', onChange);
65 | 
66 |   // NOTE(mroberts): This is a hack so that we can get a callback when the
67 |   // RTCPeerConnection is closed. In the future, we can subscribe to
68 |   // "connectionstatechange" events.
69 |   const { close } = peerConnection;
70 |   peerConnection.close = function() {
71 |     panningInput.removeEventListener('change', onChange);
72 |     peerConnection.removeEventListener('datachannel', onDataChannel);
73 | 
74 |     remoteAudio.remove();
75 |     remoteAudio.srcObject = null;
76 | 
77 |     leftCanvas.remove();
78 |     rightCanvas.remove();
79 |     leftScope.stop();
80 |     rightScope.stop();
81 |     splitter.disconnect(leftScope.input, 0);
82 |     splitter.disconnect(rightScope.input, 1);
83 |     source.disconnect(splitter);
84 | 
85 |     releaseAudioContext();
86 | 
87 |     return close.apply(this, arguments);
88 |   };
89 | }
90 | 
91 | createExample('sine-wave-stereo', description, { beforeAnswer, stereo: true });
92 | 
93 | const panningLabel = document.createElement('label');
94 | panningLabel.innerText = 'Panning (0–100):';
95 | panningLabel.appendChild(panningInput);
96 | document.body.appendChild(panningLabel);
97 | 
98 | document.body.appendChild(canvases);
99 | 


--------------------------------------------------------------------------------
/examples/pitch-detector/client.js:
--------------------------------------------------------------------------------
 1 | /* global Scope */
 2 | 'use strict';
 3 | 
 4 | require('Scope/dist/Scope.js');
 5 | 
 6 | const createExample = require('../../lib/browser/example');
 7 | const { acquireAudioContext, releaseAudioContext } = require('../../lib/browser/webaudio/refcountedaudiocontext');
 8 | const WebAudioOscillatorNodeSineWave = require('../../lib/browser/webaudio/webaudiooscillatornodesinewave');
 9 | 
10 | const description = 'This example uses node-webrtc&rsquo;s RTCAudioSink to \
11 | implement simple pitch detection server-side. The client generates a sine \
12 | wave, and the server communicates the pitch it detects using RTCDataChannel. \
13 | Use the number input to change the frequency of the client-generated sine \
14 | wave.';
15 | 
16 | const frequencyInput = document.createElement('input');
17 | frequencyInput.type = 'number';
18 | frequencyInput.value = 440;
19 | frequencyInput.min = 0;
20 | frequencyInput.max = 48000 / 2;
21 | 
22 | const detectedFrequency = document.createElement('p');
23 | detectedFrequency.innerText = 'Detected Frequency:';
24 | 
25 | function beforeAnswer(peerConnection) {
26 |   const audioContext = acquireAudioContext();
27 |   const webAudioSineWave = new WebAudioOscillatorNodeSineWave({
28 |     frequency: frequencyInput.value
29 |   });
30 | 
31 |   function onChange() {
32 |     console.log(frequencyInput.value);
33 |     webAudioSineWave.setFrequency(frequencyInput.value);
34 |   }
35 | 
36 |   frequencyInput.addEventListener('change', onChange);
37 | 
38 |   const streamNode = audioContext.createMediaStreamDestination();
39 |   webAudioSineWave.node.connect(streamNode);
40 |   const { stream } = streamNode;
41 |   stream.getTracks().forEach(track => peerConnection.addTrack(track, stream));
42 | 
43 |   const canvas = document.createElement('canvas');
44 |   const scope = new Scope(audioContext, canvas);
45 |   webAudioSineWave.node.connect(scope.input);
46 |   scope.start();
47 |   document.body.appendChild(canvas);
48 | 
49 |   let dataChannel = null;
50 | 
51 |   function onMessage({ data }) {
52 |     detectedFrequency.innerText = `Detected Frequency: ${data} hz`;
53 |   }
54 | 
55 |   function onDataChannel({ channel }) {
56 |     if (channel.label !== 'frequency') {
57 |       return;
58 |     }
59 | 
60 |     dataChannel = channel;
61 |     dataChannel.addEventListener('message', onMessage);
62 |   }
63 | 
64 |   peerConnection.addEventListener('datachannel', onDataChannel);
65 | 
66 |   // NOTE(mroberts): This is a hack so that we can get a callback when the
67 |   // RTCPeerConnection is closed. In the future, we can subscribe to
68 |   // "connectionstatechange" events.
69 |   const { close } = peerConnection;
70 |   peerConnection.close = function() {
71 |     frequencyInput.removeEventListener('change', onChange);
72 | 
73 |     canvas.remove();
74 |     scope.stop();
75 |     webAudioSineWave.node.disconnect(scope.input);
76 | 
77 |     stream.getTracks().forEach(track => track.stop());
78 |     webAudioSineWave.node.disconnect(streamNode);
79 |     webAudioSineWave.close();
80 |     releaseAudioContext();
81 | 
82 |     if (dataChannel) {
83 |       dataChannel.removeEventListener('message', onMessage);
84 |     }
85 | 
86 |     return close.apply(this, arguments);
87 |   };
88 | }
89 | 
90 | createExample('pitch-detector', description, { beforeAnswer });
91 | 
92 | const frequencyLabel = document.createElement('label');
93 | frequencyLabel.innerText = 'Frequency (hz):';
94 | frequencyLabel.appendChild(frequencyInput);
95 | document.body.appendChild(frequencyLabel);
96 | document.body.appendChild(detectedFrequency);
97 | 


--------------------------------------------------------------------------------
/examples/sine-wave/client.js:
--------------------------------------------------------------------------------
  1 | /* global Scope */
  2 | 'use strict';
  3 | 
  4 | require('Scope/dist/Scope.js');
  5 | 
  6 | const createExample = require('../../lib/browser/example');
  7 | const { acquireAudioContext, releaseAudioContext } = require('../../lib/browser/webaudio/refcountedaudiocontext');
  8 | const PitchDetector = require('../../lib/common/pitchdetector');
  9 | 
 10 | const description = 'This example uses node-webrtc&rsquo;s RTCAudioSource to \
 11 | generate a sine wave server-side. Use the number input to change the frequency \
 12 | of the server-generated sine wave. Frequency changes are sent to the server \
 13 | using RTCDataChannel. Finally, pitch is detected client-side and displayed \
 14 | alongside the received waveform.';
 15 | 
 16 | const frequencyInput = document.createElement('input');
 17 | frequencyInput.type = 'number';
 18 | frequencyInput.value = 440;
 19 | frequencyInput.min = 0;
 20 | frequencyInput.max = 48000 / 2;
 21 | 
 22 | const detectedFrequency = document.createElement('p');
 23 | detectedFrequency.innerText = 'Detected Frequency:';
 24 | 
 25 | async function beforeAnswer(peerConnection) {
 26 |   const audioContext = acquireAudioContext();
 27 | 
 28 |   const remoteStream = new MediaStream(peerConnection.getReceivers().map(receiver => receiver.track));
 29 | 
 30 |   const remoteAudio = document.createElement('audio');
 31 |   remoteAudio.srcObject = remoteStream;
 32 |   remoteAudio.play();
 33 |   document.body.appendChild(remoteAudio);
 34 | 
 35 |   const source = audioContext.createMediaStreamSource(remoteStream);
 36 | 
 37 |   const canvas = document.createElement('canvas');
 38 |   const scope = new Scope(audioContext, canvas);
 39 |   source.connect(scope.input);
 40 |   scope.start();
 41 |   document.body.appendChild(canvas);
 42 | 
 43 |   const analyser = audioContext.createAnalyser();
 44 |   const bytes = new Uint8Array(analyser.fftSize);
 45 |   const pitchDetector = new PitchDetector();
 46 |   source.connect(analyser);
 47 | 
 48 |   const interval = setInterval(() => {
 49 |     const data = {
 50 |       samples: bytes,
 51 |       bitsPerSample: 8,
 52 |       sampleRate: audioContext.sampleRate,
 53 |       unsigned: true
 54 |     };
 55 |     analyser.getByteTimeDomainData(bytes);
 56 |     const frequency = pitchDetector.onData(data);
 57 |     if (frequency) {
 58 |       detectedFrequency.innerText = `Detected Frequency: ${frequency} hz`;
 59 |     }
 60 |   }, 1000);
 61 | 
 62 |   let dataChannel = null;
 63 | 
 64 |   function onDataChannel({ channel }) {
 65 |     if (channel.label === 'frequency') {
 66 |       dataChannel = channel;
 67 |     }
 68 |   }
 69 | 
 70 |   peerConnection.addEventListener('datachannel', onDataChannel);
 71 | 
 72 |   function onChange() {
 73 |     if (dataChannel.readyState === 'open') {
 74 |       dataChannel.send(frequencyInput.value);
 75 |     }
 76 |   }
 77 | 
 78 |   frequencyInput.addEventListener('change', onChange);
 79 | 
 80 |   // NOTE(mroberts): This is a hack so that we can get a callback when the
 81 |   // RTCPeerConnection is closed. In the future, we can subscribe to
 82 |   // "connectionstatechange" events.
 83 |   const { close } = peerConnection;
 84 |   peerConnection.close = function() {
 85 |     frequencyInput.removeEventListener('change', onChange);
 86 |     peerConnection.removeEventListener('datachannel', onDataChannel);
 87 | 
 88 |     remoteAudio.remove();
 89 |     remoteAudio.srcObject = null;
 90 | 
 91 |     canvas.remove();
 92 |     scope.stop();
 93 |     source.disconnect(scope.input);
 94 | 
 95 |     clearInterval(interval);
 96 |     source.disconnect(analyser);
 97 |     releaseAudioContext();
 98 | 
 99 |     return close.apply(this, arguments);
100 |   };
101 | }
102 | 
103 | createExample('sine-wave', description, { beforeAnswer });
104 | 
105 | const frequencyLabel = document.createElement('label');
106 | frequencyLabel.innerText = 'Frequency (hz):';
107 | frequencyLabel.appendChild(frequencyInput);
108 | document.body.appendChild(frequencyLabel);
109 | document.body.appendChild(detectedFrequency);
110 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | node-webrtc-examples
 2 | ====================
 3 | 
 4 | This project presents a few example applications using node-webrtc.
 5 | 
 6 | - [audio-video-loopback](examples/audio-video-loopback): relays incoming audio
 7 |   and video using RTCRtpTransceivers.
 8 | - [ping-pong](examples/ping-pong): simple RTCDataChannel ping/pong example.
 9 | - [pitch-detector](examples/pitch-detector): pitch detector implemented using
10 |   RTCAudioSink and RTCDataChannel.
11 | - [sine-wave](examples/sine-wave): generates a sine wave using RTCAudioSource;
12 |   frequency control implemented using RTCDataChannel.
13 | - [sine-wave-stereo](examples/sine-wave-stereo): generates a stereo sine wave
14 |   using RTCAudioSource; panning control implemented using RTCDataChannel.
15 | - [video-compositing](examples/video-compositing): uses RTCVideoSink,
16 |   [node-canvas](https://github.com/Automattic/node-canvas), and RTCVideoSource
17 |   to draw spinning text on top of an incoming video.
18 | - [record-audio-video-stream](examples/record-audio-video-stream) using [FFmpeg](https://www.ffmpeg.org) and RTCVideoSink.
19 | - Broadcast example with one [broadcaster](examples/broadcaster) forwarding to many [viewers](examples/viewer).
20 | 
21 | Usage
22 | -----
23 | 
24 | Install the project's dependencies and run the tests before starting the
25 | application server:
26 | 
27 | ```
28 | npm install
29 | npm test
30 | npm start
31 | ```
32 | 
33 | Then, navigate to [http://localhost:3000](http://localhost:3000).
34 | 
35 | Architecture
36 | ------------
37 | 
38 | Each example application under [examples/](examples) has a Client and Server
39 | component. RTCPeerConnection negotiation is supported via a REST API (described
40 | below), and is abstracted away from each example application. Code for
41 | RTCPeerConnection negotiation lives under [lib/](lib).
42 | 
43 | ### RTCPeerConnection Negotiation
44 | 
45 | RTCPeerConnections are negotiated via REST API. The Server always offers (with
46 | host candidates) and the Client always answers. In order to negotiate a new
47 | RTCPeerConnection, the Client first POSTs to `/connections`. The Server responds
48 | with an RTCPeerConnection ID and SDP offer. Finally, the Client POSTs an SDP
49 | answer to the RTCPeerConnection's URL.
50 | 
51 | ```
52 | Client                                               Server
53 |   |                                                     |
54 |   |  POST /connections                                  |
55 |   |                                                     |
56 |   |---------------------------------------------------->|
57 |   |                                                     |
58 |   |                                             200 OK  |
59 |   |  { "id": "$ID", "localDescription": "$SDP_OFFER" }  |
60 |   |                                                     |
61 |   |<----------------------------------------------------|
62 |   |                                                     |
63 |   |  POST /connections/$ID/remote-description           |
64 |   |  $SDP_ANSWER                                        |
65 |   |                                                     |
66 |   |---------------------------------------------------->|
67 |   |                                                     |
68 |   |                                             200 OK  |
69 |   |                                                     |
70 |   |<----------------------------------------------------|
71 | ```
72 | 
73 | ### RTCPeerConnection Teardown
74 | 
75 | RTCPeerConnections can be proactively torn down by sending a DELETE to the
76 | RTCPeerConnection's URL; otherwise, ICE disconnection or failure, if unresolved
77 | within the `timeToReconnect` window, will also trigger teardown. The default
78 | `timeToReconnect` value is 10 s.
79 | 
80 | ```
81 | Client                                               Server
82 |   |                                                     |
83 |   |  DELETE /connections/$ID                            |
84 |   |                                                     |
85 |   |---------------------------------------------------->|
86 |   |                                                     |
87 |   |                                             200 OK  |
88 |   |                                                     |
89 |   |<----------------------------------------------------|
90 | ```
91 | 


--------------------------------------------------------------------------------
/test/integration/server/rest/connectionsapi.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | 
  3 | const bodyParser = require('body-parser');
  4 | const express = require('express');
  5 | const fetch = require('node-fetch');
  6 | const tape = require('tape');
  7 | 
  8 | const WebRtcConnection = require('../../../../lib/server/connections/webrtcconnection');
  9 | const WebRtcConnectionManager = require('../../../../lib/server/connections/webrtcconnectionmanager');
 10 | const connectionsApi = require('../../../../lib/server/rest/connectionsapi');
 11 | 
 12 | const TestRtcPeerConnection = require('../../../lib/testrtcpeerconnection');
 13 | 
 14 | async function delete_(url) {
 15 |   const response = await fetch(url, {
 16 |     method: 'delete'
 17 |   });
 18 |   return response.json();
 19 | }
 20 | 
 21 | async function get(url) {
 22 |   const response = await fetch(url);
 23 |   return response.json();
 24 | }
 25 | 
 26 | async function post(url, body) {
 27 |   const options = {
 28 |     headers: {},
 29 |     method: 'post'
 30 |   };
 31 |   if (typeof body !== 'undefined') {
 32 |     options.body = JSON.stringify(body);
 33 |     options.headers['Content-Type'] = 'application/json';
 34 |   }
 35 |   const response = await fetch(url, options);
 36 |   return response.json();
 37 | }
 38 | 
 39 | tape('connectionsApi(app, connectionManager)', t => {
 40 |   t.test('typical usage', t => {
 41 |     const app = express();
 42 | 
 43 |     app.use(bodyParser.json());
 44 | 
 45 |     const connectionManager = new WebRtcConnectionManager({
 46 |       Connection: function Connection(id) {
 47 |         return new WebRtcConnection(id, {
 48 |           RTCPeerConnection: TestRtcPeerConnection
 49 |         });
 50 |       }
 51 |     });
 52 | 
 53 |     connectionsApi(app, connectionManager);
 54 | 
 55 |     const server = app.listen(3000, async () => {
 56 |       const connections1 = await get('http://localhost:3000/v1/connections');
 57 | 
 58 |       t.deepEqual(connections1, [], 'GET /v1/connections initially returns the empty array');
 59 | 
 60 |       const connection1 = await post('http://localhost:3000/v1/connections');
 61 | 
 62 |       TestRtcPeerConnection.peerConnections.shift();
 63 | 
 64 |       t.ok(connection1.localDescription, 'POST /v1/connections returns a new connection with a local description');
 65 | 
 66 |       const connection2 = await get(`http://localhost:3000/v1/connections/${connection1.id}`);
 67 | 
 68 |       t.deepEqual(connection1, connection2, 'GET /v1/connection/$id returns the connection');
 69 | 
 70 |       const connections2 = await get('http://localhost:3000/v1/connections');
 71 | 
 72 |       t.deepEqual(connections2, connectionManager.toJSON(), 'GET /v1/connections later returns the updated array');
 73 | 
 74 |       const localDescription = await get(`http://localhost:3000/v1/connections/${connection2.id}/local-description`);
 75 | 
 76 |       t.deepEqual(localDescription, connection2.localDescription, 'GET /v1/connections/$id/local-description returns the .localDescription');
 77 | 
 78 |       const remoteDescription1 = await get(`http://localhost:3000/v1/connections/${connection2.id}/remote-description`);
 79 | 
 80 |       t.deepEqual(remoteDescription1, {}, 'GET /v1/connections/$id/remote-description returns the .remoteDescription');
 81 | 
 82 |       const remoteDescription2 = await post(`http://localhost:3000/v1/connections/${connection2.id}/remote-description`, {
 83 |         type: 'answer',
 84 |         sdp: 'answer'
 85 |       });
 86 | 
 87 |       t.deepEqual(remoteDescription2, { type: 'answer', sdp: 'answer' }, 'POST /v1/connections/$id/remote-description allows updating the .remoteDescription');
 88 | 
 89 |       const remoteDescription3 = await get(`http://localhost:3000/v1/connections/${connection2.id}/remote-description`);
 90 | 
 91 |       t.deepEqual(remoteDescription3, remoteDescription2, 'GET /v1/connections/$id/remote-description returns the updated .remoteDescription');
 92 | 
 93 |       const connection3 = await delete_(`http://localhost:3000/v1/connections/${connection1.id}`);
 94 | 
 95 |       t.equal(connection3.state, 'closed', 'DELETE /v1/connection/$id returns the closed WebRtcConnection');
 96 | 
 97 |       const connections3 = await get('http://localhost:3000/v1/connections');
 98 | 
 99 |       t.deepEqual(connections3, [], 'GET /v1/connections finally returns the empty array again');
100 | 
101 |       server.close();
102 |       t.end();
103 |     });
104 |   });
105 | 
106 |   t.end();
107 | });
108 | 


--------------------------------------------------------------------------------
/examples/record-audio-video-stream/server.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | 
  3 | const { PassThrough } = require('stream')
  4 | const fs = require('fs')
  5 | 
  6 | const { RTCAudioSink, RTCVideoSink } = require('wrtc').nonstandard;
  7 | 
  8 | const ffmpegPath = require('@ffmpeg-installer/ffmpeg').path;
  9 | const ffmpeg = require('fluent-ffmpeg');
 10 | ffmpeg.setFfmpegPath(ffmpegPath);
 11 | const { StreamInput } = require('fluent-ffmpeg-multistream')
 12 | 
 13 | const VIDEO_OUTPUT_SIZE = '320x240'
 14 | const VIDEO_OUTPUT_FILE = './recording.mp4'
 15 | 
 16 | let UID = 0;
 17 | 
 18 | function beforeOffer(peerConnection) {
 19 |   const audioTransceiver = peerConnection.addTransceiver('audio');
 20 |   const videoTransceiver = peerConnection.addTransceiver('video');
 21 |   
 22 |   const audioSink = new RTCAudioSink(audioTransceiver.receiver.track);
 23 |   const videoSink = new RTCVideoSink(videoTransceiver.receiver.track);
 24 | 
 25 |   const streams = [];
 26 | 
 27 |   videoSink.addEventListener('frame', ({ frame: { width, height, data }}) => {
 28 |     const size = width + 'x' + height;
 29 |     if (!streams[0] || (streams[0] && streams[0].size !== size)) {
 30 |       UID++;
 31 | 
 32 |       const stream = {
 33 |         recordPath: './recording-' + size + '-' + UID + '.mp4',
 34 |         size,
 35 |         video: new PassThrough(),
 36 |         audio: new PassThrough()
 37 |       };
 38 | 
 39 |       const onAudioData = ({ samples: { buffer } }) => {
 40 |         if (!stream.end) {
 41 |           stream.audio.push(Buffer.from(buffer));
 42 |         }
 43 |       };
 44 | 
 45 |       audioSink.addEventListener('data', onAudioData);
 46 | 
 47 |       stream.audio.on('end', () => {
 48 |         audioSink.removeEventListener('data', onAudioData);
 49 |       });
 50 | 
 51 |       streams.unshift(stream);
 52 | 
 53 |       streams.forEach(item=>{
 54 |         if (item !== stream && !item.end) {
 55 |           item.end = true;
 56 |           if (item.audio) {
 57 |             item.audio.end();
 58 |           }
 59 |           item.video.end();
 60 |         }
 61 |       })
 62 |   
 63 |       stream.proc = ffmpeg()
 64 |         .addInput((new StreamInput(stream.video)).url)
 65 |         .addInputOptions([
 66 |           '-f', 'rawvideo',
 67 |           '-pix_fmt', 'yuv420p',
 68 |           '-s', stream.size,
 69 |           '-r', '30',
 70 |         ])
 71 |         .addInput((new StreamInput(stream.audio)).url)
 72 |         .addInputOptions([
 73 |           '-f s16le',
 74 |           '-ar 48k',
 75 |           '-ac 1',
 76 |         ])
 77 |         .on('start', ()=>{
 78 |           console.log('Start recording >> ', stream.recordPath)
 79 |         })
 80 |         .on('end', ()=>{
 81 |           stream.recordEnd = true;
 82 |           console.log('Stop recording >> ', stream.recordPath)
 83 |         })
 84 |         .size(VIDEO_OUTPUT_SIZE)
 85 |         .output(stream.recordPath);
 86 | 
 87 |         stream.proc.run();
 88 |     }
 89 | 
 90 |     streams[0].video.push(Buffer.from(data));
 91 |   });
 92 | 
 93 |   const { close } = peerConnection;
 94 |   peerConnection.close = function() {
 95 |     audioSink.stop();
 96 |     videoSink.stop();
 97 | 
 98 |     streams.forEach(({ audio, video, end, proc, recordPath })=>{
 99 |       if (!end) {
100 |         if (audio) {
101 |           audio.end();
102 |         }
103 |         video.end();
104 |       }
105 |     });
106 | 
107 |     let totalEnd = 0;
108 |     const timer = setInterval(()=>{
109 |       streams.forEach(stream=>{
110 |         if (stream.recordEnd) {
111 |           totalEnd++;
112 |           if (totalEnd === streams.length) {
113 |             clearTimeout(timer);
114 | 
115 |             const mergeProc = ffmpeg()
116 |               .on('start', ()=>{
117 |                 console.log('Start merging into ' + VIDEO_OUTPUT_FILE);
118 |               })
119 |               .on('end', ()=>{
120 |                 streams.forEach(({ recordPath })=>{
121 |                   fs.unlinkSync(recordPath);
122 |                 })
123 |                 console.log('Merge end. You can play ' + VIDEO_OUTPUT_FILE);
124 |               });
125 |         
126 |             streams.forEach(({ recordPath })=>{
127 |               mergeProc.addInput(recordPath)
128 |             });
129 |         
130 |             mergeProc
131 |               .output(VIDEO_OUTPUT_FILE)
132 |               .run();
133 |           }
134 |         }
135 |       });
136 |     }, 1000)
137 | 
138 |     return close.apply(this, arguments);
139 |   }
140 | }
141 | 
142 | module.exports = { beforeOffer };
143 | 


--------------------------------------------------------------------------------
/test/unit/server/connections/webrtcconnection.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | 
  3 | const tape = require('tape');
  4 | 
  5 | const WebRtcConnection = require('../../../../lib/server/connections/webrtcconnection');
  6 | 
  7 | const TestRtcPeerConnection = require('../../../lib/testrtcpeerconnection');
  8 | 
  9 | const ID = 0;
 10 | 
 11 | tape('WebRtcConnection', t => {
 12 |   t.test('constructor', t => {
 13 |     const connection = new WebRtcConnection(ID, { RTCPeerConnection: TestRtcPeerConnection });
 14 |     TestRtcPeerConnection.peerConnections.shift();
 15 |     t.ok(connection instanceof WebRtcConnection, 'it returns an instance of WebRtcConnection');
 16 |     connection.close();
 17 |     t.end();
 18 |   });
 19 | 
 20 |   t.test('connection timer, if fired before .iceConnectionState is "connected" or "completed"', t => {
 21 |     const callbacks = [];
 22 | 
 23 |     const connection = new WebRtcConnection(ID, {
 24 |       RTCPeerConnection: TestRtcPeerConnection,
 25 |       setTimeout(callback) {
 26 |         callbacks.push(callback);
 27 |         return callback;
 28 |       },
 29 |       clearTimeout(callback) {
 30 |         const index = callbacks.indexOf(callback);
 31 |         if (index > -1) {
 32 |           callbacks.splice(index, 1);
 33 |         }
 34 |       }
 35 |     });
 36 | 
 37 |     const peerConnection = TestRtcPeerConnection.peerConnections.shift();
 38 | 
 39 |     callbacks[0]();
 40 | 
 41 |     t.equal(peerConnection.signalingState, 'closed', 'the RTCPeerConnection will be closed');
 42 |     t.equal(connection.state, 'closed', 'the WebRtcConnection will be closed');
 43 | 
 44 |     t.end();
 45 |   });
 46 | 
 47 |   t.test('if .iceConnectionState becomes "connected" or "completed" before the connection timer fires', t => {
 48 |     const callbacks = [];
 49 | 
 50 |     const connection = new WebRtcConnection(ID, {
 51 |       RTCPeerConnection: TestRtcPeerConnection,
 52 |       setTimeout(callback) {
 53 |         callbacks.push(callback);
 54 |         return callback;
 55 |       },
 56 |       clearTimeout(callback) {
 57 |         const index = callbacks.indexOf(callback);
 58 |         if (index > -1) {
 59 |           callbacks.splice(index, 1);
 60 |         }
 61 |       }
 62 |     });
 63 | 
 64 |     const peerConnection = TestRtcPeerConnection.peerConnections.shift();
 65 | 
 66 |     const [callback] = callbacks;
 67 |     peerConnection.updateIceConnectionState('connected');
 68 | 
 69 |     t.ok(!callbacks.includes(callback), 'the connection timer will be canceled');
 70 |     connection.close();
 71 | 
 72 |     t.end();
 73 |   });
 74 | 
 75 |   t.test('reconnection timer, if fired before .iceConnectionState is "connected" or "completed"', t => {
 76 |     const callbacks = [];
 77 | 
 78 |     const connection = new WebRtcConnection(ID, {
 79 |       RTCPeerConnection: TestRtcPeerConnection,
 80 |       setTimeout(callback) {
 81 |         callbacks.push(callback);
 82 |         return callback;
 83 |       },
 84 |       clearTimeout(callback) {
 85 |         const index = callbacks.indexOf(callback);
 86 |         if (index > -1) {
 87 |           callbacks.splice(index, 1);
 88 |         }
 89 |       }
 90 |     });
 91 | 
 92 |     const peerConnection = TestRtcPeerConnection.peerConnections.shift();
 93 |     peerConnection.updateIceConnectionState('connected');
 94 |     peerConnection.updateIceConnectionState('disconnected');
 95 | 
 96 |     callbacks[0]();
 97 | 
 98 |     t.equal(peerConnection.signalingState, 'closed', 'the RTCPeerConnection will be closed');
 99 |     t.equal(connection.state, 'closed', 'the WebRtcConnection will be closed');
100 | 
101 |     t.end();
102 |   });
103 | 
104 |   t.test('if .iceConnectionState becomes "connected" or "completed" before the connection timer fires', t => {
105 |     const callbacks = [];
106 | 
107 |     const connection = new WebRtcConnection(ID, {
108 |       RTCPeerConnection: TestRtcPeerConnection,
109 |       setTimeout(callback) {
110 |         callbacks.push(callback);
111 |         return callback;
112 |       },
113 |       clearTimeout(callback) {
114 |         const index = callbacks.indexOf(callback);
115 |         if (index > -1) {
116 |           callbacks.splice(index, 1);
117 |         }
118 |       }
119 |     });
120 | 
121 |     const peerConnection = TestRtcPeerConnection.peerConnections.shift();
122 |     peerConnection.updateIceConnectionState('connected');
123 |     peerConnection.updateIceConnectionState('disconnected');
124 | 
125 |     const [callback] = callbacks;
126 |     peerConnection.updateIceConnectionState('connected');
127 | 
128 |     t.ok(!callbacks.includes(callback), 'the reconnection timer will be canceled');
129 |     connection.close();
130 | 
131 |     t.end();
132 |   });
133 | 
134 |   t.end();
135 | });
136 | 


--------------------------------------------------------------------------------
/examples/datachannel-buffer-limits/client.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | 
  3 | const createExample = require('../../lib/browser/example');
  4 | 
  5 | const description = 'This example sends a given amount of data from the client \
  6 | over an RTCDataChannel. Upon receipt, node-webrtc responds by sending the data \
  7 | back to the client. \
  8 | Data is chunked into pieces, you can adjust both the chunk size and global \
  9 | size to test the outbound buffer limits of the RTCDataChannel.';
 10 | 
 11 | const dataSize = document.createElement('input');
 12 | dataSize.type = 'number';
 13 | dataSize.value = 10;
 14 | dataSize.min = 1;
 15 | dataSize.max = 1024;
 16 | 
 17 | const chunkSize = document.createElement('input');
 18 | chunkSize.type = 'number';
 19 | chunkSize.value = 64;
 20 | chunkSize.step = 16;
 21 | chunkSize.min = 16;
 22 | chunkSize.max = 512;
 23 | 
 24 | function beforeAnswer(peerConnection) {
 25 |   let dataChannel = null;
 26 |   let downloadStartTime = 0;
 27 |   let downLoadDuration = 0;
 28 |   let downloadedBytes = 0;
 29 |   const uploadedBytes = (dataSize.value)*1024*1024;
 30 | 
 31 |   function closeDatachannel() {
 32 |     if (dataChannel) {
 33 |       dataChannel.removeEventListener('message', onMessage);
 34 |       dataChannel.close();
 35 |       dataChannel = null;
 36 |     }
 37 |   }
 38 | 
 39 |   function resetButtons() {
 40 |     document.querySelectorAll('button').forEach((button) => {
 41 |       if (button.innerText === 'Start') {
 42 |         button.disabled = false;
 43 |       }
 44 | 
 45 |       if (button.innerText === 'Stop') {
 46 |         button.disabled = true;
 47 |       }
 48 |     });
 49 |   }
 50 | 
 51 |   function onMessage({ data }) {
 52 |     if (/^#START/.test(data)) {
 53 |       downloadStartTime = Date.now();
 54 |       const uploadDuration = data.split(' ')[1];
 55 |       const uploadBitRate = uploadedBytes*8/(uploadDuration/1000)/1000000;
 56 |       const text = `Upload &emsp;&emsp;-- total : ${uploadedBytes}, duration : ${uploadDuration} ms, bitrate : ~${uploadBitRate.toFixed(2)} Mbits/s`;
 57 |       uploadLabel.innerHTML = text;
 58 |       console.log(text);
 59 | 
 60 |       return;
 61 |     }
 62 | 
 63 |     if (/^#STOP/.test(data)) {
 64 |       downLoadDuration = Date.now() - downloadStartTime;
 65 |       const downloadBitRate = downloadedBytes*8/(downLoadDuration/1000)/1000000;
 66 |       const text = `Download -- total : ${downloadedBytes}, duration : ${downLoadDuration} ms, bitrate : ~${downloadBitRate.toFixed(2)} Mbits/s`;
 67 |       downloadLabel.innerHTML = text;
 68 |       console.log(text);
 69 | 
 70 |       peerConnection.close();
 71 |       closeDatachannel();
 72 |       resetButtons();
 73 | 
 74 |       return;
 75 |     }
 76 | 
 77 |     downloadedBytes += data.length;
 78 |   }
 79 | 
 80 |   function onDataChannel({ channel }) {
 81 |     if (channel.label !== 'datachannel-buffer-limits') {
 82 |       return;
 83 |     }
 84 | 
 85 |     uploadLabel.innerHTML = 'Upload &emsp;&emsp;-- ...';
 86 |     downloadLabel.innerHTML = 'Download -- ...';
 87 | 
 88 |     // Slightly delaying everything because Firefox needs it
 89 |     setTimeout(() => {
 90 |       dataChannel = channel;
 91 |       dataChannel.addEventListener('message', onMessage);
 92 | 
 93 |       const queueStartTime = Date.now();
 94 |       const chunkSizeInBytes = (chunkSize.value)*1024;
 95 |       const loops = uploadedBytes / chunkSizeInBytes;
 96 |       const rem = uploadedBytes % chunkSizeInBytes;
 97 | 
 98 |       try {
 99 |         dataChannel.send(`#START ${chunkSize.value}`);
100 | 
101 |         var data = new Array(chunkSizeInBytes + 1).join('.');
102 |         for (let i = 0; i < loops; i++) {
103 |           dataChannel.send(data);
104 |         }
105 | 
106 |         if (rem) {
107 |           dataChannel.send(data);
108 |         }
109 | 
110 |         dataChannel.send('#STOP');
111 |         const queueDuration = Date.now() - queueStartTime;
112 |         console.log(`Queued ${uploadedBytes} bytes in ${queueDuration} ms`);
113 |       } catch(e) {
114 |         console.log('Failed to send data over dataChannel :', e);
115 |         peerConnection.close();
116 |         closeDatachannel();
117 |         resetButtons();
118 |         alert(e);
119 |       }
120 |     }, 200);
121 |   }
122 | 
123 |   function onConnectionStateChange(event) {
124 |     switch(peerConnection.connectionState) {
125 |       case "disconnected":
126 |       case "failed":
127 |       case "closed":
128 |         console.log('Received close event');
129 |         closeDatachannel();
130 |         break;
131 |     }
132 |   }
133 | 
134 |   peerConnection.addEventListener('connectionstatechange', onConnectionStateChange);
135 |   peerConnection.addEventListener('datachannel', onDataChannel);
136 | }
137 | 
138 | createExample('datachannel-buffer-limits', description, { beforeAnswer, RTCPeerConnection: window.RTCPeerConnection });
139 | 
140 | const dataSizeLabel = document.createElement('label');
141 | dataSizeLabel.innerText = 'Data size to send (MBytes):';
142 | dataSizeLabel.appendChild(dataSize);
143 | 
144 | const chunkSizeLabel = document.createElement('label');
145 | chunkSizeLabel.innerText = 'Chunk size (Kbytes):';
146 | chunkSizeLabel.appendChild(chunkSize);
147 | 
148 | const uploadLabel = document.createElement('label');
149 | uploadLabel.innerHTML = 'Upload &emsp;&emsp;-- ';
150 | 
151 | const downloadLabel = document.createElement('label');
152 | downloadLabel.innerHTML = 'Download -- ';
153 | 
154 | document.body.appendChild(dataSizeLabel);
155 | document.body.appendChild(chunkSizeLabel);
156 | document.body.appendChild(uploadLabel);
157 | document.body.appendChild(downloadLabel);
158 | 


--------------------------------------------------------------------------------
/lib/server/connections/webrtcconnection.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | 
  3 | const DefaultRTCPeerConnection = require('wrtc').RTCPeerConnection;
  4 | 
  5 | const Connection = require('./connection');
  6 | 
  7 | const TIME_TO_CONNECTED = 10000;
  8 | const TIME_TO_HOST_CANDIDATES = 3000;  // NOTE(mroberts): Too long.
  9 | const TIME_TO_RECONNECTED = 10000;
 10 | 
 11 | class WebRtcConnection extends Connection {
 12 |   constructor(id, options = {}) {
 13 |     super(id);
 14 | 
 15 |     options = {
 16 |       RTCPeerConnection: DefaultRTCPeerConnection,
 17 |       beforeOffer() {},
 18 |       clearTimeout,
 19 |       setTimeout,
 20 |       timeToConnected: TIME_TO_CONNECTED,
 21 |       timeToHostCandidates: TIME_TO_HOST_CANDIDATES,
 22 |       timeToReconnected: TIME_TO_RECONNECTED,
 23 |       ...options
 24 |     };
 25 | 
 26 |     const {
 27 |       RTCPeerConnection,
 28 |       beforeOffer,
 29 |       timeToConnected,
 30 |       timeToReconnected
 31 |     } = options;
 32 | 
 33 |     const peerConnection = new RTCPeerConnection({
 34 |       sdpSemantics: 'unified-plan'
 35 |     });
 36 | 
 37 |     beforeOffer(peerConnection);
 38 | 
 39 |     let connectionTimer = options.setTimeout(() => {
 40 |       if (peerConnection.iceConnectionState !== 'connected'
 41 |         && peerConnection.iceConnectionState !== 'completed') {
 42 |         this.close();
 43 |       }
 44 |     }, timeToConnected);
 45 | 
 46 |     let reconnectionTimer = null;
 47 | 
 48 |     const onIceConnectionStateChange = () => {
 49 |       if (peerConnection.iceConnectionState === 'connected'
 50 |         || peerConnection.iceConnectionState === 'completed') {
 51 |         if (connectionTimer) {
 52 |           options.clearTimeout(connectionTimer);
 53 |           connectionTimer = null;
 54 |         }
 55 |         options.clearTimeout(reconnectionTimer);
 56 |         reconnectionTimer = null;
 57 |       } else if (peerConnection.iceConnectionState === 'disconnected'
 58 |         || peerConnection.iceConnectionState === 'failed') {
 59 |         if (!connectionTimer && !reconnectionTimer) {
 60 |           const self = this;
 61 |           reconnectionTimer = options.setTimeout(() => {
 62 |             self.close();
 63 |           }, timeToReconnected);
 64 |         }
 65 |       }
 66 |     };
 67 | 
 68 |     peerConnection.addEventListener('iceconnectionstatechange', onIceConnectionStateChange);
 69 | 
 70 |     this.doOffer = async () => {
 71 |       const offer = await peerConnection.createOffer();
 72 |       await peerConnection.setLocalDescription(offer);
 73 |       try {
 74 |         await waitUntilIceGatheringStateComplete(peerConnection, options);
 75 |       } catch (error) {
 76 |         this.close();
 77 |         throw error;
 78 |       }
 79 |     };
 80 | 
 81 |     this.applyAnswer = async answer => {
 82 |       await peerConnection.setRemoteDescription(answer);
 83 |     };
 84 | 
 85 |     this.close = () => {
 86 |       peerConnection.removeEventListener('iceconnectionstatechange', onIceConnectionStateChange);
 87 |       if (connectionTimer) {
 88 |         options.clearTimeout(connectionTimer);
 89 |         connectionTimer = null;
 90 |       }
 91 |       if (reconnectionTimer) {
 92 |         options.clearTimeout(reconnectionTimer);
 93 |         reconnectionTimer = null;
 94 |       }
 95 |       peerConnection.close();
 96 |       super.close();
 97 |     };
 98 | 
 99 |     this.toJSON = () => {
100 |       return {
101 |         ...super.toJSON(),
102 |         iceConnectionState: this.iceConnectionState,
103 |         localDescription: this.localDescription,
104 |         remoteDescription: this.remoteDescription,
105 |         signalingState: this.signalingState
106 |       };
107 |     };
108 | 
109 |     Object.defineProperties(this, {
110 |       iceConnectionState: {
111 |         get() {
112 |           return peerConnection.iceConnectionState;
113 |         }
114 |       },
115 |       localDescription: {
116 |         get() {
117 |           return descriptionToJSON(peerConnection.localDescription, true);
118 |         }
119 |       },
120 |       remoteDescription: {
121 |         get() {
122 |           return descriptionToJSON(peerConnection.remoteDescription);
123 |         }
124 |       },
125 |       signalingState: {
126 |         get() {
127 |           return peerConnection.signalingState;
128 |         }
129 |       }
130 |     });
131 |   }
132 | }
133 | 
134 | function descriptionToJSON(description, shouldDisableTrickleIce) {
135 |   return !description ? {} : {
136 |     type: description.type,
137 |     sdp: shouldDisableTrickleIce ? disableTrickleIce(description.sdp) : description.sdp
138 |   };
139 | }
140 | 
141 | function disableTrickleIce(sdp) {
142 |   return sdp.replace(/\r\na=ice-options:trickle/g, '');
143 | }
144 | 
145 | async function waitUntilIceGatheringStateComplete(peerConnection, options) {
146 |   if (peerConnection.iceGatheringState === 'complete') {
147 |     return;
148 |   }
149 | 
150 |   const { timeToHostCandidates } = options;
151 | 
152 |   const deferred = {};
153 |   deferred.promise = new Promise((resolve, reject) => {
154 |     deferred.resolve = resolve;
155 |     deferred.reject = reject;
156 |   });
157 | 
158 |   const timeout = options.setTimeout(() => {
159 |     peerConnection.removeEventListener('icecandidate', onIceCandidate);
160 |     deferred.reject(new Error('Timed out waiting for host candidates'));
161 |   }, timeToHostCandidates);
162 | 
163 |   function onIceCandidate({ candidate }) {
164 |     if (!candidate) {
165 |       options.clearTimeout(timeout);
166 |       peerConnection.removeEventListener('icecandidate', onIceCandidate);
167 |       deferred.resolve();
168 |     }
169 |   }
170 | 
171 |   peerConnection.addEventListener('icecandidate', onIceCandidate);
172 | 
173 |   await deferred.promise;
174 | }
175 | 
176 | module.exports = WebRtcConnection;
177 | 


--------------------------------------------------------------------------------