sdp - npm Package Compare versions

Comparing version 0.3.1 to 1.0.0

package.json

 {
-    "name": "sdp",
-    "version": "0.3.1",
-    "description": "A parser/serializer for SDP to JSON. Useful for converting SDP to other formats like Jingle for WebRTC signalling",
-    "main": "sdp.js",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/legastero/sdp.git"
-    },
-    "keywords": [
-        "sdp", 
-        "webrtc", 
-        "xmpp", 
-        "jingle"
-    ],
-    "author": "Lance Stout <[e-mail]>",
-    "license": "MIT",
-    "dependencies": {
-        "underscore": "1.5.2"
-    },
-    "devDependencies": {
-        "precommit-hook": "",
-        "browserify": ""
-    }
+  "name": "sdp",
+  "version": "1.0.0",
+  "description": "SDP parsing and serialization utilities",
+  "main": "sdp.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fippo/sdp.git"
+  },
+  "scripts": {
+    "test": "eslint sdp.js test/sdp.js && node test/sdp.js"
+  },
+  "keywords": [
+    "sdp",
+    "webrtc"
+  ],
+  "author": "Philipp Hancke",
+  "license": "MIT",
+  "devDependencies": {
+    "eslint": "^2.8.0",
+    "tape": "^4.0.0"
+  }
 }

README.md

@@ -1,5 +0,4 @@
-# sdp - an SDP parser/serializer for the browser. 
-Useful for converting to Jingle for WebRTC signalling over XMPP.
+# SDP parsing and utlities
+originally for generating SDP from ORTC and vice versa -- see https://github.com/fippo/adapter/tree/shim-ortc
 
-## License
-MIT
+But it turned out to be useful for manipulating SDP outside the context of Microsofts Edge browser.

sdp.js

@@ -1,610 +0,490 @@
-var _ = require('underscore');
-var each = _.each;
-var filter = _.filter;
+ /* eslint-env node */
+'use strict';
 
+// SDP helpers.
+var SDPUtils = {};
 
-var Session = exports.Session = function (opts) {
-    var self = this;
+// 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);
+};
 
-    self.version = '0';
-    self.origin = {};
-    self.name = '-';
-    self.media = [];
-    self.connection = {};
-    self.bandwidth = {};
-    self.attributes = [];
+// The RTCP CNAME used by all peerconnections from the same JS.
+SDPUtils.localCName = SDPUtils.generateIdentifier();
 
-    _.extend(self, opts || {});
+// 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();
+  });
 };
-Session.prototype = {
-    constructor: {
-        value: Session
-    },
-    fromSDP: function (sdp) {
-        exports.parse(sdp, this); 
-    },
-    toSDP: function () {
-        var self = this;
-        var lines = [];
+// 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';
+  });
+};
 
-        lines.push('v=' + this.version);
+// 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;
+  });
+};
 
-        lines.push('o=' + this.origin.username + 
-                   ' ' + this.origin.sessionID + 
-                   ' ' + this.origin.sessionVersion +
-                   ' ' + this.origin.netType + 
-                   ' ' + this.origin.addrType + 
-                   ' ' + this.origin.address);
+// 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(' ');
+  }
 
-        lines.push('s=' + this.name);
+  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]
+  };
 
-        if (Object.keys(this.connection).length) {
-            lines.push('c=' + this.connection.netType +
-                       ' ' + this.connection.addrType +
-                       ' ' + this.connection.address);
-        }
+  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;
+};
 
-        each(this.bandwidth, function (val, key) {
-            lines.push('b=' + key + ' ' + val);
-        });
+// 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);
 
-        lines.push('t=0 0');
+  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(' ');
+};
 
-        each(this.attributes, function (attr) {
-            if (attr.value === true) {
-                lines.push('a=' + attr.key);
-            } else {
-                lines.push('a=' + attr.key + ':' + attr.value);
-            }
-        });
+// 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
+  };
 
-        each(this.media, function (media) {
-            media.toSDP(lines);    
-        });
+  parts = parts[0].split('/');
 
-        return lines.join('\r\n');
-    },
-    get headerExtensions() {
-        var results = [];
-        each(this.attributes, function (attr) {
-            if (attr.key === 'extmap') {
-                var parsed = attr.value.split(' '),
-                ext = {};
-                ext.value = parsed.shift();
-                if (ext.value.indexOf('/') != -1) {
-                    ext.direction = ext.value.substr(ext.value.indexOf('/') + 1);
-                    ext.value = ext.value.substr(0, ext.value.indexOf('/'));
-                } else {
-                    ext.direction = 'both';
-                }
-                ext.uri = parsed.shift();
-                ext.params = parsed;
+  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;
+};
 
-                results.push(ext);
-            }
-        });
+// 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';
+};
 
