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);
+    }
+}