Favivon - Correção

node_modules/hls.js/src/demux/audio/aacdemuxer.ts

@@ -0,0 +1,96 @@
+/**
+ * AAC demuxer
+ */
+import { getId3Data } from '@svta/common-media-library/id3/getId3Data';
+import * as ADTS from './adts';
+import BaseAudioDemuxer from './base-audio-demuxer';
+import * as MpegAudio from './mpegaudio';
+import type { HlsConfig } from '../../config';
+import type { HlsEventEmitter } from '../../events';
+import type { DemuxedAudioTrack } from '../../types/demuxer';
+import type { ILogger } from '../../utils/logger';
+
+class AACDemuxer extends BaseAudioDemuxer {
+  private readonly observer: HlsEventEmitter;
+  private readonly config: HlsConfig;
+
+  constructor(observer: HlsEventEmitter, config) {
+    super();
+    this.observer = observer;
+    this.config = config;
+  }
+
+  resetInitSegment(
+    initSegment: Uint8Array | undefined,
+    audioCodec: string | undefined,
+    videoCodec: string | undefined,
+    trackDuration: number,
+  ) {
+    super.resetInitSegment(initSegment, audioCodec, videoCodec, trackDuration);
+    this._audioTrack = {
+      container: 'audio/adts',
+      type: 'audio',
+      id: 2,
+      pid: -1,
+      sequenceNumber: 0,
+      segmentCodec: 'aac',
+      samples: [],
+      manifestCodec: audioCodec,
+      duration: trackDuration,
+      inputTimeScale: 90000,
+      dropped: 0,
+    };
+  }
+
+  // Source for probe info - https://wiki.multimedia.cx/index.php?title=ADTS
+  static probe(data: Uint8Array | undefined, logger: ILogger): boolean {
+    if (!data) {
+      return false;
+    }
+
+    // Check for the ADTS sync word
+    // Look for ADTS header | 1111 1111 | 1111 X00X | where X can be either 0 or 1
+    // Layer bits (position 14 and 15) in header should be always 0 for ADTS
+    // More info https://wiki.multimedia.cx/index.php?title=ADTS
+    const id3Data = getId3Data(data, 0);
+    let offset = id3Data?.length || 0;
+
+    if (MpegAudio.probe(data, offset)) {
+      return false;
+    }
+
+    for (let length = data.length; offset < length; offset++) {
+      if (ADTS.probe(data, offset)) {
+        logger.log('ADTS sync word found !');
+        return true;
+      }
+    }
+    return false;
+  }
+
+  canParse(data, offset) {
+    return ADTS.canParse(data, offset);
+  }
+
+  appendFrame(track: DemuxedAudioTrack, data: Uint8Array, offset: number) {
+    ADTS.initTrackConfig(
+      track,
+      this.observer,
+      data,
+      offset,
+      track.manifestCodec,
+    );
+    const frame = ADTS.appendFrame(
+      track,
+      data,
+      offset,
+      this.basePTS as number,
+      this.frameIndex,
+    );
+    if (frame && frame.missing === 0) {
+      return frame;
+    }
+  }
+}
+
+export default AACDemuxer;

node_modules/hls.js/src/demux/audio/ac3-demuxer.ts

