shaka-player 4.4.2 → 4.5.0

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,
     };
   }
 });

package/test/media/media_source_engine_unit.js

@@ -116,7 +116,13 @@ describe('MediaSourceEngine', () => {
     mockMediaSource = createMockMediaSource();
     mockMediaSource.addSourceBuffer.and.callFake((mimeType) => {
       const type = mimeType.split('/')[0];
-      return type == 'audio' ? audioSourceBuffer : videoSourceBuffer;
+      const buffer = type == 'audio' ? audioSourceBuffer : videoSourceBuffer;
+      // reset buffer params
+      buffer.timestampOffset = 0;
+      buffer.appendWindowEnd = Infinity;
+      buffer.appendWindowStart = 0;
+
+      return buffer;
     });
     mockTransmuxer = new shaka.test.FakeTransmuxer();
     shaka.transmuxer.TransmuxerEngine.findTransmuxer =
@@ -167,10 +173,12 @@ describe('MediaSourceEngine', () => {
         goog.asserts.assert(attr == 'src', 'Unexpected removeAttribute() call');
         mockVideo.src = '';
       },
+      addEventListener: jasmine.createSpy('addVideoEventListener'),
       load: /** @this {HTMLVideoElement} */ () => {
         // This assertion alerts us if the requirements for this mock change.
         goog.asserts.assert(mockVideo.src == '', 'Unexpected load() call');
       },
+      play: jasmine.createSpy('play'),
     };
     video = /** @type {HTMLMediaElement} */(mockVideo);
     mockClosedCaptionParser = new shaka.test.FakeClosedCaptionParser();
@@ -1136,6 +1144,161 @@ describe('MediaSourceEngine', () => {
     });
   });
 
