From 0f6c374750d0f2d95f4a435c96ba8da75312a93f Mon Sep 17 00:00:00 2001
From: Vanilagy <1696106+Vanilagy@users.noreply.github.com>
Date: Mon, 27 Apr 2026 20:58:05 +0200
Subject: [PATCH] Ensure extensions work with huge timestamps, fix AC3 and AAC
 extension's behavior with huge timestamps

---
 dev/convert.html                          |   5 +-
 docs/guide/converting-media-files.md      |  23 +++++
 packages/aac-encoder/build/aac.js         | Bin 589600 -> 589426 bytes
 packages/aac-encoder/src/bridge.c         |   7 +-
 packages/aac-encoder/src/encode.worker.ts |  12 +--
 packages/ac3/build/ac3.js                 | Bin 687356 -> 687354 bytes
 packages/ac3/src/bridge.c                 |  13 +--
 packages/ac3/src/codec.worker.ts          |  24 +++---
 test/node/aac-encoder-extension.test.ts   |  42 +++++++++
 test/node/ac3.test.ts                     |  99 ++++++++++++++++++++++
 test/node/flac-encoder-extension.test.ts  |  44 +++++++++-
 test/node/mp3-encoder-extension.test.ts   |  44 +++++++++-
 12 files changed, 282 insertions(+), 31 deletions(-)

diff --git a/dev/convert.html b/dev/convert.html
index c7d93eb..17b6d33 100644
--- a/dev/convert.html
+++ b/dev/convert.html
@@ -6,7 +6,7 @@
 
 <script type="module">
 	//MediabunnyMp3Encoder.registerMp3Encoder();
-	MediabunnyAc3.registerAc3Encoder();
+	MediabunnyAc3.registerAc3Decoder();
 
 	const fileInput = document.createElement('input');
 	fileInput.type = 'file';
