@@ -102,8 +103,6 @@ The WASM build itself is a performance-optimized, SIMD-enabled build of LAME 3.1
## Building and development
-Building this library is done using the build commands in the [Mediabunny root](https://github.com/Vanilagy/mediabunny).
-
For simplicity, all built WASM artifacts are included in the repo, since these rarely change. However, here are the instructions for building them from scratch:
### Prerequisites
@@ -148,7 +147,7 @@ emcc src/lame-bridge.c build/libmp3lame.a \
-o build/lame.js
```
-This generates `build/lame.js`, which contains both the JavaScript "glue code" as well as the compiled WASM encoded with Base64.
+This generates `build/lame.js`, which contains both the JavaScript "glue code" as well as the compiled WASM inlined.
### Building the package
diff --git a/packages/mp3-encoder/package.json b/packages/mp3-encoder/package.json
index bbcde74..8457f35 100644
--- a/packages/mp3-encoder/package.json
+++ b/packages/mp3-encoder/package.json
@@ -1,7 +1,7 @@
{
"name": "@mediabunny/mp3-encoder",
"author": "Vanilagy",
- "version": "1.31.0",
+ "version": "1.34.2",
"description": "MP3 encoder extension for Mediabunny, based on LAME.",
"main": "./dist/bundles/mediabunny-mp3-encoder.mjs",
"module": "./dist/bundles/mediabunny-mp3-encoder.mjs",
diff --git a/packages/mp3-encoder/src/encode.worker.ts b/packages/mp3-encoder/src/encode.worker.ts
index e5745b9..ee24db8 100644
--- a/packages/mp3-encoder/src/encode.worker.ts
+++ b/packages/mp3-encoder/src/encode.worker.ts
@@ -146,7 +146,10 @@ const onMessage = (data: { id: number; command: WorkerCommand }) => {
command.data.sampleRate,
command.data.bitrate,
);
- result = { success: true };
+ result = {
+ type: command.type,
+ success: true,
+ };
}; break;
case 'encode': {
@@ -154,13 +157,19 @@ const onMessage = (data: { id: number; command: WorkerCommand }) => {
command.data.audioData,
command.data.numberOfFrames,
);
- result = { encodedData };
+ result = {
+ type: command.type,
+ encodedData,
+ };
transferables.push(encodedData);
}; break;
case 'flush': {
const flushedData = flush();
- result = { flushedData };
+ result = {
+ type: command.type,
+ flushedData,
+ };
transferables.push(flushedData);
}; break;
}
diff --git a/packages/mp3-encoder/src/index.ts b/packages/mp3-encoder/src/index.ts
index 1519a19..ad32601 100644
--- a/packages/mp3-encoder/src/index.ts
+++ b/packages/mp3-encoder/src/index.ts
@@ -80,6 +80,12 @@ class Mp3Encoder extends CustomAudioEncoder {
},
});
+ this.resetInternalState();
+ }
+
+ private resetInternalState() {
+ this.currentBufferOffset = 0;
+ this.currentTimestamp = null;
this.chunkMetadata = {
decoderConfig: {
codec: 'mp3',
@@ -119,15 +125,15 @@ class Mp3Encoder extends CustomAudioEncoder {
},
}, [audioData]);
- assert('encodedData' in result);
this.digestOutput(new Uint8Array(result.encodedData));
}
async flush() {
const result = await this.sendCommand({ type: 'flush' });
- assert('flushedData' in result);
this.digestOutput(new Uint8Array(result.flushedData));
+
+ this.resetInternalState();
}
close() {
@@ -171,9 +177,7 @@ class Mp3Encoder extends CustomAudioEncoder {
const duration = header.audioSamplesInFrame / header.sampleRate;
this.onPacket(new EncodedPacket(data, 'key', this.currentTimestamp, duration), this.chunkMetadata);
- if (this.currentTimestamp === 0) {
- this.chunkMetadata = {}; // Mimic WebCodecs-like behavior
- }
+ this.chunkMetadata = {}; // Mimic WebCodecs-like behavior
this.currentTimestamp += duration;
pos += header.totalSize;
@@ -186,13 +190,16 @@ class Mp3Encoder extends CustomAudioEncoder {
}
}
- private sendCommand(
- command: WorkerCommand,
+ private sendCommand
(
+ command: WorkerCommand & { type: T },
transferables?: Transferable[],
) {
- return new Promise((resolve, reject) => {
+ return new Promise((resolve, reject) => {
const id = this.nextMessageId++;
- this.pendingMessages.set(id, { resolve, reject });
+ this.pendingMessages.set(id, {
+ resolve: resolve as (value: WorkerResponseData) => void,
+ reject,
+ });
assert(this.worker);
diff --git a/packages/mp3-encoder/src/shared.ts b/packages/mp3-encoder/src/shared.ts
index d407003..526dac1 100644
--- a/packages/mp3-encoder/src/shared.ts
+++ b/packages/mp3-encoder/src/shared.ts
@@ -24,10 +24,13 @@ export type WorkerCommand = {
};
export type WorkerResponseData = {
+ type: 'init';
success: boolean;
} | {
+ type: 'encode';
encodedData: ArrayBuffer;
} | {
+ type: 'flush';
flushedData: ArrayBuffer;
};
diff --git a/packages/mp3-encoder/tsconfig.json b/packages/mp3-encoder/tsconfig.json
new file mode 100644
index 0000000..bf2e94f
--- /dev/null
+++ b/packages/mp3-encoder/tsconfig.json
@@ -0,0 +1,25 @@
+{
+ "extends": "../../tsconfig.json",
+ "compilerOptions": {
+ "composite": true,
+ "outDir": "./dist/modules",
+ "declaration": true,
+ "declarationMap": true,
+ "stripInternal": true,
+ "noEmit": false,
+ "moduleResolution": "nodenext",
+ "module": "nodenext",
+ "allowJs": true,
+ "paths": {
+ "mediabunny": ["../../src/index.ts"],
+ },
+ },
+ "include": [
+ "./src/**/*",
+ "./build/**/*",
+ "../../shared/**/*",
+ ],
+ "references": [
+ { "path": "../../src" }
+ ]
+}
diff --git a/packages/mp3-encoder/tsdoc.json b/packages/mp3-encoder/tsdoc.json
new file mode 100644
index 0000000..51d29d3
--- /dev/null
+++ b/packages/mp3-encoder/tsdoc.json
@@ -0,0 +1,4 @@
+{
+ "$schema": "https://developer.microsoft.com/json-schemas/tsdoc/v0/tsdoc.schema.json",
+ "extends": ["../../tsdoc.json"]
+}
diff --git a/build.sh b/scripts/build.sh
similarity index 78%
rename from build.sh
rename to scripts/build.sh
index e1d5e58..c0595fe 100755
--- a/build.sh
+++ b/scripts/build.sh
@@ -6,13 +6,15 @@ set -e
# Clear the stuff from last build
rm -rf dist
rm -rf packages/mp3-encoder/dist
+rm -rf packages/ac3/dist
# Ensure license headers on all source files
tsx scripts/ensure-license-headers.ts
# Type check & generate .js and .d.ts files
tsc -p src
-tsc -p packages/mp3-encoder/src
+tsc -p packages/mp3-encoder
+tsc -p packages/ac3
# So that the resulting files use valid ESM imports with file extension. This only runs for the core Mediabunny as only
# it ships the individual files to npm (for tree shaking, because it's large)
@@ -24,14 +26,17 @@ tsx scripts/bundle.ts
# Declaration file rollup and checks
api-extractor run
api-extractor run -c packages/mp3-encoder/api-extractor.json
+api-extractor run -c packages/ac3/api-extractor.json
# Checks that all symbols are documented
tsx scripts/check-docblocks.ts dist/mediabunny.d.ts
tsx scripts/check-docblocks.ts packages/mp3-encoder/dist/mediabunny-mp3-encoder.d.ts
+tsx scripts/check-docblocks.ts packages/ac3/dist/mediabunny-ac3.d.ts
# Checks that API docs are generatable
npm run docs:generate -- --dry
# Appends stuff to the declaration files to register the global variables these libraries expose
echo 'export as namespace Mediabunny;' >> dist/mediabunny.d.ts
-echo 'export as namespace MediabunnyMp3Encoder;' >> packages/mp3-encoder/dist/mediabunny-mp3-encoder.d.ts
\ No newline at end of file
+echo 'export as namespace MediabunnyMp3Encoder;' >> packages/mp3-encoder/dist/mediabunny-mp3-encoder.d.ts
+echo 'export as namespace MediabunnyAc3;' >> packages/ac3/dist/mediabunny-ac3.d.ts
\ No newline at end of file
diff --git a/scripts/bundle.ts b/scripts/bundle.ts
index 5ca0c3d..c1a23d2 100644
--- a/scripts/bundle.ts
+++ b/scripts/bundle.ts
@@ -113,9 +113,41 @@ const mp3EncoderVariants = await createVariants(
},
);
+const ac3Variants = await createVariants(
+ 'packages/ac3/src/index.ts',
+ 'MediabunnyAc3',
+ 'packages/ac3/dist/bundles/mediabunny-ac3',
+ 'js', // The bundles are purely for the browser, not for Node (due to the peer dependecy)
+ {
+ plugins: [
+ PluginExternalGlobal.externalGlobalPlugin({
+ mediabunny: 'Mediabunny',
+ }),
+ inlineWorkerPlugin({
+ define: {
+ 'import.meta.url': '""',
+ },
+ legalComments: 'none',
+ }),
+ ],
+ },
+ {
+ external: ['mediabunny'],
+ plugins: [
+ inlineWorkerPlugin({
+ define: {
+ 'import.meta.url': '""',
+ },
+ legalComments: 'none',
+ }),
+ ],
+ },
+);
+
const contexts = [
...mediabunnyVariants,
...mp3EncoderVariants,
+ ...ac3Variants,
];
if (process.argv[2] === '--watch') {
diff --git a/scripts/check.sh b/scripts/check.sh
new file mode 100755
index 0000000..41aaef3
--- /dev/null
+++ b/scripts/check.sh
@@ -0,0 +1,16 @@
+#!/bin/bash
+set -e
+
+rm -rf dist/modules
+tsc -p src --stripInternal false
+
+tsc -p packages/mp3-encoder --noEmit
+
+rm -rf packages/ac3/dist/modules
+tsc -p packages/ac3
+
+tsc -p tsconfig.vitest.json --noEmit
+
+tsc -p scripts --noEmit
+
+tsc -p tsconfig.vite.json --noEmit
diff --git a/scripts/ensure-license-headers.ts b/scripts/ensure-license-headers.ts
index 231f427..37720ed 100644
--- a/scripts/ensure-license-headers.ts
+++ b/scripts/ensure-license-headers.ts
@@ -36,6 +36,7 @@ const checkDirectory = (dirPath: string) => {
checkDirectory(path.join(__dirname, '..', 'src'));
checkDirectory(path.join(__dirname, '..', 'packages', 'mp3-encoder', 'src'));
+checkDirectory(path.join(__dirname, '..', 'packages', 'ac3', 'src'));
checkDirectory(path.join(__dirname, '..', 'shared'));
if (missingFiles.length > 0) {
diff --git a/shared/ac3-misc.ts b/shared/ac3-misc.ts
new file mode 100644
index 0000000..fa3145f
--- /dev/null
+++ b/shared/ac3-misc.ts
@@ -0,0 +1,13 @@
+/*!
+ * Copyright (c) 2026-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+/** Sample rates indexed by fscod (Table 4.1) */
+export const AC3_SAMPLE_RATES = [48000, 44100, 32000];
+
+/** E-AC-3 reduced sample rates for fscod2 per ATSC A/52:2018 */
+export const EAC3_REDUCED_SAMPLE_RATES = [24000, 22050, 16000];
diff --git a/src/adts/adts-muxer.ts b/src/adts/adts-muxer.ts
index 194f9de..0cadd8a 100644
--- a/src/adts/adts-muxer.ts
+++ b/src/adts/adts-muxer.ts
@@ -62,10 +62,7 @@ export class AdtsMuxer extends Muxer {
const description = meta?.decoderConfig?.description;
- // From the WebCodecs Codec Registry:
- // "If description is present, it is assumed to a AudioSpecificConfig as defined in [iso14496-3] section
- // 1.6.2.1, Table 1.15, and the bitstream is assumed to be in aac.
- // If the description is not present, the bitstream is assumed to be in adts format."
+ // Follows from the Mediabunny Codec Registry:
this.inputIsAdts = !description;
if (!this.inputIsAdts) {
diff --git a/src/codec-data.ts b/src/codec-data.ts
index 2680ab5..5f2ffb5 100644
--- a/src/codec-data.ts
+++ b/src/codec-data.ts
@@ -28,6 +28,7 @@ import {
} from './misc';
import { PacketType } from './packet';
import { MetadataTags } from './metadata';
+import { AC3_SAMPLE_RATES, EAC3_REDUCED_SAMPLE_RATES } from '../shared/ac3-misc';
// References for AVC/HEVC code:
// ISO 14496-15
@@ -2643,3 +2644,361 @@ export const createVorbisComments = (headerBytes: Uint8Array, tags: MetadataTags
return commentHeader;
};
+
+// ============================================================================
+// AC-3 / E-AC-3 Parsing
+// Reference: ETSI TS 102 366 V1.4.1
+// ============================================================================
+
+/**
+ * Channel counts indexed by acmod (Table 4.3).
+ * Does NOT include LFE - add lfeon to get total channel count.
+ */
+export const AC3_ACMOD_CHANNEL_COUNTS = [2, 1, 2, 3, 3, 4, 4, 5];
+
+export interface Ac3FrameInfo {
+ /** Sample rate code */
+ fscod: number;
+ /** Bitstream ID */
+ bsid: number;
+ /** Bitstream mode */
+ bsmod: number;
+ /** Audio coding mode */
+ acmod: number;
+ /** LFE channel on */
+ lfeon: number;
+ /** Bit rate code (0-18, maps to bitrate via Table F.4.1) */
+ bitRateCode: number;
+}
+
+/**
+ * Parse an AC-3 syncframe to extract BSI (Bit Stream Information) fields.
+ * Section 4.3
+ */
+export const parseAc3SyncFrame = (data: Uint8Array): Ac3FrameInfo | null => {
+ if (data.length < 7) {
+ return null;
+ }
+
+ // Check sync word (0x0B77)
+ if (data[0] !== 0x0B || data[1] !== 0x77) {
+ return null;
+ }
+
+ const bitstream = new Bitstream(data);
+ bitstream.skipBits(16); // sync word
+ bitstream.skipBits(16); // crc1
+
+ const fscod = bitstream.readBits(2);
+ if (fscod === 3) {
+ return null; // Reserved, invalid
+ }
+
+ const frmsizecod = bitstream.readBits(6);
+ const bsid = bitstream.readBits(5);
+
+ // Verify this is AC-3
+ if (bsid > 8) {
+ return null;
+ }
+
+ const bsmod = bitstream.readBits(3);
+ const acmod = bitstream.readBits(3);
+
+ // Skip cmixlev (center downmix level) if three front channels are in use (L, C, R).
+ if ((acmod & 0x1) !== 0 && acmod !== 0x1) {
+ bitstream.skipBits(2);
+ }
+
+ // Skip surmixlev (surround downmix level) if surround channels are in use.
+ if ((acmod & 0x4) !== 0) {
+ bitstream.skipBits(2);
+ }
+
+ // Skip dsurmod if stereo (acmod === 2)
+ if (acmod === 0x2) {
+ bitstream.skipBits(2);
+ }
+
+ const lfeon = bitstream.readBits(1);
+ const bitRateCode = Math.floor(frmsizecod / 2);
+
+ return { fscod, bsid, bsmod, acmod, lfeon, bitRateCode };
+};
+
+/**
+ * AC-3 frame sizes in bytes, indexed by [3 * frmsizecod + fscod].
+ * fscod: 0=48kHz, 1=44.1kHz, 2=32kHz
+ * Values are 16-bit words * 2 (to convert to bytes).
+ * Table 4.13
+ */
+export const AC3_FRAME_SIZES = [
+ // frmsizecod, [48kHz, 44.1kHz, 32kHz] in bytes
+ 64 * 2, 69 * 2, 96 * 2,
+ 64 * 2, 70 * 2, 96 * 2,
+ 80 * 2, 87 * 2, 120 * 2,
+ 80 * 2, 88 * 2, 120 * 2,
+ 96 * 2, 104 * 2, 144 * 2,
+ 96 * 2, 105 * 2, 144 * 2,
+ 112 * 2, 121 * 2, 168 * 2,
+ 112 * 2, 122 * 2, 168 * 2,
+ 128 * 2, 139 * 2, 192 * 2,
+ 128 * 2, 140 * 2, 192 * 2,
+ 160 * 2, 174 * 2, 240 * 2,
+ 160 * 2, 175 * 2, 240 * 2,
+ 192 * 2, 208 * 2, 288 * 2,
+ 192 * 2, 209 * 2, 288 * 2,
+ 224 * 2, 243 * 2, 336 * 2,
+ 224 * 2, 244 * 2, 336 * 2,
+ 256 * 2, 278 * 2, 384 * 2,
+ 256 * 2, 279 * 2, 384 * 2,
+ 320 * 2, 348 * 2, 480 * 2,
+ 320 * 2, 349 * 2, 480 * 2,
+ 384 * 2, 417 * 2, 576 * 2,
+ 384 * 2, 418 * 2, 576 * 2,
+ 448 * 2, 487 * 2, 672 * 2,
+ 448 * 2, 488 * 2, 672 * 2,
+ 512 * 2, 557 * 2, 768 * 2,
+ 512 * 2, 558 * 2, 768 * 2,
+ 640 * 2, 696 * 2, 960 * 2,
+ 640 * 2, 697 * 2, 960 * 2,
+ 768 * 2, 835 * 2, 1152 * 2,
+ 768 * 2, 836 * 2, 1152 * 2,
+ 896 * 2, 975 * 2, 1344 * 2,
+ 896 * 2, 976 * 2, 1344 * 2,
+ 1024 * 2, 1114 * 2, 1536 * 2,
+ 1024 * 2, 1115 * 2, 1536 * 2,
+ 1152 * 2, 1253 * 2, 1728 * 2,
+ 1152 * 2, 1254 * 2, 1728 * 2,
+ 1280 * 2, 1393 * 2, 1920 * 2,
+ 1280 * 2, 1394 * 2, 1920 * 2,
+];
+
+/** Number of samples per AC-3 syncframe (always 1536) */
+export const AC3_SAMPLES_PER_FRAME = 1536;
+
+/**
+ * AC-3 registration_descriptor for MPEG-TS.
+ * Section A.2.3
+ */
+export const AC3_REGISTRATION_DESCRIPTOR = new Uint8Array([0x05, 0x04, 0x41, 0x43, 0x2d, 0x33]);
+
+/** E-AC-3 registration_descriptor for MPEG-TS/ */
+export const EAC3_REGISTRATION_DESCRIPTOR = new Uint8Array([0x05, 0x04, 0x45, 0x41, 0x43, 0x33]);
+
+/** Number of audio blocks per syncframe, indexed by numblkscod */
+export const EAC3_NUMBLKS_TABLE = [1, 2, 3, 6];
+
+/**
+ * E-AC-3 independent substream info.
+ * Each independent substream represents a separate audio program.
+ */
+export interface Eac3SubstreamInfo {
+ /** Sample rate code */
+ fscod: number;
+ /** Sample rate code 2 (ATSC A/52:2018) */
+ fscod2: number | null;
+ /** Bitstream ID */
+ bsid: number;
+ /** Bitstream mode */
+ bsmod: number;
+ /** Audio coding mode */
+ acmod: number;
+ /** LFE channel on */
+ lfeon: number;
+ /** Number of dependent substreams */
+ numDepSub: number;
+ /** Channel locations for dependent substreams */
+ chanLoc: number;
+}
+
+/**
+ * E-AC-3 decoder configuration (dec3 box contents).
+ */
+export interface Eac3FrameInfo {
+ /** Data rate in kbps */
+ dataRate: number;
+ /** Independent substreams */
+ substreams: Eac3SubstreamInfo[];
+}
+
+/**
+ * Parse an E-AC-3 syncframe to extract BSI fields.
+ * Section E.1.2
+ */
+export const parseEac3SyncFrame = (data: Uint8Array): Eac3FrameInfo | null => {
+ if (data.length < 6) {
+ return null;
+ }
+
+ // Check sync word (0x0B77)
+ if (data[0] !== 0x0B || data[1] !== 0x77) {
+ return null;
+ }
+
+ const bitstream = new Bitstream(data);
+ bitstream.skipBits(16); // sync word
+
+ const strmtyp = bitstream.readBits(2);
+ bitstream.skipBits(3); // substreamid
+
+ // Only parse independent substreams (strmtyp 0 or 2)
+ if (strmtyp !== 0 && strmtyp !== 2) {
+ return null;
+ }
+
+ const frmsiz = bitstream.readBits(11);
+ const fscod = bitstream.readBits(2);
+
+ let fscod2 = 0;
+ let numblkscod: number;
+
+ if (fscod === 3) {
+ // fscod2 enables reduced sample rates (24/22.05/16 kHz) per ATSC A/52:2018
+ fscod2 = bitstream.readBits(2);
+ numblkscod = 3; // Implicitly 6 blocks when fscod=3
+ } else {
+ numblkscod = bitstream.readBits(2);
+ }
+
+ const acmod = bitstream.readBits(3);
+ const lfeon = bitstream.readBits(1);
+ const bsid = bitstream.readBits(5);
+
+ // Verify this is E-AC-3
+ if (bsid < 11 || bsid > 16) {
+ return null;
+ }
+
+ // Calculate data rate: ((frmsiz + 1) * fs) / (numblks * 16)
+ const numblks = EAC3_NUMBLKS_TABLE[numblkscod]!;
+ let fs: number;
+ if (fscod < 3) {
+ fs = AC3_SAMPLE_RATES[fscod]! / 1000;
+ } else {
+ fs = EAC3_REDUCED_SAMPLE_RATES[fscod2]! / 1000;
+ }
+ const dataRate = Math.round(((frmsiz + 1) * fs) / (numblks * 16));
+
+ // These fields require parsing beyond the first frame.
+ // Defaults are correct for almost all content.
+ const bsmod = 0;
+ const numDepSub = 0;
+ const chanLoc = 0;
+
+ const substream: Eac3SubstreamInfo = {
+ fscod,
+ fscod2,
+ bsid,
+ bsmod,
+ acmod,
+ lfeon,
+ numDepSub,
+ chanLoc,
+ };
+
+ return {
+ dataRate,
+ substreams: [substream],
+ };
+};
+
+/**
+ * Parse a dec3 box to extract E-AC-3 parameters.
+ * Section F.6
+ */
+export const parseEac3Config = (data: Uint8Array): Eac3FrameInfo | null => {
+ if (data.length < 2) {
+ return null;
+ }
+
+ const bitstream = new Bitstream(data);
+
+ const dataRate = bitstream.readBits(13);
+ const numIndSub = bitstream.readBits(3);
+
+ const substreams: Eac3SubstreamInfo[] = [];
+
+ for (let i = 0; i <= numIndSub; i++) {
+ // Check we have enough data for this substream
+ // Each substream needs at least 24 bits (3 bytes) without dependent subs
+ if (Math.ceil(bitstream.pos / 8) + 3 > data.length) {
+ break;
+ }
+
+ const fscod = bitstream.readBits(2);
+ const bsid = bitstream.readBits(5);
+ bitstream.skipBits(1); // reserved
+ bitstream.skipBits(1); // asvc
+ const bsmod = bitstream.readBits(3);
+ const acmod = bitstream.readBits(3);
+ const lfeon = bitstream.readBits(1);
+ bitstream.skipBits(3); // reserved
+ const numDepSub = bitstream.readBits(4);
+
+ let chanLoc = 0;
+
+ if (numDepSub > 0) {
+ chanLoc = bitstream.readBits(9);
+ } else {
+ bitstream.skipBits(1); // reserved
+ }
+
+ substreams.push({
+ fscod,
+ fscod2: null,
+ bsid,
+ bsmod,
+ acmod,
+ lfeon,
+ numDepSub,
+ chanLoc,
+ });
+ }
+
+ if (substreams.length === 0) {
+ return null;
+ }
+
+ return { dataRate, substreams };
+};
+
+/**
+ * Get sample rate from E-AC-3 config.
+ * See ATSC A/52:2018 for handling fscod2.
+ */
+export const getEac3SampleRate = (config: Eac3FrameInfo): number | null => {
+ const sub = config.substreams[0];
+ assert(sub);
+
+ if (sub.fscod < 3) {
+ return AC3_SAMPLE_RATES[sub.fscod]!;
+ } else if (sub.fscod2 !== null && sub.fscod2 < 3) {
+ return EAC3_REDUCED_SAMPLE_RATES[sub.fscod2]!;
+ }
+
+ return null;
+};
+
+/**
+ * Get channel count from E-AC-3 config (first independent substream only).
+ */
+export const getEac3ChannelCount = (config: Eac3FrameInfo): number => {
+ const sub = config.substreams[0];
+ assert(sub);
+
+ let channels = AC3_ACMOD_CHANNEL_COUNTS[sub.acmod]! + sub.lfeon;
+
+ // Add channels from dependent substreams
+ if (sub.numDepSub > 0) {
+ const CHAN_LOC_COUNTS = [2, 2, 1, 1, 2, 2, 2, 1, 1];
+
+ for (let bit = 0; bit < 9; bit++) {
+ if (sub.chanLoc & (1 << (8 - bit))) {
+ channels += CHAN_LOC_COUNTS[bit]!;
+ }
+ }
+ }
+
+ return channels;
+};
diff --git a/src/codec.ts b/src/codec.ts
index 2317ead..b7086f6 100644
--- a/src/codec.ts
+++ b/src/codec.ts
@@ -70,6 +70,8 @@ export const NON_PCM_AUDIO_CODECS = [
'mp3',
'vorbis',
'flac',
+ 'ac3',
+ 'eac3',
] as const;
/**
* List of known audio codecs, ordered by encoding preference.
@@ -528,6 +530,10 @@ export const buildAudioCodecString = (codec: AudioCodec, numberOfChannels: numbe
return 'vorbis';
} else if (codec === 'flac') {
return 'flac';
+ } else if (codec === 'ac3') {
+ return 'ac-3';
+ } else if (codec === 'eac3') {
+ return 'ec-3';
} else if ((PCM_AUDIO_CODECS as readonly string[]).includes(codec)) {
return codec;
}
@@ -573,6 +579,10 @@ export const extractAudioCodecString = (trackInfo: {
return 'vorbis';
} else if (codec === 'flac') {
return 'flac';
+ } else if (codec === 'ac3') {
+ return 'ac-3';
+ } else if (codec === 'eac3') {
+ return 'ec-3';
} else if (codec && (PCM_AUDIO_CODECS as readonly string[]).includes(codec)) {
return codec;
}
@@ -742,6 +752,10 @@ export const inferCodecFromCodecString = (codecString: string): MediaCodec | nul
return 'vorbis';
} else if (codecString === 'flac') {
return 'flac';
+ } else if (codecString === 'ac-3' || codecString === 'ac3') {
+ return 'ac3';
+ } else if (codecString === 'ec-3' || codecString === 'eac3') {
+ return 'eac3';
} else if (codecString === 'ulaw') {
return 'ulaw';
} else if (codecString === 'alaw') {
@@ -819,7 +833,7 @@ export const validateVideoChunkMetadata = (metadata: EncodedVideoChunkMetadata |
if (!VALID_VIDEO_CODEC_STRING_PREFIXES.some(prefix => metadata.decoderConfig!.codec.startsWith(prefix))) {
throw new TypeError(
'Video chunk metadata decoder configuration codec string must be a valid video codec string as specified in'
- + ' the WebCodecs Codec Registry.',
+ + ' the Mediabunny Codec Registry.',
);
}
if (!Number.isInteger(metadata.decoderConfig.codedWidth) || metadata.decoderConfig.codedWidth! <= 0) {
@@ -933,7 +947,9 @@ export const validateVideoChunkMetadata = (metadata: EncodedVideoChunkMetadata |
}
};
-const VALID_AUDIO_CODEC_STRING_PREFIXES = ['mp4a', 'mp3', 'opus', 'vorbis', 'flac', 'ulaw', 'alaw', 'pcm'];
+const VALID_AUDIO_CODEC_STRING_PREFIXES = [
+ 'mp4a', 'mp3', 'opus', 'vorbis', 'flac', 'ulaw', 'alaw', 'pcm', 'ac-3', 'ec-3',
+];
export const validateAudioChunkMetadata = (metadata: EncodedAudioChunkMetadata | undefined) => {
if (!metadata) {
@@ -954,7 +970,7 @@ export const validateAudioChunkMetadata = (metadata: EncodedAudioChunkMetadata |
if (!VALID_AUDIO_CODEC_STRING_PREFIXES.some(prefix => metadata.decoderConfig!.codec.startsWith(prefix))) {
throw new TypeError(
'Audio chunk metadata decoder configuration codec string must be a valid audio codec string as specified in'
- + ' the WebCodecs Codec Registry.',
+ + ' the Mediabunny Codec Registry.',
);
}
if (!Number.isInteger(metadata.decoderConfig.sampleRate) || metadata.decoderConfig.sampleRate <= 0) {
@@ -1051,6 +1067,18 @@ export const validateAudioChunkMetadata = (metadata: EncodedAudioChunkMetadata |
+ ' adhere to the format described in https://www.w3.org/TR/webcodecs-flac-codec-registration/.',
);
}
+ } else if (metadata.decoderConfig.codec.startsWith('ac-3') || metadata.decoderConfig.codec.startsWith('ac3')) {
+ // AC3-specific validation
+
+ if (metadata.decoderConfig.codec !== 'ac-3') {
+ throw new TypeError('Audio chunk metadata decoder configuration codec string for AC-3 must be "ac-3".');
+ }
+ } else if (metadata.decoderConfig.codec.startsWith('ec-3') || metadata.decoderConfig.codec.startsWith('eac3')) {
+ // EAC3-specific validation
+
+ if (metadata.decoderConfig.codec !== 'ec-3') {
+ throw new TypeError('Audio chunk metadata decoder configuration codec string for EC-3 must be "ec-3".');
+ }
} else if (
metadata.decoderConfig.codec.startsWith('pcm')
|| metadata.decoderConfig.codec.startsWith('ulaw')
diff --git a/src/conversion.ts b/src/conversion.ts
index 151e644..0a4ac13 100644
--- a/src/conversion.ts
+++ b/src/conversion.ts
@@ -564,11 +564,11 @@ export class Conversion {
if (options.trim !== undefined && (!options.trim || typeof options.trim !== 'object')) {
throw new TypeError('options.trim, when provided, must be an object.');
}
- if (options.trim?.start !== undefined && (!Number.isFinite(options.trim.start) || options.trim.start < 0)) {
- throw new TypeError('options.trim.start, when provided, must be a non-negative number.');
+ if (options.trim?.start !== undefined && (!Number.isFinite(options.trim.start))) {
+ throw new TypeError('options.trim.start, when provided, must be a finite number.');
}
- if (options.trim?.end !== undefined && (!Number.isFinite(options.trim.end) || options.trim.end < 0)) {
- throw new TypeError('options.trim.end, when provided, must be a non-negative number.');
+ if (options.trim?.end !== undefined && (!Number.isFinite(options.trim.end))) {
+ throw new TypeError('options.trim.end, when provided, must be a finite number.');
}
if (
options.trim?.start !== undefined
@@ -607,7 +607,7 @@ export class Conversion {
// those out by default.
0,
);
- this._endTimestamp = this._options.trim?.end ?? Infinity;
+ this._endTimestamp = Math.max(this._options.trim?.end ?? Infinity, this._startTimestamp);
const inputTracks = await this.input.getTracks();
const outputTrackCounts = this.output.format.getSupportedTrackCounts();
@@ -773,6 +773,13 @@ export class Conversion {
`\nThe @mediabunny/mp3-encoder extension package provides support for encoding MP3.`,
);
}
+
+ if (codecs.includes('ac3') || codecs.includes('eac3')) {
+ elements.push(
+ '\nThe @mediabunny/ac3 extension package provides support'
+ + ' for encoding and decoding AC-3/E-AC-3.',
+ );
+ }
} else {
elements.push('\nCheck the discardedTracks field for more info.');
}
@@ -1326,7 +1333,8 @@ export class Conversion {
let sampleRate = trackOptions.sampleRate ?? originalSampleRate;
let needsResample = numberOfChannels !== originalNumberOfChannels
|| sampleRate !== originalSampleRate
- || firstTimestamp < this._startTimestamp;
+ || firstTimestamp < this._startTimestamp
+ || (firstTimestamp > this._startTimestamp && !this.output.format.supportsTimestampedMediaData);
let audioCodecs = this.output.format.getSupportedAudioCodecs();
if (
diff --git a/src/encode.ts b/src/encode.ts
index 4d3c3d9..165dc3b 100644
--- a/src/encode.ts
+++ b/src/encode.ts
@@ -127,7 +127,7 @@ export type VideoEncodingAdditionalOptions = {
*/
latencyMode?: 'quality' | 'realtime';
/**
- * The full codec string as specified in the WebCodecs Codec Registry. This string must match the codec
+ * The full codec string as specified in the Mediabunny Codec Registry. This string must match the codec
* specified in `codec`. When not set, a fitting codec string will be constructed automatically by the library.
*/
fullCodecString?: string;
@@ -280,7 +280,7 @@ export type AudioEncodingAdditionalOptions = {
/** Configures the bitrate mode. */
bitrateMode?: 'constant' | 'variable';
/**
- * The full codec string as specified in the WebCodecs Codec Registry. This string must match the codec
+ * The full codec string as specified in the Mediabunny Codec Registry. This string must match the codec
* specified in `codec`. When not set, a fitting codec string will be constructed automatically by the library.
*/
fullCodecString?: string;
@@ -375,6 +375,8 @@ export class Quality {
opus: 64000, // 64kbps base for Opus
mp3: 160000, // 160kbps base for MP3
vorbis: 64000, // 64kbps base for Vorbis
+ ac3: 384000, // 384kbps base for AC-3
+ eac3: 192000, // 192kbps base for E-AC-3
};
const baseBitrate = baseRates[codec as keyof typeof baseRates];
diff --git a/src/input-format.ts b/src/input-format.ts
index fa437d2..c9ef78e 100644
--- a/src/input-format.ts
+++ b/src/input-format.ts
@@ -21,14 +21,14 @@ import {
} from './matroska/ebml';
import { MatroskaDemuxer } from './matroska/matroska-demuxer';
import { Mp3Demuxer } from './mp3/mp3-demuxer';
-import { FRAME_HEADER_SIZE } from '../shared/mp3-misc';
+import { FRAME_HEADER_SIZE, getXingOffset, INFO, XING } from '../shared/mp3-misc';
import { ID3_V2_HEADER_SIZE, readId3V2Header } from './id3';
import { readNextMp3FrameHeader } from './mp3/mp3-reader';
import { OggDemuxer } from './ogg/ogg-demuxer';
import { WaveDemuxer } from './wave/wave-demuxer';
import { MAX_ADTS_FRAME_HEADER_SIZE, MIN_ADTS_FRAME_HEADER_SIZE, readAdtsFrameHeader } from './adts/adts-reader';
import { AdtsDemuxer } from './adts/adts-demuxer';
-import { readAscii, readBytes } from './reader';
+import { readAscii, readBytes, readU32Be } from './reader';
import { FlacDemuxer } from './flac/flac-demuxer';
import { MpegTsDemuxer } from './mpeg-ts/mpeg-ts-demuxer';
import { TS_PACKET_SIZE } from './mpeg-ts/mpeg-ts-misc';
@@ -261,10 +261,6 @@ export class WebMInputFormat extends MatroskaInputFormat {
export class Mp3InputFormat extends InputFormat {
/** @internal */
async _canReadInput(input: Input) {
- let slice = input._reader.requestSlice(0, 10);
- if (slice instanceof Promise) slice = await slice;
- if (!slice) return false;
-
let currentPos = 0;
while (true) {
@@ -285,6 +281,21 @@ export class Mp3InputFormat extends InputFormat {
return false;
}
+ const firstHeader = firstResult.header;
+ const xingOffset = getXingOffset(firstHeader.mpegVersionId, firstHeader.channel);
+
+ let slice = input._reader.requestSlice(firstResult.startPos + xingOffset, 4);
+ if (slice instanceof Promise) slice = await slice;
+ if (!slice) return false;
+
+ const word = readU32Be(slice);
+ const isXing = word === XING || word === INFO;
+
+ if (isXing) {
+ // Gotta be MP3
+ return true;
+ }
+
currentPos = firstResult.startPos + firstResult.header.totalSize;
// Fine, we found one frame header, but we're still not entirely sure this is MP3. Let's check if we can find
@@ -294,7 +305,6 @@ export class Mp3InputFormat extends InputFormat {
return false;
}
- const firstHeader = firstResult.header;
const secondHeader = secondResult.header;
// In a well-formed MP3 file, we'd expect these two frames to share some similarities:
diff --git a/src/isobmff/isobmff-boxes.ts b/src/isobmff/isobmff-boxes.ts
index c1061d9..63330ba 100644
--- a/src/isobmff/isobmff-boxes.ts
+++ b/src/isobmff/isobmff-boxes.ts
@@ -20,6 +20,7 @@ import {
UNDETERMINED_LANGUAGE,
assertNever,
keyValueIterator,
+ Bitstream,
} from '../misc';
import {
AudioCodec,
@@ -43,7 +44,7 @@ import {
IsobmffVideoTrackData,
Sample,
} from './isobmff-muxer';
-import { parseOpusIdentificationHeader } from '../codec-data';
+import { parseAc3SyncFrame, parseEac3SyncFrame, parseOpusIdentificationHeader } from '../codec-data';
import { MetadataTags, RichImageData } from '../metadata';
export class IsobmffBoxWriter {
@@ -907,6 +908,79 @@ const pcmC = (trackData: IsobmffAudioTrackData) => {
]);
};
+/** AC3SpecificBox */
+const dac3 = (trackData: IsobmffAudioTrackData) => {
+ const frameInfo = parseAc3SyncFrame(trackData.info.firstPacket.data);
+ if (!frameInfo) {
+ throw new Error(
+ 'Couldn\'t extract AC-3 frame info from the audio packet. '
+ + 'Ensure the packets contain valid AC-3 sync frames (as specified in ETSI TS 102 366).',
+ );
+ }
+
+ const bytes = new Uint8Array(3);
+ const bitstream = new Bitstream(bytes);
+
+ bitstream.writeBits(2, frameInfo.fscod);
+ bitstream.writeBits(5, frameInfo.bsid);
+ bitstream.writeBits(3, frameInfo.bsmod);
+ bitstream.writeBits(3, frameInfo.acmod);
+ bitstream.writeBits(1, frameInfo.lfeon);
+ bitstream.writeBits(5, frameInfo.bitRateCode);
+ bitstream.writeBits(5, 0); // reserved
+
+ return box('dac3', [...bytes]);
+};
+
+/** EC3SpecificBox */
+const dec3 = (trackData: IsobmffAudioTrackData) => {
+ const frameInfo = parseEac3SyncFrame(trackData.info.firstPacket.data);
+ if (!frameInfo) {
+ throw new Error(
+ 'Couldn\'t extract E-AC-3 frame info from the audio packet. '
+ + 'Ensure the packets contain valid E-AC-3 sync frames (as specified in ETSI TS 102 366).',
+ );
+ }
+
+ // Calculate size
+ let totalBits = 16; // header: data_rate (13) + num_ind_sub (3)
+ for (const sub of frameInfo.substreams) {
+ totalBits += 23; // fixed fields per substream
+ if (sub.numDepSub > 0) {
+ totalBits += 9; // chan_loc
+ } else {
+ totalBits += 1; // reserved
+ }
+ }
+ const size = Math.ceil(totalBits / 8);
+
+ const bytes = new Uint8Array(size);
+ const bitstream = new Bitstream(bytes);
+
+ bitstream.writeBits(13, frameInfo.dataRate);
+ bitstream.writeBits(3, frameInfo.substreams.length - 1); // num_ind_sub
+
+ for (const sub of frameInfo.substreams) {
+ bitstream.writeBits(2, sub.fscod);
+ bitstream.writeBits(5, sub.bsid);
+ bitstream.writeBits(1, 0); // reserved
+ bitstream.writeBits(1, 0); // asvc = 0
+ bitstream.writeBits(3, sub.bsmod);
+ bitstream.writeBits(3, sub.acmod);
+ bitstream.writeBits(1, sub.lfeon);
+ bitstream.writeBits(3, 0); // reserved
+ bitstream.writeBits(4, sub.numDepSub);
+
+ if (sub.numDepSub > 0) {
+ bitstream.writeBits(9, sub.chanLoc);
+ } else {
+ bitstream.writeBits(1, 0); // reserved
+ }
+ }
+
+ return box('dec3', [...bytes]);
+};
+
export const subtitleSampleDescription = (
compressionType: string,
trackData: IsobmffSubtitleTrackData,
@@ -1606,6 +1680,8 @@ const audioCodecToBoxName = (codec: AudioCodec, isQuickTime: boolean): string =>
case 'alaw': return 'alaw';
case 'pcm-u8': return 'raw ';
case 'pcm-s8': return 'sowt';
+ case 'ac3': return 'ac-3';
+ case 'eac3': return 'ec-3';
}
// Logic diverges here
@@ -1645,6 +1721,8 @@ const audioCodecToConfigurationBox = (codec: AudioCodec, isQuickTime: boolean) =
case 'opus': return dOps;
case 'vorbis': return esds;
case 'flac': return dfLa;
+ case 'ac3': return dac3;
+ case 'eac3': return dec3;
}
// Logic diverges here
diff --git a/src/isobmff/isobmff-demuxer.ts b/src/isobmff/isobmff-demuxer.ts
index 22447c8..c81ab00 100644
--- a/src/isobmff/isobmff-demuxer.ts
+++ b/src/isobmff/isobmff-demuxer.ts
@@ -27,6 +27,10 @@ import {
FlacBlockType,
HevcDecoderConfigurationRecord,
Vp9CodecInfo,
+ parseEac3Config,
+ getEac3SampleRate,
+ getEac3ChannelCount,
+ AC3_ACMOD_CHANNEL_COUNTS,
} from '../codec-data';
import { Demuxer } from '../demuxer';
import { Input } from '../input';
@@ -87,6 +91,7 @@ import {
readAscii,
} from '../reader';
import { DEFAULT_TRACK_DISPOSITION, MetadataTags, RichImageData, TrackDisposition } from '../metadata';
+import { AC3_SAMPLE_RATES } from '../../shared/ac3-misc';
type InternalTrack = {
id: number;
@@ -946,6 +951,10 @@ export class IsobmffDemuxer extends Demuxer {
track.info.codec = 'ulaw';
} else if (lowercaseBoxName === 'alaw') {
track.info.codec = 'alaw';
+ } else if (lowercaseBoxName === 'ac-3') {
+ track.info.codec = 'ac3';
+ } else if (lowercaseBoxName === 'ec-3') {
+ track.info.codec = 'eac3';
} else {
console.warn(`Unsupported audio codec (sample entry type '${sampleBoxInfo.name}').`);
}
@@ -1457,6 +1466,51 @@ export class IsobmffDemuxer extends Demuxer {
track.info.codecDescription = description;
}; break;
+ case 'dac3': { // AC3SpecificBox
+ const track = this.currentTrack;
+ if (!track) {
+ break;
+ }
+ assert(track.info?.type === 'audio');
+
+ const bytes = readBytes(slice, 3);
+ const bitstream = new Bitstream(bytes);
+
+ const fscod = bitstream.readBits(2);
+ bitstream.skipBits(5 + 3); // Skip bsid and bsmod
+ const acmod = bitstream.readBits(3);
+ const lfeon = bitstream.readBits(1);
+
+ if (fscod < 3) {
+ track.info.sampleRate = AC3_SAMPLE_RATES[fscod]!;
+ }
+
+ track.info.numberOfChannels = AC3_ACMOD_CHANNEL_COUNTS[acmod]! + lfeon;
+ }; break;
+
+ case 'dec3': { // EC3SpecificBox
+ const track = this.currentTrack;
+ if (!track) {
+ break;
+ }
+ assert(track.info?.type === 'audio');
+
+ const bytes = readBytes(slice, boxInfo.contentSize);
+ const config = parseEac3Config(bytes);
+
+ if (!config) {
+ console.warn('Invalid dec3 box contents, ignoring.');
+ break;
+ }
+
+ const sampleRate = getEac3SampleRate(config);
+ if (sampleRate !== null) {
+ track.info.sampleRate = sampleRate;
+ }
+
+ track.info.numberOfChannels = getEac3ChannelCount(config);
+ }; break;
+
case 'stts': {
const track = this.currentTrack;
if (!track) {
diff --git a/src/isobmff/isobmff-muxer.ts b/src/isobmff/isobmff-muxer.ts
index d78b8fe..5074a1d 100644
--- a/src/isobmff/isobmff-muxer.ts
+++ b/src/isobmff/isobmff-muxer.ts
@@ -111,6 +111,7 @@ export type IsobmffTrackData = {
* ADTS-wrapped data.
*/
requiresAdtsStripping: boolean;
+ firstPacket: EncodedPacket;
};
} | {
track: OutputSubtitleTrack;
@@ -429,8 +430,9 @@ export class IsobmffMuxer extends Muxer {
!this.isFragmented
&& (PCM_AUDIO_CODECS as readonly string[]).includes(track.source._codec),
requiresAdtsStripping,
+ firstPacket: packet,
},
- timescale: meta.decoderConfig.sampleRate,
+ timescale: decoderConfig.sampleRate,
samples: [],
sampleQueue: [],
timestampProcessingQueue: [],
diff --git a/src/matroska/ebml.ts b/src/matroska/ebml.ts
index e764e81..ba1b736 100644
--- a/src/matroska/ebml.ts
+++ b/src/matroska/ebml.ts
@@ -744,6 +744,8 @@ export const CODEC_STRING_MAP: Partial> = {
'opus': 'A_OPUS',
'vorbis': 'A_VORBIS',
'flac': 'A_FLAC',
+ 'ac3': 'A_AC3',
+ 'eac3': 'A_EAC3',
'pcm-u8': 'A_PCM/INT/LIT',
'pcm-s16': 'A_PCM/INT/LIT',
'pcm-s16be': 'A_PCM/INT/BIG',
diff --git a/src/matroska/matroska-demuxer.ts b/src/matroska/matroska-demuxer.ts
index fb3eb74..c7c8f26 100644
--- a/src/matroska/matroska-demuxer.ts
+++ b/src/matroska/matroska-demuxer.ts
@@ -1078,6 +1078,12 @@ export class MatroskaDemuxer extends Demuxer {
} else if (codecIdWithoutSuffix === CODEC_STRING_MAP.flac) {
this.currentTrack.info.codec = 'flac';
this.currentTrack.info.codecDescription = this.currentTrack.codecPrivate;
+ } else if (codecIdWithoutSuffix === CODEC_STRING_MAP.ac3) {
+ this.currentTrack.info.codec = 'ac3';
+ this.currentTrack.info.codecDescription = this.currentTrack.codecPrivate;
+ } else if (codecIdWithoutSuffix === CODEC_STRING_MAP.eac3) {
+ this.currentTrack.info.codec = 'eac3';
+ this.currentTrack.info.codecDescription = this.currentTrack.codecPrivate;
} else if (this.currentTrack.codecId === 'A_PCM/INT/LIT') {
if (this.currentTrack.info.bitDepth === 8) {
this.currentTrack.info.codec = 'pcm-u8';
diff --git a/src/media-source.ts b/src/media-source.ts
index 362733c..a65a9da 100644
--- a/src/media-source.ts
+++ b/src/media-source.ts
@@ -227,7 +227,6 @@ class VideoEncoderWrapper {
* So, we keep track of the encoder error and throw it as soon as we get the chance.
*/
private error: Error | null = null;
- private errorNeedsNewStack = true;
constructor(private source: VideoSource, private encodingConfig: VideoEncodingConfig) {}
@@ -413,7 +412,6 @@ class VideoEncoderWrapper {
}
private ensureEncoder(videoSample: VideoSample) {
- const encoderError = new Error();
this.ensureEncoderPromise = (async () => {
const encoderConfig = buildVideoEncoderConfig({
width: videoSample.codedWidth,
@@ -448,7 +446,6 @@ class VideoEncoderWrapper {
void this.muxer!.addEncodedVideoPacket(this.source._connectedTrack!, packet, meta)
.catch((error) => {
this.error ??= error;
- this.errorNeedsNewStack = false;
});
};
@@ -520,10 +517,11 @@ class VideoEncoderWrapper {
void this.muxer!.addEncodedVideoPacket(this.source._connectedTrack!, packet, meta)
.catch((error) => {
this.error ??= error;
- this.errorNeedsNewStack = false;
});
};
+ const stack = new Error('Encoding error').stack;
+
this.encoder = new VideoEncoder({
output: (chunk, meta) => {
if (!this.alphaEncoder) {
@@ -560,13 +558,15 @@ class VideoEncoderWrapper {
}
},
error: (error) => {
- error.stack = encoderError.stack; // Provide a more useful stack trace
+ error.stack = stack; // Provide a more useful stack trace, the default one sucks
this.error ??= error;
},
});
this.encoder.configure(encoderConfig);
if (this.encodingConfig.alpha === 'keep') {
+ const stack = new Error('Encoding error').stack;
+
// We need to encode alpha as well, which we do with a separate encoder
this.alphaEncoder = new VideoEncoder({
// We ignore the alpha chunk's metadata
@@ -594,7 +594,7 @@ class VideoEncoderWrapper {
}
},
error: (error) => {
- error.stack = encoderError.stack; // Provide a more useful stack trace
+ error.stack = stack; // Provide a more useful stack trace
this.error ??= error;
},
});
@@ -652,10 +652,6 @@ class VideoEncoderWrapper {
checkForEncoderError() {
if (this.error) {
- if (this.errorNeedsNewStack) {
- this.error.stack = new Error().stack; // Provide an even more useful stack trace
- }
-
throw this.error;
}
}
@@ -1351,7 +1347,6 @@ class AudioEncoderWrapper {
* So, we keep track of the encoder error and throw it as soon as we get the chance.
*/
private error: Error | null = null;
- private errorNeedsNewStack = true;
constructor(private source: AudioSource, private encodingConfig: AudioEncodingConfig) {}
@@ -1546,7 +1541,6 @@ class AudioEncoderWrapper {
}
private ensureEncoder(audioSample: AudioSample) {
- const encoderError = new Error();
this.ensureEncoderPromise = (async () => {
const { numberOfChannels, sampleRate } = audioSample;
@@ -1582,7 +1576,6 @@ class AudioEncoderWrapper {
void this.muxer!.addEncodedAudioPacket(this.source._connectedTrack!, packet, meta)
.catch((error) => {
this.error ??= error;
- this.errorNeedsNewStack = false;
});
};
@@ -1603,6 +1596,8 @@ class AudioEncoderWrapper {
);
}
+ const stack = new Error('Encoding error').stack;
+
this.encoder = new AudioEncoder({
output: (chunk, meta) => {
// WebKit emits an invalid description for AAC (https://bugs.webkit.org/show_bug.cgi?id=302253),
@@ -1637,11 +1632,10 @@ class AudioEncoderWrapper {
void this.muxer!.addEncodedAudioPacket(this.source._connectedTrack!, packet, meta)
.catch((error) => {
this.error ??= error;
- this.errorNeedsNewStack = false;
});
},
error: (error) => {
- error.stack = encoderError.stack; // Provide a more useful stack trace
+ error.stack = stack; // Provide a more useful stack trace
this.error ??= error;
},
});
@@ -1782,10 +1776,6 @@ class AudioEncoderWrapper {
checkForEncoderError() {
if (this.error) {
- if (this.errorNeedsNewStack) {
- this.error.stack = new Error().stack; // Provide an even more useful stack trace
- }
-
throw this.error;
}
}
diff --git a/src/mpeg-ts/mpeg-ts-demuxer.ts b/src/mpeg-ts/mpeg-ts-demuxer.ts
index dff51d8..f8a6939 100644
--- a/src/mpeg-ts/mpeg-ts-demuxer.ts
+++ b/src/mpeg-ts/mpeg-ts-demuxer.ts
@@ -19,16 +19,24 @@ import {
VideoCodec,
} from '../codec';
import {
+ AC3_ACMOD_CHANNEL_COUNTS,
+ AC3_SAMPLES_PER_FRAME,
AvcDecoderConfigurationRecord,
AvcNalUnitType,
extractAvcDecoderConfigurationRecord,
extractHevcDecoderConfigurationRecord,
extractNalUnitTypeForAvc,
extractNalUnitTypeForHevc,
+ EAC3_NUMBLKS_TABLE,
+ getEac3ChannelCount,
+ getEac3SampleRate,
HevcDecoderConfigurationRecord,
HevcNalUnitType,
+ parseAc3SyncFrame,
parseAvcSps,
+ parseEac3SyncFrame,
parseHevcSps,
+ AC3_FRAME_SIZES,
} from '../codec-data';
import { Demuxer } from '../demuxer';
import { Input } from '../input';
@@ -62,6 +70,10 @@ import { FRAME_HEADER_SIZE as MP3_FRAME_HEADER_SIZE, readMp3FrameHeader } from '
import { EncodedPacket, PacketType, PLACEHOLDER_DATA } from '../packet';
import { FileSlice, readBytes, Reader, readU16Be, readU32Be, readU8 } from '../reader';
import { buildMpegTsMimeType, MpegTsStreamType, TIMESCALE, TS_PACKET_SIZE } from './mpeg-ts-misc';
+import { AC3_SAMPLE_RATES } from '../../shared/ac3-misc';
+
+// Resources:
+// ISO/IEC 13818-1
type ElementaryStream = {
demuxer: MpegTsDemuxer;
@@ -266,7 +278,20 @@ export class MpegTsDemuxer extends Demuxer {
bitstream.skipBits(6);
const esInfoLength = bitstream.readBits(10);
- bitstream.skipBits(8 * esInfoLength);
+ // Check ES descriptors to detect AC-3/E-AC-3 in System B
+ const esInfoEndPos = bitstream.pos + 8 * esInfoLength;
+ let hasAc3Descriptor = false;
+ let hasEac3Descriptor = false;
+ while (bitstream.pos < esInfoEndPos) {
+ const descriptorTag = bitstream.readBits(8);
+ const descriptorLength = bitstream.readBits(8);
+ if (descriptorTag === 0x6a) {
+ hasAc3Descriptor = true;
+ } else if (descriptorTag === 0x7a || descriptorTag === 0xcc) {
+ hasEac3Descriptor = true;
+ }
+ bitstream.skipBits(8 * descriptorLength);
+ }
let info: ElementaryStream['info'] | null = null;
@@ -306,6 +331,46 @@ export class MpegTsDemuxer extends Demuxer {
};
}; break;
+ case MpegTsStreamType.AC3_SYSTEM_A: {
+ info = {
+ type: 'audio',
+ codec: 'ac3',
+ aacCodecInfo: null,
+ numberOfChannels: -1,
+ sampleRate: -1,
+ };
+ }; break;
+
+ case MpegTsStreamType.EAC3_SYSTEM_A: {
+ info = {
+ type: 'audio',
+ codec: 'eac3',
+ aacCodecInfo: null,
+ numberOfChannels: -1,
+ sampleRate: -1,
+ };
+ }; break;
+
+ case MpegTsStreamType.PRIVATE_DATA: {
+ if (hasEac3Descriptor) {
+ info = {
+ type: 'audio',
+ codec: 'eac3',
+ aacCodecInfo: null,
+ numberOfChannels: -1,
+ sampleRate: -1,
+ };
+ } else if (hasAc3Descriptor) {
+ info = {
+ type: 'audio',
+ codec: 'ac3',
+ aacCodecInfo: null,
+ numberOfChannels: -1,
+ sampleRate: -1,
+ };
+ }
+ }; break;
+
default: {
// If we don't recognize the codec, we don't surface the track at all. This is because
// we can't determine its metadata and also have no idea how to packetize its data.
@@ -436,6 +501,44 @@ export class MpegTsDemuxer extends Demuxer {
elementaryStream.info.numberOfChannels = result.header.channel === 3 ? 1 : 2;
elementaryStream.info.sampleRate = result.header.sampleRate;
+ elementaryStream.initialized = true;
+ } else if (elementaryStream.info.codec === 'ac3') {
+ const frameInfo = parseAc3SyncFrame(pesPacket.data);
+ if (!frameInfo) {
+ throw new Error(
+ 'Invalid AC-3 audio stream; could not read sync frame from first packet.',
+ );
+ }
+
+ if (frameInfo.fscod === 3) {
+ throw new Error(
+ 'Invalid AC-3 audio stream; reserved sample rate code found in first packet.',
+ );
+ }
+
+ elementaryStream.info.numberOfChannels
+ = AC3_ACMOD_CHANNEL_COUNTS[frameInfo.acmod]! + frameInfo.lfeon;
+ elementaryStream.info.sampleRate = AC3_SAMPLE_RATES[frameInfo.fscod]!;
+
+ elementaryStream.initialized = true;
+ } else if (elementaryStream.info.codec === 'eac3') {
+ const frameInfo = parseEac3SyncFrame(pesPacket.data);
+ if (!frameInfo) {
+ throw new Error(
+ 'Invalid E-AC-3 audio stream; could not read sync frame from first packet.',
+ );
+ }
+
+ const sampleRate = getEac3SampleRate(frameInfo);
+ if (sampleRate === null) {
+ throw new Error(
+ 'Invalid E-AC-3 audio stream; reserved sample rate code found in first packet.',
+ );
+ }
+
+ elementaryStream.info.numberOfChannels = getEac3ChannelCount(frameInfo);
+ elementaryStream.info.sampleRate = sampleRate;
+
elementaryStream.initialized = true;
} else {
throw new Error('Unhandled.');
@@ -1674,6 +1777,91 @@ const markNextPacket = async (context: PacketReadingContext) => {
} else {
context.seekTo(possibleHeaderStartPos + 1);
}
+ } else if (codec === 'ac3') {
+ if (byte !== 0x0b) {
+ continue;
+ }
+
+ context.skip(-1);
+ const possibleSyncPos = context.currentPos;
+
+ // Need at least 5 bytes for sync word + CRC + fscod/frmsizecod
+ let remaining = context.ensureBuffered(5);
+ if (remaining instanceof Promise) remaining = await remaining;
+
+ if (remaining < 5) {
+ return;
+ }
+
+ const headerBytes = context.readBytes(5);
+
+ // Verify sync word (0x0B77)
+ if (headerBytes[0] !== 0x0b || headerBytes[1] !== 0x77) {
+ context.seekTo(possibleSyncPos + 1);
+ continue;
+ }
+
+ const fscod = headerBytes[4]! >> 6;
+ const frmsizecod = headerBytes[4]! & 0x3f;
+
+ if (fscod === 3 || frmsizecod > 37) {
+ // Invalid
+ context.seekTo(possibleSyncPos + 1);
+ continue;
+ }
+
+ const frameSize = AC3_FRAME_SIZES[3 * frmsizecod + fscod];
+ assert(frameSize !== undefined);
+
+ context.seekTo(possibleSyncPos);
+
+ remaining = context.ensureBuffered(frameSize);
+ if (remaining instanceof Promise) remaining = await remaining;
+
+ const duration = Math.round(
+ AC3_SAMPLES_PER_FRAME * TIMESCALE / elementaryStream.info.sampleRate,
+ );
+ return context.supplyPacket(remaining, duration);
+ } else if (codec === 'eac3') {
+ if (byte !== 0x0b) {
+ continue;
+ }
+
+ context.skip(-1);
+ const possibleSyncPos = context.currentPos;
+
+ // Need at least 5 bytes for E-AC-3 header parsing (sync word + frmsiz + fscod/numblkscod)
+ let remaining = context.ensureBuffered(5);
+ if (remaining instanceof Promise) remaining = await remaining;
+
+ if (remaining < 5) {
+ return;
+ }
+
+ const headerBytes = context.readBytes(5);
+
+ if (headerBytes[0] !== 0x0b || headerBytes[1] !== 0x77) {
+ context.seekTo(possibleSyncPos + 1);
+ continue;
+ }
+
+ const frmsiz = ((headerBytes[2]! & 0x07) << 8) | headerBytes[3]!;
+ const frameSize = (frmsiz + 1) * 2;
+ const fscod = headerBytes[4]! >> 6;
+ const numblkscod = fscod === 3 ? 3 : (headerBytes[4]! >> 4) & 0x03;
+ const numblks = EAC3_NUMBLKS_TABLE[numblkscod]!;
+
+ context.seekTo(possibleSyncPos);
+
+ remaining = context.ensureBuffered(frameSize);
+ if (remaining instanceof Promise) remaining = await remaining;
+
+ // Duration = numblks * 256 samples per block
+ const samplesPerFrame = numblks * 256;
+ const duration = Math.round(
+ samplesPerFrame * TIMESCALE / elementaryStream.info.sampleRate,
+ );
+ return context.supplyPacket(remaining, duration);
} else {
throw new Error('Unhandled.');
}
diff --git a/src/mpeg-ts/mpeg-ts-misc.ts b/src/mpeg-ts/mpeg-ts-misc.ts
index 85a0fd4..d19d062 100644
--- a/src/mpeg-ts/mpeg-ts-misc.ts
+++ b/src/mpeg-ts/mpeg-ts-misc.ts
@@ -13,6 +13,9 @@ export const enum MpegTsStreamType {
MP3_MPEG1 = 0x03,
MP3_MPEG2 = 0x04,
AAC = 0x0f,
+ AC3_SYSTEM_A = 0x81,
+ EAC3_SYSTEM_A = 0x87,
+ PRIVATE_DATA = 0x06,
AVC = 0x1b,
HEVC = 0x24,
}
diff --git a/src/mpeg-ts/mpeg-ts-muxer.ts b/src/mpeg-ts/mpeg-ts-muxer.ts
index b0774bc..e4977cc 100644
--- a/src/mpeg-ts/mpeg-ts-muxer.ts
+++ b/src/mpeg-ts/mpeg-ts-muxer.ts
@@ -9,11 +9,13 @@
import { parseAacAudioSpecificConfig, validateAudioChunkMetadata, validateVideoChunkMetadata } from '../codec';
import { buildAdtsHeaderTemplate, writeAdtsFrameLength } from '../adts/adts-misc';
import {
+ AC3_REGISTRATION_DESCRIPTOR,
AvcDecoderConfigurationRecord,
AvcNalUnitType,
concatNalUnitsInAnnexB,
deserializeAvcDecoderConfigurationRecord,
deserializeHevcDecoderConfigurationRecord,
+ EAC3_REGISTRATION_DESCRIPTOR,
extractNalUnitTypeForAvc,
extractNalUnitTypeForHevc,
HevcDecoderConfigurationRecord,
@@ -23,12 +25,15 @@ import {
} from '../codec-data';
import { assert, Bitstream, promiseWithResolvers, setUint24, toDataView, toUint8Array } from '../misc';
import { Muxer } from '../muxer';
-import { Output, OutputAudioTrack, OutputVideoTrack } from '../output';
+import { Output, OutputAudioTrack, OutputTrack, OutputVideoTrack } from '../output';
import { MpegTsOutputFormat } from '../output-format';
import { EncodedPacket } from '../packet';
import { Writer } from '../writer';
import { buildMpegTsMimeType, MpegTsStreamType, TIMESCALE, TS_PACKET_SIZE } from './mpeg-ts-misc';
+// Resources:
+// ISO/IEC 13818-1
+
const PAT_PID = 0x0000;
const PMT_PID = 0x1000;
const FIRST_TRACK_PID = 0x0100;
@@ -45,6 +50,7 @@ type MpegTsTrackData = {
streamType: MpegTsStreamType;
streamId: number;
codecString: string;
+ timestampProcessingQueue: QueuedPacket[];
packetQueue: QueuedPacket[];
inputIsAnnexB: boolean | null;
inputIsAdts: boolean | null;
@@ -57,7 +63,8 @@ type MpegTsTrackData = {
type QueuedPacket = {
data: Uint8Array;
- timestamp: number;
+ presentationTimestamp: number;
+ decodeTimestamp: number | null;
isKeyframe: boolean;
};
@@ -75,9 +82,6 @@ export class MpegTsMuxer extends Muxer {
private videoTrackIndex = 0;
private audioTrackIndex = 0;
- private pesHeaderBuffer = new Uint8Array(14);
- private pesHeaderView = toDataView(this.pesHeaderBuffer);
- private ptsBitstream = new Bitstream(this.pesHeaderBuffer.subarray(9, 14));
private adaptationFieldBuffer = new Uint8Array(184);
private payloadBuffer = new Uint8Array(184);
@@ -122,6 +126,7 @@ export class MpegTsMuxer extends Muxer {
streamType,
streamId,
codecString: meta.decoderConfig.codec,
+ timestampProcessingQueue: [],
packetQueue: [],
inputIsAnnexB: null,
inputIsAdts: null,
@@ -151,11 +156,34 @@ export class MpegTsMuxer extends Muxer {
assert(meta?.decoderConfig);
const codec = track.source._codec;
- assert(codec === 'aac' || codec === 'mp3');
+ assert(codec === 'aac' || codec === 'mp3' || codec === 'ac3' || codec === 'eac3');
+
+ let streamType: MpegTsStreamType;
+ let streamId: number;
+
+ switch (codec) {
+ case 'aac': {
+ streamType = MpegTsStreamType.AAC;
+ streamId = AUDIO_STREAM_ID_BASE + this.audioTrackIndex++;
+ }; break;
+
+ case 'mp3': {
+ streamType = MpegTsStreamType.MP3_MPEG1;
+ streamId = AUDIO_STREAM_ID_BASE + this.audioTrackIndex++;
+ }; break;
+
+ case 'ac3': {
+ streamType = MpegTsStreamType.AC3_SYSTEM_A;
+ streamId = 0xbd;
+ }; break;
+
+ case 'eac3': {
+ streamType = MpegTsStreamType.EAC3_SYSTEM_A;
+ streamId = 0xbd;
+ }; break;
+ }
- const streamType = codec === 'aac' ? MpegTsStreamType.AAC : MpegTsStreamType.MP3_MPEG1;
const pid = FIRST_TRACK_PID + this.trackDatas.length;
- const streamId = AUDIO_STREAM_ID_BASE + this.audioTrackIndex++;
const newTrackData: MpegTsTrackData = {
track,
@@ -163,6 +191,7 @@ export class MpegTsMuxer extends Muxer {
streamType,
streamId,
codecString: meta.decoderConfig.codec,
+ timestampProcessingQueue: [],
packetQueue: [],
inputIsAnnexB: null,
inputIsAdts: null,
@@ -200,13 +229,16 @@ export class MpegTsMuxer extends Muxer {
const preparedData = this.prepareVideoPacket(trackData, packet, meta);
- trackData.packetQueue.push({
+ if (packet.type === 'key') {
+ await this.flushTimestampQueue(trackData);
+ }
+
+ trackData.timestampProcessingQueue.push({
data: preparedData,
- timestamp,
+ presentationTimestamp: timestamp,
+ decodeTimestamp: null,
isKeyframe: packet.type === 'key',
});
-
- await this.interleavePackets();
} finally {
release();
}
@@ -230,13 +262,16 @@ export class MpegTsMuxer extends Muxer {
const preparedData = this.prepareAudioPacket(trackData, packet, meta);
- trackData.packetQueue.push({
+ if (packet.type === 'key') {
+ await this.flushTimestampQueue(trackData);
+ }
+
+ trackData.timestampProcessingQueue.push({
data: preparedData,
- timestamp,
+ presentationTimestamp: timestamp,
+ decodeTimestamp: null,
isKeyframe: packet.type === 'key',
});
-
- await this.interleavePackets();
} finally {
release();
}
@@ -373,7 +408,7 @@ export class MpegTsMuxer extends Muxer {
): Uint8Array {
const codec = (trackData.track as OutputAudioTrack).source._codec;
- if (codec === 'mp3') {
+ if (codec === 'mp3' || codec === 'ac3' || codec === 'eac3') {
// We're good
return packet.data;
}
@@ -419,6 +454,28 @@ export class MpegTsMuxer extends Muxer {
return true;
}
+ private async flushTimestampQueue(trackData: MpegTsTrackData, alsoInterleave = true) {
+ if (trackData.timestampProcessingQueue.length === 0) {
+ return;
+ }
+
+ const sortedTimestamps = trackData.timestampProcessingQueue
+ .map(packet => packet.presentationTimestamp)
+ .sort((a, b) => a - b);
+
+ for (let i = 0; i < trackData.timestampProcessingQueue.length; i++) {
+ const queuedPacket = trackData.timestampProcessingQueue[i]!;
+ queuedPacket.decodeTimestamp = sortedTimestamps[i]!;
+ trackData.packetQueue.push(queuedPacket);
+ }
+
+ trackData.timestampProcessingQueue.length = 0;
+
+ if (alsoInterleave) {
+ await this.interleavePackets();
+ }
+ }
+
private async interleavePackets(isFinalCall = false) {
if (!this.tablesWritten) {
if (!this.allTracksAreKnown() && !isFinalCall) {
@@ -444,10 +501,10 @@ export class MpegTsMuxer extends Muxer {
if (
trackData.packetQueue.length > 0
- && trackData.packetQueue[0]!.timestamp < minTimestamp
+ && trackData.packetQueue[0]!.presentationTimestamp < minTimestamp
) {
trackWithMinTimestamp = trackData;
- minTimestamp = trackData.packetQueue[0]!.timestamp;
+ minTimestamp = trackData.packetQueue[0]!.presentationTimestamp;
}
}
@@ -501,10 +558,14 @@ export class MpegTsMuxer extends Muxer {
}
private writePesPacket(trackData: MpegTsTrackData, queuedPacket: QueuedPacket) {
- const pesView = this.pesHeaderView;
+ const includeDts = trackData.track.type === 'video';
+ const headerDataLength = includeDts ? 10 : 5;
+ const pesHeaderBuffer = new Uint8Array(9 + headerDataLength);
+ const pesView = toDataView(pesHeaderBuffer);
+ const ptsDtsBitstream = new Bitstream(pesHeaderBuffer.subarray(9));
setUint24(pesView, 0, 0x000001, false); // packet_start_code_prefix
- this.pesHeaderBuffer[3] = trackData.streamId; // stream_id
+ pesHeaderBuffer[3] = trackData.streamId; // stream_id
const pesPacketLength = trackData.track.type === 'video'
? 0 // Unbounded
@@ -514,20 +575,33 @@ export class MpegTsMuxer extends Muxer {
// '10' marker, PES_scrambling_control=0, PES_priority=0,
// data_alignment_indicator=1, copyright=0, original_or_copy=0
pesView.setUint8(6, 0x84);
- pesView.setUint8(7, 0x80); // PTS_DTS_flags=10 (PTS only), other flags=0
- pesView.setUint8(8, 5); // PES_header_data_length (5 bytes for PTS)
+ pesView.setUint8(7, includeDts ? 0xC0 : 0x80); // PTS_DTS_flags, other flags=0
+ pesView.setUint8(8, headerDataLength); // PES_header_data_length
- const pts = Math.round(queuedPacket.timestamp * TIMESCALE);
- this.ptsBitstream.pos = 0;
- this.ptsBitstream.writeBits(4, 0b0010); // marker
- this.ptsBitstream.writeBits(3, (pts >>> 30) & 0x7); // PTS[32:30]
- this.ptsBitstream.writeBits(1, 1); // marker_bit
- this.ptsBitstream.writeBits(15, (pts >>> 15) & 0x7FFF); // PTS[29:15]
- this.ptsBitstream.writeBits(1, 1); // marker_bit
- this.ptsBitstream.writeBits(15, pts & 0x7FFF); // PTS[14:0]
- this.ptsBitstream.writeBits(1, 1); // marker_bit
+ const pts = Math.round(queuedPacket.presentationTimestamp * TIMESCALE);
+ ptsDtsBitstream.pos = 0;
+ ptsDtsBitstream.writeBits(4, includeDts ? 0b0011 : 0b0010); // marker
+ ptsDtsBitstream.writeBits(3, (pts >>> 30) & 0x7); // PTS[32:30]
+ ptsDtsBitstream.writeBits(1, 1); // marker_bit
+ ptsDtsBitstream.writeBits(15, (pts >>> 15) & 0x7FFF); // PTS[29:15]
+ ptsDtsBitstream.writeBits(1, 1); // marker_bit
+ ptsDtsBitstream.writeBits(15, pts & 0x7FFF); // PTS[14:0]
+ ptsDtsBitstream.writeBits(1, 1); // marker_bit
- const totalLength = this.pesHeaderBuffer.length + queuedPacket.data.length;
+ if (includeDts) {
+ assert(queuedPacket.decodeTimestamp !== null);
+
+ const dts = Math.round(queuedPacket.decodeTimestamp * TIMESCALE);
+ ptsDtsBitstream.writeBits(4, 0b0001);
+ ptsDtsBitstream.writeBits(3, (dts >>> 30) & 0x7); // DTS[32:30]
+ ptsDtsBitstream.writeBits(1, 1); // marker_bit
+ ptsDtsBitstream.writeBits(15, (dts >>> 15) & 0x7FFF); // DTS[29:15]
+ ptsDtsBitstream.writeBits(1, 1); // marker_bit
+ ptsDtsBitstream.writeBits(15, dts & 0x7FFF); // DTS[14:0]
+ ptsDtsBitstream.writeBits(1, 1); // marker_bit
+ }
+
+ const totalLength = pesHeaderBuffer.length + queuedPacket.data.length;
let offset = 0;
let isFirstTsPacket = true;
@@ -568,13 +642,13 @@ export class MpegTsMuxer extends Muxer {
const payload = this.payloadBuffer.subarray(0, payloadSize);
let payloadOffset = 0;
- if (offset < this.pesHeaderBuffer.length) {
- const headerBytes = Math.min(this.pesHeaderBuffer.length - offset, payloadSize);
- payload.set(this.pesHeaderBuffer.subarray(offset, offset + headerBytes), 0);
+ if (offset < pesHeaderBuffer.length) {
+ const headerBytes = Math.min(pesHeaderBuffer.length - offset, payloadSize);
+ payload.set(pesHeaderBuffer.subarray(offset, offset + headerBytes), 0);
payloadOffset = headerBytes;
}
- const dataStart = Math.max(0, offset - this.pesHeaderBuffer.length);
+ const dataStart = Math.max(0, offset - pesHeaderBuffer.length);
const dataEnd = dataStart + (payloadSize - payloadOffset);
if (payloadOffset < payloadSize) {
payload.set(queuedPacket.data.subarray(dataStart, dataEnd), payloadOffset);
@@ -633,13 +707,18 @@ export class MpegTsMuxer extends Muxer {
}
// eslint-disable-next-line @typescript-eslint/no-misused-promises
- override async onTrackClose() {
+ override async onTrackClose(track: OutputTrack) {
const release = await this.mutex.acquire();
if (this.allTracksAreKnown()) {
this.allTracksKnown.resolve();
}
+ const trackData = this.trackDatas.find(x => x.track === track);
+ if (trackData) {
+ await this.flushTimestampQueue(trackData, false);
+ }
+
await this.interleavePackets();
release();
@@ -650,6 +729,10 @@ export class MpegTsMuxer extends Muxer {
this.allTracksKnown.resolve();
+ for (const trackData of this.trackDatas) {
+ await this.flushTimestampQueue(trackData, false);
+ }
+
await this.interleavePackets(true);
release();
@@ -695,7 +778,18 @@ const PAT_SECTION = new Uint8Array(16);
}
const buildPmt = (trackDatas: MpegTsTrackData[]) => {
- const sectionLength = 9 + trackDatas.length * 5 + 4;
+ let totalEsBytes = 0;
+ for (const trackData of trackDatas) {
+ totalEsBytes += 5;
+
+ if (trackData.streamType === MpegTsStreamType.AC3_SYSTEM_A) {
+ totalEsBytes += AC3_REGISTRATION_DESCRIPTOR.length;
+ } else if (trackData.streamType === MpegTsStreamType.EAC3_SYSTEM_A) {
+ totalEsBytes += EAC3_REGISTRATION_DESCRIPTOR.length;
+ }
+ }
+
+ const sectionLength = 9 + totalEsBytes + 4;
const section = new Uint8Array(3 + sectionLength - 4);
const view = toDataView(section);
@@ -714,8 +808,21 @@ const buildPmt = (trackDatas: MpegTsTrackData[]) => {
section[offset++] = trackData.streamType; // stream_type
view.setUint16(offset, 0xE000 | (trackData.pid & 0x1FFF), false); // reserved=111, elementary_PID
offset += 2;
- view.setUint16(offset, 0xF000, false); // reserved=1111, ES_info_length=0
- offset += 2;
+
+ if (trackData.streamType === MpegTsStreamType.AC3_SYSTEM_A) {
+ view.setUint16(offset, 0xF000 | AC3_REGISTRATION_DESCRIPTOR.length, false);
+ offset += 2;
+ section.set(AC3_REGISTRATION_DESCRIPTOR, offset);
+ offset += AC3_REGISTRATION_DESCRIPTOR.length;
+ } else if (trackData.streamType === MpegTsStreamType.EAC3_SYSTEM_A) {
+ view.setUint16(offset, 0xF000 | EAC3_REGISTRATION_DESCRIPTOR.length, false);
+ offset += 2;
+ section.set(EAC3_REGISTRATION_DESCRIPTOR, offset);
+ offset += EAC3_REGISTRATION_DESCRIPTOR.length;
+ } else {
+ view.setUint16(offset, 0xF000, false); // reserved=1111, ES_info_length=0
+ offset += 2;
+ }
}
const crc = computeMpegTsCrc32(section);
diff --git a/src/output-format.ts b/src/output-format.ts
index d9dee08..adef3a9 100644
--- a/src/output-format.ts
+++ b/src/output-format.ts
@@ -74,6 +74,13 @@ export abstract class OutputFormat {
abstract getSupportedTrackCounts(): TrackCountLimits;
/** Whether this output format supports video rotation metadata. */
abstract get supportsVideoRotationMetadata(): boolean;
+ /**
+ * Whether this output format's tracks store timestamped media data. When `true`, the timestamps of added packets
+ * will be respected, allowing things like gaps in media data or non-zero start times. When `false`, the format's
+ * media data implicitly starts at zero and follows an implicit sequential timing from there, using the intrinsic
+ * durations of the media data.
+ */
+ abstract get supportsTimestampedMediaData(): boolean;
/** Returns a list of video codecs that this output format can contain. */
getSupportedVideoCodecs() {
@@ -258,6 +265,10 @@ export abstract class IsobmffOutputFormat extends OutputFormat {
return true;
}
+ get supportsTimestampedMediaData() {
+ return true;
+ }
+
/** @internal */
_createMuxer(output: Output) {
return new IsobmffMuxer(output, this);
@@ -292,7 +303,8 @@ export class Mp4OutputFormat extends IsobmffOutputFormat {
return [
...VIDEO_CODECS,
...NON_PCM_AUDIO_CODECS,
- // These are supported via ISO/IEC 23003-5
+
+ // These are supported via ISO/IEC 23003-5:
'pcm-s16',
'pcm-s16be',
'pcm-s24',
@@ -303,6 +315,7 @@ export class Mp4OutputFormat extends IsobmffOutputFormat {
'pcm-f32be',
'pcm-f64',
'pcm-f64be',
+
...SUBTITLE_CODECS,
];
}
@@ -488,6 +501,10 @@ export class MkvOutputFormat extends OutputFormat {
// While it technically does support it with ProjectionPoseRoll, many players appear to ignore this value
return false;
}
+
+ get supportsTimestampedMediaData() {
+ return true;
+ }
}
/**
@@ -624,6 +641,10 @@ export class Mp3OutputFormat extends OutputFormat {
get supportsVideoRotationMetadata() {
return false;
}
+
+ get supportsTimestampedMediaData() {
+ return false;
+ }
}
/**
@@ -722,6 +743,10 @@ export class WavOutputFormat extends OutputFormat {
get supportsVideoRotationMetadata() {
return false;
}
+
+ get supportsTimestampedMediaData() {
+ return false;
+ }
}
/**
@@ -813,6 +838,10 @@ export class OggOutputFormat extends OutputFormat {
get supportsVideoRotationMetadata() {
return false;
}
+
+ get supportsTimestampedMediaData() {
+ return false;
+ }
}
/**
@@ -887,6 +916,10 @@ export class AdtsOutputFormat extends OutputFormat {
get supportsVideoRotationMetadata() {
return false;
}
+
+ get supportsTimestampedMediaData() {
+ return false;
+ }
}
/**
@@ -958,6 +991,10 @@ export class FlacOutputFormat extends OutputFormat {
get supportsVideoRotationMetadata() {
return false;
}
+
+ get supportsTimestampedMediaData() {
+ return false;
+ }
}
/**
@@ -1032,11 +1069,15 @@ export class MpegTsOutputFormat extends OutputFormat {
getSupportedCodecs(): MediaCodec[] {
return [
...VIDEO_CODECS.filter(codec => ['avc', 'hevc'].includes(codec)),
- ...AUDIO_CODECS.filter(codec => ['aac', 'mp3'].includes(codec)),
+ ...AUDIO_CODECS.filter(codec => ['aac', 'mp3', 'ac3', 'eac3'].includes(codec)),
];
}
get supportsVideoRotationMetadata() {
return false;
}
+
+ get supportsTimestampedMediaData() {
+ return true;
+ }
}
diff --git a/src/packet.ts b/src/packet.ts
index 2fe7269..36901f4 100644
--- a/src/packet.ts
+++ b/src/packet.ts
@@ -56,7 +56,10 @@ export class EncodedPacket {
/** Creates a new {@link EncodedPacket} from raw bytes and timing information. */
constructor(
- /** The encoded data of this packet. */
+ /**
+ * The encoded data of this packet. For any given codec, this data must adhere to the format specified in the
+ * Mediabunny Codec Registry.
+ */
public readonly data: Uint8Array,
/** The type of this packet. */
public readonly type: PacketType,
diff --git a/src/source.ts b/src/source.ts
index 07de065..6a98a5f 100644
--- a/src/source.ts
+++ b/src/source.ts
@@ -355,6 +355,9 @@ export type UrlSourceOptions = {
/** The maximum number of bytes the cache is allowed to hold in memory. Defaults to 64 MiB. */
maxCacheSize?: number;
+ /** The maximum number of parallel requests to use for fetching. Defaults to 2. */
+ parallelism?: number;
+
/**
* A WHATWG-compatible fetch function. You can use this field to polyfill the `fetch` function, add missing
* features, or use a custom implementation.
@@ -415,6 +418,9 @@ export class UrlSource extends Source {
) {
throw new TypeError('options.maxCacheSize, when provided, must be a non-negative number.');
}
+ if (options.parallelism !== undefined && (!Number.isInteger(options.parallelism) || options.parallelism < 1)) {
+ throw new TypeError('options.parallelism, when provided, must be a positive number.');
+ }
if (options.fetchFn !== undefined && typeof options.fetchFn !== 'function') {
throw new TypeError('options.fetchFn, when provided, must be a function.');
// Won't bother validating this function beyond this
@@ -426,11 +432,13 @@ export class UrlSource extends Source {
this._options = options;
this._getRetryDelay = options.getRetryDelay ?? DEFAULT_RETRY_DELAY;
+ // Most files in the real-world have a single sequential access pattern, but having two in parallel can
+ // also happen
+ const DEFAULT_PARALLELISM = 2;
+
this._orchestrator = new ReadOrchestrator({
maxCacheSize: options.maxCacheSize ?? (64 * 2 ** 20 /* 64 MiB */),
- // Most files in the real-world have a single sequential access pattern, but having two in parallel can
- // also happen
- maxWorkerCount: 2,
+ maxWorkerCount: options.parallelism ?? DEFAULT_PARALLELISM,
runWorker: this._runWorker.bind(this),
prefetchProfile: PREFETCH_PROFILES.network,
});
diff --git a/src/wave/wave-demuxer.ts b/src/wave/wave-demuxer.ts
index 45febf7..95966ad 100644
--- a/src/wave/wave-demuxer.ts
+++ b/src/wave/wave-demuxer.ts
@@ -15,7 +15,7 @@ import { DEFAULT_TRACK_DISPOSITION, MetadataTags } from '../metadata';
import { assert, UNDETERMINED_LANGUAGE } from '../misc';
import { EncodedPacket, PLACEHOLDER_DATA } from '../packet';
import { readAscii, readBytes, Reader, readU16, readU32, readU64 } from '../reader';
-import { parseId3V2Tag, readId3V2Header } from '../id3';
+import { ID3_V2_HEADER_SIZE, parseId3V2Tag, readId3V2Header } from '../id3';
export enum WaveFormat {
PCM = 0x0001,
@@ -286,10 +286,15 @@ export class WaveDemuxer extends Demuxer {
const id3V2Header = readId3V2Header(slice);
if (id3V2Header) {
- // Extract the content portion (skip the 10-byte header)
- const contentSlice = slice.slice(startPos + 10, id3V2Header.size);
+ // Clamp to the available data in case the ID3 header claims more than the WAV chunk provides
+ // https://github.com/Vanilagy/mediabunny/issues/300
+ const availableSize = size - ID3_V2_HEADER_SIZE;
+ id3V2Header.size = Math.min(id3V2Header.size, availableSize);
- parseId3V2Tag(contentSlice, id3V2Header, this.metadataTags);
+ if (id3V2Header.size > 0) {
+ const contentSlice = slice.slice(startPos + ID3_V2_HEADER_SIZE, id3V2Header.size);
+ parseId3V2Tag(contentSlice, id3V2Header, this.metadataTags);
+ }
}
}
@@ -411,6 +416,8 @@ class WaveAudioTrackBacking implements InputAudioTrackBacking {
packetIndex: number,
options: PacketRetrievalOptions,
): Promise {
+ assert(packetIndex >= 0);
+
assert(this.demuxer.audioInfo);
const startOffset = packetIndex * PACKET_SIZE_IN_FRAMES * this.demuxer.audioInfo.blockSizeInBytes;
if (startOffset >= this.demuxer.dataSize) {
@@ -451,7 +458,7 @@ class WaveAudioTrackBacking implements InputAudioTrackBacking {
this.demuxer.lastKnownPacketIndex = Math.max(
packetIndex,
- timestamp,
+ this.demuxer.lastKnownPacketIndex,
);
return new EncodedPacket(
@@ -475,6 +482,9 @@ class WaveAudioTrackBacking implements InputAudioTrackBacking {
timestamp * this.demuxer.audioInfo.sampleRate / PACKET_SIZE_IN_FRAMES,
(this.demuxer.dataSize - 1) / (PACKET_SIZE_IN_FRAMES * this.demuxer.audioInfo.blockSizeInBytes),
));
+ if (packetIndex < 0) {
+ return null;
+ }
const packet = await this.getPacketAtIndex(packetIndex, options);
if (packet) {
diff --git a/test/browser/mpeg-ts-muxing.test.ts b/test/browser/mpeg-ts-muxing.test.ts
index 5bb2728..5568162 100644
--- a/test/browser/mpeg-ts-muxing.test.ts
+++ b/test/browser/mpeg-ts-muxing.test.ts
@@ -16,7 +16,7 @@ test('MPEG-TS output format', async () => {
expect(format.mimeType).toBe('video/MP2T');
expect(format.fileExtension).toBe('.ts');
expect(format.supportsVideoRotationMetadata).toBe(false);
- expect(format.getSupportedCodecs()).toEqual(['avc', 'hevc', 'aac', 'mp3']);
+ expect(format.getSupportedCodecs()).toEqual(['avc', 'hevc', 'aac', 'mp3', 'ac3', 'eac3']);
expect(format.getSupportedTrackCounts()).toEqual({
video: { min: 0, max: 16 },
audio: { min: 0, max: 32 },
@@ -70,7 +70,7 @@ test('MPEG-TS muxing with AVC and AAC', async () => {
started = true;
const fps = 30;
- const duration = 5;
+ const duration = 2;
const frameCount = fps * duration;
const frameDuration = 1 / fps;
@@ -164,9 +164,9 @@ test('MPEG-TS muxing with AVC and AAC', async () => {
}
// Check that seeking works
- const middlePacket = await videoSink.getPacket(2.5);
+ const middlePacket = await videoSink.getPacket(1);
assert(middlePacket);
- expect(middlePacket.timestamp).toBeCloseTo(2.5);
+ expect(middlePacket.timestamp).toBeCloseTo(1);
expect(videoPacketCount).toBe(frameCount);
@@ -189,9 +189,9 @@ test('MPEG-TS muxing with AVC and AAC', async () => {
}
// Check that seeking works
- const audioMiddlePacket = await audioSink.getPacket(2.5);
+ const audioMiddlePacket = await audioSink.getPacket(1);
assert(audioMiddlePacket);
- expect(audioMiddlePacket.timestamp).toBeCloseTo(2.5);
+ expect(audioMiddlePacket.timestamp).toBeCloseTo(1, 1);
expect(audioPacketCount).toBeGreaterThan(0);
@@ -199,8 +199,8 @@ test('MPEG-TS muxing with AVC and AAC', async () => {
const videoDuration = await videoTrack.computeDuration();
const audioDuration = await audioTrack.computeDuration();
- expect(videoDuration).toBeCloseTo(5, 1);
- expect(audioDuration).toBeCloseTo(5, 1);
+ expect(videoDuration).toBeCloseTo(duration, 1);
+ expect(audioDuration).toBeCloseTo(duration, 1);
});
test('MPEG-TS muxing with HEVC and MP3', async () => {
@@ -703,12 +703,14 @@ test('MPEG-TS muxing with StreamTarget', async () => {
const frameDuration = 1 / fps;
for (let i = 0; i < frameCount; i++) {
- await videoSource.add(i * frameDuration, frameDuration);
+ await videoSource.add(i * frameDuration, frameDuration, {
+ keyFrame: true, // Otherwise all packets get written at once due to the DTS logic
+ });
}
await output.finalize();
- expect(chunks.length).toBe(frameCount);
+ expect(chunks).toHaveLength(frameCount);
const buffer = new Uint8Array(nextPos);
nextPos = 0;
diff --git a/test/node/ac3.test.ts b/test/node/ac3.test.ts
new file mode 100644
index 0000000..0989b89
--- /dev/null
+++ b/test/node/ac3.test.ts
@@ -0,0 +1,327 @@
+import { expect, test } from 'vitest';
+import { Input } from '../../src/input.js';
+import { BufferSource, FilePathSource } from '../../src/source.js';
+import path from 'node:path';
+import { ALL_FORMATS } from '../../src/input-format.js';
+import { Output } from '../../src/output.js';
+import { MpegTsOutputFormat } from '../../src/output-format.js';
+import { BufferTarget } from '../../src/target.js';
+import { Conversion } from '../../src/conversion.js';
+import { AC3_REGISTRATION_DESCRIPTOR, EAC3_REGISTRATION_DESCRIPTOR } from '../../src/codec-data.js';
+import { canEncode } from '../../src/encode.js';
+import { AudioSampleSink, EncodedPacketSink } from '../../src/media-sink.js';
+import { AudioSampleSource } from '../../src/media-source.js';
+import { Mp4OutputFormat } from '../../src/output-format.js';
+import { AudioSample } from '../../src/sample.js';
+import { registerAc3Decoder, registerAc3Encoder } from '@mediabunny/ac3';
+
+const __dirname = new URL('.', import.meta.url).pathname;
+
+test('reads AC-3 from MP4', async () => {
+ using input = new Input({
+ source: new FilePathSource(path.join(__dirname, '..', 'public/ac3.mp4')),
+ formats: ALL_FORMATS,
+ });
+
+ const audioTrack = (await input.getPrimaryAudioTrack())!;
+ const decoderConfig = (await audioTrack.getDecoderConfig())!;
+
+ expect(audioTrack.codec).toBe('ac3');
+ expect(decoderConfig.description).toBeUndefined();
+});
+
+test('reads E-AC-3 from MP4', async () => {
+ using input = new Input({
+ source: new FilePathSource(path.join(__dirname, '..', 'public/eac3.mp4')),
+ formats: ALL_FORMATS,
+ });
+
+ const audioTrack = (await input.getPrimaryAudioTrack())!;
+ const decoderConfig = (await audioTrack.getDecoderConfig())!;
+
+ expect(audioTrack.codec).toBe('eac3');
+ expect(decoderConfig.description).toBeUndefined();
+});
+
+test('reads and writes AC-3 in MPEG-TS', async () => {
+ using originalInput = new Input({
+ source: new FilePathSource(path.join(__dirname, '..', 'public/ac3.ts')),
+ formats: ALL_FORMATS,
+ });
+
+ const originalAudioTrack = (await originalInput.getPrimaryAudioTrack())!;
+
+ expect(originalAudioTrack.codec).toBe('ac3');
+ expect(originalAudioTrack.internalCodecId).toBe(0x81);
+
+ const output = new Output({
+ format: new MpegTsOutputFormat(),
+ target: new BufferTarget(),
+ });
+
+ const conversion = await Conversion.init({ input: originalInput, output });
+ await conversion.execute();
+
+ using newInput = new Input({
+ source: new BufferSource(output.target.buffer!),
+ formats: ALL_FORMATS,
+ });
+
+ const newAudioTrack = (await newInput.getPrimaryAudioTrack())!;
+
+ expect(newAudioTrack.codec).toBe('ac3');
+ expect(newAudioTrack.internalCodecId).toBe(0x81);
+ expect(newAudioTrack.numberOfChannels).toBe(originalAudioTrack.numberOfChannels);
+ expect(newAudioTrack.sampleRate).toBe(originalAudioTrack.sampleRate);
+
+ // Verify registration_descriptor is present
+ const buffer = new Uint8Array(output.target.buffer!);
+ let found = false;
+ for (let i = 0; i < buffer.length - AC3_REGISTRATION_DESCRIPTOR.length; i++) {
+ if (AC3_REGISTRATION_DESCRIPTOR.every((byte, j) => buffer[i + j] === byte)) {
+ found = true;
+ break;
+ }
+ }
+ expect(found).toBe(true);
+});
+
+test('reads and writes E-AC-3 in MPEG-TS', async () => {
+ using originalInput = new Input({
+ source: new FilePathSource(path.join(__dirname, '..', 'public/eac3.ts')),
+ formats: ALL_FORMATS,
+ });
+
+ const originalAudioTrack = (await originalInput.getPrimaryAudioTrack())!;
+
+ expect(originalAudioTrack.codec).toBe('eac3');
+ expect(originalAudioTrack.internalCodecId).toBe(0x87);
+
+ const output = new Output({
+ format: new MpegTsOutputFormat(),
+ target: new BufferTarget(),
+ });
+
+ const conversion = await Conversion.init({ input: originalInput, output });
+ await conversion.execute();
+
+ using newInput = new Input({
+ source: new BufferSource(output.target.buffer!),
+ formats: ALL_FORMATS,
+ });
+
+ const newAudioTrack = (await newInput.getPrimaryAudioTrack())!;
+
+ expect(newAudioTrack.codec).toBe('eac3');
+ expect(newAudioTrack.internalCodecId).toBe(0x87);
+ expect(newAudioTrack.numberOfChannels).toBe(originalAudioTrack.numberOfChannels);
+ expect(newAudioTrack.sampleRate).toBe(originalAudioTrack.sampleRate);
+
+ // Verify registration_descriptor is present
+ const buffer = new Uint8Array(output.target.buffer!);
+ let found = false;
+ for (let i = 0; i < buffer.length - EAC3_REGISTRATION_DESCRIPTOR.length; i++) {
+ if (EAC3_REGISTRATION_DESCRIPTOR.every((byte, j) => buffer[i + j] === byte)) {
+ found = true;
+ break;
+ }
+ }
+ expect(found).toBe(true);
+});
+
+test('Custom coder registration', async () => {
+ using ac3Input = new Input({
+ source: new FilePathSource(path.join(__dirname, '..', 'public/ac3.mp4')),
+ formats: ALL_FORMATS,
+ });
+ using eac3Input = new Input({
+ source: new FilePathSource(path.join(__dirname, '..', 'public/eac3.mp4')),
+ formats: ALL_FORMATS,
+ });
+
+ const ac3Track = (await ac3Input.getPrimaryAudioTrack())!;
+ const eac3Track = (await eac3Input.getPrimaryAudioTrack())!;
+
+ // Before registration, nothing can decode or encode AC3/EAC3
+ expect(await ac3Track.canDecode()).toBe(false);
+ expect(await eac3Track.canDecode()).toBe(false);
+ expect(await canEncode('ac3')).toBe(false);
+ expect(await canEncode('eac3')).toBe(false);
+
+ registerAc3Decoder();
+ registerAc3Encoder();
+
+ // After registration, both should work
+ expect(await ac3Track.canDecode()).toBe(true);
+ expect(await eac3Track.canDecode()).toBe(true);
+ expect(await canEncode('ac3')).toBe(true);
+ expect(await canEncode('eac3')).toBe(true);
+});
+
+test('AC-3 decoding', async () => {
+ registerAc3Decoder();
+
+ using input = new Input({
+ source: new FilePathSource(path.join(__dirname, '..', 'public/ac3.mp4')),
+ formats: ALL_FORMATS,
+ });
+
+ const track = (await input.getPrimaryAudioTrack())!;
+ const { packetCount } = await track.computePacketStats();
+ const sink = new AudioSampleSink(track);
+
+ let sampleCount = 0;
+ let nextTimestamp = 0;
+
+ for await (using sample of sink.samples()) {
+ expect(sample.timestamp).toBeCloseTo(nextTimestamp);
+ expect(sample.duration).toBe(0.032);
+ expect(sample.format).toBe('f32-planar');
+ expect(sample.numberOfChannels).toBe(track.numberOfChannels);
+ expect(sample.sampleRate).toBe(track.sampleRate);
+
+ nextTimestamp += sample.duration;
+ sampleCount++;
+ }
+
+ expect(sampleCount).toBe(packetCount);
+});
+
+test('E-AC-3 decoding', async () => {
+ registerAc3Decoder();
+
+ using input = new Input({
+ source: new FilePathSource(path.join(__dirname, '..', 'public/eac3.mp4')),
+ formats: ALL_FORMATS,
+ });
+
+ const track = (await input.getPrimaryAudioTrack())!;
+ const { packetCount } = await track.computePacketStats();
+ const sink = new AudioSampleSink(track);
+
+ let sampleCount = 0;
+ let nextTimestamp = 0;
+
+ for await (using sample of sink.samples()) {
+ expect(sample.timestamp).toBeCloseTo(nextTimestamp);
+ expect(sample.duration).toBe(0.032);
+ expect(sample.format).toBe('f32-planar');
+ expect(sample.numberOfChannels).toBe(track.numberOfChannels);
+ expect(sample.sampleRate).toBe(track.sampleRate);
+
+ nextTimestamp += sample.duration;
+ sampleCount++;
+ }
+
+ expect(sampleCount).toBe(packetCount);
+});
+
+const createSineWave = (sampleRate: number, channels: number, durationSeconds: number) => {
+ const totalFrames = sampleRate * durationSeconds;
+ const data = new Float32Array(totalFrames * channels);
+
+ for (let i = 0; i < totalFrames; i++) {
+ const value = Math.sin(2 * Math.PI * 440 * i / sampleRate);
+ for (let ch = 0; ch < channels; ch++) {
+ data[i * channels + ch] = value;
+ }
+ }
+
+ return data;
+};
+
+test('AC-3 encoding', async () => {
+ registerAc3Encoder();
+
+ const sampleRate = 48000;
+ const channels = 2;
+ const durationSeconds = 2;
+ const data = createSineWave(sampleRate, channels, durationSeconds);
+
+ const output = new Output({
+ format: new Mp4OutputFormat(),
+ target: new BufferTarget(),
+ });
+
+ const audioSource = new AudioSampleSource({ codec: 'ac3', bitrate: 192000 });
+ output.addAudioTrack(audioSource);
+
+ await output.start();
+ await audioSource.add(new AudioSample({
+ data,
+ format: 'f32',
+ numberOfChannels: channels,
+ sampleRate,
+ timestamp: 0,
+ }));
+ audioSource.close();
+ await output.finalize();
+
+ using input = new Input({
+ source: new BufferSource(output.target.buffer!),
+ formats: ALL_FORMATS,
+ });
+
+ const track = (await input.getPrimaryAudioTrack())!;
+ expect(track.codec).toBe('ac3');
+ expect(track.sampleRate).toBe(sampleRate);
+ expect(track.numberOfChannels).toBe(channels);
+
+ const sink = new EncodedPacketSink(track);
+ let packetCount = 0;
+ for await (const packet of sink.packets()) {
+ expect(packet.type).toBe('key');
+ packetCount++;
+ }
+ expect(packetCount).toBeGreaterThan(0);
+
+ expect(await track.computeDuration()).toBeCloseTo(2, 1);
+});
+
+test('E-AC-3 encoding', async () => {
+ registerAc3Encoder();
+
+ const sampleRate = 48000;
+ const channels = 2;
+ const durationSeconds = 2;
+ const data = createSineWave(sampleRate, channels, durationSeconds);
+
+ const output = new Output({
+ format: new Mp4OutputFormat(),
+ target: new BufferTarget(),
+ });
+
+ const audioSource = new AudioSampleSource({ codec: 'eac3', bitrate: 192000 });
+ output.addAudioTrack(audioSource);
+
+ await output.start();
+ await audioSource.add(new AudioSample({
+ data,
+ format: 'f32',
+ numberOfChannels: channels,
+ sampleRate,
+ timestamp: 0,
+ }));
+ audioSource.close();
+ await output.finalize();
+
+ using input = new Input({
+ source: new BufferSource(output.target.buffer!),
+ formats: ALL_FORMATS,
+ });
+
+ const track = (await input.getPrimaryAudioTrack())!;
+ expect(track.codec).toBe('eac3');
+ expect(track.sampleRate).toBe(sampleRate);
+ expect(track.numberOfChannels).toBe(channels);
+
+ const sink = new EncodedPacketSink(track);
+ let packetCount = 0;
+ for await (const packet of sink.packets()) {
+ expect(packet.type).toBe('key');
+ packetCount++;
+ }
+ expect(packetCount).toBeGreaterThan(0);
+
+ expect(await track.computeDuration()).toBeCloseTo(2, 1);
+});
diff --git a/test/node/mpeg-ts-demuxing.test.ts b/test/node/mpeg-ts-demuxing.test.ts
index ea85a38..62349b9 100644
--- a/test/node/mpeg-ts-demuxing.test.ts
+++ b/test/node/mpeg-ts-demuxing.test.ts
@@ -9,6 +9,7 @@ import { assert } from '../../src/misc.js';
import { EncodedPacketSink } from '../../src/media-sink.js';
import { EncodedPacket } from '../../src/packet.js';
import { MpegTsDemuxer } from '../../src/mpeg-ts/mpeg-ts-demuxer.js';
+import { MpegTsStreamType } from '../../src/mpeg-ts/mpeg-ts-misc.js';
const __dirname = new URL('.', import.meta.url).pathname;
@@ -612,6 +613,146 @@ test('MPEG-TS with MP3 audio', async () => {
expect(count).toBeGreaterThan(0);
});
+test('MPEG-TS with AC-3 audio (System A)', async () => {
+ using input = new Input({
+ source: new FilePathSource(path.join(__dirname, '../public/ac3.ts')),
+ formats: ALL_FORMATS,
+ });
+
+ const audioTrack = await input.getPrimaryAudioTrack();
+ assert(audioTrack);
+
+ expect(audioTrack.codec).toBe('ac3');
+ expect(audioTrack.internalCodecId).toBe(MpegTsStreamType.AC3_SYSTEM_A);
+
+ const audioDecoderConfig = await audioTrack.getDecoderConfig();
+ expect(audioDecoderConfig).toEqual({
+ codec: 'ac-3',
+ numberOfChannels: 6,
+ sampleRate: 48000,
+ });
+
+ const sink = new EncodedPacketSink(audioTrack);
+
+ const firstPacket = await sink.getFirstPacket();
+ assert(firstPacket);
+
+ let count = 0;
+ for await (const packet of sink.packets()) {
+ expect(packet.data[0]).toBe(0x0b);
+ expect(packet.data[1]).toBe(0x77);
+ expect(packet.type).toBe('key');
+ count++;
+ }
+
+ expect(count).toBeGreaterThan(0);
+});
+
+test('MPEG-TS with AC-3 audio (System B)', async () => {
+ using input = new Input({
+ source: new FilePathSource(path.join(__dirname, '../public/ac3-system-b.ts')),
+ formats: ALL_FORMATS,
+ });
+
+ const audioTrack = await input.getPrimaryAudioTrack();
+ assert(audioTrack);
+
+ expect(audioTrack.codec).toBe('ac3');
+ expect(audioTrack.internalCodecId).toBe(MpegTsStreamType.PRIVATE_DATA);
+
+ const audioDecoderConfig = await audioTrack.getDecoderConfig();
+ expect(audioDecoderConfig).toEqual({
+ codec: 'ac-3',
+ numberOfChannels: 6,
+ sampleRate: 48000,
+ });
+
+ const sink = new EncodedPacketSink(audioTrack);
+
+ const firstPacket = await sink.getFirstPacket();
+ assert(firstPacket);
+
+ let count = 0;
+ for await (const packet of sink.packets()) {
+ expect(packet.data[0]).toBe(0x0b);
+ expect(packet.data[1]).toBe(0x77);
+ expect(packet.type).toBe('key');
+ count++;
+ }
+
+ expect(count).toBeGreaterThan(0);
+});
+
+test('MPEG-TS with E-AC-3 audio (System A)', async () => {
+ using input = new Input({
+ source: new FilePathSource(path.join(__dirname, '../public/eac3.ts')),
+ formats: ALL_FORMATS,
+ });
+
+ const audioTrack = await input.getPrimaryAudioTrack();
+ assert(audioTrack);
+
+ expect(audioTrack.codec).toBe('eac3');
+ expect(audioTrack.internalCodecId).toBe(MpegTsStreamType.EAC3_SYSTEM_A);
+
+ const audioDecoderConfig = await audioTrack.getDecoderConfig();
+ expect(audioDecoderConfig).toEqual({
+ codec: 'ec-3',
+ numberOfChannels: 6,
+ sampleRate: 48000,
+ });
+
+ const sink = new EncodedPacketSink(audioTrack);
+
+ const firstPacket = await sink.getFirstPacket();
+ assert(firstPacket);
+
+ let count = 0;
+ for await (const packet of sink.packets()) {
+ expect(packet.data[0]).toBe(0x0b);
+ expect(packet.data[1]).toBe(0x77);
+ expect(packet.type).toBe('key');
+ count++;
+ }
+
+ expect(count).toBeGreaterThan(0);
+});
+
+test('MPEG-TS with E-AC-3 audio (System B)', async () => {
+ using input = new Input({
+ source: new FilePathSource(path.join(__dirname, '../public/eac3-system-b.ts')),
+ formats: ALL_FORMATS,
+ });
+
+ const audioTrack = await input.getPrimaryAudioTrack();
+ assert(audioTrack);
+
+ expect(audioTrack.codec).toBe('eac3');
+ expect(audioTrack.internalCodecId).toBe(MpegTsStreamType.PRIVATE_DATA);
+
+ const audioDecoderConfig = await audioTrack.getDecoderConfig();
+ expect(audioDecoderConfig).toEqual({
+ codec: 'ec-3',
+ numberOfChannels: 6,
+ sampleRate: 48000,
+ });
+
+ const sink = new EncodedPacketSink(audioTrack);
+
+ const firstPacket = await sink.getFirstPacket();
+ assert(firstPacket);
+
+ let count = 0;
+ for await (const packet of sink.packets()) {
+ expect(packet.data[0]).toBe(0x0b);
+ expect(packet.data[1]).toBe(0x77);
+ expect(packet.type).toBe('key');
+ count++;
+ }
+
+ expect(count).toBeGreaterThan(0);
+});
+
test('MPEG-TS partial reading', async () => {
const fullPath = path.join(__dirname, '../public/193039199_mp4_h264_aac_fhd_7.ts');
const buffer = await fs.promises.readFile(fullPath);
diff --git a/test/node/read-wav.test.ts b/test/node/read-wav.test.ts
new file mode 100644
index 0000000..87f6f79
--- /dev/null
+++ b/test/node/read-wav.test.ts
@@ -0,0 +1,24 @@
+import { test } from 'vitest';
+import path from 'node:path';
+import { ALL_FORMATS, EncodedPacketSink, Input, FilePathSource } from '../../src/index.js';
+
+const __dirname = new URL('.', import.meta.url).pathname;
+
+test('Should handle WAV file with oversized ID3 chunk', async () => {
+ const filePath = path.join(__dirname, '..', 'public/oversized-id3.wav');
+ using input = new Input({
+ source: new FilePathSource(filePath),
+ formats: ALL_FORMATS,
+ });
+
+ const track = await input.getPrimaryAudioTrack();
+ if (!track) {
+ throw new Error('No audio track found');
+ }
+
+ const sink = new EncodedPacketSink(track);
+
+ for await (const packet of sink.packets()) {
+ void packet;
+ }
+});
diff --git a/test/public/ac3-system-b.ts b/test/public/ac3-system-b.ts
new file mode 100644
index 0000000..20a2fde
Binary files /dev/null and b/test/public/ac3-system-b.ts differ
diff --git a/test/public/ac3.mkv b/test/public/ac3.mkv
new file mode 100644
index 0000000..3b9a226
Binary files /dev/null and b/test/public/ac3.mkv differ
diff --git a/test/public/ac3.mp4 b/test/public/ac3.mp4
new file mode 100644
index 0000000..4dc638e
Binary files /dev/null and b/test/public/ac3.mp4 differ
diff --git a/test/public/ac3.ts b/test/public/ac3.ts
new file mode 100644
index 0000000..38b82c1
Binary files /dev/null and b/test/public/ac3.ts differ
diff --git a/test/public/eac3-system-b.ts b/test/public/eac3-system-b.ts
new file mode 100644
index 0000000..462911e
Binary files /dev/null and b/test/public/eac3-system-b.ts differ
diff --git a/test/public/eac3.mkv b/test/public/eac3.mkv
new file mode 100644
index 0000000..b9fb219
Binary files /dev/null and b/test/public/eac3.mkv differ
diff --git a/test/public/eac3.mp4 b/test/public/eac3.mp4
new file mode 100644
index 0000000..aa31d2a
Binary files /dev/null and b/test/public/eac3.mp4 differ
diff --git a/test/public/eac3.ts b/test/public/eac3.ts
new file mode 100644
index 0000000..fb00fef
Binary files /dev/null and b/test/public/eac3.ts differ
diff --git a/test/public/oversized-id3.wav b/test/public/oversized-id3.wav
new file mode 100644
index 0000000..6996ea3
Binary files /dev/null and b/test/public/oversized-id3.wav differ
diff --git a/tsconfig.vite.json b/tsconfig.vite.json
index e40e718..18c8e14 100644
--- a/tsconfig.vite.json
+++ b/tsconfig.vite.json
@@ -7,6 +7,7 @@
"noEmit": false,
"paths": {
"mediabunny": ["./src/index.ts"],
+ "@mediabunny/ac3": ["./packages/ac3/src/index.ts"],
},
"types": ["vite/client"]
},
diff --git a/tsconfig.vitest.json b/tsconfig.vitest.json
index 7a24606..7101888 100644
--- a/tsconfig.vitest.json
+++ b/tsconfig.vitest.json
@@ -4,9 +4,13 @@
"moduleResolution": "nodenext",
"module": "NodeNext",
"composite": true,
- "noEmit": false
+ "noEmit": false,
+ "paths": {
+ "mediabunny": ["./src/index.ts"],
+ "@mediabunny/ac3": ["./packages/ac3/src/index.ts"],
+ },
},
"include": ["vitest.config.ts", "./test/**/*"],
"exclude": ["./test/public/**/*"],
- "references": [{ "path": "./src" }]
+ "references": [{ "path": "./src" }, { "path": "./packages/ac3" }]
}
diff --git a/vitest.config.ts b/vitest.config.ts
index 33a53df..3623ed8 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -1,11 +1,19 @@
///
import { defineConfig } from 'vitest/config';
+import path from 'path';
export default defineConfig({
+ resolve: {
+ alias: {
+ 'mediabunny': path.resolve(__dirname, './src/index.ts'),
+ '@mediabunny/ac3': path.resolve(__dirname, './packages/ac3/dist/bundles/mediabunny-ac3.mjs'),
+ },
+ },
test: {
projects: [
{
+ extends: true,
test: {
name: 'node',
root: 'test',
@@ -14,6 +22,7 @@ export default defineConfig({
},
},
{
+ extends: true,
test: {
name: 'browser',
root: 'test',
+