@@ -0,0 +1,170 @@
+import { getId3Data } from '@svta/common-media-library/id3/getId3Data';
+import { getId3Timestamp } from '@svta/common-media-library/id3/getId3Timestamp';
+import BaseAudioDemuxer from './base-audio-demuxer';
+import { getAudioBSID } from './dolby';
+import type { HlsEventEmitter } from '../../events';
+import type { AudioFrame, DemuxedAudioTrack } from '../../types/demuxer';
+
+export class AC3Demuxer extends BaseAudioDemuxer {
+  private readonly observer: HlsEventEmitter;
+
+  constructor(observer: HlsEventEmitter) {
+    super();
+    this.observer = observer;
+  }
+
+  resetInitSegment(
+    initSegment: Uint8Array | undefined,
+    audioCodec: string | undefined,
+    videoCodec: string | undefined,
+    trackDuration: number,
+  ) {
+    super.resetInitSegment(initSegment, audioCodec, videoCodec, trackDuration);
+    this._audioTrack = {
+      container: 'audio/ac-3',
+      type: 'audio',
+      id: 2,
+      pid: -1,
+      sequenceNumber: 0,
+      segmentCodec: 'ac3',
+      samples: [],
+      manifestCodec: audioCodec,
+      duration: trackDuration,
+      inputTimeScale: 90000,
+      dropped: 0,
+    };
+  }
+
+  canParse(data: Uint8Array, offset: number): boolean {
+    return offset + 64 < data.length;
+  }
+
+  appendFrame(
+    track: DemuxedAudioTrack,
+    data: Uint8Array,
+    offset: number,
+  ): AudioFrame | void {
+    const frameLength = appendFrame(
+      track,
+      data,
+      offset,
+      this.basePTS as number,
+      this.frameIndex,
+    );
+    if (frameLength !== -1) {
+      const sample = track.samples[track.samples.length - 1];
+      return { sample, length: frameLength, missing: 0 };
+    }
+  }
+
+  static probe(data: Uint8Array | undefined): boolean {
+    if (!data) {
+      return false;
+    }
+
+    const id3Data = getId3Data(data, 0);
+    if (!id3Data) {
+      return false;
+    }
+
+    // look for the ac-3 sync bytes
+    const offset = id3Data.length;
+    if (
+      data[offset] === 0x0b &&
+      data[offset + 1] === 0x77 &&
+      getId3Timestamp(id3Data) !== undefined &&
+      // check the bsid to confirm ac-3
+      getAudioBSID(data, offset) < 16
+    ) {
+      return true;
+    }
+    return false;
+  }
+}
+
+export function appendFrame(
+  track: DemuxedAudioTrack,
+  data: Uint8Array,
+  start: number,
+  pts: number,
+  frameIndex: number,
+): number {
+  if (start + 8 > data.length) {
+    return -1; // not enough bytes left
+  }
+
+  if (data[start] !== 0x0b || data[start + 1] !== 0x77) {
+    return -1; // invalid magic
+  }
+
+  // get sample rate
+  const samplingRateCode = data[start + 4] >> 6;
+  if (samplingRateCode >= 3) {
+    return -1; // invalid sampling rate
+  }
+
+  const samplingRateMap = [48000, 44100, 32000];
+  const sampleRate = samplingRateMap[samplingRateCode];
+
+  // get frame size
+  const frameSizeCode = data[start + 4] & 0x3f;
+  const frameSizeMap = [
+    64, 69, 96, 64, 70, 96, 80, 87, 120, 80, 88, 120, 96, 104, 144, 96, 105,
+    144, 112, 121, 168, 112, 122, 168, 128, 139, 192, 128, 140, 192, 160, 174,
+    240, 160, 175, 240, 192, 208, 288, 192, 209, 288, 224, 243, 336, 224, 244,
+    336, 256, 278, 384, 256, 279, 384, 320, 348, 480, 320, 349, 480, 384, 417,
+    576, 384, 418, 576, 448, 487, 672, 448, 488, 672, 512, 557, 768, 512, 558,
+    768, 640, 696, 960, 640, 697, 960, 768, 835, 1152, 768, 836, 1152, 896, 975,
+    1344, 896, 976, 1344, 1024, 1114, 1536, 1024, 1115, 1536, 1152, 1253, 1728,
+    1152, 1254, 1728, 1280, 1393, 1920, 1280, 1394, 1920,
+  ];
+
+  const frameLength = frameSizeMap[frameSizeCode * 3 + samplingRateCode] * 2;
+  if (start + frameLength > data.length) {
+    return -1;
+  }
+
+  // get channel count
+  const channelMode = data[start + 6] >> 5;
+  let skipCount = 0;
+  if (channelMode === 2) {
+    skipCount += 2;
+  } else {
+    if (channelMode & 1 && channelMode !== 1) {
+      skipCount += 2;
+    }
+    if (channelMode & 4) {
+      skipCount += 2;
+    }
+  }
+
+  const lfeon =
+    (((data[start + 6] << 8) | data[start + 7]) >> (12 - skipCount)) & 1;
+
+  const channelsMap = [2, 1, 2, 3, 3, 4, 4, 5];
+  const channelCount = channelsMap[channelMode] + lfeon;
+
+  // build dac3 box
+  const bsid = data[start + 5] >> 3;
+  const bsmod = data[start + 5] & 7;
+
+  const config = new Uint8Array([
+    (samplingRateCode << 6) | (bsid << 1) | (bsmod >> 2),
+    ((bsmod & 3) << 6) |
+      (channelMode << 3) |
+      (lfeon << 2) |
+      (frameSizeCode >> 4),
+    (frameSizeCode << 4) & 0xe0,
+  ]);
+
+  const frameDuration = (1536 / sampleRate) * 90000;
+  const stamp = pts + frameIndex * frameDuration;
+  const unit = data.subarray(start, start + frameLength);
+
+  track.config = config;
+  track.channelCount = channelCount;
+  track.samplerate = sampleRate;
+  track.samples.push({ unit, pts: stamp });
+
+  return frameLength;
+}

