mediac 1.7.5 → 1.7.6

package/cmd/cmd_ffmpeg.js

@@ -8,37 +8,34 @@
 import chalk from 'chalk'
 import dayjs from 'dayjs'
 import { execa } from 'execa'
-import { fileTypeFromFile } from 'file-type'
 import fs from 'fs-extra'
 import iconv from "iconv-lite"
 import inquirer from "inquirer"
 import mm from 'music-metadata'
 import { cpus } from "os"
 import pMap from 'p-map'
-import path, { format } from "path"
+import path from "path"
 import which from "which"
 import * as core from '../lib/core.js'
 import { asyncFilter, formatArgs } from '../lib/core.js'
 import * as log from '../lib/debug.js'
 import * as enc from '../lib/encoding.js'
+import presets from '../lib/ffmpeg_presets.js'
 import { getMediaInfo } from '../lib/ffprobe.js'
 import * as mf from '../lib/file.js'
 import * as helper from '../lib/helper.js'
-import { applyFileNameRules } from './cmd_shared.js'
+import { FFMPEG_BINARY } from '../lib/shared.js'
+import { addEntryProps, applyFileNameRules } from './cmd_shared.js'
 
 const LOG_TAG = "FFConv"
-
-const PRESET_NAMES = []
-const PRESET_MAP = new Map()
-
 // ===========================================
 // 命令内容执行
 // ===========================================
 
 
 export { aliases, builder, command, describe, handler }
-
-const command = "ffmpeg <input> [options]"
+// directories 表示额外输入文件，用于支持多个目录
+const command = "ffmpeg <input> [directories...]"
 const aliases = ["transcode", "aconv", "vconv", "avconv"]
 const describe = 'convert audio or video files using ffmpeg.'
 
@@ -55,12 +52,17 @@ const builder = function addOptions(ya, helpOrVersionSet) {
             describe: "Folder store ouput files",
             type: "string",
         })
+        // 复杂字符串参数，单独解析
+        .option("params", {
+            describe: "complex combined string parameters for parse",
+            type: "string",
+        })
         // 保持源文件目录结构
         .option("output-tree", {
             alias: 'otree',
             describe: "keep folder tree structure in output folder",
             type: "boolean",
-            default: false,
+            default: true,
         })
         // 正则，包含文件名规则
         .option("include", {
@@ -70,17 +72,18 @@ const builder = function addOptions(ya, helpOrVersionSet) {
         })
         //字符串或正则，不包含文件名规则
         // 如果是正则的话需要转义
-        // 默认排除 [SHANA] 开头的文件
+        // 默认排除含shana的文件和.m4a文件
         .option("exclude", {
             alias: "E",
             type: "string",
-            default: '[SHANA]',
+            default: 'shana|.m4a',
             description: "filename exclude pattern ",
         })
-        // 默认使用字符串模式，可启用正则模式
+        // 默认启用正则模式，禁用则为字符串模式
         .option("regex", {
             alias: 're',
             type: "boolean",
+            default: true,
             description: "match filenames by regex pattern",
         })
         // 需要处理的扩展名列表，默认为常见视频文件
@@ -92,7 +95,7 @@ const builder = function addOptions(ya, helpOrVersionSet) {
         // 选择预设，从预设列表中选一个，预设等于一堆预定义参数
         .option("preset", {
             type: "choices",
-            choices: PRESET_NAMES,
+            choices: presets.getAllNames(),
             default: 'hevc_2k',
             describe: "convert preset args for ffmpeg command",
         })
@@ -130,10 +133,17 @@ const builder = function addOptions(ya, helpOrVersionSet) {
             default: 0,
             describe: "chang max side for video",
         })
+        // 视频帧率，FPS
+        .option("fps", {
+            alias: 'framerate',
+            type: "number",
+            default: 0,
+            describe: "output framerate value",
+        })
         // 视频加速减速，默认不改动，范围0.25-4.0
         .option("speed", {
             type: "number",
-            default: 1,
+            default: 0,
             describe: "chang speed for video and audio",
         })
         // 视频选项
@@ -198,6 +208,12 @@ const builder = function addOptions(ya, helpOrVersionSet) {
             describe: "Write error logs to file [json or text]",
             type: "string",
         })
+        // 硬件加速方式
+        .option("hwaccel", {
+            alias: "hw",
+            describe: "hardware acceleration for video decode and encode",
+            type: "string",
+        })
         // 并行操作限制，并发数，默认为 CPU 核心数
         .option("jobs", {
             alias: "j",
@@ -213,13 +229,14 @@ const builder = function addOptions(ya, helpOrVersionSet) {
         })
 }
 
