Merge branch 'main' into hls

test/browser/mpeg-ts-muxing.test.ts

@@ -156,7 +156,6 @@ test('MPEG-TS muxing with AVC and AAC', async () => {
 
 	const secondVideoPacket = await videoSink.getNextPacket(firstVideoPacket);
 	assert(secondVideoPacket);
-	expect(secondVideoPacket.type).toBe('delta');
 
 	for await (const packet of videoSink.packets()) {
 		expect(packet.data.slice(0, 4)).toEqual(new Uint8Array([0, 0, 0, 1])); // Annex B start code

test/node/aac-encoder-extension.test.ts

@@ -0,0 +1,82 @@
+import { expect, test } from 'vitest';
+import { Input } from '../../src/input.js';
+import { BufferSource } from '../../src/source.js';
+import { ALL_FORMATS } from '../../src/input-format.js';
+import { Output } from '../../src/output.js';
+import { BufferTarget } from '../../src/target.js';
+import { canEncode } from '../../src/encode.js';
+import { AudioSampleSource } from '../../src/media-source.js';
+import { EncodedPacketSink } from '../../src/media-sink.js';
+import { Mp4OutputFormat } from '../../src/output-format.js';
+import { AudioSample } from '../../src/sample.js';
+import { registerAacEncoder } from '@mediabunny/aac-encoder';
+
+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('Custom coder registration', async () => {
+	expect(await canEncode('aac')).toBe(false);
+
+	registerAacEncoder();
+
+	expect(await canEncode('aac')).toBe(true);
+});
+
+test('AAC encoding', async () => {
+	registerAacEncoder();
+
+	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: 'aac', bitrate: 128000 });
+	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('aac');
+	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(durationSeconds * sampleRate / 1024);
+
+	expect(await track.computeDuration()).toBeCloseTo(2, 1);
+});