Ensure extensions work with huge timestamps, fix AC3 and AAC extension's behavior with huge timestamps

This commit is contained in:
Vanilagy
2026-04-27 20:58:05 +02:00
parent 0cc564b47a
commit 0f6c374750
12 changed files with 282 additions and 31 deletions
+42
View File
@@ -10,6 +10,7 @@ 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';
import { assert } from '../../src/misc.js';
const createSineWave = (sampleRate: number, channels: number, durationSeconds: number) => {
const totalFrames = sampleRate * durationSeconds;
@@ -80,3 +81,44 @@ test('AAC encoding', async () => {
expect(await track.computeDuration()).toBeCloseTo(2, 1);
});
test('AAC with huge timestamps', async () => {
registerAacEncoder();
const sampleRate = 48000;
const channels = 2;
const timestamp = 1e9;
const durationSeconds = 2;
const data = createSineWave(sampleRate, channels, durationSeconds);
const output = new Output({
format: new Mp4OutputFormat({ fastStart: 'fragmented' }),
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,
}));
audioSource.close();
await output.finalize();
using input = new Input({
source: new BufferSource(output.target.buffer!),
formats: ALL_FORMATS,
});
const track = (await input.getPrimaryAudioTrack())!;
const sink = new EncodedPacketSink(track);
const firstPacket = await sink.getFirstPacket();
assert(firstPacket);
expect(firstPacket.timestamp).toBe(timestamp);
});
+99
View File
@@ -14,6 +14,7 @@ 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';
import { assert } from '../../src/misc.js';
const __dirname = new URL('.', import.meta.url).pathname;
@@ -329,3 +330,101 @@ test('E-AC-3 encoding', async () => {
expect(await track.computeDuration()).toBeCloseTo(2, 1);
});
test('AC-3 with huge timestamps', async () => {
registerAc3Decoder();
registerAc3Encoder();
const sampleRate = 48000;
const channels = 2;
const timestamp = 1e9;
const durationSeconds = 2;
const data = createSineWave(sampleRate, channels, durationSeconds);
const output = new Output({
format: new Mp4OutputFormat({ fastStart: 'fragmented' }),
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,
}));
audioSource.close();
await output.finalize();
using input = new Input({
source: new BufferSource(output.target.buffer!),
formats: ALL_FORMATS,
});
const track = (await input.getPrimaryAudioTrack())!;
const packetSink = new EncodedPacketSink(track);
const firstPacket = await packetSink.getFirstPacket();
assert(firstPacket);
expect(firstPacket.timestamp).toBe(timestamp);
const sampleSink = new AudioSampleSink(track);
const iterator = sampleSink.samples(timestamp);
const firstSample = (await iterator.next()).value;
assert(firstSample);
expect(firstSample.timestamp).toBe(timestamp);
});
test('E-AC-3 with huge timestamps', async () => {
registerAc3Decoder();
registerAc3Encoder();
const sampleRate = 48000;
const channels = 2;
const timestamp = 1e9;
const durationSeconds = 2;
const data = createSineWave(sampleRate, channels, durationSeconds);
const output = new Output({
format: new Mp4OutputFormat({ fastStart: 'fragmented' }),
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,
}));
audioSource.close();
await output.finalize();
using input = new Input({
source: new BufferSource(output.target.buffer!),
formats: ALL_FORMATS,
});
const track = (await input.getPrimaryAudioTrack())!;
const packetSink = new EncodedPacketSink(track);
const firstPacket = await packetSink.getFirstPacket();
assert(firstPacket);
expect(firstPacket.timestamp).toBe(timestamp);
const sampleSink = new AudioSampleSink(track);
const iterator = sampleSink.samples(timestamp);
const firstSample = (await iterator.next()).value;
assert(firstSample);
expect(firstSample.timestamp).toBe(timestamp);
});
+43 -1
View File
@@ -7,9 +7,10 @@ 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 { FlacOutputFormat } from '../../src/output-format.js';
import { FlacOutputFormat, Mp4OutputFormat } from '../../src/output-format.js';
import { AudioSample } from '../../src/sample.js';
import { registerFlacEncoder } from '@mediabunny/flac-encoder';
import { assert } from '../../src/misc.js';
const createSineWave = (sampleRate: number, channels: number, durationSeconds: number) => {
const totalFrames = sampleRate * durationSeconds;
@@ -81,3 +82,44 @@ test('FLAC encoding', async () => {
expect(await track.computeDuration()).toBeCloseTo(2, 1);
});
test('FLAC with huge timestamps', async () => {
registerFlacEncoder();
const sampleRate = 48000;
const channels = 2;
const timestamp = 1e9;
const durationSeconds = 2;
const data = createSineWave(sampleRate, channels, durationSeconds);
const output = new Output({
format: new Mp4OutputFormat({ fastStart: 'fragmented' }),
target: new BufferTarget(),
});
const audioSource = new AudioSampleSource({ codec: 'flac', bitrate: 1 });
output.addAudioTrack(audioSource);
await output.start();
await audioSource.add(new AudioSample({
data,
format: 'f32',
numberOfChannels: channels,
sampleRate,
timestamp,
}));
audioSource.close();
await output.finalize();
using input = new Input({
source: new BufferSource(output.target.buffer!),
formats: ALL_FORMATS,
});
const track = (await input.getPrimaryAudioTrack())!;
const sink = new EncodedPacketSink(track);
const firstPacket = await sink.getFirstPacket();
assert(firstPacket);
expect(firstPacket.timestamp).toBe(timestamp);
});
+43 -1
View File
@@ -7,9 +7,10 @@ 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 { Mp3OutputFormat } from '../../src/output-format.js';
import { Mp3OutputFormat, Mp4OutputFormat } from '../../src/output-format.js';
import { AudioSample } from '../../src/sample.js';
import { registerMp3Encoder } from '@mediabunny/mp3-encoder';
import { assert } from '../../src/misc.js';
const createSineWave = (sampleRate: number, channels: number, durationSeconds: number) => {
const totalFrames = sampleRate * durationSeconds;
@@ -81,3 +82,44 @@ test('MP3 encoding', async () => {
expect(await track.computeDuration()).toBeCloseTo(2, 0);
});
test('MP3 with huge timestamps', async () => {
registerMp3Encoder();
const sampleRate = 44100;
const channels = 2;
const timestamp = 1e9;
const durationSeconds = 2;
const data = createSineWave(sampleRate, channels, durationSeconds);
const output = new Output({
format: new Mp4OutputFormat({ fastStart: 'fragmented' }),
target: new BufferTarget(),
});
const audioSource = new AudioSampleSource({ codec: 'mp3', bitrate: 128_000 });
output.addAudioTrack(audioSource);
await output.start();
await audioSource.add(new AudioSample({
data,
format: 'f32',
numberOfChannels: channels,
sampleRate,
timestamp,
}));
audioSource.close();
await output.finalize();
using input = new Input({
source: new BufferSource(output.target.buffer!),
formats: ALL_FORMATS,
});
const track = (await input.getPrimaryAudioTrack())!;
const sink = new EncodedPacketSink(track);
const firstPacket = await sink.getFirstPacket();
assert(firstPacket);
expect(firstPacket.timestamp).toBe(timestamp);
});