shaka-player 4.3.10 → 4.4.0

package/test/transmuxer/transmuxer_integration.js

@@ -0,0 +1,296 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+describe('Transmuxer Player', () => {
+  const Util = shaka.test.Util;
+
+  /** @type {!jasmine.Spy} */
+  let onErrorSpy;
+
+  /** @type {!HTMLVideoElement} */
+  let video;
+  /** @type {shaka.Player} */
+  let player;
+  /** @type {!shaka.util.EventManager} */
+  let eventManager;
+
+  let compiledShaka;
+
+  /** @type {!shaka.test.Waiter} */
+  let waiter;
+
+  function isAc3Supported() {
+    if (!MediaSource.isTypeSupported('audio/mp4; codecs="ac-3"')) {
+      return false;
+    }
+    // AC3 is flaky in some Tizen devices, so we need omit it for now.
+    if (shaka.util.Platform.isTizen()) {
+      return false;
+    }
+    // It seems that AC3 on Edge Windows from github actions is not working
+    // (in the lab AC3 is working). The AC3 detection is currently hard-coded
+    // to true, which leads to a failure in GitHub's environment.
+    // We must enable this, once it is resolved:
+    // https://bugs.chromium.org/p/chromium/issues/detail?id=1450313
+    const chromeVersion = shaka.util.Platform.chromeVersion();
+    if (shaka.util.Platform.isEdge() &&
+        chromeVersion && chromeVersion <= 116) {
+      return false;
+    }
+    return true;
+  }
+
+  function isEc3Supported() {
+    if (!MediaSource.isTypeSupported('audio/mp4; codecs="ec-3"')) {
+      return false;
+    }
+    // EC3 is flaky in some Tizen devices, so we need omit it for now.
+    if (shaka.util.Platform.isTizen()) {
+      return false;
+    }
+    // It seems that EC3 on Edge Windows from github actions is not working
+    // (in the lab EC3 is working). The EC3 detection is currently hard-coded
+    // to true, which leads to a failure in GitHub's environment.
+    // We must enable this, once it is resolved:
+    // https://bugs.chromium.org/p/chromium/issues/detail?id=1450313
+    const chromeVersion = shaka.util.Platform.chromeVersion();
+    if (shaka.util.Platform.isEdge() &&
+        chromeVersion && chromeVersion <= 116) {
+      return false;
+    }
+    return true;
+  }
+
+  beforeAll(async () => {
+    video = shaka.test.UiUtils.createVideoElement();
+    document.body.appendChild(video);
+    compiledShaka =
+        await shaka.test.Loader.loadShaka(getClientArg('uncompiled'));
+  });
+
+  beforeEach(async () => {
+    await shaka.test.TestScheme.createManifests(compiledShaka, '_compiled');
+    player = new compiledShaka.Player(video);
+
+    player.configure('mediaSource.forceTransmux', true);
+    player.configure('streaming.useNativeHlsOnSafari', false);
+
+    // Disable stall detection, which can interfere with playback tests.
+    player.configure('streaming.stallEnabled', false);
+
+    // Grab event manager from the uncompiled library:
+    eventManager = new shaka.util.EventManager();
+    waiter = new shaka.test.Waiter(eventManager);
+    waiter.setPlayer(player);
+
+    onErrorSpy = jasmine.createSpy('onError');
+    onErrorSpy.and.callFake((event) => fail(event.detail));
+    eventManager.listen(player, 'error', Util.spyFunc(onErrorSpy));
+  });
+
+  afterEach(async () => {
+    eventManager.release();
+    await player.destroy();
+  });
+
+  afterAll(() => {
+    document.body.removeChild(video);
+  });
+
+  describe('for audio', () => {
+    it('raw AAC', async () => {
+      await player.load('/base/test/test/assets/hls-raw-aac/manifest.m3u8');
+      await video.play();
+      expect(player.isLive()).toBe(false);
+
+      // Wait for the video to start playback.  If it takes longer than 10
+      // seconds, fail the test.
+      await waiter.waitForMovementOrFailOnTimeout(video, 10);
+
+      // Play for 15 seconds, but stop early if the video ends.  If it takes
+      // longer than 45 seconds, fail the test.
+      await waiter.waitUntilPlayheadReachesOrFailOnTimeout(video, 15, 45);
+
+      await player.unload();
+    });
+
+    it('raw MP3', async () => {
+      if (!MediaSource.isTypeSupported('audio/mp4; codecs="mp3"')) {
+        pending('Codec MP3 in MP4 is not supported by the platform.');
+      }
+      await player.load('/base/test/test/assets/hls-raw-mp3/playlist.m3u8');
+      await video.play();
+      expect(player.isLive()).toBe(false);
+
+      // Wait for the video to start playback.  If it takes longer than 10
+      // seconds, fail the test.
+      await waiter.waitForMovementOrFailOnTimeout(video, 10);
+
+      // Play for 15 seconds, but stop early if the video ends.  If it takes
+      // longer than 45 seconds, fail the test.
+      await waiter.waitUntilPlayheadReachesOrFailOnTimeout(video, 15, 45);
+
+      await player.unload();
+    });
+
+    it('raw AC3', async () => {
+      if (!isAc3Supported()) {
+        pending('Codec AC-3 is not supported by the platform.');
+      }
+
+      await player.load('/base/test/test/assets/hls-raw-ac3/prog_index.m3u8');
+      await video.play();
+      expect(player.isLive()).toBe(false);
+
+      // Wait for the video to start playback.  If it takes longer than 10
+      // seconds, fail the test.
+      await waiter.waitForMovementOrFailOnTimeout(video, 10);
+
+      // Play for 15 seconds, but stop early if the video ends.  If it takes
+      // longer than 45 seconds, fail the test.
+      await waiter.waitUntilPlayheadReachesOrFailOnTimeout(video, 15, 45);
+
+      await player.unload();
+    });
+
+    it('raw EC3', async () => {
+      if (!isEc3Supported()) {
+        pending('Codec EC-3 is not supported by the platform.');
+      }
+
+      await player.load('/base/test/test/assets/hls-raw-ac3/prog_index.m3u8');
+      await video.play();
+      expect(player.isLive()).toBe(false);
+
+      // Wait for the video to start playback.  If it takes longer than 10
+      // seconds, fail the test.
+      await waiter.waitForMovementOrFailOnTimeout(video, 10);
+
+      // Play for 15 seconds, but stop early if the video ends.  If it takes
+      // longer than 45 seconds, fail the test.
+      await waiter.waitUntilPlayheadReachesOrFailOnTimeout(video, 15, 45);
+
+      await player.unload();
+    });
+
+    it('AAC in TS', async () => {
+      await player.load('/base/test/test/assets/hls-ts-aac/playlist.m3u8');
+      await video.play();
+      expect(player.isLive()).toBe(false);
+
+      // Wait for the video to start playback.  If it takes longer than 10
+      // seconds, fail the test.
+      await waiter.waitForMovementOrFailOnTimeout(video, 10);
+
+      // Play for 15 seconds, but stop early if the video ends.  If it takes
+      // longer than 45 seconds, fail the test.
+      await waiter.waitUntilPlayheadReachesOrFailOnTimeout(video, 15, 45);
+
+      await player.unload();
+    });
+
+    it('MP3 in TS', async () => {
+      if (!MediaSource.isTypeSupported('audio/mp4; codecs="mp3"') &&
+        !MediaSource.isTypeSupported('audio/mpeg')) {
+        pending('Codec MP3 is not supported by the platform.');
+      }
+      // This tests is flaky in some Tizen devices, so we need omit it for now.
+      if (shaka.util.Platform.isTizen()) {
+        return;
+      }
+      await player.load('/base/test/test/assets/hls-ts-mp3/manifest.m3u8');
+      await video.play();
+      expect(player.isLive()).toBe(false);
+
+      // Wait for the video to start playback.  If it takes longer than 10
+      // seconds, fail the test.
+      await waiter.waitForMovementOrFailOnTimeout(video, 10);
+
+      // Play for 15 seconds, but stop early if the video ends.  If it takes
+      // longer than 45 seconds, fail the test.
+      await waiter.waitUntilPlayheadReachesOrFailOnTimeout(video, 15, 45);
+
+      await player.unload();
+    });
+
+    it('AC3 in TS', async () => {
+      if (!isAc3Supported()) {
+        pending('Codec AC-3 is not supported by the platform.');
+      }
+
+      await player.load('/base/test/test/assets/hls-ts-ac3/prog_index.m3u8');
+      await video.play();
+      expect(player.isLive()).toBe(false);
+
+      // Wait for the video to start playback.  If it takes longer than 10
+      // seconds, fail the test.
+      await waiter.waitForMovementOrFailOnTimeout(video, 10);
+
+      // Play for 15 seconds, but stop early if the video ends.  If it takes
+      // longer than 45 seconds, fail the test.
+      await waiter.waitUntilPlayheadReachesOrFailOnTimeout(video, 15, 45);
+
+      await player.unload();
+    });
+
+    it('EC3 in TS', async () => {
+      if (!isEc3Supported()) {
+        pending('Codec EC-3 is not supported by the platform.');
+      }
+
+      await player.load('/base/test/test/assets/hls-ts-ec3/prog_index.m3u8');
+      await video.play();
+      expect(player.isLive()).toBe(false);
+
+      // Wait for the video to start playback.  If it takes longer than 10
+      // seconds, fail the test.
+      await waiter.waitForMovementOrFailOnTimeout(video, 10);
+
+      // Play for 15 seconds, but stop early if the video ends.  If it takes
+      // longer than 45 seconds, fail the test.
+      await waiter.waitUntilPlayheadReachesOrFailOnTimeout(video, 15, 45);
+
+      await player.unload();
+    });
+  });
+
+  describe('for video', () => {
+    it('H.264 in TS', async () => {
+      await player.load('/base/test/test/assets/hls-ts-h264/prog_index.m3u8');
+      await video.play();
+      expect(player.isLive()).toBe(false);
+
+      // Wait for the video to start playback.  If it takes longer than 10
+      // seconds, fail the test.
+      await waiter.waitForMovementOrFailOnTimeout(video, 10);
+
+      // Play for 15 seconds, but stop early if the video ends.  If it takes
+      // longer than 45 seconds, fail the test.
+      await waiter.waitUntilPlayheadReachesOrFailOnTimeout(video, 15, 45);
+
+      await player.unload();
+    });
+  });
+
+  describe('for muxed content', () => {
+    it('H.264+AAC in TS', async () => {
+      // eslint-disable-next-line max-len
+      await player.load('/base/test/test/assets/hls-ts-muxed-aac-h264/playlist.m3u8');
+      await video.play();
+      expect(player.isLive()).toBe(false);
+
+      // Wait for the video to start playback.  If it takes longer than 10
+      // seconds, fail the test.
+      await waiter.waitForMovementOrFailOnTimeout(video, 10);
+
+      // Play for 15 seconds, but stop early if the video ends.  If it takes
+      // longer than 45 seconds, fail the test.
+      await waiter.waitUntilPlayheadReachesOrFailOnTimeout(video, 15, 45);
+
+      await player.unload();
+    });
+  });
+});

