mediac 1.8.0 → 1.8.2

package/cmd/cmd_compress.js

@@ -24,8 +24,8 @@ import * as core from '../lib/core.js'
 import * as log from '../lib/debug.js'
 import * as mf from '../lib/file.js'
 import * as helper from '../lib/helper.js'
-import tryfp from '../lib/tryfp.js'
-import { calculateScale, compressImage } from "./cmd_shared.js"
+import * as tryfp from '../lib/tryfp.js'
+import { compressImage } from "./cmd_shared.js"
 
 //
 export { aliases, builder, command, describe, handler }

package/cmd/cmd_ffmpeg.js

@@ -22,10 +22,9 @@ 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 { FFMPEG_BINARY } from '../lib/shared.js'
+import { getMediaInfo } from '../lib/mediainfo.js'
 import { addEntryProps, applyFileNameRules, calculateScale } from './cmd_shared.js'
 
 const LOG_TAG = "FFConv"
@@ -157,7 +156,7 @@ const builder = function addOptions(ya, helpOrVersionSet) {
         })
         // 视频选项，指定码率
         .option("video-bitrate", {
-            alias: "vbk",
+            alias: "vb",
             type: "number",
             default: 0,
             describe: "Set video bitrate (in kbytes) in ffmpeg command",
@@ -179,7 +178,7 @@ const builder = function addOptions(ya, helpOrVersionSet) {
         })
         // 音频选项，指定码率
         .option("audio-bitrate", {
-            alias: "abk",
+            alias: "ab",
             type: "number",
             default: 0,
             describe: "Set audio bitrate (in kbytes) in ffmpeg command",
@@ -356,8 +355,8 @@ async function cmdConvert(argv) {
             testMode: testMode
         }
     })
-    log.showYellow(logTag, 'ARGV:', core.pickTrueValues(argv))
-    log.showYellow(logTag, 'PRESET:', core.pickTrueValues(preset))
+    log.showYellow(logTag, 'ARGV:', argv)
+    log.showYellow(logTag, 'PRESET:', preset)
     const prepareAnswer = await inquirer.prompt([
         {
             type: 'confirm',
@@ -408,9 +407,9 @@ async function cmdConvert(argv) {
     const lastTask = tasks.slice(-1)[0]
     !testMode && log.fileLog(`ffmpegArgs:`, lastTask.ffmpegArgs.flat(), 'FFConv')
     log.show('-----------------------------------------------------------')
-    log.showYellow(logTag, 'PRESET:', core.pickTrueValues(lastTask.debugPreset))
+    log.showYellow(logTag, 'PRESET:', lastTask.debugPreset)
     log.showCyan(logTag, 'CMD: ffmpeg', lastTask.ffmpegArgs.flat().join(' '))
-    const totalDuration = tasks.reduce((acc, t) => acc + t.info?.format.duration || 0, 0)
+    const totalDuration = tasks.reduce((acc, t) => acc + t.info?.duration || 0, 0)
     log.show('-----------------------------------------------------------')
     testMode && log.showYellow('++++++++++ TEST MODE (DRY RUN) ++++++++++')
     log.showYellow(logTag, 'Please CHECK above details BEFORE continue!')
@@ -461,7 +460,7 @@ async function runFFmpegCmd(entry) {
     log.showGray(logTag, getEntryShowInfo(entry))
     log.showGray(logTag, `ffmpeg`, entry.ffmpegArgs.flat().join(' '))
     // }
-    const exePath = await which(FFMPEG_BINARY)
+    const exePath = await which('ffmpeg')
     if (entry.testMode) {
         // 测试模式跳过
         log.show(logTag, `${ipx} Skipped ${entry.path} (${helper.humanSize(entry.size)}) [TestMode]`)
@@ -563,39 +562,19 @@ async function prepareFFmpegCmd(entry) {
         // 如果没有指定输出目录，直接输出在原文件同目录
         fileDstDir = path.resolve(srcDir)
     }
-    if (isAudio || presets.isAudioExtract(preset)) {
-        // 不带后缀只改扩展名的m4a文件，如果存在也需要首先忽略
-        // 可能是其它压缩工具生成的文件，不需要重复压缩
-        // 检查输出目录
-        // 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
-        // }
-    }
     try {
         // 使用ffprobe读取媒体信息，速度较慢
-        // 注意flac和ape格式的stream里没有bit_rate字段 format里有
+        // 注意flac和ape格式的stream里没有bitrate字段 format里有
         entry.info = await getMediaInfo(entry.path, { audio: isAudio })
 
         // ffprobe无法读取时长和比特率，可以认为文件损坏，或不支持的格式，跳过
-        if (!(entry.info?.format?.duration && entry.info?.format?.bit_rate)) {
+        if (!(entry.info?.duration && entry.info?.bitrate)) {
             log.showYellow(logTag, `${ipx} Skip[BadFormat]: ${entry.path} (${helper.humanSize(entry.size)})`)
             log.fileLog(`${ipx} Skip[BadFormat]: <${entry.path}> (${helper.humanSize(entry.size)})`, 'Prepare')
             return false
         }
-        const audioCodec = entry.info?.audio?.codec_name
-        const videoCodec = entry.info?.video?.codec_name
+        const audioCodec = entry.info?.audio?.format
+        const videoCodec = entry.info?.video?.format
         if (isAudio) {
             // 检查音频文件
             // 放前面，因为 dstAudioBitrate 会用于前缀后缀参数
@@ -605,7 +584,7 @@ async function prepareFFmpegCmd(entry) {
             entry.tags = meta?.tags
             // 如果ffprobe或music-metadata获取的数据中有比特率数据
             log.info(entry.name, preset.name)
-            if (entry.format?.bitrate || entry.info?.audio.bit_rate || entry.info?.format?.bit_rate) {
+            if (entry.format?.bitrate || entry.info?.audio.bitrate || entry.info?.bitrate) {
                 // 可以读取码率，文件未损坏
             } else {
                 // 如果无法获取元数据，认为不是合法的音频或视频文件，忽略
@@ -613,11 +592,24 @@ async function prepareFFmpegCmd(entry) {
                 log.fileLog(`${ipx} Skip[Invalid]: <${entry.path}> (${helper.humanSize(entry.size)})`, 'Prepare')
                 return false
             }
+        } else {
+            // H264 10Bit Nvidia和Intel都不支持硬解，直接跳过
+            if (entry.info?.video?.format === 'h264'
+                && entry.info?.video.bitDepth === 10
+                && entry.info?.video.profile?.includes('10')) {
+                log.showYellow(logTag, `${ipx} Skip[H264_10Bit]: ${entry.path} ${entry.info?.video?.pixelFormat} (${helper.humanSize(entry.size)})`)
+                log.fileLog(`${ipx} Skip[H264_10Bit]: <${entry.path}> (${helper.humanSize(entry.size)})`, 'Prepare')
+                return false
+            }
+
         }
         // 获取原始音频码率，计算目标音频码率
         // vp9视频和opus音频无法获取码率
         const dstArgs = calculateDstArgs(entry)
 
+        log.info('>>>', entry.name)
+        log.info(dstArgs)
+
         // 计算后的视频和音频码率，关联文件
         // 与预设独立，优先级高于预设
         // srcXX单位为bytes dstXXX单位为kbytes
@@ -628,13 +620,13 @@ async function prepareFFmpegCmd(entry) {
         log.info(logTag, entry.path, dstArgs)
         // 如果转换目标是音频，但是源文件不含音频流，忽略
         if (entry.preset.type === 'audio' && !audioCodec) {
-            log.showYellow(logTag, `${ipx} Skip[NoAudio]: ${entry.path}`, getEntryShowInfo(newEntry))
+            log.showYellow(logTag, `${ipx} Skip[NoAudio]: ${entry.path} (${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(logTag, `${ipx} Skip[NoVideo]: ${entry.path}`, getEntryShowInfo(newEntry))
+            log.showYellow(logTag, `${ipx} Skip[NoVideo]: ${entry.path} (${helper.humanSize(entry.size)})`)
             log.fileLog(`${ipx} Skip[NoVideo]: <${entry.path}> (${helper.humanSize(entry.size)})`, 'Prepare')
             return false
         }
@@ -676,8 +668,6 @@ async function prepareFFmpegCmd(entry) {
         let fileSubtitle = path.join(srcDir, `${srcBase}.ass`)
         if (!(await fs.pathExists(fileSubtitle))) {
             fileSubtitle = null
-        } else {
-            fileSubtitle = path.basename(fileSubtitle)
         }
         log.show(logTag, `${ipx} FR: ${helper.pathShort(entry.path, 80)}`, chalk.yellow(entry.preset.name), helper.humanTime(entry.startMs))
         log.showGray(logTag, `${ipx} TO:`, fileDst)
@@ -798,10 +788,11 @@ function minNoZero(...numbers) {
     return Math.min(...fNumbers)
 }
 
-// 计算视频和音频码率
+const PIXELS_1080P = 1920 * 1080
+// 计算视频和音频码率等各种目标文件数据
 function calculateDstArgs(entry) {
     const ep = entry.preset
-    const iformat = entry.info?.format
+    const info = entry.info
     const ivideo = entry.info?.video
     const iaudio = entry.info?.audio
 
@@ -810,10 +801,13 @@ function calculateDstArgs(entry) {
     let dstAudioBitrate = 0
     let srcVideoBitrate = 0
     let dstVideoBitrate = 0
+
+    const reqAudioBitrate = ep.userArgs.audioBitrate || ep.audioBitrate
+    const reqVideoBitrate = ep.userArgs.videoBitrate || ep.videoBitrate
     if (helper.isAudioFile(entry.path)) {
         // 音频文件
         // 文件信息中的码率值
-        const fileBitrate = entry.format?.bitrate || iformat?.bit_rate || iaudio?.bit_rate || 0
+        const fileBitrate = entry.format?.bitrate || info?.bitrate || iaudio?.bitrate || 0
         if (fileBitrate > 0) {
             srcAudioBitrate = fileBitrate
         } else {
@@ -833,7 +827,7 @@ function calculateDstArgs(entry) {
                 dstAudioBitrate = bitrateMap.find(br => srcAudioBitrate > br.threshold)?.value || 48 * 1000
             } else {
                 // 智能码率关闭，直接使用用户值或预设值
-                dstAudioBitrate = ep.userArgs.audioBitrate || ep.audioBitrate
+                dstAudioBitrate = reqAudioBitrate
             }
         } else {
             // 有的文件无法获取音频码率，如opus，此时srcAudioBitrate=0
@@ -845,23 +839,24 @@ function calculateDstArgs(entry) {
     } else {
         // 视频文件
         // 这个是文件整体码率，如果是是视频文件，等于是视频和音频的码率相加
-        const fileBitrate = iformat?.bit_rate || 0
-        srcAudioBitrate = iaudio?.bit_rate || 0
+        const fileBitrate = info?.bitrate || 0
+        srcAudioBitrate = iaudio?.bitrate || 0
         // 计算出的视频码率不高于源文件的视频码率
         // 减去音频的码率，估算为48k
-        srcVideoBitrate = ivideo?.bit_rate
+        srcVideoBitrate = ivideo?.bitrate
             || fileBitrate - 48 * 1000 || 0
 
         // 音频和视频码率 用户指定>预设
         // 音频和视频码率都不能高于原码率
-        const reqAudioBitrate = ep.userArgs.audioBitrate || ep.audioBitrate
         dstAudioBitrate = minNoZero(srcAudioBitrate, reqAudioBitrate)
-        const reqVideoBitrate = ep.userArgs.videoBitrate || ep.videoBitrate
         dstVideoBitrate = minNoZero(srcVideoBitrate, reqVideoBitrate)
+
+        log.info(entry.name, "fileBitrate", fileBitrate, "srcVideoBitrate", srcVideoBitrate, "reqVideoBitrate", reqVideoBitrate, "dstVideoBitrate", dstVideoBitrate)
+
     }
 
     // 源文件时长
-    const srcDuration = iformat?.duration
+    const srcDuration = info?.duration
         || ivideo?.duration
         || iaudio?.duration || 0
     // 如果目标帧率大于原帧率，就将目标帧率设置为0，即让ffmpeg自动处理，不添加帧率参数
@@ -878,6 +873,26 @@ function calculateDstArgs(entry) {
     const dstDimension = ep.userArgs.dimension || ep.dimension
     const { dstWidth, dstHeight } = calculateScale(ivideo?.width || 0, ivideo?.height || 0, dstDimension)
 
+    const dstPixels = dstWidth * dstHeight
+    const dstVideoBitrateFixed = dstVideoBitrate
+    if (dstPixels > 0) {
+        let scaleFactor = dstPixels / PIXELS_1080P
+        // dstVideoBitrate针对目标是1080p的数据
+        // 如果目标码率不是1080p，根据分辨率智能缩放
+        // 示例 辨率1920*1080的目标码率是 1600k
+        // 1280*720码率 960k
+        // 3840*2160码率 2560k
+        // 0.9~1.1 之间不缩放
+        if (scaleFactor > 1.1) {
+            scaleFactor *= 0.4
+        } else if (scaleFactor < 0.9) {
+            scaleFactor *= 1.6
+        } else {
+            scaleFactor = 1
+        }
+        dstVideoBitrate = Math.round(dstVideoBitrate * scaleFactor)
+    }
+
     const dstSpeed = ep.userArgs.speed || ep.speed
 
     // 用于模板字符串的模板参数，针对当前文件
@@ -891,11 +906,11 @@ function calculateDstArgs(entry) {
         srcDuration,
         srcWidth: ivideo?.width || 0,
         srcHeight: ivideo?.height || 0,
-        srcDuration: iformat?.duration || 0,
-        srcSize: iformat?.size || 0,
-        srcVideoCodec: ivideo?.codec_name,
-        srcAudioCodec: iaudio?.codec_name,
-        srcFormat: iformat?.format_name,
+        srcDuration: info?.duration || 0,
+        srcSize: info?.size || 0,
+        srcVideoCodec: ivideo?.format,
+        srcAudioCodec: iaudio?.format,
+        srcFormat: info?.format,
         // 计算出来的参数
         dstAudioBitrate,
         dstVideoBitrate,
@@ -906,6 +921,9 @@ function calculateDstArgs(entry) {
         dstWidth,
         dstHeight,
         dstSpeed,
+        // 码率智能缩放
+        audioBitrateScaled: dstAudioBitrate !== reqAudioBitrate,
+        videoBitrateScaled: dstVideoBitrate !== dstVideoBitrateFixed,
         // 会覆盖preset的同名预设值
         // videoBitrate: dstVideoBitrate,
         videoBitrateK: `${Math.round(dstVideoBitrate / 1000)}K`,
@@ -927,6 +945,9 @@ function createFFmpegArgs(entry, forDisplay = false) {
     // 不要使用 entry.perset，下面复制一份针对每个entry
     const tempPreset = { ...entry.preset, ...entry.dstArgs, }
 
+    log.info('>>>>', entry.name)
+    log.info(tempPreset)
+
     // 输入参数
     let inputArgs = []
 
@@ -939,7 +960,7 @@ function createFFmpegArgs(entry, forDisplay = false) {
         }
     }
 
-    log.info('createFFmpegArgs', 'tempPreset', entry.name, core.pickTrueValues(tempPreset))
+    log.info('createFFmpegArgs', 'tempPreset', entry.name, tempPreset)
 
     // 几种ffmpeg参数设置的时间和功耗
     // ffmpeg -hide_banner -n -v error -stats -i 

package/cmd/cmd_remove.js

@@ -21,9 +21,9 @@ import { promisify } from 'util'
 import { comparePathSmartBy } from "../lib/core.js"
 import * as log from '../lib/debug.js'
 import * as enc from '../lib/encoding.js'
-import { getMediaInfo } from '../lib/ffprobe.js'
 import * as mf from '../lib/file.js'
 import * as helper from '../lib/helper.js'
+import { getMediaInfo } from '../lib/mediainfo.js'
 import { addEntryProps, applyFileNameRules } from './cmd_shared.js'
 
 // a = all, f = files, d = directories
@@ -115,6 +115,15 @@ const builder = function addOptions(ya, helpOrVersionSet) {
             // 文件名列表文本文件，或者一个目录，里面包含的文件作为文件名列表来源
             description: "File name list file, or dir contains files for file name",
         })
+        // 视频模式，按照视频文件的元数据删除
+        // duration,dimension(width,height),bitrate
+        // 参数格式 缩写 du=xx,w=xx,h=xx,dm=xx,bit=xx 
+        // duration=xx,width=xx,height=xx,bitrate=xx
+        .option("video", {
+            alias: "vdm",
+            type: "string",
+            description: "Remove files by video metadata",
+        })
         // 要处理的文件类型 文件或目录或所有，默认只处理文件
         .option("type", {
             type: "choices",

package/cmd/cmd_rename.js

@@ -16,9 +16,9 @@ import argparser from '../lib/argparser.js'
 import * as core from '../lib/core.js'
 import * as log from '../lib/debug.js'
 import * as enc from '../lib/encoding.js'
-import { getMediaInfo } from '../lib/ffprobe.js'
 import * as mf from '../lib/file.js'
 import * as helper from '../lib/helper.js'
+import { getMediaInfo } from '../lib/mediainfo.js'
 import { mergePath } from '../lib/path-merge.js'
 import { applyFileNameRules, cleanFileName, renameFiles } from "./cmd_shared.js"
 
@@ -407,9 +407,8 @@ async function preRename(f) {
             let tplValues = isAudio ? info.audio : info.video
             tplValues = {
                 ...tplValues,
-                duration_s: Math.floor(duration),
-                duration_m: Math.floor(duration / 60),
-                bitrate_k: Math.floor(bitrate / 1000),
+                duration: `${helper.humanSeconds(duration)}`,
+                bitrate: `${Math.floor(bitrate / 1000)}K`,
             }
             // 替换模板字符串
             const base = tmpNewBase || oldBase

package/lib/core.js

@@ -345,6 +345,25 @@ export function copyFields(source, target, ignoreKeys = []) {
     }
 }
 
+// 直接修改原对象， 删除某些键值
+export function removeFieldsIn(obj, removeKeys = []) {
+    for (const key in obj) {
+        if (obj.hasOwnProperty(key)
+            && removeKeys.includes(key)) {
+            delete obj[key]
+        }
+    }
+}
+
+// 直接修改原对象，删除符合条件的键值
+export function removeFieldsBy(obj, filterFunc) {
+    for (const [key, value] of Object.entries(obj)) {
+        // 如果提供了过滤函数，并且该键值对不符合过滤函数的条件，则跳过该键值对
+        if (filterFunc && filterFunc(key, value)) {
+            delete obj[key]
+        }
+    }
+}
 
 // 去掉一个object所有值不是基本类型的字段
 // 保留值类型为字符串、数字、布尔值的字段

package/lib/ffmpeg_presets.js

@@ -24,6 +24,7 @@ const BIT_RATE_1600K = UNIT_KB * 1600
 const BIT_RATE_2000K = UNIT_KB * 2000
 const BIT_RATE_4000K = UNIT_KB * 4000
 const BIT_RATE_6000K = UNIT_KB * 6000
+const BIT_RATE_8M = UNIT_MB * 8
 const BIT_RATE_10M = UNIT_MB * 10
 const BIT_RATE_16M = UNIT_MB * 16
 
@@ -279,6 +280,8 @@ const HEVC_BASE = new FFmpegPreset('hevc-base', {
     // 快速读取和播放
     outputArgs: '-movflags +faststart -movflags use_metadata_tags',
     // -vf 'scale=if(gte(iw\,ih)\,min(1280\,iw)\,-2):if(lt(iw\,ih)\,min(1280\,ih)\,-2)'
+    // 前面如果不加 hwupload_cuda 某些10bit视频会报错
+    // 查了半天，发现Nvidia和Intel都不支持H264-10bit的硬解，但是HEVC-10bit可以
     filters: "scale_cuda='if(gte(iw,ih),min({dimension},iw),-2)':'if(lt(iw,ih),min({dimension},ih),-2)':interp_algo=lanczos",
     complexFilter: '',
 })
@@ -299,7 +302,31 @@ const PRESET_HEVC_4K = FFmpegPreset.fromPreset(HEVC_BASE).update({
     dimension: 3840
 })
 
-const PRESET_HEVC_HIGH = FFmpegPreset.fromPreset(HEVC_BASE).update({
+const PRESET_HEVC_4K_LOW = FFmpegPreset.fromPreset(HEVC_BASE).update({
+    name: 'hevc_4kl',
+    videoQuality: 24,
+    videoBitrate: BIT_RATE_6000K,
+    audioBitrate: BIT_RATE_256K,
+    dimension: 3840
+})
+
+const PRESET_HEVC_4K_LOWEST = FFmpegPreset.fromPreset(HEVC_BASE).update({
+    name: 'hevc_4kt',
+    videoQuality: 26,
+    videoBitrate: BIT_RATE_4000K,
+    audioBitrate: BIT_RATE_192K,
+    dimension: 3840
+})
+
+const PRESET_HEVC_2K_ULTRA = FFmpegPreset.fromPreset(HEVC_BASE).update({
+    name: 'hevc_2ku',
+    videoQuality: 22,
+    videoBitrate: BIT_RATE_8M,
+    audioBitrate: BIT_RATE_256K,
+    dimension: 1920
+})
+
+const PRESET_HEVC_2K_HIGH = FFmpegPreset.fromPreset(HEVC_BASE).update({
     name: 'hevc_2kh',
     videoQuality: 22,
     videoBitrate: BIT_RATE_6000K,
@@ -315,7 +342,7 @@ const PRESET_HEVC_2K = FFmpegPreset.fromPreset(HEVC_BASE).update({
     dimension: 1920
 })
 
-const PRESET_HEVC_MEDIUM = FFmpegPreset.fromPreset(HEVC_BASE).update({
+const PRESET_HEVC_2K_MEDIUM = FFmpegPreset.fromPreset(HEVC_BASE).update({
     name: 'hevc_2km',
     videoQuality: 26,
     videoBitrate: BIT_RATE_2000K,
@@ -323,7 +350,7 @@ const PRESET_HEVC_MEDIUM = FFmpegPreset.fromPreset(HEVC_BASE).update({
     dimension: 1920
 })
 
-const PRESET_HEVC_LOW = FFmpegPreset.fromPreset(HEVC_BASE).update({
+const PRESET_HEVC_2K_LOW = FFmpegPreset.fromPreset(HEVC_BASE).update({
     name: 'hevc_2kl',
     videoQuality: 26,
     videoBitrate: BIT_RATE_1600K,
@@ -331,7 +358,7 @@ const PRESET_HEVC_LOW = FFmpegPreset.fromPreset(HEVC_BASE).update({
     dimension: 1920
 })
 
-const PRESET_HEVC_LOWEST = FFmpegPreset.fromPreset(HEVC_BASE).update({
+const PRESET_HEVC_2K_LOWEST = FFmpegPreset.fromPreset(HEVC_BASE).update({
     name: 'hevc_2kt',
     videoQuality: 28,
     videoBitrate: BIT_RATE_1200K,
@@ -485,23 +512,25 @@ function initPresets() {
         PRESET_H264_MEDIUM: PRESET_H264_MEDIUM,
         // H264 LOW
         PRESET_H264_LOW: PRESET_H264_LOW,
-        // 
-        PRESET_HEVC_ULTRA: PRESET_HEVC_ULTRA,
         //4K超高码率和质量
         //4K超高码率和质量
         PRESET_HEVC_ULTRA: PRESET_HEVC_ULTRA,
         //4k高码率和质量
         PRESET_HEVC_4K: PRESET_HEVC_4K,
+        PRESET_HEVC_4K_LOW: PRESET_HEVC_4K_LOW,
+        PRESET_HEVC_4K_LOWEST: PRESET_HEVC_4K_LOWEST,
+        // 2K极致质量
+        PRESET_HEVC_2K_ULTRA: PRESET_HEVC_2K_ULTRA,
         // 2K高码率和质量
-        PRESET_HEVC_HIGH: PRESET_HEVC_HIGH,
+        PRESET_HEVC_HIGH: PRESET_HEVC_2K_HIGH,
         // 2K默认码率和质量
         PRESET_HEVC_2K: PRESET_HEVC_2K,
         // 2K中码率和质量
-        PRESET_HEVC_MEDIUM: PRESET_HEVC_MEDIUM,
+        PRESET_HEVC_MEDIUM: PRESET_HEVC_2K_MEDIUM,
         // 2K低码率和质量
-        PRESET_HEVC_LOW: PRESET_HEVC_LOW,
+        PRESET_HEVC_LOW: PRESET_HEVC_2K_LOW,
         // 极低画质和码率
-        PRESET_HEVC_LOWEST: PRESET_HEVC_LOWEST,
+        PRESET_HEVC_LOWEST: PRESET_HEVC_2K_LOWEST,
         // 极速模式，适用于视频教程
         PRESET_HEVC_SPEED: PRESET_HEVC_SPEED,
         // 提取视频中的音频，复制或转换为AAC格式

package/lib/file.js

@@ -80,8 +80,8 @@ export async function walk(root, options = {}) {
         ctime: st.ctime,
         mtime: st.mtime,
         size: st.size || 0,
-        isDir: st.isDirectory(),
-        isFile: st.isFile(),
+        isDir: st?.isDirectory() || false,
+        isFile: st?.isFile() || false,
         index,
       }
       log.debug(
@@ -97,7 +97,7 @@ export async function walk(root, options = {}) {
       }
       return entry
     } catch (error) {
-      log.warn(
+      log.error(
         logTag,
         error,
         pathShort(fpath)

package/lib/media_parser.js

@@ -0,0 +1,278 @@
+/*
+ * Project: mediac
+ * Created: 2024-05-02 17:22:06
+ * Modified: 2024-05-02 17:22:06
+ * Author: mcxiaoke (github@mcxiaoke.com)
+ * License: Apache License 2.0
+ */
+
+import { removeFieldsBy, roundNum } from './core.js'
+
+class MediaStreamBase {
+    constructor(
+        {
+            type, // 媒体类型
+            format, // 格式名称
+            codec, // 编解码器名称
+            profile, // 编解码器配置概况
+            size, // 文件大小
+            duration, // 时长
+            bitrate, // 比特率
+        }
+
+    ) {
+        this.type = type // 媒体类型
+        this.format = format // 格式名称
+        this.codec = codec // 编解码器名称
+        this.profile = profile // 编解码器配置概况
+        this.size = size || 0 // 文件大小
+        this.duration = duration // 时长
+        this.bitrate = bitrate // 比特率
+    }
+}
+
+class Video extends MediaStreamBase {
+    constructor(
+        {
+            type, // 媒体类型
+            format, // 格式名称
+            codec, // 编解码器名称
+            profile, // 编解码器配置概况
+            size, // 文件大小
+            duration, // 时长
+            bitrate, // 比特率
+
+            framerate, // 帧率
+            bitDepth, // 位深 8bit or 10bit
+            width, // 视频宽度
+            height, // 视频高度
+            aspectRatio, // 宽高比
+            pixelFormat, // 像素格式
+        }
+
+    ) {
+        super({ type, format, codec, profile, size, duration, bitrate })
+        this.framerate = framerate // 帧率
+        this.bitDepth = bitDepth // 位深 8bit or 10bit
+        this.width = width // 视频宽度
+        this.height = height // 视频高度
+        this.aspectRatio = aspectRatio
+        this.pixelFormat = pixelFormat
+    }
+
+}
+
+class Audio extends MediaStreamBase {
+    constructor(
+        {
+            type, // 媒体类型
+            format, // 格式名称
+            codec, // 编解码器名称
+            profile, // 编解码器配置概况
+            size, // 文件大小
+            duration, // 时长
+            bitrate, // 比特率
+            sampleRate, // 采样率
+        }
+
+    ) {
+        super({ type, format, codec, profile, size, duration, bitrate })
+        this.sampleRate = sampleRate
+    }
+}
+
+class MediaInfo {
+    constructor(
+        {
+            provider, // 解析器
+            format, // 文件的格式类型（如：video/mp4）
+            size, // 文件大小，单位根据情况设定（如字节）
+            duration, // 时长，单位根据情况设定（如秒）
+            bitrate, // 平均比特率，单位根据情况设定（如bps）
+            createdAt, // 创建时间
+            audio, // audio stream 音频流
+            video, // video stream 视频流
+        }
+    ) {
+        this.provider = provider
+        this.format = format
+        this.size = size
+        this.duration = duration
+        this.bitrate = bitrate
+        this.createdAt = createdAt
+        this.audio = audio
+        this.video = video
+    }
+}
+
+function fromFFprobe(data) {
+    const obj = {
+        type: data['codec_type'], // 媒体类型
+        format: data['codec_name'], // 格式名称
+        codec: data['codec_tag_string'], // 编解码器名称
+        profile: data['profile'], // 编解码器配置概况
+        bitDepth: data['bits_per_raw_sample']
+            || data['bits_per_raw_sample'], // 位深 8bit or 10bit
+        size: data['size']
+            || data['tags']?.['NUMBER_OF_BYTES'], // 文件大小
+        duration: data['duration']
+            || data['tags']?.['DURATION'], // 时长
+        bitrate: data['bit_rate']
+            || data['tags']?.['BPS'], // 比特率
+        framerate: data['r_frame_rate'], // 帧率
+        pixelFormat: data['pix_fmt'],
+        width: data['width'], // 视频宽度
+        height: data['height'], // 视频高度
+        aspectRatio: data['display_aspect_ratio'],
+        sampleRate: data['sample_rate'],
+        language: data['tags']?.['language'], // 语言
+    }
+    return createStreamData(obj)
+}
+
+function fromMediaInfo(data) {
+    // console.log('fromMediaInfo', data)
+    const obj = {
+        type: data['@type'].toLowerCase(), // 媒体类型
+        format: data['Format'].toLowerCase(), // 格式名称
+        codec: data['CodecID'], // 编解码器名称
+        profile: data['Format_Profile'], // 编解码器配置概况
+        bitDepth: data['BitDepth'], // 位深 8bit or 10bit
+        size: data['StreamSize'], // 文件大小
+        duration: data['Duration'], // 时长
+        bitrate: data['BitRate'], // 比特率
+        framerate: data['FrameRate_Num'] || data['FrameRate'], // 帧率
+        pixelFormat: data['ColorSpace'] ?
+            data['ColorSpace'] + data['ChromaSubsampling'] : undefined,
+        width: data['Width'], // 视频宽度
+        height: data['Height'], // 视频高度
+        aspectRatio: data['DisplayAspectRatio'],
+        sampleRate: data['SamplingRate'],
+        language: data['language'], // 语言
+    }
+    return createStreamData(obj)
+}
+
+function createStreamData(obj) {
+    const isAudio = obj.type === 'audio'
+    const stream = isAudio ? (new Audio(obj)) : (new Video(obj))
+    removeFieldsBy(stream, (k, v) => v === undefined || v === null)
+    return stream
+}
+
+// 解析ffprobe json输出，返回MediaInfo
+export function fromFFprobeJson(data) {
+    // console.log('MediaInfo.fromFFprobeJson', data)
+    const root = data.format
+    const ad = data.streams?.find(obj => obj.codec_type === "audio")
+    const vd = data.streams?.find(obj => obj.codec_type === "video")
+    const obj = {
+        provider: 'ffprobe',
+        format: root['format_long_name'],
+        size: root['size'],
+        duration: root['duration'],
+        bitrate: root['bit_rate'],
+        createdAt: root['tags']?.['creation_time'],
+        audio: ad && fromFFprobe(ad),
+        video: vd && fromFFprobe(vd),
+    }
+    const info = new MediaInfo(convertNumber(obj))
+    removeFieldsBy(info, (k, v) => v === undefined || v === null)
+    return info
+}
+
+// 解析mediainfo json输出，返回MediaInfo
+export function fromMediaInfoJson(data) {
+    // console.log('MediaInfo.fromMediaInfoJson', data)
+    const root = data.media?.track?.find(o => o['@type'] === "General")
+    const ad = data.media?.track?.find(o => o['@type'] === "Audio")
+    const vd = data.media?.track?.find(o => o['@type'] === "Video")
+    const obj = {
+        provider: 'mediainfo',
+        format: root['Format']?.toLowerCase(),
+        size: root['FileSize'],
+        duration: root['Duration'],
+        bitrate: root['OverallBitRate'],
+        createdAt: root['Encoded_Date'],
+        audio: ad && fromMediaInfo(ad),
+        video: vd && fromMediaInfo(vd),
+    }
+    const info = new MediaInfo(convertNumber(obj))
+    removeFieldsBy(info, (k, v) => v === undefined || v === null)
+    return info
+}
+
+// 计算平均码率的方法
+// 如果是单音频文件，还有一个码率计算方式
+// fileSize / duration * 8 = bitrate
+// 或者如果知道流大小，也可以计算出来
+// streamSize / duration * 8 = bitrate
+// 还可以用用ffmpeg读取元数据，需要解析
+//  ffmpeg -hide_banner -i video.mp4 -c copy -f null -
+
+// "tags": {
+//     "title": "Encode By H-Enc",
+//     "BPS": "2430147",
+//     "DURATION": "00:16:44.003000000",
+// }
+// 提取tags里DURATION字段
+// 示例 00:16:43.946000000
+// 示例 00:16:44.003000000
+// 分割 (00):(16):(44.003000000)
+function extractDuration(timeString) {
+    // 使用 match 方法匹配时间字符串中的各个部分
+    const match = timeString.match(/(\d{2}):(\d{2}):(\d{2}(?:\.\d+))?/)
+
+    if (match) {
+        // log.showBlue(timeString, match)
+        // 解构赋值提取匹配到的时间部分
+        const [, hours, minutes, seconds] = match.map(Number)
+        // 将时间部分转换成秒
+        return roundNum(hours * 3600 + minutes * 60 + seconds)
+    } else {
+        return 0
+    }
+}
+
+// 字符串值转为数字值，修改原对象
+function convertNumber(obj) {
+    // 兼容空值
+    if (!obj) return obj
+    // 遍历对象的所有属性
+    for (const [key, value] of Object.entries(obj)) {
+        // 匹配 DURATION
+        if (key === 'DURATION') {
+            obj[key] = extractDuration(value)
+            continue
+        }
+        // 对于对象类型，递归处理
+        if (typeof value === 'object') {
+            obj[key] = convertNumber(value)
+            continue
+        }
+        // 检查属性的值是否为字符串类型且可以转换为数字
+        else if (typeof value === 'string') {
+            // 匹配字符串数字
+            if (/^\d+(\.\d+)?$/.test(value)) {
+                // 解析字符串数字
+                // 如果可以转换为数字，则将其转换并更新对象的值
+                obj[key] = roundNum(parseFloat(value))
+            } else if (key.includes('frame_rate')) {
+                // 解析 '25/1' 这种 r_frame_rate 字段值
+                const regex = /(\d+)\/(\d+)/
+                const match = value.match(regex)
+                if (match) {
+                    const numerator = parseInt(match[1])
+                    const denominator = parseInt(match[2])
+                    if (denominator !== 0) {
+                        obj[key] = roundNum(numerator / denominator)
+                    } else {
+                        obj[key] = 0
+                    }
+                }
+            }
+            continue
+        }
+    }
+    return obj
+}

package/lib/mediainfo.js

@@ -0,0 +1,99 @@
+/*
+ * Project: mediac
+ * Created: 2024-04-20 17:00:36
+ * Modified: 2024-04-20 17:00:36
+ * Author: mcxiaoke (github@mcxiaoke.com)
+ * License: Apache License 2.0
+ */
+
+import { execa } from 'execa'
+import iconv from 'iconv-lite'
+import { roundNum } from './core.js'
+import * as log from './debug.js'
+import { fromFFprobeJson, fromMediaInfoJson } from './media_parser.js'
+import { trySmartAsync } from './tryfp.js'
+
+import which from 'which'
+
+export const FFMPEG_BINARY = 'ffmpeg'
+export const FFPROBE_BINARY = 'ffprobe'
+export const MEDIAINFO_BINARY = 'mediainfo'
+
+// 检测可执行文件是否存在
+const HAS_FFPROBE_EXE = await which(FFPROBE_BINARY, { nothrow: true })
+const HAS_MEDIAINFO_EXE = await which(MEDIAINFO_BINARY, { nothrow: true })
+
+function fixEncoding(str = '') {
+    return iconv.decode(Buffer.from(str, 'binary'), 'gbk')
+}
+
+// ffprobe -v error -show_entries 'stream=codec_name,codec_long_name,profile,codec_type,codec_tag_string,width,height,display_aspect_ratio,pix_fmt,duration,bit_rate,sample_rate,sample_fmt,time_base,r_frame_rate,channels,bits_per_sample:format=format_name,format_long_name,duration,size,bit_rate:format_tags:stream_tags' -of json
+// 获取媒体文件信息 使用ffprobe
+async function ffprobeCall(filePath) {
+    // 只选择需要的字段，避免乱码和非法JSON
+    // 有的文件视频和音频duration和bit_rate放在stream_tags里
+    const propsSelected = 'stream=codec_name,codec_long_name,profile,codec_type,codec_tag_string,width,height,display_aspect_ratio,pix_fmt,duration,bit_rate,sample_rate,sample_fmt,time_base,r_frame_rate,avg_frame_rate,channels,bits_per_sample,bits_per_raw_sample:format=format_name,format_long_name,duration,size,bit_rate:stream_tags:format_tags=creation_time'
+    const cmdArgs = ['-v', 'error']
+    cmdArgs.push('-show_entries', propsSelected)
+    cmdArgs.push('-of', 'json', filePath)
+    // 使用 execa 执行 ffprobe 命令
+    const { stdout, stderr } = await execa(FFPROBE_BINARY, cmdArgs, { encoding: 'binary' })
+    const info = JSON.parse(stdout)
+    log.debug('ffprobeCall', filePath, info)
+    return info
+}
+
+// 获取媒体文件信息 使用mediainfo
+async function mediainfoCall(filePath) {
+    const cmdArgs = ['--Output=JSON', filePath]
+    // 使用 execa 执行 ffprobe 命令
+    const { stdout, stderr } = await execa(MEDIAINFO_BINARY, cmdArgs, { encoding: 'binary' })
+    log.showGray(stderr)
+    const result = JSON.parse(stdout)
+    log.debug('ffprobeCall', filePath, result)
+    return result
+}
+
+async function parseFFProbe(filePath) {
+    return fromFFprobeJson(await ffprobeCall(filePath))
+}
+
+async function parseMediaInfo(filePath) {
+    return fromMediaInfoJson(await mediainfoCall(filePath))
+}
+
+
+export async function getMediaInfo(filePath, options = { ffprobe: false }) {
+    if (!HAS_FFPROBE_EXE && !HAS_MEDIAINFO_EXE) {
+        throw new Error('both ffprobe and mediainfo binary not found')
+    }
+    let [err1, data1] = await trySmartAsync(options.ffprobe ? parseFFProbe : parseMediaInfo)(filePath)
+    if (err1) {
+        let [err2, data2] = await trySmartAsync(options.ffprobe ? parseMediaInfo : parseFFProbe)(filePath)
+        if (data2) {
+            return data2
+        }
+        err1 && log.error('getMediaInfo', fixEncoding(err1?.message))
+        err2 && log.error('getMediaInfo', fixEncoding(err2?.message))
+    } else {
+        return data1
+    }
+}
+
+export async function getSimpleInfo(filePath, options = {}) {
+    const info = await getMediaInfo(filePath, options)
+    const arr = []
+    if (!info?.duration) {
+        arr.push('ERROR: failed to get media info!')
+    }
+    arr.push(`format=${info?.format},duration=${info?.duration}s,bitrate=${roundNum((info?.bitrate || 0) / 1000)}K`)
+    if (info?.audio) {
+        const a = info?.audio
+        arr.push(`a:codec=${a.format},bitrate=${roundNum(a.bitrate || 0 / 1000)}K`)
+    }
+    if (info?.video) {
+        const v = info?.video
+        arr.push(`v:codec=${v.format},bitrate=${roundNum(v.bitrate || 0 / 1000)}K,fps=${v.framerate},size=${v.width}x${v.height}`)
+    }
+    return arr
+}

package/lib/shared.js

@@ -6,5 +6,3 @@
  * License: Apache License 2.0
  */
 
-export const FFMPEG_BINARY = 'ffmpeg'
-export const FFPROBE_BINARY = 'ffprobe'

package/lib/tryfp.js

@@ -44,10 +44,8 @@ const trySmartAsync = tryWrapAsync(throwNativeErr)
 const tryCatch = tryWrap()
 const tryCatchAsync = tryWrapAsync()
 
-export default {
-  setNoneValue,
-  trySmart,
-  trySmartAsync,
-  tryCatch,
-  tryCatchAsync,
-}
+export {
+  setNoneValue, tryCatch,
+  tryCatchAsync, trySmart,
+  trySmartAsync
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mediac",
-  "version": "1.8.0",
+  "version": "1.8.2",
   "type": "module",
   "description": "MediaCli is a multimedia file processing tool that utilizes ffmpeg and exiftool, among others, to compress/convert/rename/delete/organize media files, including images, videos, and audio.",
   "main": "index.js",

package/lib/ffprobe.js

@@ -1,205 +0,0 @@
-/*
- * Project: mediac
- * Created: 2024-04-20 17:00:36
- * Modified: 2024-04-20 17:00:36
- * Author: mcxiaoke (github@mcxiaoke.com)
- * License: Apache License 2.0
- */
-
-import { execa } from 'execa'
-import * as log from '../lib/debug.js'
-import { roundNum } from './core.js'
-import { FFPROBE_BINARY } from './shared.js'
-
-// ffprobe -v error -show_entries 'stream=codec_name,codec_long_name,profile,codec_type,codec_tag_string,width,height,display_aspect_ratio,pix_fmt,duration,bit_rate,sample_rate,sample_fmt,time_base,r_frame_rate,channels,bits_per_sample:format=format_name,format_long_name,duration,size,bit_rate:format_tags:stream_tags' -of json
-// 获取媒体文件信息的函数
-export async function getMediaInfo(filePath, options = { video: false, audio: false, fullData: false }) {
-    // 只选择需要的字段，避免乱码和非法JSON
-    // 有的文件视频和音频duration和bit_rate放在stream_tags里
-    const propsSelected = 'stream=codec_name,codec_long_name,profile,codec_type,codec_tag_string,width,height,display_aspect_ratio,pix_fmt,duration,bit_rate,sample_rate,sample_fmt,time_base,r_frame_rate,avg_frame_rate,channels,bits_per_sample:format=format_name,format_long_name,duration,size,bit_rate:stream_tags'
-    const selectJsonArgs = ['-v', 'error']
-    // 只选择 audio stream
-    if (options.audio) {
-        selectJsonArgs.push('-select_streams', 'a:0')
-    }
-    if (options.video) {
-        //只选择 video stream
-        selectJsonArgs.push('-select_streams', 'v:0')
-    }
-    selectJsonArgs.push('-show_entries', propsSelected)
-    selectJsonArgs.push('-of', 'json', filePath)
-    try {
-        // 使用 execa 执行 ffprobe 命令
-        const { stdout, stderr } = await execa(FFPROBE_BINARY, selectJsonArgs)
-        // console.log(stdout)
-        // console.log(stderr)
-        // return parseFFProbeOutput(stdout)
-        const info = JSON.parse(stdout)
-        // 只返回stream第一项
-        // format作为子项
-        log.debug('getMediaInfo', filePath, info)
-        // 只返回第一条视频轨和第一条音轨
-        // 如果有fullData参数，返回全部streams数据
-        const result = {
-            video: convertNumber(info.streams.find(obj => obj.codec_type === "video")),
-            audio: convertNumber(info.streams.find(obj => obj.codec_type === "audio")),
-            format: convertNumber(info.format),
-            streams: options.fullData ? info.streams : undefined,
-        }
-        if (result.video) {
-            result.video.duration = result.video?.duration || result.video?.tags?.DURATION
-            result.video.bit_rate = result.video?.bit_rate || result.video?.tags?.BPS
-            result.video.framerate = result.video?.r_frame_rate || result.video?.avg_frame_rate
-        }
-        // 特殊处理，有些视频文件的时长和码率参数放在stream_tags里
-        if (result.audio) {
-            result.audio.duration = result.audio?.duration || result.audio?.tags?.DURATION
-            result.audio.bit_rate = result.audio?.bit_rate || result.audio?.tags?.BPS
-        }
-        return result
-    } catch (error) {
-        log.warn(`ERROR:`, error.message?.slice(-160))
-    }
-}
-
-export async function getSimpleInfo(filePath, options = {}) {
-    const info = await getMediaInfo(filePath, options)
-    const arr = []
-    if (info?.audio) {
-        const a = info?.audio
-        arr.push(`a:codec=${a.codec_name},bitrate=${roundNum(a.bit_rate / 1000)}K,time=${Math.floor(a.duration)}s`)
-    }
-    if (info?.video) {
-        const v = info?.video
-        arr.push(`v:codec=${v.codec_name},bitrate=${roundNum(v.bit_rate / 1000)}K,time=${Math.floor(v.duration)}s,fps=${v.r_frame_rate},size=${v.width}x${v.height}`)
-    }
-
-    return arr
-}
-
-// "tags": {
-//     "title": "Encode By H-Enc",
-//     "BPS": "2430147",
-//     "DURATION": "00:16:44.003000000",
-// }
-// 提取tags里DURATION字段
-// 示例 00:16:43.946000000
-// 示例 00:16:44.003000000
-// 分割 (00):(16):(44.003000000)
-function extractDuration(timeString) {
-    // 使用 match 方法匹配时间字符串中的各个部分
-    const match = timeString.match(/(\d{2}):(\d{2}):(\d{2}(?:\.\d+))?/)
-
-    if (match) {
-        // log.showBlue(timeString, match)
-        // 解构赋值提取匹配到的时间部分
-        const [, hours, minutes, seconds] = match.map(Number)
-        // 将时间部分转换成秒
-        return roundNum(hours * 3600 + minutes * 60 + seconds)
-    } else {
-        return 0
-    }
-}
-
-// 字符串值转为数字值，修改原对象
-function convertNumber(obj) {
-    // 兼容空值
-    if (!obj) return obj
-    // 遍历对象的所有属性
-    for (const [key, value] of Object.entries(obj)) {
-        // 匹配 DURATION
-        if (key === 'DURATION') {
-            obj[key] = extractDuration(value)
-            continue
-        }
-        // 对于对象类型，递归处理
-        if (typeof value === 'object') {
-            obj[key] = convertNumber(value)
-            continue
-        }
-        // 检查属性的值是否为字符串类型且可以转换为数字
-        else if (typeof value === 'string') {
-            // 匹配字符串数字
-            if (/^\d+(\.\d+)?$/.test(value)) {
-                // 解析字符串数字
-                // 如果可以转换为数字，则将其转换并更新对象的值
-                obj[key] = roundNum(parseFloat(value))
-            } else if (key.includes('frame_rate')) {
-                // 解析 '25/1' 这种 r_frame_rate 字段值
-                const regex = /(\d+)\/(\d+)/
-                const match = value.match(regex)
-                if (match) {
-                    const numerator = parseInt(match[1])
-                    const denominator = parseInt(match[2])
-                    if (denominator !== 0) {
-                        obj[key] = roundNum(numerator / denominator)
-                    } else {
-                        obj[key] = 0
-                    }
-                }
-            }
-            continue
-        }
-    }
-    return obj
-}
-
-// 返回数据示例 video/audio/format 三个字段
-
-// {
-//     video: {
-//       codec_name: 'hevc',
-//       codec_long_name: 'H.265 / HEVC (High Efficiency Video Coding)',
-//       profile: 'Main 10',
-//       codec_type: 'video',
-//       codec_tag_string: '[0][0][0][0]',
-//       width: 1920,
-//       height: 1080,
-//       display_aspect_ratio: '16:9',
-//       pix_fmt: 'yuv420p10le',
-//       r_frame_rate: 23.98,
-//       avg_frame_rate: 23.98,
-//       time_base: '1/1000',
-//       tags: {
-//         title: 'Encode By H-Enc',
-//         BPS: '2430147',
-//         DURATION: '00:16:44.003000000',
-//         NUMBER_OF_FRAMES: '24072',
-//         NUMBER_OF_BYTES: '304984449',
-//         _STATISTICS_WRITING_APP: "mkvmerge v70.0.0 ('Caught A Lite Sneeze') 64-bit",
-//         _STATISTICS_WRITING_DATE_UTC: '2022-10-05 18:40:29',
-//         _STATISTICS_TAGS: 'BPS DURATION NUMBER_OF_FRAMES NUMBER_OF_BYTES'
-//       }
-//     },
-//     audio: {
-//       codec_name: 'aac',
-//       codec_long_name: 'AAC (Advanced Audio Coding)',
-//       profile: 'LC',
-//       codec_type: 'audio',
-//       codec_tag_string: '[0][0][0][0]',
-//       sample_fmt: 'fltp',
-//       sample_rate: 48000,
-//       channels: 2,
-//       bits_per_sample: 0,
-//       r_frame_rate: 0,
-//       avg_frame_rate: 0,
-//       time_base: '1/1000',
-//       tags: {
-//         BPS: '261491',
-//         DURATION: '00:16:43.946000000',
-//         NUMBER_OF_FRAMES: '47060',
-//         NUMBER_OF_BYTES: '32815429',
-//         _STATISTICS_WRITING_APP: "mkvmerge v70.0.0 ('Caught A Lite Sneeze') 64-bit",
-//         _STATISTICS_WRITING_DATE_UTC: '2022-10-05 18:40:29',
-//         _STATISTICS_TAGS: 'BPS DURATION NUMBER_OF_FRAMES NUMBER_OF_BYTES'
-//       }
-//     },
-//     format: {
-//       format_name: 'matroska,webm',
-//       format_long_name: 'Matroska / WebM',
-//       duration: 1004,
-//       size: 338094926,
-//       bit_rate: 2693975
-//     },
-//     streams: undefined
-//   }