shaka-player 4.4.2 → 4.5.0

package/externs/mux.js

@@ -1,69 +0,0 @@
-/*! @license
- * Shaka Player
- * Copyright 2016 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @fileoverview Externs for mux.js library.
- * @externs
- */
-
-
-/**
- * @typedef {{
- *   mp4: typeof muxjs.mp4
- * }}
- * @const
-*/
-var muxjs = {};
-
-
-/** @const */
-muxjs.mp4 = {};
-
-
-muxjs.mp4.Transmuxer = class {
-  /** @param {Object=} options */
-  constructor(options) {}
-
-  /** @param {number} time */
-  setBaseMediaDecodeTime(time) {}
-
-  /** @param {!Uint8Array} data */
-  push(data) {}
-
-  flush() {}
-
-  /**
-   * Add a handler for a specified event type.
-   * @param {string} type Event name
-   * @param {Function} listener The callback to be invoked
-   */
-  on(type, listener) {}
-
-  /**
-   * Remove a handler for a specified event type.
-   * @param {string} type Event name
-   * @param {Function} listener The callback to be removed
-   */
-  off(type, listener) {}
-
-  /** Remove all handlers and clean up. */
-  dispose() {}
-};
-
-
-/**
- * @typedef {{
- *   initSegment: !Uint8Array,
- *   data: !Uint8Array
- * }}
- *
- * @description Transmuxed data from mux.js.
- * @property {!Uint8Array} initSegment
- * @property {!Uint8Array} data
- * @exportDoc
- */
-muxjs.mp4.Transmuxer.Segment;
-

package/lib/lcevc/lcevc_dil.js

@@ -1,152 +0,0 @@
-/*! @license
- * Shaka Player
- * Copyright 2016 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-goog.provide('shaka.lcevc.Dil');
-goog.require('shaka.log');
-goog.require('shaka.util.IReleasable');
-
-/**
- * @summary
- *  lcevcDil - (MPEG-5 Part 2 LCEVC - Decoder Integration Layer) provides
- *  all the operations related to the enhancement and rendering
- *  of LCEVC enabled streams and on to a canvas.
- * @implements {shaka.util.IReleasable}
- * @export
- */
-shaka.lcevc.Dil = class {
-  /**
-   * @param {HTMLVideoElement} media The video element that will be attached to
-   * LCEVC Dil for input.
-   * @param {HTMLCanvasElement} canvas The canvas element that will be attached
-   * to LCEVC Dil to render the enhanced frames.
-   * @param {shaka.extern.LcevcConfiguration} dilConfig The LCEVC DIL
-   * config object to initialize the LCEVC DIL.
-   */
-  constructor(media, canvas, dilConfig) {
-    /** @private {?LcevcDil.LcevcDIL} */
-    this.dil_ = null;
-
-    /** @private {number} */
-    this.variantId_ = -1;
-
-    /** @private {HTMLVideoElement} */
-    this.media_ = media;
-
-    /** @private {HTMLCanvasElement} */
-    this.canvas_ = canvas;
-
-    /** @private {shaka.extern.LcevcConfiguration} */
-    this.dilConfig_ = dilConfig;
-
-    this.create_();
-  }
-
-  /**
-   * Append data to the LCEVC Dil.
-   * @param {BufferSource} data
-   */
-  appendBuffer(data) {
-    if (this.dil_) {
-      this.dil_.appendBuffer(data, 'video', this.variantId_);
-    }
-  }
-
-  /**
-   * Hide the canvas specifically in the case of a DRM Content
-   */
-  hideCanvas() {
-    if (this.dil_) {
-      this.canvas_.classList.add('shaka-hidden');
-    }
-  }
-
-  /**
-   * Create LCEVC Dil.
-   * @private
-   */
-  create_() {
-    if (this.isSupported_() && !this.dil_) {
-      if (LcevcDil.SupportObject.webGLSupport(this.canvas_)) {
-        // Make sure the canvas is not hidden from a previous playback session.
-        this.canvas_.classList.remove('shaka-hidden');
-        this.dil_ = new LcevcDil.LcevcDil(
-            this.media_,
-            this.canvas_,
-            this.dilConfig_);
-      }
-    }
-  }
-
-  /**
-   * Close LCEVC Dil.
-   * @override
-   * @export
-   */
-  release() {
-    if (this.dil_) {
-      this.dil_.close();
-      this.dil_ = null;
-    }
-  }
-
-  /**
-   * Check if the LCEVC Dil lib is present and is supported by the browser.
-   * @return {boolean}
-   * @private
-   */
-  isSupported_() {
-    if (typeof libDPIModule === 'undefined') {
-      shaka.log.alwaysWarn(
-          'Could not Find LCEVC Library dependencies on this page');
-    }
-
-    if (typeof LcevcDil === 'undefined') {
-      shaka.log.alwaysWarn('Could not Find LCEVC Library on this page');
-    } else {
-      if (!LcevcDil.SupportObject.SupportStatus) {
-        shaka.log.alwaysWarn(LcevcDil.SupportObject.SupportError);
-      }
-    }
-
-    return typeof LcevcDil !== 'undefined' &&
-      typeof libDPIModule !== 'undefined' &&
-      this.canvas_ instanceof HTMLCanvasElement &&
-      LcevcDil.SupportObject.SupportStatus;
-  }
-
-  /**
-   * Update current active variant
-   * @param {shaka.extern.Track} track
-   */
-  updateVariant(track) {
-    let containerFormat = shaka.lcevc.Dil.ContainerFormat.MPEG2_TS;
-    switch (track.mimeType) {
-      case 'video/webm': {
-        containerFormat = shaka.lcevc.Dil.ContainerFormat.WEBM;
-        break;
-      }
-      case 'video/mp4': {
-        containerFormat = shaka.lcevc.Dil.ContainerFormat.MP4;
-        break;
-      }
-    }
-    if (this.dil_) {
-      this.variantId_ = track.id;
-      this.dil_.setLevelSwitching(track.id, true);
-      this.dil_.setContainerFormat(containerFormat);
-    }
-  }
-};
-
-/**
- * Container Formats.
- * @const @enum {number}
- */
-shaka.lcevc.Dil.ContainerFormat = {
-  MPEG2_TS: 0,
-  WEBM: 1,
-  MP4: 2,
-};