package/test/util/cmcd_manager_unit.js

@@ -67,9 +67,31 @@ describe('CmcdManager', () => {
     });
   });
 
+  const NetworkingEngine = shaka.net.NetworkingEngine;
+  const RequestType = NetworkingEngine.RequestType;
+
+  function createNetworkingEngine(cmcd) {
+    const resolveScheme = jasmine.createSpy('cmcd').and.callFake(
+        () => shaka.util.AbortableOperation.completed(
+            {uri: '', data: new ArrayBuffer(5), headers: {}},
+        ));
+
+    NetworkingEngine.registerScheme(
+        'cmcd', shaka.test.Util.spyFunc(resolveScheme),
+        NetworkingEngine.PluginPriority.FALLBACK);
+
+
+    /** @type {shaka.net.NetworkingEngine.OnRequest} */
+    function onRequest(type, request, context) {
+      cmcd.applyData(type, request, context);
+    }
+
+    return new NetworkingEngine(undefined, undefined, undefined,
+        onRequest);
+  }
+
   describe('CmcdManager instance', () => {
     const ObjectUtils = shaka.util.ObjectUtils;
-
     const playerInterface = {
       isLive: () => false,
       getBandwidthEstimate: () => 10000000,
@@ -80,6 +102,8 @@ describe('CmcdManager', () => {
           {start: 35, end: 40},
         ],
       }),
+      getCurrentTime: () => 10,
+      getPlaybackRate: () => 1,
       getVariantTracks: () => /** @type {Array.<shaka.extern.Track>} */([
         {
           type: 'variant',
@@ -94,8 +118,6 @@ describe('CmcdManager', () => {
           audioBandWidth: 1000000,
         },
       ]),
-      getPlaybackRate: () => 1,
-      getCurrentTime: () => 10,
     };
 
     const sid = '2ed2d1cd-970b-48f2-bfb3-50a79e87cfa3';
@@ -126,18 +148,25 @@ describe('CmcdManager', () => {
       streamDataCallback: null,
     };
 
-    const manifestInfo = {
-      format: shaka.util.CmcdManager.StreamingFormat.DASH,
+    const createContext = (type) => {
+      return {
+        type: type,
+        stream: /** @type {shaka.extern.Stream} */ ({
+          bandwidth: 5234167,
+          codecs: 'avc1.42001e',
+          mimeType: 'application/mp4',
+          type: 'video',
+        }),
+        segment: /** @type {shaka.media.SegmentReference} */ ({
+          startTime: 0,
+          endTime: 3.33,
+        }),
+      };
     };
 
-    const segmentInfo = {
-      type: 'video',
-      init: false,
-      duration: 3.33,
-      mimeType: 'application/mp4',
-      codecs: 'avc1.42001e',
-      bandwidth: 5234167,
-    };
+    const AdvancedRequestType = NetworkingEngine.AdvancedRequestType;
+    const manifestInfo = createContext(AdvancedRequestType.MPD);
+    const segmentInfo = createContext(AdvancedRequestType.MEDIA_SEGMENT);
 
     describe('configuration', () => {
       it('does not modify requests when disabled', () => {
@@ -286,6 +315,126 @@ describe('CmcdManager', () => {
         cmcdManager.applySegmentData(r, segmentInfo);
         expect(r.headers['CMCD-Request']).not.toContain(',su');
       });
+
+      describe('applies core CMCD params to networking engine requests', () => {
+        let networkingEngine;
+        const uri = 'cmcd://foo';
+        const retry = NetworkingEngine.defaultRetryParameters();
+
+        beforeAll(() => {
+          config.useHeaders = false;
+          cmcdManager = new CmcdManager(playerInterface, config);
+          networkingEngine = createNetworkingEngine(cmcdManager);
+        });
+
+        it('HEAD requests', async () => {
+          const request = NetworkingEngine.makeRequest([uri], retry);
+          request.method = 'HEAD';
+          await networkingEngine.request(RequestType.MANIFEST, request);
+
+          const result = request.uris[0];
+          expect(result).toContain('?CMCD=');
+          expect(result).toContain(encodeURIComponent('sid="'));
+          expect(result).toContain(encodeURIComponent('cid="testing"'));
+          expect(result).not.toContain(encodeURIComponent('sf='));
+        });
+
+        it('dash manifest requests', async () => {
+          const request = NetworkingEngine.makeRequest([uri], retry);
+          await networkingEngine.request(RequestType.MANIFEST, request,
+              {type: AdvancedRequestType.MPD});
+
+          const result = request.uris[0];
+          expect(result).toContain(encodeURIComponent('ot=m'));
+          expect(result).toContain(encodeURIComponent('sf=d'));
+        });
+
+        it('hls manifest requests', async () => {
+          const request = NetworkingEngine.makeRequest([uri], retry);
+          await networkingEngine.request(RequestType.MANIFEST, request,
+              {type: AdvancedRequestType.MASTER_PLAYLIST});
+
+          const result = request.uris[0];
+          expect(result).toContain(encodeURIComponent('ot=m'));
+          expect(result).toContain(encodeURIComponent('sf=h'));
+        });
+
+        it('hls playlist requests', async () => {
+          const request = NetworkingEngine.makeRequest([uri], retry);
+          await networkingEngine.request(RequestType.MANIFEST, request,
+              {type: AdvancedRequestType.MEDIA_PLAYLIST});
+
+          const result = request.uris[0];
+          expect(result).toContain(encodeURIComponent('ot=m'));
+          expect(result).toContain(encodeURIComponent('sf=h'));
+        });
+
+        it('init segment requests', async () => {
+          const request = NetworkingEngine.makeRequest([uri], retry);
+          await networkingEngine.request(RequestType.SEGMENT, request,
+              {type: AdvancedRequestType.INIT_SEGMENT});
+
+          const result = request.uris[0];
+          expect(result).toContain(encodeURIComponent('ot=i'));
+        });
+
+        it('media segment requests', async () => {
+          const request = NetworkingEngine.makeRequest([uri], retry);
+          await networkingEngine.request(RequestType.SEGMENT, request,
+              {
+                type: AdvancedRequestType.MEDIA_SEGMENT,
+                stream: {
+                  type: 'video',
+                },
+              });
+
+          const result = request.uris[0];
+          expect(result).toContain(encodeURIComponent('ot=v'));
+        });
+
+        it('key requests', async () => {
+          const request = NetworkingEngine.makeRequest([uri], retry);
+          await networkingEngine.request(RequestType.KEY, request);
+
+          const result = request.uris[0];
+          expect(result).toContain(encodeURIComponent('ot=k'));
+        });
+
+        it('license requests', async () => {
+          const request = NetworkingEngine.makeRequest([uri], retry);
+          await networkingEngine.request(RequestType.LICENSE, request);
+
+          const result = request.uris[0];
+          expect(result).toContain(encodeURIComponent('ot=k'));
+        });
+
+        it('cert requests', async () => {
+          const request = NetworkingEngine.makeRequest([uri], retry);
+          await networkingEngine.request(RequestType.SERVER_CERTIFICATE,
+              request);
+
+          const result = request.uris[0];
+          expect(result).toContain(encodeURIComponent('ot=k'));
+        });
+
+        it('timing requests', async () => {
+          const request = NetworkingEngine.makeRequest([uri], retry);
+          await networkingEngine.request(RequestType.TIMING, request);
+
+          const result = request.uris[0];
+          expect(result).toContain(encodeURIComponent('ot=o'));
+        });
+
+        it('not when enabled is false', async () => {
+          config.enabled = false;
+          cmcdManager = new CmcdManager(playerInterface, config);
+          const request = NetworkingEngine.makeRequest([uri], retry);
+          await networkingEngine.request(RequestType.TIMING, request);
+
+          const result = request.uris[0];
+          expect(result).not.toContain('?CMCD=');
+        });
+      });
     });
   });
 });

package/test/util/language_utils_unit.js

@@ -111,16 +111,23 @@ describe('LanguageUtils', () => {
       expect(LanguageUtils.normalize('EN')).toBe('en');
     });
 
-    it('standardized region', () => {
+    it('standardizes region', () => {
       expect(LanguageUtils.normalize('en-US')).toBe('en-US');
       expect(LanguageUtils.normalize('en-us')).toBe('en-US');
     });
 
-    it('ignored unknown base languages', () => {
+    it('ignores unknown base languages', () => {
       expect(LanguageUtils.normalize('elvish')).toBe('elvish');
       expect(LanguageUtils.normalize(
           'elvish-woodland')).toBe('elvish-WOODLAND');
     });
+
+    it('supports private use tag', () => {
+      expect(LanguageUtils.normalize('eng-us-x-1')).toBe('en-US-x-1');
+      expect(LanguageUtils.normalize('eng-x-1')).toBe('en-x-1');
+      expect(LanguageUtils.normalize(
+          'elvish-woodland-x-1')).toBe('elvish-WOODLAND-x-1');
+    });
   });
 
   describe('getLocaleForText', () => {

package/test/util/mp4_box_parsers_unit.js

@@ -29,12 +29,18 @@ describe('Mp4BoxParsers', () => {
     let defaultSampleDuration;
     let defaultSampleSize;
     let trackId;
+    let width;
+    let height;
     let timescale;
+    let language;
 
     const expectedDefaultSampleDuration = 512;
     const expectedDefaultSampleSize = 0;
     const expectedTrackId = 1;
+    const expectedWidth = 1685.9375;
+    const expectedHeight = 110;
     const expectedTimescale = 12288;
+    const expectedLanguage = 'eng';
 
     const Mp4Parser = shaka.util.Mp4Parser;
     new Mp4Parser()
@@ -56,6 +62,8 @@ describe('Mp4BoxParsers', () => {
           const parsedTKHDBox = shaka.util.Mp4BoxParsers.parseTKHD(
               box.reader, box.version);
           trackId = parsedTKHDBox.trackId;
+          width = parsedTKHDBox.width;
+          height = parsedTKHDBox.height;
           tkhdParsed = true;
         })
         .box('mdia', Mp4Parser.children)
@@ -66,6 +74,7 @@ describe('Mp4BoxParsers', () => {
           const parsedMDHDBox = shaka.util.Mp4BoxParsers.parseMDHD(
               box.reader, box.version);
           timescale = parsedMDHDBox.timescale;
+          language = parsedMDHDBox.language;
           mdhdParsed = true;
         })
         .parse(videoInitSegment, /* partialOkay= */ true);
@@ -76,7 +85,10 @@ describe('Mp4BoxParsers', () => {
     expect(defaultSampleDuration).toBe(expectedDefaultSampleDuration);
     expect(defaultSampleSize).toBe(expectedDefaultSampleSize);
     expect(trackId).toBe(expectedTrackId);
+    expect(width).toBe(expectedWidth);
+    expect(height).toBe(expectedHeight);
     expect(timescale).toBe(expectedTimescale);
+    expect(language).toBe(expectedLanguage);
   });
 
   it('parses video segment', () => {
@@ -146,14 +158,22 @@ describe('Mp4BoxParsers', () => {
   });
 
   /**
-   * Test on parsing an incomplete TKHD V1 box, since the parser doesn't
-   * parse the other fields
    *
    * Explanation on the Uint8Array:
    * [
    * <creation_time, 8 bytes>,
    * <modification_time, 8 bytes>,
-   * <track_id, 4 bytes>
+   * <track_id, 4 bytes>,
+   * <reserved, 8 bytes>,
+   * <duration, 4 bytes>,
+   * <reserved, 8 bytes>,
+   * <layer, 2 bytes>,
+   * <alternate_group, 2 bytes>,
+   * <volume, 2 bytes>,
+   * <reserved, 2 bytes>,
+   * <matrix_structure, 36 bytes>,
+   * <width, 4 bytes>,
+   * <height, 4 bytes>
    * ]
    *
    * Time is a 32B integer expressed in seconds since Jan 1, 1904, 0000 UTC
@@ -164,12 +184,27 @@ describe('Mp4BoxParsers', () => {
       0x00, 0x00, 0x00, 0x00, 0xDC, 0xBF, 0x0F, 0xD7, // Creation time
       0x00, 0x00, 0x00, 0x00, 0xDC, 0xBF, 0x0F, 0xD7, // Modification time
       0x00, 0x00, 0x00, 0x01, // Track ID
-      // Remaining fields are not processed in parseTKHD()
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Reserved
+      0x00, 0x00, 0x00, 0x00, // Duration
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Reserved
+      0x00, 0x00, // Layer
+      0x00, 0x00, // Alternate Group
+      0x00, 0x00, // Volume
+      0x00, 0x00, // Reserved
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Matrix Structure
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Matrix Structure
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Matrix Structure
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Matrix Structure
+      0x00, 0x00, 0x00, 0x00, // Matrix Structure
+      0x00, 0x40, 0x00, 0x00, // Width
+      0x00, 0x40, 0x00, 0x00, // Height
     ]);
     const reader = new shaka.util.DataViewReader(
         tkhdBox, shaka.util.DataViewReader.Endianness.BIG_ENDIAN);
     const parsedTkhd = shaka.util.Mp4BoxParsers
         .parseTKHD(reader, /* version= */ 1);
     expect(parsedTkhd.trackId).toBe(1);
+    expect(parsedTkhd.width).toBe(64);
+    expect(parsedTkhd.height).toBe(64);
   });
 });