shaka-player 4.4.3 → 4.6.0

package/test/util/stream_utils_unit.js

@@ -390,88 +390,6 @@ describe('StreamUtils', () => {
         });
   });
 
-  describe('filterVariantsByAudioChannelCount', () => {
-    it('chooses variants with preferred audio channels count', () => {
-      manifest = shaka.test.ManifestGenerator.generate((manifest) => {
-        manifest.addVariant(0, (variant) => {
-          variant.addAudio(0, (stream) => {
-            stream.channelsCount = 2;
-          });
-        });
-        manifest.addVariant(1, (variant) => {
-          variant.addAudio(1, (stream) => {
-            stream.channelsCount = 6;
-          });
-        });
-        manifest.addVariant(2, (variant) => {
-          variant.addAudio(2, (stream) => {
-            stream.channelsCount = 2;
-          });
-        });
-      });
-
-      const chosen = StreamUtils.filterVariantsByAudioChannelCount(
-          manifest.variants, 2);
-      expect(chosen.length).toBe(2);
-      expect(chosen[0]).toBe(manifest.variants[0]);
-      expect(chosen[1]).toBe(manifest.variants[2]);
-    });
-
-    it('chooses variants with largest audio channel count less than config' +
-        ' when no exact audio channel count match is possible', () => {
-      manifest = shaka.test.ManifestGenerator.generate((manifest) => {
-        manifest.addVariant(0, (variant) => {
-          variant.addAudio(0, (stream) => {
-            stream.channelsCount = 2;
-          });
-        });
-        manifest.addVariant(1, (variant) => {
-          variant.addAudio(1, (stream) => {
-            stream.channelsCount = 8;
-          });
-        });
-        manifest.addVariant(2, (variant) => {
-          variant.addAudio(2, (stream) => {
-            stream.channelsCount = 2;
-          });
-        });
-      });
-
-      const chosen = StreamUtils.filterVariantsByAudioChannelCount(
-          manifest.variants, 6);
-      expect(chosen.length).toBe(2);
-      expect(chosen[0]).toBe(manifest.variants[0]);
-      expect(chosen[1]).toBe(manifest.variants[2]);
-    });
-
-    it('chooses variants with fewest audio channels when none fit in the ' +
-        'config', () => {
-      manifest = shaka.test.ManifestGenerator.generate((manifest) => {
-        manifest.addVariant(0, (variant) => {
-          variant.addAudio(0, (stream) => {
-            stream.channelsCount = 6;
-          });
-        });
-        manifest.addVariant(1, (variant) => {
-          variant.addAudio(1, (stream) => {
-            stream.channelsCount = 8;
-          });
-        });
-        manifest.addVariant(2, (variant) => {
-          variant.addAudio(2, (stream) => {
-            stream.channelsCount = 6;
-          });
-        });
-      });
-
-      const chosen = StreamUtils.filterVariantsByAudioChannelCount(
-          manifest.variants, 2);
-      expect(chosen.length).toBe(2);
-      expect(chosen[0]).toBe(manifest.variants[0]);
-      expect(chosen[1]).toBe(manifest.variants[2]);
-    });
-  });
-
   describe('getDecodingInfosForVariants', () => {
     it('for multiplexd content', async () => {
       manifest = shaka.test.ManifestGenerator.generate((manifest) => {
@@ -634,9 +552,7 @@ describe('StreamUtils', () => {
         });
       });
 
-      const noVariant = null;
-      await shaka.util.StreamUtils.filterManifest(
-          fakeDrmEngine, noVariant, manifest);
+      await shaka.util.StreamUtils.filterManifest(fakeDrmEngine, manifest);
 
       // Covers a regression in which we would remove streams with codecs.
       // The last two streams should be removed because their full MIME types
@@ -671,9 +587,7 @@ describe('StreamUtils', () => {
         });
       });
 
-      const noVariant = null;
-      await shaka.util.StreamUtils.filterManifest(
-          fakeDrmEngine, noVariant, manifest);
+      await shaka.util.StreamUtils.filterManifest(fakeDrmEngine, manifest);
 
       // Covers a regression in which we would remove streams with codecs.
       // The first 4 streams should be there because they are always supported.
@@ -691,6 +605,36 @@ describe('StreamUtils', () => {
           jasmine.objectContaining({id: 5}));
     });
 
+    it('does not filter manifest when codec switching is enabled', async () => {
+      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';
+          });
+        });
+      });
+
+      const originalFilterManifestByCurrentVariant =
+          shaka.util.StreamUtils.filterManifestByCurrentVariant;
+
+      try {
+        const filterManifestByCurrentVariantSpy =
+          jasmine.createSpy('filterManifestByCurrentVariant');
+        shaka.util.StreamUtils.filterManifestByCurrentVariant =
+          shaka.test.Util.spyFunc(filterManifestByCurrentVariantSpy);
+
+        await shaka.util.StreamUtils.filterManifest(fakeDrmEngine, manifest);
+
+        expect(filterManifestByCurrentVariantSpy).not.toHaveBeenCalled();
+      } finally {
+        shaka.util.StreamUtils.filterManifestByCurrentVariant =
+          originalFilterManifestByCurrentVariant;
+      }
+    });
+
     it('filters transport streams', async () => {
       manifest = shaka.test.ManifestGenerator.generate((manifest) => {
         manifest.addVariant(0, (variant) => {
@@ -704,8 +648,7 @@ describe('StreamUtils', () => {
         });
       });
 
-      await shaka.util.StreamUtils.filterManifest(
-          fakeDrmEngine, /* currentVariant= */ null, manifest);
+      await shaka.util.StreamUtils.filterManifest(fakeDrmEngine, manifest);
 
       // Covers a regression in which we would remove streams with codecs.
       // The last two streams should be removed because their full MIME types
@@ -731,8 +674,7 @@ describe('StreamUtils', () => {
         });
       });
 
-      await shaka.util.StreamUtils.filterManifest(
-          fakeDrmEngine, /* currentVariant= */ null, manifest);
+      await shaka.util.StreamUtils.filterManifest(fakeDrmEngine, manifest);
       expect(manifest.variants.length).toBe(1);
     });
 
