feat: file copy support overwrite

Author: modstart

src/lib/ffmpeg.ts

@@ -1,5 +1,185 @@
 import {ffprobeGetMediaDuration, ffprobeVideoInfo} from "./ffprobe";
 
+let hardwareEncodersCache: { [key: string]: boolean } | null = null;
+
+const detectHardwareEncoders = async (): Promise<{ [key: string]: boolean }> => {
+    if (hardwareEncodersCache) return hardwareEncodersCache;
+
+    const platform = $mapi.app.platformName();
+    const encoders: { [key: string]: boolean } = {};
+
+    try {
+        const output = await new Promise<string>((resolve, reject) => {
+            let buffer = "";
+            $mapi.app.spawnBinary("ffmpeg", ["-encoders"], {
+                shell: false,
+                stdout: (data: string) => buffer += data,
+                stderr: (data: string) => buffer += data,
+                success: () => resolve(buffer),
+                error: (msg: string) => reject(msg),
+            });
+        });
+        // Check for common hardware encoders based on platform
+        if (platform === "osx") {
+            // macOS VideoToolbox
+            if (output.includes("h264_videotoolbox")) encoders.h264_videotoolbox = true;
+            if (output.includes("hevc_videotoolbox")) encoders.hevc_videotoolbox = true;
+        } else if (platform === "win") {
+            // Windows
+            if (output.includes("h264_nvenc")) encoders.h264_nvenc = true;
+            if (output.includes("hevc_nvenc")) encoders.hevc_nvenc = true;
+            if (output.includes("h264_amf")) encoders.h264_amf = true;
+            if (output.includes("hevc_amf")) encoders.hevc_amf = true;
+            if (output.includes("h264_qsv")) encoders.h264_qsv = true;
+            if (output.includes("hevc_qsv")) encoders.hevc_qsv = true;
+        } else if (platform === "linux") {
+            // Linux
+            if (output.includes("h264_nvenc")) encoders.h264_nvenc = true;
+            if (output.includes("hevc_nvenc")) encoders.hevc_nvenc = true;
+            if (output.includes("h264_amf")) encoders.h264_amf = true;
+            if (output.includes("hevc_amf")) encoders.hevc_amf = true;
+            if (output.includes("h264_qsv")) encoders.h264_qsv = true;
+            if (output.includes("hevc_qsv")) encoders.hevc_qsv = true;
+            if (output.includes("h264_vaapi")) encoders.h264_vaapi = true;
+            if (output.includes("hevc_vaapi")) encoders.hevc_vaapi = true;
+        }
+    } catch (e) {
+        // If detection fails, assume no hardware acceleration
+    }
+    hardwareEncodersCache = encoders;
+    return encoders;
+};
+
+const optimizeArgs = (args: string[], encoders: { [key: string]: boolean }): string[] => {
+    const optimizedArgs = [...args];
+    // Replace software encoders with hardware ones if available
+    for (let i = 0; i < optimizedArgs.length; i++) {
+        if (optimizedArgs[i] === "-c:v") {
+            const encoder = optimizedArgs[i + 1];
+            if (encoder === "libx264" && encoders.h264_nvenc) {
+                optimizedArgs[i + 1] = "h264_nvenc";
+            } else if (encoder === "libx264" && encoders.h264_amf) {
+                optimizedArgs[i + 1] = "h264_amf";
+            } else if (encoder === "libx264" && encoders.h264_qsv) {
+                optimizedArgs[i + 1] = "h264_qsv";
+            } else if (encoder === "libx264" && encoders.h264_videotoolbox) {
+                optimizedArgs[i + 1] = "h264_videotoolbox";
+            } else if (encoder === "libx265" && encoders.hevc_nvenc) {
+                optimizedArgs[i + 1] = "hevc_nvenc";
+            } else if (encoder === "libx265" && encoders.hevc_amf) {
+                optimizedArgs[i + 1] = "hevc_amf";
+            } else if (encoder === "libx265" && encoders.hevc_qsv) {
+                optimizedArgs[i + 1] = "hevc_qsv";
+            } else if (encoder === "libx265" && encoders.hevc_videotoolbox) {
+                optimizedArgs[i + 1] = "hevc_videotoolbox";
+            }
+        }
+    }
+
+    return optimizedArgs;
+};
+
+const extractInputFile = (args: string[]): string | null => {
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "-i" && i + 1 < args.length) {
+            return args[i + 1];
+        }
+    }
+    return null;
+};
+
+export const ffmpegOptimized = async (
+    args: string[],
+    option?: {
+        successFileCheck?: string,
+        onProgress?: (progress: number) => void;
+        codesOptimized?: boolean,
+    }
+): Promise<void> => {
+
+    option = Object.assign({
+        successFileCheck: '',
+        codesOptimized: false,
+        onProgress: undefined,
+    }, option)
+
+    // add hide banner and loglevel error
+    if (!args.includes("-hide_banner")) {
+        args.unshift("-hide_banner");
+    }
+    // if (!args.includes("-loglevel")) {
+    //     args.unshift("-loglevel", "info");
+    // }
+
+    let optimizedArgs = args;
+    if (option!.codesOptimized) {
+        const encoders = await detectHardwareEncoders();
+        const optimizedArgs = optimizeArgs(args, encoders);
+        if (optimizedArgs.join(' ') !== args.join(' ')) {
+            $mapi.log.info('FfmpegCommandOptimized', {
+                original: 'ffmpeg ' + args.join(' '),
+                optimized: 'ffmpeg ' + optimizedArgs.join(' ')
+            });
+        }
+    }
+
+    let totalDuration = 0;
+    const inputFile = extractInputFile(optimizedArgs);
+    if (inputFile && option?.onProgress) {
+        try {
+            totalDuration = await ffprobeGetMediaDuration(inputFile, false);
+        } catch (e) {
+            // If can't get duration, progress won't work
+        }
+    }
+
+    return new Promise<void>((resolve, reject) => {
+        let lastProgress = 0;
+        const controller = $mapi.app.spawnBinary("ffmpeg", optimizedArgs, {
+            shell: false,
+            stdout: (data: string) => {
+                // console.log("FFmpeg stdout:", data);
+            },
+            stderr: (data: string) => {
+                // console.log("FFmpeg stderr:", data);
+                if (option?.onProgress && totalDuration > 0) {
+                    const timeMatch = data.match(/time=(\d+):(\d+):(\d+\.\d+)/);
+                    if (timeMatch) {
+                        const hours = parseInt(timeMatch[1]);
+                        const minutes = parseInt(timeMatch[2]);
+                        const seconds = parseFloat(timeMatch[3]);
+                        const currentTime = hours * 3600 + minutes * 60 + seconds;
+                        const progress = Math.min(currentTime / totalDuration, 1);
+                        if (progress > lastProgress) {
+                            option.onProgress(progress);
+                            lastProgress = progress;
+                        }
+                    }
+                }
+            },
+            success: () => {
+                if (option?.onProgress) {
+                    option.onProgress(1);
+                }
+                if (option?.successFileCheck) {
+                    $mapi.file.exists(option.successFileCheck).then(exists => {
+                        if (exists) {
+                            resolve();
+                        } else {
+                            reject(`FFmpeg completed but output file not found: ${option?.successFileCheck}`);
+                        }
+                    }).catch(reject);
+                } else {
+                    resolve();
+                }
+            },
+            error: (msg: string, exitCode: number) => {
+                reject(`FFmpeg error (code ${exitCode}): ${msg}`);
+            },
+        });
+    });
+};
+
 export const ffmpegSetMediaRatio = async (
     input: string,
     output: string,
@@ -45,7 +225,7 @@ export const ffmpegSetMediaRatio = async (
             "-map",
             "[a]",
             "-preset",
-            "fast",
+            "ultrafast",
             "-y",
             output,
         ];
@@ -238,14 +418,12 @@ export const ffmpegCombineVideoAudio = async (video: string, audio: string) => {
         video,
         "-i",
         audio,
-        "-c:v",
-        "copy",
-        "-c:a",
-        "aac",
-        "-map",
-        "0:v:0",
-        "-map",
-        "1:a:0",
+        "-c:v", "libx264",
+        "-preset", "ultrafast",
+        "-crf", "0",
+        "-c:a", "aac",
+        "-map", "0:v:0",
+        "-map", "1:a:0",
         "-y",
         output,
     ]);
