shaka-player 4.4.3 → 4.5.0

package/test/codec_switching/codec_switching_integration.js

@@ -0,0 +1,181 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+describe('Codec Switching', () => {
+  /** @type {!HTMLVideoElement} */
+  let video;
+  /** @type {shaka.Player} */
+  let player;
+  /** @type {!shaka.util.EventManager} */
+  let eventManager;
+
+  let compiledShaka;
+
+  /** @type {!shaka.test.Waiter} */
+  let waiter;
+
+  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);
+
+    // Disable stall detection, which can interfere with playback tests.
+    player.configure('streaming.stallEnabled', false);
+
+    eventManager = new shaka.util.EventManager();
+    waiter = new shaka.test.Waiter(eventManager);
+    waiter.setPlayer(player);
+  });
+
+  afterEach(async () => {
+    eventManager.release();
+    await player.destroy();
+  });
+
+  afterAll(() => {
+    document.body.removeChild(video);
+  });
+
+  describe('for audio and only-audio content', () => {
+    it('can switch codecs RELOAD', async () => {
+      if (!MediaSource.isTypeSupported('audio/webm; codecs="opus"')) {
+        pending('Codec OPUS in WEBM is not supported by the platform.');
+      }
+      const preferredAudioLanguage = 'en';
+      player.configure({preferredAudioLanguage: preferredAudioLanguage});
+      player.configure('manifest.disableVideo', true);
+      player.configure('streaming.mediaSource.codecSwitchingStrategy',
+          shaka.config.CodecSwitchingStrategy.RELOAD);
+
+      await player.load('/base/test/test/assets/dash-multi-codec/dash.mpd', 9);
+      await video.play();
+      await waiter.waitForMovementOrFailOnTimeout(video, 10);
+
+      expect(player.isLive()).toBe(false);
+
+      let variants = player.getVariantTracks();
+
+      expect(variants.length).toBe(2);
+      expect(variants.find((v) => !!v.active).language).toBe('en');
+
+      player.selectAudioLanguage('es');
+      await waiter.waitUntilPlayheadReachesOrFailOnTimeout(video, 10, 45);
+
+      variants = player.getVariantTracks();
+
+      expect(variants.find((v) => !!v.active).language).toBe('es');
+
+      await player.unload();
+    });
+
+    it('can switch codecs SMOOTH', async () => {
+      if (!shaka.util.Platform.supportsSmoothCodecSwitching()) {
+        pending('Mediasource.ChangeType is not considered ' +
+          'reliable on this device');
+      }
+      if (!MediaSource.isTypeSupported('audio/webm; codecs="opus"')) {
+        pending('Codec OPUS in WEBM is not supported by the platform.');
+      }
+      const preferredAudioLanguage = 'en';
+      player.configure({preferredAudioLanguage: preferredAudioLanguage});
+      player.configure('manifest.disableVideo', true);
+      player.configure('streaming.mediaSource.codecSwitchingStrategy',
+          shaka.config.CodecSwitchingStrategy.SMOOTH);
+
+      await player.load('/base/test/test/assets/dash-multi-codec/dash.mpd', 9);
+      await video.play();
+      await waiter.waitForMovementOrFailOnTimeout(video, 10);
+
+      expect(player.isLive()).toBe(false);
+
+      let variants = player.getVariantTracks();
+
+      expect(variants.length).toBe(2);
+      expect(variants.find((v) => !!v.active).language).toBe('en');
+
+      player.selectAudioLanguage('es');
+      await waiter.waitUntilPlayheadReachesOrFailOnTimeout(video, 10, 45);
+
+      variants = player.getVariantTracks();
+
+      expect(variants.find((v) => !!v.active).language).toBe('es');
+
+      await player.unload();
+    });
+  });
+
+  describe('for audio', () => {
+    it('can switch codecs RELOAD', async () => {
+      if (!MediaSource.isTypeSupported('audio/webm; codecs="opus"')) {
+        pending('Codec OPUS in WEBM is not supported by the platform.');
+      }
+      const preferredAudioLanguage = 'en';
+      player.configure({preferredAudioLanguage: preferredAudioLanguage});
+      player.configure('streaming.mediaSource.codecSwitchingStrategy',
+          shaka.config.CodecSwitchingStrategy.RELOAD);
+
+      await player.load('/base/test/test/assets/dash-multi-codec/dash.mpd', 9);
+      await video.play();
+      await waiter.waitForMovementOrFailOnTimeout(video, 10);
+
+      expect(player.isLive()).toBe(false);
+
+      let variants = player.getVariantTracks();
+
+      expect(variants.length).toBe(2);
+      expect(variants.find((v) => !!v.active).language).toBe('en');
+
+      player.selectAudioLanguage('es');
+      await waiter.waitUntilPlayheadReachesOrFailOnTimeout(video, 10, 45);
+
+      variants = player.getVariantTracks();
+
+      expect(variants.find((v) => !!v.active).language).toBe('es');
+
+      await player.unload();
+    });
+
+    it('can switch codecs SMOOTH', async () => {
+      if (!shaka.util.Platform.supportsSmoothCodecSwitching()) {
+        pending('Mediasource.ChangeType is not considered ' +
+          'reliable on this device');
+      }
+      if (!MediaSource.isTypeSupported('audio/webm; codecs="opus"')) {
+        pending('Codec OPUS in WEBM is not supported by the platform.');
+      }
+      const preferredAudioLanguage = 'en';
+      player.configure({preferredAudioLanguage: preferredAudioLanguage});
+      player.configure('streaming.mediaSource.codecSwitchingStrategy',
+          shaka.config.CodecSwitchingStrategy.SMOOTH);
+
+      await player.load('/base/test/test/assets/dash-multi-codec/dash.mpd', 9);
+      await video.play();
+      await waiter.waitForMovementOrFailOnTimeout(video, 10);
+
+      expect(player.isLive()).toBe(false);
+
+      let variants = player.getVariantTracks();
+
+      expect(variants.length).toBe(2);
+      expect(variants.find((v) => !!v.active).language).toBe('en');
+
+      player.selectAudioLanguage('es');
+      await waiter.waitUntilPlayheadReachesOrFailOnTimeout(video, 10, 45);
+
+      variants = player.getVariantTracks();
+
+      expect(variants.find((v) => !!v.active).language).toBe('es');
+
+      await player.unload();
+    });
+  });
+});