@@ -748,8 +690,7 @@ describe('StreamUtils', () => {
         });
       });
 
-      await shaka.util.StreamUtils.filterManifest(
-          fakeDrmEngine, /* currentVariant= */ null, manifest);
+      await shaka.util.StreamUtils.filterManifest(fakeDrmEngine, manifest);
 
       expect(manifest.variants.length).toBe(1);
     });
@@ -771,8 +712,7 @@ describe('StreamUtils', () => {
         });
       });
 
-      await shaka.util.StreamUtils.filterManifest(
-          fakeDrmEngine, /* currentVariant= */ null, manifest);
+      await shaka.util.StreamUtils.filterManifest(fakeDrmEngine, manifest);
 
       expect(manifest.variants.length).toBe(2);
     });
@@ -794,8 +734,7 @@ describe('StreamUtils', () => {
         });
       });
 
-      await shaka.util.StreamUtils.filterManifest(
-          fakeDrmEngine, /* currentVariant= */ null, manifest);
+      await shaka.util.StreamUtils.filterManifest(fakeDrmEngine, manifest);
 
       expect(manifest.variants.length).toBe(2);
     });
@@ -812,149 +751,249 @@ describe('StreamUtils', () => {
         });
       });
 
-      await shaka.util.StreamUtils.filterManifest(
-          fakeDrmEngine, /* currentVariant= */ null, manifest);
+      await shaka.util.StreamUtils.filterManifest(fakeDrmEngine, manifest);
 
       expect(manifest.variants.length).toBe(1);
     });
   });
 
   describe('chooseCodecsAndFilterManifest', () => {
-    const avc1Codecs = 'avc1.640028';
-    const vp09Codecs = 'vp09.00.40.08.00.02.02.02.00';
-
-    const addVariant1080Avc1 = (manifest) => {
+    const addVariant720Avc1 = (manifest) => {
       manifest.addVariant(0, (variant) => {
         variant.bandwidth = 5058558;
         variant.addAudio(1, (stream) => {
           stream.bandwidth = 129998;
-          stream.codecs = 'opus';
+          stream.mime('audio/mp4', 'mp4a.40.2');
         });
         variant.addVideo(2, (stream) => {
           stream.bandwidth = 4928560;
-          stream.codecs = avc1Codecs;
-          stream.size(1920, 1080);
+          stream.size(1280, 720);
+          stream.mime('video/mp4', 'avc1.640028');
         });
       });
     };
 
-    const addVariant1080Vp9 = (manifest) => {
+    const addVariant720Vp9 = (manifest) => {
       manifest.addVariant(3, (variant) => {
         variant.bandwidth = 4911000;
         variant.addAudio(4, (stream) => {
           stream.bandwidth = 129998;
-          stream.codecs = 'vorbis';
+          stream.mime('audio/webm', 'vorbis');
         });
         variant.addVideo(5, (stream) => {
           stream.bandwidth = 4781002;
-          stream.codecs = vp09Codecs;
-          stream.size(1920, 1080);
+          stream.size(1280, 720);
+          stream.mime('video/webm', 'vp9');
         });
       });
     };
 
-    const addVariant2160Vp9 = (manifest) => {
+    const addVariant1080Vp9 = (manifest) => {
       manifest.addVariant(6, (variant) => {
         variant.bandwidth = 10850316;
-        variant.addAudio(7, (stream) => {
+        variant.addAudio(1, (stream) => {
           stream.bandwidth = 129998;
-          stream.codecs = 'opus';
+          stream.mime('audio/mp4', 'mp4a.40.2');
         });
         variant.addVideo(8, (stream) => {
           stream.bandwidth = 10784324;
-          stream.codecs = vp09Codecs;
-          stream.size(3840, 2160);
+          stream.size(1920, 1080);
+          stream.mime('video/webm', 'vp9');
         });
       });
     };
 
+    it('should filter variants by the best available bandwidth' +
+        ' for video resolution', () => {
+      manifest = shaka.test.ManifestGenerator.generate((manifest) => {
+        manifest.addVariant(0, (variant) => {
+          variant.bandwidth = 4058558;
+          variant.addVideo(1, (stream) => {
+            stream.bandwidth = 300000;
+            stream.size(10, 10);
+          });
+        });
+        manifest.addVariant(2, (variant) => {
+          variant.bandwidth = 4781002;
+          variant.addVideo(3, (stream) => {
+            stream.bandwidth = 400000;
+            stream.size(10, 10);
+          });
+        });
+        manifest.addVariant(4, (variant) => {
+          variant.addVideo(5, (stream) => {
+            stream.bandwidth = 500000;
+            stream.size(20, 20);
+          });
+        });
+        manifest.addVariant(6, (variant) => {
+          variant.addVideo(7, (stream) => {
+            stream.bandwidth = 600000;
+            stream.size(20, 20);
+          });
+        });
+      });
+
+      shaka.util.StreamUtils.chooseCodecsAndFilterManifest(manifest,
+          /* preferredVideoCodecs= */[],
+          /* preferredAudioCodecs= */[],
+          /* preferredDecodingAttributes= */[]);
+
+      expect(manifest.variants.length).toBe(2);
+      expect(manifest.variants.every((v) => [300000, 500000].includes(
+          v.video.bandwidth))).toBeTruthy();
+    });
+
+    it('should filter variants by the best available bandwidth' +
+    ' for audio language', () => {
+      // This test is flaky in some Tizen devices, due to codec restrictions.
+      if (shaka.util.Platform.isTizen()) {
+        pending('Skip flaky test in Tizen');
+      }
+      manifest = shaka.test.ManifestGenerator.generate((manifest) => {
+        manifest.addVariant(0, (variant) => {
+          variant.bandwidth = 4058558;
+          variant.addAudio(1, (stream) => {
+            stream.bandwidth = 100000;
+            stream.language = 'en';
+            stream.mime('audio/mp4', 'mp4a.40.2');
+          });
+        });
+        manifest.addVariant(2, (variant) => {
+          variant.bandwidth = 4781002;
+          variant.addAudio(3, (stream) => {
+            stream.bandwidth = 200000;
+            stream.language = 'en';
+            stream.mime('audio/mp4', 'flac');
+          });
+        });
+        manifest.addVariant(4, (variant) => {
+          variant.addAudio(5, (stream) => {
+            stream.bandwidth = 100000;
+            stream.language = 'es';
+            stream.mime('audio/mp4', 'mp4a.40.2');
+          });
+        });
+        manifest.addVariant(6, (variant) => {
+          variant.addAudio(7, (stream) => {
+            stream.bandwidth = 500000;
+            stream.language = 'es';
+            stream.mime('audio/mp4', 'flac');
+          });
+        });
+      });
+
+      shaka.util.StreamUtils.chooseCodecsAndFilterManifest(manifest,
+      /* preferredVideoCodecs= */[],
+          /* preferredAudioCodecs= */[],
+          /* preferredDecodingAttributes= */[]);
+
+      expect(manifest.variants.length).toBe(2);
+      expect(manifest.variants.every((v) => v.audio.bandwidth == 100000))
+          .toBeTruthy();
+    });
+
+    it('should allow multiple codecs for codec switching', () => {
+      if (!MediaSource.isTypeSupported('video/webm; codecs="vp9"')) {
+        pending('Codec VP9 is not supported by the platform.');
+      }
+      if (!MediaSource.isTypeSupported('video/webm; codecs="vorbis"')) {
+        pending('Codec vorbis is not supported by the platform.');
+      }
+      // This test is flaky in some Tizen devices, due to codec restrictions.
+      if (shaka.util.Platform.isTizen()) {
+        pending('Skip flaky test in Tizen');
+      }
+      manifest = shaka.test.ManifestGenerator.generate((manifest) => {
+        addVariant720Avc1(manifest);
+        addVariant720Vp9(manifest);
+        addVariant1080Vp9(manifest);
+      });
+
+      manifest.variants[0].video.bandwidth = 1;
+
+      shaka.util.StreamUtils.chooseCodecsAndFilterManifest(manifest,
+          /* preferredVideoCodecs= */[],
+          /* preferredAudioCodecs= */[],
+          /* preferredDecodingAttributes= */[]);
+
+      expect(manifest.variants.length).toBe(2);
+      expect(manifest.variants[0].video.codecs)
+          .not.toBe(manifest.variants[1].video.codecs);
+    });
+
     it('chooses preferred audio and video codecs', () => {
+      if (!MediaSource.isTypeSupported('video/webm; codecs="vp9"')) {
+        pending('Codec VP9 is not supported by the platform.');
+      }
+      if (!MediaSource.isTypeSupported('video/webm; codecs="vorbis"')) {
+        pending('Codec vorbis is not supported by the platform.');
+      }
       manifest = shaka.test.ManifestGenerator.generate((manifest) => {
-        addVariant1080Avc1(manifest);
+        addVariant720Avc1(manifest);
+        addVariant720Vp9(manifest);
         addVariant1080Vp9(manifest);
-        addVariant2160Vp9(manifest);
       });
       const variants =
           shaka.util.StreamUtils.choosePreferredCodecs(manifest.variants,
-              /* preferredVideoCodecs= */['vp09'],
-              /* preferredAudioCodecs= */['opus']);
+              /* preferredVideoCodecs= */['vp9'],
+              /* preferredAudioCodecs= */['mp4a']);
 
       expect(variants.length).toBe(1);
-      expect(variants[0].video.codecs).toBe(vp09Codecs);
-      expect(variants[0].audio.codecs).toBe('opus');
+      expect(variants[0].video.codecs).toBe('vp9');
+      expect(variants[0].audio.codecs).toBe('mp4a.40.2');
     });
 
     it('chooses preferred video codecs', () => {
+      if (!MediaSource.isTypeSupported('video/webm; codecs="vp9"')) {
+        pending('Codec VP9 is not supported by the platform.');
+      }
+      if (!MediaSource.isTypeSupported('video/webm; codecs="vorbis"')) {
+        pending('Codec vorbis is not supported by the platform.');
+      }
       // If no preferred audio codecs is specified or can be found, choose the
       // variants with preferred video codecs.
       manifest = shaka.test.ManifestGenerator.generate((manifest) => {
-        addVariant1080Avc1(manifest);
+        addVariant720Avc1(manifest);
+        addVariant720Vp9(manifest);
         addVariant1080Vp9(manifest);
-        addVariant2160Vp9(manifest);
       });
       const variants =
           shaka.util.StreamUtils.choosePreferredCodecs(manifest.variants,
-              /* preferredVideoCodecs= */['vp09'],
+              /* preferredVideoCodecs= */['vp9'],
               /* preferredAudioCodecs= */[]);
 
       expect(variants.length).toBe(2);
-      expect(variants[0].video.codecs).toBe(vp09Codecs);
+      expect(variants[0].video.codecs).toBe('vp9');
       expect(variants[0].audio.codecs).toBe('vorbis');
-      expect(variants[1].video.codecs).toBe(vp09Codecs);
-      expect(variants[1].audio.codecs).toBe('opus');
+      expect(variants[1].video.codecs).toBe('vp9');
+      expect(variants[1].audio.codecs).toBe('mp4a.40.2');
     });
 
     it('chooses preferred audio codecs', () => {
+      if (!MediaSource.isTypeSupported('video/webm; codecs="vp9"')) {
+        pending('Codec VP9 is not supported by the platform.');
+      }
+      if (!MediaSource.isTypeSupported('video/webm; codecs="vorbis"')) {
+        pending('Codec vorbis is not supported by the platform.');
+      }
       // If no preferred video codecs is specified or can be found, choose the
       // variants with preferred audio codecs.
       manifest = shaka.test.ManifestGenerator.generate((manifest) => {
-        addVariant1080Avc1(manifest);
+        addVariant720Avc1(manifest);
+        addVariant720Vp9(manifest);
         addVariant1080Vp9(manifest);
-        addVariant2160Vp9(manifest);
       });
       const variants =
           shaka.util.StreamUtils.choosePreferredCodecs(manifest.variants,
               /* preferredVideoCodecs= */['foo'],
-              /* preferredAudioCodecs= */['opus']);
+              /* preferredAudioCodecs= */['mp4a.40.2']);
 
       expect(variants.length).toBe(2);
-      expect(variants[0].video.codecs).toBe(avc1Codecs);
-      expect(variants[0].audio.codecs).toBe('opus');
-      expect(variants[1].video.codecs).toBe(vp09Codecs);
-      expect(variants[1].audio.codecs).toBe('opus');
-    });
-
-    it('chooses variants with different sizes (density) by codecs', () => {
-      manifest = shaka.test.ManifestGenerator.generate((manifest) => {
-        addVariant1080Avc1(manifest);
-        addVariant1080Vp9(manifest);
-        addVariant2160Vp9(manifest);
-      });
-
-      shaka.util.StreamUtils.chooseCodecsAndFilterManifest(manifest,
-          /* preferredVideoCodecs= */[],
-          /* preferredAudioCodecs= */[],
-          /* preferredAudioChannelCount= */2,
-          /* preferredDecodingAttributes= */[]);
-
-      expect(manifest.variants.length).toBe(1);
-      expect(manifest.variants[0].video.codecs).toBe(vp09Codecs);
-    });
-
-    it('chooses variants with same sizes (density) by codecs', () => {
-      manifest = shaka.test.ManifestGenerator.generate((manifest) => {
-        addVariant1080Avc1(manifest);
-        addVariant1080Vp9(manifest);
-      });
-
-      shaka.util.StreamUtils.chooseCodecsAndFilterManifest(manifest,
-          /* preferredVideoCodecs= */[],
-          /* preferredAudioCodecs= */[],
-          /* preferredAudioChannelCount= */2,
-          /* preferredDecodingAttributes= */[]);
-
-      expect(manifest.variants.length).toBe(1);
-      expect(manifest.variants[0].video.codecs).toBe(vp09Codecs);
+      expect(variants[0].video.codecs).toBe('avc1.640028');
+      expect(variants[0].audio.codecs).toBe('mp4a.40.2');
+      expect(variants[1].video.codecs).toBe('vp9');
+      expect(variants[1].audio.codecs).toBe('mp4a.40.2');
     });
 
     it('chooses variants by decoding attributes', async () => {
@@ -994,7 +1033,6 @@ describe('StreamUtils', () => {
       shaka.util.StreamUtils.chooseCodecsAndFilterManifest(manifest,
           /* preferredVideoCodecs= */[],
           /* preferredAudioCodecs= */[],
-          /* preferredAudioChannelCount= */2,
           /* preferredDecodingAttributes= */
           [shaka.util.StreamUtils.DecodingAttributes.SMOOTH]);
       // 2 video codecs are smooth. Choose the one with the lowest bandwidth.

package/test/util/ts_parser_unit.js

@@ -7,6 +7,7 @@
 describe('TsParser', () => {
   const Util = shaka.test.Util;
   const BufferUtils = shaka.util.BufferUtils;
+  const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
   it('probes a TS segment', async () => {
     const responses = await Promise.all([
@@ -59,9 +60,8 @@ describe('TsParser', () => {
     ]);
     const tsSegment = BufferUtils.toUint8(responses[0]);
     const starttime = new shaka.util.TsParser().parse(tsSegment)
-        .getStartTime();
-    expect(starttime.audio).toBeCloseTo(90019.586, 3);
-    expect(starttime.video).toBe(null);
+        .getStartTime(ContentType.AUDIO);
+    expect(starttime).toBeCloseTo(90019.586, 3);
   });
 
   it('get the codecs from a TS segment', async () => {

package/third_party/closure-uri/uri.js

@@ -8,7 +8,7 @@
  *
  * Use new goog.Uri(string) to parse a URI string.
  *
- * e.g: <code>var myUri = new goog.Uri(window.location);</code>
+ * e.g.: <code>var myUri = new goog.Uri(window.location);</code>
  *
  * Implements RFC 3986 for parsing/formatting URIs.
  * http://www.ietf.org/rfc/rfc3986.txt
@@ -830,6 +830,18 @@ goog.Uri.QueryData.prototype.add = function(key, value) {
 };
 
 
+/**
+ * Get the values from a key.
+ *
+ * @param {string} key Name.
+ * @return {Array.<string>}
+ */
+ goog.Uri.QueryData.prototype.get = function(key) {
+  this.ensureKeyMapInitialized_();
+  return this.keyMap_[key] || [];
+};
+
+
 /**
  * @return {string} Encoded query string.
  * @override

package/ui/audio_language_selection.js

@@ -68,7 +68,8 @@ shaka.ui.AudioLanguageSelection = class extends shaka.ui.SettingsMenu {
     shaka.ui.LanguageUtils.updateTracks(tracks, this.menu,
         (track) => this.onAudioTrackSelected_(track),
         /* updateChosen= */ true, this.currentSelection, this.localization,
-        this.controls.getConfig().trackLabelFormat);
+        this.controls.getConfig().trackLabelFormat,
+        this.controls.getConfig().showAudioChannelCountVariants);
     shaka.ui.Utils.focusOnTheChosenItem(this.menu);
 
     this.controls.dispatchEvent(
@@ -89,7 +90,13 @@ shaka.ui.AudioLanguageSelection = class extends shaka.ui.SettingsMenu {
    * @private
    */
   onAudioTrackSelected_(track) {
-    this.player.selectAudioLanguage(track.language, track.roles[0]);
+    if (track.channelsCount &&
+        this.controls.getConfig().showAudioChannelCountVariants) {
+      this.player.selectAudioLanguage(
+          track.language, track.roles[0], track.channelsCount);
+    } else {
+      this.player.selectAudioLanguage(track.language, track.roles[0]);
+    }
   }