@remotion/media 4.0.511 → 4.0.513

package/dist/audio-extraction/extract-audio.d.ts

@@ -1,6 +1,6 @@
 import { type LogLevel } from 'remotion';
 import type { MediaCache } from '../caches';
-import type { PcmS16AudioData } from '../convert-audiodata/convert-audiodata';
+import { type PcmS16AudioData } from '../convert-audiodata/convert-audiodata';
 import type { MediaRequestInit } from '../request-init';
 type ExtractAudioParams = {
     src: string;

package/dist/convert-audiodata/combine-audiodata.d.ts

@@ -1,2 +1,2 @@
-import { type PcmS16AudioData } from './convert-audiodata';
-export declare const combineAudioDataAndClosePrevious: (audioDataArray: PcmS16AudioData[]) => PcmS16AudioData;
+import { type UnresampledPcmS16AudioData } from './convert-audiodata';
+export declare const combineAudioDataAndClosePrevious: (audioDataArray: UnresampledPcmS16AudioData[]) => UnresampledPcmS16AudioData;

package/dist/convert-audiodata/convert-audiodata.d.ts

@@ -12,5 +12,15 @@ export type PcmS16AudioData = {
     timestamp: number;
     durationInMicroSeconds: number;
 };
+export type UnresampledPcmS16AudioData = PcmS16AudioData & {
+    numberOfChannels: number;
+    sampleRate: number;
+};
 export declare const fixFloatingPoint: (value: number) => number;
-export declare const convertAudioData: ({ audioData, trimStartInSeconds, trimEndInSeconds, playbackRate, audioDataTimestamp, isLast, }: ConvertAudioDataOptions) => PcmS16AudioData;
+export declare const convertAudioDataToS16: ({ audioData, trimStartInSeconds, trimEndInSeconds, audioDataTimestamp, isLast, }: Omit<ConvertAudioDataOptions, "playbackRate">) => UnresampledPcmS16AudioData;
+export declare const resamplePcmS16AudioData: ({ audioData, playbackRate, isLast, }: {
+    audioData: UnresampledPcmS16AudioData;
+    playbackRate: number;
+    isLast: boolean;
+}) => PcmS16AudioData;
+export declare const convertAudioData: (options: ConvertAudioDataOptions) => PcmS16AudioData;

package/dist/esm/index.mjs

@@ -2146,9 +2146,11 @@ class MediaPlayer {
   }
   setIsPremounting(isPremounting) {
     this.premountAwareDelayPlayback.setIsPremounting(isPremounting);
+    processNext();
   }
   setIsPostmounting(isPostmounting) {
     this.premountAwareDelayPlayback.setIsPostmounting(isPostmounting);
+    processNext();
   }
   async setLoop(loop, unloopedTimeInSeconds) {
     const previousLoop = this.loop;
@@ -4196,11 +4198,10 @@ var ceilButNotIfFloatingPointIssue = (value) => {
   const fixed = fixFloatingPoint2(value);
   return Math.ceil(fixed);
 };
-var convertAudioData = ({
+var convertAudioDataToS16 = ({
   audioData,
   trimStartInSeconds,
   trimEndInSeconds,
-  playbackRate,
   audioDataTimestamp,
   isLast
 }) => {
@@ -4209,14 +4210,9 @@ var convertAudioData = ({
     sampleRate: currentSampleRate,
     numberOfFrames
   } = audioData;
-  const ratio = currentSampleRate / getTargetSampleRate();
   const frameOffset = Math.floor(fixFloatingPoint2(trimStartInSeconds * audioData.sampleRate));
   const unroundedFrameCount = numberOfFrames - trimEndInSeconds * audioData.sampleRate - frameOffset;
   const frameCount = isLast ? ceilButNotIfFloatingPointIssue(unroundedFrameCount) : Math.round(unroundedFrameCount);
-  const newNumberOfFrames = isLast ? ceilButNotIfFloatingPointIssue(unroundedFrameCount / ratio / playbackRate) : Math.round(unroundedFrameCount / ratio / playbackRate);
-  if (newNumberOfFrames === 0) {
-    throw new Error("Cannot resample - the given sample rate would result in less than 1 sample");
-  }
   const srcChannels = new Int16Array(srcNumberOfChannels * frameCount);
   const isF32 = audioData.format === "f32" || audioData.format === "f32-planar";
   if (isF32) {
@@ -4248,20 +4244,39 @@ var convertAudioData = ({
       frameCount
     });
   }
-  const data = new Int16Array(newNumberOfFrames * TARGET_NUMBER_OF_CHANNELS);
-  const chunkSize = frameCount / newNumberOfFrames;
   const timestampOffsetMicroseconds = frameOffset / audioData.sampleRate * 1e6;
-  if (newNumberOfFrames === frameCount && TARGET_NUMBER_OF_CHANNELS === srcNumberOfChannels && playbackRate === 1) {
+  return {
+    data: srcChannels,
+    numberOfChannels: srcNumberOfChannels,
+    numberOfFrames: frameCount,
+    sampleRate: currentSampleRate,
+    timestamp: audioDataTimestamp * 1e6 + fixFloatingPoint2(timestampOffsetMicroseconds),
+    durationInMicroSeconds: fixFloatingPoint2(frameCount / currentSampleRate * 1e6)
+  };
+};
+var resamplePcmS16AudioData = ({
+  audioData,
+  playbackRate,
+  isLast
+}) => {
+  const ratio = audioData.sampleRate / getTargetSampleRate();
+  const newNumberOfFrames = isLast ? ceilButNotIfFloatingPointIssue(audioData.numberOfFrames / ratio / playbackRate) : Math.round(audioData.numberOfFrames / ratio / playbackRate);
+  if (newNumberOfFrames === 0) {
+    throw new Error("Cannot resample - the given sample rate would result in less than 1 sample");
+  }
+  if (newNumberOfFrames === audioData.numberOfFrames && TARGET_NUMBER_OF_CHANNELS === audioData.numberOfChannels && playbackRate === 1) {
     return {
-      data: srcChannels,
+      data: audioData.data,
       numberOfFrames: newNumberOfFrames,
-      timestamp: audioDataTimestamp * 1e6 + fixFloatingPoint2(timestampOffsetMicroseconds),
+      timestamp: audioData.timestamp,
       durationInMicroSeconds: fixFloatingPoint2(newNumberOfFrames / getTargetSampleRate() * 1e6)
     };
   }
+  const data = new Int16Array(newNumberOfFrames * TARGET_NUMBER_OF_CHANNELS);
+  const chunkSize = audioData.numberOfFrames / newNumberOfFrames;
   resampleAudioData({
-    srcNumberOfChannels,
-    sourceChannels: srcChannels,
+    srcNumberOfChannels: audioData.numberOfChannels,
+    sourceChannels: audioData.data,
     destination: data,
     targetFrames: newNumberOfFrames,
     chunkSize
@@ -4269,7 +4284,7 @@ var convertAudioData = ({
   const newAudioData = {
     data,
     numberOfFrames: newNumberOfFrames,
-    timestamp: audioDataTimestamp * 1e6 + fixFloatingPoint2(timestampOffsetMicroseconds),
+    timestamp: audioData.timestamp,
     durationInMicroSeconds: fixFloatingPoint2(newNumberOfFrames / getTargetSampleRate() * 1e6)
   };
   return newAudioData;
@@ -4279,12 +4294,15 @@ var convertAudioData = ({
 var combineAudioDataAndClosePrevious = (audioDataArray) => {
   let numberOfFrames = 0;
   let durationInMicroSeconds = 0;
-  const { timestamp } = audioDataArray[0];
+  const { numberOfChannels, sampleRate, timestamp } = audioDataArray[0];
   for (const audioData of audioDataArray) {
+    if (audioData.numberOfChannels !== numberOfChannels || audioData.sampleRate !== sampleRate) {
+      throw new Error("Cannot combine audio data with different formats");
+    }
     numberOfFrames += audioData.numberOfFrames;
     durationInMicroSeconds += audioData.durationInMicroSeconds;
   }
-  const arr = new Int16Array(numberOfFrames * TARGET_NUMBER_OF_CHANNELS);
+  const arr = new Int16Array(numberOfFrames * numberOfChannels);
   let offset = 0;
   for (const audioData of audioDataArray) {
     arr.set(audioData.data, offset);
@@ -4292,7 +4310,9 @@ var combineAudioDataAndClosePrevious = (audioDataArray) => {
   }
   return {
     data: arr,
+    numberOfChannels,
     numberOfFrames,
+    sampleRate,
     timestamp: fixFloatingPoint2(timestamp),
     durationInMicroSeconds: fixFloatingPoint2(durationInMicroSeconds)
   };
@@ -4378,12 +4398,14 @@ var extractAudioInternal = async ({
       if (isFirstSample) {
         trimStartInSeconds = fixFloatingPoint2(timeInSeconds - sample.timestamp);
         if (trimStartInSeconds < 0) {
-          const silenceFrames = Math.ceil(fixFloatingPoint2(-trimStartInSeconds * getTargetSampleRate()));
+          const silenceFrames = Math.ceil(fixFloatingPoint2(-trimStartInSeconds * audioDataRaw.sampleRate));
           leadingSilence = {
-            data: new Int16Array(silenceFrames * TARGET_NUMBER_OF_CHANNELS),
+            data: new Int16Array(silenceFrames * audioDataRaw.numberOfChannels),
+            numberOfChannels: audioDataRaw.numberOfChannels,
             numberOfFrames: silenceFrames,
+            sampleRate: audioDataRaw.sampleRate,
             timestamp: timeInSeconds * 1e6,
-            durationInMicroSeconds: silenceFrames / getTargetSampleRate() * 1e6
+            durationInMicroSeconds: silenceFrames / audioDataRaw.sampleRate * 1e6
           };
           trimStartInSeconds = 0;
         }
@@ -4391,11 +4413,10 @@ var extractAudioInternal = async ({
       if (isLastSample) {
         trimEndInSeconds = Math.max(0, sample.timestamp + sample.duration - (timeInSeconds + durationInSeconds));
       }
-      const audioData = convertAudioData({
+      const audioData = convertAudioDataToS16({
         audioData: audioDataRaw,
         trimStartInSeconds,
         trimEndInSeconds,
-        playbackRate,
         audioDataTimestamp: sample.timestamp,
         isLast: isLastSample
       });
@@ -4412,7 +4433,12 @@ var extractAudioInternal = async ({
       return { data: null, durationInSeconds: mediaDurationInSeconds };
     }
     const combined = combineAudioDataAndClosePrevious(audioDataArray);
-    return { data: combined, durationInSeconds: mediaDurationInSeconds };
+    const resampled = resamplePcmS16AudioData({
+      audioData: combined,
+      playbackRate,
+      isLast: true
+    });
+    return { data: resampled, durationInSeconds: mediaDurationInSeconds };
   } catch (err) {
     const error = err;
     if (isNetworkError(error)) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@remotion/media",
-	"version": "4.0.511",
+	"version": "4.0.513",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"module": "dist/esm/index.mjs",
@@ -23,7 +23,7 @@
 	},
 	"dependencies": {
 		"mediabunny": "1.50.8",
-		"remotion": "4.0.511",
+		"remotion": "4.0.513",
 		"zod": "4.4.3"
 	},
 	"peerDependencies": {
@@ -31,8 +31,8 @@
 		"react-dom": ">=16.8.0"
 	},
 	"devDependencies": {
-		"@remotion/eslint-config-internal": "4.0.511",
-		"@remotion/player": "4.0.511",
+		"@remotion/eslint-config-internal": "4.0.513",
+		"@remotion/player": "4.0.513",
 		"@vitest/browser-webdriverio": "4.0.9",
 		"eslint": "9.19.0",
 		"react": "19.2.3",