shaka-player 4.2.3 → 4.3.0

package/test/media/streaming_engine_unit.js

@@ -74,6 +74,8 @@ describe('StreamingEngine', () => {
   let streamingEngine;
   /** @type {!jasmine.Spy} */
   let beforeAppendSegment;
+  /** @type {!jasmine.Spy} */
+  let onMetadata;
 
   /** @type {function(function(), number)} */
   let realSetTimeout;
@@ -432,6 +434,7 @@ describe('StreamingEngine', () => {
     onManifestUpdate = jasmine.createSpy('onManifestUpdate');
     onSegmentAppended = jasmine.createSpy('onSegmentAppended');
     beforeAppendSegment = jasmine.createSpy('beforeAppendSegment');
+    onMetadata = jasmine.createSpy('onMetadata');
     getBandwidthEstimate = jasmine.createSpy('getBandwidthEstimate');
     getBandwidthEstimate.and.returnValue(1e3);
 
@@ -461,6 +464,7 @@ describe('StreamingEngine', () => {
       onSegmentAppended: Util.spyFunc(onSegmentAppended),
       onInitSegmentAppended: () => {},
       beforeAppendSegment: Util.spyFunc(beforeAppendSegment),
+      onMetadata: Util.spyFunc(onMetadata),
     };
     streamingEngine = new shaka.media.StreamingEngine(
         /** @type {shaka.extern.Manifest} */(manifest), playerInterface);
@@ -517,7 +521,7 @@ describe('StreamingEngine', () => {
     expectedMseInit.set(ContentType.TEXT, textStream);
 
     expect(mediaSourceEngine.init).toHaveBeenCalledWith(expectedMseInit,
-        /** forceTransmuxTS= */ false, /** sequenceMode= */ false);
+        /** forceTransmux= */ false, /** sequenceMode= */ false);
     expect(mediaSourceEngine.init).toHaveBeenCalledTimes(1);
 
     expect(mediaSourceEngine.setDuration).toHaveBeenCalledTimes(1);
@@ -878,7 +882,7 @@ describe('StreamingEngine', () => {
 
     const config = shaka.util.PlayerConfiguration.createDefault().streaming;
     config.bufferingGoal = 60;
-    config.failureCallback = () => streamingEngine.retry();
+    config.failureCallback = () => streamingEngine.retry(0.1);
     createStreamingEngine(config);
 
     // Make requests for different types take different amounts of time.
@@ -1737,8 +1741,23 @@ describe('StreamingEngine', () => {
     beforeEach(() => {
       setupLive();
       mediaSourceEngine = new shaka.test.FakeMediaSourceEngine(segmentData, 0);
-      createStreamingEngine();
+
+      // Retry on failure for live streams.
+      const config = shaka.util.PlayerConfiguration.createDefault().streaming;
+      config.failureCallback = () => streamingEngine.retry(0.1);
+
+      createStreamingEngine(config);
       presentationTimeInSeconds = 100;
+
+      // Ignore 404 errors in live stream tests.
+      onError.and.callFake((error) => {
+        if (error.code == shaka.util.Error.Code.BAD_HTTP_STATUS &&
+            error.data[1] == 404) {
+          // 404 error
+        } else {
+          fail(error);
+        }
+      });
     });
 
     it('outside segment availability window', async () => {
@@ -1768,24 +1787,22 @@ describe('StreamingEngine', () => {
       const originalAppendBuffer =
           // eslint-disable-next-line no-restricted-syntax
           shaka.test.FakeMediaSourceEngine.prototype.appendBufferImpl;
-      mediaSourceEngine.appendBuffer.and.callFake(
-          (type, data, reference) => {
-            expect(presentationTimeInSeconds).toBe(125);
-            if (reference && reference.startTime >= 100) {
-              // Ignore a possible call for the first Period.
-              expect(Util.invokeSpy(timeline.getSegmentAvailabilityStart))
-                  .toBe(100);
-              expect(Util.invokeSpy(timeline.getSegmentAvailabilityEnd))
-                  .toBe(120);
-              playing = true;
-              mediaSourceEngine.appendBuffer.and.callFake(
-                  originalAppendBuffer);
-            }
+      mediaSourceEngine.appendBuffer.and.callFake((type, data, reference) => {
+        expect(presentationTimeInSeconds).toBe(125);
+        // Ignore a possible call for the first Period.
+        if (reference && reference.startTime >= 100) {
+          expect(Util.invokeSpy(timeline.getSegmentAvailabilityStart))
+              .not.toBeLessThan(100);
+          expect(Util.invokeSpy(timeline.getSegmentAvailabilityEnd))
+              .not.toBeLessThan(120);
+          playing = true;
+          mediaSourceEngine.appendBuffer.and.callFake(originalAppendBuffer);
+        }
 
-            // eslint-disable-next-line no-restricted-syntax
-            return originalAppendBuffer.call(
-                mediaSourceEngine, type, data, reference);
-          });
+        // eslint-disable-next-line no-restricted-syntax
+        return originalAppendBuffer.call(
+            mediaSourceEngine, type, data, reference);
+      });
 
       await runTest(slideSegmentAvailabilityWindow);
       // Verify buffers.
@@ -2001,7 +2018,7 @@ describe('StreamingEngine', () => {
       mediaSourceEngine = new shaka.test.FakeMediaSourceEngine(segmentData);
 
       const config = shaka.util.PlayerConfiguration.createDefault().streaming;
-      config.failureCallback = () => streamingEngine.retry();
+      config.failureCallback = () => streamingEngine.retry(0.1);
       createStreamingEngine(config);
 
       presentationTimeInSeconds = 100;
@@ -2162,7 +2179,7 @@ describe('StreamingEngine', () => {
         netEngine.request.calls.reset();
 
         // Retry streaming.
-        expect(streamingEngine.retry()).toBe(true);
+        expect(streamingEngine.retry(0.1)).toBe(true);
       });
 
       // Here we go!
@@ -2192,7 +2209,7 @@ describe('StreamingEngine', () => {
 
         // Retry streaming, which should fail and return false.
         netEngine.request.calls.reset();
-        expect(streamingEngine.retry()).toBe(false);
+        expect(streamingEngine.retry(0.1)).toBe(false);
       });
 
       // Here we go!
@@ -2244,7 +2261,7 @@ describe('StreamingEngine', () => {
 
           // Retry streaming, which should fail and return false.
           netEngine.request.calls.reset();
-          expect(streamingEngine.retry()).toBe(false);
+          expect(streamingEngine.retry(0.1)).toBe(false);
         }
       });
 
@@ -2848,6 +2865,52 @@ describe('StreamingEngine', () => {
       expect(onEvent).not.toHaveBeenCalled();
       expect(onManifestUpdate).toHaveBeenCalled();
     });
+
+    it('triggers metadata event', async () => {
+      // This is an 'emsg' box that contains a scheme of
+      // https://aomedia.org/emsg/ID to indicate a ID3 metadata.
+      segmentData[ContentType.VIDEO].segments[0] =
+          Uint8ArrayUtils.fromHex((
+            // 105 bytes  emsg box     v0, flags 0
+            '00 00 00 69  65 6d 73 67  00 00 00 00' +
+
+            // scheme id uri (13 bytes) 'https://aomedia.org/emsg/ID3'
+            '68 74 74 70  73 3a 2f 2f   61 6f 6d 65  64 69 61 2e' +
+            '6f 72 67 2f  65 6d 73 67   2f 49 44 33  00' +
+
+            // value (1 byte) ''
+            '00' +
+
+            // timescale (4 bytes) 49
+            '00 00 00 31' +
+
+            // presentation time delta (4 bytes) 8
+            '00 00 00 08' +
+
+            // event duration (4 bytes) 255
+            '00 00 00 ff' +
+
+            // id (4 bytes) 51
+            '00 00 00 33' +
+
+            // message data (47 bytes)
+            '49 44 33 03  00 40 00 00   00 1b 00 00  00 06 00 00' +
+            '00 00 00 02  54 58 58 58   00 00 00 07  e0 00 03 00' +
+            '53 68 61 6b  61 33 44 49   03 00 40 00  00 00 1b'
+          ).replace(/\s/g, ''));
+
+      videoStream.emsgSchemeIdUris = ['https://aomedia.org/emsg/ID3'];
+
+      // Here we go!
+      streamingEngine.switchVariant(variant);
+      streamingEngine.switchTextStream(textStream);
+      await streamingEngine.start();
+      playing = true;
+      await runTest();
+
+      expect(onEvent).not.toHaveBeenCalled();
+      expect(onMetadata).toHaveBeenCalled();
+    });
   });
 
   describe('embedded emsg boxes with non zero timestamps', () => {
@@ -2912,6 +2975,99 @@ describe('StreamingEngine', () => {
     });
   });
 
+  describe('embedded prft boxes', () => {
+    const prftSegment = Uint8ArrayUtils.fromHex(
+        '00000020707266740100000000000001E683B62E8E63CC580000001B319D5767');
+    const mdhdSegment = Uint8ArrayUtils.fromHex(
+        '000000446D6F6F760000003C7472616B000000346D6469610000002C6D646864'+
+        '0100000000000000DF22526500000000DF22526500989680FFFFFFFFFFFFFFFF'+
+        '15C70000');
+
+    const prftEventObj = {
+      wallClockTime: 1658402734556,
+      startDate: new Date(1658391054904.7898),
+    };
+
+    beforeEach(() => {
+      setupVod();
+      mediaSourceEngine = new shaka.test.FakeMediaSourceEngine(segmentData);
+      const config = shaka.util.PlayerConfiguration.createDefault().streaming;
+      config.parsePrftBox = true;
+      createStreamingEngine(config);
+    });
+
+    it('raises an event for registered prft v1', async () => {
+      segmentData[ContentType.VIDEO].segments[0] = prftSegment;
+      segmentData[ContentType.VIDEO].initSegments[0] = mdhdSegment;
+
+      streamingEngine.switchVariant(variant);
+      streamingEngine.switchTextStream(textStream);
+      await streamingEngine.start();
+      playing = true;
+      await runTest();
+      expect(onEvent).toHaveBeenCalled();
+
+      const event = onEvent.calls.argsFor(0)[0];
+      expect(event.detail.wallClockTime).toBe(prftEventObj.wallClockTime);
+      expect(event.detail.programStartDate.getUTCMilliseconds()).toBe(
+          prftEventObj.startDate.getUTCMilliseconds());
+      expect(event.detail.programStartDate.toUTCString()).toBe(
+          prftEventObj.startDate.toUTCString());
+    });
+
+    it('raises an event for registered prft v0', async () => {
+      const prftSegment = Uint8ArrayUtils.fromHex(
+          '0000001C707266740000000000000001E683B62E8E63CC5819999999');
+      const expectedStartDate = new Date(1658402691606.3271);
+      segmentData[ContentType.VIDEO].segments[0] = prftSegment;
+      segmentData[ContentType.VIDEO].initSegments[0] = mdhdSegment;
+
+      streamingEngine.switchVariant(variant);
+      streamingEngine.switchTextStream(textStream);
+      await streamingEngine.start();
+      playing = true;
+      await runTest();
+      expect(onEvent).toHaveBeenCalled();
+
+      const event = onEvent.calls.argsFor(0)[0];
+      expect(event.detail.wallClockTime).toBe(prftEventObj.wallClockTime);
+      expect(event.detail.programStartDate.getUTCMilliseconds()).toBe(
+          expectedStartDate.getUTCMilliseconds());
+      expect(event.detail.programStartDate.toUTCString()).toBe(
+          expectedStartDate.toUTCString());
+    });
+
+    it('does not raise event if mediatime exceeds Number.MAX_VALUE',
+        async () => {
+          const prftSegment = Uint8ArrayUtils.fromHex(
+              '00000020707266740100000000000001E683B62E8E63CC58'+
+                                              'FFFFFFFFFFFFFFFF');
+          segmentData[ContentType.VIDEO].segments[0] = prftSegment;
+          segmentData[ContentType.VIDEO].initSegments[0] = mdhdSegment;
+
+          streamingEngine.switchVariant(variant);
+          streamingEngine.switchTextStream(textStream);
+          await streamingEngine.start();
+          playing = true;
+          await runTest();
+          expect(onEvent).not.toHaveBeenCalled();
+        });
+
+    it('raises an event once only', async () => {
+      segmentData[ContentType.VIDEO].segments[0] =
+          shaka.util.Uint8ArrayUtils.concat(prftSegment, prftSegment);
+      segmentData[ContentType.VIDEO].segments[1] = prftSegment;
+      segmentData[ContentType.VIDEO].initSegments[0] = mdhdSegment;
+
+      streamingEngine.switchVariant(variant);
+      streamingEngine.switchTextStream(textStream);
+      await streamingEngine.start();
+      playing = true;
+      await runTest();
+      expect(onEvent).toHaveBeenCalledTimes(1);
+    });
+  });
+
   describe('network downgrading', () => {
     /** @type {shaka.extern.Variant} */
     let initialVariant;

package/test/media/transmuxer_integration.js

@@ -12,6 +12,9 @@ describe('Transmuxer', () => {
   const mp4MimeType = 'video/mp4; codecs="avc1.42E01E"';
   const transportStreamVideoMimeType = 'video/mp2t; codecs="avc1.42E01E"';
   const transportStreamAudioMimeType = 'video/mp2t; codecs="mp4a.40.2"';
+  const aacAudioMimeType = 'audio/aac';
+
+  const transmuxerMimeType = 'fake/mimeType';
 
   /** @type {!ArrayBuffer} */
   let videoSegment;
@@ -35,7 +38,7 @@ describe('Transmuxer', () => {
   });
 
   beforeEach(() => {
-    transmuxer = new shaka.media.Transmuxer();
+    transmuxer = new shaka.media.Transmuxer(transmuxerMimeType);
   });
 
   afterEach(async () => {
@@ -59,42 +62,50 @@ describe('Transmuxer', () => {
     });
   });
 
-  describe('convertTsCodecs', () => {
-    const convertTsCodecs =
-        (type, codecs) => shaka.media.Transmuxer.convertTsCodecs(type, codecs);
+  describe('convertCodecs', () => {
+    const convertCodecs =
+        (type, codecs) => shaka.media.Transmuxer.convertCodecs(type, codecs);
 
     it('returns converted codecs', () => {
       const convertedVideoCodecs =
-          convertTsCodecs(ContentType.VIDEO, transportStreamVideoMimeType);
+          convertCodecs(ContentType.VIDEO, transportStreamVideoMimeType);
       const convertedAudioCodecs =
-          convertTsCodecs(ContentType.AUDIO, transportStreamAudioMimeType);
+          convertCodecs(ContentType.AUDIO, transportStreamAudioMimeType);
+      const convertedAacCodecs =
+          convertCodecs(ContentType.AUDIO, aacAudioMimeType);
       const expectedVideoCodecs = 'video/mp4; codecs="avc1.42E01E"';
       const expectedAudioCodecs = 'audio/mp4; codecs="mp4a.40.2"';
+      const expectedAacCodecs = 'audio/mp4; codecs="mp4a.40.2"';
       expect(convertedVideoCodecs).toBe(expectedVideoCodecs);
       expect(convertedAudioCodecs).toBe(expectedAudioCodecs);
+      expect(convertedAacCodecs).toBe(expectedAacCodecs);
     });
 
     it('converts legacy avc1 codec strings', () => {
       expect(
-          convertTsCodecs(
+          convertCodecs(
               ContentType.VIDEO, 'video/mp2t; codecs="avc1.100.42"'))
           .toBe('video/mp4; codecs="avc1.64002a"');
       expect(
-          convertTsCodecs(ContentType.VIDEO, 'video/mp2t; codecs="avc1.77.80"'))
+          convertCodecs(ContentType.VIDEO, 'video/mp2t; codecs="avc1.77.80"'))
           .toBe('video/mp4; codecs="avc1.4d0050"');
       expect(
-          convertTsCodecs(ContentType.VIDEO, 'video/mp2t; codecs="avc1.66.1"'))
+          convertCodecs(ContentType.VIDEO, 'video/mp2t; codecs="avc1.66.1"'))
           .toBe('video/mp4; codecs="avc1.420001"');
     });
 
     // Issue #1991
     it('handles upper-case MIME types', () => {
-      expect(convertTsCodecs(
+      expect(convertCodecs(
           ContentType.VIDEO, 'video/MP2T; codecs="avc1.420001"'))
           .toBe('video/mp4; codecs="avc1.420001"');
     });
   });
 
+  it('getOrginalMimeType returns the correct mimeType', () => {
+    expect(transmuxer.getOrginalMimeType()).toBe(transmuxerMimeType);
+  });
+
   describe('transmuxing', () => {
     it('transmux video from TS to MP4', async () => {
       let sawMDAT = false;