Fully update MP3 demuxer to use new packet reading system & mutex, add MP3 reading tests

test/node/demux-mp3.test.ts

@@ -0,0 +1,95 @@
+import { expect, test } from 'vitest';
+import { Input } from '../../src/input.js';
+import { BufferSource, FilePathSource } from '../../src/source.js';
+import path from 'node:path';
+import fs from 'node:fs';
+import { ALL_FORMATS, MP3 } from '../../src/input-format.js';
+import { PacketReader } from '../../src/cursors.js';
+import { InputAudioTrack } from '../../src/input-track.js';
+import { assert } from '../../src/misc.js';
+import { EncodedPacket } from '../../src/packet.js';
+
+const __dirname = new URL('.', import.meta.url).pathname;
+
+test('MP3 demuxing', async () => {
+	using input = new Input({
+		source: new FilePathSource(path.join(__dirname, '../public/AudacityTest1.mp3')),
+		formats: ALL_FORMATS,
+	});
+
+	expect(await input.getFormat()).toBe(MP3);
+	expect(await input.getMimeType()).toBe('audio/mpeg');
+
+	const tracks = await input.getTracks();
+	expect(tracks).toHaveLength(1);
+	const audioTrack = tracks[0] as InputAudioTrack;
+	expect(audioTrack).toBeInstanceOf(InputAudioTrack);
+
+	expect(audioTrack.numberOfChannels).toBe(1);
+	expect(audioTrack.sampleRate).toBe(44100);
+
+	const decoderConfig = await audioTrack.getDecoderConfig();
+	expect(decoderConfig!.codec).toBe('mp3');
+	expect(decoderConfig!.numberOfChannels).toBe(audioTrack.numberOfChannels);
+	expect(decoderConfig!.sampleRate).toBe(audioTrack.sampleRate);
+	expect(decoderConfig!.description).toBeUndefined();
+
+	const reader = new PacketReader(audioTrack);
+	const first = await reader.readFirst();
+	expect(first).not.toBe(null);
+	expect(first!.timestamp).toBe(0);
+	expect(first!.data[0]).toBe(255);
+
+	const next = await reader.readNext(first!);
+	expect(next).not.toBe(null);
+	expect(next!.timestamp).toBeCloseTo(first!.timestamp + first!.duration);
+	expect(next!.sequenceNumber).toBeGreaterThan(first!.sequenceNumber);
+
+	const nextKey = await reader.readNextKey(first!);
+	expect(nextKey).not.toBe(null);
+	expect(nextKey!.timestamp).toBe(next!.timestamp);
+
+	const seeked = await reader.readAt(1);
+	expect(seeked).not.toBe(null);
+	expect(seeked!.timestamp).toBeGreaterThan(0.9);
+	expect(seeked!.timestamp).toBeLessThanOrEqual(1);
+	expect(seeked!.sequenceNumber).toBeGreaterThan(next!.sequenceNumber);
+
+	const seekedKey = await reader.readKeyAt(1);
+	expect(seekedKey).not.toBe(null);
+	expect(seeked!.sequenceNumber).toBe(seeked!.sequenceNumber);
+
+	const last = await reader.readAt(Infinity);
+	expect(last).not.toBe(null);
+	expect(last!.sequenceNumber).toBeGreaterThan(seeked!.sequenceNumber);
+
+	const afterLast = await reader.readNext(last!);
+	expect(afterLast).toBe(null);
+
+	const firstTimestamp = await audioTrack.getFirstTimestamp();
+	expect(firstTimestamp).toBe(0);
+
+	const duration = await audioTrack.computeDuration();
+	expect(duration).toBe(last!.timestamp + last!.duration);
+});
+
+test('Sync reading', async () => {
+	using input = new Input({
+		source: new BufferSource(fs.readFileSync(path.join(__dirname, '../public/AudacityTest1.mp3'))),
+		formats: ALL_FORMATS,
+	});
+
+	const audioTrack = await input.getPrimaryAudioTrack();
+	assert(audioTrack);
+
+	const reader = new PacketReader(audioTrack);
+
+	let current = reader.readFirst() as EncodedPacket | null;
+	let count = 0;
+	while (current) {
+		current = reader.readNext(current) as EncodedPacket | null;
+		count++;
+	}
+
+	expect(count).toBe(475);
+});