node_modules/hls.js/src/demux/audio/adts.ts

@@ -0,0 +1,249 @@
+/**
+ * ADTS parser helper
+ * @link https://wiki.multimedia.cx/index.php?title=ADTS
+ */
+import { ErrorDetails, ErrorTypes } from '../../errors';
+import { Events } from '../../events';
+import { logger } from '../../utils/logger';
+import type { HlsEventEmitter } from '../../events';
+import type {
+  AudioFrame,
+  AudioSample,
+  DemuxedAudioTrack,
+} from '../../types/demuxer';
+
+type AudioConfig = {
+  config: [number, number];
+  samplerate: number;
+  channelCount: number;
+  codec: string;
+  parsedCodec: string;
+  manifestCodec: string | undefined;
+};
+
+type FrameHeader = {
+  headerLength: number;
+  frameLength: number;
+};
+
+export function getAudioConfig(
+  observer: HlsEventEmitter,
+  data: Uint8Array,
+  offset: number,
+  manifestCodec: string | undefined,
+): AudioConfig | void {
+  const adtsSamplingRates = [
+    96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025,
+    8000, 7350,
+  ];
+  const byte2 = data[offset + 2];
+  const adtsSamplingIndex = (byte2 >> 2) & 0xf;
+  if (adtsSamplingIndex > 12) {
+    const error = new Error(`invalid ADTS sampling index:${adtsSamplingIndex}`);
+    observer.emit(Events.ERROR, Events.ERROR, {
+      type: ErrorTypes.MEDIA_ERROR,
+      details: ErrorDetails.FRAG_PARSING_ERROR,
+      fatal: true,
+      error,
+      reason: error.message,
+    });
+    return;
+  }
+  // MPEG-4 Audio Object Type (profile_ObjectType+1)
+  const adtsObjectType = ((byte2 >> 6) & 0x3) + 1;
+  const channelCount = ((data[offset + 3] >> 6) & 0x3) | ((byte2 & 1) << 2);
+  const codec = 'mp4a.40.' + adtsObjectType;
+  /* refer to http://wiki.multimedia.cx/index.php?title=MPEG-4_Audio#Audio_Specific_Config
+      ISO/IEC 14496-3 - Table 1.13 — Syntax of AudioSpecificConfig()
+    Audio Profile / Audio Object Type
+    0: Null
+    1: AAC Main
+    2: AAC LC (Low Complexity)
+    3: AAC SSR (Scalable Sample Rate)
+    4: AAC LTP (Long Term Prediction)
+    5: SBR (Spectral Band Replication)
+    6: AAC Scalable
+   sampling freq
+    0: 96000 Hz
+    1: 88200 Hz
+    2: 64000 Hz
+    3: 48000 Hz
+    4: 44100 Hz
+    5: 32000 Hz
+    6: 24000 Hz
+    7: 22050 Hz
+    8: 16000 Hz
+    9: 12000 Hz
+    10: 11025 Hz
+    11: 8000 Hz
+    12: 7350 Hz
+    13: Reserved
+    14: Reserved
+    15: frequency is written explictly
+    Channel Configurations
+    These are the channel configurations:
+    0: Defined in AOT Specifc Config
+    1: 1 channel: front-center
+    2: 2 channels: front-left, front-right
+  */
+  // audioObjectType = profile => profile, the MPEG-4 Audio Object Type minus 1
+  const samplerate = adtsSamplingRates[adtsSamplingIndex];
+  let aacSampleIndex = adtsSamplingIndex;
+  if (adtsObjectType === 5 || adtsObjectType === 29) {
+    // HE-AAC uses SBR (Spectral Band Replication) , high frequencies are constructed from low frequencies
+    // there is a factor 2 between frame sample rate and output sample rate
+    // multiply frequency by 2 (see table above, equivalent to substract 3)
+    aacSampleIndex -= 3;
+  }
+  const config: [number, number] = [
+    (adtsObjectType << 3) | ((aacSampleIndex & 0x0e) >> 1),
+    ((aacSampleIndex & 0x01) << 7) | (channelCount << 3),
+  ];
+  logger.log(
+    `manifest codec:${manifestCodec}, parsed codec:${codec}, channels:${channelCount}, rate:${samplerate} (ADTS object type:${adtsObjectType} sampling index:${adtsSamplingIndex})`,
+  );
+  return {
+    config,
+    samplerate,
+    channelCount,
+    codec,
+    parsedCodec: codec,
+    manifestCodec,
+  };
+}
+
+export function isHeaderPattern(data: Uint8Array, offset: number): boolean {
+  return data[offset] === 0xff && (data[offset + 1] & 0xf6) === 0xf0;
+}
+
+export function getHeaderLength(data: Uint8Array, offset: number): number {
+  return data[offset + 1] & 0x01 ? 7 : 9;
+}
+
+export function getFullFrameLength(data: Uint8Array, offset: number): number {
+  return (
+    ((data[offset + 3] & 0x03) << 11) |
+    (data[offset + 4] << 3) |
+    ((data[offset + 5] & 0xe0) >>> 5)
+  );
+}
+
+export function canGetFrameLength(data: Uint8Array, offset: number): boolean {
+  return offset + 5 < data.length;
+}
+
+export function isHeader(data: Uint8Array, offset: number): boolean {
+  // Look for ADTS header | 1111 1111 | 1111 X00X | where X can be either 0 or 1
+  // Layer bits (position 14 and 15) in header should be always 0 for ADTS
+  // More info https://wiki.multimedia.cx/index.php?title=ADTS
+  return offset + 1 < data.length && isHeaderPattern(data, offset);
+}
+
+export function canParse(data: Uint8Array, offset: number): boolean {
+  return (
+    canGetFrameLength(data, offset) &&
+    isHeaderPattern(data, offset) &&
+    getFullFrameLength(data, offset) <= data.length - offset
+  );
+}
+
+export function probe(data: Uint8Array, offset: number): boolean {
+  // same as isHeader but we also check that ADTS frame follows last ADTS frame
+  // or end of data is reached
+  if (isHeader(data, offset)) {
+    // ADTS header Length
+    const headerLength = getHeaderLength(data, offset);
+    if (offset + headerLength >= data.length) {
+      return false;
+    }
+    // ADTS frame Length
+    const frameLength = getFullFrameLength(data, offset);
+    if (frameLength <= headerLength) {
+      return false;
+    }
+
+    const newOffset = offset + frameLength;
+    return newOffset === data.length || isHeader(data, newOffset);
+  }
+  return false;
+}
+
+export function initTrackConfig(
+  track: DemuxedAudioTrack,
+  observer: HlsEventEmitter,
+  data: Uint8Array,
+  offset: number,
+  audioCodec: string | undefined,
+) {
+  if (!track.samplerate) {
+    const config = getAudioConfig(observer, data, offset, audioCodec);
+    if (!config) {
+      return;
+    }
+    Object.assign(track, config);
+  }
+}
+
+export function getFrameDuration(samplerate: number): number {
+  return (1024 * 90000) / samplerate;
+}
+
+export function parseFrameHeader(
+  data: Uint8Array,
+  offset: number,
+): FrameHeader | void {
+  // The protection skip bit tells us if we have 2 bytes of CRC data at the end of the ADTS header
+  const headerLength = getHeaderLength(data, offset);
+  if (offset + headerLength <= data.length) {
+    // retrieve frame size
+    const frameLength = getFullFrameLength(data, offset) - headerLength;
+    if (frameLength > 0) {
+      // logger.log(`AAC frame, offset/length/total/pts:${offset+headerLength}/${frameLength}/${data.byteLength}`);
+      return { headerLength, frameLength };
+    }
+  }
+}
+
+export function appendFrame(
+  track: DemuxedAudioTrack,
+  data: Uint8Array,
+  offset: number,
+  pts: number,
+  frameIndex: number,
+): AudioFrame {
+  const frameDuration = getFrameDuration(track.samplerate as number);
+  const stamp = pts + frameIndex * frameDuration;
+  const header = parseFrameHeader(data, offset);
+  let unit: Uint8Array;
+  if (header) {
+    const { frameLength, headerLength } = header;
+    const length = headerLength + frameLength;
+    const missing = Math.max(0, offset + length - data.length);
+    // logger.log(`AAC frame ${frameIndex}, pts:${stamp} length@offset/total: ${frameLength}@${offset+headerLength}/${data.byteLength} missing: ${missing}`);
+    if (missing) {
+      unit = new Uint8Array(length - headerLength);
+      unit.set(data.subarray(offset + headerLength, data.length), 0);
+    } else {
+      unit = data.subarray(offset + headerLength, offset + length);
+    }
+
+    const sample: AudioSample = {
+      unit,
+      pts: stamp,
+    };
+    if (!missing) {
+      track.samples.push(sample as AudioSample);
+    }
+
+    return { sample, length, missing };
+  }
+  // overflow incomplete header
+  const length = data.length - offset;
+  unit = new Uint8Array(length);
+  unit.set(data.subarray(offset, data.length), 0);
+  const sample: AudioSample = {
+    unit,
+    pts: stamp,
+  };
+  return { sample, length, missing: -1 };
+}

