@remotion/webcodecs 4.0.287 → 4.0.288

package/dist/audio-data/data-types.d.ts

@@ -0,0 +1 @@
+export declare const getDataTypeForAudioFormat: (format: AudioSampleFormat) => Uint8ArrayConstructor | Float32ArrayConstructor | Int16ArrayConstructor | Int32ArrayConstructor;

package/dist/audio-data/data-types.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDataTypeForAudioFormat = void 0;
+const getDataTypeForAudioFormat = (format) => {
+    switch (format) {
+        case 'f32':
+            return Float32Array;
+        case 'f32-planar':
+            return Float32Array;
+        case 's16':
+            return Int16Array;
+        case 's16-planar':
+            return Int16Array;
+        case 'u8':
+            return Uint8Array;
+        case 'u8-planar':
+            return Uint8Array;
+        case 's32':
+            return Int32Array;
+        case 's32-planar':
+            return Int32Array;
+        default:
+            throw new Error(`Unsupported audio format: ${format}`);
+    }
+};
+exports.getDataTypeForAudioFormat = getDataTypeForAudioFormat;

package/dist/audio-data/is-planar-format.d.ts

@@ -0,0 +1 @@
+export declare const isPlanarFormat: (format: AudioSampleFormat) => boolean;

package/dist/audio-data/is-planar-format.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPlanarFormat = void 0;
+const isPlanarFormat = (format) => {
+    return format.includes('-planar');
+};
+exports.isPlanarFormat = isPlanarFormat;

package/dist/audio-encoder.js