-        return results;
-    }
+// 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';
+};
 
-var Media = exports.Media = function (opts) {
-    var self = this;
+// 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;
+};
 
-    self.type = '';
-    self.port = undefined;
-    self.numberOfPorts = undefined;
-    self.proto = undefined;
-    self.formats = [];
-    self.connection = {};
-    self.bandwidth = {};
-    self.attributes = [];
+// 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;
+};
 
-    _.extend(self, opts || {});
+// 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(' ')
+  };
 };
-Media.prototype = {
-    constructor: {
-        value: Media
-    },
-    toSDP: function (lines) {
-        var self = this;
-        lines = lines || [];
+// 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 +
+          '\r\n';
+    });
+  }
+  return lines;
+};
 
-        lines.push('m=' + this.type + 
-                   ' ' + this.port +
-                   ((this.numberOfPorts > 1) ? '/' + this.numberOfPorts : '') +
-                   ' ' + this.proto +
-                   ' ' + this.formats.join(' '));
+// 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;
+};
 
-        if (Object.keys(this.connection).length) {
-            lines.push('c=' + this.connection.netType +
-                       ' ' + this.connection.addrType +
-                       ' ' + this.connection.address);
-        }
+// 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;
+};
 
-        each(this.bandwidth, function (val, key) {
-            lines.push('b=' + key + ' ' + val);
-        });
+// 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;
+};
 
-        each(this.attributes, function (attr) {
-            if (attr.value === true) {
-                lines.push('a=' + attr.key);
-            } else {
-                lines.push('a=' + attr.key + ':' + attr.value);
-            }
-        });
+// Serializes ICE parameters to SDP.
+SDPUtils.writeIceParameters = function(params) {
+  return 'a=ice-ufrag:' + params.usernameFragment + '\r\n' +
+      'a=ice-pwd:' + params.password + '\r\n';
+};
 
-        return lines.join('\r\n');
-    },
-    get payloadTypes() {
-        var payloads = {};
-        var vals = '';
+// 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;
+};
 
-        each(this.formats, function (fmtID) {
-            payloads[fmtID] = {
-                feedback: [],
-                parameters: []
-            };
-        });
-        each(this.attributes, function (attr) {
-            var parsed, codec;
-            if (attr.key === 'rtpmap') {
-                parsed = (/^(\d+) ?(.*)/).exec(attr.value);
-                if (parsed) {
-                    codec = parsed[1];
-                    vals = parsed[2].split(/\//);
+// Generates parts of the SDP media section describing the capabilities /
+// parameters.
+SDPUtils.writeRtpDescription = function(kind, caps) {
+  var sdp = '';
 
-                    if (payloads[codec]) {
-                        payloads[codec].id = codec;
-                        payloads[codec].name = vals[0];
-                        payloads[codec].clockrate = vals[1] || undefined;
-                        payloads[codec].channels = vals[2] || 1;
-                    }
-                }
-                return;
-            }
-            if (attr.key === 'fmtp') {
-                parsed = (/^(\d+) ?(.*)/).exec(attr.value);
-                if (parsed) {
-                    codec = parsed[1];
-                    vals = parsed[2].split(/;/);
+  // 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';
 
-                    if (payloads[codec]) {
-                        each(vals, function (val) {
-                            var parsed = val.split('=');
-                            var key = parsed[0].trim();
-                            var value = (parsed[1] || '').trim();
+  sdp += 'c=IN IP4 0.0.0.0\r\n';
+  sdp += 'a=rtcp:9 IN IP4 0.0.0.0\r\n';
 
-                            if (key) {
-                                payloads[codec].parameters.push({key: key, value: value});
-                            }
-                        });
-                    }
-                }
-                return;
-            }
-            if (attr.key === 'rtcp-fb') {
-                parsed = attr.value.split(' ');
-                codec = parsed.shift();
+  // 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);
+  });
+  // FIXME: add headerExtensions, fecMechanismş and rtcp.
+  sdp += 'a=rtcp-mux\r\n';
+  return sdp;
+};
 
-                var fb = {
-                    type: parsed.shift() || '',
-                    subtype: parsed.shift() || '',
-                    params: parsed
-                };
+// 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;
 
-                if (codec !== '*' && payloads[codec]) {
-                    payloads[codec].feedback.push(fb);
-                }
-                return;
-            }
-        });
+  // 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 results = [];
-        each(payloads, function (payload) {
-            results.push(payload);
-        });
-        return results;
-    },
-    set payloadTypes(val) {
-        var self = this;
-        each(val, function (payload) {
-            var payloadOpts = [payload.name];
-            if (payload.clockrate) {
-                payloadOpts.push(payload.clockrate);
-            }
-            if (payload.channels > 1) {
-                payloadOpts.push(payload.channels);
-            }
-            self.attributes.push({
-                key: 'rtpmap',
-                value: payload.id + ' ' + payloadOpts.join('/')
-            });
+  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];
+  }
 
-            payload.parameters = payload.parameters || [];
-            if (payload.parameters.length) {
-                var parameters = [];
-                each(payload.parameters, function (param) {
-                    parameters.push(param.key + '=' + param.value + ';');
-                });
-                self.attributes.push({
-                    key: 'fmtp',
-                    value: payload.id + ' ' + parameters.join(' ')
-                });
-            }
-
-            payload.feedback = payload.feedback || [];
-            each(payload.feedback, function (fb) {
-                self.attributes.push({
-                    key: 'rtcp-fb',
-                    value: [payload.id, fb.type, fb.subtype, fb.params.join(' ')].join(' ')
-                });
-            });
-        });
-    },
-    get feedback() {
-        var results = [];
-        each(this.attributes, function (attr) {
-            if (attr.key === 'rtcp-fb') {
-                var parsed = attr.value.split(' ');
-                var codec = parsed.shift();
-                var fb = {
-                    type: parsed.shift() || '',
-                    subtype: parsed.shift() || '',
-                    params: parsed
-                };
-
-                if (codec === '*') {
-                    results.push(fb);
-                }
-            }
-        });
-        return results;
-    },
-    set feedback(val) {
-        var self = this;
-        each(val, function (fb) {
-            self.attributes.push({
-                key: 'rtcp-fb',
-                value: ['*', fb.type, fb.params.join(' ')].join(' ')
-            });
-        });
-    },
-    get ice() {
-        var result = {
-            pwd: '',
-            ufrag: ''
+  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'
         };
-        var iceLines = filter(this.attributes, function (attr) {
-            return attr.key === 'ice-pwd' || attr.key === 'ice-ufrag';
-        });
+        encodingParameters.push(encParam);
+      }
+    }
+  });
+  if (encodingParameters.length === 0 && primarySsrc) {
+    encodingParameters.push({
+      ssrc: primarySsrc
+    });
+  }
 
