@remotion/renderer 4.0.0-oops.3 → 4.0.0-prefetch.10

package/dist/assets/calculate-asset-positions.d.ts

@@ -1,3 +1,3 @@
-import { TAsset } from 'remotion';
-import { Assets } from './types';
+import type { TAsset } from 'remotion';
+import type { Assets } from './types';
 export declare const calculateAssetPositions: (frames: TAsset[][]) => Assets;

package/dist/assets/convert-assets-to-file-urls.d.ts

@@ -1,7 +1,8 @@
-import { TAsset } from 'remotion';
-import { RenderMediaOnDownload } from './download-and-map-assets-to-file';
-export declare const convertAssetsToFileUrls: ({ assets, downloadDir, onDownload, }: {
+import type { TAsset } from 'remotion';
+import type { RenderMediaOnDownload } from './download-and-map-assets-to-file';
+import type { DownloadMap } from './download-map';
+export declare const convertAssetsToFileUrls: ({ assets, onDownload, downloadMap, }: {
     assets: TAsset[][];
-    downloadDir: string;
     onDownload: RenderMediaOnDownload;
+    downloadMap: DownloadMap;
 }) => Promise<TAsset[][]>;

package/dist/assets/convert-assets-to-file-urls.js

@@ -9,7 +9,7 @@ const chunk = (input, size) => {
             : [...arr.slice(0, -1), [...arr.slice(-1)[0], item]];
     }, []);
 };
-const convertAssetsToFileUrls = async ({ assets, downloadDir, onDownload, }) => {
+const convertAssetsToFileUrls = async ({ assets, onDownload, downloadMap, }) => {
     const chunks = chunk(assets, 1000);
     const results = [];
     for (const ch of chunks) {
@@ -17,8 +17,8 @@ const convertAssetsToFileUrls = async ({ assets, downloadDir, onDownload, }) =>
             return Promise.all(assetsForFrame.map((a) => {
                 return (0, download_and_map_assets_to_file_1.downloadAndMapAssetsToFileUrl)({
                     asset: a,
-                    downloadDir,
                     onDownload,
+                    downloadMap,
                 });
             }));
         }));

package/dist/assets/download-and-map-assets-to-file.d.ts

@@ -1,14 +1,24 @@
-import { TAsset } from 'remotion';
+import type { TAsset } from 'remotion';
+import type { DownloadMap } from './download-map';
 export declare type RenderMediaOnDownload = (src: string) => ((progress: {
-    percent: number;
+    percent: number | null;
+    downloaded: number;
+    totalSize: number | null;
 }) => void) | undefined | void;