@@ -9,7 +9,11 @@ const createAudioEncoder = ({ onChunk, onError, codec, controller, config: audio
         throw new media_parser_1.MediaParserAbortError('Not creating audio encoder, already aborted');
     }
     if (codec === 'wav') {
-        return (0, wav_audio_encoder_1.getWaveAudioEncoder)({ onChunk, controller });
+        return (0, wav_audio_encoder_1.getWaveAudioEncoder)({
+            onChunk,
+            controller,
+            config: audioEncoderConfig,
+        });
     }
     const ioSynchronizer = (0, io_synchronizer_1.makeIoSynchronizer)({
         logLevel,

package/dist/can-reencode-audio-track.d.ts

@@ -1,7 +1,8 @@
 import type { AudioTrack } from '@remotion/media-parser';
 import type { ConvertMediaAudioCodec } from './get-available-audio-codecs';
-export declare const canReencodeAudioTrack: ({ track, audioCodec, bitrate, }: {
+export declare const canReencodeAudioTrack: ({ track, audioCodec, bitrate, sampleRate, }: {
     track: AudioTrack;
     audioCodec: ConvertMediaAudioCodec;
     bitrate: number;
+    sampleRate: number | null;
 }) => Promise<boolean>;

package/dist/can-reencode-audio-track.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.canReencodeAudioTrack = void 0;
 const audio_decoder_config_1 = require("./audio-decoder-config");
 const audio_encoder_config_1 = require("./audio-encoder-config");
-const canReencodeAudioTrack = async ({ track, audioCodec, bitrate, }) => {
+const canReencodeAudioTrack = async ({ track, audioCodec, bitrate, sampleRate, }) => {
     const audioDecoderConfig = await (0, audio_decoder_config_1.getAudioDecoderConfig)(track);
     if (audioCodec === 'wav' && audioDecoderConfig) {
         return true;
@@ -11,7 +11,7 @@ const canReencodeAudioTrack = async ({ track, audioCodec, bitrate, }) => {
     const audioEncoderConfig = await (0, audio_encoder_config_1.getAudioEncoderConfig)({
         codec: audioCodec,
         numberOfChannels: track.numberOfChannels,
-        sampleRate: track.sampleRate,
+        sampleRate: sampleRate ?? track.sampleRate,
         bitrate,
     });
     return Boolean(audioDecoderConfig && audioEncoderConfig);

package/dist/convert-audiodata.d.ts

@@ -0,0 +1,10 @@
+export type ConvertAudioDataOptions = {
+    audioData: AudioData;
+    newSampleRate?: number;
+    format?: AudioSampleFormat | null;
+};
+/**
+ * Converts an `AudioData` object to a new `AudioData` object with a different sample rate or format.
+ * @see [Documentation](https://remotion.dev/docs/webcodecs/convert-audiodata)
+ */
+export declare const convertAudioData: ({ audioData, newSampleRate, format, }: ConvertAudioDataOptions) => AudioData;

package/dist/convert-audiodata.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertAudioData = void 0;
+const data_types_1 = require("./audio-data/data-types");
+const is_planar_format_1 = require("./audio-data/is-planar-format");
+const validateRange = (format, value) => {
+    if (format === 'f32' || format === 'f32-planar') {
+        if (value < -1 || value > 1) {
+            throw new Error('All values in a Float32 array must be between -1 and 1');
+        }
+    }
+};
+/**
+ * Converts an `AudioData` object to a new `AudioData` object with a different sample rate or format.
+ * @see [Documentation](https://remotion.dev/docs/webcodecs/convert-audiodata)
+ */
+const convertAudioData = ({ audioData, newSampleRate = audioData.sampleRate, format = audioData.format, }) => {
+    const { numberOfChannels, sampleRate: currentSampleRate, numberOfFrames: currentNumberOfFrames, } = audioData;
+    const ratio = currentSampleRate / newSampleRate;
+    const newNumberOfFrames = Math.floor(currentNumberOfFrames / ratio);
+    if (newNumberOfFrames === 0) {
+        throw new Error('Cannot resample - the given sample rate would result in less than 1 sample');
+    }
+    if (newSampleRate < 3000 || newSampleRate > 768000) {
+        throw new Error('newSampleRate must be between 3000 and 768000');
+    }
+    if (!format) {
+        throw new Error('AudioData format is not set');
+    }
+    if (format === audioData.format &&
+        newNumberOfFrames === currentNumberOfFrames) {
+        return audioData.clone();
+    }
+    const DataType = (0, data_types_1.getDataTypeForAudioFormat)(format);
+    const isPlanar = (0, is_planar_format_1.isPlanarFormat)(format);
+    const planes = isPlanar ? numberOfChannels : 1;
+    const srcChannels = new Array(planes)
+        .fill(true)
+        .map(() => new DataType((isPlanar ? 1 : numberOfChannels) * currentNumberOfFrames));
+    for (let i = 0; i < planes; i++) {
+        audioData.clone().copyTo(srcChannels[i], {
+            planeIndex: i,
+            format,
+        });
+    }
+    const data = new DataType(newNumberOfFrames * numberOfChannels);
+    const chunkSize = currentNumberOfFrames / newNumberOfFrames;
+    for (let newFrameIndex = 0; newFrameIndex < newNumberOfFrames; newFrameIndex++) {
+        const start = Math.floor(newFrameIndex * chunkSize);
+        const end = Math.max(Math.floor(start + chunkSize), start + 1);
+        if (isPlanar) {
+            for (let channelIndex = 0; channelIndex < numberOfChannels; channelIndex++) {
+                const chunk = srcChannels[channelIndex].slice(start, end);
+                const average = chunk.reduce((a, b) => {
+                    return a + b;
+                }, 0) / chunk.length;
+                validateRange(format, average);
+                data[newFrameIndex + channelIndex * newNumberOfFrames] = average;
+            }
+        }
+        else {
+            const sampleCountAvg = end - start;
+            for (let channelIndex = 0; channelIndex < numberOfChannels; channelIndex++) {
+                const items = [];
+                for (let k = 0; k < sampleCountAvg; k++) {
+                    const num = srcChannels[0][(start + k) * numberOfChannels + channelIndex];
+                    items.push(num);
+                }
+                const average = items.reduce((a, b) => a + b, 0) / items.length;
+                validateRange(format, average);
+                data[newFrameIndex * numberOfChannels + channelIndex] = average;
+            }
+        }
+    }
+    const newAudioData = new AudioData({
+        data,
+        format,
+        numberOfChannels,
+        numberOfFrames: newNumberOfFrames,
+        sampleRate: newSampleRate,
+        timestamp: audioData.timestamp,
+    });
+    return newAudioData;
+};
+exports.convertAudioData = convertAudioData;

package/dist/create/iso-base-media/codec-specific/create-codec-specific-data.js

@@ -10,6 +10,10 @@ const mp4a_1 = require("./mp4a");
 const createCodecSpecificData = (track) => {
     if (track.type === 'video') {
         if (track.codec === 'h264') {
+            // May not have it initially
+            if (!track.codecPrivate) {
+                return new Uint8Array([]);
+            }
             return (0, avc1_1.createAvc1Data)({
                 avccBox: (0, create_avcc_1.createAvccBox)(track.codecPrivate),
                 compressorName: 'WebCodecs',
@@ -23,6 +27,10 @@ const createCodecSpecificData = (track) => {
             });
         }
         if (track.codec === 'h265') {
+            // May not have it initially
+            if (!track.codecPrivate) {
+                return new Uint8Array([]);
+            }
             return (0, hvc1_1.createHvc1Data)({
                 hvccBox: (0, create_hvcc_1.createHvccBox)(track.codecPrivate),
                 compressorName: 'WebCodecs',

package/dist/create/iso-base-media/create-iso-base-media.js

@@ -127,6 +127,8 @@ const createIsoBaseMedia = async ({ writer, onBytesProgress, onMillisecondsProgr
             dts: Math.round((chunk.dts / 1000000) * currentTrack.timescale),
             duration: Math.round(((chunk.duration ?? 0) / 1000000) * currentTrack.timescale),
             size: chunk.data.length,
+            bigEndian: false,
+            chunkSize: null,
         };
         lastChunkWasVideo = isVideo;
         samplePositions[trackNumber].push(samplePositionToAdd);