-        each(iceLines, function (attr) {
-            if (attr.key === 'ice-pwd') {
-                result.pwd = attr.value;
-                return;
-            }
-            if (attr.key === 'ice-ufrag') {
-                result.ufrag = attr.value;
-                return;
-            }
-        });
+  // 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;
+};
 
-        return result;
-    },
-    set ice(val) {
-        if (val.ufrag) {
-            this.attributes.push({
-                key: 'ice-ufrag',
-                value: val.ufrag
-            });
-        }
-        if (val.pwd) {
-            this.attributes.push({
-                key: 'ice-pwd',
-                value: val.pwd
-            });
-        }
-    },
-    get candidates() {
-        var results = [];
+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';
+};
 
-        var candidateLines = filter(this.attributes, function (attr) {
-            return attr.key === 'candidate';
-        });
+SDPUtils.writeMediaSection = function(transceiver, caps, type, stream) {
+  var sdp = SDPUtils.writeRtpDescription(transceiver.kind, caps);
 
-        each(candidateLines, function (attr) {
-            var parsed = attr.value.split(' ');
-            var candidate = {};
+  // Map ICE parameters (ufrag, pwd) to SDP.
+  sdp += SDPUtils.writeIceParameters(
+      transceiver.iceGatherer.getLocalParameters());
 
-            candidate.foundation = parsed.shift();
-            candidate.component = parsed.shift();
-            candidate.protocol = parsed.shift();
-            candidate.priority = parsed.shift();
-            candidate.ip = parsed.shift();
-            candidate.port = parsed.shift();
-            for (var i = 0; i < parsed.length; i += 2) {
-                switch (parsed[i]) {
-                case 'typ':
-                    candidate.type = parsed[i + 1];
-                    break;
-                case 'raddr':
-                    candidate['rel-addr'] = parsed[i + 1];
-                    break;
-                case 'rport':
-                    candidate['rel-port'] = parsed[i + 1];
-                    break;
-                case 'generation':
-                    candidate.generation = parsed[i + 1];
-                    break;
-                }
-            }
-            candidate.network = '1';
+  // Map DTLS parameters to SDP.
+  sdp += SDPUtils.writeDtlsParameters(
+      transceiver.dtlsTransport.getLocalParameters(),
+      type === 'offer' ? 'actpass' : 'active');
 
-            results.push(candidate);
-        });
+  sdp += 'a=mid:' + transceiver.mid + '\r\n';
 
-        return results;
-    },
-    set candidates(val) {
-        var self = this;
-        each(val, function (candidate) {
-            var line = [
-                candidate.foundation,
-                candidate.component,
-                candidate.protocol,
-                candidate.priority,
-                candidate.ip,
-                candidate.port,
-                'typ',
-                candidate.type
-            ].join(' ');
+  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';
+  }
 
-            if (candidate['rel-addr']) {
-                line += ' raddr ' + candidate['rel-addr'];
-            }
-            if (candidate['rel-port']) {
-                line += ' rport ' + candidate['rel-port'];
-            }
-
-            line += ' generation ' + candidate.generation;
-
-            self.attributes.push({
-                key: 'candidate',
-                value: line
-            });
-        });
-    },
-    get remoteCandidates() {
-        var results = [];
-
-        var candidateLines = filter(this.attributes, function (attr) {
-            return attr.key === 'remote-candidate';
-        });
-
-        each(candidateLines, function (attr) {
-            var parsed = attr.value.split(' ');
-            var candidate = {};
-
-            candidate.component = parsed.shift();
-            candidate.ip = parsed.shift();
-            candidate.port = parsed.shift();
-
-            results.push(candidate);
-        });
-
-        return results;
-    },
-    set remoteCandidates(val) {
-        var self = this;
-        each(val, function (candidate) {
-            self.attributes.push({
-                key: 'remote-candidate',
-                value: [candidate.component, candidate.ip, candidate.port].join(' ')
-            });
-        });
-    },
-    get fingerprint() {
-        var result = {};
-        each(this.attributes, function (attr) {
-            if (attr.key === 'fingerprint') {
-                var parsed = attr.value.split(' ');
-                result.hash = parsed[0];
-                result.value = parsed[1];
-            }
-        });
-        return result;
-    },
-    set fingerprint(val) {
-        this.attributes.push({
-            key: 'fingerprint',
-            value: val.hash + ' ' + val.value
-        });
-    },
-    get encryption() {
-        var results = [];
-
-        var cryptoLines = filter(this.attributes, function (attr) {
-            return attr.key === 'crypto';
-        });
-
-        each(cryptoLines, function (attr) {
-            var parsed = attr.value.split(' ');
-            var crypto = {};
-
-            crypto.tag = parsed.shift();
-            crypto.cryptoSuite = parsed.shift();
-            crypto.keyParams = parsed.shift();
-            if (parsed.length) {
-                crypto.sessionParams = parsed.join(' ');
-            }
-
-            results.push(crypto);
-        });
-
-        return results;
-    },
-    set encryption(val) {
-        var self = this;
-        each(val, function (crypto) {
-            self.attributes.push({
-                key: 'crypto',
-                value: [crypto.tag, crypto.cryptoSuite, crypto.keyParams, crypto.sessionParams].join(' ')
-            });
-        });
-    },
-    get rtcp() {
-        var result = {};
-        each(this.attributes, function (attr) {
-            if (attr.key === 'rtcp') {
-                var parsed = attr.value.split(' ');
-                result.port = parsed[0];
-                result.netType = parsed[1];
-                result.addrType = parsed[2];
-                result.address = parsed[3];
-            }
-        });
-        return result;
-    },
-    set rtcp(val) {
-        this.attributes.push({
-            key: 'rtcp',
-            value: [val.port, val.netType, val.addrType, val.address].join(' ')
-        });
-    },
-    get headerExtensions() {
-        var results = [];
-        each(this.attributes, function (attr) {
-            if (attr.key === 'extmap') {
-                var parsed = attr.value.split(' ');
-                var ext = {};
-                ext.value = parsed.shift();
-                if (ext.value.indexOf('/') != -1) {
-                    ext.direction = ext.value.substr(ext.value.indexOf('/') + 1);
-                    ext.value = ext.value.substr(0, ext.value.indexOf('/'));
-                } else {
-                    ext.direction = 'both';
-                }
-                ext.uri = parsed.shift();
-                ext.params = parsed;
-
-                results.push(ext);
-            }
-        });
-        return results;
-    },
-    set headerExtensions(val) {
-        var self = this;
-        each(val, function (ext) {
-            self.attributes.push({
-                key: 'extmap',
-                value: [
-                    ext.value, 
-                    (ext.direction === 'both' ? '' : '/' + ext.direction),
-                    ext.uri,
-                    ext.params.join(' ')
-                ].join(' ')
-            });
-        });
-    },
-    get streamMode() {
-        var result = '';
-        each(this.attributes, function (attr) {
-            if (attr.key === 'sendrecv' || attr.key === 'recvonly' || attr.key === 'sendonly' || attr.key === 'inactive') {
-                result = attr.key;
-            }
-        });
-        return result;
-    },
-    set streamMode(val) {
-        this.attributes = _.filter(this.attributes, function (attr) {
-            return attr.key !== 'inactive' && attr.key !== 'sendonly' && attr.key !== 'recvonly' && attr.key !== 'sendrecv';
-        });
-        this.attributes.push({
-            key: val,
-            value: true
-        });
-    }
+  // 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;
 };
 