package/lib/transmuxer/muxjs_transmuxer.js

@@ -1,242 +0,0 @@
-/*! @license
- * Shaka Player
- * Copyright 2016 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-goog.provide('shaka.transmuxer.MuxjsTransmuxer');
-
-goog.require('goog.asserts');
-goog.require('shaka.dependencies');
-goog.require('shaka.media.Capabilities');
-goog.require('shaka.transmuxer.TransmuxerEngine');
-goog.require('shaka.util.BufferUtils');
-goog.require('shaka.util.Error');
-goog.require('shaka.util.ManifestParserUtils');
-goog.require('shaka.util.PublicPromise');
-goog.require('shaka.util.Uint8ArrayUtils');
-
-
-/**
- * @implements {shaka.extern.Transmuxer}
- * @export
- */
-shaka.transmuxer.MuxjsTransmuxer = class {
-  /**
-   * @param {string} mimeType
-   */
-  constructor(mimeType) {
-    /** @private {string} */
-    this.originalMimeType_ = mimeType;
-
-    /** @private {?muxjs} */
-    this.muxjs_ = shaka.dependencies.muxjs();
-
-    /** @private {muxjs.mp4.Transmuxer} */
-    this.muxTransmuxer_ = null;
-
-    /** @private {shaka.util.PublicPromise} */
-    this.transmuxPromise_ = null;
-
-    /** @private {!Array.<!Uint8Array>} */
-    this.transmuxedData_ = [];
-
-    /** @private {boolean} */
-    this.isTransmuxing_ = false;
-
-    if (this.muxjs_) {
-      this.muxTransmuxer_ = new this.muxjs_.mp4.Transmuxer({
-        'keepOriginalTimestamps': true,
-      });
-      this.muxTransmuxer_.on('data', (segment) => this.onTransmuxed_(segment));
-      this.muxTransmuxer_.on('done', () => this.onTransmuxDone_());
-    }
-  }
-
-
-  /**
-   * @override
-   * @export
-   */
-  destroy() {
-    if (this.muxTransmuxer_) {
-      this.muxTransmuxer_.dispose();
-    }
-    this.muxTransmuxer_ = null;
-  }
-
-
-  /**
-   * Check if the mime type and the content type is supported.
-   * @param {string} mimeType
-   * @param {string=} contentType
-   * @return {boolean}
-   * @override
-   * @export
-   */
-  isSupported(mimeType, contentType) {
-    const Capabilities = shaka.media.Capabilities;
-
-    const isTs = this.isTsContainer_(mimeType);
-
-    if (!this.muxjs_ || !isTs) {
-      return false;
-    }
-
-    if (contentType) {
-      return Capabilities.isTypeSupported(
-          this.convertTsCodecs_(contentType, mimeType));
-    }
-
-    const ContentType = shaka.util.ManifestParserUtils.ContentType;
-
-    const audioMime = this.convertTsCodecs_(ContentType.AUDIO, mimeType);
-    const videoMime = this.convertTsCodecs_(ContentType.VIDEO, mimeType);
-    return Capabilities.isTypeSupported(audioMime) ||
-        Capabilities.isTypeSupported(videoMime);
-  }
-
-
-  /**
-   * Check if the mimetype contains 'mp2t'.
-   * @param {string} mimeType
-   * @return {boolean}
-   * @private
-   */
-  isTsContainer_(mimeType) {
-    return mimeType.toLowerCase().split(';')[0].split('/')[1] == 'mp2t';
-  }
-
-
-  /**
-   * @override
-   * @export
-   */
-  convertCodecs(contentType, mimeType) {
-    if (this.isTsContainer_(mimeType)) {
-      return this.convertTsCodecs_(contentType, mimeType);
-    }
-    return mimeType;
-  }
-
-
-  /**
-   * For transport stream, convert its codecs to MP4 codecs.
-   * @param {string} contentType
-   * @param {string} tsMimeType
-   * @return {string}
-   * @private
-   */
-  convertTsCodecs_(contentType, tsMimeType) {
-    const ContentType = shaka.util.ManifestParserUtils.ContentType;
-    let mp4MimeType = tsMimeType.replace(/mp2t/i, 'mp4');
-    if (contentType == ContentType.AUDIO) {
-      mp4MimeType = mp4MimeType.replace('video', 'audio');
-    }
-
-    // Handle legacy AVC1 codec strings (pre-RFC 6381).
-    // Look for "avc1.<profile>.<level>", where profile is:
-    //   66 (baseline => 0x42)
-    //   77 (main => 0x4d)
-    //   100 (high => 0x64)
-    // Reference: https://bit.ly/2K9JI3x
-    const match = /avc1\.(66|77|100)\.(\d+)/.exec(mp4MimeType);
-    if (match) {
-      let newCodecString = 'avc1.';
-
-      const profile = match[1];
-      if (profile == '66') {
-        newCodecString += '4200';
-      } else if (profile == '77') {
-        newCodecString += '4d00';
-      } else {
-        goog.asserts.assert(profile == '100',
-            'Legacy avc1 parsing code out of sync with regex!');
-        newCodecString += '6400';
-      }
-
-      // Convert the level to hex and append to the codec string.
-      const level = Number(match[2]);
-      goog.asserts.assert(level < 256,
-          'Invalid legacy avc1 level number!');
-      newCodecString += (level >> 4).toString(16);
-      newCodecString += (level & 0xf).toString(16);
-
-      mp4MimeType = mp4MimeType.replace(match[0], newCodecString);
-    }
-
-    return mp4MimeType;
-  }
-
-
-  /**
-   * @override
-   * @export
-   */
-  getOrginalMimeType() {
-    return this.originalMimeType_;
-  }
-
-
-  /**
-   * @override
-   * @export
-   */
-  transmux(data) {
-    goog.asserts.assert(this.muxTransmuxer_,
-        'mux.js should be available.');
-    goog.asserts.assert(!this.isTransmuxing_,
-        'No transmuxing should be in progress.');
-    this.isTransmuxing_ = true;
-    this.transmuxPromise_ = new shaka.util.PublicPromise();
-    this.transmuxedData_ = [];
-
-    const dataArray = shaka.util.BufferUtils.toUint8(data);
-    this.muxTransmuxer_.push(dataArray);
-    this.muxTransmuxer_.flush();
-
-    // Workaround for https://bit.ly/Shaka1449 mux.js not
-    // emitting 'data' and 'done' events.
-    // mux.js code is synchronous, so if onTransmuxDone_ has
-    // not been called by now, it's not going to be.
-    // Treat it as a transmuxing failure and reject the promise.
-    if (this.isTransmuxing_) {
-      this.transmuxPromise_.reject(new shaka.util.Error(
-          shaka.util.Error.Severity.CRITICAL,
-          shaka.util.Error.Category.MEDIA,
-          shaka.util.Error.Code.TRANSMUXING_FAILED));
-    }
-    return this.transmuxPromise_;
-  }
-
-  /**
-   * Handles the 'data' event of the transmuxer.
-   * Extracts the cues from the transmuxed segment, and adds them to an array.
-   * Stores the transmuxed data in another array, to pass it back to
-   * MediaSourceEngine, and append to the source buffer.
-   *
-   * @param {muxjs.mp4.Transmuxer.Segment} segment
-   * @private
-   */
-  onTransmuxed_(segment) {
-    this.transmuxedData_.push(
-        shaka.util.Uint8ArrayUtils.concat(segment.initSegment, segment.data));
-  }
-
-
-  /**
-   * Handles the 'done' event of the transmuxer.
-   * Resolves the transmux Promise, and returns the transmuxed data.
-   * @private
-   */
-  onTransmuxDone_() {
-    const data = shaka.util.Uint8ArrayUtils.concat(...this.transmuxedData_);
-    this.transmuxPromise_.resolve(data);
-    this.isTransmuxing_ = false;
-  }
-};
-
-shaka.transmuxer.TransmuxerEngine.registerTransmuxer(
-    'video/mp2t',
-    () => new shaka.transmuxer.MuxjsTransmuxer('video/mp2t'),
-    shaka.transmuxer.TransmuxerEngine.PluginPriority.FALLBACK);

