shaka-player 4.3.11 → 4.4.1

package/test/player_unit.js

@@ -6,7 +6,6 @@
 
 describe('Player', () => {
   const ContentType = shaka.util.ManifestParserUtils.ContentType;
-  const StreamUtils = shaka.util.StreamUtils;
   const Util = shaka.test.Util;
 
   const originalLogError = shaka.log.error;
@@ -30,8 +29,6 @@ describe('Player', () => {
   let player;
   /** @type {!shaka.test.FakeAbrManager} */
   let abrManager;
-  /** @type {function(!shaka.util.Error)} */
-  let onErrorCallback;
 
   /** @type {!shaka.test.FakeNetworkingEngine} */
   let networkingEngine;
@@ -138,8 +135,7 @@ describe('Player', () => {
         ended: jasmine.createSpy('ended').and.returnValue(false),
       };
 
-      player.createDrmEngine = ({onError}) => {
-        onErrorCallback = onError;
+      player.createDrmEngine = () => {
         return drmEngine;
       };
       player.createNetworkingEngine = () => networkingEngine;
@@ -343,164 +339,376 @@ describe('Player', () => {
       });
     });
 
-    describe('onError and tryToRecoverFromError', () => {
-      const httpError = new shaka.util.Error(
-          shaka.util.Error.Severity.RECOVERABLE,
-          shaka.util.Error.Category.NETWORK,
-          shaka.util.Error.Code.HTTP_ERROR);
-      const nonHttpError = new shaka.util.Error(
-          shaka.util.Error.Severity.RECOVERABLE,
-          shaka.util.Error.Category.NETWORK,
-          shaka.util.Error.Code.TIMEOUT);
+    describe('disableStream', () => {
+      /** @type {function(function(), number)} */
+      let realSetTimeout;
+      /** @type {number} */
+      let disableTimeInSeconds;
       /** @type {?jasmine.Spy} */
-      let dispatchEventSpy;
+      let getBufferedInfoSpy;
+
+      beforeAll(() => {
+        realSetTimeout = window.setTimeout;
+        jasmine.clock().install();
+        jasmine.clock().mockDate();
+      });
+
+      afterAll(() => {
+        jasmine.clock().uninstall();
+      });
+
+      beforeEach(() => {
+        disableTimeInSeconds = 30;
+        getBufferedInfoSpy = spyOn(player, 'getBufferedInfo')
+            .and.returnValue(bufferedInfo);
+      });
+
+      async function runTest(variantIndex, streamType, expectedStatus) {
+        await player.load(fakeManifestUri, 0, fakeMimeType);
+
+        const stream =
+            /** @type {shaka.extern.Stream} */
+            (manifest.variants[variantIndex][streamType]);
+        const status = player.disableStream(stream, 10);
+
+        expect(status).toBe(expectedStatus);
+      }
 
-      beforeEach(async () => {
+      function multiVariantManifest() {
         manifest = shaka.test.ManifestGenerator.generate((manifest) => {
-          manifest.addVariant(11, (variant) => {
-            variant.addAudio(2);
+          manifest.addVariant(0, (variant) => {
+            variant.addAudio(1, (stream) => {
+              stream.mime('audio/mp4', 'mp4a.40.2');
+              stream.language = 'en';
+            });
+            variant.addVideo(2);
+          });
+          manifest.addVariant(1, (variant) => {
+            variant.addExistingStream(1);
             variant.addVideo(3);
           });
-          manifest.addVariant(12, (variant) => {
-            variant.addAudio(4);
-            variant.addVideo(5);
+          manifest.addVariant(2, (variant) => {
+            variant.addExistingStream(1);
+            variant.addVideo(4);
           });
         });
+      }
+
+      it('disable and restore stream after configured time', async () => {
+        multiVariantManifest();
+
         await player.load(fakeManifestUri, 0, fakeMimeType);
-        dispatchEventSpy = spyOn(player, 'dispatchEvent').and.returnValue(true);
-      });
 
-      afterEach(() => {
-        dispatchEventSpy.calls.reset();
+        const variant = manifest.variants[0];
+        const videoStream = /** @type {shaka.extern.Stream} */ (variant.video);
+
+        player.disableStream(videoStream, disableTimeInSeconds);
+
+        expect(variant.disabledUntilTime).toBeGreaterThan(Date.now()/1000);
+
+        await shaka.test.Util.fakeEventLoop(disableTimeInSeconds);
+
+        expect(variant.disabledUntilTime).toBe(0);
       });
 
-      it('does not handle non NETWORK HTTP_ERROR', () => {
-        onErrorCallback(nonHttpError);
-        expect(nonHttpError.handled).toBeFalsy();
-        expect(player.dispatchEvent).toHaveBeenCalled();
+      it('does not restore stream if disabled time did not elapsed',
+          async () => {
+            multiVariantManifest();
+
+            await player.load(fakeManifestUri, 0, fakeMimeType);
+
+            const variant = manifest.variants[0];
+            const videoStream =
+            /** @type {shaka.extern.Stream} */ (variant.video);
+
+            player.disableStream(videoStream, disableTimeInSeconds);
+
+            expect(variant.disabledUntilTime).toBeGreaterThan(Date.now()/1000);
+
+            await shaka.test.Util.fakeEventLoop(disableTimeInSeconds - 5);
+
+            expect(variant.disabledUntilTime).toBeGreaterThan(Date.now()/1000);
+          });
+
+      it('updates abrManager and switch after disabling a stream', async () => {
+        multiVariantManifest();
+
+        await player.load(fakeManifestUri, 0, fakeMimeType);
+
+        const variantCount = manifest.variants.length;
+        const variant = manifest.variants[0];
+        const videoStream =
+        /** @type {shaka.extern.Stream} */ (variant.video);
+
+        player.disableStream(videoStream, disableTimeInSeconds);
+
+        // Disabled as expected?
+        expect(variant.disabledUntilTime).toBeGreaterThan(Date.now()/1000);
+        expect(abrManager.setVariants).toHaveBeenCalled();
+        expect(abrManager.chooseVariant).toHaveBeenCalled();
+        expect(streamingEngine.switchVariant).toHaveBeenCalled();
+        expect(getBufferedInfoSpy).toHaveBeenCalled();
+
+        const updatedVariants =
+            abrManager.setVariants.calls.mostRecent().args[0];
+        const alternateVariant =
+            streamingEngine.switchVariant.calls.mostRecent().args[0];
+        const safeMargin =
+            streamingEngine.switchVariant.calls.mostRecent().args[2];
+        const forceSwitch =
+            streamingEngine.switchVariant.calls.mostRecent().args[3];
+        const fromAdaptation =
+            streamingEngine.switchVariant.calls.mostRecent().args[4];
+
+        expect(updatedVariants.length).toBe(variantCount - 1);
+        expect(alternateVariant.video).not.toEqual(variant.video);
+        expect(safeMargin).toBe(14);
+        expect(forceSwitch).toBeTruthy();
+        expect(fromAdaptation).toBeFalsy();
+      });
+
+      it('updates abrManager and switch after restoring a stream', async () => {
+        multiVariantManifest();
+
+        await player.load(fakeManifestUri, 0, fakeMimeType);
+
+        const variantCount = manifest.variants.length;
+        const variant = manifest.variants[0];
+        const videoStream = /** @type {shaka.extern.Stream} */ (variant.video);
+
+        player.disableStream(videoStream, disableTimeInSeconds);
+
+        await shaka.test.Util.fakeEventLoop(disableTimeInSeconds);
+
+        // Restored as expected?
+        expect(variant.disabledUntilTime).toBe(0);
+        expect(abrManager.setVariants).toHaveBeenCalled();
+        expect(abrManager.chooseVariant).toHaveBeenCalled();
+        expect(streamingEngine.switchVariant).toHaveBeenCalled();
+
+        const updatedVariants =
+            abrManager.setVariants.calls.mostRecent().args[0];
+        const forceSwitch =
+            streamingEngine.switchVariant.calls.mostRecent().args[3];
+        const fromAdaptation =
+            streamingEngine.switchVariant.calls.mostRecent().args[4];
+
+        expect(updatedVariants.length).toBe(variantCount);
+        expect(forceSwitch).toBeFalsy();
+        expect(fromAdaptation).toBeFalsy();
       });
 
-      describe('when config.streaming.maxDisabledTime is 0', () => {
-        it('does not handle NETWORK HTTP_ERROR', () => {
-          player.configure({streaming: {maxDisabledTime: 0}});
-          httpError.handled = false;
-          onErrorCallback(httpError);
-          expect(httpError.handled).toBeFalsy();
-          expect(player.dispatchEvent).toHaveBeenCalled();
+      it('disables all variants containing stream', async () => {
+        manifest = shaka.test.ManifestGenerator.generate((manifest) => {
+          manifest.addVariant(0, (variant) => {
+            variant.addAudio(1, (stream) => {
+              stream.mime('audio/mp4', 'mp4a.40.2');
+              stream.language = 'en';
+              stream.bandwidth = 100;
+            });
+            variant.addVideo(2);
+          });
+          manifest.addVariant(1, (variant) => {
+            variant.addExistingStream(1);
+            variant.addVideo(3);
+          });
+
+          manifest.addVariant(2, (variant) => {
+            variant.addAudio(4, (stream) => {
+              stream.mime('audio/mp4', 'mp4a.40.2');
+              stream.language = 'en';
+              stream.bandwidth = 200;
+            });
+            variant.addExistingStream(2);
+          });
+          manifest.addVariant(3, (variant) => {
+            variant.addExistingStream(4);
+            variant.addExistingStream(3);
+          });
         });
+
+        await player.load(fakeManifestUri, 0, fakeMimeType);
+
+        const variantCount = manifest.variants.length;
+        const variantAffected = 2;
+        const audioStream =
+        /** @type {shaka.extern.Stream} */ (manifest.variants[0].audio);
+
+        player.disableStream(audioStream, disableTimeInSeconds);
+
+        await shaka.test.Util.shortDelay(realSetTimeout);
+
+        expect(abrManager.setVariants).toHaveBeenCalled();
+
+        const updatedVariants =
+            abrManager.setVariants.calls.mostRecent().args[0];
+
+        expect(updatedVariants.length).toBe(variantCount - variantAffected);
+
+        for (const variant of updatedVariants) {
+          expect(variant.audio).not.toEqual(audioStream);
+        }
       });
 
-      describe('when config.streaming.maxDisabledTime is 30', () => {
-        /** @type {number} */
-        const maxDisabledTime = 30;
-        /** @type {number} */
-        const currentTime = 123;
-        const chosenVariant = {
-          id: 1,
-          language: 'es',
-          disabledUntilTime: 0,
-          primary: false,
-          bandwidth: 2100,
-          allowedByApplication: true,
-          allowedByKeySystem: true,
-          decodingInfos: [],
-        };
-        /** @type {?jasmine.Spy} */
-        let applyRestrictionsSpy;
-        /** @type {?jasmine.Spy} */
-        let chooseVariantSpy;
-        /** @type {?jasmine.Spy} */
-        let getBufferedInfoSpy;
-        /** @type {?jasmine.Spy} */
-        let switchVariantSpy;
-
-        describe('and there is new variant', () => {
-          const oldDateNow = Date.now;
-          beforeEach(() => {
-            Date.now = () => currentTime * 1000;
-            chooseVariantSpy = spyOn(player, 'chooseVariant_')
-                .and.returnValue(chosenVariant);
-            getBufferedInfoSpy = spyOn(player, 'getBufferedInfo')
-                .and.returnValue(bufferedInfo);
-            switchVariantSpy = spyOn(player, 'switchVariant_');
-            applyRestrictionsSpy = spyOn(StreamUtils, 'applyRestrictions');
-            httpError.handled = false;
-            dispatchEventSpy.calls.reset();
-            player.configure({streaming: {maxDisabledTime}});
-            player.setMaxHardwareResolution(123, 456);
-          });
+      it('does not disable streams if abr is disabled', async () => {
+        await player.load(fakeManifestUri, 0, fakeMimeType);
 
-          afterEach(() => {
-            Date.now = oldDateNow;
-            chooseVariantSpy.calls.reset();
-            getBufferedInfoSpy.calls.reset();
-            switchVariantSpy.calls.reset();
-            applyRestrictionsSpy.calls.reset();
+        player.configure({abr: {enabled: true}});
+
+        const videoStream =
+        /** @type {shaka.extern.Stream} */ (manifest.variants[0].video);
+        let status = player.disableStream(videoStream, 10);
+        expect(status).toBe(true);
+
+        player.configure({abr: {enabled: false}});
+
+        status = player.disableStream(videoStream, 10);
+        expect(status).toBe(false);
+      });
+
+      it('disables stream if have alternate stream', async () => {
+        // Run test with the default manifest
+        await runTest(0, 'video', true);
+
+        manifest = shaka.test.ManifestGenerator.generate((manifest) => {
+          manifest.addVariant(0, (variant) => {
+            variant.addAudio(1, (stream) => {
+              stream.mime('audio/mp4', 'mp4a.40.2');
+              stream.language = 'en';
+              stream.bandwidth = 10;
+            });
+            variant.addVideo(2);
           });
+          manifest.addVariant(1, (variant) => {
+            variant.addAudio(3, (stream) => {
+              stream.mime('audio/mp4', 'mp4a.40.2');
+              stream.language = 'en';
+              stream.bandwidth = 20;
+            });
+            variant.addExistingStream(2);
+          });
+        });
+
+        player.configure({abr: {enabled: true}});
+
+        await runTest(0, 'audio', true);
+      });
 
-          it('handles HTTP_ERROR', () => {
-            onErrorCallback(httpError);
-            expect(httpError.handled).toBeTruthy();
+      describe('does not disable stream if there not alternate stream', () => {
+        it('single audio multiple videos', async () => {
+          manifest = shaka.test.ManifestGenerator.generate((manifest) => {
+            manifest.addVariant(0, (variant) => {
+              variant.addAudio(1, (stream) => {
+                stream.mime('audio/mp4', 'mp4a.40.2');
+                stream.language = 'en';
+              });
+              variant.addVideo(2);
+            });
+            manifest.addVariant(1, (variant) => {
+              variant.addExistingStream(1);
+              variant.addVideo(3);
+            });
           });
 
-          it('does not dispatch any error', () => {
-            onErrorCallback(httpError);
-            expect(dispatchEventSpy).not.toHaveBeenCalled();
+          await runTest(0, 'audio', false);
+        });
+
+        it('multiple audio different languages', async () => {
+          manifest = shaka.test.ManifestGenerator.generate((manifest) => {
+            manifest.addVariant(0, (variant) => {
+              variant.addAudio(1, (stream) => {
+                stream.mime('audio/mp4', 'mp4a.40.2');
+                stream.language = 'en';
+              });
+              variant.addVideo(2);
+            });
+            manifest.addVariant(1, (variant) => {
+              variant.addAudio(3, (stream) => {
+                stream.mime('audio/mp4', 'mp4a.40.2');
+                stream.language = 'de';
+              });
+              variant.addExistingStream(2);
+            });
           });
 
-          it('disables the current variant and applies restrictions', () => {
-            onErrorCallback(httpError);
-
-            const foundDisabledVariant =
-                manifest.variants.some(({disabledUntilTime}) =>
-                  disabledUntilTime == currentTime + maxDisabledTime);
-            expect(foundDisabledVariant).toBeTruthy();
-            expect(applyRestrictionsSpy).toHaveBeenCalledWith(
-                manifest.variants,
-                player.getConfiguration().restrictions,
-                {width: 123, height: 456});
+          await runTest(1, 'audio', false);
+        });
+
+        it('single variant', async () => {
+          manifest = shaka.test.ManifestGenerator.generate((manifest) => {
+            manifest.addVariant(0, (variant) => {
+              variant.addAudio(1);
+              variant.addVideo(2);
+            });
           });
 
-          it('switches the variant', () => {
-            onErrorCallback(httpError);
+          await runTest(0, 'audio', false);
+          await runTest(0, 'video', false);
+        });
 
-            expect(chooseVariantSpy).toHaveBeenCalled();
-            expect(getBufferedInfoSpy).toHaveBeenCalled();
-            expect(switchVariantSpy)
-                .toHaveBeenCalledWith(chosenVariant, false, true, 14);
+        it('single video multiple audio', async () => {
+          manifest = shaka.test.ManifestGenerator.generate((manifest) => {
+            manifest.addVariant(0, (variant) => {
+              variant.addAudio(1, (stream) => {
+                stream.mime('audio/mp4', 'mp4a.40.2');
+                stream.language = 'en';
+                stream.bandwidth = 10;
+              });
+              variant.addVideo(2);
+            });
+            manifest.addVariant(1, (variant) => {
+              variant.addAudio(3, (stream) => {
+                stream.mime('audio/mp4', 'mp4a.40.2');
+                stream.language = 'en';
+                stream.bandwidth = 20;
+              });
+              variant.addExistingStream(2);
+            });
           });
 
-          describe('but browser is truly offline', () => {
-            /** @type {!Object} */
-            let navigatorOnLineDescriptor;
+          await runTest(0, 'video', false);
+        });
 
-            // eslint-disable-next-line no-restricted-syntax
-            const navigatorPrototype = Navigator.prototype;
+        describe('or', () => {
+          /** @type {!Object} */
+          let navigatorOnLineDescriptor;
 
-            beforeAll(() => {
-              navigatorOnLineDescriptor =
-                /** @type {!Object} */(Object.getOwnPropertyDescriptor(
-                    navigatorPrototype, 'onLine'));
-            });
+          // eslint-disable-next-line no-restricted-syntax
+          const navigatorPrototype = Navigator.prototype;
 
-            beforeEach(() => {
-              // Redefine the property, replacing only the getter.
-              Object.defineProperty(navigatorPrototype, 'onLine',
-                  Object.assign(navigatorOnLineDescriptor, {
-                    get: () => false,
-                  }));
-            });
+          beforeAll(() => {
+            navigatorOnLineDescriptor =
+              /** @type {!Object} */(Object.getOwnPropertyDescriptor(
+                  navigatorPrototype, 'onLine'));
+          });
 
-            afterEach(() => {
-              // Restore the original property definition.
-              Object.defineProperty(
-                  navigatorPrototype, 'onLine', navigatorOnLineDescriptor);
-            });
+          beforeEach(() => {
+            // Redefine the property, replacing only the getter.
+            Object.defineProperty(navigatorPrototype, 'onLine',
+                Object.assign(navigatorOnLineDescriptor, {
+                  get: () => false,
+                }));
+          });
+
+          afterEach(() => {
+            // Restore the original property definition.
+            Object.defineProperty(
+                navigatorPrototype, 'onLine', navigatorOnLineDescriptor);
+          });
 
-            it('does not handle HTTP_ERROR', () => {
-              onErrorCallback(httpError);
-              expect(httpError.handled).toBe(false);
+          it('browser is truly offline', async () => {
+            manifest = shaka.test.ManifestGenerator.generate((manifest) => {
+              manifest.addVariant(11, (variant) => {
+                variant.addAudio(2);
+                variant.addVideo(3);
+              });
+              manifest.addVariant(12, (variant) => {
+                variant.addAudio(4);
+                variant.addVideo(5);
+              });
             });
+
+            await runTest(0, 'video', false);
           });
         });
       });
@@ -1083,19 +1291,23 @@ describe('Player', () => {
           lowLatencyMode: true,
           rebufferingGoal: 1,
           inaccurateManifestTolerance: 1,
+          segmentPrefetchLimit: 1,
         },
       });
       expect(player.getConfiguration().streaming.rebufferingGoal).toBe(1);
       expect(player.getConfiguration().streaming.inaccurateManifestTolerance)
           .toBe(1);
+      expect(player.getConfiguration().streaming.segmentPrefetchLimit).toBe(1);
 
       // When low latency streaming gets enabled, rebufferingGoal will default
-      // to 0.01 if unless specified, and inaccurateManifestTolerance will
-      // default to 0 unless specified.
+      // to 0.01 if unless specified, inaccurateManifestTolerance will
+      // default to 0 unless specified, and segmentPrefetchLimit will
+      // default to 2 unless specified.
       player.configure('streaming.lowLatencyMode', true);
       expect(player.getConfiguration().streaming.rebufferingGoal).toBe(0.01);
       expect(player.getConfiguration().streaming.inaccurateManifestTolerance)
           .toBe(0);
+      expect(player.getConfiguration().streaming.segmentPrefetchLimit).toBe(2);
     });
   });
 
@@ -1309,6 +1521,7 @@ describe('Player', () => {
         manifest.addVariant(106, (variant) => {  // spanish stereo, low res
           variant.language = 'es';
           variant.bandwidth = 1100;
+          variant.label = 'es-label';
           variant.addExistingStream(1);  // video
           variant.addAudio(6, (stream) => {
             stream.originalId = 'audio-es';
@@ -1320,6 +1533,7 @@ describe('Player', () => {
         manifest.addVariant(107, (variant) => {  // spanish stereo, high res
           variant.language = 'es';
           variant.bandwidth = 2100;
+          variant.label = 'es-label';
           variant.addExistingStream(2);  // video
           variant.addExistingStream(6);  // audio
         });
@@ -1328,6 +1542,7 @@ describe('Player', () => {
         manifest.addTextStream(50, (stream) => {
           stream.originalId = 'text-es';
           stream.language = 'es';
+          stream.originalLanguage = 'es';
           stream.label = 'Spanish';
           stream.bandwidth = 10;
           stream.mimeType = 'text/vtt';
@@ -1336,6 +1551,7 @@ describe('Player', () => {
         manifest.addTextStream(51, (stream) => {
           stream.originalId = 'text-en';
           stream.language = 'en';
+          stream.originalLanguage = 'en';
           stream.label = 'English';
           stream.bandwidth = 10;
           stream.mimeType = 'application/ttml+xml';
@@ -1345,6 +1561,7 @@ describe('Player', () => {
         manifest.addTextStream(52, (stream) => {
           stream.originalId = 'text-commentary';
           stream.language = 'en';
+          stream.originalLanguage = 'en';
           stream.label = 'English';
           stream.bandwidth = 10;
           stream.mimeType = 'application/ttml+xml';
@@ -1370,6 +1587,7 @@ describe('Player', () => {
           type: 'variant',
           bandwidth: 1300,
           language: 'en',
+          originalLanguage: 'en',
           label: null,
           kind: null,
           width: 100,
@@ -1399,6 +1617,7 @@ describe('Player', () => {
           originalVideoId: 'video-1kbps',
           originalTextId: null,
           originalImageId: null,
+          accessibilityPurpose: undefined,
         },
         {
           id: 101,
@@ -1406,6 +1625,7 @@ describe('Player', () => {
           type: 'variant',
           bandwidth: 2300,
           language: 'en',
+          originalLanguage: 'en',
           label: null,
           kind: null,
           width: 200,
@@ -1435,6 +1655,7 @@ describe('Player', () => {
           originalVideoId: 'video-2kbps',
           originalTextId: null,
           originalImageId: null,
+          accessibilityPurpose: undefined,
         },
         {
           id: 102,
@@ -1442,6 +1663,7 @@ describe('Player', () => {
           type: 'variant',
           bandwidth: 1100,
           language: 'en',
+          originalLanguage: 'en',
           label: null,
           kind: null,
           width: 100,
@@ -1471,6 +1693,7 @@ describe('Player', () => {
           originalVideoId: 'video-1kbps',
           originalTextId: null,
           originalImageId: null,
+          accessibilityPurpose: undefined,
         },
         {
           id: 103,
@@ -1478,6 +1701,7 @@ describe('Player', () => {
           type: 'variant',
           bandwidth: 2100,
           language: 'en',
+          originalLanguage: 'en',
           label: null,
           kind: null,
           width: 200,
@@ -1507,6 +1731,7 @@ describe('Player', () => {
           originalVideoId: 'video-2kbps',
           originalTextId: null,
           originalImageId: null,
+          accessibilityPurpose: undefined,
         },
         {
           id: 104,
@@ -1514,6 +1739,7 @@ describe('Player', () => {
           type: 'variant',
           bandwidth: 1100,
           language: 'en',
+          originalLanguage: 'en',
           label: null,
           kind: null,
           width: 100,
@@ -1543,6 +1769,7 @@ describe('Player', () => {
           originalVideoId: 'video-1kbps',
           originalTextId: null,
           originalImageId: null,
+          accessibilityPurpose: undefined,
         },
         {
           id: 105,
@@ -1550,6 +1777,7 @@ describe('Player', () => {
           type: 'variant',
           bandwidth: 2100,
           language: 'en',
+          originalLanguage: 'en',
           label: null,
           kind: null,
           width: 200,
@@ -1579,6 +1807,7 @@ describe('Player', () => {
           originalVideoId: 'video-2kbps',
           originalTextId: null,
           originalImageId: null,
+          accessibilityPurpose: undefined,
         },
         {
           id: 106,
@@ -1586,7 +1815,8 @@ describe('Player', () => {
           type: 'variant',
           bandwidth: 1100,
           language: 'es',
-          label: null,
+          label: 'es-label',
+          originalLanguage: 'es',
           kind: null,
           width: 100,
           height: 200,
@@ -1615,6 +1845,7 @@ describe('Player', () => {
           originalVideoId: 'video-1kbps',
           originalTextId: null,
           originalImageId: null,
+          accessibilityPurpose: undefined,
         },
         {
           id: 107,
@@ -1622,7 +1853,8 @@ describe('Player', () => {
           type: 'variant',
           bandwidth: 2100,
           language: 'es',
-          label: null,
+          label: 'es-label',
+          originalLanguage: 'es',
           kind: null,
           width: 200,
           height: 400,
@@ -1651,6 +1883,7 @@ describe('Player', () => {
           originalVideoId: 'video-2kbps',
           originalTextId: null,
           originalImageId: null,
+          accessibilityPurpose: undefined,
         },
       ];
 
@@ -1660,6 +1893,7 @@ describe('Player', () => {
           active: true,
           type: ContentType.TEXT,
           language: 'es',
+          originalLanguage: 'es',
           label: 'Spanish',
           kind: 'caption',
           mimeType: 'text/vtt',
@@ -1690,12 +1924,14 @@ describe('Player', () => {
           originalVideoId: null,
           originalTextId: 'text-es',
           originalImageId: null,
+          accessibilityPurpose: undefined,
         },
         {
           id: 51,
           active: false,
           type: ContentType.TEXT,
           language: 'en',
+          originalLanguage: 'en',
           label: 'English',
           kind: 'caption',
           mimeType: 'application/ttml+xml',
@@ -1726,12 +1962,14 @@ describe('Player', () => {
           originalVideoId: null,
           originalTextId: 'text-en',
           originalImageId: null,
+          accessibilityPurpose: undefined,
         },
         {
           id: 52,
           active: false,
           type: ContentType.TEXT,
           language: 'en',
+          originalLanguage: 'en',
           label: 'English',
           kind: 'caption',
           mimeType: 'application/ttml+xml',
@@ -1762,6 +2000,7 @@ describe('Player', () => {
           originalVideoId: null,
           originalTextId: 'text-commentary',
           originalImageId: null,
+          accessibilityPurpose: undefined,
         },
       ];
 
@@ -1771,6 +2010,7 @@ describe('Player', () => {
           active: false,
           type: ContentType.IMAGE,
           language: '',
+          originalLanguage: null,
           label: null,
           kind: null,
           mimeType: 'image/jpeg',
@@ -1801,6 +2041,7 @@ describe('Player', () => {
           originalVideoId: null,
           originalTextId: null,
           originalImageId: 'thumbnail',
+          accessibilityPurpose: null,
         },
       ];
 
@@ -2293,6 +2534,18 @@ describe('Player', () => {
         roles: ['commentary'],
       }));
     });
+
+    it('chooses a variant with preferred audio label', async () => {
+      expect(getActiveVariantTrack().label).toBe(null);
+
+      player.configure({
+        preferredAudioLanguage: '',
+        preferredAudioLabel: 'es-label',
+      });
+
+      await player.load(fakeManifestUri, 0, fakeMimeType);
+      expect(getActiveVariantTrack().label).toBe('es-label');
+    });
   });  // describe('tracks')
 
   describe('languages', () => {