shaka-player 4.3.0 → 4.3.1

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/polyfill/media_capabilities_unit.js

@@ -0,0 +1,259 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+describe('MediaCapabilities', () => {
+  const Util = shaka.test.Util;
+  const originalCast = window['cast'];
+  const originalVendor = navigator.vendor;
+  const originalUserAgent = navigator.userAgent;
+  const originalRequestMediaKeySystemAccess =
+    navigator.requestMediaKeySystemAccess;
+  const originalMediaCapabilities = navigator.mediaCapabilities;
+  const supportMap = shaka.media.Capabilities.MediaSourceTypeSupportMap;
+
+  /** @type {MediaDecodingConfiguration} */
+  let mockDecodingConfig;
+  /** @type {!jasmine.Spy} */
+  let mockCanDisplayType;
+
+  beforeAll(() => {
+    Object.defineProperty(window['navigator'],
+        'userAgent', {
+          value: 'unknown', configurable: true,
+          writable: true,
+        });
+    Object.defineProperty(window['navigator'],
+        'vendor', {
+          value: 'unknown', configurable: true,
+          writable: true,
+        });
+    Object.defineProperty(window['navigator'],
+        'requestMediaKeySystemAccess', {
+          value: 'unknown', configurable: true,
+          writable: true,
+        });
+    Object.defineProperty(window['navigator'],
+        'mediaCapabilities', {
+          value: undefined, configurable: true,
+          writable: true,
+        });
+  });
+
+  beforeEach(() => {
+    mockDecodingConfig = {
+      audio: {
+        bitrate: 100891,
+        channels: 2,
+        contentType: 'audio/mp4; codecs="mp4a.40.2"',
+        samplerate: 48000,
+        spatialRendering: false,
+      },
+      keySystemConfiguration: {
+        audio: {robustness: 'SW_SECURE_CRYPTO'},
+        distinctiveIdentifier: 'optional',
+        initDataType: 'cenc',
+        keySystem: 'com.widevine.alpha',
+        persistentState: 'optional',
+        sessionTypes: ['temporary'],
+        video: {robustness: 'SW_SECURE_CRYPTO'},
+      },
+      type: 'media-source',
+      video: {
+        bitrate: 349265,
+        contentType: 'video/mp4; codecs="avc1.4D4015"',
+        framerate: 23.976023976023978,
+        height: 288,
+        width: 512,
+      },
+    };
+    shaka.polyfill.MediaCapabilities.memoizedMediaKeySystemAccessRequests_ = {};
+
+    mockCanDisplayType = jasmine.createSpy('canDisplayType');
+    mockCanDisplayType.and.returnValue(false);
+  });
+
+  afterEach(() => {
+    window['cast'] = originalCast;
+  });
+
+  afterAll(() => {
+    window['cast'] = originalCast;
+    Object.defineProperty(window['navigator'],
+        'userAgent', {value: originalUserAgent});
+    Object.defineProperty(window['navigator'],
+        'vendor', {value: originalVendor});
+    Object.defineProperty(window['navigator'],
+        'requestMediaKeySystemAccess',
+        {value: originalRequestMediaKeySystemAccess});
+    Object.defineProperty(window['navigator'],
+        'mediaCapabilities', {value: originalMediaCapabilities});
+  });
+
+  describe('install', () => {
+    it('should define decoding info method', () => {
+      shaka.polyfill.MediaCapabilities.install();
+
+      expect(navigator.mediaCapabilities.decodingInfo).toBeDefined();
+    });
+  });
+
+  describe('decodingInfo', () => {
+    it('should check codec support when MediaDecodingConfiguration.type ' +
+      'is "media-source"', () => {
+      expect(window['MediaSource']['isTypeSupported']).toBeDefined();
+      shaka.polyfill.MediaCapabilities.install();
+      navigator.mediaCapabilities.decodingInfo(mockDecodingConfig);
+
+      expect(supportMap.has(mockDecodingConfig.video.contentType)).toBe(true);
+      expect(supportMap.has(mockDecodingConfig.audio.contentType)).toBe(true);
+    });
+
+    it('should check codec support when MediaDecodingConfiguration.type ' +
+      'is "file"', () => {
+      const supportsMediaTypeSpy =
+          spyOn(shaka['util']['Platform'],
+              'supportsMediaType').and.returnValue(true);
+      mockDecodingConfig.type = 'file';
+      shaka.polyfill.MediaCapabilities.install();
+      navigator.mediaCapabilities.decodingInfo(mockDecodingConfig);
+
+      expect(supportsMediaTypeSpy).toHaveBeenCalledTimes(2);
+      expect(supportsMediaTypeSpy).toHaveBeenCalledWith(
+          mockDecodingConfig.video.contentType,
+      );
+      expect(supportsMediaTypeSpy).toHaveBeenCalledWith(
+          mockDecodingConfig.audio.contentType,
+      );
+    });
+
+    it('should check MediaKeySystem when keySystemConfiguration is present',
+        async () => {
+          const mockResult = {mockKeySystemAccess: 'mockKeySystemAccess'};
+          spyOn(window['MediaSource'], 'isTypeSupported').and.returnValue(true);
+          const requestKeySystemAccessSpy =
+          spyOn(window['navigator'],
+              'requestMediaKeySystemAccess').and.returnValue(mockResult);
+
+          shaka.polyfill.MediaCapabilities.install();
+          const result = await navigator.mediaCapabilities
+              .decodingInfo(mockDecodingConfig);
+
+          expect(requestKeySystemAccessSpy).toHaveBeenCalledWith(
+              'com.widevine.alpha',
+              [{
+                audioCapabilities: [
+                  {
+                    robustness: 'SW_SECURE_CRYPTO',
+                    contentType: 'audio/mp4; codecs="mp4a.40.2"',
+                  },
+                ],
+                distinctiveIdentifier: 'optional',
+                initDataTypes: ['cenc'],
+                persistentState: 'optional',
+                sessionTypes: ['temporary'],
+                videoCapabilities: [{
+                  robustness: 'SW_SECURE_CRYPTO',
+                  contentType: 'video/mp4; codecs="avc1.4D4015"',
+                }],
+              }],
+          );
+          expect(result.keySystemAccess).toEqual(mockResult);
+        });
+
+    it('throws when the cast namespace is not available', async () => {
+      // Temporarily remove window.cast to trigger error. It's restored after
+      // every test.
+      delete window['cast'];
+
+      const isChromecastSpy =
+          spyOn(shaka['util']['Platform'],
+              'isChromecast').and.returnValue(true);
+      const expected = Util.jasmineError(new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.CAST,
+          shaka.util.Error.Code.CAST_API_UNAVAILABLE));
+      const isTypeSupportedSpy =
+          spyOn(window['MediaSource'], 'isTypeSupported').and.returnValue(true);
+
+      shaka.polyfill.MediaCapabilities.install();
+      await expectAsync(
+          navigator.mediaCapabilities.decodingInfo(mockDecodingConfig))
+          .toBeRejectedWith(expected);
+
+      expect(isTypeSupportedSpy).not.toHaveBeenCalled();
+      // 1 (during install()) + 1 (for video config check).
+      expect(isChromecastSpy).toHaveBeenCalledTimes(2);
+    });
+
+    it('falls back to isTypeSupported() when canDisplayType() missing',
+        async () => {
+          // We only set the cast namespace, but not the canDisplayType() API.
+          window['cast'] = {};
+          const isChromecastSpy =
+              spyOn(shaka['util']['Platform'],
+                  'isChromecast').and.returnValue(true);
+          expect(window['MediaSource']['isTypeSupported']).toBeDefined();
+
+          shaka.polyfill.MediaCapabilities.install();
+          await navigator.mediaCapabilities.decodingInfo(mockDecodingConfig);
+
+          expect(mockCanDisplayType).not.toHaveBeenCalled();
+          // 1 (during install()) + 1 (for video config check).
+          expect(isChromecastSpy).toHaveBeenCalledTimes(2);
+          // 1 (fallback in canCastDisplayType()) +
+          // 1 (mockDecodingConfig.audio).
+          expect(supportMap.has(mockDecodingConfig.video.contentType))
+              .toBe(true);
+          expect(supportMap.has(mockDecodingConfig.audio.contentType))
+              .toBe(true);
+        });
+
+    it('should use cast.__platform__.canDisplayType for "supported" field ' +
+        'when platform is Cast', async () => {
+      // We're using quotes to access window.cast because the compiler
+      // knows about lots of Cast-specific APIs we aren't mocking.  We
+      // don't need this mock strictly type-checked.
+      window['cast'] = {
+        __platform__: {canDisplayType: mockCanDisplayType},
+      };
+      const isChromecastSpy =
+          spyOn(shaka['util']['Platform'],
+              'isChromecast').and.returnValue(true);
+      expect(window['MediaSource']['isTypeSupported']).toBeDefined();
+
+      // Tests an HDR stream's extended MIME type is correctly provided.
+      mockDecodingConfig.video.transferFunction = 'pq';
+      mockDecodingConfig.video.contentType =
+          'video/mp4; codecs="hev1.2.4.L153.B0"';
+      // Round to a whole number since we can't rely on number => string
+      // conversion precision on all devices.
+      mockDecodingConfig.video.framerate = 24;
+
+      const chromecastType =
+          'video/mp4; ' +
+          'codecs="hev1.2.4.L153.B0"; ' +
+          'width=512; ' +
+          'height=288; ' +
+          'framerate=24; ' +
+          'eotf=smpte2084';
+      mockCanDisplayType.and.callFake((type) => {
+        expect(type).toBe(chromecastType);
+        supportMap.set(type, true);
+        return true;
+      });
+
+      shaka.polyfill.MediaCapabilities.install();
+      await navigator.mediaCapabilities.decodingInfo(mockDecodingConfig);
+
+      // 1 (during install()) + 1 (for video config check).
+      expect(isChromecastSpy).toHaveBeenCalledTimes(2);
+      // 1 (mockDecodingConfig.audio).
+      expect(supportMap.has(chromecastType)).toBe(true);
+      // Called once in canCastDisplayType.
+      expect(mockCanDisplayType).toHaveBeenCalledTimes(1);
+    });
+  });
+});

package/test/polyfill/patchedmediakeys_apple_unit.js

@@ -1,3 +1,9 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
 describe('PatchedMediaKeys_Apple', () => {
   const PatchedMediaKeysApple = shaka.polyfill.PatchedMediaKeysApple;
   let originalMediaKeys;