node_modules/hls.js/src/demux/audio/base-audio-demuxer.ts

@@ -0,0 +1,205 @@
+import { canParseId3 } from '@svta/common-media-library/id3/canParseId3';
+import { getId3Data } from '@svta/common-media-library/id3/getId3Data';
+import { getId3Timestamp } from '@svta/common-media-library/id3/getId3Timestamp';
+import {
+  type AudioFrame,
+  type DemuxedAudioTrack,
+  type DemuxedMetadataTrack,
+  type DemuxedUserdataTrack,
+  type DemuxedVideoTrackBase,
+  type Demuxer,
+  type DemuxerResult,
+  type KeyData,
+  MetadataSchema,
+} from '../../types/demuxer';
+import { appendUint8Array } from '../../utils/mp4-tools';
+import { dummyTrack } from '../dummy-demuxed-track';
+import type {
+  RationalTimestamp,
+  TimestampOffset,
+} from '../../utils/timescale-conversion';
+
+class BaseAudioDemuxer implements Demuxer {
+  protected _audioTrack?: DemuxedAudioTrack;
+  protected _id3Track?: DemuxedMetadataTrack;
+  protected frameIndex: number = 0;
+  protected cachedData: Uint8Array | null = null;
+  protected basePTS: number | null = null;
+  protected initPTS: TimestampOffset | null = null;
+  protected lastPTS: number | null = null;
+
+  resetInitSegment(
+    initSegment: Uint8Array | undefined,
+    audioCodec: string | undefined,
+    videoCodec: string | undefined,
+    trackDuration: number,
+  ) {
+    this._id3Track = {
+      type: 'id3',
+      id: 3,
+      pid: -1,
+      inputTimeScale: 90000,
+      sequenceNumber: 0,
+      samples: [],
+      dropped: 0,
+    };
+  }
+
+  resetTimeStamp(deaultTimestamp: TimestampOffset | null) {
+    this.initPTS = deaultTimestamp;
+    this.resetContiguity();
+  }
+
+  resetContiguity(): void {
+    this.basePTS = null;
+    this.lastPTS = null;
+    this.frameIndex = 0;
+  }
+
+  canParse(data: Uint8Array, offset: number): boolean {
+    return false;
+  }
+
+  appendFrame(
+    track: DemuxedAudioTrack,
+    data: Uint8Array,
+    offset: number,
+  ): AudioFrame | void {}
+
+  // feed incoming data to the front of the parsing pipeline
+  demux(data: Uint8Array, timeOffset: number): DemuxerResult {
+    if (this.cachedData) {
+      data = appendUint8Array(this.cachedData, data);
+      this.cachedData = null;
+    }
+
+    let id3Data: Uint8Array | undefined = getId3Data(data, 0);
+    let offset = id3Data ? id3Data.length : 0;
+    let lastDataIndex;
+    const track = this._audioTrack as DemuxedAudioTrack;
+    const id3Track = this._id3Track as DemuxedMetadataTrack;
+    const timestamp = id3Data ? getId3Timestamp(id3Data) : undefined;
+    const length = data.length;
+
+    if (
+      this.basePTS === null ||
+      (this.frameIndex === 0 && Number.isFinite(timestamp))
+    ) {
+      this.basePTS = initPTSFn(timestamp, timeOffset, this.initPTS);
+      this.lastPTS = this.basePTS;
+    }
+
+    if (this.lastPTS === null) {
+      this.lastPTS = this.basePTS;
+    }
+
+    // more expressive than alternative: id3Data?.length
+    if (id3Data && id3Data.length > 0) {
+      id3Track.samples.push({
+        pts: this.lastPTS,
+        dts: this.lastPTS,
+        data: id3Data,
+        type: MetadataSchema.audioId3,
+        duration: Number.POSITIVE_INFINITY,
+      });
+    }
+
+    while (offset < length) {
+      if (this.canParse(data, offset)) {
+        const frame = this.appendFrame(track, data, offset);
+        if (frame) {
+          this.frameIndex++;
+          this.lastPTS = frame.sample.pts;
+          offset += frame.length;
+          lastDataIndex = offset;
+        } else {
+          offset = length;
+        }
+      } else if (canParseId3(data, offset)) {
+        // after a canParse, a call to getId3Data *should* always returns some data
+        id3Data = getId3Data(data, offset)!;
+        id3Track.samples.push({
+          pts: this.lastPTS,
+          dts: this.lastPTS,
+          data: id3Data,
+          type: MetadataSchema.audioId3,
+          duration: Number.POSITIVE_INFINITY,
+        });
+        offset += id3Data.length;
+        lastDataIndex = offset;
+      } else {
+        offset++;
+      }
+      if (offset === length && lastDataIndex !== length) {
+        const partialData = data.slice(lastDataIndex);
+        if (this.cachedData) {
+          this.cachedData = appendUint8Array(this.cachedData, partialData);
+        } else {
+          this.cachedData = partialData;
+        }
+      }
+    }
+
+    return {
+      audioTrack: track,
+      videoTrack: dummyTrack() as DemuxedVideoTrackBase,
+      id3Track,
+      textTrack: dummyTrack() as DemuxedUserdataTrack,
+    };
+  }
+
+  demuxSampleAes(
+    data: Uint8Array,
+    keyData: KeyData,
+    timeOffset: number,
+  ): Promise<DemuxerResult> {
+    return Promise.reject(
+      new Error(
+        `[${this}] This demuxer does not support Sample-AES decryption`,
+      ),
+    );
+  }
+
+  flush(timeOffset: number): DemuxerResult {
+    // Parse cache in case of remaining frames.
+    const cachedData = this.cachedData;
+    if (cachedData) {
+      this.cachedData = null;
+      this.demux(cachedData, 0);
+    }
+
+    return {
+      audioTrack: this._audioTrack as DemuxedAudioTrack,
+      videoTrack: dummyTrack() as DemuxedVideoTrackBase,
+      id3Track: this._id3Track as DemuxedMetadataTrack,
+      textTrack: dummyTrack() as DemuxedUserdataTrack,
+    };
+  }
+
+  destroy() {
+    this.cachedData = null;
+    // @ts-ignore
+    this._audioTrack = this._id3Track = undefined;
+  }
+}
+
+/**
+ * Initialize PTS
+ * <p>
+ *    use timestamp unless it is undefined, NaN or Infinity
+ * </p>
+ */
+export const initPTSFn = (
+  timestamp: number | undefined,
+  timeOffset: number,
+  initPTS: RationalTimestamp | null,
+): number => {
+  if (Number.isFinite(timestamp as number)) {
+    return timestamp! * 90;
+  }
+  const init90kHz = initPTS
+    ? (initPTS.baseTime * 90000) / initPTS.timescale
+    : 0;
+  return timeOffset * 90000 + init90kHz;
+};
+export default BaseAudioDemuxer;