-
-
-var LINE_PARSERS = {
-    v: function (curr, value) {
-        curr.version = value;
-    },
-    o: function (curr, value) {
-        var parsed = value.split(/\s+/);
-        curr.origin = {
-            username: parsed[0],
-            sessionID: parsed[1],
-            sessionVersion: parsed[2],
-            netType: parsed[3],
-            addrType: parsed[4],
-            address: parsed[5]
-        };
-    },
-    s: function (curr, value) {
-        curr.name = value;
-    },
-    c: function (curr, value) {
-        var parsed = value.split(/\s+/);
-        curr.connection = {
-            netType: parsed[0],
-            addrType: parsed[1],
-            address: parsed[2]
-        };
-    },
-    m: function (curr, value) {
-        var parsed = (/^(\w+) +(\d+)(?:\/(\d))? +(\S+) (\d+( +\d+)*)/).exec(value);
-        if (parsed) {
-            curr.type = parsed[1];
-            curr.port = parseInt(parsed[2], 10);
-            curr.numberOfPorts = parseInt(parsed[3] || '1', 10);
-            curr.proto = parsed[4];
-            curr.formats = parsed[5].split(' ');
-        }
-    },
-    a: function (curr, value) {
-        var parsed = (/^([\w-]+)(?::(.*))?$/).exec(value);
-        if (parsed) {
-            curr.attributes.push({
-                key: parsed[1],
-                value: parsed[2] || true
-            });
-        }
-    },
-    b: function (curr, value) {
-        var parsed = (/^([\w-]+)(?::(.*))?$/).exec(value);
-        if (parsed) {
-            curr.bandwidth[parsed[1]] = parsed[2] || null;
-        }
+// 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';
 };
 
-exports.parse = function (sdp, existingSession) {
-    var session = existingSession || new Session();
-    var lines = sdp.split(/\r?\n/);
-    var curr = session;
-
-    for (var i = 0; i < lines.length; i++) {
-        var data = (/^(\w)=(.*)/).exec(lines[i]);
-        if (data) {
-            var lineType = data[1];
-            var lineValue = data[2];
-
-            if (lineType === 'm') {
-                var media = new Media();
-                session.media.push(media);
-                curr = media;
-            }
-
-            if (LINE_PARSERS[lineType]) {
-                LINE_PARSERS[lineType](curr, lineValue);
-            }
-        }
-    }
-
-    return session;
-};
+// Expose public methods.
+module.exports = SDPUtils;

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

New author

Supply chain risk

A new npm collaborator published a version of the package for the first time. New collaborators are usually benign additions to a project, but do indicate a change to the security surface area of a package.

Found 1 instance in 1 package

Fixed alerts

Uses eval

Supply chain risk

Package uses eval() which is a dangerous function. This prevents the code from running in certain environments and increases the risk that the code may contain exploits or malicious behavior.

Found 1 instance in 1 package

Dynamic require

Supply chain risk

Dynamic require can indicate the package is performing dangerous or unsafe dynamic code execution.

Found 1 instance in 1 package

Filesystem access

Supply chain risk

Accesses the file system, and could potentially read sensitive data.

Found 1 instance in 1 package

No v1

Quality

Package is not semver >=1. This means it is not stable and does not support ^ ranges.

Found 1 instance in 1 package

Improved metrics

Dependency count

0

decreased by-100%

Number of low quality alerts

1

decreased by-50%

Number of low supply chain risk alerts

0

decreased by-100%

Worsened metrics

Total package byte prevSize

23756

decreased by-89.64%

Number of package files

5

decreased by-44.44%

Lines of code

602

decreased by-90.5%

Number of lines in readme file

5

decreased by-16.67%

Number of medium supply chain risk alerts

2

increased by100%

Dependency changes

• - Removedunderscore@1.5.2

• - Removedunderscore@1.5.2(transitive)