@@ -59,7 +59,7 @@
 
 		if (true) {
 			input = new Mediabunny.Input({
-				source: new Mediabunny.UrlSource('https://stream.mux.com/v69RSHhFelSm4701snP22dYz2jICy4E4FUyk02rW4gxRM.m3u8'),
+				source: new Mediabunny.UrlSource('http://localhost:8000/index.m3u8'),
 				formats: Mediabunny.ALL_FORMATS,
 			});
 
@@ -87,6 +87,7 @@
 
 		const primaryTrack = await input.getPrimaryAudioTrack();
 		const startTime = await primaryTrack.getFirstTimestamp();
+		console.log(startTime)
 
 		let ctx = null;
 		let conversion = await Mediabunny.Conversion.init({
diff --git a/docs/guide/converting-media-files.md b/docs/guide/converting-media-files.md
index cb3178a..c14b7d0 100644
--- a/docs/guide/converting-media-files.md
+++ b/docs/guide/converting-media-files.md
@@ -500,3 +500,26 @@ const conversion = await Conversion.init({ input, output });
 conversion.utilizedTracks; // => InputTrack[]
 ```
 A track may appear multiple times in this list when [fan-out](#track-fan-out) produces multiple output tracks from it.
+
+## Converting live streams
+
+Live inputs, like HLS live streams, can also be used with the Conversion API. In this case, by default, the conversion will run until the live stream has ended.
+
+If you only want to convert a part of the live stream instead of waiting until it has ended, you can [trim](#trimming) the conversion. For example, here we're capturing the next 60 seconds of the live stream:
+```ts
+// Get the live edge
+const currentDuration = await input.getDurationFromMetadata(undefined, {
+	skipLiveWait: true,
+});
+
+const conversion = await Conversion.init({
+	input,
+	output,
+	trim: {
+		// Start at the current live edge
+		start: currentDuration,
+		// End at most 60 seconds later
+		end: currentDuration + 60,
+	},
+});
+```
diff --git a/packages/aac-encoder/build/aac.js b/packages/aac-encoder/build/aac.js
index 9bd7d8d5b7ec0bfe1856801aa10329b6d93b77b3..6b49462faa943e09112c07ef1d3fa082bd34c1c3 100644
GIT binary patch
delta 5054
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
C6BTd(

delta 5208
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
EJNt@F$N&HU

diff --git a/packages/aac-encoder/src/bridge.c b/packages/aac-encoder/src/bridge.c
index 0306e38..ed4ca49 100644
--- a/packages/aac-encoder/src/bridge.c
+++ b/packages/aac-encoder/src/bridge.c
@@ -7,6 +7,7 @@
  */
 
 #include <emscripten.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 #include "libavcodec/avcodec.h"
@@ -20,7 +21,7 @@ typedef struct {
 	AVFrame *frame;
 	float *input_buffer;
 	int input_buffer_size;
-	int encoded_pts;
+	int64_t encoded_pts;
 	int encoded_duration;
 } EncoderContext;
 
@@ -123,7 +124,7 @@ float *get_encode_input_ptr(EncoderContext *ctx, int size) {
 }
 
 EMSCRIPTEN_KEEPALIVE
-int send_frame(EncoderContext *ctx, int pts) {
+int send_frame(EncoderContext *ctx, int64_t pts) {
 	int channels = ctx->codec_ctx->ch_layout.nb_channels;
 	int frame_size = ctx->frame->nb_samples;
 
@@ -171,7 +172,7 @@ uint8_t *get_encoded_data(EncoderContext *ctx) {
 }
 
 EMSCRIPTEN_KEEPALIVE
-int get_encoded_pts(EncoderContext *ctx) {
+int64_t get_encoded_pts(EncoderContext *ctx) {
 	return ctx->encoded_pts;
 }
 
diff --git a/packages/aac-encoder/src/encode.worker.ts b/packages/aac-encoder/src/encode.worker.ts
index 0023d49..76fea2f 100644
--- a/packages/aac-encoder/src/encode.worker.ts
+++ b/packages/aac-encoder/src/encode.worker.ts
@@ -21,12 +21,12 @@ let getEncoderFrameSize: (ctx: number) => number;
 let getEncoderExtradata: (ctx: number) => number;
 let getEncoderExtradataSize: (ctx: number) => number;
 let getEncodeInputPtr: (ctx: number, size: number) => number;
-let sendFrameFn: (ctx: number, pts: number) => number;
+let sendFrameFn: (ctx: number, pts: bigint) => number;
 let receivePacketFn: (ctx: number) => number;
 let flushEncoderStartFn: (ctx: number) => void;
 let resetEncoderFn: (ctx: number) => void;
 let getEncodedData: (ctx: number) => number;
-let getEncodedPts: (ctx: number) => number;
+let getEncodedPts: (ctx: number) => bigint;
 let getEncodedDuration: (ctx: number) => number;
 const ensureModule = async () => {
 	if (!module) {
@@ -43,12 +43,12 @@ const ensureModule = async () => {
 		getEncoderExtradata = module.cwrap('get_encoder_extradata', 'number', ['number']);
 		getEncoderExtradataSize = module.cwrap('get_encoder_extradata_size', 'number', ['number']);
 		getEncodeInputPtr = module.cwrap('get_encode_input_ptr', 'number', ['number', 'number']);
-		sendFrameFn = module.cwrap('send_frame', 'number', ['number', 'number']);
+		sendFrameFn = module.cwrap('send_frame', 'number', ['number', 'number']) as unknown as typeof sendFrameFn;
 		receivePacketFn = module.cwrap('receive_packet', 'number', ['number']);
 		flushEncoderStartFn = module.cwrap('flush_encoder_start', null, ['number']);
 		resetEncoderFn = module.cwrap('reset_encoder', null, ['number']);
 		getEncodedData = module.cwrap('get_encoded_data', 'number', ['number']);
-		getEncodedPts = module.cwrap('get_encoded_pts', 'number', ['number']);
+		getEncodedPts = module.cwrap('get_encoded_pts', 'number', ['number']) as unknown as typeof getEncodedPts;
 		getEncodedDuration = module.cwrap('get_encoded_duration', 'number', ['number']);
 	}
 };
@@ -81,7 +81,7 @@ const drainPackets = (ctx: number) => {
 	while ((size = receivePacketFn(ctx)) > 0) {
 		const ptr = getEncodedData(ctx);
 		const encodedData = module.HEAPU8.slice(ptr, ptr + size).buffer;
-		const pts = getEncodedPts(ctx);
+		const pts = Number(getEncodedPts(ctx));
 		const duration = getEncodedDuration(ctx);
 		packets.push({ encodedData, pts, duration });
 	}
@@ -98,7 +98,7 @@ const encode = (ctx: number, audioData: ArrayBuffer, timestamp: number) => {
 	}
 	module.HEAPU8.set(audioBytes, inputPtr);
 
-	const ret = sendFrameFn(ctx, timestamp);
+	const ret = sendFrameFn(ctx, BigInt(timestamp));
 	if (ret < 0) {
 		throw new Error(`Encode failed with error code ${ret}.`);
 	}
diff --git a/packages/ac3/build/ac3.js b/packages/ac3/build/ac3.js
index 777bd8a313d4091753c16961676e75ada177615d..65f4c2fee2722b17f890a0199d33a7064dfa359d 100644
GIT binary patch
delta 1007
zcmYjQOKTKC5bmn3>6yt))`?-w=A}Jjj5|hSd~JNjU7tx144RvB(1QqryK2yr=n5+F
zASliuiss<Sh#mydy@<l>U-0HX5Il>bV)c5lXR4~Z`m3t13i{WN_~(!K%{`a$J2ai$
zcb5s8a5F1+&0E;K3C-+!*O%;!H|vz(9Gn-)#_Y8>wzbTMx**mKku=y`5;5z`0$5)W
zDD$UQ{=^ar+)d#1XSP3fVL-y*;1I1=3SoGQQUu@<$X*4oc3f_yo(awb+qMtw@JJ>N
zZ(Y$NaFxxA!G)ck5MmeF&`*G1b2z$y(q=7{tqPS%pxsKX&7Sxp%{{o+rvecH(LN%*
z9}Wnbve)%Q2L)BBSQ8HL5^PGG)&c&dzgidNK-Al7u7E3vf{<&F_kAEKX}HP4Aq2^1
zLlg_7fD|1DSJ088ppu0VgJSBmhWfa)WhpgGh%%%;V7op$)jb0nvS;1>tlxLv?;aiX
zec>Jp0uti*+mnT53s&BK>zyMQ%ce@>u=#eqv{)}et6stvw;^m5pW)|6uzvCDxNLnL
zr=cw{(y|kJ+=KbYrRR0}qpb@1+B!;AO|{KwFyn)#Dae;0k`;8cT>8|YVk|XQFuwy@
z)|?8?X{kjS+Yi}!f?fG7OtlJ54>0_9gY=nlFc!hToK70dacVyeX8)@IHBmvW;gFb=
zrH)}1oZXZJ!-?21L@=G22o0y&L^>igEZw+7-@I6sJX;tNx^?X`eJ@}vTa6}tc-LGp
z<8GQO5velfA21|yaw1E^q&&-+gpt|7(AHKNPejNL7IruW=!dSXa)<UYs$x|uZ3XRD
zU{KS^LZ@a&QP6(*pVvfEgmF_krX|i8%ZVxO5z9CfqNj0{r(GTvUX3sflZHlZrA#t3
z4I)=W?Qlg#KpILPEzL2EPIU)M7tMYXirr|~G6s1zqVu)yA_Bj?T6-mL#TDz%@aSQH
t&J386>AKSx#|7;-5MqaGFsgCs<h(TuxLBXJSQLxR;;^`_`h3@e@?T;+s8Ij_

delta 1025
zcmY*X&u<iU6o2o1-+XtbGhL@_Tc+JD{mxKvmcm*@7Zj*FTF@dUP3S?BIpD#|B3o?H
z6LcYH>VZV#999E_BM=~I(wMz89(Ml)Pu~0kOh`N!j8Wf=9`HN!eth41^WNuuGJia)
z|M{%G{guPRAJseAE$4357&)J9jr`2m#m(%3`(9};euN*xi`kAlzi>eOOTeN#kaonZ
zLHd%I%YdRk1yY0C*5G>!G&(W5K{o2mFHb3)p04s9tqE)MS~H@<s45z9=8!tfV-0DA
zFE3P&xUABSyKll}baY9M6qjFd0pKW=FvxCrllH5xAvd+2$?kb`-D7mz<1#ZN^XtsB
zZ{P{wlcjxQ;VIxno_G^%lmlY+N*5dDRo<T22{jc~DtQW}F_b|~lK3rDoOYaaJt0(b
z&v8+iHL~Wn&;fpX33a-@Kd%y`JSmeIElcYf6DgD9Ad0dNMwhE-$-v^+|7qI>ac#hC
zcl6fy+??lubK3VA;0$S%uh2X4i!-(JS^1iUPj-H*tT5KIrJ#WaZ*Bxz8v*t=0=j<_
zO}~1Fe)<-pt)~suf7;;MVcg#zP5HYq8s6yLzr=raRg*lUPIJp}a;WVud*~YW2X`^T
zCfNr6&3JA9>~jTZs7Zq_&|qRWX~m#{n1<g-@SKDO*Qsr^e}3Aae>H)3i{5tIUy%;~
zZ<N&7pO2^)uW@ahOfiv+Kw?7%ngqS=4=JdSC#Vt#NuVVQ?Kv>i+g#&c-I&JR66C{!
z{^ytZ_cF!QU+ePj58a3I^K|nJL{?0LT?$oxvm-V*czjG<Fe-su&Q?QhIHq$EN<c&c
zrM%P&ZPgMS`V6<IWh|j(_(*7xjnegEXrUzf@VRLIB}dq;D|?Z~jdZN5g+&Ss##9T1
zTztVbwxNWsMA!};;f~vaGE6(NA<9HFC7CD{k|vKVlXe6aU1^)VSbdVa2MLZ-j#g?=
z$bsS+eo2Iz*iD8H`f=0xdnR5&EJ)x;*v;3r3rY<6!)*+)0P7zx*n5A~nnB#UxN3=L
Qk&=il;`A@Bj(i>e19mH_c>n+a

diff --git a/packages/ac3/src/bridge.c b/packages/ac3/src/bridge.c
index 21973f2..bb88428 100644
--- a/packages/ac3/src/bridge.c
+++ b/packages/ac3/src/bridge.c
@@ -7,6 +7,7 @@
  */
 
 #include <emscripten.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 #include "libavcodec/avcodec.h"
@@ -72,7 +73,7 @@ uint8_t *configure_decode_packet(DecoderContext *ctx, int size) {
 }
 
 EMSCRIPTEN_KEEPALIVE
-int decode_packet(DecoderContext *ctx, int pts) {
+int decode_packet(DecoderContext *ctx, int64_t pts) {
 	ctx->packet->pts = pts;
 	int ret = avcodec_send_packet(ctx->codec_ctx, ctx->packet);
 	av_packet_unref(ctx->packet);
@@ -110,8 +111,8 @@ int get_decoded_sample_count(DecoderContext *ctx) {
 }
 
 EMSCRIPTEN_KEEPALIVE
-int get_decoded_pts(DecoderContext *ctx) {
-	return (int)ctx->frame->pts;
+int64_t get_decoded_pts(DecoderContext *ctx) {
+	return ctx->frame->pts;
 }
 
 EMSCRIPTEN_KEEPALIVE
@@ -135,7 +136,7 @@ typedef struct {
 	AVFrame *frame;
 	float *input_buffer;
 	int input_buffer_size;
-	int encoded_pts;
+	int64_t encoded_pts;
 	int encoded_duration;
 } EncoderContext;
 
@@ -229,7 +230,7 @@ float *get_encode_input_ptr(EncoderContext *ctx, int size) {
 }
 
 EMSCRIPTEN_KEEPALIVE
-int encode_frame(EncoderContext *ctx, int pts) {
+int encode_frame(EncoderContext *ctx, int64_t pts) {
 	int channels = ctx->codec_ctx->ch_layout.nb_channels;
 	int frame_size = ctx->frame->nb_samples;
 
@@ -270,7 +271,7 @@ uint8_t *get_encoded_data(EncoderContext *ctx) {
 }
 
 EMSCRIPTEN_KEEPALIVE
-int get_encoded_pts(EncoderContext *ctx) {
+int64_t get_encoded_pts(EncoderContext *ctx) {
 	return ctx->encoded_pts;
 }
 
diff --git a/packages/ac3/src/codec.worker.ts b/packages/ac3/src/codec.worker.ts
index 7224b15..8bfc2fa 100644
--- a/packages/ac3/src/codec.worker.ts
+++ b/packages/ac3/src/codec.worker.ts
@@ -18,23 +18,23 @@ let modulePromise: Promise<ExtendedEmscriptenModule> | null = null;
 
 let initDecoderFn: (codecId: number) => number;
 let configureDecodePacket: (ctx: number, size: number) => number;
-let decodePacket: (ctx: number, pts: number) => number;
+let decodePacket: (ctx: number, pts: bigint) => number;
 let getDecodedFormat: (ctx: number) => number;
 let getDecodedPlanePtr: (ctx: number, plane: number) => number;
 let getDecodedChannels: (ctx: number) => number;
 let getDecodedSampleRate: (ctx: number) => number;
 let getDecodedSampleCount: (ctx: number) => number;
-let getDecodedPts: (ctx: number) => number;
+let getDecodedPts: (ctx: number) => bigint;
 let flushDecoderFn: (ctx: number) => void;
 let closeDecoderFn: (ctx: number) => void;
 
 let initEncoderFn: (codecId: number, channels: number, sampleRate: number, bitrate: number) => number;
 let getEncoderFrameSize: (ctx: number) => number;
 let getEncodeInputPtr: (ctx: number, size: number) => number;
-let encodeFrameFn: (ctx: number, pts: number) => number;
+let encodeFrameFn: (ctx: number, pts: bigint) => number;
 let flushEncoderFn: (ctx: number) => void;
 let getEncodedData: (ctx: number) => number;
-let getEncodedPts: (ctx: number) => number;
+let getEncodedPts: (ctx: number) => bigint;
 let getEncodedDuration: (ctx: number) => number;
 let closeEncoderFn: (ctx: number) => void;
 
@@ -53,23 +53,23 @@ const ensureModule = async () => {
 
 		initDecoderFn = module.cwrap('init_decoder', 'number', ['number']);
 		configureDecodePacket = module.cwrap('configure_decode_packet', 'number', ['number', 'number']);
-		decodePacket = module.cwrap('decode_packet', 'number', ['number', 'number']);
+		decodePacket = module.cwrap('decode_packet', 'number', ['number', 'number']) as unknown as typeof decodePacket;
 		getDecodedFormat = module.cwrap('get_decoded_format', 'number', ['number']);
 		getDecodedPlanePtr = module.cwrap('get_decoded_plane_ptr', 'number', ['number', 'number']);
 		getDecodedChannels = module.cwrap('get_decoded_channels', 'number', ['number']);
 		getDecodedSampleRate = module.cwrap('get_decoded_sample_rate', 'number', ['number']);
 		getDecodedSampleCount = module.cwrap('get_decoded_sample_count', 'number', ['number']);
-		getDecodedPts = module.cwrap('get_decoded_pts', 'number', ['number']);
+		getDecodedPts = module.cwrap('get_decoded_pts', 'number', ['number']) as unknown as typeof getDecodedPts;
 		flushDecoderFn = module.cwrap('flush_decoder', null, ['number']);
 		closeDecoderFn = module.cwrap('close_decoder', null, ['number']);
 
 		initEncoderFn = module.cwrap('init_encoder', 'number', ['number', 'number', 'number', 'number']);
 		getEncoderFrameSize = module.cwrap('get_encoder_frame_size', 'number', ['number']);
 		getEncodeInputPtr = module.cwrap('get_encode_input_ptr', 'number', ['number', 'number']);
-		encodeFrameFn = module.cwrap('encode_frame', 'number', ['number', 'number']);
+		encodeFrameFn = module.cwrap('encode_frame', 'number', ['number', 'number']) as unknown as typeof encodeFrameFn;
 		flushEncoderFn = module.cwrap('flush_encoder', null, ['number']);
 		getEncodedData = module.cwrap('get_encoded_data', 'number', ['number']);
-		getEncodedPts = module.cwrap('get_encoded_pts', 'number', ['number']);
+		getEncodedPts = module.cwrap('get_encoded_pts', 'number', ['number']) as unknown as typeof getEncodedPts;
 		getEncodedDuration = module.cwrap('get_encoded_duration', 'number', ['number']);
 		closeEncoderFn = module.cwrap('close_encoder', null, ['number']);
 	}
@@ -108,7 +108,7 @@ const decode = (ctx: number, encodedData: ArrayBuffer, timestamp: number) => {
 
 	module.HEAPU8.set(bytes, dataPtr);
 
-	const ret = decodePacket(ctx, timestamp);
+	const ret = decodePacket(ctx, BigInt(timestamp));
 	if (ret < 0) {
 		throw new Error(`Decode failed with error code ${ret}.`);
 	}
@@ -122,7 +122,7 @@ const decode = (ctx: number, encodedData: ArrayBuffer, timestamp: number) => {
 	const channels = getDecodedChannels(ctx);
 	const sampleRate = getDecodedSampleRate(ctx);
 	const sampleCount = getDecodedSampleCount(ctx);
-	const pts = getDecodedPts(ctx);
+	const pts = Number(getDecodedPts(ctx));
 
 	let pcmData: ArrayBuffer;
 	if (info.planar) {
@@ -169,14 +169,14 @@ const encode = (ctx: number, audioData: ArrayBuffer, timestamp: number) => {
 	}
 	module.HEAPU8.set(audioBytes, inputPtr);
 
-	const bytesWritten = encodeFrameFn(ctx, timestamp);
+	const bytesWritten = encodeFrameFn(ctx, BigInt(timestamp));
 	if (bytesWritten < 0) {
 		throw new Error(`Encode failed with error code ${bytesWritten}.`);
 	}
 
 	const ptr = getEncodedData(ctx);
 	const encodedData = module.HEAPU8.slice(ptr, ptr + bytesWritten).buffer;
-	const pts = getEncodedPts(ctx);
+	const pts = Number(getEncodedPts(ctx));
 	const duration = getEncodedDuration(ctx);
 
 	return { encodedData, pts, duration };
diff --git a/test/node/aac-encoder-extension.test.ts b/test/node/aac-encoder-extension.test.ts
index c569356..5f29a34 100644
--- a/test/node/aac-encoder-extension.test.ts
+++ b/test/node/aac-encoder-extension.test.ts
@@ -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);
+});
diff --git a/test/node/ac3.test.ts b/test/node/ac3.test.ts
index f3fd262..bafea2c 100644
--- a/test/node/ac3.test.ts
+++ b/test/node/ac3.test.ts
@@ -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);
+});
diff --git a/test/node/flac-encoder-extension.test.ts b/test/node/flac-encoder-extension.test.ts
index 2c785dd..eecf8d9 100644
--- a/test/node/flac-encoder-extension.test.ts
+++ b/test/node/flac-encoder-extension.test.ts
@@ -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);
+});
diff --git a/test/node/mp3-encoder-extension.test.ts b/test/node/mp3-encoder-extension.test.ts
index e1b6c0b..15848d7 100644
--- a/test/node/mp3-encoder-extension.test.ts
+++ b/test/node/mp3-encoder-extension.test.ts
@@ -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);
+});