node_modules/hls.js/src/demux/audio/dolby.ts

@@ -0,0 +1,21 @@
+export const getAudioBSID = (data: Uint8Array, offset: number): number => {
+  // check the bsid to confirm ac-3 | ec-3
+  let bsid = 0;
+  let numBits = 5;
+  offset += numBits;
+  const temp = new Uint32Array(1); // unsigned 32 bit for temporary storage
+  const mask = new Uint32Array(1); // unsigned 32 bit mask value
+  const byte = new Uint8Array(1); // unsigned 8 bit for temporary storage
+  while (numBits > 0) {
+    byte[0] = data[offset];
+    // read remaining bits, upto 8 bits at a time
+    const bits = Math.min(numBits, 8);
+    const shift = 8 - bits;
+    mask[0] = (0xff000000 >>> (24 + shift)) << shift;
+    temp[0] = (byte[0] & mask[0]) >> shift;
+    bsid = !bsid ? temp[0] : (bsid << bits) | temp[0];
+    offset += 1;
+    numBits -= bits;
+  }
+  return bsid;
+};

node_modules/hls.js/src/demux/audio/mp3demuxer.ts

@@ -0,0 +1,85 @@
+/**
+ * MP3 demuxer
+ */
+import { getId3Data } from '@svta/common-media-library/id3/getId3Data';
+import { getId3Timestamp } from '@svta/common-media-library/id3/getId3Timestamp';
+import BaseAudioDemuxer from './base-audio-demuxer';
+import { getAudioBSID } from './dolby';
+import * as MpegAudio from './mpegaudio';
+import { logger } from '../../utils/logger';
+
+class MP3Demuxer extends BaseAudioDemuxer {
+  resetInitSegment(
+    initSegment: Uint8Array | undefined,
+    audioCodec: string | undefined,
+    videoCodec: string | undefined,
+    trackDuration: number,
+  ) {
+    super.resetInitSegment(initSegment, audioCodec, videoCodec, trackDuration);
+    this._audioTrack = {
+      container: 'audio/mpeg',
+      type: 'audio',
+      id: 2,
+      pid: -1,
+      sequenceNumber: 0,
+      segmentCodec: 'mp3',
+      samples: [],
+      manifestCodec: audioCodec,
+      duration: trackDuration,
+      inputTimeScale: 90000,
+      dropped: 0,
+    };
+  }
+
+  static probe(data: Uint8Array | undefined): boolean {
+    if (!data) {
+      return false;
+    }
+
+    // check if data contains ID3 timestamp and MPEG sync word
+    // Look for MPEG header | 1111 1111 | 111X XYZX | where X can be either 0 or 1 and Y or Z should be 1
+    // Layer bits (position 14 and 15) in header should be always different from 0 (Layer I or Layer II or Layer III)
+    // More info http://www.mp3-tech.org/programmer/frame_header.html
+    const id3Data = getId3Data(data, 0);
+    let offset = id3Data?.length || 0;
+
+    // Check for ac-3|ec-3 sync bytes and return false if present
+    if (
+      id3Data &&
+      data[offset] === 0x0b &&
+      data[offset + 1] === 0x77 &&
+      getId3Timestamp(id3Data) !== undefined &&
+      // check the bsid to confirm ac-3 or ec-3 (not mp3)
+      getAudioBSID(data, offset) <= 16
+    ) {
+      return false;
+    }
+
+    for (let length = data.length; offset < length; offset++) {
+      if (MpegAudio.probe(data, offset)) {
+        logger.log('MPEG Audio sync word found !');
+        return true;
+      }
+    }
+    return false;
+  }
+
+  canParse(data, offset) {
+    return MpegAudio.canParse(data, offset);
+  }
+
+  appendFrame(track, data, offset) {
+    if (this.basePTS === null) {
+      return;
+    }
+    return MpegAudio.appendFrame(
+      track,
+      data,
+      offset,
+      this.basePTS,
+      this.frameIndex,
+    );
+  }
+}
+
+export default MP3Demuxer;