package/test/dash/dash_parser_content_protection_unit.js

@@ -45,6 +45,8 @@ describe('DashParser ContentProtection', () => {
       enableLowLatencyMode: () => {},
       updateDuration: () => {},
       newDrmInfo: (stream) => {},
+      onManifestUpdated: () => {},
+      getBandwidthEstimate: () => 1e6,
     };
 
     const actual = await dashParser.start(

package/test/dash/dash_parser_integration.js

@@ -0,0 +1,73 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+describe('DashParser', () => {
+  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;
+
+  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);
+
+    // 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);
+  });
+
+  it('supports AES-128 streaming', async () => {
+    await player.load('/base/test/test/assets/dash-aes-128/dash.mpd');
+    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 10 seconds, but stop early if the video ends.  If it takes
+    // longer than 30 seconds, fail the test.
+    await waiter.waitUntilPlayheadReachesOrFailOnTimeout(video, 10, 30);
+
+    await player.unload();
+  });
+});

package/test/dash/dash_parser_live_unit.js

@@ -36,6 +36,8 @@ describe('DashParser Live', () => {
       enableLowLatencyMode: () => {},
       updateDuration: () => {},
       newDrmInfo: (stream) => {},
+      onManifestUpdated: () => {},
+      getBandwidthEstimate: () => 1e6,
     };
   });
 

package/test/dash/dash_parser_manifest_unit.js