+//todo 实现一种更方便的传参数的方法，比如逗号分割 -preset ab=128,aq=3,ac=aac,ap=aac_he;vb=1536,vq=23,vc=hevc_nvenc,vs=1280*720,vw=1280,vh=720;vf=xxx,cf=xxx,
 
 const handler = cmdConvert
 
 async function cmdConvert(argv) {
     // 显示预设列表
     if (argv.showPresets) {
-        for (const [key, value] of PRESET_MAP) {
+        for (const [key, value] of presets.getAllPresets()) {
             log.show(key, core.pickTrueValues(value))
         }
         return
@@ -240,14 +257,31 @@ async function cmdConvert(argv) {
         log.fileLog(`Preset: ${JSON.stringify(preset)}`, 'FFConv')
     }
     // 首先找到所有的视频和音频文件
-    let fileEntries = await mf.walk(root, {
+    const walkOpts = {
         withFiles: true,
         needStats: true,
         entryFilter: (e) => e.isFile && helper.isMediaFile(e.name)
-    })
+    }
+    let fileEntries = await mf.walk(root, walkOpts)
+    // 处理额外目录参数
+    if (argv.directories?.length > 0) {
+        const extraDirs = new Set(argv.directories.map(d => path.resolve(d)))
+        for (const dirPath of extraDirs) {
+            const st = await fs.stat(dirPath)
+            if (st.isDirectory()) {
+                const dirFiles = await mf.walk(dirPath, walkOpts)
+                if (dirFiles.length > 0) {
+                    log.show(logTag, `Add ${dirFiles.length} extra files from ${dirPath}`)
+                    fileEntries = fileEntries.concat(dirFiles)
+                }
+            }
+        }
+    }
+    // 根据完整路径去重
+    fileEntries = core.uniqueByFields(fileEntries, 'path')
     log.show(logTag, `Total ${fileEntries.length} files found [${preset.name}] (${helper.humanTime(startMs)})`)
     // 再根据preset过滤找到的文件
-    if (preset.type === 'video' || preset.name === PRESET_AUDIO_EXTRACT.name) {
+    if (preset.type === 'video' || presets.isAudioExtract(preset)) {
         // 视频转换模式，保留视频文件
         // 提取音频模式，保留视频文件
         fileEntries = fileEntries.filter(e => helper.isVideoFile(e.name))
@@ -259,7 +293,7 @@ async function cmdConvert(argv) {
     // 应用文件名过滤规则
     fileEntries = await applyFileNameRules(fileEntries, argv)
     // 提取音频时不判断文件名
-    if (!preset.name === PRESET_AUDIO_EXTRACT.name) {
+    if (!presets.isAudioExtract(preset)) {
         // 过滤掉压缩过的文件 关键词 shana tmp m4a 
         fileEntries = fileEntries.filter(entry => !/tmp|\.m4a/i.test(entry.name))
     }
@@ -285,14 +319,15 @@ async function cmdConvert(argv) {
         }
     }
     startMs = Date.now()
-    fileEntries = fileEntries.map((f, i) => {
+    addEntryProps(fileEntries)
+    fileEntries = fileEntries.map((entry, index) => {
         return {
-            ...f,
+            ...entry,
             argv,
             preset,
-            startMs: startMs,
-            index: i,
-            total: fileEntries.length,
+            // startMs: startMs,
+            // index: index,
+            // total: fileEntries.length,
             errorFile: argv.errorFile,
             testMode: testMode
         }
@@ -348,11 +383,7 @@ async function cmdConvert(argv) {
     }
     // 记录开始时间
     startMs = Date.now()
-    tasks.forEach((t, i) => {
-        t.startMs = startMs
-        t.index = i
-        t.total = tasks.length
-    })
+    addEntryProps(tasks)
     // 先写入一次LOG
     await log.flushFileLog()
     // 并发数视频1，音频4，或者参数指定
@@ -368,25 +399,25 @@ function fixEncoding(str = '') {
 }
 
 async function runFFmpegCmd(entry) {
-    const ipx = `${entry.index}/${entry.total}`
+    const ipx = `${entry.index + 1}/${entry.total}`
     const logTag = chalk.green('FFCMD')
     const ffmpegArgs = entry.ffmpegArgs
 
-    log.show(logTag, `(${ipx}) Processing ${helper.pathShort(entry.path, 72)}`, helper.humanTime(entry.startMs))
+    log.show(logTag, `${ipx} Processing ${helper.pathShort(entry.path, 72)}`, helper.humanSize(entry.size), chalk.yellow(getDurationInfo(entry)), helper.humanTime(entry.startMs))
     log.showGray(logTag, getEntryShowInfo(entry), chalk.yellow(entry.preset.name), helper.humanSize(entry.size))
 
-
     log.showGray(logTag, 'ffmpeg', createFFmpegArgs(entry, true).join(' '))
-    const exePath = await which("ffmpeg")
+    const exePath = await which(FFMPEG_BINARY)
     if (entry.testMode) {
         // 测试模式跳过
-        log.show(logTag, `(${ipx}) Skipped ${entry.path} (${helper.humanSize(entry.size)}) [TestMode]`)
+        log.show(logTag, `${ipx} Skipped ${entry.path} (${helper.humanSize(entry.size)}) [TestMode]`)
         return
     }
 
     // 创建输出目录
     await fs.mkdirp(entry.fileDstDir)
     await fs.remove(entry.fileDstTemp)
+    const ffmpegStartMs = Date.now()
     try {
         // https://2ality.com/2022/07/nodejs-child-process.html
         // Windows下 { shell: true } 必须，否则报错
@@ -396,22 +427,27 @@ async function runFFmpegCmd(entry) {
         const { stdout, stderr } = await ffmpegProcess
         // const stdoutFixed = fixEncoding(stdout || "")
         // const stderrFixed = fixEncoding(stderr || "")
+        if (await fs.pathExists(entry.fileDst)) {
+            log.showYellow(logTag, `${ipx} DstExists ${entry.fileDst}`, helper.humanSize(entry.size), chalk.yellow(entry.preset.name), helper.humanTime(ffmpegStartMs))
+            await fs.remove(entry.fileDstTemp)
+            return
+        }
         if (await fs.pathExists(entry.fileDstTemp)) {
             const dstSize = (await fs.stat(entry.fileDstTemp))?.size || 0
             if (dstSize > 20 * mf.FILE_SIZE_1K) {
                 await fs.move(entry.fileDstTemp, entry.fileDst)
-                log.showGreen(logTag, `(${ipx}) Done ${entry.fileDst}`, helper.humanSize(entry.size), chalk.cyan(`${Math.round(entry.srcAudioBitrate / 1024)}k:${Math.round(entry.srcVideoBitrate / 1024)}k`), chalk.yellow(entry.preset.name), helper.humanTime(entry.startMs))
-                log.fileLog(`(${ipx}) Done <${entry.fileDst}> [${entry.preset.name}] (${helper.humanSize(dstSize)})`, 'FFCMD')
+                log.showGreen(logTag, `${ipx} Done ${entry.fileDst}`, chalk.cyan(`${helper.humanSize(entry.size)}=>${helper.humanSize(dstSize)}`), chalk.yellow(entry.preset.name), helper.humanTime(ffmpegStartMs))
+                log.fileLog(`${ipx} Done <${entry.fileDst}> [${entry.preset.name}] (${helper.humanSize(dstSize)})`, 'FFCMD')
                 entry.ok = true
                 return entry
             } else {
                 // 转换失败，删除临时文件
             }
         }
-        log.showYellow(logTag, `Failed(${ipx}) ${entry.path}`, entry.preset.name, helper.humanSize(dstSize))
-        log.fileLog(`Failed(${ipx}) <${entry.path}> [${entry.dstAudioBitrate || entry.preset.name}]`, 'FFCMD')
+        log.showYellow(logTag, `${ipx} Failed ${entry.path}`, entry.preset.name, helper.humanSize(dstSize))
+        log.fileLog(`${ipx} Failed <${entry.path}> [${entry.dstAudioBitrate || entry.preset.name}]`, 'FFCMD')
     } catch (error) {
-        const errMsg = error.stderr || error.message?.substring(0, 240) || '[ERROR]'
+        const errMsg = (error.stderr || error.message || '[Unknown]').substring(0, 240)
         log.showRed(logTag, `Error(${ipx}) ${errMsg}`)
         log.fileLog(`Error(${ipx}) <${entry.path}> [${entry.preset.name}] ${errMsg}`, 'FFCMD')
         await writeErrorFile(entry, error)
@@ -440,7 +476,7 @@ async function writeErrorFile(entry, error) {
 
 async function prepareFFmpegCmd(entry) {
     const logTag = chalk.green('Prepare')
-    const ipx = `${entry.index}/${entry.total}`
+    const ipx = `${entry.index + 1}/${entry.total}`
     log.info(logTag, `Processing(${ipx}) file: ${entry.path}`)
     const isAudio = helper.isAudioFile(entry.path)
     const [srcDir, srcBase, srcExt] = helper.pathSplit(entry.path)
@@ -449,9 +485,9 @@ async function prepareFFmpegCmd(entry) {
     const dstExt = preset.format || srcExt
     let fileDstDir
     // 命令行参数指定输出目录
-    if (preset.output) {
+    if (argv.output) {
         // 默认true 保留目录结构，可以防止文件名冲突
-        if (argv.ouputTree) {
+        if (argv.outputTree) {
             // 如果要保持源文件目录结构
             fileDstDir = helper.pathRewrite(srcDir, preset.output)
         } else {
@@ -462,25 +498,25 @@ async function prepareFFmpegCmd(entry) {
         // 如果没有指定输出目录，直接输出在原文件同目录
         fileDstDir = path.resolve(srcDir)
     }
-    if (isAudio || preset.name === PRESET_AUDIO_EXTRACT.name) {
+    if (isAudio || presets.isAudioExtract(preset)) {
         // 不带后缀只改扩展名的m4a文件，如果存在也需要首先忽略
         // 可能是其它压缩工具生成的文件，不需要重复压缩
         // 检查输出目录
-        const fileDstNoSuffix = path.join(fileDstDir, `${srcBase}${dstExt}`)
-        if (await fs.pathExists(fileDstNoSuffix)) {
-            log.info(
-                logTag,
-                `(${ipx}) Skip[DstOut]: ${helper.pathShort(entry.path)} (${helper.humanSize(entry.size)})`)
-            return false
-        }
+        // const fileDstNoSuffix = path.join(fileDstDir, `${srcBase}${dstExt}`)
+        // if (await fs.pathExists(fileDstNoSuffix)) {
+        //     log.info(
+        //         logTag,
+        //         `${ipx} Skip[DstM4A]: ${helper.pathShort(entry.path)} (${helper.humanSize(entry.size)})`)
+        //     return false
+        // }
         // 检查源文件同目录
-        const fileDstSameDirNoSuffix = path.join(srcDir, `${srcBase}${dstExt}`)
-        if (await fs.pathExists(fileDstSameDirNoSuffix)) {
-            log.info(
-                logTag,
-                `(${ipx}) Skip[DstSame]: ${helper.pathShort(entry.path)} (${helper.humanSize(entry.size)})`)
-            return false
-        }
+        // const fileDstSameDirNoSuffix = path.join(srcDir, `${srcBase}${dstExt}`)
+        // if (await fs.pathExists(fileDstSameDirNoSuffix)) {
+        //     log.info(
+        //         logTag,
+        //         `${ipx} Skip[DstSame]: ${helper.pathShort(entry.path)} (${helper.humanSize(entry.size)})`)
+        //     return false
+        // }
     }
     try {
         // 使用ffprobe读取媒体信息，速度较慢
@@ -489,8 +525,8 @@ async function prepareFFmpegCmd(entry) {
 
         // ffprobe无法读取时长和比特率，可以认为文件损坏，或不支持的格式，跳过
         if (!(entry.info?.format?.duration || entry.info?.format?.bit_rate)) {
-            log.showYellow('Prepare', `(${ipx}) Skip[Corrupted]: ${entry.path} (${helper.humanSize(entry.size)})`)
-            log.fileLog(`(${ipx}) Skip[Corrupted]: <${entry.path}> (${helper.humanSize(entry.size)})`, 'Prepare')
+            log.showYellow(logTag, `${ipx} Skip[Corrupted]: ${entry.path} (${helper.humanSize(entry.size)})`)
+            log.fileLog(`${ipx} Skip[Corrupted]: <${entry.path}> (${helper.humanSize(entry.size)})`, 'Prepare')
             return false
         }
         const audioCodec = entry.info?.audio?.codec_name
@@ -508,8 +544,8 @@ async function prepareFFmpegCmd(entry) {
                 // 可以读取码率，文件未损坏
             } else {
                 // 如果无法获取元数据，认为不是合法的音频或视频文件，忽略
-                log.showYellow('Prepare', `(${ipx}) Skip[Invalid]: ${entry.path} (${helper.humanSize(entry.size)})`)
-                log.fileLog(`(${ipx}) Skip[Invalid]: <${entry.path}> (${helper.humanSize(entry.size)})`, 'Prepare')
+                log.showYellow(logTag, `${ipx} Skip[Invalid]: ${entry.path} (${helper.humanSize(entry.size)})`)
+                log.fileLog(`${ipx} Skip[Invalid]: <${entry.path}> (${helper.humanSize(entry.size)})`, 'Prepare')
                 return false
             }
         }
@@ -523,14 +559,14 @@ async function prepareFFmpegCmd(entry) {
         log.info(logTag, entry.path, mediaBitrate)
         // 如果转换目标是音频，但是源文件不含音频流，忽略
         if (entry.preset.type === 'audio' && !audioCodec) {
-            log.showYellow('Prepare', `(${ipx}) Skip[NoAudio]: ${entry.path}`, getEntryShowInfo(entry), helper.humanSize(entry.size))
-            log.fileLog(`(${ipx}) Skip[NoAudio]: <${entry.path}> (${helper.humanSize(entry.size)})`, 'Prepare')
+            log.showYellow(logTag, `${ipx} Skip[NoAudio]: ${entry.path}`, getEntryShowInfo(entry), helper.humanSize(entry.size))
+            log.fileLog(`${ipx} Skip[NoAudio]: <${entry.path}> (${helper.humanSize(entry.size)})`, 'Prepare')
             return false
         }
         // 如果转换目标是视频，但是源文件不含视频流，忽略
         if (entry.preset.type === 'video' && !videoCodec) {
-            log.showYellow('Prepare', `(${ipx}) Skip[NoVideo]: ${entry.path}`, getEntryShowInfo(entry), helper.humanSize(entry.size))
-            log.fileLog(`(${ipx}) Skip[NoVideo]: <${entry.path}> (${helper.humanSize(entry.size)})`, 'Prepare')
+            log.showYellow(logTag, `${ipx} Skip[NoVideo]: ${entry.path}`, getEntryShowInfo(entry), helper.humanSize(entry.size))
+            log.fileLog(`${ipx} Skip[NoVideo]: <${entry.path}> (${helper.humanSize(entry.size)})`, 'Prepare')
             return false
         }
         // 输出文件名基本名，含前后缀，不含扩展名
@@ -545,21 +581,21 @@ async function prepareFFmpegCmd(entry) {
         if (await fs.pathExists(fileDst)) {
             log.info(
                 logTag,
-                `(${ipx}) Skip[Dst1]: ${helper.pathShort(entry.path)} (${helper.humanSize(entry.size)})`)
+                `${ipx} Skip[Dst1]: ${helper.pathShort(entry.path)} (${helper.humanSize(entry.size)})`)
             return false
         }
         if (await fs.pathExists(fileDstSameDir)) {
             log.info(
                 logTag,
-                `(${ipx}) Skip[Dst2]: ${helper.pathShort(entry.path)} (${helper.humanSize(entry.size)})`)
+                `${ipx} Skip[Dst2]: ${helper.pathShort(entry.path)} (${helper.humanSize(entry.size)})`)
             return false
         }
         if (await fs.pathExists(fileDstTemp)) {
             await fs.remove(fileDstTemp)
         }
-        log.show(logTag, `(${ipx}) Task ${helper.pathShort(entry.path, 72)}`, helper.humanTime(entry.startMs))
-        log.showGray(logTag, getEntryShowInfo(entry), chalk.yellow(entry.preset.name), helper.humanSize(entry.size))
-        log.info(logTag, `(${ipx}) Task DST:${fileDst}`)
+        log.show(logTag, `${ipx} TaskSRC: ${helper.pathShort(entry.path, 72)}`, helper.humanTime(entry.startMs))
+        log.info(logTag, `${ipx} TaskDST:`, `${fileDst}`)
+        log.showGray(logTag, `${ipx} Streams:`, getEntryShowInfo(entry), chalk.yellow(entry.preset.name), helper.humanSize(entry.size))
         // log.show(logTag, `Entry(${ipx})`, entry)
         const newEntry = {
             ...entry,
@@ -572,7 +608,7 @@ async function prepareFFmpegCmd(entry) {
         // log.info(logTag, 'ffmpeg', ffmpegArgs.join(' '))
         return newEntry
     } catch (error) {
-        log.warn(logTag, `(${ipx}) Skip[Error]: ${entry.path}`, error)
+        log.warn(logTag, `${ipx} Skip[Error]: ${entry.path}`, error)
     }
 }
 
@@ -605,12 +641,17 @@ function getEntryShowInfo(entry) {
     const duration = entry?.info?.audio?.duration
         || entry?.info?.video?.duration
         || entry?.info?.format?.duration || 0
+    const fps = entry.info?.video?.r_frame_rate || 0
     const showInfo = []
     if (ac) showInfo.push(`audio|${ac}|${Math.round(entry.srcAudioBitrate / 1024)}K=>${getBestAudioBitrate(entry)}K|${helper.humanDuration(duration * 1000)}`)
-    if (vc) showInfo.push(`video|${vc}|${Math.round(entry.srcVideoBitrate / 1024)}K=>${getBestVideoBitrate(entry)}K|${helper.humanDuration(duration * 1000)}`,)
+    if (vc) showInfo.push(`video|${vc}|${Math.round(entry.srcVideoBitrate / 1024)}K=>${getBestVideoBitrate(entry)}K|${helper.humanDuration(duration * 1000)}|${fps}`,)
     return showInfo.join(', ')
 }
 
+function getDurationInfo(entry) {
+    return helper.humanDuration((entry?.info?.audio?.duration || entry?.info?.video?.duration || entry?.info?.format?.duration || 0) * 1000)
+}
+
 // 读取单个音频文件的元数据
 async function readMusicMeta(entry) {
     try {
@@ -648,9 +689,11 @@ function calculateBitrate(entry) {
     // 这个是文件整体码率，如果是是视频文件，等于是视频和音频的码率相加
     const fileBitrate = entry.info?.format?.bit_rate || 0
     let srcAudioBitrate = 0
+    let dstAudioBitrate = 0
     let srcVideoBitrate = 0
     let dstVideoBitrate = 0
     if (helper.isAudioFile(entry.path)) {
+        // 对于音频文件，音频格式转换
         if (entry.format?.lossless || helper.isAudioLossless(entry.path)) {
             // 无损音频，设置默认值
             srcAudioBitrate = srcAudioBitrate > 320 ? srcAudioBitrate : 999 * 1024
@@ -659,25 +702,35 @@ function calculateBitrate(entry) {
         srcAudioBitrate = entry.format?.bitrate
             || entry.info?.audio?.bit_rate
             || fileBitrate || 0
+        // 有的文件无法获取音频码率，如opus，此时srcAudioBitrate=0
+        // opus用于极低码率音频，此时 dstAudioBitrate=48 可以接受
+        dstAudioBitrate = bitrateMap.find(br => srcAudioBitrate > br.threshold)?.value || 48
+        // 忽略计算结果，直接使用预设数值
+        if (!entry.preset.smartBitrate) {
+            dstAudioBitrate = entry.preset.audioBitrate
+        }
     } else {
-        // video file
+        // 对于视频文件
+        // 计算码率原则
+        // 计算出的音频码率不高于源文件的音频码率
+        // 计算出的音频码率不高于预设指定的码率
         srcAudioBitrate = entry.info?.audio?.bit_rate || 0
+        dstAudioBitrate = Math.min(Math.round(srcAudioBitrate / 1024), entry.preset.audioBitrate)
+
+        // 计算出的视频码率不高于源文件的视频码率
         // 减去音频的码率，估算为48k
         srcVideoBitrate = entry.info?.video?.bit_rate
             || fileBitrate - 48 * 1024 || 0
         // 压缩后的视频比特率不能高于源文件比特率
-        if (entry.preset.videoBitrate * 1024 > srcVideoBitrate) {
-            dstVideoBitrate = Math.round(srcVideoBitrate / 1024)
-        } else {
+        dstVideoBitrate = Math.min(Math.round(srcVideoBitrate / 1024), entry.preset.videoBitrate)
+        // 忽略计算结果，直接使用预设数值
+        if (!entry.preset.smartBitrate) {
+            dstAudioBitrate = entry.preset.audioBitrate
             dstVideoBitrate = entry.preset.videoBitrate
         }
     }
-    // 有的文件无法获取音频码率，如opus，此时srcAudioBitrate=0
-    // opus用于极低码率音频，此时 dstAudioBitrate=48 可以接受
-    const dstAudioBitrate = bitrateMap.find(br => srcAudioBitrate > br.threshold)?.value || 48
-    const result = { srcAudioBitrate, dstAudioBitrate, srcVideoBitrate, dstVideoBitrate }
-    // log.showRed(entry.path, result)
-    return result
+
+    return { srcAudioBitrate, dstAudioBitrate, srcVideoBitrate, dstVideoBitrate }
 }
 
 // 选择最佳视频码率
@@ -716,10 +769,46 @@ function getBestAudioQuality(entry) {
 // 此函数仅读取参数，不修改preset对象
 function createFFmpegArgs(entry, forDisplay = false) {
     const preset = entry.preset
+    // 用于模板字符串的模板参数，针对当前文件
+    const entryPreset = {
+        ...preset,
+        // 这几个会覆盖preset的预设数值
+        videoBitrate: getBestVideoBitrate(entry),
+        videoQuality: getBestVideoQuality(entry),
+        audioBitrate: getBestAudioBitrate(entry),
+        audioQuality: getBestAudioQuality(entry),
+        // 下面的是源文件参数
+        srcAudioBitrate: entry.srcAudioBitrate,
+        srcVideoBitrate: entry.srcVideoBitrate,
+        srcWidth: entry.info.video?.width || 0,
+        srcHeight: entry.info.video?.height || 0,
+        srcFrameRate: entry.info.video?.r_frame_rate || 0,
+        srcDuration: entry.info.format?.duration || 0,
+        srcSize: entry.info.format?.size || 0,
+        srcVideoCodec: entry.info.video?.codec_name,
+        srcAudioCodec: entry.info.audio?.codec_name,
+        srcFormat: entry.info.format?.format_name,
+    }
+    // 几种ffmpeg参数设置的时间和功耗
+    // ffmpeg -hide_banner -n -v error -stats -i 
+    // 32s 110w
+    // ffmpeg -hide_banner -n -v error -stats -hwaccel auto -i
+    // 34s 56w
+    // ffmpeg -hide_banner -n -v error -stats  -hwaccel d3d11va -hwaccel_output_format d3d11 
+    // 27s 45w rm格式死机蓝屏
+    // ffmpeg -hide_banner -n -v error -stats -hwaccel cuda -hwaccel_output_format cuda 
+    // 27s 41w
+    // ffmpeg -hide_banner -n -v error -stats -hwaccel cuda -i
+    // 31s 60w
     // 显示详细信息
     // let args = "-hide_banner -n -loglevel repeat+level+info -stats".split(" ")
     // 只显示进度和错误
-    let args = "-hide_banner -n -v error -stats".split(" ")
+    let args = "-hide_banner -n -v error".split(" ")
+    // 输出视频时才需要cuda加速，音频用cpu就行
+    if (preset.type === 'video') {
+        // -hwaccel cuda -hwaccel_output_format cuda
+        args = args.concat(["-stats", "-hwaccel", "cuda", "-hwaccel_output_format", "cuda"])
+    }
     // 输入参数在输入文件前面，顺序重要
     if (preset.inputArgs?.length > 0) {
         args = args.concat(this.preset.inputArgs.split(' '))
@@ -732,16 +821,13 @@ function createFFmpegArgs(entry, forDisplay = false) {
     if (preset.complexFilter?.length > 0) {
         args.push('-filter_complex')
         args.push(`"${formatArgs(preset.complexFilter, preset)}"`)
-    } else if (preset.filters?.length > 0) {
+    } else if (preset.filters.length > 0) {
         args.push('-vf')
         args.push(formatArgs(preset.filters, preset))
     }
+
     if (preset.videoArgs?.length > 0) {
-        const va = formatArgs(preset.videoArgs, {
-            ...preset,
-            videoBitrate: getBestVideoBitrate(entry),
-            videoQuality: getBestVideoQuality(entry)
-        })
+        const va = formatArgs(preset.videoArgs, entryPreset)
         args = args.concat(va.split(' '))
     }
     if (preset.audioArgs?.length > 0) {
@@ -750,7 +836,7 @@ function createFFmpegArgs(entry, forDisplay = false) {
         // audioArgsCopy: '-c:a copy',
         // audioArgsEncode: '-c:a libfdk_aac -b:a {audioBitrate}k',
         let audioArgsFixed = preset.audioArgs
-        if (preset.name === PRESET_AUDIO_EXTRACT.name) {
+        if (presets.isAudioExtract(preset)) {
             if (entry.info?.audio?.codec_name === 'aac') {
                 audioArgsFixed = '-c:a copy'
             } else {
@@ -759,11 +845,7 @@ function createFFmpegArgs(entry, forDisplay = false) {
         } else {
             audioArgsFixed = preset.audioArgs
         }
-        const aa = formatArgs(audioArgsFixed, {
-            ...preset,
-            audioBitrate: getBestAudioBitrate(entry),
-            audioQuality: getBestAudioQuality(entry)
-        })
+        const aa = formatArgs(audioArgsFixed, entryPreset)
         args = args.concat(aa.split(' '))
     }
     // 在输入文件后面
@@ -775,18 +857,21 @@ function createFFmpegArgs(entry, forDisplay = false) {
     let extraArgsArray = []
     // 添加自定义metadata字段
     //description, comment, copyright
+
     extraArgsArray.push(`-metadata`, `description="encoder=mediac-ffmpeg"`)
     extraArgsArray.push(`-metadata`, `copyright="name=${entry.name}"`)
-    extraArgsArray.push(`-metadata`, `comment="preset=${preset.name},vargs=${formatArgs(preset.videoArgs, preset)},aargs=${formatArgs(preset.audioArgs, preset)}"`)
+    extraArgsArray.push(`-metadata`, `comment="preset=${preset.name},vargs=${formatArgs(preset.videoArgs, entryPreset)},aargs=${formatArgs(preset.audioArgs, entryPreset)}"`)
     // 检查源文件元数据
     if (entry.tags?.title) {
         const KEY_LIST = ['title', 'artist', 'album', 'albumartist', 'year']
         // 验证 非空值，无乱码，值为字符串或数字
         const validTags = core.filterFields(entry.tags, (key, value) => {
             return KEY_LIST.includes(key)
-                && !enc.hasBadCJKChar(value)
+                && Boolean(value)
                 && ((typeof value === 'string' && value.length > 0)
                     || typeof value === 'number')
+                && !enc.hasBadCJKChar(value)
+                && !enc.hasBadUnicode(value)
         })
         extraArgsArray = extraArgsArray.concat(...Object.entries(validTags)
             .map(([key, value]) => [`-metadata`, `${key}="${value}"`]))
@@ -812,242 +897,12 @@ function createFFmpegArgs(entry, forDisplay = false) {
     return args
 }
 
-// ===========================================
-// 数据类定义
-// ===========================================
-
-// ffmpeg命令参数预设类
-class Preset {
-    constructor(name, {
-        format,
-        type,
-        prefix,
-        suffix,
-        videoArgs,
-        audioArgs,
-        inputArgs,
-        streamArgs,
-        extraArgs,
-        outputArgs,
-        filters,
-        complexFilter,
-        output,
-        videoBitrate = 0,
-        videoQuality = 0,
-        audioBitrate = 0,
-        audioQuality = 0,
-        dimension = 0,
-        speed = 1
-    } = {}) {
-        this.name = name
-        this.format = format
-        this.type = type
-        this.prefix = prefix
-        this.suffix = suffix
-        this.videoArgs = videoArgs
-        this.audioArgs = audioArgs
-        this.inputArgs = inputArgs
-        this.streamArgs = streamArgs
-        this.extraArgs = extraArgs
-        this.outputArgs = outputArgs
-        this.filters = filters
-        this.complexFilter = complexFilter
-        // 输出目录
-        this.output = output
-        // 视频码率和质量
-        this.videoBitrate = videoBitrate
-        this.videoQuality = videoQuality
-        // 音频码率和质量
-        this.audioBitrate = audioBitrate
-        this.audioQuality = audioQuality
-        // 视频尺寸
-        this.dimension = dimension
-        // 视频加速
-        this.speed = speed
-        // 元数据参数
-        // 用户从命令行设定的参数
-        // 优先级最高
-        this.userVideoBitrate = 0
-        this.userVideoQuality = 0
-        this.userAudioBitrate = 0
-        this.userAudioQuality = 0
-    }
-
-    update(source) {
-        for (const key in source) {
-            this[key] = source[key]
-        }
-        return this
-    }
-
-    // 构造函数，参数为另一个 Preset 对象
-    static fromPreset(preset) {
-        return new Preset(preset.name, preset)
-    }
-
-}
-
-// videoArgs = { args,codec,quality,bitrate,filters}
-// audioOptons = {args,codec, quality,bitrate,filters} 
-// audioArgs = {prefix,suffix}
-
-// HEVC基础参数
-const HEVC_BASE = new Preset('hevc-base', {
-    format: '.mp4',
-    type: 'video',
-    intro: 'hevc|hevc_nvenc|libfdk_aac',
-    prefix: '[SHANA] ',
-    suffix: '_{preset}_{videoBitrate}k',
-    description: 'HEVC_BASE',
-    // 视频参数说明
-    // video_codec block '-c:v hevc_nvenc -profile:v main -tune:v hq'
-    // video_quality block '-cq {quality} -bufsize {bitrate} -maxrate {bitrate}'
-    videoArgs: '-c:v hevc_nvenc -profile:v main -tune:v hq -cq {videoQuality} -bufsize {videoBitrate}k -maxrate {videoBitrate}k',
-    // 音频参数说明
-    // audio_codec block '-c:a libfdk_aac'
-    // audio_quality block '-b:a {bitrate}'
-    audioArgs: '-c:a libfdk_aac -b:a {audioBitrate}k',
-    inputArgs: '',
-    streamArgs: '-map_metadata 0 -map_metadata:s:v 0:s:v',
-    // 快速读取和播放
-    outputArgs: '-movflags +faststart -movflags use_metadata_tags',
-    filters: "scale='if(gte(iw,ih),min({dimension},iw),-2)':'if(lt(iw,ih),min({dimension},ih),-2)'",
-    complexFilter: '',
-})
-
-// 音频AAC基础参数
-const AAC_BASE = new Preset('aac_base', {
-    format: '.m4a',
-    type: 'audio',
-    intro: 'aac|libfdk_aac',
-    prefix: '',
-    suffix: '_{preset}_{audioBitrate}k',
-    description: 'AAC_BASE',
-    videoArgs: '',
-    // 音频参数说明
-    // audio_codec block '-c:a libfdk_aac'
-    // audio_quality block '-b:a {bitrate}'
-    audioArgs: '-map 0:a -c:a libfdk_aac -b:a {audioBitrate}k',
-    inputArgs: '',
-    streamArgs: '-map_metadata 0 -map_metadata:s:a 0:s:a',
-    outputArgs: '-movflags +faststart -movflags use_metadata_tags',
-})
-
-
-const PRESET_AUDIO_EXTRACT = Preset.fromPreset(AAC_BASE).update({
-    name: 'audio_extract',
-    intro: 'aac|extract',
-    audioArgs: '-c:a copy',
-    streamArgs: '-vn -map 0:a:0 -map_metadata 0 -map_metadata:s:a 0:s:a'
-})
-
-function initializePresets() {
-
-    const PRESET_HEVC_ULTRA = Preset.fromPreset(HEVC_BASE).update({
-        name: 'hevc_ultra',
-        videoQuality: 20,
-        videoBitrate: 20480,
-        audioBitrate: 320,
-        dimension: 3840
-    })
-
-    const PRESET_HEVC_4K = Preset.fromPreset(HEVC_BASE).update({
-        name: 'hevc_4k',
-        videoQuality: 22,
-        videoBitrate: 10240,
-        audioBitrate: 256,
-        dimension: 3840
-    })
-
-    const PRESET_HEVC_2K = Preset.fromPreset(HEVC_BASE).update({
-        name: 'hevc_2k',
-        videoQuality: 22,
-        videoBitrate: 4096,
-        audioBitrate: 192,
-        dimension: 1920
-    })
-
-    const PRESET_HEVC_MEDIUM = Preset.fromPreset(HEVC_BASE).update({
-        name: 'hevc_medium',
-        videoQuality: 24,
-        videoBitrate: 2048,
-        audioBitrate: 128,
-        dimension: 1920
-    })
-
-    const PRESET_HEVC_LOW = Preset.fromPreset(HEVC_BASE).update({
-        name: 'hevc_low',
-        videoQuality: 26,
-        videoBitrate: 1536,
-        audioBitrate: 96,
-        dimension: 1920
-    })
-
-    const PRESET_HEVC_LOWEST = Preset.fromPreset(HEVC_BASE).update({
-        name: 'hevc_lowest',
-        videoQuality: 26,
-        videoBitrate: 512,
-        audioBitrate: 48,
-        dimension: 1920,
-        streamArgs: '-map [v] -map [a]',
-        // 音频参数说明
-        // audio_codec block '-c:a libfdk_aac -profile:a aac_he'
-        // audio_quality block '-b:a 48k'
-        audioArgs: '-c:a libfdk_aac -profile:a aac_he -b:a {audioBitrate}k',
-        // filters 和 complexFilter 不能共存，此预设使用 complexFilter
-        filters: '',
-        // 这里单引号必须，否则逗号需要转义，Windows太多坑
-        complexFilter: "[0:v]setpts=PTS/{speed},scale='if(gt(iw,1280),min(1280,iw),-2)':'if(gt(ih,1280),min(1280,ih),-2)'[v];[0:a]atempo={speed}[a]"
-    })
-
-    const presets = {
-        //4K超高码率和质量
-        PRESET_HEVC_ULTRA: PRESET_HEVC_ULTRA,
-        //4k高码率和质量
-        PRESET_HEVC_4K: PRESET_HEVC_4K,
-        // 2K高码率和质量
-        PRESET_HEVC_2K: PRESET_HEVC_2K,
-        // 2K中码率和质量
-        PRESET_HEVC_MEDIUM: PRESET_HEVC_MEDIUM,
-        // 2K低码率和质量
-        PRESET_HEVC_LOW: PRESET_HEVC_LOW,
-        // 极低画质和码率，适用于教程类视频
-        PRESET_HEVC_LOWEST: PRESET_HEVC_LOWEST,
-        // 提取视频中的音频，复制或转换为AAC格式
-        PRESET_AUDIO_EXTRACT: PRESET_AUDIO_EXTRACT,
-        //音频AAC最高码率
-        PRESET_AAC_HIGH: Preset.fromPreset(AAC_BASE).update({
-            name: 'aac_high',
-            audioBitrate: 320,
-        }),
-        //音频AAC中码率
-        PRESET_AAC_MEDIUM: Preset.fromPreset(AAC_BASE).update({
-            name: 'aac_medium',
-            audioBitrate: 192,
-        }),
-        // 音频AAC低码率
-        PRESET_AAC_LOW: Preset.fromPreset(AAC_BASE).update({
-            name: 'aac_low',
-            audioBitrate: 128,
-        }),
-        // 音频AAC极低码率，适用人声
-        PRESET_AAC_VOICE: Preset.fromPreset(AAC_BASE).update({
-            name: 'aac_voice',
-            audioBitrate: 48,
-            audioArgs: '-c:a libfdk_aac -profile:a aac_he -b:a {audioBitrate}k',
-        })
-    }
-
-    core.modifyObjectWithKeyField(presets, 'description')
-    for (const [key, preset] of Object.entries(presets)) {
-        PRESET_NAMES.push(preset.name)
-        PRESET_MAP.set(preset.name, preset)
-    }
-}
-
 function preparePreset(argv) {
     // 参数中指定的preset
-    let preset = PRESET_MAP.get(argv.preset)
+    let preset = presets.getPreset(argv.preset)
+
+    // log.show('ARGV', argv)
+    // log.show('P1', preset)
     // 克隆对象，不修改Map中的内容
     preset = structuredClone(preset)
     // 保存argv方便调试
@@ -1084,6 +939,17 @@ function preparePreset(argv) {
     if (argv.speed > 0) {
         preset.speed = argv.speed
     }
+    // 视频帧率
+    if (argv.framerate > 0) {
+        preset.framerate = argv.framerate
+    }
+    if (preset.framerate > 0) {
+        if (preset.filters?.length > 0) {
+            preset.filters += ',fps={framerate}'
+        } else {
+            preset.filters = 'fps={framerate}'
+        }
+    }
     // 视频码率，用户指定，优先级最高
     if (argv.videoBitrate > 0) {
         preset.userVideoBitrate = argv.videoBitrate
@@ -1098,12 +964,6 @@ function preparePreset(argv) {
     if (argv.audioQuality > 0) {
         preset.userAudioQuality = argv.audioQuality
     }
-
+    // log.show('P2', preset)
     return preset
-}
-
-
-
-
-// 初始化调用
-initializePresets()
+}