shaka-player 4.3.0 → 4.3.2

package/lib/util/stream_utils.js

@@ -8,6 +8,7 @@ goog.provide('shaka.util.StreamUtils');
 
 goog.require('goog.asserts');
 goog.require('shaka.log');
+goog.require('shaka.media.Capabilities');
 goog.require('shaka.text.TextEngine');
 goog.require('shaka.util.Functional');
 goog.require('shaka.util.LanguageUtils');
@@ -437,25 +438,31 @@ shaka.util.StreamUtils = class {
       // See: https://github.com/shaka-project/shaka-player/issues/3860
       const video = variant.video;
       const ContentType = shaka.util.ManifestParserUtils.ContentType;
+      const Capabilities = shaka.media.Capabilities;
       if (video) {
-        let videoCodecs = shaka.util.StreamUtils.patchVp9(video.codecs);
+        let videoCodecs =
+            shaka.util.StreamUtils.getCorrectVideoCodecs_(video.codecs);
         // For multiplexed streams. Here we must check the audio of the
         // stream to see if it is compatible.
         if (video.codecs.includes(',')) {
           const allCodecs = video.codecs.split(',');
           videoCodecs = shaka.util.ManifestParserUtils.guessCodecs(
               ContentType.VIDEO, allCodecs);
-          const audioCodecs = shaka.util.ManifestParserUtils.guessCodecs(
+          videoCodecs =
+              shaka.util.StreamUtils.getCorrectVideoCodecs_(videoCodecs);
+          let audioCodecs = shaka.util.ManifestParserUtils.guessCodecs(
               ContentType.AUDIO, allCodecs);
+          audioCodecs =
+              shaka.util.StreamUtils.getCorrectAudioCodecs_(audioCodecs);
           const audioFullType = shaka.util.MimeUtils.getFullOrConvertedType(
               video.mimeType, audioCodecs, ContentType.AUDIO);
-          if (!MediaSource.isTypeSupported(audioFullType)) {
+          if (!Capabilities.isTypeSupported(audioFullType)) {
             return false;
           }
         }
         const fullType = shaka.util.MimeUtils.getFullOrConvertedType(
             video.mimeType, videoCodecs, ContentType.VIDEO);
-        if (!MediaSource.isTypeSupported(fullType)) {
+        if (!Capabilities.isTypeSupported(fullType)) {
           return false;
         }
       }
@@ -465,7 +472,7 @@ shaka.util.StreamUtils = class {
             shaka.util.StreamUtils.getCorrectAudioCodecs_(audio.codecs);
         const fullType = shaka.util.MimeUtils.getFullOrConvertedType(
             audio.mimeType, codecs, ContentType.AUDIO);
-        if (!MediaSource.isTypeSupported(fullType)) {
+        if (!Capabilities.isTypeSupported(fullType)) {
           return false;
         }
       }
@@ -566,7 +573,8 @@ shaka.util.StreamUtils = class {
         const allCodecs = video.codecs.split(',');
         videoCodecs = shaka.util.ManifestParserUtils.guessCodecs(
             ContentType.VIDEO, allCodecs);
-        videoCodecs = shaka.util.StreamUtils.patchVp9(videoCodecs);
+        videoCodecs =
+            shaka.util.StreamUtils.getCorrectVideoCodecs_(videoCodecs);
         const audioCodecs = shaka.util.ManifestParserUtils.guessCodecs(
             ContentType.AUDIO, allCodecs);
 
@@ -580,7 +588,7 @@ shaka.util.StreamUtils = class {
           spatialRendering: false,
         };
       }
-      videoCodecs = shaka.util.StreamUtils.patchVp9(videoCodecs);
+      videoCodecs = shaka.util.StreamUtils.getCorrectVideoCodecs_(videoCodecs);
       const fullType = shaka.util.MimeUtils.getFullOrConvertedType(
           video.mimeType, videoCodecs, ContentType.VIDEO);
       // VideoConfiguration
@@ -749,15 +757,29 @@ shaka.util.StreamUtils = class {
 
 
   /**
-   * MediaCapabilities supports 'vp09...' codecs, but not 'vp9'. Translate vp9
-   * codec strings into 'vp09...', to allow such content to play with
-   * mediaCapabilities enabled.
-   *
+   * Generates the correct video codec for MediaDecodingConfiguration and
+   * for MediaSource.isTypeSupported.
    * @param {string} codec
    * @return {string}
+   * @private
    */
-  static patchVp9(codec) {
-    if (codec == 'vp9') {
+  static getCorrectVideoCodecs_(codec) {
+    if (codec.includes('avc1')) {
+      // Convert avc1 codec string from RFC-4281 to RFC-6381 for
+      // MediaSource.isTypeSupported
+      // Example, convert avc1.66.30 to avc1.42001e (0x42 == 66 and 0x1e == 30)
+      const avcdata = codec.split('.');
+      if (avcdata.length == 3) {
+        let result = avcdata.shift() + '.';
+        result += parseInt(avcdata.shift(), 10).toString(16);
+        result +=
+            ('000' + parseInt(avcdata.shift(), 10).toString(16)).slice(-4);
+        return result;
+      }
+    } else if (codec == 'vp9') {
+      // MediaCapabilities supports 'vp09...' codecs, but not 'vp9'. Translate
+      // vp9 codec strings into 'vp09...', to allow such content to play with
+      // mediaCapabilities enabled.
       // This means profile 0, level 4.1, 8-bit color.  This supports 1080p @
       // 60Hz.  See https://en.wikipedia.org/wiki/VP9#Levels
       //

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "shaka-player",
   "description": "DASH/EME video player library",
-  "version": "4.3.0",
+  "version": "4.3.2",
   "homepage": "https://github.com/shaka-project/shaka-player",
   "author": "Google",
   "maintainers": [
@@ -28,9 +28,9 @@
     "eslint-plugin-shaka-rules": "file:./build/eslint-plugin-shaka-rules",
     "esprima": "^4.0.1",
     "fontfaceonload": "^1.0.2",
-    "google-closure-compiler-java": "^20220301.0.0",
-    "google-closure-deps": "https://gitpkg.now.sh/google/closure-library/closure-deps?d7736da6",
-    "google-closure-library": "^20220301.0.0",
+    "google-closure-compiler-java": "^20221102.0.0",
+    "google-closure-deps": "^20221102.0.0",
+    "google-closure-library": "^20221102.0.0",
     "htmlhint": "^1.1.3",
     "jasmine-ajax": "^4.0.0",
     "jimp": "^0.16.1",

package/shaka-player.uncompiled.js

@@ -32,6 +32,7 @@ goog.require('shaka.offline.OfflineManifestParser');
 goog.require('shaka.offline.OfflineScheme');
 goog.require('shaka.offline.Storage');
 goog.require('shaka.offline.indexeddb.StorageMechanism');
+goog.require('shaka.polyfill.AbortController');
 goog.require('shaka.polyfill.Aria');
 goog.require('shaka.polyfill.EncryptionScheme');
 goog.require('shaka.polyfill.Fullscreen');

package/test/ads/ad_manager_unit.js

@@ -115,7 +115,9 @@ describe('Ad manager', () => {
         startedEventB = /** @type {!google.ima.AdEvent} */ (
           new shaka.util.FakeEvent(google.ima.AdEvent.Type.STARTED));
         startedEventB.getAd = () => {
-          return {};
+          return {
+            isLinear: () => true,
+          };
         };
       }
       makeMocks();

package/test/dash/dash_parser_manifest_unit.js

@@ -2198,6 +2198,7 @@ describe('DashParser Manifest', () => {
     /** @type {shaka.extern.Manifest} */
     const manifest = await parser.start('dummy://foo', playerInterface);
     expect(manifest.imageStreams.length).toBe(1);
+    expect(manifest.presentationTimeline.getMaxSegmentDuration()).toBe(1);
     const imageStream = manifest.imageStreams[0];
     expect(imageStream.width).toBe(1024);
     expect(imageStream.height).toBe(1152);

package/test/hls/hls_parser_unit.js

@@ -40,6 +40,7 @@ describe('HlsParser', () => {
 
   afterEach(() => {
     shaka.log.alwaysWarn = originalAlwaysWarn;
+    parser.stop();
   });
 
   beforeEach(() => {
@@ -1089,6 +1090,77 @@ describe('HlsParser', () => {
     await testHlsParser(master, media, manifest);
   });
 
+  // https://github.com/shaka-project/shaka-player/issues/4759
+  it('makes roles available without loading tracks', async () => {
+    const master = [
+      '#EXTM3U\n',
+      '#EXT-X-STREAM-INF:BANDWIDTH=200,CODECS="avc1",',
+      'RESOLUTION=960x540,FRAME-RATE=60,AUDIO="aud1",SUBTITLES="sub1"\n',
+      'video\n',
+
+      '#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="aud1",LANGUAGE="en",',
+      'NAME="English",URI="audio"\n',
+
+      '#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="aud1",LANGUAGE="en",',
+      'CHARACTERISTICS="public.accessibility.describes-video,',
+      'public.accessibility.describes-music-and-sound",',
+      'NAME="English (describes-video)",URI="audio2"\n',
+
+      '#EXT-X-MEDIA:TYPE=SUBTITLES,GROUP-ID="sub1",LANGUAGE="en",',
+      'NAME="English (caption)",DEFAULT=YES,AUTOSELECT=YES,',
+      'URI="text"\n',
+
+      '#EXT-X-MEDIA:TYPE=SUBTITLES,GROUP-ID="sub1",LANGUAGE="en",',
+      'NAME="English (caption)",DEFAULT=YES,AUTOSELECT=YES,',
+      'CHARACTERISTICS="public.accessibility.describes-spoken-dialog,',
+      'public.accessibility.describes-music-and-sound",',
+      'URI="text2"\n',
+    ].join('');
+
+    const manifest = shaka.test.ManifestGenerator.generate((manifest) => {
+      manifest.anyTimeline();
+      manifest.addPartialVariant((variant) => {
+        variant.language = 'en';
+        variant.addPartialStream(ContentType.VIDEO);
+        variant.addPartialStream(ContentType.AUDIO, (stream) => {
+          stream.language = 'en';
+        });
+      });
+      manifest.addPartialVariant((variant) => {
+        variant.language = 'en';
+        variant.addPartialStream(ContentType.VIDEO);
+        variant.addPartialStream(ContentType.AUDIO, (stream) => {
+          stream.language = 'en';
+          stream.roles = [
+            'public.accessibility.describes-video',
+            'public.accessibility.describes-music-and-sound',
+          ];
+        });
+      });
+      manifest.addPartialTextStream((stream) => {
+        stream.language = 'en';
+        stream.kind = TextStreamKind.SUBTITLE;
+      });
+      manifest.addPartialTextStream((stream) => {
+        stream.language = 'en';
+        stream.kind = TextStreamKind.SUBTITLE;
+        stream.roles = [
+          'public.accessibility.describes-spoken-dialog',
+          'public.accessibility.describes-music-and-sound',
+        ];
+      });
+      manifest.sequenceMode = true;
+    });
+
+    fakeNetEngine.setResponseText('test:/master', master);
+
+    // NOTE: Not using testHlsParser here because that unconditionally loads all
+    // streams.  We need to test the behavior specifically when streams are
+    // _not_ loaded.
+    const actual = await parser.start('test:/master', playerInterface);
+    expect(actual).toEqual(manifest);
+  });
+
   it('gets mime type from header request', async () => {
     const master = [
       '#EXTM3U\n',
@@ -4262,4 +4334,64 @@ describe('HlsParser', () => {
     expect(actualVideo0.mimeType).toBe('video/mp2t');
     expect(actualVideo1.mimeType).toBe('video/mp2t');
   });
+
+  it('lazy-loads AAC content without filtering it out', async () => {
+    const master = [
+      '#EXTM3U\n',
+      '#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="aud1",LANGUAGE="eng",URI="audio"\n',
+      '#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="aud1",LANGUAGE="spa",URI="audio2"\n',
+      '#EXT-X-STREAM-INF:BANDWIDTH=200,CODECS="avc1,mp4a",',
+      'RESOLUTION=960x540,FRAME-RATE=60,AUDIO="aud1"\n',
+      'video\n',
+    ].join('');
+
+    const video = [
+      '#EXTM3U\n',
+      '#EXT-X-TARGETDURATION:5\n',
+      '#EXT-X-MAP:URI="init.mp4",BYTERANGE="616@0"\n',
+      '#EXT-X-MEDIA-SEQUENCE:1\n',
+      '#EXTINF:5,\n',
+      'video1.ts\n',
+      '#EXTINF:5,\n',
+      'video2.ts\n',
+    ].join('');
+
+    const audio = [
+      '#EXTM3U\n',
+      '#EXT-X-TARGETDURATION:5\n',
+      '#EXT-X-MEDIA-SEQUENCE:3\n',
+      '#EXTINF:5,\n',
+      'audio1.aac\n',
+      '#EXTINF:5,\n',
+      'audio2.aac\n',
+    ].join('');
+
+    fakeNetEngine
+        .setResponseText('test:/master', master)
+        .setResponseText('test:/audio', audio)
+        .setResponseText('test:/audio2', audio)
+        .setResponseText('test:/video', video)
+        .setResponseValue('test:/init.mp4', initSegmentData);
+
+    const actualManifest = await parser.start('test:/master', playerInterface);
+    expect(actualManifest.variants.length).toBe(2);
+
+    const actualAudio0 = actualManifest.variants[0].audio;
+    const actualAudio1 = actualManifest.variants[1].audio;
+
+    // Before loading, all MIME types agree, and are defaulted to audio/mp4.
+    expect(actualAudio0.mimeType).toBe('audio/mp4');
+    expect(actualAudio1.mimeType).toBe('audio/mp4');
+
+    await actualAudio0.createSegmentIndex();
+
+    // After loading just ONE stream, all MIME types agree again, and have been
+    // updated to reflect the AAC content found inside the loaded playlist.
+    // This is how we avoid having the unloaded tracks filtered out during
+    // startup.
+    expect(actualAudio0.mimeType).toBe('audio/aac');
+    expect(actualAudio0.codecs).toBe('');
+    expect(actualAudio1.mimeType).toBe('audio/aac');
+    expect(actualAudio1.codecs).toBe('');
+  });
 });

package/test/media/drm_engine_unit.js

@@ -120,11 +120,17 @@ describe('DrmEngine', () => {
     };
 
     drmEngine = new shaka.media.DrmEngine(playerInterface);
+
     config = shaka.util.PlayerConfiguration.createDefault().drm;
     config.servers = {
       'drm.abc': 'http://abc.drm/license',
       'drm.def': 'http://def.drm/license',
     };
+    // Some platforms, such as Xbox, default to parseInbandPssh: true, which
+    // ignores encrypted events.  So set it explicitly to false, and let
+    // individual tests set it to true where relevant.
+    config.parseInbandPsshEnabled = false;
+
     drmEngine.configure(config);
   });
 
@@ -2548,7 +2554,11 @@ describe('DrmEngine', () => {
    */
   async function sendEncryptedEvent(
       initDataType = 'cenc', initData = new Uint8Array(1), keyId = null) {
-    mockVideo.on['encrypted']({initDataType, initData, keyId});
+    // For some platforms, such as Xbox, where parseInbandPssh defaults to
+    // true, this listener may never be set.
+    if (mockVideo.on['encrypted']) {
+      mockVideo.on['encrypted']({initDataType, initData, keyId});
+    }
 
     await Util.shortDelay();
   }

package/test/media/media_source_engine_integration.js

@@ -6,6 +6,8 @@
 
 describe('MediaSourceEngine', () => {
   const ContentType = shaka.util.ManifestParserUtils.ContentType;
+  const Cue = shaka.text.Cue;
+  const Util = shaka.test.Util;
   const presentationDuration = 840;
 
   /** @type {!HTMLVideoElement} */
@@ -18,6 +20,64 @@ describe('MediaSourceEngine', () => {
   let metadata;
   // TODO: add text streams to MSE integration tests
 
+  const mp4CeaCue0 = jasmine.objectContaining({
+    startTime: Util.closeTo(0.067, 0.001),
+    endTime: Util.closeTo(1, 0.001),
+    textAlign: Cue.textAlign.CENTER,
+    nestedCues: [
+      jasmine.objectContaining({
+        startTime: Util.closeTo(0.067, 0.001),
+        endTime: Util.closeTo(1, 0.001),
+        payload: 'eng:⠀00:00:00:00',
+        textAlign: Cue.textAlign.CENTER,
+      }),
+    ],
+  });
+
+  const tsCeaCue0 = jasmine.objectContaining({
+    startTime: Util.closeTo(0.767, 0.001),
+    endTime: Util.closeTo(4.972, 0.001),
+    textAlign: Cue.textAlign.CENTER,
+    payload: 'These are 608 captions\n(top left)',
+  });
+
+  const tsCeaCue1 = jasmine.objectContaining({
+    startTime: Util.closeTo(5.305, 0.001),
+    endTime: Util.closeTo(11.979, 0.001),
+    textAlign: Cue.textAlign.CENTER,
+    payload: 'These are 608 captions\n(middle)',
+  });
+
+  const tsCeaCue2 = jasmine.objectContaining({
+    startTime: Util.closeTo(12.312, 0.001),
+    endTime: Util.closeTo(19.319, 0.001),
+    textAlign: Cue.textAlign.CENTER,
+    payload: 'These are 608 captions\n(bottom left)',
+  });
+
+  // The same segments as above, but offset by 40 seconds (yes, 40), which is
+  // also 2 segments.
+  const tsCeaCue3 = jasmine.objectContaining({
+    startTime: Util.closeTo(40.767, 0.001),
+    endTime: Util.closeTo(44.972, 0.001),
+    textAlign: Cue.textAlign.CENTER,
+    payload: 'These are 608 captions\n(top left)',
+  });
+
+  const tsCeaCue4 = jasmine.objectContaining({
+    startTime: Util.closeTo(45.305, 0.001),
+    endTime: Util.closeTo(51.979, 0.001),
+    textAlign: Cue.textAlign.CENTER,
+    payload: 'These are 608 captions\n(middle)',
+  });
+
+  const tsCeaCue5 = jasmine.objectContaining({
+    startTime: Util.closeTo(52.312, 0.001),
+    endTime: Util.closeTo(59.319, 0.001),
+    textAlign: Cue.textAlign.CENTER,
+    payload: 'These are 608 captions\n(bottom left)',
+  });
+
   /**
    * We use a fake text displayer so that we can check if CEA text is being
    * passed through the system correctly.
@@ -394,9 +454,14 @@ describe('MediaSourceEngine', () => {
     // platforms with native TS support.
     await mediaSourceEngine.init(initObject, /* forceTransmux= */ true);
     mediaSourceEngine.setSelectedClosedCaptionId('CC1');
+
     await append(ContentType.VIDEO, 0);
 
     expect(textDisplayer.appendSpy).toHaveBeenCalledTimes(3);
+
+    expect(textDisplayer.appendSpy).toHaveBeenCalledWith([tsCeaCue0]);
+    expect(textDisplayer.appendSpy).toHaveBeenCalledWith([tsCeaCue1]);
+    expect(textDisplayer.appendSpy).toHaveBeenCalledWith([tsCeaCue2]);
   });
 
   it('extracts CEA-708 captions from previous segment from hls', async () => {
@@ -413,9 +478,19 @@ describe('MediaSourceEngine', () => {
     mediaSourceEngine.setSelectedClosedCaptionId('CC1');
 
     await append(ContentType.VIDEO, 2);
+
+    expect(textDisplayer.appendSpy).toHaveBeenCalledTimes(3);
+    expect(textDisplayer.appendSpy).toHaveBeenCalledWith([tsCeaCue3]);
+    expect(textDisplayer.appendSpy).toHaveBeenCalledWith([tsCeaCue4]);
+    expect(textDisplayer.appendSpy).toHaveBeenCalledWith([tsCeaCue5]);
+
+    textDisplayer.appendSpy.calls.reset();
     await appendWithSeek(ContentType.VIDEO, 0);
 
-    expect(textDisplayer.appendSpy).toHaveBeenCalledTimes(6);
+    expect(textDisplayer.appendSpy).toHaveBeenCalledTimes(3);
+    expect(textDisplayer.appendSpy).toHaveBeenCalledWith([tsCeaCue0]);
+    expect(textDisplayer.appendSpy).toHaveBeenCalledWith([tsCeaCue1]);
+    expect(textDisplayer.appendSpy).toHaveBeenCalledWith([tsCeaCue2]);
   });
 
   it('buffers partial TS video segments in sequence mode', async () => {
@@ -468,7 +543,8 @@ describe('MediaSourceEngine', () => {
     mediaSourceEngine.setSelectedClosedCaptionId('CC1');
     await appendWithClosedCaptions(ContentType.VIDEO, 0);
 
-    expect(textDisplayer.appendSpy).toHaveBeenCalled();
+    expect(textDisplayer.appendSpy).toHaveBeenCalledTimes(1);
+    expect(textDisplayer.appendSpy).toHaveBeenCalledWith([mp4CeaCue0]);
   });
 
   it('extracts ID3 metadata from TS', async () => {

package/test/player_integration.js

@@ -970,7 +970,7 @@ describe('Player', () => {
       expect(getBufferedBehind()).toBe(20);  // Buffered to start still.
       video.currentTime = 50;
       await waitUntilBuffered(30);
-      expect(getBufferedBehind()).toBeLessThan(30);
+      expect(getBufferedBehind()).toBeLessThan(40);  // 30 + segment_size
 
       player.configure('streaming.bufferBehind', 10);
       // We only evict content when we append a segment, so increase the
@@ -997,7 +997,7 @@ describe('Player', () => {
     }
 
     async function waitUntilBuffered(amount) {
-      for (let i = 0; i < 25; i++) {
+      for (let i = 0; i < 50; i++) {
         // We buffer from an internal segment, so this shouldn't take long to
         // buffer.
         await Util.delay(0.1);  // eslint-disable-line no-await-in-loop
@@ -1005,7 +1005,14 @@ describe('Player', () => {
           return;
         }
       }
-      throw new Error('Timeout waiting to buffer');
+
+      const ranges =
+          shaka.media.TimeRangesUtils.getBufferedInfo(video.buffered);
+      const currentTime = video.currentTime;
+      const target = currentTime + amount;
+
+      throw new Error('Timeout waiting to buffer! ' +
+          JSON.stringify({ranges, currentTime, target}));
     }
   });  // describe('buffering')