node_modules/hls.js/src/demux/audio/mpegaudio.ts

@@ -0,0 +1,177 @@
+/**
+ *  MPEG parser helper
+ */
+import type { DemuxedAudioTrack } from '../../types/demuxer';
+
+let chromeVersion: number | null = null;
+
+const BitratesMap = [
+  32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 32, 48, 56,
+  64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 32, 40, 48, 56, 64, 80,
+  96, 112, 128, 160, 192, 224, 256, 320, 32, 48, 56, 64, 80, 96, 112, 128, 144,
+  160, 176, 192, 224, 256, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144,
+  160,
+];
+
+const SamplingRateMap = [
+  44100, 48000, 32000, 22050, 24000, 16000, 11025, 12000, 8000,
+];
+
+const SamplesCoefficients = [
+  // MPEG 2.5
+  [
+    0, // Reserved
+    72, // Layer3
+    144, // Layer2
+    12, // Layer1
+  ],
+  // Reserved
+  [
+    0, // Reserved
+    0, // Layer3
+    0, // Layer2
+    0, // Layer1
+  ],
+  // MPEG 2
+  [
+    0, // Reserved
+    72, // Layer3
+    144, // Layer2
+    12, // Layer1
+  ],
+  // MPEG 1
+  [
+    0, // Reserved
+    144, // Layer3
+    144, // Layer2
+    12, // Layer1
+  ],
+];
+
+const BytesInSlot = [
+  0, // Reserved
+  1, // Layer3
+  1, // Layer2
+  4, // Layer1
+];
+
+export function appendFrame(
+  track: DemuxedAudioTrack,
+  data: Uint8Array,
+  offset: number,
+  pts: number,
+  frameIndex: number,
+) {
+  // Using http://www.datavoyage.com/mpgscript/mpeghdr.htm as a reference
+  if (offset + 24 > data.length) {
+    return;
+  }
+
+  const header = parseHeader(data, offset);
+  if (header && offset + header.frameLength <= data.length) {
+    const frameDuration = (header.samplesPerFrame * 90000) / header.sampleRate;
+    const stamp = pts + frameIndex * frameDuration;
+    const sample = {
+      unit: data.subarray(offset, offset + header.frameLength),
+      pts: stamp,
+      dts: stamp,
+    };
+
+    track.config = [];
+    track.channelCount = header.channelCount;
+    track.samplerate = header.sampleRate;
+    track.samples.push(sample);
+
+    return { sample, length: header.frameLength, missing: 0 };
+  }
+}
+
+export function parseHeader(data: Uint8Array, offset: number) {
+  const mpegVersion = (data[offset + 1] >> 3) & 3;
+  const mpegLayer = (data[offset + 1] >> 1) & 3;
+  const bitRateIndex = (data[offset + 2] >> 4) & 15;
+  const sampleRateIndex = (data[offset + 2] >> 2) & 3;
+  if (
+    mpegVersion !== 1 &&
+    bitRateIndex !== 0 &&
+    bitRateIndex !== 15 &&
+    sampleRateIndex !== 3
+  ) {
+    const paddingBit = (data[offset + 2] >> 1) & 1;
+    const channelMode = data[offset + 3] >> 6;
+    const columnInBitrates =
+      mpegVersion === 3 ? 3 - mpegLayer : mpegLayer === 3 ? 3 : 4;
+    const bitRate =
+      BitratesMap[columnInBitrates * 14 + bitRateIndex - 1] * 1000;
+    const columnInSampleRates =
+      mpegVersion === 3 ? 0 : mpegVersion === 2 ? 1 : 2;
+    const sampleRate =
+      SamplingRateMap[columnInSampleRates * 3 + sampleRateIndex];
+    const channelCount = channelMode === 3 ? 1 : 2; // If bits of channel mode are `11` then it is a single channel (Mono)
+    const sampleCoefficient = SamplesCoefficients[mpegVersion][mpegLayer];
+    const bytesInSlot = BytesInSlot[mpegLayer];
+    const samplesPerFrame = sampleCoefficient * 8 * bytesInSlot;
+    const frameLength =
+      Math.floor((sampleCoefficient * bitRate) / sampleRate + paddingBit) *
+      bytesInSlot;
+
+    if (chromeVersion === null) {
+      const userAgent = navigator.userAgent || '';
+      const result = userAgent.match(/Chrome\/(\d+)/i);
+      chromeVersion = result ? parseInt(result[1]) : 0;
+    }
+    const needChromeFix = !!chromeVersion && chromeVersion <= 87;
+
+    if (
+      needChromeFix &&
+      mpegLayer === 2 &&
+      bitRate >= 224000 &&
+      channelMode === 0
+    ) {
+      // Work around bug in Chromium by setting channelMode to dual-channel (01) instead of stereo (00)
+      data[offset + 3] = data[offset + 3] | 0x80;
+    }
+
+    return { sampleRate, channelCount, frameLength, samplesPerFrame };
+  }
+}
+
+export function isHeaderPattern(data: Uint8Array, offset: number): boolean {
+  return (
+    data[offset] === 0xff &&
+    (data[offset + 1] & 0xe0) === 0xe0 &&
+    (data[offset + 1] & 0x06) !== 0x00
+  );
+}
+
+export function isHeader(data: Uint8Array, offset: number): boolean {
+  // Look for MPEG header | 1111 1111 | 111X XYZX | where X can be either 0 or 1 and Y or Z should be 1
+  // Layer bits (position 14 and 15) in header should be always different from 0 (Layer I or Layer II or Layer III)
+  // More info http://www.mp3-tech.org/programmer/frame_header.html
+  return offset + 1 < data.length && isHeaderPattern(data, offset);
+}
+
+export function canParse(data: Uint8Array, offset: number): boolean {
+  const headerSize = 4;
+
+  return isHeaderPattern(data, offset) && headerSize <= data.length - offset;
+}
+
+export function probe(data: Uint8Array, offset: number): boolean {
+  // same as isHeader but we also check that MPEG frame follows last MPEG frame
+  // or end of data is reached
+  if (offset + 1 < data.length && isHeaderPattern(data, offset)) {
+    // MPEG header Length
+    const headerLength = 4;
+    // MPEG frame Length
+    const header = parseHeader(data, offset);
+    let frameLength = headerLength;
+    if (header?.frameLength) {
+      frameLength = header.frameLength;
+    }
+
+    const newOffset = offset + frameLength;
+    return newOffset === data.length || isHeader(data, newOffset);
+  }
+  return false;
+}