shaka-player 4.7.13 → 4.8.0

package/lib/text/vtt_text_parser.js

@@ -15,7 +15,7 @@ goog.require('shaka.text.TextEngine');
 goog.require('shaka.util.Error');
 goog.require('shaka.util.StringUtils');
 goog.require('shaka.util.TextParser');
-goog.require('shaka.util.XmlUtils');
+goog.require('shaka.util.TXml');
 
 
 /**
@@ -458,26 +458,34 @@ shaka.text.VttTextParser = class {
    */
   static parseCueStyles(payload, rootCue, styles) {
     const VttTextParser = shaka.text.VttTextParser;
+    const StringUtils = shaka.util.StringUtils;
+    const TXml = shaka.util.TXml;
     // Optimization for unstyled payloads.
     if (!payload.includes('<')) {
-      rootCue.payload = VttTextParser.htmlUnescape_(payload);
+      rootCue.payload = StringUtils.htmlUnescape(payload);
       return;
     }
     if (styles.size === 0) {
       VttTextParser.addDefaultTextColor_(styles);
     }
-    payload = VttTextParser.replaceColorPayload_(payload);
+
     payload = VttTextParser.replaceKaraokeStylePayload_(payload);
     payload = VttTextParser.replaceVoiceStylePayload_(payload);
+    payload = VttTextParser.escapeInvalidChevrons_(payload);
     const xmlPayload = '<span>' + payload + '</span>';
-    const element = shaka.util.XmlUtils.parseXmlString(xmlPayload, 'span');
+    let element;
+    try {
+      element = TXml.parseXmlString(xmlPayload, 'span');
+    } catch (e) {
+      shaka.log.warning('cue parse fail: ', e);
+    }
+
     if (element) {
-      const childNodes = element.childNodes;
+      const childNodes = element.children;
       if (childNodes.length == 1) {
         const childNode = childNodes[0];
-        if (childNode.nodeType == Node.TEXT_NODE ||
-            childNode.nodeType == Node.CDATA_SECTION_NODE) {
-          rootCue.payload = VttTextParser.htmlUnescape_(payload);
+        if (!TXml.isNode(childNode)) {
+          rootCue.payload = StringUtils.htmlUnescape(payload);
           return;
         }
       }
@@ -486,8 +494,34 @@ shaka.text.VttTextParser = class {
       }
     } else {
       shaka.log.warning('The cue\'s markup could not be parsed: ', payload);
-      rootCue.payload = VttTextParser.htmlUnescape_(payload);
+      rootCue.payload = StringUtils.htmlUnescape(payload);
+    }
+  }
+
+  /**
+   * This method converts invalid > chevrons to HTML entities.
+   * It also removes < chevrons as per spec.
+   *
+   * @param {!string} input
+   * @return {string}
+   * @private
+   */
+  static escapeInvalidChevrons_(input) {
+    // Used to map HTML entities to characters.
+    const htmlEscapes = {
+      '< ': '',
+      ' >': ' &gt;',
+    };
+
+    const reEscapedHtml = /(< +>|<\s|\s>)/g;
+    const reHasEscapedHtml = RegExp(reEscapedHtml.source);
+    // This check is an optimization, since replace always makes a copy
+    if (input && reHasEscapedHtml.test(input)) {
+      return input.replace(reEscapedHtml, (entity) => {
+        return htmlEscapes[entity] || '';
+      });
     }
+    return input || '';
   }
 
   /**
@@ -601,66 +635,6 @@ shaka.text.VttTextParser = class {
     return newPayload;
   }
 
-  /**
-   * Converts color end tag to be valid for xml parsing
-   * For example,
-   * input: <c.yellow.bg_blue>Yellow text on blue bg</c>
-   * output: <c.yellow.bg_blue>Yellow text on blue bg</c.yellow.bg_blue>
-   *
-   * Returns original payload if invalid tag is found.
-   * Invalid tag example: <c.yellow><b>Example</c></b>
-   *
-   * @param {string} payload
-   * @return {string} processed payload
-   * @private
-   */
-  static replaceColorPayload_(payload) {
-    const names = [];
-    let nameStart = -1;
-    let newPayload = '';
-    for (let i = 0; i < payload.length; i++) {
-      if (payload[i] === '/' && i > 0 && payload[i - 1] === '<') {
-        const end = payload.indexOf('>', i);
-        if (end <= i) {
-          return payload;
-        }
-        const tagEnd = payload.substring(i + 1, end);
-        if (!tagEnd || tagEnd !== 'c') {
-          newPayload += payload[i];
-          continue;
-        }
-        const tagStart = names.pop();
-        if (!tagStart) {
-          newPayload += payload[i];
-        } else if (tagStart === tagEnd) {
-          newPayload += '/' + tagEnd + '>';
-          i += tagEnd.length + 1;
-        } else {
-          if (!tagStart.startsWith('c.')) {
-            newPayload += payload[i];
-            continue;
-          }
-          i += tagEnd.length + 1;
-          newPayload += '/' + tagStart + '>';
-        }
-      } else {
-        if (payload[i] === '<') {
-          nameStart = i + 1;
-          if (payload[nameStart] != 'c') {
-            nameStart = -1;
-          }
-        } else if (payload[i] === '>') {
-          if (nameStart > 0) {
-            names.push(payload.substr(nameStart, i - nameStart));
-            nameStart = -1;
-          }
-        }
-        newPayload += payload[i];
-      }
-    }
-    return newPayload;
-  }
-
   /**
    * @param {string} value
    * @param {string} defaultValue
@@ -708,13 +682,14 @@ shaka.text.VttTextParser = class {
   }
 
   /**
-   * @param {!Node} element
+   * @param {!shaka.extern.xml.Node} element
    * @param {!shaka.text.Cue} rootCue
    * @param {!Map.<string, shaka.text.Cue>} styles
    * @private
    */
   static generateCueFromElement_(element, rootCue, styles) {
     const VttTextParser = shaka.text.VttTextParser;
+    const TXml = shaka.util.TXml;
     const nestedCue = rootCue.clone();
     // We don't want propagate some properties.
     nestedCue.nestedCues = [];
@@ -725,11 +700,12 @@ shaka.text.VttTextParser = class {
     nestedCue.region = new shaka.text.CueRegion();
     nestedCue.position = null;
     nestedCue.size = 0;
-    if (element.nodeType === Node.ELEMENT_NODE && element.nodeName) {
+
+    if (shaka.util.TXml.isNode(element)) {
       const bold = shaka.text.Cue.fontWeight.BOLD;
       const italic = shaka.text.Cue.fontStyle.ITALIC;
       const underline = shaka.text.Cue.textDecoration.UNDERLINE;
-      const tags = element.nodeName.split(/(?=[ .])+/g);
+      const tags = element.tagName.split(/(?=[ .])+/g);
       for (const tag of tags) {
         let styleTag = tag;
         // White blanks at start indicate that the style is a voice
@@ -762,15 +738,14 @@ shaka.text.VttTextParser = class {
             nestedCue.textDecoration.push(underline);
             break;
           case 'font': {
-            const color =
-            /** @type {!Element} */(element).getAttribute('color');
+            const color = element.attributes['color'];
             if (color) {
               nestedCue.color = color;
             }
             break;
           }
           case 'div': {
-            const time = /** @type {!Element} */(element).getAttribute('time');
+            const time = element.attributes['time'];
             if (!time) {
               break;
             }
@@ -792,13 +767,13 @@ shaka.text.VttTextParser = class {
       }
     }
 
-    const isTextNode = (item) => shaka.util.XmlUtils.isText(item);
-    const childNodes = element.childNodes;
+    const isTextNode = (item) => shaka.util.TXml.isText(item);
+    const childNodes = element.children;
     if (isTextNode(element) ||
         (childNodes.length == 1 && isTextNode(childNodes[0]))) {
       // Trailing line breaks may lost when convert cue to HTML tag
       // Need to insert line break cue to preserve line breaks
-      const textArr = element.textContent.split('\n');
+      const textArr = TXml.getTextContents(element).split('\n');
       let isFirst = true;
       for (const text of textArr) {
         if (!isFirst) {
@@ -808,7 +783,7 @@ shaka.text.VttTextParser = class {
         }
         if (text.length > 0) {
           const textCue = nestedCue.clone();
-          textCue.payload = VttTextParser.htmlUnescape_(text);
+          textCue.payload = shaka.util.StringUtils.htmlUnescape(text);
           rootCue.nestedCues.push(textCue);
         }
         isFirst = false;
@@ -1024,42 +999,6 @@ shaka.text.VttTextParser = class {
 
     return (milliseconds / 1000) + seconds + (minutes * 60) + (hours * 3600);
   }
-
-  /**
-   * This method converts the HTML entities &amp;, &lt;, &gt;, &quot;, &#39;,
-   * &nbsp;, &lrm; and &rlm; in string to their corresponding characters.
-   *
-   * @param {!string} input
-   * @return {string}
-   * @private
-   */
-  static htmlUnescape_(input) {
-    // Used to map HTML entities to characters.
-    const htmlUnescapes = {
-      '&amp;': '&',
-      '&lt;': '<',
-      '&gt;': '>',
-      '&quot;': '"',
-      '&#39;': '\'',
-      '&nbsp;': '\u{a0}',
-      '&lrm;': '\u{200e}',
-      '&rlm;': '\u{200f}',
-    };
-
-    // Used to match HTML entities and HTML characters.
-    const reEscapedHtml = /&(?:amp|lt|gt|quot|#(0+)?39|nbsp|lrm|rlm);/g;
-    const reHasEscapedHtml = RegExp(reEscapedHtml.source);
-    // This check is an optimization, since replace always makes a copy
-    if (input && reHasEscapedHtml.test(input)) {
-      return input.replace(reEscapedHtml, (entity) => {
-        // The only thing that might not match the dictionary above is the
-        // single quote, which can be matched by many strings in the regex, but
-        // only has a single entry in the dictionary.
-        return htmlUnescapes[entity] || '\'';
-      });
-    }
-    return input || '';
-  }
 };
 
 /**

package/lib/transmuxer/opus.js

@@ -0,0 +1,91 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('shaka.transmuxer.Opus');
+
+goog.requireType('shaka.util.TsParser');
+
+
+/**
+ * Opus utils
+ */
+shaka.transmuxer.Opus = class {
+  /**
+   * @param {!shaka.util.TsParser.OpusMetadata} metadata
+   * @return {!Uint8Array}
+   */
+  static getAudioConfig(metadata) {
+    let mapping = [];
+    switch (metadata.channelConfigCode) {
+      case 0x01:
+      case 0x02:
+        mapping = [0x0];
+        break;
+      case 0x00: // dualmono
+        mapping = [0xFF, 1, 1, 0, 1];
+        break;
+      case 0x80: // dualmono
+        mapping = [0xFF, 2, 0, 0, 1];
+        break;
+      case 0x03:
+        mapping = [0x01, 2, 1, 0, 2, 1];
+        break;
+      case 0x04:
+        mapping = [0x01, 2, 2, 0, 1, 2, 3];
+        break;
+      case 0x05:
+        mapping = [0x01, 3, 2, 0, 4, 1, 2, 3];
+        break;
+      case 0x06:
+        mapping = [0x01, 4, 2, 0, 4, 1, 2, 3, 5];
+        break;
+      case 0x07:
+        mapping = [0x01, 4, 2, 0, 4, 1, 2, 3, 5, 6];
+        break;
+      case 0x08:
+        mapping = [0x01, 5, 3, 0, 6, 1, 2, 3, 4, 5, 7];
+        break;
+      case 0x82:
+        mapping = [0x01, 1, 2, 0, 1];
+        break;
+      case 0x83:
+        mapping = [0x01, 1, 3, 0, 1, 2];
+        break;
+      case 0x84:
+        mapping = [0x01, 1, 4, 0, 1, 2, 3];
+        break;
+      case 0x85:
+        mapping = [0x01, 1, 5, 0, 1, 2, 3, 4];
+        break;
+      case 0x86:
+        mapping = [0x01, 1, 6, 0, 1, 2, 3, 4, 5];
+        break;
+      case 0x87:
+        mapping = [0x01, 1, 7, 0, 1, 2, 3, 4, 5, 6];
+        break;
+      case 0x88:
+        mapping = [0x01, 1, 8, 0, 1, 2, 3, 4, 5, 6, 7];
+        break;
+    }
+
+    return new Uint8Array([
+      0x00,         // Version (1)
+      metadata.channelCount, // OutputChannelCount: 2
+      0x00, 0x00,   // PreSkip: 2
+      (metadata.sampleRate >>> 24) & 0xFF,  // Audio sample rate: 4
+      (metadata.sampleRate >>> 17) & 0xFF,
+      (metadata.sampleRate >>> 8) & 0xFF,
+      (metadata.sampleRate >>> 0) & 0xFF,
+      0x00, 0x00,  // Global Gain : 2
+      ...mapping,
+    ]);
+  }
+};
+
+/**
+ * @const {number}
+ */
+shaka.transmuxer.Opus.OPUS_AUDIO_SAMPLE_PER_FRAME = 960;

package/lib/transmuxer/ts_transmuxer.js

@@ -14,6 +14,7 @@ goog.require('shaka.transmuxer.Ec3');
 goog.require('shaka.transmuxer.H264');
 goog.require('shaka.transmuxer.H265');
 goog.require('shaka.transmuxer.MpegAudio');
+goog.require('shaka.transmuxer.Opus');
 goog.require('shaka.transmuxer.TransmuxerEngine');
 goog.require('shaka.util.BufferUtils');
 goog.require('shaka.util.Error');
@@ -274,6 +275,10 @@ shaka.transmuxer.TsTransmuxer = class {
             streamInfo =
               this.getMp3StreamInfo_(tsParser, stream, duration);
             break;
+          case 'opus':
+            streamInfo =
+              this.getOpusStreamInfo_(tsParser, stream, duration);
+            break;
         }
         if (streamInfo) {
           streamInfos.push(streamInfo);
@@ -734,6 +739,115 @@ shaka.transmuxer.TsTransmuxer = class {
   }
 
 
+  /**
+   * @param {shaka.util.TsParser} tsParser
+   * @param {shaka.extern.Stream} stream
+   * @param {number} duration
+   * @return {shaka.util.Mp4Generator.StreamInfo}
+   * @private
+   */
+  getOpusStreamInfo_(tsParser, stream, duration) {
+    const Opus = shaka.transmuxer.Opus;
+    const timescale = shaka.util.TsParser.Timescale;
+
+    /** @type {!Array.<shaka.util.Mp4Generator.Mp4Sample>} */
+    const samples = [];
+
+    let firstPts = null;
+
+    /** @type {?shaka.util.TsParser.OpusMetadata} */
+    const opusMetadata = tsParser.getOpusMetadata();
+
+    if (!opusMetadata) {
+      throw new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.MEDIA,
+          shaka.util.Error.Code.TRANSMUXING_FAILED);
+    }
+
+    /** @type {!Uint8Array} */
+    const audioConfig = Opus.getAudioConfig(opusMetadata);
+
+    /** @type {number} */
+    const sampleRate = opusMetadata.sampleRate;
+
+    for (const audioData of tsParser.getAudioData()) {
+      const data = audioData.data;
+      if (firstPts == null && audioData.pts !== null) {
+        firstPts = audioData.pts;
+      }
+      let offset = 0;
+      while (offset < data.length) {
+        const opusPendingTrimStart = (data[offset + 1] & 0x10) !== 0;
+        const trimEnd = (data[offset + 1] & 0x08) !== 0;
+        let index = offset + 2;
+        let size = 0;
+
+        while (data[index] === 0xFF) {
+          size += 255;
+          index += 1;
+        }
+        size += data[index];
+        index += 1;
+        index += opusPendingTrimStart ? 2 : 0;
+        index += trimEnd ? 2 : 0;
+
+        const sample = data.slice(index, index + size);
+
+        samples.push({
+          data: sample,
+          size: sample.byteLength,
+          duration: Opus.OPUS_AUDIO_SAMPLE_PER_FRAME,
+          cts: 0,
+          flags: {
+            isLeading: 0,
+            isDependedOn: 0,
+            hasRedundancy: 0,
+            degradPrio: 0,
+            dependsOn: 2,
+            isNonSync: 0,
+          },
+        });
+        offset = index + size;
+      }
+    }
+
+    if (audioConfig.byteLength == 0 || firstPts == null) {
+      throw new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.MEDIA,
+          shaka.util.Error.Code.TRANSMUXING_FAILED);
+    }
+
+    stream.audioSamplingRate = opusMetadata.sampleRate;
+    stream.channelsCount = opusMetadata.channelCount;
+
+
+    /** @type {number} */
+    const baseMediaDecodeTime = firstPts / timescale * sampleRate;
+
+    return {
+      id: stream.id,
+      type: shaka.util.ManifestParserUtils.ContentType.AUDIO,
+      codecs: 'opus',
+      encrypted: stream.encrypted && stream.drmInfos.length > 0,
+      timescale: sampleRate,
+      duration: duration,
+      videoNalus: [],
+      audioConfig: audioConfig,
+      videoConfig: new Uint8Array([]),
+      hSpacing: 0,
+      vSpacing: 0,
+      data: {
+        sequenceNumber: this.frameIndex_,
+        baseMediaDecodeTime: baseMediaDecodeTime,
+        samples: samples,
+      },
+      stream: stream,
+    };
+  }
+
+
   /**
    * @param {shaka.util.TsParser} tsParser
    * @param {shaka.extern.Stream} stream
@@ -933,6 +1047,7 @@ shaka.transmuxer.TsTransmuxer.SUPPORTED_AUDIO_CODECS_ = [
   'ac-3',
   'ec-3',
   'mp3',
+  'opus',
 ];
 
 /**

package/lib/util/cmcd_manager.js

@@ -9,6 +9,9 @@ goog.provide('shaka.util.CmcdManager');
 goog.require('goog.Uri');
 goog.require('shaka.log');
 goog.require('shaka.net.NetworkingEngine');
+goog.require('shaka.util.ArrayUtils');
+
+goog.requireType('shaka.media.SegmentReference');
 
 /**
  * @summary
@@ -186,11 +189,49 @@ shaka.util.CmcdManager = class {
       if (stream) {
         if (isMedia) {
           data.bl = this.getBufferLength_(stream.type);
+          if (data.ot !== ObjectType.TIMED_TEXT) {
+            const remainingBufferLength =
+                this.getRemainingBufferLength_(stream.type);
+            const playbackRate = this.playerInterface_.getPlaybackRate();
+            if (playbackRate) {
+              data.dl = remainingBufferLength / Math.abs(playbackRate);
+            } else {
+              data.dl = remainingBufferLength;
+            }
+          }
         }
 
         if (stream.bandwidth) {
           data.br = stream.bandwidth / 1000;
         }
+
+        if (stream.segmentIndex && segment) {
+          const iterator = stream.segmentIndex.getIteratorForTime(
+              segment.endTime, /* allowNonIndepedent= */ true);
+          if (iterator) {
+            const nextSegment = iterator.next().value;
+            if (nextSegment && nextSegment != segment) {
+              if (!shaka.util.ArrayUtils.equal(
+                  segment.getUris(), nextSegment.getUris())) {
+                data.nor = this.urlToRelativePath_(
+                    nextSegment.getUris()[0], request.uris[0]);
+              }
+              if ((nextSegment.startByte || nextSegment.endByte) &&
+                  (segment.startByte != nextSegment.startByte ||
+                  segment.endByte != nextSegment.endByte)) {
+                let range = nextSegment.startByte + '-';
+                if (nextSegment.endByte) {
+                  range += nextSegment.endByte;
+                }
+                data.nrr = range;
+              }
+            }
+          }
+          const rtp = this.calculateRtp_(stream, segment);
+          if (!isNaN(rtp)) {
+            data.rtp = rtp;
+          }
+        }
       }
 
       if (isMedia && data.ot !== ObjectType.TIMED_TEXT) {
@@ -328,17 +369,17 @@ shaka.util.CmcdManager = class {
       data.su = this.buffering_;
     }
 
-    // TODO: Implement rtp, nrr, nor, dl
+    const output = this.filterKeys_(data);
 
     if (useHeaders) {
-      const headers = shaka.util.CmcdManager.toHeaders(data);
+      const headers = shaka.util.CmcdManager.toHeaders(output);
       if (!Object.keys(headers).length) {
         return;
       }
 
       Object.assign(request.headers, headers);
     } else {
-      const query = shaka.util.CmcdManager.toQuery(data);
+      const query = shaka.util.CmcdManager.toQuery(output);
       if (!query) {
         return;
       }
@@ -349,6 +390,29 @@ shaka.util.CmcdManager = class {
     }
   }
 
+  /**
+   * Filter the CMCD data object to include only the keys specified in the
+   * configuration.
+   *
+   * @param {CmcdData} data
+   * @return {CmcdData}
+   * @private
+   */
+  filterKeys_(data) {
+    const includeKeys = this.config_.includeKeys;
+
+    if (!includeKeys.length) {
+      return data;
+    }
+
+    return Object.keys(data).reduce((acc, key) => {
+      if (includeKeys.includes(key)) {
+        acc[key] = data[key];
+      }
+      return acc;
+    }, {});
+  }
+
   /**
    * The CMCD object type.
    *
@@ -451,6 +515,91 @@ shaka.util.CmcdManager = class {
     return (range.end - start) * 1000;
   }
 
+  /**
+   * Get the remaining buffer length for a media type in milliseconds
+   *
+   * @param {string} type
+   * @return {number}
+   * @private
+   */
+  getRemainingBufferLength_(type) {
+    const ranges = this.playerInterface_.getBufferedInfo()[type];
+
+    if (!ranges.length) {
+      return 0;
+    }
+
+    const start = this.playerInterface_.getCurrentTime();
+    const range = ranges.find((r) => r.start <= start && r.end >= start);
+
+    if (!range) {
+      return 0;
+    }
+
+    return (range.end - start) * 1000;
+  }
+
+  /**
+   * Constructs a relative path from a URL
+   *
+   * @param {string} url
+   * @param {string} base
+   * @return {string}
+   * @private
+   */
+  urlToRelativePath_(url, base) {
+    const to = new URL(url);
+    const from = new URL(base);
+
+    if (to.origin !== from.origin) {
+      return url;
+    }
+
+    const toPath = to.pathname.split('/').slice(1);
+    const fromPath = from.pathname.split('/').slice(1, -1);
+
+    // remove common parents
+    while (toPath[0] === fromPath[0]) {
+      toPath.shift();
+      fromPath.shift();
+    }
+
+    // add back paths
+    while (fromPath.length) {
+      fromPath.shift();
+      toPath.unshift('..');
+    }
+
+    return toPath.join('/');
+  }
+
+  /**
+   * Calculate requested maximun throughput
+   *
+   * @param {shaka.extern.Stream} stream
+   * @param {shaka.media.SegmentReference} segment
+   * @return {number}
+   * @private
+   */
+  calculateRtp_(stream, segment) {
+    const playbackRate = this.playerInterface_.getPlaybackRate() || 1;
+    const currentBufferLevel =
+        this.getRemainingBufferLength_(stream.type) || 500;
+    const bandwidth = stream.bandwidth;
+    if (!bandwidth) {
+      return NaN;
+    }
+    const segmentDuration = segment.endTime - segment.startTime;
+    // Calculate file size in kilobits
+    const segmentSize = bandwidth * segmentDuration / 1000;
+    // Calculate time available to load file in seconds
+    const timeToLoad = (currentBufferLevel / playbackRate) / 1000;
+    // Calculate the exact bandwidth required
+    const minBandwidth = segmentSize / timeToLoad;
+    // Include a safety buffer
+    return minBandwidth * this.config_.rtpSafetyFactor;
+  }
+
   /**
    * Get the stream format
    *