Skip to content

The swiss army knife of lossless video/audio editing

improve types and simplify

Mikael Finstad9079aeeff280
diff --git a/src/renderer/src/App.tsx b/src/renderer/src/App.tsx
index 5db4205b..b2e6720a 100644
--- a/src/renderer/src/App.tsx
+++ b/src/renderer/src/App.tsx
@@ -86,7 +86,7 @@ import { rightBarWidth, leftBarWidth, ffmpegExtractWindow, zoomMax } from './uti
import BigWaveform from './components/BigWaveform';
import isDev from './isDev';
-import { ChromiumHTMLVideoElement, CustomTagsByFile, EdlFileType, FfmpegCommandLog, FilesMeta, FormatTimecode, ParamsByStreamId, ParseTimecode, PlaybackMode, SegmentColorIndex, SegmentTags, SegmentToExport, StateSegment, Thumbnail, TunerType } from './types';
+import { Chapter, ChromiumHTMLVideoElement, CustomTagsByFile, EdlFileType, FfmpegCommandLog, FilesMeta, FormatTimecode, ParamsByStreamId, ParseTimecode, PlaybackMode, SegmentColorIndex, SegmentTags, SegmentToExport, StateSegment, Thumbnail, TunerType } from './types';
import { CaptureFormat, KeyboardAction, Html5ifyMode } from '../../../types';
import { FFprobeChapter, FFprobeFormat, FFprobeStream } from '../../../ffprobe';
@@ -249,9 +249,9 @@ function App() {
});
}, [zoomedDuration]);
- function appendFfmpegCommandLog(command: string) {
+ const appendFfmpegCommandLog = useCallback((command: string) => {
setFfmpegCommandLog((old) => [...old, { command, time: new Date() }]);
- }
+ }, []);
const setCopyStreamIdsForPath = useCallback<Parameters<typeof StreamsSelector>[0]['setCopyStreamIdsForPath']>((path, cb) => {
setCopyStreamIdsByFile((old) => {
@@ -836,9 +836,9 @@ function App() {
const {
concatFiles, html5ifyDummy, cutMultiple, autoConcatCutSegments, html5ify, fixInvalidDuration,
- } = useFfmpegOperations({ filePath, treatInputFileModifiedTimeAsStart, treatOutputFileModifiedTimeAsStart, needSmartCut, enableOverwriteOutput, outputPlaybackRate, cutFromAdjustmentFrames });
+ } = useFfmpegOperations({ filePath, treatInputFileModifiedTimeAsStart, treatOutputFileModifiedTimeAsStart, needSmartCut, enableOverwriteOutput, outputPlaybackRate, cutFromAdjustmentFrames, appendFfmpegCommandLog });
- const html5ifyAndLoad = useCallback(async (cod, fp, speed, hv, ha) => {
+ const html5ifyAndLoad = useCallback(async (cod: string | undefined, fp: string, speed: Html5ifyMode, hv: boolean, ha: boolean) => {
const usesDummyVideo = speed === 'fastest';
console.log('html5ifyAndLoad', { speed, hasVideo: hv, hasAudio: ha, usesDummyVideo });
@@ -1107,7 +1107,7 @@ function App() {
// console.log('merge', paths);
const metadataFromPath = paths[0];
invariant(metadataFromPath != null);
- const { haveExcludedStreams } = await concatFiles({ paths, outPath, outDir, outFormat, metadataFromPath, includeAllStreams, streams, ffmpegExperimental, onProgress: setCutProgress, preserveMovData, movFastStart, preserveMetadataOnMerge, chapters: chaptersFromSegments, appendFfmpegCommandLog });
+ const { haveExcludedStreams } = await concatFiles({ paths, outPath, outDir, outFormat, metadataFromPath, includeAllStreams, streams, ffmpegExperimental, onProgress: setCutProgress, preserveMovData, movFastStart, preserveMetadataOnMerge, chapters: chaptersFromSegments });
const warnings: string[] = [];
const notices: string[] = [];
@@ -1244,7 +1244,7 @@ function App() {
setWorking({ text: i18n.t('Exporting') });
// Special segments-to-chapters mode:
- let chaptersToAdd;
+ let chaptersToAdd: Chapter[] | undefined;
if (segmentsToChaptersOnly) {
const sortedSegments = sortSegments(selectedSegmentsOrInverse);
if (hasAnySegmentOverlap(sortedSegments)) {
@@ -1274,7 +1274,6 @@ function App() {
segments: segmentsToExport,
outSegFileNames,
onProgress: setCutProgress,
- appendFfmpegCommandLog,
shortestFlag,
ffmpegExperimental,
preserveMovData,
@@ -1304,7 +1303,6 @@ function App() {
chapterNames,
autoDeleteMergedSegments,
preserveMetadataOnMerge,
- appendFfmpegCommandLog,
mergedOutFilePath,
});
}
diff --git a/src/renderer/src/TopMenu.tsx b/src/renderer/src/TopMenu.tsx
index 2c3a9bf2..3ecefae4 100644
--- a/src/renderer/src/TopMenu.tsx
+++ b/src/renderer/src/TopMenu.tsx
@@ -10,6 +10,7 @@ import ExportModeButton from './components/ExportModeButton';
import { withBlur } from './util';
import { primaryTextColor, controlsBackground, darkModeTransition } from './colors';
import useUserSettings from './hooks/useUserSettings';
+import { InverseCutSegment } from './types';
const outFmtStyle = { height: 20, maxWidth: 100 };
@@ -38,9 +39,9 @@ const TopMenu = memo(({
numStreamsTotal: number,
setStreamsSelectorShown: (v: boolean) => void,
toggleSettings: () => void,
- selectedSegments,
- isCustomFormatSelected,
- clearOutDir,
+ selectedSegments: InverseCutSegment[],
+ isCustomFormatSelected: boolean,
+ clearOutDir: () => void,
}) => {
const { t } = useTranslation();
const { customOutDir, changeOutDir, simpleMode, outFormatLocked, setOutFormatLocked } = useUserSettings();
diff --git a/src/renderer/src/edlStore.ts b/src/renderer/src/edlStore.ts
index 65642e40..25a162b1 100644
--- a/src/renderer/src/edlStore.ts
+++ b/src/renderer/src/edlStore.ts
@@ -1,6 +1,7 @@
import JSON5 from 'json5';
import i18n from 'i18next';
import type { parse as CueParse } from 'cue-parser';
+import invariant from 'tiny-invariant';
import { parseSrt, formatSrt, parseCuesheet, parseXmeml, parseFcpXml, parseCsv, parseCutlist, parsePbf, parseMplayerEdl, formatCsvHuman, formatTsv, formatCsvFrames, formatCsvSeconds, parseCsvTime, getFrameValParser, parseDvAnalyzerSummaryTxt } from './edlFormats';
import { askForYouTubeInput, showOpenDialog } from './dialogs';
@@ -139,8 +140,10 @@ export async function askForEdlImport({ type, fps }: { type: EdlImportType, fps?
export async function exportEdlFile({ type, cutSegments, customOutDir, filePath, getFrameCount }: {
type: EdlExportType, cutSegments: Segment[], customOutDir?: string | undefined, filePath?: string | undefined, getFrameCount: (a: number) => number | undefined,
}) {
- let filters;
- let ext;
+ invariant(filePath != null);
+
+ let filters: { name: string, extensions: string[] }[] | undefined;
+ let ext: string | undefined;
// eslint-disable-next-line unicorn/prefer-switch
if (type === 'csv') {
ext = 'csv';
@@ -164,7 +167,7 @@ export async function exportEdlFile({ type, cutSegments, customOutDir, filePath,
const defaultPath = getOutPath({ filePath, customOutDir, fileName: `${basename(filePath)}.${ext}` });
- const { canceled, filePath: savePath } = await dialog.showSaveDialog({ defaultPath, filters });
+ const { canceled, filePath: savePath } = await dialog.showSaveDialog({ defaultPath, ...(filters != null ? { filters } : {}) });
if (canceled || !savePath) return;
console.log('Saving', type, savePath);
// eslint-disable-next-line unicorn/prefer-switch
diff --git a/src/renderer/src/ffmpeg.ts b/src/renderer/src/ffmpeg.ts
index 3924d00a..abb44904 100644
--- a/src/renderer/src/ffmpeg.ts
+++ b/src/renderer/src/ffmpeg.ts
@@ -48,11 +48,11 @@ export function logStdoutStderr({ stdout, stderr }: { stdout: Buffer, stderr: Bu
}
}
-export function isCuttingStart(cutFrom) {
+export function isCuttingStart(cutFrom: number) {
return cutFrom > 0;
}
-export function isCuttingEnd(cutTo, duration) {
+export function isCuttingEnd(cutTo: number, duration: number | undefined) {
if (!isDurationValid(duration)) return true;
return cutTo < duration;
}
diff --git a/src/renderer/src/hooks/useFfmpegOperations.ts b/src/renderer/src/hooks/useFfmpegOperations.ts
index 559c2e07..63335053 100644
--- a/src/renderer/src/hooks/useFfmpegOperations.ts
+++ b/src/renderer/src/hooks/useFfmpegOperations.ts
@@ -10,14 +10,14 @@ import { getMapStreamsArgs, getStreamIdsToCopy } from '../util/streams';
import { getSmartCutParams } from '../smartcut';
import { isDurationValid } from '../segments';
import { FFprobeStream } from '../../../../ffprobe';
-import { Html5ifyMode } from '../../../../types';
-import { ParamsByStreamId } from '../types';
+import { AvoidNegativeTs, Html5ifyMode } from '../../../../types';
+import { AllFilesMeta, Chapter, CopyfileStreams, CustomTagsByFile, ParamsByStreamId, SegmentToExport } from '../types';
const { join, resolve, dirname } = window.require('path');
const { pathExists } = window.require('fs-extra');
const { writeFile, mkdir } = window.require('fs/promises');
-async function writeChaptersFfmetadata(outDir: string, chapters: { start: number, end: number, name?: string }[]) {
+async function writeChaptersFfmetadata(outDir: string, chapters: Chapter[] | undefined) {
if (!chapters || chapters.length === 0) return undefined;
const path = join(outDir, `ffmetadata-${Date.now()}.txt`);
@@ -54,23 +54,32 @@ function getMatroskaFlags() {
];
}
-const getChaptersInputArgs = (ffmetadataPath) => (ffmetadataPath ? ['-f', 'ffmetadata', '-i', ffmetadataPath] : []);
+const getChaptersInputArgs = (ffmetadataPath: string | undefined) => (ffmetadataPath ? ['-f', 'ffmetadata', '-i', ffmetadataPath] : []);
async function tryDeleteFiles(paths: string[]) {
return pMap(paths, (path) => unlinkWithRetry(path).catch((err) => console.error('Failed to delete', path, err)), { concurrency: 5 });
}
-function useFfmpegOperations({ filePath, treatInputFileModifiedTimeAsStart, treatOutputFileModifiedTimeAsStart, needSmartCut, enableOverwriteOutput, outputPlaybackRate, cutFromAdjustmentFrames }) {
+function useFfmpegOperations({ filePath, treatInputFileModifiedTimeAsStart, treatOutputFileModifiedTimeAsStart, needSmartCut, enableOverwriteOutput, outputPlaybackRate, cutFromAdjustmentFrames, appendFfmpegCommandLog }: {
+ filePath: string | undefined,
+ treatInputFileModifiedTimeAsStart: boolean | null | undefined,
+ treatOutputFileModifiedTimeAsStart: boolean | null | undefined,
+ enableOverwriteOutput: boolean,
+ needSmartCut: boolean,
+ outputPlaybackRate: number,
+ cutFromAdjustmentFrames: number,
+ appendFfmpegCommandLog: (a: string) => void,
+}) {
const shouldSkipExistingFile = useCallback(async (path) => {
const skip = !enableOverwriteOutput && await pathExists(path);
if (skip) console.log('Not overwriting existing file', path);
return skip;
}, [enableOverwriteOutput]);
- const getOutputPlaybackRateArgs = useCallback(() => (outputPlaybackRate !== 1 ? ['-itsscale', 1 / outputPlaybackRate] : []), [outputPlaybackRate]);
+ const getOutputPlaybackRateArgs = useCallback(() => (outputPlaybackRate !== 1 ? ['-itsscale', String(1 / outputPlaybackRate)] : []), [outputPlaybackRate]);
- const concatFiles = useCallback(async ({ paths, outDir, outPath, metadataFromPath, includeAllStreams, streams, outFormat, ffmpegExperimental, onProgress = () => undefined, preserveMovData, movFastStart, chapters, preserveMetadataOnMerge, videoTimebase, appendFfmpegCommandLog }: {
- paths: string[], outDir: string | undefined, outPath: string, metadataFromPath: string, includeAllStreams: boolean, streams: FFprobeStream[], outFormat: string, ffmpegExperimental: boolean, onProgress?: (a: number) => void, preserveMovData: boolean, movFastStart: boolean, chapters: { start: number, end: number, name: string | undefined }[] | undefined, preserveMetadataOnMerge: boolean, videoTimebase?: number | undefined, appendFfmpegCommandLog: (a: string) => void,
+ const concatFiles = useCallback(async ({ paths, outDir, outPath, metadataFromPath, includeAllStreams, streams, outFormat, ffmpegExperimental, onProgress = () => undefined, preserveMovData, movFastStart, chapters, preserveMetadataOnMerge, videoTimebase }: {
+ paths: string[], outDir: string | undefined, outPath: string, metadataFromPath: string, includeAllStreams: boolean, streams: FFprobeStream[], outFormat: string, ffmpegExperimental: boolean, onProgress?: (a: number) => void, preserveMovData: boolean, movFastStart: boolean, chapters: Chapter[] | undefined, preserveMetadataOnMerge: boolean, videoTimebase?: number | undefined,
}) => {
if (await shouldSkipExistingFile(outPath)) return { haveExcludedStreams: false };
@@ -177,14 +186,14 @@ function useFfmpegOperations({ filePath, treatInputFileModifiedTimeAsStart, trea
} finally {
if (chaptersPath) await tryDeleteFiles([chaptersPath]);
}
- }, [shouldSkipExistingFile, treatOutputFileModifiedTimeAsStart]);
+ }, [appendFfmpegCommandLog, shouldSkipExistingFile, treatOutputFileModifiedTimeAsStart]);
const losslessCutSingle = useCallback(async ({
keyframeCut: ssBeforeInput, avoidNegativeTs, copyFileStreams, cutFrom, cutTo, chaptersPath, onProgress, outPath,
- videoDuration, rotation, allFilesMeta, outFormat, appendFfmpegCommandLog, shortestFlag, ffmpegExperimental, preserveMovData, movFastStart, customTagsByFile, paramsByStreamId, videoTimebase, detectedFps,
+ videoDuration, rotation, allFilesMeta, outFormat, shortestFlag, ffmpegExperimental, preserveMovData, movFastStart, customTagsByFile, paramsByStreamId, videoTimebase, detectedFps,
}: {
- keyframeCut: boolean, avoidNegativeTs: boolean, copyFileStreams, cutFrom, cutTo, chaptersPath, onProgress, outPath,
- videoDuration, rotation, allFilesMeta, outFormat, appendFfmpegCommandLog, shortestFlag, ffmpegExperimental, preserveMovData, movFastStart, customTagsByFile, paramsByStreamId: ParamsByStreamId, videoTimebase, detectedFps,
+ keyframeCut: boolean, avoidNegativeTs: AvoidNegativeTs | undefined, copyFileStreams: CopyfileStreams, cutFrom: number, cutTo: number, chaptersPath?: string | undefined, onProgress: (p: number) => void, outPath: string,
+ videoDuration: number | undefined, rotation: number | undefined, allFilesMeta: AllFilesMeta, outFormat: string, shortestFlag: boolean, ffmpegExperimental: boolean, preserveMovData: boolean, movFastStart: boolean, customTagsByFile: CustomTagsByFile, paramsByStreamId: ParamsByStreamId, videoTimebase?: number | undefined, detectedFps?: number,
}) => {
if (await shouldSkipExistingFile(outPath)) return;
@@ -205,7 +214,7 @@ function useFfmpegOperations({ filePath, treatInputFileModifiedTimeAsStart, trea
const copyFileStreamsFiltered = copyFileStreams.filter(({ streamIds }) => streamIds.length > 0);
// remove -avoid_negative_ts make_zero when not cutting start (no -ss), or else some videos get blank first frame in QuickLook
- const avoidNegativeTsArgs = cuttingStart && avoidNegativeTs ? ['-avoid_negative_ts', avoidNegativeTs] : [];
+ const avoidNegativeTsArgs = cuttingStart && avoidNegativeTs ? ['-avoid_negative_ts', String(avoidNegativeTs)] : [];
const inputFilesArgs = flatMap(copyFileStreamsFiltered, ({ path }) => ['-i', path]);
const inputFilesArgsWithCuts = ssBeforeInput ? [
@@ -247,6 +256,8 @@ function useFfmpegOperations({ filePath, treatInputFileModifiedTimeAsStart, trea
return streamCount + copiedStreamIndex;
}
+ invariant(filePath != null);
+
const customTagsArgs = [
// Main file metadata:
...flatMap(Object.entries(customTagsByFile[filePath] || []), ([key, value]) => ['-metadata', `${key}=${value}`]),
@@ -300,7 +311,7 @@ function useFfmpegOperations({ filePath, treatInputFileModifiedTimeAsStart, trea
'-map_metadata', '0',
- ...(chaptersPath ? ['-map_chapters', chaptersInputIndex] : []),
+ ...(chaptersPath ? ['-map_chapters', String(chaptersInputIndex)] : []),
...(shortestFlag ? ['-shortest'] : []),
@@ -332,13 +343,32 @@ function useFfmpegOperations({ filePath, treatInputFileModifiedTimeAsStart, trea
logStdoutStderr(result);
await transferTimestamps({ inPath: filePath, outPath, cutFrom, cutTo, treatInputFileModifiedTimeAsStart, duration: isDurationValid(videoDuration) ? videoDuration : undefined, treatOutputFileModifiedTimeAsStart });
- }, [cutFromAdjustmentFrames, filePath, getOutputPlaybackRateArgs, shouldSkipExistingFile, treatInputFileModifiedTimeAsStart, treatOutputFileModifiedTimeAsStart]);
+ }, [appendFfmpegCommandLog, cutFromAdjustmentFrames, filePath, getOutputPlaybackRateArgs, shouldSkipExistingFile, treatInputFileModifiedTimeAsStart, treatOutputFileModifiedTimeAsStart]);
const cutMultiple = useCallback(async ({
- outputDir, customOutDir, segments, outSegFileNames, videoDuration, rotation, detectedFps,
- onProgress: onTotalProgress, keyframeCut, copyFileStreams, allFilesMeta, outFormat,
- appendFfmpegCommandLog, shortestFlag, ffmpegExperimental, preserveMovData, movFastStart, avoidNegativeTs,
- customTagsByFile, paramsByStreamId, chapters, preserveMetadataOnMerge,
+ outputDir, customOutDir, segments, outSegFileNames, videoDuration, rotation, detectedFps, onProgress: onTotalProgress, keyframeCut, copyFileStreams, allFilesMeta, outFormat, shortestFlag, ffmpegExperimental, preserveMovData, movFastStart, avoidNegativeTs, customTagsByFile, paramsByStreamId, chapters, preserveMetadataOnMerge,
+ }: {
+ outputDir: string,
+ customOutDir: string | undefined,
+ segments: SegmentToExport[],
+ outSegFileNames: string[],
+ videoDuration: number | undefined,
+ rotation: number | undefined,
+ detectedFps: number | undefined,
+ onProgress: (p: number) => void,
+ keyframeCut: boolean,
+ copyFileStreams: CopyfileStreams,
+ allFilesMeta: AllFilesMeta,
+ outFormat: string | undefined,
+ shortestFlag: boolean,
+ ffmpegExperimental: boolean,
+ preserveMovData: boolean,
+ movFastStart: boolean,
+ avoidNegativeTs: AvoidNegativeTs | undefined,
+ customTagsByFile: CustomTagsByFile,
+ paramsByStreamId: ParamsByStreamId,
+ chapters: Chapter[] | undefined,
+ preserveMetadataOnMerge,
}) => {
console.log('customTagsByFile', customTagsByFile);
console.log('paramsByStreamId', paramsByStreamId);
@@ -357,7 +387,7 @@ function useFfmpegOperations({ filePath, treatInputFileModifiedTimeAsStart, trea
// so that for the calling code it looks as if it's just a normal segment
async function maybeSmartCutSegment({ start: desiredCutFrom, end: cutTo }, i) {
async function makeSegmentOutPath() {
- const outPath = join(outputDir, outSegFileNames[i]);
+ const outPath = join(outputDir, outSegFileNames[i]!);
// because outSegFileNames might contain slashes https://github.com/mifi/lossless-cut/issues/1532
const actualOutputDir = dirname(outPath);
if (actualOutputDir !== outputDir) await mkdir(actualOutputDir, { recursive: true });
@@ -366,17 +396,22 @@ function useFfmpegOperations({ filePath, treatInputFileModifiedTimeAsStart, trea
if (!needSmartCut) {
const outPath = await makeSegmentOutPath();
- // @ts-expect-error todo
+ invariant(outFormat != null);
await losslessCutSingle({
- cutFrom: desiredCutFrom, cutTo, chaptersPath, outPath, copyFileStreams, keyframeCut, avoidNegativeTs, videoDuration, rotation, allFilesMeta, outFormat, appendFfmpegCommandLog, shortestFlag, ffmpegExperimental, preserveMovData, movFastStart, customTagsByFile, paramsByStreamId, onProgress: (progress) => onSingleProgress(i, progress),
+ cutFrom: desiredCutFrom, cutTo, chaptersPath, outPath, copyFileStreams, keyframeCut, avoidNegativeTs, videoDuration, rotation, allFilesMeta, outFormat, shortestFlag, ffmpegExperimental, preserveMovData, movFastStart, customTagsByFile, paramsByStreamId, onProgress: (progress) => onSingleProgress(i, progress),
});
return outPath;
}
+ invariant(filePath != null);
+
// smart cut only supports cutting main file (no externally added files)
- const { streams } = allFilesMeta[filePath];
- const streamsToCopyFromMainFile = copyFileStreams.find(({ path }) => path === filePath).streamIds
- .map((streamId) => streams.find((stream) => stream.index === streamId));
+ const { streams } = allFilesMeta[filePath]!;
+ const streamsToCopyFromMainFile = copyFileStreams.find(({ path }) => path === filePath)!.streamIds
+ .flatMap((streamId) => {
+ const match = streams.find((stream) => stream.index === streamId);
+ return match ? [match] : [];
+ });
const { losslessCutFrom, segmentNeedsSmartCut, videoCodec, videoBitrate, videoStreamIndex, videoTimebase } = await getSmartCutParams({ path: filePath, videoDuration, desiredCutFrom, streams: streamsToCopyFromMainFile });
@@ -397,6 +432,8 @@ function useFfmpegOperations({ filePath, treatInputFileModifiedTimeAsStart, trea
async function cutEncodeSmartPartWrapper({ cutFrom, cutTo, outPath }) {
if (await shouldSkipExistingFile(outPath)) return;
if (videoCodec == null || videoBitrate == null || videoTimebase == null) throw new Error();
+ invariant(filePath != null);
+ invariant(outFormat != null);
await cutEncodeSmartPart({ filePath, cutFrom, cutTo, outPath, outFormat, videoCodec, videoBitrate, videoStreamIndex, videoTimebase, allFilesMeta, copyFileStreams: copyFileStreamsFiltered, ffmpegExperimental });
}
@@ -409,6 +446,8 @@ function useFfmpegOperations({ filePath, treatInputFileModifiedTimeAsStart, trea
return outPath;
}
+ invariant(outFormat != null);
+
const ext = getOutFileExtension({ isCustomFormatSelected: true, outFormat, filePath });
const losslessPartOutPath = segmentNeedsSmartCut
@@ -420,9 +459,8 @@ function useFfmpegOperations({ filePath, treatInputFileModifiedTimeAsStart, trea
}
// for smart cut we need to use keyframe cut here, and no avoid_negative_ts
- // @ts-expect-error todo
await losslessCutSingle({
- cutFrom: losslessCutFrom, cutTo, chaptersPath, outPath: losslessPartOutPath, copyFileStreams: copyFileStreamsFiltered, keyframeCut: true, avoidNegativeTs: false, videoDuration, rotation, allFilesMeta, outFormat, appendFfmpegCommandLog, shortestFlag, ffmpegExperimental, preserveMovData, movFastStart, customTagsByFile, paramsByStreamId, videoTimebase, onProgress: onCutProgress,
+ cutFrom: losslessCutFrom, cutTo, chaptersPath, outPath: losslessPartOutPath, copyFileStreams: copyFileStreamsFiltered, keyframeCut: true, avoidNegativeTs: undefined, videoDuration, rotation, allFilesMeta, outFormat, shortestFlag, ffmpegExperimental, preserveMovData, movFastStart, customTagsByFile, paramsByStreamId, videoTimebase, onProgress: onCutProgress,
});
// OK, just return the single cut file (we may need smart cut in other segments though)
@@ -445,7 +483,7 @@ function useFfmpegOperations({ filePath, treatInputFileModifiedTimeAsStart, trea
const outPath = await makeSegmentOutPath();
- await concatFiles({ paths: smartCutSegmentsToConcat, outDir: outputDir, outPath, metadataFromPath: losslessPartOutPath, outFormat, includeAllStreams: true, streams: streamsAfterCut, ffmpegExperimental, preserveMovData, movFastStart, chapters, preserveMetadataOnMerge, videoTimebase, appendFfmpegCommandLog, onProgress: onConcatProgress });
+ await concatFiles({ paths: smartCutSegmentsToConcat, outDir: outputDir, outPath, metadataFromPath: losslessPartOutPath, outFormat, includeAllStreams: true, streams: streamsAfterCut, ffmpegExperimental, preserveMovData, movFastStart, chapters, preserveMetadataOnMerge, videoTimebase, onProgress: onConcatProgress });
return outPath;
} finally {
await tryDeleteFiles(smartCutSegmentsToConcat);
@@ -459,9 +497,9 @@ function useFfmpegOperations({ filePath, treatInputFileModifiedTimeAsStart, trea
} finally {
if (chaptersPath) await tryDeleteFiles([chaptersPath]);
}
- }, [concatFiles, losslessCutSingle, filePath, needSmartCut, shouldSkipExistingFile]);
+ }, [needSmartCut, filePath, losslessCutSingle, shouldSkipExistingFile, concatFiles]);
- const autoConcatCutSegments = useCallback(async ({ customOutDir, outFormat, segmentPaths, ffmpegExperimental, onProgress, preserveMovData, movFastStart, autoDeleteMergedSegments, chapterNames, preserveMetadataOnMerge, appendFfmpegCommandLog, mergedOutFilePath }) => {
+ const autoConcatCutSegments = useCallback(async ({ customOutDir, outFormat, segmentPaths, ffmpegExperimental, onProgress, preserveMovData, movFastStart, autoDeleteMergedSegments, chapterNames, preserveMetadataOnMerge, mergedOutFilePath }) => {
const outDir = getOutDir(customOutDir, filePath);
if (await shouldSkipExistingFile(mergedOutFilePath)) return;
@@ -471,7 +509,7 @@ function useFfmpegOperations({ filePath, treatInputFileModifiedTimeAsStart, trea
const metadataFromPath = segmentPaths[0];
// need to re-read streams because may have changed
const { streams } = await readFileMeta(metadataFromPath);
- await concatFiles({ paths: segmentPaths, outDir, outPath: mergedOutFilePath, metadataFromPath, outFormat, includeAllStreams: true, streams, ffmpegExperimental, onProgress, preserveMovData, movFastStart, chapters, preserveMetadataOnMerge, appendFfmpegCommandLog });
+ await concatFiles({ paths: segmentPaths, outDir, outPath: mergedOutFilePath, metadataFromPath, outFormat, includeAllStreams: true, streams, ffmpegExperimental, onProgress, preserveMovData, movFastStart, chapters, preserveMetadataOnMerge });
if (autoDeleteMergedSegments) await tryDeleteFiles(segmentPaths);
}, [concatFiles, filePath, shouldSkipExistingFile]);
@@ -511,6 +549,7 @@ function useFfmpegOperations({ filePath, treatInputFileModifiedTimeAsStart, trea
// https://stackoverflow.com/questions/34118013/how-to-determine-webm-duration-using-ffprobe
const fixInvalidDuration = useCallback(async ({ fileFormat, customOutDir, duration, onProgress }: { fileFormat: string, customOutDir?: string | undefined, duration: number | undefined, onProgress }) => {
+ invariant(filePath != null);
const ext = getOutFileExtension({ outFormat: fileFormat, filePath });
const outPath = getSuffixedOutPath({ customOutDir, filePath, nameSuffix: `reformatted${ext}` });
invariant(outPath != null);
diff --git a/src/renderer/src/index.tsx b/src/renderer/src/index.tsx
index 0c5168ea..ab711c4d 100644
--- a/src/renderer/src/index.tsx
+++ b/src/renderer/src/index.tsx
@@ -4,6 +4,7 @@ import { MotionConfig } from 'framer-motion';
import { enableMapSet } from 'immer';
import * as Electron from 'electron';
import Remote from '@electron/remote';
+import type path from 'path';
import 'sweetalert2/dist/sweetalert2.css';
@@ -42,6 +43,7 @@ declare global {
require: <T extends string>(module: T) => (
T extends '@electron/remote' ? TypedRemote :
T extends 'electron' ? typeof Electron :
+ T extends 'path' ? typeof path :
// todo more
// eslint-disable-next-line @typescript-eslint/no-explicit-any
any
diff --git a/src/renderer/src/segments.ts b/src/renderer/src/segments.ts
index 53a24fa5..1d0ec1fa 100644
--- a/src/renderer/src/segments.ts
+++ b/src/renderer/src/segments.ts
@@ -2,6 +2,8 @@ import { nanoid } from 'nanoid';
import sortBy from 'lodash/sortBy';
import minBy from 'lodash/minBy';
import maxBy from 'lodash/maxBy';
+import invariant from 'tiny-invariant';
+
import { ApparentSegmentBase, PlaybackMode, SegmentBase, SegmentTags, StateSegment } from './types';
@@ -199,12 +201,14 @@ export function invertSegments(sortedCutSegments: (SegmentBase & { segId?: strin
}
// because chapters need to be contiguous, we need to insert gaps in-between
-export function convertSegmentsToChapters(sortedSegments) {
+export function convertSegmentsToChapters(sortedSegments: { start: number, end: number, name?: string | undefined }[]) {
if (sortedSegments.length === 0) return [];
if (hasAnySegmentOverlap(sortedSegments)) throw new Error('Segments cannot overlap');
- sortedSegments.map((segment) => ({ start: segment.start, end: segment.end, name: segment.name }));
- const invertedSegments = invertSegments(sortedSegments, true, false);
+ const invertedSegments = invertSegments(sortedSegments, true, false).map(({ start, end, ...seg }) => {
+ invariant(start != null && end != null); // to please typescript
+ return { ...seg, start, end };
+ });
// inverted segments will be "gap" segments. Merge together with normal segments
return sortSegments([...sortedSegments, ...invertedSegments]);
diff --git a/src/renderer/src/smartcut.ts b/src/renderer/src/smartcut.ts
index b478f629..36fdbf23 100644
--- a/src/renderer/src/smartcut.ts
+++ b/src/renderer/src/smartcut.ts
@@ -10,7 +10,7 @@ const mapVideoCodec = (codec: string) => ({ av1: 'libsvtav1' }[codec] ?? codec);
// eslint-disable-next-line import/prefer-default-export
export async function getSmartCutParams({ path, videoDuration, desiredCutFrom, streams }: {
- path: string, videoDuration: number, desiredCutFrom: number, streams: FFprobeStream[],
+ path: string, videoDuration: number | undefined, desiredCutFrom: number, streams: FFprobeStream[],
}) {
const videoStreams = getRealVideoStreams(streams);
if (videoStreams.length > 1) throw new Error('Can only smart cut video with exactly one video stream');
@@ -49,6 +49,7 @@ export async function getSmartCutParams({ path, videoDuration, desiredCutFrom, s
if (Number.isNaN(videoBitrate)) {
console.warn('Unable to detect input bitrate');
const stats = await stat(path);
+ if (videoDuration == null) throw new Error('Video duration is unknown, cannot estimate bitrate');
videoBitrate = (stats.size * 8) / videoDuration;
}
diff --git a/src/renderer/src/types.ts b/src/renderer/src/types.ts
index 8e43a457..bf5cd959 100644
--- a/src/renderer/src/types.ts
+++ b/src/renderer/src/types.ts
@@ -20,11 +20,13 @@ export interface SegmentColorIndex {
segColorIndex: number,
}
-export interface ApparentSegmentBase extends SegmentColorIndex {
+export interface ApparentSegmentBase {
start: number,
end: number,
}
+export interface ApparentSegmentWithColorIndex extends ApparentSegmentBase, SegmentColorIndex {}
+
export const segmentTagsSchema = z.record(z.string(), z.string());
export type SegmentTags = z.infer<typeof segmentTagsSchema>
@@ -41,7 +43,7 @@ export interface Segment extends SegmentBase {
name?: string | undefined,
}
-export interface ApparentCutSegment extends ApparentSegmentBase {
+export interface ApparentCutSegment extends ApparentSegmentWithColorIndex {
name: string;
segId: string,
tags?: SegmentTags | undefined;
@@ -104,6 +106,19 @@ export type FilesMeta = Record<string, {
chapters: FFprobeChapter[];
}>
+export type CopyfileStreams = {
+ path: string;
+ streamIds: number[];
+}[]
+
+export interface Chapter { start: number, end: number, name?: string | undefined }
+
+export type AllFilesMeta = Record<string, {
+ streams: FFprobeStream[];
+ formatData: FFprobeFormat;
+ chapters: FFprobeChapter[];
+}>
+
export type CustomTagsByFile = Record<string, Record<string, string>>;
export interface StreamParams {
diff --git a/src/renderer/src/util.ts b/src/renderer/src/util.ts
index 81568f1b..050ddce1 100644
--- a/src/renderer/src/util.ts
+++ b/src/renderer/src/util.ts
@@ -132,7 +132,7 @@ export const utimesWithRetry = async (path: string, atime: number, mtime: number
export const getFrameDuration = (fps?: number) => 1 / (fps ?? 30);
export async function transferTimestamps({ inPath, outPath, cutFrom = 0, cutTo = 0, duration = 0, treatInputFileModifiedTimeAsStart = true, treatOutputFileModifiedTimeAsStart }: {
- inPath: string, outPath: string, cutFrom?: number | undefined, cutTo?: number | undefined, duration?: number | undefined, treatInputFileModifiedTimeAsStart?: boolean, treatOutputFileModifiedTimeAsStart: boolean | null | undefined
+ inPath: string, outPath: string, cutFrom?: number | undefined, cutTo?: number | undefined, duration?: number | undefined, treatInputFileModifiedTimeAsStart?: boolean | null | undefined, treatOutputFileModifiedTimeAsStart: boolean | null | undefined
}) {
if (treatOutputFileModifiedTimeAsStart == null) return; // null means disabled;