shaka-player 4.0.0 → 4.1.0

package/test/player_unit.js

@@ -6,6 +6,7 @@
 
 describe('Player', () => {
   const ContentType = shaka.util.ManifestParserUtils.ContentType;
+  const StreamUtils = shaka.util.StreamUtils;
   const Util = shaka.test.Util;
 
   const originalLogError = shaka.log.error;
@@ -29,6 +30,8 @@ describe('Player', () => {
   let player;
   /** @type {!shaka.test.FakeAbrManager} */
   let abrManager;
+  /** @type {function(!shaka.util.Error)} */
+  let onErrorCallback;
 
   /** @type {!shaka.test.FakeNetworkingEngine} */
   let networkingEngine;
@@ -40,6 +43,8 @@ describe('Player', () => {
   let playhead;
   /** @type {!shaka.test.FakeTextDisplayer} */
   let textDisplayer;
+  /** @type {shaka.extern.BufferedInfo} */
+  let bufferedInfo;
 
   let mediaSourceEngine;
 
@@ -101,6 +106,13 @@ describe('Player', () => {
     abrManager = new shaka.test.FakeAbrManager();
     textDisplayer = createTextDisplayer();
 
+    bufferedInfo = {
+      total: [],
+      audio: [],
+      video: [{start: 12, end: 26}],
+      text: [],
+    };
+
     function dependencyInjector(player) {
       // Create a networking engine that always returns an empty buffer.
       networkingEngine = new shaka.test.FakeNetworkingEngine();
@@ -119,12 +131,22 @@ describe('Player', () => {
         setSegmentRelativeVttTiming:
             jasmine.createSpy('setSegmentRelativeVttTiming'),
         getTextDisplayer: () => textDisplayer,
+        getBufferedInfo: () => bufferedInfo,
         ended: jasmine.createSpy('ended').and.returnValue(false),
       };
 
-      player.createDrmEngine = () => drmEngine;
+      player.createDrmEngine = ({onError}) => {
+        onErrorCallback = onError;
+        return drmEngine;
+      };
       player.createNetworkingEngine = () => networkingEngine;
-      player.createPlayhead = () => playhead;
+      player.createPlayhead = (startTime) => {
+        const callableSetStartTime =
+            shaka.test.Util.spyFunc(playhead.setStartTime);
+        callableSetStartTime(startTime);
+        playhead.setStartTime.calls.reset();
+        return playhead;
+      };
       player.createMediaSourceEngine = () => mediaSourceEngine;
       player.createStreamingEngine = () => streamingEngine;
     }
@@ -156,6 +178,7 @@ describe('Player', () => {
       window.MediaSource.isTypeSupported = originalIsTypeSupported;
       shaka.media.ManifestParser.unregisterParserByMime(fakeMimeType);
       navigator.mediaCapabilities.decodingInfo = originalDecodingInfo;
+      onError.calls.reset();
     }
   });
 
@@ -314,6 +337,131 @@ 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);
+      /** @type {?jasmine.Spy} */
+      let dispatchEventSpy;
+
+      beforeEach(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 player.load(fakeManifestUri, 0, fakeMimeType);
+        dispatchEventSpy = spyOn(player, 'dispatchEvent').and.returnValue(true);
+      });
+
+      afterEach(() => {
+        dispatchEventSpy.calls.reset();
+      });
+
+      it('does not handle non NETWORK HTTP_ERROR', () => {
+        onErrorCallback(nonHttpError);
+        expect(nonHttpError.handled).toBeFalsy();
+        expect(player.dispatchEvent).toHaveBeenCalled();
+      });
+
+      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();
+        });
+      });
+
+      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);
+            onErrorCallback(httpError);
+          });
+
+          afterEach(() => {
+            Date.now = oldDateNow;
+            chooseVariantSpy.calls.reset();
+            getBufferedInfoSpy.calls.reset();
+            switchVariantSpy.calls.reset();
+            applyRestrictionsSpy.calls.reset();
+          });
+
+          it('handles HTTP_ERROR', () => {
+            expect(httpError.handled).toBeTruthy();
+          });
+
+          it('does not dispatch any error', () => {
+            expect(dispatchEventSpy).not.toHaveBeenCalled();
+          });
+
+          it('disables the current variant and applies restrictions', () => {
+            const foundDisabledVariant =
+                manifest.variants.some(({disabledUntilTime}) =>
+                  disabledUntilTime == currentTime + maxDisabledTime);
+            expect(foundDisabledVariant).toBeTruthy();
+            expect(applyRestrictionsSpy).toHaveBeenCalledWith(
+                manifest.variants,
+                player.getConfiguration().restrictions,
+                {width: 123, height: 456});
+          });
+
+          it('switches the variant', () => {
+            expect(chooseVariantSpy).toHaveBeenCalled();
+            expect(getBufferedInfoSpy).toHaveBeenCalled();
+            expect(switchVariantSpy)
+                .toHaveBeenCalledWith(chosenVariant, false, true, 14);
+          });
+        });
+      });
+    });
+
     describe('setTextTrackVisibility', () => {
       beforeEach(() => {
         manifest = shaka.test.ManifestGenerator.generate((manifest) => {
@@ -2658,6 +2806,51 @@ describe('Player', () => {
       expect(activeVariant.id).toBe(1);
     });
 
+    // Regression test for https://github.com/shaka-project/shaka-player/issues/4190
+    it('throws only one RESTRICTIONS_CANNOT_BE_MET error', async () => {
+      manifest = shaka.test.ManifestGenerator.generate((manifest) => {
+        manifest.addVariant(0, (variant) => {
+          variant.addVideo(1, (stream) => {
+            stream.keyIds = new Set(['abc']);
+          });
+        });
+      });
+
+      // Check that error is RESTRICTIONS_CANNOT_BE_MET
+      onError.and.callFake((e) => {
+        const error = e.detail;
+        shaka.test.Util.expectToEqualError(
+            error,
+            new shaka.util.Error(
+                shaka.util.Error.Severity.CRITICAL,
+                shaka.util.Error.Category.MANIFEST,
+                shaka.util.Error.Code.RESTRICTIONS_CANNOT_BE_MET, {
+                  hasAppRestrictions: false,
+                  missingKeys: ['abc'],
+                  restrictedKeyStatuses: [],
+                }));
+      });
+
+      await player.load(fakeManifestUri, 0, fakeMimeType);
+      const activeVariant = getActiveVariantTrack();
+      expect(activeVariant.id).toBe(0);
+
+      abrManager.chooseIndex = 0;
+      abrManager.chooseVariant.calls.reset();
+
+      onKeyStatus({'abc': 'output-restricted'});
+
+      // Ensure that RESTRICTIONS_CANNOT_BE_MET is thrown once
+      expect(onError).toHaveBeenCalledTimes(1);
+
+      // It does not call chooseVariant
+      expect(abrManager.chooseVariant).not.toHaveBeenCalled();
+
+      // The first variant is disallowed.
+      expect(manifest.variants[0].id).toBe(0);
+      expect(manifest.variants[0].allowedByKeySystem).toBe(false);
+    });
+
     it('doesn\'t switch if the active stream isn\'t restricted', async () => {
       manifest = shaka.test.ManifestGenerator.generate((manifest) => {
         manifest.addVariant(0, (variant) => {
@@ -3664,6 +3857,51 @@ describe('Player', () => {
     });
   });
 
+  describe('config streaming.startAtSegmentBoundary', () => {
+    // Test for https://github.com/shaka-project/shaka-player/issues/4188
+    // In that issue, using streaming.startAtSegmentBoundary in v4.0.0 caused
+    // an exception due to the use of a removed method.
+    it('adjusts start time', async () => {
+      player.configure('streaming.startAtSegmentBoundary', true);
+
+      // In order to adjust the start time to a segment boundary, we need
+      // segment descriptions in the segment index.  So create a non-default
+      // fake manifest.
+      const timeline = new shaka.media.PresentationTimeline(300, 0);
+      timeline.setStatic(true);
+      // This duration is used by useSegmentTemplate below to decide how many
+      // references to generate.
+      timeline.setDuration(300);
+      manifest = shaka.test.ManifestGenerator.generate((manifest) => {
+        manifest.presentationTimeline = timeline;
+        manifest.addVariant(0, (variant) => {
+          variant.addVideo(1, (stream) => {
+            stream.useSegmentTemplate(
+                '$Number$.mp4', /* segmentDuration= */ 10);
+          });
+        });
+      });
+
+      await player.load(fakeManifestUri, 12, fakeMimeType);
+
+      expect(playhead.setStartTime).toHaveBeenCalledWith(10);
+    });
+
+    it('does not fail with no segments', async () => {
+      player.configure('streaming.startAtSegmentBoundary', true);
+
+      // Without useSegmentTemplate in the fake manifest, the call to
+      // getIteratorForTime() in Player produces a null iterator.  Using the
+      // default fake manifest should cover that case.  But just to make sure,
+      // verify that we have no segments before calling load().
+      const variant = manifest.variants[0];
+      expect(variant.video.segmentIndex.getIteratorForTime(0)).toBeNull();
+      expect(variant.audio.segmentIndex.getIteratorForTime(0)).toBeNull();
+
+      await player.load(fakeManifestUri, 0, fakeMimeType);
+    });
+  });
+
   /**
    * Gets the currently active variant track.
    * @return {shaka.extern.Track}

package/test/test/boot.js

@@ -242,6 +242,15 @@ window.xfilterDescribe = (describeName, cond, describeBody) => {
   window['describe'] = oldDescribe;
 };
 
+/**
+ * A very short alias for filtering offline integration tests.
+ *
+ * @return {boolean}
+ */
+window.offlineSupported = () => {
+  return shaka.offline.StorageMuxer.support();
+};
+
 /**
  * Load node modules used in testing and install them into window.
  * @return {!Promise}

package/test/test/externs/filters.js

@@ -38,3 +38,7 @@ var filterDescribe = function(name, cond, callback) {};
  * @param {function()} callback
  */
 var xfilterDescribe = function(name, cond, callback) {};
+
+
+/** @return {boolean} */
+var offlineSupported = function() {};

package/test/test/util/manifest_generator.js

@@ -265,6 +265,8 @@ shaka.test.ManifestGenerator.Variant = class {
       this.language = 'und';
       /** @type {number} */
       this.bandwidth = 0;
+      /** @type {number} */
+      this.disabledUntilTime = 0;
       /** @type {boolean} */
       this.primary = false;
       /** @type {boolean} */

package/test/test/util/simple_fakes.js

@@ -152,9 +152,27 @@ shaka.test.FakeVideo = class {
   constructor(currentTime) {
     /** @const {!Object.<string, !Function>} */
     this.on = {};  // event listeners
+
     /** @type {!Array.<!TextTrack>} */
     this.textTracks = [];
 
+    // In a real video element, textTracks is an event target.
+    // Since Player listens to events on textTracks, we need to fake that
+    // interface.
+    this.textTracksEventTarget = new shaka.util.FakeEventTarget();
+    this.textTracks.addEventListener =
+        // eslint-disable-next-line no-restricted-syntax
+        this.textTracksEventTarget.addEventListener.bind(
+            this.textTracksEventTarget);
+    this.textTracks.removeEventListener =
+        // eslint-disable-next-line no-restricted-syntax
+        this.textTracksEventTarget.removeEventListener.bind(
+            this.textTracksEventTarget);
+    this.textTracks.dispatchEvent =
+        // eslint-disable-next-line no-restricted-syntax
+        this.textTracksEventTarget.dispatchEvent.bind(
+            this.textTracksEventTarget);
+
     this.currentTime = currentTime || 0;
     this.readyState = 0;
     this.playbackRate = 1;
@@ -173,6 +191,10 @@ shaka.test.FakeVideo = class {
         jasmine.createSpy('addTextTrack').and.callFake((kind, id) => {
           const track = new shaka.test.FakeTextTrack();
           this.textTracks.push(track);
+
+          const trackEvent = new shaka.util.FakeEvent('addtrack', {track});
+          this.textTracksEventTarget.dispatchEvent(trackEvent);
+
           return track;
         });
 
@@ -308,11 +330,32 @@ shaka.test.FakePlayhead = class {
     /** @type {!jasmine.Spy} */
     this.setRebufferingGoal = jasmine.createSpy('setRebufferingGoal');
 
+    /** @private {number} */
+    this.startTime_ = 0;
+
+    /** @private {number} */
+    this.gapsJumped_ = 0;
+
+    /** @private {number} */
+    this.stallsDetected_ = 0;
+
+    /** @type {!jasmine.Spy} */
+    this.setStartTime = jasmine.createSpy('setStartTime')
+        .and.callFake((value) => {
+          this.startTime_ = value;
+        });
+
+    /** @type {!jasmine.Spy} */
+    this.getTime = jasmine.createSpy('getTime')
+        .and.callFake(() => this.startTime_);
+
     /** @type {!jasmine.Spy} */
-    this.setStartTime = jasmine.createSpy('setStartTime');
+    this.getGapsJumped = jasmine.createSpy('getGapsJumped')
+        .and.callFake(() => this.gapsJumped_);
 
     /** @type {!jasmine.Spy} */
-    this.getTime = jasmine.createSpy('getTime').and.returnValue(0);
+    this.getStallsDetected = jasmine.createSpy('getTime')
+        .and.callFake(() => this.stallsDetected_);
 
     /** @type {!jasmine.Spy} */
     this.setBuffering = jasmine.createSpy('setBuffering');

package/test/test/util/streaming_engine_util.js

@@ -287,6 +287,7 @@ shaka.test.StreamingEngineUtil = class {
       bandwidth: 0,
       id: 0,
       language: 'und',
+      disabledUntilTime: 0,
       primary: false,
       decodingInfos: [],
     };

package/test/text/vtt_text_parser_unit.js

@@ -535,7 +535,61 @@ describe('VttTextParser', () => {
         'Test\n\n' +
         '00:00:40.000 --> 00:00:50.000 line:-1\n' +
         'Test2',
-        {periodStart: 0, segmentStart: 25, segmentEnd: 65, vttOffset: 0});
+        {periodStart: 0, segmentStart: 25, segmentEnd: 65, vttOffset: 0},
+        /* sequenceMode= */ true);
+  });
+
+  it('ignores X-TIMESTAMP-MAP header if not in sequence mode', () => {
+    verifyHelper(
+        [
+          {startTime: 20, endTime: 40, payload: 'Test'},
+          {startTime: 40, endTime: 50, payload: 'Test2'},
+        ],
+        'WEBVTT\n' +
+        'X-TIMESTAMP-MAP=MPEGTS:900000,LOCAL:01:00:00.000\n\n' +
+        '00:00:20.000 --> 00:00:40.000 line:0\n' +
+        'Test\n\n' +
+        '00:00:40.000 --> 00:00:50.000 line:-1\n' +
+        'Test2',
+        {periodStart: 0, segmentStart: 25, segmentEnd: 65, vttOffset: 0},
+        /* sequenceMode= */ false);
+  });
+
+  it('parses X-TIMESTAMP-MAP header with non-zero local base', () => {
+    verifyHelper(
+        [
+          {startTime: 1800, endTime: 1810, payload: 'Test'},
+          {startTime: 1820, endTime: 1830, payload: 'Test2'},
+        ],
+        // 162000000 = 30 * 60 * 90k = 30 minutes for the TS part of the map.
+        // The local (VTT) part of the map is 1 hour.
+        // So text times of 1 hour map to media times of 30 minutes.
+        'WEBVTT\n' +
+        'X-TIMESTAMP-MAP=MPEGTS:162000000,LOCAL:01:00:00.000\n\n' +
+        '01:00:00.000 --> 01:00:10.000 line:0\n' +
+        'Test\n\n' +
+        '01:00:20.000 --> 01:00:30.000 line:-1\n' +
+        'Test2',
+        {periodStart: 0, segmentStart: 25, segmentEnd: 65, vttOffset: 0},
+        /* sequenceMode= */ true);
+  });
+
+  it('combines X-TIMESTAMP-MAP header with periodStart', () => {
+    verifyHelper(
+        [
+          {startTime: 130, endTime: 150, payload: 'Test'},
+          {startTime: 150, endTime: 160, payload: 'Test2'},
+        ],
+        // 900000 = 10 sec, so expect every timestamp to be 10
+        // seconds ahead of what is specified.
+        'WEBVTT\n' +
+        'X-TIMESTAMP-MAP=MPEGTS:900000,LOCAL:00:00:00.000\n\n' +
+        '00:00:20.000 --> 00:00:40.000 line:0\n' +
+        'Test\n\n' +
+        '00:00:40.000 --> 00:00:50.000 line:-1\n' +
+        'Test2',
+        {periodStart: 100, segmentStart: 25, segmentEnd: 65, vttOffset: 0},
+        /* sequenceMode= */ true);
   });
 
   it('handles timestamp rollover with X-TIMESTAMP-MAP header', () => {
@@ -551,7 +605,8 @@ describe('VttTextParser', () => {
         'Test',
         // Non-null segmentStart takes precedence over X-TIMESTAMP-MAP.
         // This protects us from rollover in the MPEGTS field.
-        {periodStart: 0, segmentStart: 95440, segmentEnd: 95550, vttOffset: 0});
+        {periodStart: 0, segmentStart: 95440, segmentEnd: 95550, vttOffset: 0},
+        /* sequenceMode= */ true);
 
     verifyHelper(
         [
@@ -564,10 +619,12 @@ describe('VttTextParser', () => {
         'X-TIMESTAMP-MAP=MPEGTS:9745408,LOCAL:00:00:00.000\n\n' +
         '00:00:00.000 --> 00:00:02.000 line:0\n' +
         'Test2',
-        {periodStart: 0, segmentStart: 95550, segmentEnd: 95560, vttOffset: 0});
+        {periodStart: 0, segmentStart: 95550, segmentEnd: 95560, vttOffset: 0},
+        /* sequenceMode= */ true);
   });
 
   it('supports global style blocks', () => {
+    const textShadow = '-1px 0 black, 0 1px black, 1px 0 black, 0 -1px black';
     verifyHelper(
         [
           {
@@ -576,6 +633,7 @@ describe('VttTextParser', () => {
             payload: 'Test',
             color: 'cyan',
             fontSize: '10px',
+            textShadow: textShadow,
           },
           {
             startTime: 40,
@@ -583,6 +641,7 @@ describe('VttTextParser', () => {
             payload: 'Test2',
             color: 'cyan',
             fontSize: '10px',
+            textShadow: textShadow,
           },
         ],
         'WEBVTT\n\n' +
@@ -590,6 +649,7 @@ describe('VttTextParser', () => {
         '::cue {\n' +
         'color: cyan;\n'+
         'font-size: 10px;\n'+
+        `text-shadow: ${textShadow};\n`+
         '}\n\n' +
         '00:00:20.000 --> 00:00:40.000\n' +
         'Test\n\n' +
@@ -978,11 +1038,14 @@ describe('VttTextParser', () => {
    * @param {!Array} cues
    * @param {string} text
    * @param {shaka.extern.TextParser.TimeContext} time
+   * @param {boolean=} sequenceMode
    */
-  function verifyHelper(cues, text, time) {
+  function verifyHelper(cues, text, time, sequenceMode = false) {
     const data =
         shaka.util.BufferUtils.toUint8(shaka.util.StringUtils.toUTF8(text));
-    const result = new shaka.text.VttTextParser().parseMedia(data, time);
+    const parser = new shaka.text.VttTextParser();
+    parser.setSequenceMode(sequenceMode);
+    const result = parser.parseMedia(data, time);
 
     const expected = cues.map((cue) => {
       if (cue.nestedCues) {

package/test/ui/ui_unit.js

@@ -809,12 +809,25 @@ describe('UI', () => {
         }
       });
       it('is updated periodically', async () => {
-        function getStatsFromContainer() {
+        // There is no guaranteed ordering, so fetch by the stat name.
+        function getStatsElementByName(name) {
           const nodes = statisticsContainer.childNodes;
-          width = nodes[0].childNodes[1].textContent.replace(' (px)', '');
-          height = nodes[1].childNodes[1].textContent.replace(' (px)', '');
-          bufferingTime =
-              nodes[13].childNodes[1].textContent.replace(' (s)', '');
+          for (const node of nodes) {
+            if (node.hasChildNodes() &&
+                node.childNodes[0].textContent.includes(name)) {
+              return node;
+            }
+          }
+          return null;
+        }
+
+        function getStatsFromContainer() {
+          width = getStatsElementByName(
+              'width').childNodes[1].textContent.replace(' (px)', '');
+          height = getStatsElementByName(
+              'height').childNodes[1].textContent.replace(' (px)', '');
+          bufferingTime = getStatsElementByName(
+              'bufferingTime').childNodes[1].textContent.replace(' (s)', '');
         }
 
         /** @type {!string} */

package/test/util/mime_utils_unit.js

@@ -0,0 +1,54 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+describe('MimeUtils', () => {
+  const getNormalizedCodec = (codecs) =>
+    shaka.util.MimeUtils.getNormalizedCodec(codecs);
+
+  it('normalizes codecs', () => {
+    expect(getNormalizedCodec('mp4a.66')).toBe('aac');
+    expect(getNormalizedCodec('mp4a.67')).toBe('aac');
+    expect(getNormalizedCodec('mp4a.68')).toBe('aac');
+
+    expect(getNormalizedCodec('mp3')).toBe('mp3');
+    expect(getNormalizedCodec('mp4a.69')).toBe('mp3');
+    expect(getNormalizedCodec('mp4a.6B')).toBe('mp3');
+    expect(getNormalizedCodec('mp4a.6b')).toBe('mp3');
+
+    expect(getNormalizedCodec('mp4a.40.2')).toBe('aac');
+    expect(getNormalizedCodec('mp4a.40.02')).toBe('aac');
+    expect(getNormalizedCodec('mp4a.40.5')).toBe('aac');
+    expect(getNormalizedCodec('mp4a.40.05')).toBe('aac');
+    expect(getNormalizedCodec('mp4a.40.29')).toBe('aac');
+    expect(getNormalizedCodec('mp4a.40.42')).toBe('aac');
+
+    expect(getNormalizedCodec('ac-3')).toBe('ac-3');
+    expect(getNormalizedCodec('mp4a.a5')).toBe('ac-3');
+    expect(getNormalizedCodec('mp4a.A5')).toBe('ac-3');
+
+    expect(getNormalizedCodec('ec-3')).toBe('ec-3');
+    expect(getNormalizedCodec('mp4a.a6')).toBe('ec-3');
+    expect(getNormalizedCodec('mp4a.A6')).toBe('ec-3');
+
+    expect(getNormalizedCodec('dtsc')).toBe('dtsc');
+    expect(getNormalizedCodec('mp4a.a9')).toBe('dtsc');
+
+    expect(getNormalizedCodec('dtsx')).toBe('dtsx');
+    expect(getNormalizedCodec('mp4a.b2')).toBe('dtsx');
+
+    expect(getNormalizedCodec('vp8')).toBe('vp8');
+    expect(getNormalizedCodec('vp8.0')).toBe('vp8');
+
+    expect(getNormalizedCodec('avc1')).toBe('avc');
+    expect(getNormalizedCodec('avc3')).toBe('avc');
+
+    expect(getNormalizedCodec('hvc1')).toBe('hevc');
+    expect(getNormalizedCodec('hev1')).toBe('hevc');
+
+    expect(getNormalizedCodec('dvh1.05')).toBe('dovi');
+    expect(getNormalizedCodec('dvhe.05')).toBe('dovi');
+  });
+});