package/test/transmuxer/muxjs_transmuxer_integration.js

@@ -1,177 +0,0 @@
-/*! @license
- * Shaka Player
- * Copyright 2016 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-describe('MuxjsTransmuxer', () => {
-  const ContentType = shaka.util.ManifestParserUtils.ContentType;
-
-  const videoSegmentUri = '/base/test/test/assets/video.ts';
-  const audioSegmentUri = '/base/test/test/assets/audio.ts';
-  const mp4MimeType = 'video/mp4; codecs="avc1.42E01E"';
-  const transportStreamVideoMimeType = 'video/mp2t; codecs="avc1.42E01E"';
-  const transportStreamAudioMimeType = 'video/mp2t; codecs="mp4a.40.2"';
-
-  /** @type {!ArrayBuffer} */
-  let videoSegment;
-  /** @type {!ArrayBuffer} */
-  let audioSegment;
-  /** @type {!ArrayBuffer} */
-  let emptySegment;
-
-  /** @type {?shaka.transmuxer.MuxjsTransmuxer} */
-  let transmuxer;
-
-  function useTsTransmuxer() {
-    transmuxer = new shaka.transmuxer.MuxjsTransmuxer('video/mp2t');
-  }
-
-  beforeAll(async () => {
-    const responses = await Promise.all([
-      shaka.test.Util.fetch(videoSegmentUri),
-      shaka.test.Util.fetch(audioSegmentUri),
-    ]);
-    videoSegment = responses[0];
-    audioSegment = responses[1];
-    emptySegment = new ArrayBuffer(0);
-  });
-
-  beforeEach(() => {
-    transmuxer = null;
-  });
-
-  afterEach(async () => {
-    await transmuxer.destroy();
-  });
-
-  describe('isSupported', () => {
-    it('returns whether the content type is supported', () => {
-      useTsTransmuxer();
-      expect(transmuxer.isSupported(
-          mp4MimeType, ContentType.VIDEO)).toBe(false);
-      expect(transmuxer.isSupported(
-          transportStreamVideoMimeType, ContentType.VIDEO)).toBe(true);
-    });
-
-    // Issue #1991
-    it('handles upper-case MIME types', () => {
-      useTsTransmuxer();
-      const mimeType = transportStreamVideoMimeType.replace('mp2t', 'MP2T');
-      expect(transmuxer.isSupported(
-          mimeType, ContentType.VIDEO)).toBe(true);
-    });
-  });
-
-  describe('convertCodecs', () => {
-    const convertCodecs =
-        (type, codecs) => transmuxer.convertCodecs(type, codecs);
-
-    it('returns converted codecs for TS', () => {
-      useTsTransmuxer();
-      const convertedVideoCodecs =
-          convertCodecs(ContentType.VIDEO, transportStreamVideoMimeType);
-      const convertedAudioCodecs =
-          convertCodecs(ContentType.AUDIO, transportStreamAudioMimeType);
-      const expectedVideoCodecs = 'video/mp4; codecs="avc1.42E01E"';
-      const expectedAudioCodecs = 'audio/mp4; codecs="mp4a.40.2"';
-      expect(convertedVideoCodecs).toBe(expectedVideoCodecs);
-      expect(convertedAudioCodecs).toBe(expectedAudioCodecs);
-    });
-
-    it('converts legacy avc1 codec strings', () => {
-      useTsTransmuxer();
-      expect(
-          convertCodecs(
-              ContentType.VIDEO, 'video/mp2t; codecs="avc1.100.42"'))
-          .toBe('video/mp4; codecs="avc1.64002a"');
-      expect(
-          convertCodecs(ContentType.VIDEO, 'video/mp2t; codecs="avc1.77.80"'))
-          .toBe('video/mp4; codecs="avc1.4d0050"');
-      expect(
-          convertCodecs(ContentType.VIDEO, 'video/mp2t; codecs="avc1.66.1"'))
-          .toBe('video/mp4; codecs="avc1.420001"');
-    });
-
-    // Issue #1991
-    it('handles upper-case MIME types', () => {
-      useTsTransmuxer();
-      expect(convertCodecs(
-          ContentType.VIDEO, 'video/MP2T; codecs="avc1.420001"'))
-          .toBe('video/mp4; codecs="avc1.420001"');
-    });
-  });
-
-  describe('transmuxing', () => {
-    it('transmux video from TS to MP4', async () => {
-      useTsTransmuxer();
-      let sawMDAT = false;
-
-      const transmuxedData = await transmuxer.transmux(videoSegment);
-      expect(transmuxedData).toEqual(jasmine.any(Uint8Array));
-      expect(transmuxedData.length).toBeGreaterThan(0);
-      new shaka.util.Mp4Parser()
-          .box('mdat', shaka.util.Mp4Parser.allData((data) => {
-            sawMDAT = true;
-            expect(data.byteLength).toBeGreaterThan(0);
-          }))
-          .parse(transmuxedData);
-      expect(sawMDAT).toBeTruthy();
-    });
-
-    it('transmux audio from TS to MP4', async () => {
-      useTsTransmuxer();
-      let sawMDAT = false;
-      const transmuxedData = await transmuxer.transmux(audioSegment);
-      expect(transmuxedData).toEqual(jasmine.any(Uint8Array));
-      expect(transmuxedData.length).toBeGreaterThan(0);
-      new shaka.util.Mp4Parser()
-          .box('mdat', shaka.util.Mp4Parser.allData((data) => {
-            sawMDAT = true;
-            expect(data.byteLength).toBeGreaterThan(0);
-          }))
-          .parse(transmuxedData);
-      expect(sawMDAT).toBeTruthy();
-    });
-
-    it('transmux empty video from TS to MP4', async () => {
-      useTsTransmuxer();
-      let sawMDAT = false;
-      const transmuxedData = await transmuxer.transmux(emptySegment);
-      expect(transmuxedData).toEqual(jasmine.any(Uint8Array));
-      new shaka.util.Mp4Parser()
-          .box('mdat', shaka.util.Mp4Parser.allData((data) => {
-            sawMDAT = true;
-          }))
-          .parse(transmuxedData);
-      expect(sawMDAT).toBeFalsy();
-    });
-
-    it('passes through true timestamps', async () => {
-      useTsTransmuxer();
-      let parsed = false;
-      const expectedMp4Timestamp = 5166000;  // in timescale units
-      let mp4Timestamp;
-
-      const transmuxedData = await transmuxer.transmux(videoSegment);
-      const Mp4Parser = shaka.util.Mp4Parser;
-
-      new Mp4Parser()
-          .box('moof', Mp4Parser.children)
-          .box('traf', Mp4Parser.children)
-          .fullBox('tfdt', (box) => {
-            goog.asserts.assert(
-                box.version == 0 || box.version == 1,
-                'TFDT version can only be 0 or 1');
-            const parsedTFDTBox = shaka.util.Mp4BoxParsers.parseTFDT(
-                box.reader, box.version);
-            mp4Timestamp = parsedTFDTBox.baseMediaDecodeTime;
-            parsed = true;
-          })
-          .parse(transmuxedData);
-
-      expect(parsed).toBe(true);
-      expect(mp4Timestamp).toBe(expectedMp4Timestamp);
-    });
-  });
-});