feat(codec): add detection support for AC-3, E-AC-3 audio codecs (#275)

* ac3/eac3 detection

* fix tests

* review pass + follow codebase comments style

* Add ac3/eac3 to docs

* WIP mpeg-2

* Set registration_descriptor

* add support for ac3 system b in mpeg-ts

* Update docs with ac3 in .ts support

* fix formatting

* Remove default to fix linter

* Add eac3 to mpeg-ts

* fix formatting

* Fix failing test

* Refactor AC3/EAC3 code a little

---------

Co-authored-by: Vanilagy <[email protected]>

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);