hls.js 1.6.0-beta.4.0.canary.11066 → 1.6.0-beta.4.0.canary.11069

package/package.json

@@ -74,7 +74,7 @@
     "@babel/preset-env": "7.26.9",
     "@babel/preset-typescript": "7.26.0",
     "@babel/register": "7.25.9",
-    "@microsoft/api-documenter": "7.26.16",
+    "@microsoft/api-documenter": "7.26.17",
     "@microsoft/api-extractor": "7.52.1",
     "@rollup/plugin-alias": "5.1.1",
     "@rollup/plugin-babel": "6.0.4",
@@ -134,5 +134,5 @@
     "url-toolkit": "2.2.5",
     "wrangler": "3.114.1"
   },
-  "version": "1.6.0-beta.4.0.canary.11066"
+  "version": "1.6.0-beta.4.0.canary.11069"
 }

package/src/controller/buffer-controller.ts

@@ -6,6 +6,7 @@ import { ElementaryStreamTypes } from '../loader/fragment';
 import { PlaylistLevelType } from '../types/loader';
 import { BufferHelper } from '../utils/buffer-helper';
 import {
+  areCodecsMediaSourceSupported,
   getCodecCompatibleName,
   pickMostCompleteCodecName,
 } from '../utils/codecs';
@@ -607,7 +608,8 @@ transfer tracks: ${stringify(transferredTracks, (key, value) => (key === 'initSe
     }
     trackNames.forEach((trackName: SourceBufferName) => {
       const parsedTrack = data[trackName] as ParsedTrack;
-      const { id, codec, levelCodec, container, metadata } = parsedTrack;
+      const { id, codec, levelCodec, container, metadata, supplemental } =
+        parsedTrack;
       let track = tracks[trackName];
       const transferredTrack = this.transferData?.tracks?.[trackName];
       const sbTrack = transferredTrack?.buffer ? transferredTrack : track;
@@ -618,6 +620,7 @@ transfer tracks: ${stringify(transferredTracks, (key, value) => (key === 'initSe
           buffer: undefined,
           listeners: [],
           codec,
+          supplemental,
           container,
           levelCodec,
           metadata,
@@ -1350,6 +1353,7 @@ transfer tracks: ${stringify(transferredTracks, (key, value) => (key === 'initSe
             buffer,
             container: track.container,
             codec: track.codec,
+            supplemental: track.supplemental,
             levelCodec: track.levelCodec,
             id: track.id,
             metadata: track.metadata,
@@ -1430,6 +1434,15 @@ transfer tracks: ${stringify(transferredTracks, (key, value) => (key === 'initSe
   }
 
   private getTrackCodec(track: BaseTrack, trackName: SourceBufferName): string {
+    // Use supplemental video codec when supported when adding SourceBuffer (#5558)
+    const supplementalCodec = track.supplemental;
+    if (
+      supplementalCodec &&
+      trackName === 'video' &&
+      areCodecsMediaSourceSupported(supplementalCodec, trackName)
+    ) {
+      return supplementalCodec;
+    }
     const codec = pickMostCompleteCodecName(track.codec, track.levelCodec);
     if (codec) {
       if (trackName.slice(0, 5) === 'audio') {
@@ -1451,6 +1464,7 @@ transfer tracks: ${stringify(transferredTracks, (key, value) => (key === 'initSe
       codec,
       container: track.container,
       levelCodec: track.levelCodec,
+      supplemental: track.supplemental,
       metadata: track.metadata,
       id: track.id,
       listeners: [],

package/src/controller/level-controller.ts

@@ -12,6 +12,7 @@ import {
   videoCodecPreferenceValue,
 } from '../utils/codecs';
 import { reassignFragmentLevelIndexes } from '../utils/level-helper';
+import { getUnsupportedResult } from '../utils/mediacapabilities-helper';
 import { stringify } from '../utils/safe-json-stringify';
 import type ContentSteeringController from './content-steering-controller';
 import type Hls from '../hls';
@@ -163,6 +164,7 @@ export default class LevelController extends BasePlaylistController {
         (audioCodec && !this.isAudioSupported(audioCodec)) ||
         (videoCodec && !this.isVideoSupported(videoCodec))
       ) {
+        this.log(`Some or all CODECS not supported "${attributes.CODECS}"`);
         return;
       }
 
@@ -178,7 +180,7 @@ export default class LevelController extends BasePlaylistController {
       const levelKey = `${contentSteeringPrefix}${levelParsed.bitrate}-${RESOLUTION}-${FRAMERATE}-${CODECS}-${VIDEO_RANGE}-${HDCP}`;
 
       if (!redundantSet[levelKey]) {
-        const level = new Level(levelParsed);
+        const level = this.createLevel(levelParsed);
         redundantSet[levelKey] = level;
         generatePathwaySet[levelKey] = 1;
         levels.push(level);
@@ -190,7 +192,7 @@ export default class LevelController extends BasePlaylistController {
         // Content Steering controller to handles Pathway fallback on error
         const pathwayCount = (generatePathwaySet[levelKey] += 1);
         levelParsed.attrs['PATHWAY-ID'] = new Array(pathwayCount + 1).join('.');
-        const level = new Level(levelParsed);
+        const level = this.createLevel(levelParsed);
         redundantSet[levelKey] = level;
         levels.push(level);
       } else {
@@ -208,6 +210,22 @@ export default class LevelController extends BasePlaylistController {
     );
   }
 
+  private createLevel(levelParsed: LevelParsed): Level {
+    const level = new Level(levelParsed);
+    const supplemental = levelParsed.supplemental;
+    if (
+      supplemental?.videoCodec &&
+      !this.isVideoSupported(supplemental.videoCodec)
+    ) {
+      const error = new Error(
+        `SUPPLEMENTAL-CODECS not supported "${supplemental.videoCodec}"`,
+      );
+      this.log(error.message);
+      level.supportedResult = getUnsupportedResult(error, []);
+    }
+    return level;
+  }
+
   private isAudioSupported(codec: string): boolean {
     return areCodecsMediaSourceSupported(
       codec,
@@ -247,23 +265,27 @@ export default class LevelController extends BasePlaylistController {
       // Dispatch error after MANIFEST_LOADED is done propagating
       Promise.resolve().then(() => {
         if (this.hls) {
+          let message = 'no level with compatible codecs found in manifest';
+          let reason = message;
           if (data.levels.length) {
-            this.warn(
-              `One or more CODECS in variant not supported: ${stringify(
-                data.levels[0].attrs,
-              )}`,
-            );
+            reason = `one or more CODECS in variant not supported: ${stringify(
+              data.levels
+                .map((level) => level.attrs.CODECS)
+                .filter(
+                  (value, index, array) => array.indexOf(value) === index,
+                ),
+            )}`;
+            this.warn(reason);
+            message += ` (${reason})`;
           }
-          const error = new Error(
-            'no level with compatible codecs found in manifest',
-          );
+          const error = new Error(message);
           this.hls.trigger(Events.ERROR, {
             type: ErrorTypes.MEDIA_ERROR,
             details: ErrorDetails.MANIFEST_INCOMPATIBLE_CODECS_ERROR,
             fatal: true,
             url: data.url,
             error,
-            reason: error.message,
+            reason,
           });
         }
       });

package/src/controller/stream-controller.ts

@@ -1453,7 +1453,7 @@ export default class StreamController
           video.container
         }, codecs[level/parsed]=[${currentLevel.videoCodec || ''}/${
           parsedVideoCodec
-        }${video.codec !== parsedVideoCodec ? ' parsed-corrected=' + video.codec : ''}}]`,
+        }]${video.codec !== parsedVideoCodec ? ' parsed-corrected=' + video.codec : ''}${video.supplemental ? ' supplemental=' + video.supplemental : ''}`,
       );
       delete tracks.audiovideo;
     }

package/src/demux/mp4demuxer.ts

@@ -71,10 +71,11 @@ class MP4Demuxer implements Demuxer {
     const initData = parseInitSegment(initSegment);
 
     if (initData.video) {
-      const { id, timescale, codec } = initData.video;
+      const { id, timescale, codec, supplemental } = initData.video;
       videoTrack.id = id;
       videoTrack.timescale = captionTrack.timescale = timescale;
       videoTrack.codec = codec;
+      videoTrack.supplemental = supplemental;
     }
 
     if (initData.audio) {

package/src/hls.ts

@@ -1477,6 +1477,7 @@ export type { Bufferable } from './utils/buffer-helper';
 export type { CaptionScreen } from './utils/cea-608-parser';
 export type { CuesInterface } from './utils/cues';
 export type {
+  CodecsParsed,
   HdcpLevels,
   HlsSkip,
   HlsUrlParameters,

package/src/loader/m3u8-parser.ts

@@ -14,7 +14,12 @@ import {
 } from '../utils/variable-substitution';
 import type { MediaFragment } from './fragment';
 import type { ContentSteeringOptions } from '../types/events';
-import type { LevelAttributes, LevelParsed, VariableMap } from '../types/level';
+import type {
+  CodecsParsed,
+  LevelAttributes,
+  LevelParsed,
+  VariableMap,
+} from '../types/level';
 import type { PlaylistLevelType } from '../types/loader';
 import type { MediaAttributes, MediaPlaylist } from '../types/media-playlist';
 import type { CodecType } from '../utils/codecs';
@@ -138,6 +143,11 @@ export default class M3U8Parser {
         }
 
         setCodecs(attrs.CODECS, level);
+        const supplementalCodecs = attrs['SUPPLEMENTAL-CODECS'];
+        if (supplementalCodecs) {
+          level.supplemental = {};
+          setCodecs(supplementalCodecs, level.supplemental);
+        }
 
         if (!level.unknownCodecs?.length) {
           levelsWithKnownCodecs.push(level);
@@ -822,14 +832,14 @@ function parseStartTimeOffset(startAttributes: string): number | null {
 
 function setCodecs(
   codecsAttributeValue: string | undefined,
-  level: LevelParsed,
+  level: CodecsParsed,
 ) {
   let codecs = (codecsAttributeValue || '').split(/[ ,]+/).filter((c) => c);
   ['video', 'audio', 'text'].forEach((type: CodecType) => {
     const filtered = codecs.filter((codec) => isCodecType(codec, type));
     if (filtered.length) {
       // Comma separated list of all codecs for type
-      level[`${type}Codec`] = filtered.join(',');
+      level[`${type}Codec`] = filtered.map((c) => c.split('/')[0]).join(',');
       // Remove known codecs so that only unknownCodecs are left after iterating through each type
       codecs = codecs.filter((codec) => filtered.indexOf(codec) === -1);
     }

package/src/remux/passthrough-remuxer.ts

@@ -117,6 +117,7 @@ class PassThroughRemuxer implements Remuxer {
       tracks.video = {
         container: 'video/mp4',
         codec: videoCodec,
+        supplemental: initData.video.supplemental,
         initSegment,
         id: 'main',
       };

package/src/types/buffer.ts

@@ -20,6 +20,7 @@ export interface BaseTrack {
   id: 'audio' | 'main';
   container: string;
   codec?: string;
+  supplemental?: string;
   levelCodec?: string;
   pendingCodec?: string;
   metadata?: {

package/src/types/demuxer.ts

@@ -57,6 +57,7 @@ export interface PassthroughTrack extends DemuxedTrack {
   timescale: number;
   duration: number;
   codec: string;
+  supplemental: string | undefined;
 }
 export interface DemuxedAudioTrack extends DemuxedTrack {
   type: 'audio';

package/src/types/level.ts

@@ -3,21 +3,25 @@ import type { LevelDetails } from '../loader/level-details';
 import type { AttrList } from '../utils/attr-list';
 import type { MediaDecodingInfo } from '../utils/mediacapabilities-helper';
 
-export interface LevelParsed {
+export interface LevelParsed extends CodecsParsed {
   attrs: LevelAttributes;
-  audioCodec?: string;
   bitrate: number;
   details?: LevelDetails;
   height?: number;
   id?: number;
   name: string;
-  textCodec?: string;
-  unknownCodecs?: string[];
+  supplemental?: CodecsParsed;
   url: string;
-  videoCodec?: string;
   width?: number;
 }
 
+export interface CodecsParsed {
+  audioCodec?: string;
+  videoCodec?: string;
+  textCodec?: string;
+  unknownCodecs?: string[];
+}
+
 export interface LevelAttributes extends AttrList {
   'ALLOWED-CPC'?: string;
   AUDIO?: string;
@@ -110,6 +114,7 @@ export class Level {
   public readonly height: number;
   public readonly id: number;
   public readonly name: string;
+  public readonly supplemental: CodecsParsed | undefined;
   public readonly videoCodec: string | undefined;
   public readonly width: number;
   public details?: LevelDetails;
@@ -144,6 +149,13 @@ export class Level {
       .filter((c) => !!c)
       .map((s: string) => s.substring(0, 4))
       .join(',');
+    if ('supplemental' in data) {
+      this.supplemental = data.supplemental;
+      const supplementalVideo = data.supplemental?.videoCodec;
+      if (supplementalVideo && supplementalVideo !== data.videoCodec) {
+        this.codecSet += `,${supplementalVideo.substring(0, 4)}`;
+      }
+    }
     this.addGroupId('audio', data.attrs.AUDIO);
     this.addGroupId('text', data.attrs.SUBTITLES);
   }

package/src/utils/attr-list.ts

@@ -36,7 +36,7 @@ export class AttrList {
     return intValue;
   }
 
-  hexadecimalInteger(attrName: string): Uint8Array | null {
+  hexadecimalInteger(attrName: string) {
     if (this[attrName]) {
       let stringValue = (this[attrName] || '0x').slice(2);
       stringValue = (stringValue.length & 1 ? '0' : '') + stringValue;

package/src/utils/codecs.ts

@@ -53,6 +53,7 @@ export const sampleEntryCodesISO = {
     avc4: 1,
     avcp: 1,
     av01: 0.8,
+    dav1: 0.8,
     drac: 1,
     dva1: 1,
     dvav: 1,

package/src/utils/mediacapabilities-helper.ts

@@ -30,6 +30,24 @@ export const SUPPORTED_INFO_DEFAULT: MediaDecodingInfo = {
   ],
 } as const;
 
+export function getUnsupportedResult(
+  error: Error,
+  configurations: MediaDecodingConfiguration[],
+): MediaDecodingInfo {
+  return {
+    supported: false,
+    configurations,
+    decodingInfoResults: [
+      {
+        supported: false,
+        smooth: false,
+        powerEfficient: false,
+      },
+    ],
+    error,
+  };
+}
+
 export const SUPPORTED_INFO_CACHE: Record<
   string,
   Promise<MediaCapabilitiesDecodingInfo>
@@ -128,20 +146,14 @@ export function getMediaDecodingInfoPromise(
       videoCodecsArray.some((videoCodec) => isHEVC(videoCodec)) &&
       userAgentHevcSupportIsInaccurate()
     ) {
-      return Promise.resolve({
-        supported: false,
-        configurations,
-        decodingInfoResults: [
-          {
-            supported: false,
-            smooth: false,
-            powerEfficient: false,
-          },
-        ],
-        error: new Error(
-          `Overriding Windows Firefox HEVC MediaCapabilities result based on user-agent sting: (${ua})`,
+      return Promise.resolve(
+        getUnsupportedResult(
+          new Error(
+            `Overriding Windows Firefox HEVC MediaCapabilities result based on user-agent sting: (${ua})`,
+          ),
+          configurations,
         ),
-      });
+      );
     }
     configurations.push.apply(
       configurations,

package/src/utils/mp4-tools.ts

@@ -223,6 +223,7 @@ export interface InitDataTrack {
   timescale: number;
   id: number;
   codec: string;
+  supplemental: string | undefined;
 }
 
 type HdlrType = ElementaryStreamTypes.AUDIO | ElementaryStreamTypes.VIDEO;
@@ -290,11 +291,16 @@ export function parseInitSegment(initSegment: Uint8Array): InitData {
   return result;
 }
 
-function parseStsd(stsd: Uint8Array): { codec: string; encrypted: boolean } {
+function parseStsd(stsd: Uint8Array): {
+  codec: string;
+  encrypted: boolean;
+  supplemental: string | undefined;
+} {
   const sampleEntries = stsd.subarray(8);
   const sampleEntriesEnd = sampleEntries.subarray(8 + 78);
   const fourCC = bin2str(sampleEntries.subarray(4, 8));
   let codec = fourCC;
+  let supplemental;
   const encrypted = fourCC === 'enca' || fourCC === 'encv';
   if (encrypted) {
     const encBox = findBox(sampleEntries, [fourCC])[0];
@@ -314,6 +320,7 @@ function parseStsd(stsd: Uint8Array): { codec: string; encrypted: boolean } {
       }
     });
   }
+  const codecFourCC = codec;
   switch (codec) {
     case 'avc1':
     case 'avc2':
@@ -322,6 +329,10 @@ function parseStsd(stsd: Uint8Array): { codec: string; encrypted: boolean } {
       // extract profile + compatibility + level out of avcC box
       const avcCBox = findBox(sampleEntriesEnd, ['avcC'])[0];
       codec += '.' + toHex(avcCBox[1]) + toHex(avcCBox[2]) + toHex(avcCBox[3]);
+      supplemental = parseSupplementalDoViCodec(
+        codecFourCC === 'avc1' ? 'dva1' : 'dvav',
+        sampleEntriesEnd,
+      );
       break;
     }
     case 'mp4a': {
@@ -371,34 +382,41 @@ function parseStsd(stsd: Uint8Array): { codec: string; encrypted: boolean } {
     }
     case 'hvc1':
     case 'hev1': {
-      const hvcCBox = findBox(sampleEntriesEnd, ['hvcC'])[0];
-      const profileByte = hvcCBox[1];
-      const profileSpace = ['', 'A', 'B', 'C'][profileByte >> 6];
-      const generalProfileIdc = profileByte & 0x1f;
-      const profileCompat = readUint32(hvcCBox, 2);
-      const tierFlag = (profileByte & 0x20) >> 5 ? 'H' : 'L';
-      const levelIDC = hvcCBox[12];
-      const constraintIndicator = hvcCBox.subarray(6, 12);
-      codec += '.' + profileSpace + generalProfileIdc;
-      codec += '.' + profileCompat.toString(16).toUpperCase();
-      codec += '.' + tierFlag + levelIDC;
-      let constraintString = '';
-      for (let i = constraintIndicator.length; i--; ) {
-        const byte = constraintIndicator[i];
-        if (byte || constraintString) {
-          const encodedByte = byte.toString(16).toUpperCase();
-          constraintString = '.' + encodedByte + constraintString;
+      const hvcCBoxes = findBox(sampleEntriesEnd, ['hvcC']);
+      if (hvcCBoxes) {
+        const hvcCBox = hvcCBoxes[0];
+        const profileByte = hvcCBox[1];
+        const profileSpace = ['', 'A', 'B', 'C'][profileByte >> 6];
+        const generalProfileIdc = profileByte & 0x1f;
+        const profileCompat = readUint32(hvcCBox, 2);
+        const tierFlag = (profileByte & 0x20) >> 5 ? 'H' : 'L';
+        const levelIDC = hvcCBox[12];
+        const constraintIndicator = hvcCBox.subarray(6, 12);
+        codec += '.' + profileSpace + generalProfileIdc;
+        codec += '.' + profileCompat.toString(16).toUpperCase();
+        codec += '.' + tierFlag + levelIDC;
+        let constraintString = '';
+        for (let i = constraintIndicator.length; i--; ) {
+          const byte = constraintIndicator[i];
+          if (byte || constraintString) {
+            const encodedByte = byte.toString(16).toUpperCase();
+            constraintString = '.' + encodedByte + constraintString;
+          }
         }
+        codec += constraintString;
       }
-      codec += constraintString;
+      supplemental = parseSupplementalDoViCodec(
+        codecFourCC == 'hev1' ? 'dvhe' : 'dvh1',
+        sampleEntriesEnd,
+      );
       break;
     }
     case 'dvh1':
-    case 'dvhe': {
-      const dvcCBox = findBox(sampleEntriesEnd, ['dvcC'])[0];
-      const profile = (dvcCBox[2] >> 1) & 0x7f;
-      const level = ((dvcCBox[2] << 5) & 0x20) | ((dvcCBox[3] >> 3) & 0x1f);
-      codec += '.' + addLeadingZero(profile) + '.' + addLeadingZero(level);
+    case 'dvhe':
+    case 'dvav':
+    case 'dva1':
+    case 'dav1': {
+      codec = parseSupplementalDoViCodec(codec, sampleEntriesEnd) || codec;
       break;
     }
     case 'vp09': {
@@ -463,6 +481,7 @@ function parseStsd(stsd: Uint8Array): { codec: string; encrypted: boolean } {
         addLeadingZero(matrixCoefficients) +
         '.' +
         videoFullRangeFlag;
+      supplemental = parseSupplementalDoViCodec('dav1', sampleEntriesEnd);
       break;
     }
     case 'ac-3':
@@ -473,7 +492,28 @@ function parseStsd(stsd: Uint8Array): { codec: string; encrypted: boolean } {
     default:
       break;
   }
-  return { codec, encrypted };
+  return { codec, encrypted, supplemental };
+}
+
+function parseSupplementalDoViCodec(
+  fourCC: string,
+  sampleEntriesEnd: Uint8Array,
+): string | undefined {
+  const dvvCResult = findBox(sampleEntriesEnd, ['dvvC']); // used by DoVi Profile 8 to 10
+  const dvXCBox = dvvCResult.length
+    ? dvvCResult[0]
+    : findBox(sampleEntriesEnd, ['dvcC'])[0]; // used by DoVi Profiles up to 7 and 20
+  if (dvXCBox) {
+    const doViProfile = (dvXCBox[2] >> 1) & 0x7f;
+    const doViLevel = ((dvXCBox[2] << 5) & 0x20) | ((dvXCBox[3] >> 3) & 0x1f);
+    return (
+      fourCC +
+      '.' +
+      addLeadingZero(doViProfile) +
+      '.' +
+      addLeadingZero(doViLevel)
+    );
+  }
 }
 
 function skipBERInteger(bytes: Uint8Array, i: number): number {