@@ -360,7 +538,7 @@ export const ffmpegVideoNormal = async (input: string, option: {
         "-r",
         targetFps.toString(),
         "-preset",
-        "fast",
+        "ultrafast",
         "-y",
         output,
     ];
@@ -372,6 +550,55 @@ export const ffmpegVideoNormal = async (input: string, option: {
     return output;
 }
 
+export async function ffmpegCutVideo(input: string, startMs: number, endMs: number): Promise<string> {
+    const output = await $mapi.file.temp('mp4');
+    const startSeconds = startMs / 1000;
+    const durationSeconds = (endMs - startMs) / 1000;
+    const args = [
+        '-i', input,
+        '-ss', startSeconds.toString(),
+        '-t', durationSeconds.toString(),
+        '-c:v', 'libx264',
+        '-preset', 'ultrafast',
+        '-crf', '0',
+        '-c:a', 'aac',
+        '-avoid_negative_ts', 'make_zero',
+        '-y', output
+    ];
+    await ffmpegOptimized(args, {
+        successFileCheck: output
+    });
+    return output;
+}
+
+// FFmpeg 工具函数：合并多个视频
+export async function ffmpegConcatVideos(videos: string[]): Promise<string> {
+    if (videos.length === 0) {
+        throw new Error('No videos to concat');
+    }
+    if (videos.length === 1) {
+        return videos[0];
+    }
+    const output = await $mapi.file.temp('mp4');
+    const txtFile = await $mapi.file.temp('txt');
+    // 创建 concat 文件列表
+    const lines = videos.map(video => `file '${video.replace(/'/g, "'\\''")}'`);
+    await $mapi.file.write(txtFile, lines.join('\n'));
+    const args = [
+        '-f', 'concat',
+        '-safe', '0',
+        '-i', txtFile,
+        '-c:v', 'libx264',
+        '-preset', 'ultrafast',
+        '-crf', '0',
+        '-c:a', 'aac',
+        '-y', output
+    ];
+    await ffmpegOptimized(args, {
+        successFileCheck: output
+    });
+    return output;
+}
 
 export const ffmpegVideoNormal = async (input: string, option: {
     widthMax?: number;

src/pages/Apps/LongTextTts/components/LongTextTtsParamDialog.vue

@@ -1,9 +1,12 @@
 <script setup lang="ts">
-import {ref} from "vue";
+import { nextTick, ref } from "vue";
 import SoundGenerateForm from "../../../Sound/components/SoundGenerateForm.vue";
 
 const soundGenerateForm = ref<InstanceType<typeof SoundGenerateForm> | null>(null);
 
+const props = defineProps<{
+}>();
+
 const visible = ref(false);
 const emit = defineEmits<{
     update: [
@@ -24,8 +27,13 @@ const doSubmit = async () => {
 };
 
 defineExpose({
-    show: () => {
+    show: (data?: any) => {
         visible.value = true;
+        nextTick(() => {
+            if (data?.soundGenerate) {
+                soundGenerateForm.value?.setValue(data.soundGenerate);
+            }
+        });
     },
 });
 

src/pages/Apps/LongTextTts/task.ts

@@ -121,10 +121,7 @@ export const LongTextTts: TaskBiz = {
                 if (ret.type === "retry") {
                     return ret.type;
                 }
-                record.audio = await $mapi.file.hubSave(ret.url, {
-                    saveGroup: "part",
-
-                });
+                record.audio = await $mapi.file.hubSave(ret.url);
                 await TaskService.update(bizId, {jobResult});
             }
             jobResult.step = "Combine";
@@ -145,10 +142,7 @@ export const LongTextTts: TaskBiz = {
             const filesToClean: string[] = [];
             try {
                 const audio = await ffmpegConcatAudio(jobResult.SoundGenerate.records!.map(r => r.audio));
-                jobResult.Combine.audio = await $mapi.file.hubSave(audio, {
-                    saveGroup: "part",
-
-                });
+                jobResult.Combine.audio = await $mapi.file.hubSave(audio);
                 jobResult.step = "End";
                 jobResult.Combine.status = "success";
                 await TaskService.update(bizId, {

src/pages/Apps/LongTextTts/workflow/LongTextTtsNode.vue

@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import {ref} from "vue";
+import { ref } from "vue";
 import TaskDialogViewButton from "../../../../components/common/TaskDialogViewButton.vue";
 import {
     FunctionCallNodeEmits,
@@ -17,18 +17,16 @@ const paramDialog = ref<InstanceType<typeof LongTextTtsParamDialog>>();
 
 <template>
     <div class="p-2 relative">
-        <div class="-mb-4">
+        <div>
             <SoundGenerateFormView v-if="nodeData.soundGenerate" :data="nodeData.soundGenerate"/>
-            <a-button v-if="(!nodeData.soundGenerate) || (props.source==='config')"
-                      :class="props.source==='config'?'cursor-pointer':''"
-                      @click="props.source==='config'&&paramDialog.show()"
-                      size="small" class="w-full mb-4">
-                {{ props.source === 'config' ? $t("修改配置") : $t("没有配置") }}
-            </a-button>
-            <div v-if="nodeRunData" class="mb-4">
-                <div class="">
-                    <TaskDialogViewButton :task-id="nodeRunData.taskId"/>
-                </div>
+            <div class="flex gap-2 items-center">
+                <a-button v-if="props.source==='config'" @click="paramDialog?.show(nodeData)" size="small">
+                    <template #icon>
+                        <icon-settings/>
+                    </template>
+                    {{ $t('设置')}}
+                </a-button>
+                <TaskDialogViewButton :task-id="nodeRunData.taskId"/>
             </div>
         </div>
     </div>

src/pages/Apps/LongTextTts/workflow/node.ts

@@ -1,13 +1,14 @@
-import {defineAsyncComponent} from "vue";
-import {t} from "../../../../lang";
-import {NodeFunctionCall, NodeRunController, NodeRunParam, NodeRunResult} from "../../../../module/Workflow/core/type";
-import {workflowRun} from "../../common/workflow";
-import {LongTextTtsRun} from "../task";
+import { defineAsyncComponent } from "vue";
+import { t } from "../../../../lang";
+import { NodeFunctionCall, NodeRunController, NodeRunParam, NodeRunResult } from "../../../../module/Workflow/core/type";
+import { workflowRun } from "../../common/workflow";
+import { LongTextTtsRun } from "../task";
 import LongTextTtsIcon from "./../assets/icon.svg";
 
 export default <NodeFunctionCall>{
     name: "LongTextTts",
     title: t("长文本转音频"),
+    description: "将长文本转换为音频",
     icon: LongTextTtsIcon,
     comp: defineAsyncComponent(() => import("./LongTextTtsNode.vue")),
     inputFields: [