+  describe('reload codec switching', () => {
+    beforeEach(
+        /** @suppress {visibility, checkTypes} */
+        () => {
+          mediaSourceEngine.eventManager_.listenOnce =
+              jasmine.createSpy('listener');
+          mediaSourceEngine.eventManager_.listen =
+              jasmine.createSpy('eventListener');
+        });
+    const initObject = new Map();
+    initObject.set(ContentType.VIDEO, fakeVideoStream);
+    initObject.set(ContentType.AUDIO, fakeAudioStream);
+
+    it('should re-create a new MediaSource',
+    /** @suppress {visibility} */ async () => {
+          await mediaSourceEngine.init(initObject, false);
+          mediaSourceEngine.reset_(initObject);
+          expect(createMediaSourceSpy).toHaveBeenCalled();
+        });
+
+    it('should re-create the audio & video source buffers',
+    /** @suppress {invalidCasts, visibility, checkTypes} */ async () => {
+          await mediaSourceEngine.init(initObject, false);
+          mediaSourceEngine.reset_(initObject);
+          expect(mockMediaSource.addSourceBuffer).toHaveBeenCalledTimes(2);
+        });
+
+    it('should persist the previous source buffer parameters',
+    /** @suppress {invalidCasts, visibility, checkTypes} */async () => {
+          await mediaSourceEngine.init(initObject, false);
+
+          audioSourceBuffer.timestampOffset = 10;
+          audioSourceBuffer.appendWindowStart = 5;
+          audioSourceBuffer.appendWindowEnd = 20;
+
+          videoSourceBuffer.timestampOffset = 20;
+          videoSourceBuffer.appendWindowStart = 15;
+          videoSourceBuffer.appendWindowEnd = 30;
+
+          mediaSourceEngine.reset_(initObject);
+
+          expect(audioSourceBuffer.timestampOffset).toBe(10);
+          expect(audioSourceBuffer.appendWindowStart).toBe(5);
+          expect(audioSourceBuffer.appendWindowEnd).toBe(20);
+
+          expect(videoSourceBuffer.timestampOffset).toBe(20);
+          expect(videoSourceBuffer.appendWindowStart).toBe(15);
+          expect(videoSourceBuffer.appendWindowEnd).toBe(30);
+        });
+
+    it('should preserve autoplay state',
+    /** @suppress {invalidCasts, visibility, checkTypes} */
+        async () => {
+          const originalInitSourceBuffer = mediaSourceEngine.initSourceBuffer_;
+          try {
+            await mediaSourceEngine.init(initObject, false);
+            video.autoplay = true;
+            video.paused = true;
+            const playSpy = /** @type {jasmine.Spy} */ (video.play);
+            const addListenOnceSpy =
+            /** @type {jasmine.Spy} */
+              (mediaSourceEngine.eventManager_.listenOnce);
+            const addEventListenerSpy =
+            /** @type {jasmine.Spy} */
+                (mediaSourceEngine.eventManager_.listen);
+            mediaSourceEngine.playbackHasBegun_ = true;
+            mediaSourceEngine.initSourceBuffer_ =
+              jasmine.createSpy('initSourceBuffer');
+            const initSourceBufferSpy =
+            /** @type {jasmine.Spy} */
+                (mediaSourceEngine.initSourceBuffer_);
+            addEventListenerSpy.and.callFake((o, e, c) => {
+              c(); // audio
+              c(); // video
+            });
+            await mediaSourceEngine.reset_(initObject);
+            const callback = addListenOnceSpy.calls.argsFor(0)[2];
+            callback();
+            expect(initSourceBufferSpy).toHaveBeenCalled();
+            expect(addListenOnceSpy.calls.argsFor(0)[1]).toBe('canplay');
+            expect(video.autoplay).toBe(true);
+            expect(playSpy).not.toHaveBeenCalled();
+          } finally {
+            mediaSourceEngine.initSourceBuffer_ = originalInitSourceBuffer;
+          }
+        });
+
+    it('should not set autoplay to false if playback has not begun',
+    /** @suppress {invalidCasts, visibility, checkTypes} */
+        async () => {
+          const originalInitSourceBuffer = mediaSourceEngine.initSourceBuffer_;
+          try {
+            await mediaSourceEngine.init(initObject, false);
+            video.autoplay = true;
+            let setCount = 0;
+            const addEventListenerSpy =
+            /** @type {jasmine.Spy} */
+              (mediaSourceEngine.eventManager_.listen);
+            addEventListenerSpy.and.callFake((o, e, c) => {
+              c(); // audio
+              c(); // video
+            });
+            mediaSourceEngine.initSourceBuffer_ =
+            jasmine.createSpy('initSourceBuffer');
+            Object.defineProperty(video, 'autoplay', {
+              get: () => true,
+              set: () => {
+                setCount++;
+              },
+            });
+            await mediaSourceEngine.reset_(initObject);
+            expect(setCount).toBe(0);
+          } finally {
+            mediaSourceEngine.initSourceBuffer_ = originalInitSourceBuffer;
+          }
+        });
+
+    it('should preserve playing state',
+    /** @suppress {invalidCasts, visibility, checkTypes} */
+        async () => {
+          const originalInitSourceBuffer = mediaSourceEngine.initSourceBuffer_;
+          try {
+            await mediaSourceEngine.init(initObject, false);
+            video.autoplay = false;
+            video.paused = false;
+            const playSpy = /** @type {jasmine.Spy} */ (video.play);
+            const addListenOnceSpy =
+            /** @type {jasmine.Spy} */
+              (mediaSourceEngine.eventManager_.listenOnce);
+            const addEventListenerSpy =
+            /** @type {jasmine.Spy} */
+                (mediaSourceEngine.eventManager_.listen);
+            mediaSourceEngine.playbackHasBegun_ = true;
+            mediaSourceEngine.initSourceBuffer_ =
+              jasmine.createSpy('initSourceBuffer');
+            const initSourceBufferSpy =
+            /** @type {jasmine.Spy} */
+                (mediaSourceEngine.initSourceBuffer_);
+            addEventListenerSpy.and.callFake((o, e, c) => {
+              c(); // audio
+              c(); // video
+            });
+            await mediaSourceEngine.reset_(initObject);
+            const callback = addListenOnceSpy.calls.argsFor(0)[2];
+            callback();
+            expect(initSourceBufferSpy).toHaveBeenCalled();
+            expect(addListenOnceSpy.calls.argsFor(0)[1]).toBe('canplay');
+            expect(video.autoplay).toBe(false);
+            expect(playSpy).toHaveBeenCalled();
+          } finally {
+            mediaSourceEngine.initSourceBuffer_ = originalInitSourceBuffer;
+          }
+        });
+  });
+
   describe('destroy', () => {
     beforeEach(async () => {
       captureEvents(audioSourceBuffer, ['updateend', 'error']);
@@ -1259,6 +1422,7 @@ describe('MediaSourceEngine', () => {
   function createMockMediaSource() {
     const mediaSource = {
       readyState: 'open',
+      sourceBuffers: document.createElement('div'),
       addSourceBuffer: jasmine.createSpy('addSourceBuffer'),
       endOfStream: jasmine.createSpy('endOfStream'),
       durationGetter: jasmine.createSpy('duration getter'),

package/test/media/segment_index_unit.js

@@ -223,7 +223,7 @@ describe('SegmentIndex', /** @suppress {accessControls} */ () => {
 
       index.fit(/* windowStart= */ 0, /* windowEnd= */ 10);
       expect(
-          index.references[index.references.length - 1].hlsAes128Key,
+          index.references[index.references.length - 1].aes128Key,
       ).toEqual({method: 'AES-128', firstMediaSequenceNumber: 0});
     });
   });
@@ -1054,11 +1054,11 @@ describe('SegmentIndex', /** @suppress {accessControls} */ () => {
    * @param {number} startTime
    * @param {number} endTime
    * @param {!Array.<!shaka.media.SegmentReference>=} partialReferences
-   * @param {?shaka.extern.HlsAes128Key=} hlsAes128Key
+   * @param {?shaka.extern.aes128Key=} aes128Key
    * @return {shaka.media.SegmentReference}
    */
   function makeReference(uri, startTime, endTime, partialReferences = [],
-      hlsAes128Key = null) {
+      aes128Key = null) {
     return new shaka.media.SegmentReference(
         startTime,
         endTime,
@@ -1074,6 +1074,6 @@ describe('SegmentIndex', /** @suppress {accessControls} */ () => {
         /* tileDuration= */ undefined,
         /* syncTime= */ undefined,
         /* status= */ undefined,
-        /* hlsAes128Key= */ hlsAes128Key);
+        /* aes128Key= */ aes128Key);
   }
 });

package/test/media/segment_prefetch_unit.js

@@ -201,7 +201,7 @@ describe('SegmentPrefetch', () => {
         /* tileDuration= */ undefined,
         /* syncTime= */ undefined,
         /* status= */ undefined,
-        /* hlsAes128Key= */ null);
+        /* aes128Key= */ null);
   }
 
   /**

package/test/media/streaming_engine_unit.js

@@ -109,10 +109,10 @@ describe('StreamingEngine', () => {
   /**
    * @param {boolean=} trickMode
    * @param {number=} mediaOffset The offset from 0 for the segment start times
-   * @param {shaka.extern.HlsAes128Key=} hlsAes128Key The AES-128 key to put in
+   * @param {shaka.extern.aes128Key=} aes128Key The AES-128 key to put in
    *   the manifest, if one should exist
    */
-  function setupVod(trickMode, mediaOffset, hlsAes128Key) {
+  function setupVod(trickMode, mediaOffset, aes128Key) {
     // For VOD, we fake a presentation that has 2 Periods of equal duration
     // (20 seconds), where each Period has 1 Variant and 1 text stream.
     //
@@ -219,7 +219,7 @@ describe('StreamingEngine', () => {
         /* firstPeriodStartTime= */ 0,
         /* secondPeriodStartTime= */ 20,
         /* presentationDuration= */ 40,
-        hlsAes128Key);
+        aes128Key);
   }
 
   function setupLive() {
@@ -370,11 +370,11 @@ describe('StreamingEngine', () => {
    * @param {number} firstPeriodStartTime
    * @param {number} secondPeriodStartTime
    * @param {number} presentationDuration
-   * @param {shaka.extern.HlsAes128Key=} hlsAes128Key
+   * @param {shaka.extern.aes128Key=} aes128Key
    */
   function setupManifest(
       firstPeriodStartTime, secondPeriodStartTime, presentationDuration,
-      hlsAes128Key) {
+      aes128Key) {
     const segmentDurations = {
       audio: segmentData[ContentType.AUDIO].segmentDuration,
       video: segmentData[ContentType.VIDEO].segmentDuration,
@@ -397,7 +397,7 @@ describe('StreamingEngine', () => {
         /** @type {!shaka.media.PresentationTimeline} */(timeline),
         [firstPeriodStartTime, secondPeriodStartTime],
         presentationDuration, segmentDurations, initSegmentRanges,
-        timestampOffsets, hlsAes128Key);
+        timestampOffsets, aes128Key);
 
     audioStream = manifest.variants[0].audio;
     videoStream = manifest.variants[0].video;
@@ -3809,8 +3809,8 @@ describe('StreamingEngine', () => {
 
   describe('AES-128', () => {
     let key;
-    /** @type {!shaka.extern.HlsAes128Key} */
-    let hlsAes128Key;
+    /** @type {!shaka.extern.aes128Key} */
+    let aes128Key;
 
     beforeEach(async () => {
       // Get a key.
@@ -3823,10 +3823,10 @@ describe('StreamingEngine', () => {
       // Set up a manifest with AES-128 key info.
       // We don't actually provide the imported key OR the key fetching function
       // here, though, so that the individual tests can choose what the starting
-      // state of the hlsAes128Key object is.
-      hlsAes128Key = {method: 'AES-128', firstMediaSequenceNumber: 0};
+      // state of the aes128Key object is.
+      aes128Key = {method: 'AES-128', firstMediaSequenceNumber: 0};
 
-      setupVod(false, 0, hlsAes128Key);
+      setupVod(false, 0, aes128Key);
       mediaSourceEngine = new shaka.test.FakeMediaSourceEngine(segmentData);
       presentationTimeInSeconds = 0;
       createStreamingEngine();
@@ -3851,22 +3851,22 @@ describe('StreamingEngine', () => {
     }
 
     it('decrypts segments', async () => {
-      hlsAes128Key.cryptoKey = key;
+      aes128Key.cryptoKey = key;
       await runTest();
     });
 
     it('downloads key if not pre-filled', async () => {
-      hlsAes128Key.fetchKey = () => {
-        hlsAes128Key.cryptoKey = key;
-        hlsAes128Key.fetchKey = undefined;
+      aes128Key.fetchKey = () => {
+        aes128Key.cryptoKey = key;
+        aes128Key.fetchKey = undefined;
         return Promise.resolve();
       };
 
       await runTest();
 
       // The key should have been fetched.
-      expect(hlsAes128Key.cryptoKey).not.toBeUndefined();
-      expect(hlsAes128Key.fetchKey).toBeUndefined();
+      expect(aes128Key.cryptoKey).not.toBeUndefined();
+      expect(aes128Key.fetchKey).toBeUndefined();
     });
   });
 

package/test/mss/mss_parser_unit.js

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

package/test/offline/manifest_convert_unit.js

@@ -298,6 +298,7 @@ describe('ManifestConverter', () => {
     const streamDB = {
       id,
       originalId: id.toString(),
+      groupId: null,
       primary: false,
       type,
       mimeType: '',
@@ -355,6 +356,7 @@ describe('ManifestConverter', () => {
     return {
       id,
       originalId: id.toString(),
+      groupId: null,
       primary: false,
       type: ContentType.VIDEO,
       mimeType: 'video/mp4',
@@ -407,6 +409,7 @@ describe('ManifestConverter', () => {
     return {
       id,
       originalId: id.toString(),
+      groupId: null,
       primary: false,
       type: ContentType.AUDIO,
       mimeType: 'audio/mp4',
@@ -458,6 +461,7 @@ describe('ManifestConverter', () => {
     return {
       id,
       originalId: id.toString(),
+      groupId: null,
       primary: false,
       type: ContentType.TEXT,
       mimeType: 'text/vtt',
@@ -516,6 +520,7 @@ describe('ManifestConverter', () => {
     const expectedStream = {
       id: jasmine.any(Number),
       originalId: jasmine.any(String),
+      groupId: streamDb.groupId,
       createSegmentIndex: jasmine.any(Function),
       segmentIndex: jasmine.any(shaka.media.SegmentIndex),
       mimeType: streamDb.mimeType,

package/test/offline/storage_integration.js

@@ -1530,10 +1530,7 @@ filterDescribe('Storage', storageSupport, () => {
       manifest.addVariant(3, (variant) => {
         variant.language = frenchCanadian;
         variant.bandwidth = kbps(13);
-        variant.addVideo(4, (stream) => {
-          stream.bandwidth = kbps(10);
-          stream.size(100, 200);
-        });
+        variant.addExistingStream(1);
         variant.addAudio(5, (stream) => {
           stream.language = frenchCanadian;
           stream.bandwidth = kbps(3);