shaka-player 4.2.4 → 4.3.0

package/test/media/closed_caption_parser_unit.js

@@ -10,7 +10,8 @@ describe('ClosedCaptionParser', () => {
         'base/test/test/assets/empty_caption_video_init.mp4');
     const videoSegment = await shaka.test.Util.fetch(
         'base/test/test/assets/empty_caption_video_segment.mp4');
-    const parser = new shaka.media.ClosedCaptionParser();
+    const mimeType = 'video/mp4';
+    const parser = new shaka.media.ClosedCaptionParser(mimeType);
     parser.init(initSegment);
     parser.parseFrom(videoSegment);
   });

package/test/media/drm_engine_integration.js

@@ -126,8 +126,10 @@ describe('DrmEngine', () => {
 
     mediaSourceEngine = new shaka.media.MediaSourceEngine(
         video,
-        new shaka.test.FakeClosedCaptionParser(),
         new shaka.test.FakeTextDisplayer());
+    const mediaSourceConfig =
+        shaka.util.PlayerConfiguration.createDefault().mediaSource;
+    mediaSourceEngine.configure(mediaSourceConfig);
 
     const expectedObject = new Map();
     expectedObject.set(ContentType.AUDIO, audioStream);

package/test/media/media_source_engine_integration.js

@@ -26,6 +26,9 @@ describe('MediaSourceEngine', () => {
    */
   let textDisplayer;
 
+  /** @type {!jasmine.Spy} */
+  let onMetadata;
+
   beforeAll(() => {
     video = shaka.test.UiUtils.createVideoElement();
     document.body.appendChild(video);
@@ -37,10 +40,14 @@ describe('MediaSourceEngine', () => {
 
     textDisplayer = new shaka.test.FakeTextDisplayer();
 
+    onMetadata = jasmine.createSpy('onMetadata');
+
     mediaSourceEngine = new shaka.media.MediaSourceEngine(
         video,
-        new shaka.media.ClosedCaptionParser(),
-        textDisplayer);
+        textDisplayer,
+        shaka.test.Util.spyFunc(onMetadata));
+    const config = shaka.util.PlayerConfiguration.createDefault().mediaSource;
+    mediaSourceEngine.configure(config);
 
     mediaSource = /** @type {?} */(mediaSourceEngine)['mediaSource_'];
     expect(video.src).toBeTruthy();
@@ -383,9 +390,9 @@ describe('MediaSourceEngine', () => {
     const initObject = new Map();
     initObject.set(ContentType.VIDEO, getFakeStream(metadata.video));
     initObject.set(ContentType.TEXT, getFakeStream(metadata.text));
-    // Call with forceTransmuxTS = true, so that it will transmux even on
+    // Call with forceTransmux = true, so that it will transmux even on
     // platforms with native TS support.
-    await mediaSourceEngine.init(initObject, /* forceTransmuxTS= */ true);
+    await mediaSourceEngine.init(initObject, /* forceTransmux= */ true);
     mediaSourceEngine.setSelectedClosedCaptionId('CC1');
     await append(ContentType.VIDEO, 0);
 
@@ -420,7 +427,7 @@ describe('MediaSourceEngine', () => {
     initObject.set(videoType, getFakeStream(metadata.video));
 
     await mediaSourceEngine.init(
-        initObject, /* forceTransmuxTS= */ false, /* sequenceMode= */ true);
+        initObject, /* forceTransmux= */ false, /* sequenceMode= */ true);
     await mediaSourceEngine.setDuration(presentationDuration);
     await mediaSourceEngine.setStreamProperties(
         videoType,
@@ -455,7 +462,7 @@ describe('MediaSourceEngine', () => {
     const initObject = new Map();
     initObject.set(ContentType.VIDEO, getFakeStream(metadata.video));
 
-    await mediaSourceEngine.init(initObject, /* forceTransmuxTS= */ false);
+    await mediaSourceEngine.init(initObject, /* forceTransmux= */ false);
     await mediaSourceEngine.setDuration(presentationDuration);
     await appendInitWithClosedCaptions(ContentType.VIDEO);
     mediaSourceEngine.setSelectedClosedCaptionId('CC1');
@@ -463,4 +470,62 @@ describe('MediaSourceEngine', () => {
 
     expect(textDisplayer.appendSpy).toHaveBeenCalled();
   });
+
+  it('extracts ID3 metadata from TS', async () => {
+    metadata = shaka.test.TestScheme.DATA['id3-metadata_ts'];
+    generators = shaka.test.TestScheme.GENERATORS['id3-metadata_ts'];
+
+    const audioType = ContentType.AUDIO;
+    const initObject = new Map();
+    initObject.set(audioType, getFakeStream(metadata.audio));
+    await mediaSourceEngine.init(initObject, /* forceTransmux= */ false);
+    await append(ContentType.AUDIO, 0);
+
+    expect(onMetadata).toHaveBeenCalled();
+  });
+
+  it('extracts ID3 metadata from TS when transmuxing', async () => {
+    metadata = shaka.test.TestScheme.DATA['id3-metadata_ts'];
+    generators = shaka.test.TestScheme.GENERATORS['id3-metadata_ts'];
+
+    const audioType = ContentType.AUDIO;
+    const initObject = new Map();
+    initObject.set(audioType, getFakeStream(metadata.audio));
+    await mediaSourceEngine.init(initObject, /* forceTransmux= */ true);
+    await append(ContentType.AUDIO, 0);
+
+    expect(onMetadata).toHaveBeenCalled();
+  });
+
+  it('extracts ID3 metadata from AAC', async () => {
+    if (!MediaSource.isTypeSupported('audio/aac')) {
+      return;
+    }
+    metadata = shaka.test.TestScheme.DATA['id3-metadata_aac'];
+    generators = shaka.test.TestScheme.GENERATORS['id3-metadata_aac'];
+
+    const audioType = ContentType.AUDIO;
+    const initObject = new Map();
+    initObject.set(audioType, getFakeStream(metadata.audio));
+    await mediaSourceEngine.init(initObject, /* forceTransmux= */ false);
+    await append(ContentType.AUDIO, 0);
+
+    expect(onMetadata).toHaveBeenCalled();
+  });
+
+  it('extracts ID3 metadata from AAC when transmuxing', async () => {
+    if (!MediaSource.isTypeSupported('audio/aac')) {
+      return;
+    }
+    metadata = shaka.test.TestScheme.DATA['id3-metadata_aac'];
+    generators = shaka.test.TestScheme.GENERATORS['id3-metadata_aac'];
+
+    const audioType = ContentType.AUDIO;
+    const initObject = new Map();
+    initObject.set(audioType, getFakeStream(metadata.audio));
+    await mediaSourceEngine.init(initObject, /* forceTransmux= */ true);
+    await append(ContentType.AUDIO, 0);
+
+    expect(onMetadata).toHaveBeenCalled();
+  });
 });

package/test/media/media_source_engine_unit.js

@@ -106,7 +106,9 @@ describe('MediaSourceEngine', () => {
     shaka.media.Transmuxer = /** @type {?} */ (function() {
       return /** @type {?} */ (mockTransmuxer);
     });
-    shaka.media.Transmuxer.convertTsCodecs = originalTransmuxer.convertTsCodecs;
+    shaka.media.Transmuxer.convertCodecs = (mimeType, contentType) => {
+      return 'video/mp4; codecs="avc1.42E01E"';
+    };
     shaka.media.Transmuxer.isSupported = (mimeType, contentType) => {
       return mimeType == 'tsMimetype';
     };
@@ -150,8 +152,12 @@ describe('MediaSourceEngine', () => {
     mockTextDisplayer = new shaka.test.FakeTextDisplayer();
     mediaSourceEngine = new shaka.media.MediaSourceEngine(
         video,
-        mockClosedCaptionParser,
         mockTextDisplayer);
+    mediaSourceEngine.getCaptionParser = () => {
+      return mockClosedCaptionParser;
+    };
+    const config = shaka.util.PlayerConfiguration.createDefault().mediaSource;
+    mediaSourceEngine.configure(config);
   });
 
   afterEach(() => {
@@ -204,7 +210,6 @@ describe('MediaSourceEngine', () => {
     it('creates a MediaSource object and sets video.src', () => {
       mediaSourceEngine = new shaka.media.MediaSourceEngine(
           video,
-          new shaka.test.FakeClosedCaptionParser(),
           new shaka.test.FakeTextDisplayer());
 
       expect(createMediaSourceSpy).toHaveBeenCalled();
@@ -631,7 +636,7 @@ describe('MediaSourceEngine', () => {
       videoSourceBuffer.mode = 'sequence';
 
       await mediaSourceEngine.init(
-          initObject, /* forceTransmuxTS= */ false, /* sequenceMode= */ true);
+          initObject, /* forceTransmux= */ false, /* sequenceMode= */ true);
 
       expect(videoSourceBuffer.timestampOffset).toBe(0);
 
@@ -657,7 +662,7 @@ describe('MediaSourceEngine', () => {
       initObject.set(ContentType.VIDEO, fakeVideoStream);
 
       await mediaSourceEngine.init(
-          initObject, /* forceTransmuxTS= */ false, /* sequenceMode= */ true);
+          initObject, /* forceTransmux= */ false, /* sequenceMode= */ true);
 
       // First, mock the scenario where timestampOffset is set to help align
       // text segments. In this case, SourceBuffer mode is still 'segments'.

package/test/media/streaming_engine_integration.js

@@ -66,8 +66,10 @@ describe('StreamingEngine', () => {
 
     mediaSourceEngine = new shaka.media.MediaSourceEngine(
         video,
-        new shaka.test.FakeClosedCaptionParser(),
         new shaka.test.FakeTextDisplayer());
+    const mediaSourceConfig =
+        shaka.util.PlayerConfiguration.createDefault().mediaSource;
+    mediaSourceEngine.configure(mediaSourceConfig);
     waiter.setMediaSourceEngine(mediaSourceEngine);
   });
 
@@ -261,6 +263,7 @@ describe('StreamingEngine', () => {
       onSegmentAppended: () => playhead.notifyOfBufferingChange(),
       onInitSegmentAppended: () => {},
       beforeAppendSegment: () => Promise.resolve(),
+      onMetadata: () => {},
     };
     streamingEngine = new shaka.media.StreamingEngine(
         /** @type {shaka.extern.Manifest} */(manifest), playerInterface);

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);
@@ -2861,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', () => {
@@ -2925,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;