-export declare const markAllAssetsAsDownloaded: () => void;
-export declare const getSanitizedFilenameForAssetUrl: ({ src, downloadDir, }: {
+export declare const downloadAsset: ({ src, onDownload, downloadMap, }: {
+    src: string;
+    onDownload: RenderMediaOnDownload;
+    downloadMap: DownloadMap;
+}) => Promise<string>;
+export declare const markAllAssetsAsDownloaded: (downloadMap: DownloadMap) => void;
+export declare const getSanitizedFilenameForAssetUrl: ({ src, downloadDir, contentDisposition, contentType, }: {
     src: string;
     downloadDir: string;
+    contentDisposition: string | null;
+    contentType: string | null;
 }) => string;
-export declare const downloadAndMapAssetsToFileUrl: ({ asset, downloadDir, onDownload, }: {
+export declare const downloadAndMapAssetsToFileUrl: ({ asset, onDownload, downloadMap, }: {
     asset: TAsset;
-    downloadDir: string;
     onDownload: RenderMediaOnDownload;
+    downloadMap: DownloadMap;
 }) => Promise<TAsset>;

package/dist/assets/download-and-map-assets-to-file.js

@@ -1,33 +1,77 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.downloadAndMapAssetsToFileUrl = exports.getSanitizedFilenameForAssetUrl = exports.markAllAssetsAsDownloaded = void 0;
+exports.downloadAndMapAssetsToFileUrl = exports.getSanitizedFilenameForAssetUrl = exports.markAllAssetsAsDownloaded = exports.downloadAsset = void 0;
 const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
+const path_1 = __importStar(require("path"));
 const remotion_1 = require("remotion");
+const compress_assets_1 = require("../compress-assets");
 const ensure_output_directory_1 = require("../ensure-output-directory");
+const mime_types_1 = require("../mime-types");
 const download_file_1 = require("./download-file");
 const sanitize_filepath_1 = require("./sanitize-filepath");
-const isDownloadingMap = {};
-const hasBeenDownloadedMap = {};
-const listeners = {};
-const waitForAssetToBeDownloaded = (src) => {
-    if (!listeners[src]) {
-        listeners[src] = [];
+const waitForAssetToBeDownloaded = ({ src, downloadDir, downloadMap, }) => {
+    var _a, _b;
+    if ((_a = downloadMap.hasBeenDownloadedMap[src]) === null || _a === void 0 ? void 0 : _a[downloadDir]) {
+        return Promise.resolve((_b = downloadMap.hasBeenDownloadedMap[src]) === null || _b === void 0 ? void 0 : _b[downloadDir]);
+    }
+    if (!downloadMap.listeners[src]) {
+        downloadMap.listeners[src] = {};
+    }
+    if (!downloadMap.listeners[src][downloadDir]) {
+        downloadMap.listeners[src][downloadDir] = [];
     }
     return new Promise((resolve) => {
-        listeners[src].push(() => resolve());
+        downloadMap.listeners[src][downloadDir].push(() => {
+            const srcMap = downloadMap.hasBeenDownloadedMap[src];
+            if (!srcMap || !srcMap[downloadDir]) {
+                throw new Error('Expected file for ' + src + 'to be available in ' + downloadDir);
+            }
+            resolve(srcMap[downloadDir]);
+        });
     });
 };
-const notifyAssetIsDownloaded = (src) => {
-    if (!listeners[src]) {
-        listeners[src] = [];
+const notifyAssetIsDownloaded = ({ src, downloadDir, to, downloadMap, }) => {
+    if (!downloadMap.listeners[src]) {
+        downloadMap.listeners[src] = {};
+    }
+    if (!downloadMap.listeners[src][downloadDir]) {
+        downloadMap.listeners[src][downloadDir] = [];
     }
-    listeners[src].forEach((fn) => fn());
-    isDownloadingMap[src] = false;
-    hasBeenDownloadedMap[src] = true;
+    if (!downloadMap.isDownloadingMap[src]) {
+        downloadMap.isDownloadingMap[src] = {};
+    }
+    downloadMap.isDownloadingMap[src][downloadDir] = false;
+    if (!downloadMap.hasBeenDownloadedMap[src]) {
+        downloadMap.hasBeenDownloadedMap[src] = {};
+    }
+    downloadMap.hasBeenDownloadedMap[src][downloadDir] = to;
+    downloadMap.listeners[src][downloadDir].forEach((fn) => fn());
 };
 const validateMimeType = (mimeType, src) => {
     if (!mimeType.includes('/')) {
@@ -68,17 +112,42 @@ function validateBufferEncoding(potentialEncoding, dataUrl) {
         throw new TypeError(errMessage);
     }
 }
-const downloadAsset = async (src, to, onDownload) => {
-    if (hasBeenDownloadedMap[src]) {
-        return;
+const downloadAsset = async ({ src, onDownload, downloadMap, }) => {
+    var _a, _b, _c;
+    if ((0, compress_assets_1.isAssetCompressed)(src)) {
+        return src;
+    }
+    const { downloadDir } = downloadMap;
+    if ((_a = downloadMap.hasBeenDownloadedMap[src]) === null || _a === void 0 ? void 0 : _a[downloadDir]) {
+        const claimedDownloadLocation = (_b = downloadMap.hasBeenDownloadedMap[src]) === null || _b === void 0 ? void 0 : _b[downloadDir];
+        // The OS might have deleted the file since even though we marked it as downloaded. In that case we reset the state and download it again
+        if (fs_1.default.existsSync(claimedDownloadLocation)) {
+            return claimedDownloadLocation;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        downloadMap.hasBeenDownloadedMap[src][downloadDir] = null;
+        if (!downloadMap.isDownloadingMap[src]) {
+            downloadMap.isDownloadingMap[src] = {};
+        }
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        downloadMap.isDownloadingMap[src][downloadDir] = false;
     }
-    if (isDownloadingMap[src]) {
-        return waitForAssetToBeDownloaded(src);
+    if ((_c = downloadMap.isDownloadingMap[src]) === null || _c === void 0 ? void 0 : _c[downloadDir]) {
+        return waitForAssetToBeDownloaded({ downloadMap, src, downloadDir });
     }
-    isDownloadingMap[src] = true;
+    if (!downloadMap.isDownloadingMap[src]) {
+        downloadMap.isDownloadingMap[src] = {};
+    }
+    downloadMap.isDownloadingMap[src][downloadDir] = true;
     const onProgress = onDownload(src);
-    (0, ensure_output_directory_1.ensureOutputDirectory)(to);
     if (src.startsWith('data:')) {
+        const output = (0, exports.getSanitizedFilenameForAssetUrl)({
+            contentDisposition: null,
+            downloadDir,
+            src,
+            contentType: null,
+        });
+        (0, ensure_output_directory_1.ensureOutputDirectory)(output);
         const [assetDetails, assetData] = src.substring('data:'.length).split(',');
         if (!assetDetails.includes(';')) {
             const errMessage = [
@@ -93,47 +162,85 @@ const downloadAsset = async (src, to, onDownload) => {
         validateMimeType(mimeType, src);
         validateBufferEncoding(encoding, src);
         const buff = Buffer.from(assetData, encoding);
-        await fs_1.default.promises.writeFile(to, buff);
-        notifyAssetIsDownloaded(src);
-        return;
+        await fs_1.default.promises.writeFile(output, buff);
+        notifyAssetIsDownloaded({ src, downloadMap, downloadDir, to: output });
+        return output;
     }
-    await (0, download_file_1.downloadFile)(src, to, ({ progress }) => {
-        onProgress === null || onProgress === void 0 ? void 0 : onProgress({
-            percent: progress,
-        });
+    const { to } = await (0, download_file_1.downloadFile)({
+        url: src,
+        onProgress: (progress) => {
+            onProgress === null || onProgress === void 0 ? void 0 : onProgress(progress);
+        },
+        to: (contentDisposition, contentType) => (0, exports.getSanitizedFilenameForAssetUrl)({
+            contentDisposition,
+            downloadDir,
+            src,
+            contentType,
+        }),
     });
-    notifyAssetIsDownloaded(src);
+    notifyAssetIsDownloaded({ src, downloadMap, downloadDir, to });
+    return to;
 };
-const markAllAssetsAsDownloaded = () => {
-    Object.keys(hasBeenDownloadedMap).forEach((key) => {
-        delete hasBeenDownloadedMap[key];
+exports.downloadAsset = downloadAsset;
+const markAllAssetsAsDownloaded = (downloadMap) => {
+    Object.keys(downloadMap.hasBeenDownloadedMap).forEach((key) => {
+        delete downloadMap.hasBeenDownloadedMap[key];
     });
-    Object.keys(isDownloadingMap).forEach((key) => {
-        delete isDownloadingMap[key];
+    Object.keys(downloadMap.isDownloadingMap).forEach((key) => {
+        delete downloadMap.isDownloadingMap[key];
     });
 };
 exports.markAllAssetsAsDownloaded = markAllAssetsAsDownloaded;
-const getSanitizedFilenameForAssetUrl = ({ src, downloadDir, }) => {
-    if (remotion_1.Internals.AssetCompression.isAssetCompressed(src)) {
-        return src;
+const getFilename = ({ contentDisposition, src, contentType, }) => {
+    const filenameProbe = 'filename=';
+    if (contentDisposition === null || contentDisposition === void 0 ? void 0 : contentDisposition.includes(filenameProbe)) {
+        const start = contentDisposition.indexOf(filenameProbe);
+        const onlyFromFileName = contentDisposition.substring(start + filenameProbe.length);
+        const hasSemi = onlyFromFileName.indexOf(';');
+        if (hasSemi === -1) {
+            return { pathname: onlyFromFileName.trim(), search: '' };
+        }
+        return {
+            search: '',
+            pathname: onlyFromFileName.substring(0, hasSemi).trim(),
+        };
     }
     const { pathname, search } = new URL(src);
+    const ext = (0, path_1.extname)(pathname);
+    // Has no file extension, check if we can derive it from contentType
+    if (!ext && contentType) {
+        const matchedExt = (0, mime_types_1.getExt)(contentType);
+        return {
+            pathname: `${pathname}.${matchedExt}`,
+            search,
+        };
+    }
+    return { pathname, search };
+};
+const getSanitizedFilenameForAssetUrl = ({ src, downloadDir, contentDisposition, contentType, }) => {
+    if ((0, compress_assets_1.isAssetCompressed)(src)) {
+        return src;
+    }
+    const { pathname, search } = getFilename({
+        contentDisposition,
+        contentType,
+        src,
+    });
     const split = pathname.split('.');
     const fileExtension = split.length > 1 && split[split.length - 1]
         ? `.${split[split.length - 1]}`
         : '';
     const hashedFileName = String((0, remotion_1.random)(`${pathname}${search}`)).replace('0.', '');
-    return path_1.default.join(downloadDir, (0, sanitize_filepath_1.sanitizeFilePath)(hashedFileName + fileExtension));
+    const filename = hashedFileName + fileExtension;
+    return path_1.default.join(downloadDir, (0, sanitize_filepath_1.sanitizeFilePath)(filename));
 };
 exports.getSanitizedFilenameForAssetUrl = getSanitizedFilenameForAssetUrl;
-const downloadAndMapAssetsToFileUrl = async ({ asset, downloadDir, onDownload, }) => {
-    const newSrc = (0, exports.getSanitizedFilenameForAssetUrl)({
+const downloadAndMapAssetsToFileUrl = async ({ asset, onDownload, downloadMap, }) => {
+    const newSrc = await (0, exports.downloadAsset)({
         src: asset.src,
-        downloadDir,
+        onDownload,
+        downloadMap,
     });
-    if (!remotion_1.Internals.AssetCompression.isAssetCompressed(newSrc)) {
-        await downloadAsset(asset.src, newSrc, onDownload);
-    }
     return {
         ...asset,
         src: newSrc,

package/dist/assets/download-file.d.ts

@@ -1,7 +1,12 @@
-export declare const downloadFile: (url: string, to: string, onProgress: ((progress: {
-    progress: number;
-    downloaded: number;
-    totalSize: number;
-}) => void) | undefined) => Promise<{
+export declare const downloadFile: ({ onProgress, url, to: toFn, }: {
+    url: string;
+    to: (contentDisposition: string | null, contentType: string | null) => string;
+    onProgress: ((progress: {
+        percent: number | null;
+        downloaded: number;
+        totalSize: number | null;
+    }) => void) | undefined;
+}) => Promise<{
     sizeInBytes: number;
+    to: string;
 }>;

package/dist/assets/download-file.js

@@ -2,25 +2,40 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.downloadFile = void 0;
 const fs_1 = require("fs");
+const ensure_output_directory_1 = require("../ensure-output-directory");
 const read_file_1 = require("./read-file");
-const downloadFile = (url, to, onProgress) => {
+const downloadFile = ({ onProgress, url, to: toFn, }) => {
     return new Promise((resolve, reject) => {
         (0, read_file_1.readFile)(url)
             .then((res) => {
-            const totalSize = Number(res.headers['content-length']);
+            var _a, _b;
+            const contentDisposition = (_a = res.headers['content-disposition']) !== null && _a !== void 0 ? _a : null;
+            const contentType = (_b = res.headers['content-type']) !== null && _b !== void 0 ? _b : null;
+            const to = toFn(contentDisposition, contentType);
+            (0, ensure_output_directory_1.ensureOutputDirectory)(to);
+            const sizeHeader = res.headers['content-length'];
+            const totalSize = typeof sizeHeader === 'undefined' ? null : Number(sizeHeader);
             const writeStream = (0, fs_1.createWriteStream)(to);
+            let downloaded = 0;
             // Listen to 'close' event instead of more
             // concise method to avoid this problem
             // https://github.com/remotion-dev/remotion/issues/384#issuecomment-844398183
-            writeStream.on('close', () => resolve({ sizeInBytes: totalSize }));
+            writeStream.on('close', () => {
+                onProgress === null || onProgress === void 0 ? void 0 : onProgress({
+                    downloaded,
+                    percent: 1,
+                    totalSize: downloaded,
+                });
+                return resolve({ sizeInBytes: downloaded, to });
+            });
             writeStream.on('error', (err) => reject(err));
-            let downloaded = 0;
+            res.on('error', (err) => reject(err));
             res.pipe(writeStream).on('error', (err) => reject(err));
             res.on('data', (d) => {
                 downloaded += d.length;
                 onProgress === null || onProgress === void 0 ? void 0 : onProgress({
                     downloaded,
-                    progress: downloaded / totalSize,
+                    percent: totalSize === null ? null : downloaded / totalSize,
                     totalSize,
                 });
             });

package/dist/assets/download-map.d.ts

@@ -0,0 +1,64 @@
+/// <reference types="node" />
+import type { TAsset } from 'remotion';
+declare type EncodingStatus = {
+    type: 'encoding';
+} | {
+    type: 'done';
+    src: string;
+} | undefined;
+export declare type SpecialVCodecForTransparency = 'vp9' | 'vp8' | 'none';
+export declare type Vp9Result = {
+    specialVcodec: SpecialVCodecForTransparency;
+    needsResize: [number, number] | null;
+};
+export declare type VideoDurationResult = {
+    duration: number | null;
+    fps: number | null;
+};
+export declare type AudioChannelsAndDurationResultCache = {
+    channels: number;
+    duration: number | null;
+};
+export declare type DownloadMap = {
+    id: string;
+    isDownloadingMap: {
+        [src: string]: {
+            [downloadDir: string]: boolean;
+        } | undefined;
+    };
+    hasBeenDownloadedMap: {
+        [src: string]: {
+            [downloadDir: string]: string | null;
+        } | undefined;
+    };
+    listeners: {
+        [key: string]: {
+            [downloadDir: string]: (() => void)[];
+        };
+    };
+    lastFrameMap: Record<string, {
+        lastAccessed: number;
+        data: Buffer;
+    }>;
+    isBeyondLastFrameMap: Record<string, number>;
+    isVp9VideoCache: Record<string, Vp9Result>;
+    ensureFileHasPresentationTimestamp: Record<string, EncodingStatus>;
+    videoDurationResultCache: Record<string, VideoDurationResult>;
+    durationOfAssetCache: Record<string, AudioChannelsAndDurationResultCache>;
+    downloadDir: string;
+    preEncode: string;
+    audioMixing: string;
+    complexFilter: string;
+    audioPreprocessing: string;
+    stitchFrames: string;
+    assetDir: string;
+};
+export declare type RenderAssetInfo = {
+    assets: TAsset[][];
+    imageSequenceName: string;
+    firstFrameIndex: number;
+    downloadMap: DownloadMap;
+};
+export declare const makeDownloadMap: () => DownloadMap;
+export declare const cleanDownloadMap: (downloadMap: DownloadMap) => Promise<void>;
+export {};

package/dist/assets/download-map.js

@@ -0,0 +1,73 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanDownloadMap = exports.makeDownloadMap = void 0;
+const fs_1 = __importStar(require("fs"));
+const path_1 = __importDefault(require("path"));
+const delete_directory_1 = require("../delete-directory");
+const tmp_dir_1 = require("../tmp-dir");
+const makeAndReturn = (dir, name) => {
+    const p = path_1.default.join(dir, name);
+    (0, fs_1.mkdirSync)(p);
+    return p;
+};
+const packageJsonPath = path_1.default.join(__dirname, '..', '..', 'package.json');
+const packageJson = fs_1.default.existsSync(packageJsonPath)
+    ? JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'))
+    : null;
+const makeDownloadMap = () => {
+    const dir = (0, tmp_dir_1.tmpDir)(packageJson
+        ? `remotion-v${packageJson.version.replace(/\./g, '-')}-assets`
+        : 'remotion-assets');
+    return {
+        isDownloadingMap: {},
+        hasBeenDownloadedMap: {},
+        listeners: {},
+        lastFrameMap: {},
+        isBeyondLastFrameMap: {},
+        ensureFileHasPresentationTimestamp: {},
+        isVp9VideoCache: {},
+        videoDurationResultCache: {},
+        durationOfAssetCache: {},
+        id: String(Math.random()),
+        assetDir: dir,
+        downloadDir: makeAndReturn(dir, 'remotion-assets-dir'),
+        complexFilter: makeAndReturn(dir, 'remotion-complex-filter'),
+        preEncode: makeAndReturn(dir, 'pre-encode'),
+        audioMixing: makeAndReturn(dir, 'remotion-audio-mixing'),
+        audioPreprocessing: makeAndReturn(dir, 'remotion-audio-preprocessing'),
+        stitchFrames: makeAndReturn(dir, 'remotion-stitch-temp-dir'),
+    };
+};
+exports.makeDownloadMap = makeDownloadMap;
+const cleanDownloadMap = async (downloadMap) => {
+    await (0, delete_directory_1.deleteDirectory)(downloadMap.downloadDir);
+    await (0, delete_directory_1.deleteDirectory)(downloadMap.complexFilter);
+    await (0, delete_directory_1.deleteDirectory)(downloadMap.assetDir);
+};
+exports.cleanDownloadMap = cleanDownloadMap;

package/dist/assets/ffmpeg-volume-expression.d.ts

@@ -1,12 +1,12 @@
-import { AssetVolume } from './types';
+import type { AssetVolume } from './types';
 declare type FfmpegEval = 'once' | 'frame';
 declare type FfmpegVolumeExpression = {
     eval: FfmpegEval;
     value: string;
 };
-export declare const ffmpegVolumeExpression: ({ volume, startInVideo, fps, }: {
+export declare const ffmpegVolumeExpression: ({ volume, fps, trimLeft, }: {
     volume: AssetVolume;
-    startInVideo: number;
+    trimLeft: number;
     fps: number;
 }) => FfmpegVolumeExpression;
 export {};

package/dist/assets/ffmpeg-volume-expression.js

@@ -12,12 +12,12 @@ const FFMPEG_TIME_VARIABLE = 't';
 const ffmpegIfOrElse = (condition, then, elseDo) => {
     return `if(${condition},${then},${elseDo})`;
 };
-const ffmpegIsOneOfFrames = (frames, fps) => {
+const ffmpegIsOneOfFrames = ({ frames, trimLeft, fps, }) => {
     const consecutiveArrays = [];
     for (let i = 0; i < frames.length; i++) {
         const previousFrame = frames[i - 1];
         const frame = frames[i];
-        if (!previousFrame || frame !== previousFrame + 1) {
+        if (previousFrame === undefined || frame !== previousFrame + 1) {
             consecutiveArrays.push([]);
         }
         consecutiveArrays[consecutiveArrays.length - 1].push(frame);
@@ -28,25 +28,22 @@ const ffmpegIsOneOfFrames = (frames, fps) => {
         const lastFrame = f[f.length - 1];
         const before = (firstFrame - 0.5) / fps;
         const after = (lastFrame + 0.5) / fps;
-        return `between(${FFMPEG_TIME_VARIABLE},${before.toFixed(4)},${after.toFixed(4)})`;
+        return `between(${FFMPEG_TIME_VARIABLE},${(before + trimLeft).toFixed(4)},${(after + trimLeft).toFixed(4)})`;
     })
         .join('+');
 };
-const ffmpegBuildVolumeExpression = (arr, fps) => {
+const ffmpegBuildVolumeExpression = (arr, delay, fps) => {
     if (arr.length === 0) {
         throw new Error('Volume array expression should never have length 0');
     }
     if (arr.length === 1) {
-        // FFMpeg tends to request volume for frames outside the range
-        // where the audio actually plays.
-        // If this is the case, we just return volume 0 to clip it.
-        return ffmpegIfOrElse(ffmpegIsOneOfFrames(arr[0][1], fps), String(arr[0][0]), String(0));
+        return String(arr[0][0]);
     }
     const [first, ...rest] = arr;
     const [volume, frames] = first;
-    return ffmpegIfOrElse(ffmpegIsOneOfFrames(frames, fps), String(volume), ffmpegBuildVolumeExpression(rest, fps));
+    return ffmpegIfOrElse(ffmpegIsOneOfFrames({ frames, trimLeft: delay, fps }), String(volume), ffmpegBuildVolumeExpression(rest, delay, fps));
 };
-const ffmpegVolumeExpression = ({ volume, startInVideo, fps, }) => {
+const ffmpegVolumeExpression = ({ volume, fps, trimLeft, }) => {
     // If it's a static volume, we return it and tell
     // FFMPEG it only has to evaluate it once
     if (typeof volume === 'number') {
@@ -58,22 +55,27 @@ const ffmpegVolumeExpression = ({ volume, startInVideo, fps, }) => {
     if ([...new Set(volume)].length === 1) {
         return (0, exports.ffmpegVolumeExpression)({
             volume: volume[0],
-            startInVideo,
             fps,
+            trimLeft,
         });
     }
+    // A 1 sec video with frames 0-29 would mean that
+    // frame 29 corresponds to timestamp 0.966666...
+    // but the audio is actually 1 sec long. For that reason we pad the last
+    // timestamp.
+    const paddedVolume = [...volume, volume[volume.length - 1]];
     // Otherwise, we construct an FFMPEG expression. First step:
     // Make a map of all possible volumes
     // {possibleVolume1} => [frame1, frame2]
     // {possibleVolume2} => [frame3, frame4]
     const volumeMap = {};
-    volume.forEach((baseVolume, frame) => {
+    paddedVolume.forEach((baseVolume, frame) => {
         // Adjust volume based on how many other tracks have not yet finished
         const actualVolume = (0, round_volume_to_avoid_stack_overflow_1.roundVolumeToAvoidStackOverflow)(Math.min(1, baseVolume));
         if (!volumeMap[actualVolume]) {
             volumeMap[actualVolume] = [];
         }
-        volumeMap[actualVolume].push(frame + startInVideo);
+        volumeMap[actualVolume].push(frame);
     });
     // Sort the map so that the most common volume is last
     // this is going to be the else statement so the expression is short
@@ -81,7 +83,7 @@ const ffmpegVolumeExpression = ({ volume, startInVideo, fps, }) => {
         .map((key) => [Number(key), volumeMap[key]])
         .sort((a, b) => a[1].length - b[1].length);
     // Construct and tell FFMPEG it has to evaluate expression on each frame
-    const expression = ffmpegBuildVolumeExpression(volumeArray, fps);
+    const expression = ffmpegBuildVolumeExpression(volumeArray, trimLeft, fps);
     return {
         eval: 'frame',
         value: `'${expression}'`,

package/dist/assets/flatten-volume-array.d.ts

@@ -1,3 +1,3 @@
-import { AssetVolume, MediaAsset } from './types';
+import type { AssetVolume, MediaAsset } from './types';
 export declare const flattenVolumeArray: (volume: AssetVolume) => AssetVolume;
 export declare const convertAssetToFlattenedVolume: (asset: MediaAsset) => MediaAsset;

package/dist/assets/get-audio-channels.d.ts

@@ -1,4 +1,3 @@
-export declare function getAudioChannelsAndDuration(path: string): Promise<{
-    channels: number;
-    duration: number | null;
-}>;
+import type { FfmpegExecutable } from '../ffmpeg-executable';
+import type { AudioChannelsAndDurationResultCache, DownloadMap } from './download-map';
+export declare const getAudioChannelsAndDuration: (downloadMap: DownloadMap, src: string, ffprobeExecutable: FfmpegExecutable) => Promise<AudioChannelsAndDurationResultCache>;