@@ -54,6 +54,8 @@ describe('DashParser Manifest', () => {
       enableLowLatencyMode: () => {},
       updateDuration: () => {},
       newDrmInfo: (stream) => {},
+      onManifestUpdated: () => {},
+      getBandwidthEstimate: () => 1e6,
     };
   });
 
@@ -1180,6 +1182,46 @@ describe('DashParser Manifest', () => {
     expect(trickModeVideo).toBe(null);
   });
 
+  it('populates groupId if configuration enabled', async () => {
+    const manifestText = [
+      '<MPD minBufferTime="PT75S">',
+      '  <Period id="1" duration="PT30S">',
+      '    <AdaptationSet id="1" contentType="text">',
+      '      <Representation id="text-en" mimeType="text/webvtt">',
+      '        <BaseURL>t-en.vtt</BaseURL>',
+      '      </Representation>',
+      '    </AdaptationSet>',
+      '    <AdaptationSet id="2" mimeType="video/mp4">',
+      '      <Representation id="video-sd" width="640" height="480">',
+      '        <BaseURL>v-sd.mp4</BaseURL>',
+      '        <SegmentBase indexRange="100-200" />',
+      '      </Representation>',
+      '    </AdaptationSet>',
+      '    <AdaptationSet id="3" mimeType="audio/mp4">',
+      '      <Representation id="audio-en">',
+      '        <BaseURL>a-en.mp4</BaseURL>',
+      '        <SegmentBase indexRange="100-200" />',
+      '      </Representation>',
+      '    </AdaptationSet>',
+      '  </Period>',
+      '</MPD>',
+    ].join('\n');
+
+    fakeNetEngine.setResponseText('dummy://foo', manifestText);
+
+    const config = shaka.util.PlayerConfiguration.createDefault().manifest;
+    config.dash.enableAudioGroups = true;
+    parser.configure(config);
+
+    /** @type {shaka.extern.Manifest} */
+    const manifest = await parser.start('dummy://foo', playerInterface);
+
+
+    expect(manifest.variants.length).toBe(1);
+    const variant = manifest.variants[0];
+    expect(variant.audio.groupId).toBe('3');
+  });
+
   it('sets contentType to text for embedded text mime types', async () => {
     // One MIME type for embedded TTML, one for embedded WebVTT.
     // One MIME type specified on AdaptationSet, on one Representation.

package/test/dash/dash_parser_segment_base_unit.js

@@ -40,6 +40,8 @@ describe('DashParser SegmentBase', () => {
       enableLowLatencyMode: () => {},
       updateDuration: () => {},
       newDrmInfo: (stream) => {},
+      onManifestUpdated: () => {},
+      getBandwidthEstimate: () => 1e6,
     };
   });
 

package/test/dash/dash_parser_segment_list_unit.js

@@ -350,6 +350,8 @@ describe('DashParser SegmentList', () => {
       enableLowLatencyMode: () => {},
       updateDuration: () => {},
       newDrmInfo: (stream) => {},
+      onManifestUpdated: () => {},
+      getBandwidthEstimate: () => 1e6,
     };
     try {
       const manifest = await dashParser.start('dummy://foo', playerInterface);

package/test/dash/dash_parser_segment_template_unit.js

@@ -49,6 +49,8 @@ describe('DashParser SegmentTemplate', () => {
       enableLowLatencyMode: () => {},
       updateDuration: () => {},
       newDrmInfo: (stream) => {},
+      onManifestUpdated: () => {},
+      getBandwidthEstimate: () => 1e6,
     };
   });
 

package/test/demo/demo_unit.js

@@ -33,22 +33,6 @@ describe('Demo', () => {
     await shakaDemoMain.cleanup();
   });
 
-  it('has all messages defined', async () => {
-    const englishBuffer =
-        await shaka.test.Util.fetch('/base/demo/locales/en.json');
-    const englishMessages = JSON.parse(shaka.util.StringUtils.fromUTF8(
-        englishBuffer));
-    const sourceBuffer =
-        await shaka.test.Util.fetch('/base/demo/locales/source.json');
-    const sourceMessages = JSON.parse(shaka.util.StringUtils.fromUTF8(
-        sourceBuffer));
-
-    for (const id of Object.values(shakaDemo.MessageIds)) {
-      expect(englishMessages[id]).withContext(`id=${id}, English`).toBeTruthy();
-      expect(sourceMessages[id]).withContext(`id=${id}, source`).toBeTruthy();
-    }
-  });
-
   describe('config', () => {
     it('does not have entries for invalid config options', () => {
       // We determine whether a config option has been made or not by looking at

package/test/hls/hls_live_unit.js

@@ -77,6 +77,8 @@ describe('HlsParser live', () => {
       enableLowLatencyMode: () => {},
       updateDuration: () => {},
       newDrmInfo: (stream) => {},
+      onManifestUpdated: () => {},
+      getBandwidthEstimate: () => 1e6,
     };
 
     parser = new shaka.hls.HlsParser();

package/test/hls/hls_parser_unit.js

@@ -90,6 +90,8 @@ describe('HlsParser', () => {
       enableLowLatencyMode: () => {},
       updateDuration: () => {},
       newDrmInfo: shaka.test.Util.spyFunc(newDrmInfoSpy),
+      onManifestUpdated: () => {},
+      getBandwidthEstimate: () => 1e6,
     };
 
     parser = new shaka.hls.HlsParser();
@@ -3124,11 +3126,11 @@ describe('HlsParser', () => {
         'Null segmentIndex!');
 
     const firstMp4Segment = mp4AesEncryptionVideo.segmentIndex.get(0);
-    expect(firstMp4Segment.hlsAes128Key).toBeDefined();
-    expect(firstMp4Segment.initSegmentReference.hlsAes128Key).toBeDefined();
+    expect(firstMp4Segment.aes128Key).toBeDefined();
+    expect(firstMp4Segment.initSegmentReference.aes128Key).toBeDefined();
     const secondMp4Segment = mp4AesEncryptionVideo.segmentIndex.get(1);
-    expect(secondMp4Segment.hlsAes128Key).toBeNull();
-    expect(secondMp4Segment.initSegmentReference.hlsAes128Key).toBeDefined();
+    expect(secondMp4Segment.aes128Key).toBeNull();
+    expect(secondMp4Segment.initSegmentReference.aes128Key).toBeDefined();
 
     const tsAesEncryptionVideo = actual.variants[2].video;
     await tsAesEncryptionVideo.createSegmentIndex();
@@ -3136,9 +3138,9 @@ describe('HlsParser', () => {
         'Null segmentIndex!');
 
     const firstTsSegment = tsAesEncryptionVideo.segmentIndex.get(0);
-    expect(firstTsSegment.hlsAes128Key).toBeDefined();
+    expect(firstTsSegment.aes128Key).toBeDefined();
     const secondTsSegment = tsAesEncryptionVideo.segmentIndex.get(1);
-    expect(secondTsSegment.hlsAes128Key).toBeNull();
+    expect(secondTsSegment.aes128Key).toBeNull();
   });
 
   it('fails on AES-128 if WebCrypto APIs are not available', async () => {

package/test/media/adaptation_set_criteria_unit.js

@@ -49,6 +49,90 @@ describe('AdaptationSetCriteria', () => {
       ]);
     });
 
+    it('should not filter varaints when codec switching startegy is smooth '+
+        'and changeType is supported', () => {
+      const manifest = shaka.test.ManifestGenerator.generate((manifest) => {
+        manifest.addVariant(1, (variant) => {
+          variant.addAudio(10, (stream) => {
+            stream.codecs = 'mp4a.69';
+          });
+          variant.addVideo(11, (stream) => {
+            stream.codecs = 'avc1';
+          });
+        });
+        manifest.addVariant(2, (variant) => {
+          variant.addAudio(12, (stream) => {
+            stream.codecs = 'mp4a.66';
+          });
+          variant.addVideo(13, (stream) => {
+            stream.codecs = 'hvc1';
+          });
+        });
+        manifest.addVariant(3, (variant) => {
+          variant.addAudio(14, (stream) => {
+            stream.codecs = 'mp4a.a6';
+          });
+          variant.addVideo(14, (stream) => {
+            stream.codecs = 'dvh1';
+          });
+        });
+      });
+
+      const originalIsChangeTypeSupported = shaka.media.Capabilities
+          .isChangeTypeSupported;
+
+      try {
+        shaka.media.Capabilities.isChangeTypeSupported = () => {
+          return true;
+        };
+
+        const builder = new shaka.media.PreferenceBasedCriteria('en', '', 0, '',
+            undefined, shaka.config.CodecSwitchingStrategy.SMOOTH);
+        const set = builder.create(manifest.variants);
+
+        expect(Array.from(set.values()).length).toBe(3);
+      } finally {
+        shaka.media.Capabilities
+            .isChangeTypeSupported = originalIsChangeTypeSupported;
+      }
+    });
+
+    it('should filter varaints when codec switching startegy'+
+        'is not SMOOTH', () => {
+      const manifest = shaka.test.ManifestGenerator.generate((manifest) => {
+        manifest.addVariant(1, (variant) => {
+          variant.addAudio(10, (stream) => {
+            stream.codecs = 'mp4a.69';
+          });
+          variant.addVideo(11, (stream) => {
+            stream.codecs = 'avc1';
+          });
+        });
+        manifest.addVariant(2, (variant) => {
+          variant.addAudio(12, (stream) => {
+            stream.codecs = 'mp4a.66';
+          });
+          variant.addVideo(13, (stream) => {
+            stream.codecs = 'hvc1';
+          });
+        });
+        manifest.addVariant(3, (variant) => {
+          variant.addAudio(14, (stream) => {
+            stream.codecs = 'mp4a.a6';
+          });
+          variant.addVideo(14, (stream) => {
+            stream.codecs = 'dvh1';
+          });
+        });
+      });
+
+      const builder = new shaka.media.PreferenceBasedCriteria('en', '', 0, '',
+          undefined, shaka.config.CodecSwitchingStrategy.RELOAD);
+      const set = builder.create(manifest.variants);
+
+      expect(Array.from(set.values()).length).toBe(1);
+    });
+
     it('chooses variants in preferred language and role', () => {
       const manifest = shaka.test.ManifestGenerator.generate((manifest) => {
         manifest.addVariant(1, (variant) => {
@@ -524,6 +608,40 @@ describe('AdaptationSetCriteria', () => {
         manifest.variants[2],
       ]);
     });
+
+    it('filters by audio group if present', () => {
+      const manifest = shaka.test.ManifestGenerator.generate((manifest) => {
+        manifest.addVariant(1, (variant) => {
+          variant.language = 'en';
+          variant.bandwidth = 300;
+          variant.addAudio(10, (stream) => {
+            stream.groupId = '1';
+          });
+        });
+        manifest.addVariant(2, (variant) => {
+          variant.language = 'en';
+          variant.bandwidth = 400;
+          variant.addAudio(11, (stream) => {
+            stream.groupId = '2';
+          });
+        });
+        manifest.addVariant(3, (variant) => {
+          variant.language = 'en';
+          variant.bandwidth = 500;
+          variant.addAudio(12, (stream) => {
+            stream.groupId = '1';
+          });
+        });
+      });
+
+      const builder = new shaka.media.PreferenceBasedCriteria('en', '', 0, '');
+      const set = builder.create(manifest.variants);
+
+      checkSet(set, [
+        manifest.variants[0],
+        manifest.variants[2],
+      ]);
+    });
   });
 
   /**

package/test/media/adaptation_set_unit.js

@@ -221,6 +221,7 @@ describe('AdaptationSet', () => {
       type: '',
       accessibilityPurpose: null,
       external: false,
+      groupId: null,
     };
   }
 });