Squashed 'third_party/rawrtc/rawrtc/' content from commit aa3ae4b24
Change-Id: I38a655a4259b62f591334e90a1315bd4e7e4d8ec
git-subtree-dir: third_party/rawrtc/rawrtc
git-subtree-split: aa3ae4b247275cc6e69c30613b3a4ba7fdc82d1b
diff --git a/htdocs/ortc/index.html b/htdocs/ortc/index.html
new file mode 100644
index 0000000..f5e46c6
--- /dev/null
+++ b/htdocs/ortc/index.html
@@ -0,0 +1,92 @@
+<!DOCTYPE html>
+<html>
+<head>
+ <meta charset="utf-8">
+ <title>ORTC/WebRTC Interop Data Channel Example</title>
+</head>
+<style>
+textarea {
+}
+</style>
+<body>
+ <textarea cols="120" rows="20" id="local-parameters" onclick="this.select();" readonly></textarea>
+ <textarea cols="120" rows="20" id="remote-parameters"></textarea><br />
+ <button type="button" onclick="start(peer);" id="start" disabled>Start</button>
+
+ <script type="text/javascript" src="sdp.js"></script>
+ <script type="text/javascript" src="https://webrtc.github.io/adapter/adapter-latest.js"></script>
+ <script type="text/javascript" src="webrtc-rawrtc.js"></script>
+ <script type="text/javascript">
+ 'use strict';
+
+ let localParameters = document.getElementById('local-parameters');
+ let remoteParameters = document.getElementById('remote-parameters');
+ let startButton = document.getElementById('start');
+
+ function getURLParameter(name) {
+ return decodeURIComponent((new RegExp('[?|&]' + name + '=' + '([^&;]+?)(&|#|;|$)').exec(location.search) || [null, ''])[1].replace(/\+/g, '%20')) || null;
+ }
+
+ function setRemoteParameters(peer) {
+ // Parse and apply the remote parameters
+ let parameters = JSON.parse(remoteParameters.value);
+ console.log('Remote parameters:', parameters);
+ peer.setRemoteParameters(parameters)
+ .then((parameters) => {
+ // Generate local parameters if controlled
+ if (peer instanceof ControlledPeer) {
+ getLocalParameters(peer);
+ }
+ })
+ .catch((error) => {
+ console.error(error);
+ });
+ };
+
+ function getLocalParameters(peer) {
+ // Generate and show the local parameters
+ peer.getLocalParameters()
+ .then((parameters) => {
+ console.log('Local parameters:', parameters);
+ localParameters.value = JSON.stringify(parameters);
+ });
+ }
+
+ function createPeer(controllingParameter) {
+ let controlling = controllingParameter == 'true' || controllingParameter == '1';
+ console.log('Role: ICE-Controll' + (controlling ? 'ing' : 'ed'));
+
+ // Create peer depending on the role
+ let peer = controlling ? new ControllingPeer() : new ControlledPeer();
+ peer.createPeerConnection();
+ let cat = peer.createDataChannel(peer.pc.createDataChannel('cat-noises', {
+ ordered: true,
+ negotiated: true,
+ id: 0
+ }));
+ peer.createDataChannel();
+
+ // Create local parameters if we are the controlling peer.
+ // Keep in mind this still uses offer/answer in the background, thus this
+ // limitation which does not exist for ORTC but does for WebRTC.
+ if (controlling) {
+ getLocalParameters(peer);
+ }
+
+ return peer;
+ }
+
+ function start(peer) {
+ // Apply remote parameters
+ // For the controlled peer, this will automatically generate local parameters
+ setRemoteParameters(peer);
+ startButton.disabled = true;
+ }
+
+ // Create peer
+ // Determine role from GET parameter (?controlling=true|false)
+ let peer = createPeer(getURLParameter('controlling'));
+ startButton.disabled = false;
+ </script>
+</body>
+</html>
diff --git a/htdocs/ortc/sdp.js b/htdocs/ortc/sdp.js
new file mode 100644
index 0000000..0dd2472
--- /dev/null
+++ b/htdocs/ortc/sdp.js
@@ -0,0 +1,549 @@
+/*
+ * Copyright Philipp Hancke
+ * License: MIT
+ * Source: https://github.com/fippo/sdp
+ *
+ * Extended by Lennart Grahl
+ */
+
+/* eslint-env node */
+'use strict';
+
+// SDP helpers.
+var SDPUtils = {};
+
+// Generate an alphanumeric identifier for cname or mids.
+// TODO: use UUIDs instead? https://gist.github.com/jed/982883
+SDPUtils.generateIdentifier = function() {
+ return Math.random().toString(36).substr(2, 10);
+};
+
+// The RTCP CNAME used by all peerconnections from the same JS.
+SDPUtils.localCName = SDPUtils.generateIdentifier();
+
+// Splits SDP into lines, dealing with both CRLF and LF.
+SDPUtils.splitLines = function(blob) {
+ return blob.trim().split('\n').map(function(line) {
+ return line.trim();
+ });
+};
+// Splits SDP into sessionpart and mediasections. Ensures CRLF.
+SDPUtils.splitSections = function(blob) {
+ var parts = blob.split('\nm=');
+ return parts.map(function(part, index) {
+ return (index > 0 ? 'm=' + part : part).trim() + '\r\n';
+ });
+};
+
+// Returns lines that start with a certain prefix.
+SDPUtils.matchPrefix = function(blob, prefix) {
+ return SDPUtils.splitLines(blob).filter(function(line) {
+ return line.indexOf(prefix) === 0;
+ });
+};
+
+// Parses an ICE candidate line. Sample input:
+// candidate:702786350 2 udp 41819902 8.8.8.8 60769 typ relay raddr 8.8.8.8
+// rport 55996"
+SDPUtils.parseCandidate = function(line) {
+ var parts;
+ // Parse both variants.
+ if (line.indexOf('a=candidate:') === 0) {
+ parts = line.substring(12).split(' ');
+ } else {
+ parts = line.substring(10).split(' ');
+ }
+
+ var candidate = {
+ foundation: parts[0],
+ component: parts[1],
+ protocol: parts[2].toLowerCase(),
+ priority: parseInt(parts[3], 10),
+ ip: parts[4],
+ port: parseInt(parts[5], 10),
+ // skip parts[6] == 'typ'
+ type: parts[7]
+ };
+
+ for (var i = 8; i < parts.length; i += 2) {
+ switch (parts[i]) {
+ case 'raddr':
+ candidate.relatedAddress = parts[i + 1];
+ break;
+ case 'rport':
+ candidate.relatedPort = parseInt(parts[i + 1], 10);
+ break;
+ case 'tcptype':
+ candidate.tcpType = parts[i + 1];
+ break;
+ default: // Unknown extensions are silently ignored.
+ break;
+ }
+ }
+ return candidate;
+};
+
+// Translates a candidate object into SDP candidate attribute.
+SDPUtils.writeCandidate = function(candidate) {
+ var sdp = [];
+ sdp.push(candidate.foundation);
+ sdp.push(candidate.component);
+ sdp.push(candidate.protocol.toUpperCase());
+ sdp.push(candidate.priority);
+ sdp.push(candidate.ip);
+ sdp.push(candidate.port);
+
+ var type = candidate.type;
+ sdp.push('typ');
+ sdp.push(type);
+ if (type !== 'host' && candidate.relatedAddress &&
+ candidate.relatedPort) {
+ sdp.push('raddr');
+ sdp.push(candidate.relatedAddress); // was: relAddr
+ sdp.push('rport');
+ sdp.push(candidate.relatedPort); // was: relPort
+ }
+ if (candidate.tcpType && candidate.protocol.toLowerCase() === 'tcp') {
+ sdp.push('tcptype');
+ sdp.push(candidate.tcpType);
+ }
+ return 'candidate:' + sdp.join(' ');
+};
+
+// Parses an rtpmap line, returns RTCRtpCoddecParameters. Sample input:
+// a=rtpmap:111 opus/48000/2
+SDPUtils.parseRtpMap = function(line) {
+ var parts = line.substr(9).split(' ');
+ var parsed = {
+ payloadType: parseInt(parts.shift(), 10) // was: id
+ };
+
+ parts = parts[0].split('/');
+
+ parsed.name = parts[0];
+ parsed.clockRate = parseInt(parts[1], 10); // was: clockrate
+ // was: channels
+ parsed.numChannels = parts.length === 3 ? parseInt(parts[2], 10) : 1;
+ return parsed;
+};
+
+// Generate an a=rtpmap line from RTCRtpCodecCapability or
+// RTCRtpCodecParameters.
+SDPUtils.writeRtpMap = function(codec) {
+ var pt = codec.payloadType;
+ if (codec.preferredPayloadType !== undefined) {
+ pt = codec.preferredPayloadType;
+ }
+ return 'a=rtpmap:' + pt + ' ' + codec.name + '/' + codec.clockRate +
+ (codec.numChannels !== 1 ? '/' + codec.numChannels : '') + '\r\n';
+};
+
+// Parses an a=extmap line (headerextension from RFC 5285). Sample input:
+// a=extmap:2 urn:ietf:params:rtp-hdrext:toffset
+SDPUtils.parseExtmap = function(line) {
+ var parts = line.substr(9).split(' ');
+ return {
+ id: parseInt(parts[0], 10),
+ uri: parts[1]
+ };
+};
+
+// Generates a=extmap line from RTCRtpHeaderExtensionParameters or
+// RTCRtpHeaderExtension.
+SDPUtils.writeExtmap = function(headerExtension) {
+ return 'a=extmap:' + (headerExtension.id || headerExtension.preferredId) +
+ ' ' + headerExtension.uri + '\r\n';
+};
+
+// Parses an ftmp line, returns dictionary. Sample input:
+// a=fmtp:96 vbr=on;cng=on
+// Also deals with vbr=on; cng=on
+SDPUtils.parseFmtp = function(line) {
+ var parsed = {};
+ var kv;
+ var parts = line.substr(line.indexOf(' ') + 1).split(';');
+ for (var j = 0; j < parts.length; j++) {
+ kv = parts[j].trim().split('=');
+ parsed[kv[0].trim()] = kv[1];
+ }
+ return parsed;
+};
+
+// Generates an a=ftmp line from RTCRtpCodecCapability or RTCRtpCodecParameters.
+SDPUtils.writeFmtp = function(codec) {
+ var line = '';
+ var pt = codec.payloadType;
+ if (codec.preferredPayloadType !== undefined) {
+ pt = codec.preferredPayloadType;
+ }
+ if (codec.parameters && Object.keys(codec.parameters).length) {
+ var params = [];
+ Object.keys(codec.parameters).forEach(function(param) {
+ params.push(param + '=' + codec.parameters[param]);
+ });
+ line += 'a=fmtp:' + pt + ' ' + params.join(';') + '\r\n';
+ }
+ return line;
+};
+
+// Parses an rtcp-fb line, returns RTCPRtcpFeedback object. Sample input:
+// a=rtcp-fb:98 nack rpsi
+SDPUtils.parseRtcpFb = function(line) {
+ var parts = line.substr(line.indexOf(' ') + 1).split(' ');
+ return {
+ type: parts.shift(),
+ parameter: parts.join(' ')
+ };
+};
+// Generate a=rtcp-fb lines from RTCRtpCodecCapability or RTCRtpCodecParameters.
+SDPUtils.writeRtcpFb = function(codec) {
+ var lines = '';
+ var pt = codec.payloadType;
+ if (codec.preferredPayloadType !== undefined) {
+ pt = codec.preferredPayloadType;
+ }
+ if (codec.rtcpFeedback && codec.rtcpFeedback.length) {
+ // FIXME: special handling for trr-int?
+ codec.rtcpFeedback.forEach(function(fb) {
+ lines += 'a=rtcp-fb:' + pt + ' ' + fb.type +
+ (fb.parameter && fb.parameter.length ? ' ' + fb.parameter : '') +
+ '\r\n';
+ });
+ }
+ return lines;
+};
+
+// Parses an RFC 5576 ssrc media attribute. Sample input:
+// a=ssrc:3735928559 cname:something
+SDPUtils.parseSsrcMedia = function(line) {
+ var sp = line.indexOf(' ');
+ var parts = {
+ ssrc: parseInt(line.substr(7, sp - 7), 10)
+ };
+ var colon = line.indexOf(':', sp);
+ if (colon > -1) {
+ parts.attribute = line.substr(sp + 1, colon - sp - 1);
+ parts.value = line.substr(colon + 1);
+ } else {
+ parts.attribute = line.substr(sp + 1);
+ }
+ return parts;
+};
+
+// Extracts SCTP capabilities from SDP media section or sessionpart.
+SDPUtils.getSctpCapabilities = function(mediaSection, sessionpart) {
+ var lines = SDPUtils.splitLines(mediaSection);
+ // Search in session part, too.
+ lines = lines.concat(SDPUtils.splitLines(sessionpart));
+ var maxMessageSize = lines.filter(function(line) {
+ return line.indexOf('a=max-message-size:') === 0;
+ });
+ // TODO: Use 65536 once Firefox has disabled PPID-based fragmentation
+ // see: https://lgrahl.de/articles/demystifying-webrtc-dc-size-limit.html
+ maxMessageSize = maxMessageSize.length ? parseInt(maxMessageSize[0].substr(19)) : 16384;
+ return {
+ maxMessageSize: maxMessageSize
+ };
+};
+
+// Serializes SCTP capabilities to SDP.
+SDPUtils.writeSctpCapabilities = function(capabilities) {
+ return 'a=max-message-size:' + capabilities.maxMessageSize + '\r\n'; // (03)
+};
+
+// Extracts SCTP port from SDP media section or sessionpart.
+SDPUtils.getSctpPort = function(mediaSection, sessionpart) {
+ var lines = SDPUtils.splitLines(mediaSection);
+ // Search in session part, too.
+ lines = lines.concat(SDPUtils.splitLines(sessionpart));
+ var port = lines.filter(function(line) {
+ return line.indexOf('a=sctp-port:') === 0;
+ });
+ port = port.length ? parseInt(port[0].substr(12), 10) : 5000;
+ return port;
+};
+
+// Serializes SCTP port to SDP.
+SDPUtils.writeSctpPort = function(port) {
+ // TODO: Enable (chromium can't cope with it)
+ // return 'a=sctp-port:' + (port ? port : 5000) + '\r\n'; // (03)
+ return '';
+};
+
+// Extracts DTLS parameters from SDP media section or sessionpart.
+// FIXME: for consistency with other functions this should only
+// get the fingerprint line as input. See also getIceParameters.
+SDPUtils.getDtlsParameters = function(mediaSection, sessionpart) {
+ var lines = SDPUtils.splitLines(mediaSection);
+ // Search in session part, too.
+ lines = lines.concat(SDPUtils.splitLines(sessionpart));
+ var fpLine = lines.filter(function(line) {
+ return line.indexOf('a=fingerprint:') === 0;
+ })[0].substr(14);
+ // Note: a=setup line is ignored since we use the 'auto' role.
+ var dtlsParameters = {
+ role: 'auto',
+ fingerprints: [{
+ algorithm: fpLine.split(' ')[0],
+ value: fpLine.split(' ')[1]
+ }]
+ };
+ return dtlsParameters;
+};
+
+// Serializes DTLS parameters to SDP.
+SDPUtils.writeDtlsParameters = function(params, setupType) {
+ var sdp = 'a=setup:' + setupType + '\r\n';
+ params.fingerprints.forEach(function(fp) {
+ sdp += 'a=fingerprint:' + fp.algorithm + ' ' + fp.value + '\r\n';
+ });
+ return sdp;
+};
+// Parses ICE information from SDP media section or sessionpart.
+// FIXME: for consistency with other functions this should only
+// get the ice-ufrag and ice-pwd lines as input.
+SDPUtils.getIceParameters = function(mediaSection, sessionpart) {
+ var lines = SDPUtils.splitLines(mediaSection);
+ // Search in session part, too.
+ lines = lines.concat(SDPUtils.splitLines(sessionpart));
+ var iceParameters = {
+ usernameFragment: lines.filter(function(line) {
+ return line.indexOf('a=ice-ufrag:') === 0;
+ })[0].substr(12),
+ password: lines.filter(function(line) {
+ return line.indexOf('a=ice-pwd:') === 0;
+ })[0].substr(10)
+ };
+ return iceParameters;
+};
+
+// Serializes ICE parameters to SDP.
+SDPUtils.writeIceParameters = function(params) {
+ return 'a=ice-ufrag:' + params.usernameFragment + '\r\n' +
+ 'a=ice-pwd:' + params.password + '\r\n';
+};
+
+// Parses the SDP media section and returns RTCRtpParameters.
+SDPUtils.parseRtpParameters = function(mediaSection) {
+ var description = {
+ codecs: [],
+ headerExtensions: [],
+ fecMechanisms: [],
+ rtcp: []
+ };
+ var lines = SDPUtils.splitLines(mediaSection);
+ var mline = lines[0].split(' ');
+ for (var i = 3; i < mline.length; i++) { // find all codecs from mline[3..]
+ var pt = mline[i];
+ var rtpmapline = SDPUtils.matchPrefix(
+ mediaSection, 'a=rtpmap:' + pt + ' ')[0];
+ if (rtpmapline) {
+ var codec = SDPUtils.parseRtpMap(rtpmapline);
+ var fmtps = SDPUtils.matchPrefix(
+ mediaSection, 'a=fmtp:' + pt + ' ');
+ // Only the first a=fmtp:<pt> is considered.
+ codec.parameters = fmtps.length ? SDPUtils.parseFmtp(fmtps[0]) : {};
+ codec.rtcpFeedback = SDPUtils.matchPrefix(
+ mediaSection, 'a=rtcp-fb:' + pt + ' ')
+ .map(SDPUtils.parseRtcpFb);
+ description.codecs.push(codec);
+ // parse FEC mechanisms from rtpmap lines.
+ switch (codec.name.toUpperCase()) {
+ case 'RED':
+ case 'ULPFEC':
+ description.fecMechanisms.push(codec.name.toUpperCase());
+ break;
+ default: // only RED and ULPFEC are recognized as FEC mechanisms.
+ break;
+ }
+ }
+ }
+ SDPUtils.matchPrefix(mediaSection, 'a=extmap:').forEach(function(line) {
+ description.headerExtensions.push(SDPUtils.parseExtmap(line));
+ });
+ // FIXME: parse rtcp.
+ return description;
+};
+
+// Generates parts of the SDP media section describing the capabilities /
+// parameters.
+SDPUtils.writeRtpDescription = function(kind, caps) {
+ var sdp = '';
+
+ // Build the mline.
+ sdp += 'm=' + kind + ' ';
+ sdp += caps.codecs.length > 0 ? '9' : '0'; // reject if no codecs.
+ sdp += ' UDP/TLS/RTP/SAVPF ';
+ sdp += caps.codecs.map(function(codec) {
+ if (codec.preferredPayloadType !== undefined) {
+ return codec.preferredPayloadType;
+ }
+ return codec.payloadType;
+ }).join(' ') + '\r\n';
+
+ sdp += 'c=IN IP4 0.0.0.0\r\n';
+ sdp += 'a=rtcp:9 IN IP4 0.0.0.0\r\n';
+
+ // Add a=rtpmap lines for each codec. Also fmtp and rtcp-fb.
+ caps.codecs.forEach(function(codec) {
+ sdp += SDPUtils.writeRtpMap(codec);
+ sdp += SDPUtils.writeFmtp(codec);
+ sdp += SDPUtils.writeRtcpFb(codec);
+ });
+ var maxptime = 0;
+ caps.codecs.forEach(function(codec) {
+ if (codec.maxptime > maxptime) {
+ maxptime = codec.maxptime;
+ }
+ });
+ if (maxptime > 0) {
+ sdp += 'a=maxptime:' + maxptime + '\r\n';
+ }
+ sdp += 'a=rtcp-mux\r\n';
+
+ caps.headerExtensions.forEach(function(extension) {
+ sdp += SDPUtils.writeExtmap(extension);
+ });
+ // FIXME: write fecMechanisms.
+ return sdp;
+};
+
+// Parses the SDP media section and returns an array of
+// RTCRtpEncodingParameters.
+SDPUtils.parseRtpEncodingParameters = function(mediaSection) {
+ var encodingParameters = [];
+ var description = SDPUtils.parseRtpParameters(mediaSection);
+ var hasRed = description.fecMechanisms.indexOf('RED') !== -1;
+ var hasUlpfec = description.fecMechanisms.indexOf('ULPFEC') !== -1;
+
+ // filter a=ssrc:... cname:, ignore PlanB-msid
+ var ssrcs = SDPUtils.matchPrefix(mediaSection, 'a=ssrc:')
+ .map(function(line) {
+ return SDPUtils.parseSsrcMedia(line);
+ })
+ .filter(function(parts) {
+ return parts.attribute === 'cname';
+ });
+ var primarySsrc = ssrcs.length > 0 && ssrcs[0].ssrc;
+ var secondarySsrc;
+
+ var flows = SDPUtils.matchPrefix(mediaSection, 'a=ssrc-group:FID')
+ .map(function(line) {
+ var parts = line.split(' ');
+ parts.shift();
+ return parts.map(function(part) {
+ return parseInt(part, 10);
+ });
+ });
+ if (flows.length > 0 && flows[0].length > 1 && flows[0][0] === primarySsrc) {
+ secondarySsrc = flows[0][1];
+ }
+
+ description.codecs.forEach(function(codec) {
+ if (codec.name.toUpperCase() === 'RTX' && codec.parameters.apt) {
+ var encParam = {
+ ssrc: primarySsrc,
+ codecPayloadType: parseInt(codec.parameters.apt, 10),
+ rtx: {
+ payloadType: codec.payloadType,
+ ssrc: secondarySsrc
+ }
+ };
+ encodingParameters.push(encParam);
+ if (hasRed) {
+ encParam = JSON.parse(JSON.stringify(encParam));
+ encParam.fec = {
+ ssrc: secondarySsrc,
+ mechanism: hasUlpfec ? 'red+ulpfec' : 'red'
+ };
+ encodingParameters.push(encParam);
+ }
+ }
+ });
+ if (encodingParameters.length === 0 && primarySsrc) {
+ encodingParameters.push({
+ ssrc: primarySsrc
+ });
+ }
+
+ // we support both b=AS and b=TIAS but interpret AS as TIAS.
+ var bandwidth = SDPUtils.matchPrefix(mediaSection, 'b=');
+ if (bandwidth.length) {
+ if (bandwidth[0].indexOf('b=TIAS:') === 0) {
+ bandwidth = parseInt(bandwidth[0].substr(7), 10);
+ } else if (bandwidth[0].indexOf('b=AS:') === 0) {
+ bandwidth = parseInt(bandwidth[0].substr(5), 10);
+ }
+ encodingParameters.forEach(function(params) {
+ params.maxBitrate = bandwidth;
+ });
+ }
+ return encodingParameters;
+};
+
+SDPUtils.writeSessionBoilerplate = function() {
+ // FIXME: sess-id should be an NTP timestamp.
+ return 'v=0\r\n' +
+ 'o=thisisadapterortc 8169639915646943137 2 IN IP4 127.0.0.1\r\n' +
+ 's=-\r\n' +
+ 't=0 0\r\n';
+};
+
+SDPUtils.writeMediaSection = function(transceiver, caps, type, stream) {
+ var sdp = SDPUtils.writeRtpDescription(transceiver.kind, caps);
+
+ // Map ICE parameters (ufrag, pwd) to SDP.
+ sdp += SDPUtils.writeIceParameters(
+ transceiver.iceGatherer.getLocalParameters());
+
+ // Map DTLS parameters to SDP.
+ sdp += SDPUtils.writeDtlsParameters(
+ transceiver.dtlsTransport.getLocalParameters(),
+ type === 'offer' ? 'actpass' : 'active');
+
+ sdp += 'a=mid:' + transceiver.mid + '\r\n';
+
+ if (transceiver.rtpSender && transceiver.rtpReceiver) {
+ sdp += 'a=sendrecv\r\n';
+ } else if (transceiver.rtpSender) {
+ sdp += 'a=sendonly\r\n';
+ } else if (transceiver.rtpReceiver) {
+ sdp += 'a=recvonly\r\n';
+ } else {
+ sdp += 'a=inactive\r\n';
+ }
+
+ // FIXME: for RTX there might be multiple SSRCs. Not implemented in Edge yet.
+ if (transceiver.rtpSender) {
+ var msid = 'msid:' + stream.id + ' ' +
+ transceiver.rtpSender.track.id + '\r\n';
+ sdp += 'a=' + msid;
+ sdp += 'a=ssrc:' + transceiver.sendEncodingParameters[0].ssrc +
+ ' ' + msid;
+ }
+ // FIXME: this should be written by writeRtpDescription.
+ sdp += 'a=ssrc:' + transceiver.sendEncodingParameters[0].ssrc +
+ ' cname:' + SDPUtils.localCName + '\r\n';
+ return sdp;
+};
+
+// Gets the direction from the mediaSection or the sessionpart.
+SDPUtils.getDirection = function(mediaSection, sessionpart) {
+ // Look for sendrecv, sendonly, recvonly, inactive, default to sendrecv.
+ var lines = SDPUtils.splitLines(mediaSection);
+ for (var i = 0; i < lines.length; i++) {
+ switch (lines[i]) {
+ case 'a=sendrecv':
+ case 'a=sendonly':
+ case 'a=recvonly':
+ case 'a=inactive':
+ return lines[i].substr(2);
+ default:
+ // FIXME: What should happen here?
+ }
+ }
+ if (sessionpart) {
+ return SDPUtils.getDirection(sessionpart);
+ }
+ return 'sendrecv';
+};
diff --git a/htdocs/ortc/webrtc-rawrtc.js b/htdocs/ortc/webrtc-rawrtc.js
new file mode 100644
index 0000000..bad70e0
--- /dev/null
+++ b/htdocs/ortc/webrtc-rawrtc.js
@@ -0,0 +1,396 @@
+'use strict';
+
+class Peer {
+ constructor() {
+ this.pc = null;
+ this.localMid = null;
+ this.localCandidates = [];
+ this.localParameters = null;
+ this.localDescription = null;
+ this.remoteParameters = null;
+ this.remoteDescription = null;
+ var _waitGatheringComplete = {};
+ _waitGatheringComplete.promise = new Promise((resolve, reject) => {
+ _waitGatheringComplete.resolve = resolve;
+ _waitGatheringComplete.reject = reject;
+ });
+ this._waitGatheringComplete = _waitGatheringComplete;
+ this.dc = {}
+ }
+
+ createPeerConnection() {
+ if (this.pc) {
+ console.warn('RTCPeerConnection already created');
+ return this.pc;
+ }
+
+ var self = this;
+
+ // Create peer connection
+ var pc = new RTCPeerConnection({
+ iceServers: [{
+ urls: 'stun:stun.l.google.com:19302'
+ }]
+ });
+
+ // Bind peer connection events
+ pc.onnegotiationneeded = function(event) {
+ console.log('Negotiation needed')
+ };
+ pc.onicecandidate = function(event) {
+ if (event.candidate) {
+ console.log('Gathered candidate:', event.candidate);
+ self.localCandidates.push(event.candidate);
+ } else {
+ console.log('Gathering complete');
+ self._waitGatheringComplete.resolve();
+ }
+ };
+ pc.onicecandidateerror = function(event) {
+ console.error('ICE candidate error:', event.errorText);
+ };
+ pc.onsignalingstatechange = function(event) {
+ console.log('Signaling state changed to:', pc.signalingState);
+ };
+ pc.oniceconnectionstatechange = function(event) {
+ console.log('ICE connection state changed to:', pc.iceConnectionState);
+ };
+ pc.onicegatheringstatechange = function(event) {
+ console.log('ICE gathering state changed to:', pc.iceGatheringState);
+ };
+ pc.onconnectionstatechange = function(event) {
+ console.log('Connection state changed to:', pc.connectionState);
+ };
+ pc.ondatachannel = function(event) {
+ self.createDataChannel(event.channel);
+ };
+
+ this.pc = pc;
+ return pc;
+ }
+
+ createDataChannel(dc) {
+ // Create data channel
+ dc = (typeof dc !== 'undefined') ? dc : this.pc.createDataChannel('example-channel', {
+ ordered: true
+ });
+
+ // Bind data channel events
+ dc.onopen = function(event) {
+ console.log('Data channel', dc.label, '(', dc.id, ')', 'open');
+ // Send 'hello'
+ dc.send('Hello from WebRTC on', navigator.userAgent);
+ };
+ dc.onbufferedamountlow = function(event) {
+ console.log('Data channel', dc.label, '(', dc.id, ')', 'buffered amount low');
+ };
+ dc.onerror = function(event) {
+ console.error('Data channel', dc.label, '(', dc.id, ')', 'error:', event);
+ };
+ dc.onclose = function(event) {
+ console.log('Data channel', dc.label, '(', dc.id, ')', 'closed');
+ };
+ dc.onmessage = function(event) {
+ var length = event.data.size || event.data.byteLength || event.data.length;
+ console.info('Data channel', dc.label, '(', dc.id, ')', 'message size:', length);
+ };
+
+ // Store channel
+ this.dc[dc.label] = dc;
+
+ return dc;
+ }
+
+ getLocalParameters() {
+ return new Promise((resolve, reject) => {
+ var error;
+ var self = this;
+
+ if (!this.localDescription) {
+ error = 'Must create offer/answer';
+ console.error(error);
+ reject(error);
+ return;
+ }
+
+ // Initialise parameters
+ var parameters = {
+ iceParameters: null,
+ iceCandidates: [],
+ dtlsParameters: null,
+ sctpParameters: null,
+ };
+
+ // Split sections
+ var sections = SDPUtils.splitSections(this.localDescription.sdp);
+ var session = sections.shift();
+
+ // Go through media sections
+ sections.forEach(function(mediaSection, sdpMLineIndex) {
+ // TODO: Ignore anything else but data transports
+
+ // Get mid
+ // TODO: This breaks with multiple transceivers
+ if (!self.localMid) {
+ var mid = SDPUtils.matchPrefix(mediaSection, 'a=mid:');
+ if (mid.length > 0) {
+ self.localMid = mid[0].substr(6);
+ }
+ }
+
+ // Get ICE parameters
+ if (!parameters.iceParameters) {
+ parameters.iceParameters = SDPUtils.getIceParameters(mediaSection, session);
+ }
+
+ // Get DTLS parameters
+ if (!parameters.dtlsParameters) {
+ parameters.dtlsParameters = SDPUtils.getDtlsParameters(mediaSection, session);
+ }
+
+ // Get SCTP parameters
+ if (!parameters.sctpParameters) {
+ parameters.sctpParameters = SDPUtils.getSctpCapabilities(mediaSection, session);
+ parameters.sctpParameters.port = SDPUtils.getSctpPort(mediaSection, session);
+ }
+ });
+
+ // ICE lite parameter
+ if (!parameters.iceParameters
+ || !parameters.dtlsParameters
+ || !parameters.sctpParameters) {
+ error = 'Could not retrieve required parameters from local description';
+ console.error(error);
+ reject(error);
+ return;
+ }
+ parameters.iceParameters.iceLite =
+ SDPUtils.matchPrefix(session, 'a=ice-lite').length > 0;
+
+ // Get ICE candidates
+ this._waitGatheringComplete.promise.then(() => {
+ // Add ICE candidates
+ for (var sdpCandidate of self.localCandidates) {
+ var candidate = SDPUtils.parseCandidate(sdpCandidate.candidate);
+ parameters.iceCandidates.push(candidate);
+ }
+
+ // Add ICE candidate complete sentinel
+ // parameters.iceCandidates.push({complete: true}); // TODO
+
+ // Done
+ resolve(parameters);
+ });
+ });
+ }
+
+ setRemoteParameters(parameters, type, localMid = null) {
+ return new Promise((resolve, reject) => {
+ if (this.remoteDescription) {
+ resolve(this.remoteDescription);
+ return;
+ }
+
+ if (!this.pc) {
+ console.error('Must create RTCPeerConnection instance');
+ return;
+ }
+
+ if (!localMid) {
+ localMid = this.localMid;
+ }
+ this.remoteParameters = parameters;
+
+ // Translate DTLS role
+ // TODO: This somehow didn't make it into SDPUtils
+ var setupType;
+ switch (parameters.dtlsParameters.role) {
+ case 'client':
+ setupType = 'active';
+ break;
+ case 'server':
+ setupType = 'passive';
+ break;
+ default:
+ // We map 'offer' to 'controlling' and 'answer' to 'controlled',
+ // so rawrtc will take 'server' if offering and 'client' if answering
+ // as specified by the ORTC spec
+ switch (type) {
+ case 'offer':
+ // WebRTC requires actpass in offer
+ setupType = 'actpass';
+ break;
+ case 'answer':
+ setupType = 'active';
+ break;
+ }
+ break;
+ }
+
+ // Write session section
+ var sdp = SDPUtils.writeSessionBoilerplate();
+ sdp += 'a=group:BUNDLE ' + localMid + '\r\n';
+ sdp += 'a=ice-options:trickle\r\n';
+ if (parameters.iceParameters.iceLite) {
+ sdp += 'a=ice-lite\r\n';
+ }
+
+ // Write media section
+ // TODO: Replace
+ // sdp += 'm=application 9 UDP/DTLS/SCTP webrtc-datachannel\r\n'; // (03)
+ sdp += 'm=application 9 DTLS/SCTP ' + parameters.sctpParameters.port + '\r\n'; // (01)
+ sdp += 'c=IN IP4 0.0.0.0\r\n';
+ sdp += 'a=mid:' + localMid + '\r\n';
+ sdp += 'a=sendrecv\r\n';
+
+ // SCTP part
+ sdp += SDPUtils.writeSctpCapabilities(parameters.sctpParameters);
+ sdp += SDPUtils.writeSctpPort(parameters.sctpParameters.port);
+ sdp += 'a=sctpmap:' + parameters.sctpParameters.port + ' webrtc-datachannel 65535\r\n'; // (01)
+
+ // DTLS part
+ sdp += SDPUtils.writeDtlsParameters(parameters.dtlsParameters, setupType);
+
+ // ICE part
+ sdp += 'a=connection:new\r\n'; // (03)
+ sdp += SDPUtils.writeIceParameters(parameters.iceParameters);
+
+ // Done
+ console.log('Remote description:\n' + sdp);
+
+ // Set remote description
+ this.pc.setRemoteDescription({type: type, sdp: sdp})
+ .then(() => {
+ console.log('Remote description:\n' + this.pc.remoteDescription.sdp);
+ this.remoteDescription = this.pc.remoteDescription;
+
+ // Add ICE candidates
+ for (var iceCandidate of parameters.iceCandidates) {
+ // Add component which ORTC doesn't have
+ // Note: We choose RTP as it doesn't actually matter for us
+ iceCandidate.component = 1; // RTP
+
+ // Create
+ var candidate = new RTCIceCandidate({
+ candidate: SDPUtils.writeCandidate(iceCandidate),
+ sdpMLineIndex: 0, // TODO: Fix
+ sdpMid: localMid // TODO: Fix
+ });
+
+ // Add
+ console.log(candidate.candidate);
+ this.pc.addIceCandidate(candidate)
+ .then(() => {
+ console.log('Added remote candidate', candidate);
+ });
+ }
+
+ // It's trickle ICE, no need to wait for candidates to be added
+ resolve();
+ })
+ .catch((error) => {
+ reject(error);
+ });
+ });
+ }
+
+ start() {}
+}
+
+class ControllingPeer extends Peer {
+ getLocalParameters() {
+ return new Promise((resolve, reject) => {
+ if (!this.pc) {
+ var error = 'Must create RTCPeerConnection instance';
+ console.error(error);
+ reject(error);
+ return;
+ }
+
+ var getLocalParameters = () => {
+ // Return parameters
+ super.getLocalParameters()
+ .then((parameters) => {
+ this.localParameters = parameters;
+ resolve(parameters);
+ })
+ .catch((error) => {
+ reject(error);
+ });
+ };
+
+ // Create offer
+ if (!this.localDescription) {
+ this.pc.createOffer()
+ .then((description) => {
+ return this.pc.setLocalDescription(description);
+ })
+ .then(() => {
+ console.log('Local description:\n' + this.pc.localDescription.sdp);
+ this.localDescription = this.pc.localDescription;
+ getLocalParameters();
+ })
+ .catch((error) => {
+ reject(error);
+ });
+ } else {
+ getLocalParameters();
+ }
+ });
+ }
+
+ setRemoteParameters(parameters, localMid = null) {
+ return super.setRemoteParameters(parameters, 'answer', localMid);
+ }
+}
+
+class ControlledPeer extends Peer {
+ getLocalParameters() {
+ return new Promise((resolve, reject) => {
+ var error;
+
+ if (!this.pc) {
+ error = 'Must create RTCPeerConnection instance';
+ console.error(error);
+ reject(error);
+ return;
+ }
+ if (!this.remoteDescription) {
+ error = 'Must have remote description';
+ console.error(error);
+ reject(error);
+ return;
+ }
+
+ var getLocalParameters = () => {
+ // Return parameters
+ super.getLocalParameters()
+ .then((parameters) => {
+ resolve(parameters);
+ })
+ .catch((error) => {
+ reject(error);
+ });
+ };
+
+ // Create answer
+ if (!this.localDescription) {
+ this.pc.createAnswer()
+ .then((description) => {
+ return this.pc.setLocalDescription(description);
+ })
+ .then(() => {
+ console.log('Local description:\n' + this.pc.localDescription.sdp);
+ this.localDescription = this.pc.localDescription;
+ getLocalParameters();
+ });
+ } else {
+ getLocalParameters();
+ }
+ });
+ }
+
+ setRemoteParameters(parameters, localMid = null) {
+ return super.setRemoteParameters(parameters, 'offer', localMid);
+ }
+}