Subversion Repositories qbpwcf-lib(archive)

(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.adapter = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){

 /* 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 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);

  });

  // FIXME: add headerExtensions, fecMechanismş and rtcp.

  sdp += 'a=rtcp-mux\r\n';

  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';

};

// Expose public methods.

module.exports = SDPUtils;

},{}],2:[function(require,module,exports){

/*

 *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.

 *

 *  Use of this source code is governed by a BSD-style license

 *  that can be found in the LICENSE file in the root of the source

 *  tree.

 */

 /* eslint-env node */

'use strict';

// Shimming starts here.

(function() {

  // Utils.

  var logging = require('./utils').log;

  var browserDetails = require('./utils').browserDetails;

  // Export to the adapter global object visible in the browser.

  module.exports.browserDetails = browserDetails;

  module.exports.extractVersion = require('./utils').extractVersion;

  module.exports.disableLog = require('./utils').disableLog;

  // Uncomment the line below if you want logging to occur, including logging

  // for the switch statement below. Can also be turned on in the browser via

  // adapter.disableLog(false), but then logging from the switch statement below

  // will not appear.

  // require('./utils').disableLog(false);

  // Browser shims.

  var chromeShim = require('./chrome/chrome_shim') || null;

  var edgeShim = require('./edge/edge_shim') || null;

  var firefoxShim = require('./firefox/firefox_shim') || null;

  var safariShim = require('./safari/safari_shim') || null;

  // Shim browser if found.

  switch (browserDetails.browser) {

    case 'opera': // fallthrough as it uses chrome shims

    case 'chrome':

      if (!chromeShim || !chromeShim.shimPeerConnection) {

        logging('Chrome shim is not included in this adapter release.');

        return;

      }

      logging('adapter.js shimming chrome.');

      // Export to the adapter global object visible in the browser.

      module.exports.browserShim = chromeShim;

      chromeShim.shimGetUserMedia();

      chromeShim.shimMediaStream();

      chromeShim.shimSourceObject();

      chromeShim.shimPeerConnection();

      chromeShim.shimOnTrack();

      break;

    case 'firefox':

      if (!firefoxShim || !firefoxShim.shimPeerConnection) {

        logging('Firefox shim is not included in this adapter release.');

        return;

      }

      logging('adapter.js shimming firefox.');

      // Export to the adapter global object visible in the browser.

      module.exports.browserShim = firefoxShim;

      firefoxShim.shimGetUserMedia();

      firefoxShim.shimSourceObject();

      firefoxShim.shimPeerConnection();

      firefoxShim.shimOnTrack();

      break;

    case 'edge':

      if (!edgeShim || !edgeShim.shimPeerConnection) {

        logging('MS edge shim is not included in this adapter release.');

        return;

      }

      logging('adapter.js shimming edge.');

      // Export to the adapter global object visible in the browser.

      module.exports.browserShim = edgeShim;

      edgeShim.shimGetUserMedia();

      edgeShim.shimPeerConnection();

      break;

    case 'safari':

      if (!safariShim) {

        logging('Safari shim is not included in this adapter release.');

        return;

      }

      logging('adapter.js shimming safari.');

      // Export to the adapter global object visible in the browser.

      module.exports.browserShim = safariShim;

      safariShim.shimGetUserMedia();

      break;

    default:

      logging('Unsupported browser!');

  }

})();

},{"./chrome/chrome_shim":3,"./edge/edge_shim":5,"./firefox/firefox_shim":7,"./safari/safari_shim":9,"./utils":10}],3:[function(require,module,exports){

/*

 *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.

 *

 *  Use of this source code is governed by a BSD-style license

 *  that can be found in the LICENSE file in the root of the source

 *  tree.

 */

 /* eslint-env node */

'use strict';

var logging = require('../utils.js').log;

var browserDetails = require('../utils.js').browserDetails;

var chromeShim = {

  shimMediaStream: function() {

    window.MediaStream = window.MediaStream || window.webkitMediaStream;

  },

  shimOnTrack: function() {

    if (typeof window === 'object' && window.RTCPeerConnection && !('ontrack' in

        window.RTCPeerConnection.prototype)) {

      Object.defineProperty(window.RTCPeerConnection.prototype, 'ontrack', {

        get: function() {

          return this._ontrack;

        },

        set: function(f) {

          var self = this;

          if (this._ontrack) {

            this.removeEventListener('track', this._ontrack);

            this.removeEventListener('addstream', this._ontrackpoly);

          }

          this.addEventListener('track', this._ontrack = f);

          this.addEventListener('addstream', this._ontrackpoly = function(e) {

            // onaddstream does not fire when a track is added to an existing

            // stream. But stream.onaddtrack is implemented so we use that.

            e.stream.addEventListener('addtrack', function(te) {

              var event = new Event('track');

              event.track = te.track;

              event.receiver = {track: te.track};

              event.streams = [e.stream];

              self.dispatchEvent(event);

            });

            e.stream.getTracks().forEach(function(track) {

              var event = new Event('track');

              event.track = track;

              event.receiver = {track: track};

              event.streams = [e.stream];

              this.dispatchEvent(event);

            }.bind(this));

          }.bind(this));

        }

      });

    }

  },

  shimSourceObject: function() {

    if (typeof window === 'object') {

      if (window.HTMLMediaElement &&

        !('srcObject' in window.HTMLMediaElement.prototype)) {

        // Shim the srcObject property, once, when HTMLMediaElement is found.

        Object.defineProperty(window.HTMLMediaElement.prototype, 'srcObject', {

          get: function() {

            return this._srcObject;

          },

          set: function(stream) {

            var self = this;

            // Use _srcObject as a private property for this shim

            this._srcObject = stream;

            if (this.src) {

              URL.revokeObjectURL(this.src);

            }

            if (!stream) {

              this.src = '';

              return;

            }

            this.src = URL.createObjectURL(stream);

            // We need to recreate the blob url when a track is added or

            // removed. Doing it manually since we want to avoid a recursion.

            stream.addEventListener('addtrack', function() {

              if (self.src) {

                URL.revokeObjectURL(self.src);

              }

              self.src = URL.createObjectURL(stream);

            });

            stream.addEventListener('removetrack', function() {

              if (self.src) {

                URL.revokeObjectURL(self.src);

              }

              self.src = URL.createObjectURL(stream);

            });

          }

        });

      }

    }

  },

  shimPeerConnection: function() {

    // The RTCPeerConnection object.

    window.RTCPeerConnection = function(pcConfig, pcConstraints) {

      // Translate iceTransportPolicy to iceTransports,

      // see https://code.google.com/p/webrtc/issues/detail?id=4869

      logging('PeerConnection');

      if (pcConfig && pcConfig.iceTransportPolicy) {

        pcConfig.iceTransports = pcConfig.iceTransportPolicy;

      }

      var pc = new webkitRTCPeerConnection(pcConfig, pcConstraints);

      var origGetStats = pc.getStats.bind(pc);

      pc.getStats = function(selector, successCallback, errorCallback) {

        var self = this;

        var args = arguments;

        // If selector is a function then we are in the old style stats so just

        // pass back the original getStats format to avoid breaking old users.

        if (arguments.length > 0 && typeof selector === 'function') {

          return origGetStats(selector, successCallback);

        }

        var fixChromeStats_ = function(response) {

          var standardReport = {};

          var reports = response.result();

          reports.forEach(function(report) {

            var standardStats = {

              id: report.id,

              timestamp: report.timestamp,

              type: report.type

            };

            report.names().forEach(function(name) {

              standardStats[name] = report.stat(name);

            });

            standardReport[standardStats.id] = standardStats;

          });

          return standardReport;

        };

        // shim getStats with maplike support

        var makeMapStats = function(stats, legacyStats) {

          var map = new Map(Object.keys(stats).map(function(key) {

            return[key, stats[key]];

          }));

          legacyStats = legacyStats || stats;

          Object.keys(legacyStats).forEach(function(key) {

            map[key] = legacyStats[key];

          });

          return map;

        };

        if (arguments.length >= 2) {

          var successCallbackWrapper_ = function(response) {

            args[1](makeMapStats(fixChromeStats_(response)));

          };

          return origGetStats.apply(this, [successCallbackWrapper_,

              arguments[0]]);

        }

        // promise-support

        return new Promise(function(resolve, reject) {

          if (args.length === 1 && typeof selector === 'object') {

            origGetStats.apply(self, [

              function(response) {

                resolve(makeMapStats(fixChromeStats_(response)));

              }, reject]);

          } else {

            // Preserve legacy chrome stats only on legacy access of stats obj

            origGetStats.apply(self, [

              function(response) {

                resolve(makeMapStats(fixChromeStats_(response),

                    response.result()));

              }, reject]);

          }

        }).then(successCallback, errorCallback);

      };

      return pc;

    };

    window.RTCPeerConnection.prototype = webkitRTCPeerConnection.prototype;

    // wrap static methods. Currently just generateCertificate.

    if (webkitRTCPeerConnection.generateCertificate) {

      Object.defineProperty(window.RTCPeerConnection, 'generateCertificate', {

        get: function() {

          return webkitRTCPeerConnection.generateCertificate;

        }

      });

    }

    ['createOffer', 'createAnswer'].forEach(function(method) {

      var nativeMethod = webkitRTCPeerConnection.prototype[method];

      webkitRTCPeerConnection.prototype[method] = function() {

        var self = this;

        if (arguments.length < 1 || (arguments.length === 1 &&

            typeof arguments[0] === 'object')) {

          var opts = arguments.length === 1 ? arguments[0] : undefined;

          return new Promise(function(resolve, reject) {

            nativeMethod.apply(self, [resolve, reject, opts]);

          });

        }

        return nativeMethod.apply(this, arguments);

      };

    });

    // add promise support -- natively available in Chrome 51

    if (browserDetails.version < 51) {

      ['setLocalDescription', 'setRemoteDescription', 'addIceCandidate']

          .forEach(function(method) {

            var nativeMethod = webkitRTCPeerConnection.prototype[method];

            webkitRTCPeerConnection.prototype[method] = function() {

              var args = arguments;

              var self = this;

              var promise = new Promise(function(resolve, reject) {

                nativeMethod.apply(self, [args[0], resolve, reject]);

              });

              if (args.length < 2) {

                return promise;

              }

              return promise.then(function() {

                args[1].apply(null, []);

              },

              function(err) {

                if (args.length >= 3) {

                  args[2].apply(null, [err]);

                }

              });

            };

          });

    }

    // shim implicit creation of RTCSessionDescription/RTCIceCandidate

    ['setLocalDescription', 'setRemoteDescription', 'addIceCandidate']

        .forEach(function(method) {

          var nativeMethod = webkitRTCPeerConnection.prototype[method];

          webkitRTCPeerConnection.prototype[method] = function() {

            arguments[0] = new ((method === 'addIceCandidate') ?

                RTCIceCandidate : RTCSessionDescription)(arguments[0]);

            return nativeMethod.apply(this, arguments);

          };

        });

    // support for addIceCandidate(null)

    var nativeAddIceCandidate =

        RTCPeerConnection.prototype.addIceCandidate;

    RTCPeerConnection.prototype.addIceCandidate = function() {

      return arguments[0] === null ? Promise.resolve()

          : nativeAddIceCandidate.apply(this, arguments);

    };

  }

};

// Expose public methods.

module.exports = {

  shimMediaStream: chromeShim.shimMediaStream,

  shimOnTrack: chromeShim.shimOnTrack,

  shimSourceObject: chromeShim.shimSourceObject,

  shimPeerConnection: chromeShim.shimPeerConnection,

  shimGetUserMedia: require('./getusermedia')

};

},{"../utils.js":10,"./getusermedia":4}],4:[function(require,module,exports){

/*

 *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.

 *

 *  Use of this source code is governed by a BSD-style license

 *  that can be found in the LICENSE file in the root of the source

 *  tree.

 */

 /* eslint-env node */

'use strict';

var logging = require('../utils.js').log;

// Expose public methods.

module.exports = function() {

  var constraintsToChrome_ = function(c) {

    if (typeof c !== 'object' || c.mandatory || c.optional) {

      return c;

    }

    var cc = {};

    Object.keys(c).forEach(function(key) {

      if (key === 'require' || key === 'advanced' || key === 'mediaSource') {

        return;

      }

      var r = (typeof c[key] === 'object') ? c[key] : {ideal: c[key]};

      if (r.exact !== undefined && typeof r.exact === 'number') {

        r.min = r.max = r.exact;

      }

      var oldname_ = function(prefix, name) {

        if (prefix) {

          return prefix + name.charAt(0).toUpperCase() + name.slice(1);

        }

        return (name === 'deviceId') ? 'sourceId' : name;

      };

      if (r.ideal !== undefined) {

        cc.optional = cc.optional || [];

        var oc = {};

        if (typeof r.ideal === 'number') {

          oc[oldname_('min', key)] = r.ideal;

          cc.optional.push(oc);

          oc = {};

          oc[oldname_('max', key)] = r.ideal;

          cc.optional.push(oc);

        } else {

          oc[oldname_('', key)] = r.ideal;

          cc.optional.push(oc);

        }

      }

      if (r.exact !== undefined && typeof r.exact !== 'number') {

        cc.mandatory = cc.mandatory || {};

        cc.mandatory[oldname_('', key)] = r.exact;

      } else {

        ['min', 'max'].forEach(function(mix) {

          if (r[mix] !== undefined) {

            cc.mandatory = cc.mandatory || {};

            cc.mandatory[oldname_(mix, key)] = r[mix];

          }

        });

      }

    });

    if (c.advanced) {

      cc.optional = (cc.optional || []).concat(c.advanced);

    }

    return cc;

  };

  var shimConstraints_ = function(constraints, func) {

    constraints = JSON.parse(JSON.stringify(constraints));

    if (constraints && constraints.audio) {

      constraints.audio = constraintsToChrome_(constraints.audio);

    }

    if (constraints && typeof constraints.video === 'object') {

      // Shim facingMode for mobile, where it defaults to "user".

      var face = constraints.video.facingMode;

      face = face && ((typeof face === 'object') ? face : {ideal: face});

      if ((face && (face.exact === 'user' || face.exact === 'environment' ||

                    face.ideal === 'user' || face.ideal === 'environment')) &&

          !(navigator.mediaDevices.getSupportedConstraints &&

            navigator.mediaDevices.getSupportedConstraints().facingMode)) {

        delete constraints.video.facingMode;

        if (face.exact === 'environment' || face.ideal === 'environment') {

          // Look for "back" in label, or use last cam (typically back cam).

          return navigator.mediaDevices.enumerateDevices()

          .then(function(devices) {

            devices = devices.filter(function(d) {

              return d.kind === 'videoinput';

            });

            var back = devices.find(function(d) {

              return d.label.toLowerCase().indexOf('back') !== -1;

            }) || (devices.length && devices[devices.length - 1]);

            if (back) {

              constraints.video.deviceId = face.exact ? {exact: back.deviceId} :

                                                        {ideal: back.deviceId};

            }

            constraints.video = constraintsToChrome_(constraints.video);

            logging('chrome: ' + JSON.stringify(constraints));

            return func(constraints);

          });

        }

      }

      constraints.video = constraintsToChrome_(constraints.video);

    }

    logging('chrome: ' + JSON.stringify(constraints));

    return func(constraints);

  };

  var shimError_ = function(e) {

    return {

      name: {

        PermissionDeniedError: 'NotAllowedError',

        ConstraintNotSatisfiedError: 'OverconstrainedError'

      }[e.name] || e.name,

      message: e.message,

      constraint: e.constraintName,

      toString: function() {

        return this.name + (this.message && ': ') + this.message;

      }

    };

  };

  var getUserMedia_ = function(constraints, onSuccess, onError) {

    shimConstraints_(constraints, function(c) {

      navigator.webkitGetUserMedia(c, onSuccess, function(e) {

        onError(shimError_(e));

      });

    });

  };

  navigator.getUserMedia = getUserMedia_;

  // Returns the result of getUserMedia as a Promise.

  var getUserMediaPromise_ = function(constraints) {

    return new Promise(function(resolve, reject) {

      navigator.getUserMedia(constraints, resolve, reject);

    });

  };

  if (!navigator.mediaDevices) {

    navigator.mediaDevices = {

      getUserMedia: getUserMediaPromise_,

      enumerateDevices: function() {

        return new Promise(function(resolve) {

          var kinds = {audio: 'audioinput', video: 'videoinput'};

          return MediaStreamTrack.getSources(function(devices) {

            resolve(devices.map(function(device) {

              return {label: device.label,

                      kind: kinds[device.kind],

                      deviceId: device.id,

                      groupId: ''};