tools_batch_files 1.0.28 → 1.0.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tools_batch_files",
-  "version": "1.0.28",
+  "version": "1.0.30",
   "description": "批处理视频工具",
   "keywords": [
     "utils",
@@ -12,6 +12,7 @@
   "bin": {
     "tbf": "./index.js",
     "tbfp": "./src/photoBatch.js",
+    "tbfa": "./src/audioFn/audioBatch.js",
     "tbfb": "./src/photoBatchBack.js",
     "tbfre": "./src/removeFailVideo.js"
   },

package/src/audioFn/audioBatch.js

@@ -0,0 +1,440 @@
+const generateUniqueHash = require("../utils/index");
+const { disposeError, readExcel, logger } = require("../utils/logger");
+
+const {
+  findFileInDir,
+  logFileSize,
+  ensureDirSync,
+} = require("../utils/settleFiles");
+const ffmpeg = require("fluent-ffmpeg");
+const fs = require("fs");
+const path = require("path");
+const fs_asnyc = require("fs").promises;
+const archiver = require("archiver");
+const axios = require("axios");
+const FormData = require("form-data");
+
+//并发数量
+const queueCount = 1;
+
+//起始任务下标
+let taskIndex = 0;
+
+//执行目录
+const exeDir = __dirname;
+//当前工作目录
+const workDir = process.cwd();
+// 表格目录
+const excelDir = path.join(workDir, "excel", "excel.xlsx");
+
+const ORIGIN_FILE_DIR = "audio";
+const WM_AUDIO_DIR = "watermark_audio";
+const WAV_AUDIO_DIR = "wav_audio";
+const SOURCE_AUDIO_DIR = "source_audio";
+const ZIP_FILES_DIR = "zip";
+//拷贝 - 存放上传失败的文件
+const Error_Files_Dir = "failed_audio";
+//水印
+const watermarkAudioPath = path.join(__dirname, "..", "vocal_print", "mz.mp3");
+const longWatermarkAudioPath = path.join(
+  __dirname,
+  "..",
+  "vocal_print",
+  "800a.mp3"
+);
+
+const maxRetries = 1; // 最大重试次数
+let retryCount = 0; // 当前重试次数
+
+/**
+ * 声纹
+ */
+const watermarkAudio = (indexFilePath, originFilePath, fileName, duration) => {
+  //存放声纹文件夹
+  const outputDir = path.join(indexFilePath, WM_AUDIO_DIR);
+  const outputFile = path.join(outputDir, fileName);
+  let vocalPath = "";
+
+  ensureDirSync(outputDir);
+  logger("duration" + duration);
+
+  // 确保输出时长与源音频保持一致，方案改为截取声纹音频了。
+  const complexFilter = [
+    `[0:a]volume=1[a0]`, // 设置原音频音量为1，重命名为a0
+    `[1:a]atrim=0:duration=${duration},volume=1.5[a1]`, // 对声纹音频流进行截取操作，并设置音量，重命名为a1
+    `[a0][a1]amix=inputs=2[a]`, // 合并两个音频流为一个输出流，重命名为a
+    `[a]volume=3.0`, // 设置输出音频的音量
+  ].join(";");
+
+  if (duration <= 5) {
+    //直接合并，放在末尾，下次补上
+    vocalPath = watermarkAudioPath;
+  } else if (duration > 5 && duration < 30) {
+    // 5s开始/ 每隔10s出现一次
+    vocalPath = watermarkAudioPath;
+
+    const totalCount = Math.floor((duration + 5) / 10);
+    for (let i = 1; i <= totalCount; i++) {
+      if (i === 1) {
+        complexFilter.push(`[1:a]adelay=5000|2000,volume=2.0[a${i}]`);
+      } else {
+        complexFilter.push(
+          `[1:a]adelay=${5000 + 10000 * (i - 1)}|2000,volume=2.0[a${i}]`
+        );
+      }
+    }
+  } else {
+    //30以上 10s开始 每隔10s出现一次
+    vocalPath = longWatermarkAudioPath;
+  }
+
+  return new Promise((resolve, reject) => {
+    const watermarkCommand = ffmpeg();
+    // 打声纹
+    watermarkCommand
+      .input(originFilePath)
+      .input(vocalPath) // 声纹音频文件
+
+      .complexFilter(complexFilter)
+      .output(outputFile)
+      .on("error", (err) => {
+        logger("添加声纹出错: " + err);
+        reject(err);
+      })
+      .on("end", () => {
+        logger("添加声纹完成: " + outputFile);
+        resolve();
+      })
+      .run();
+  });
+};
+
+/**
+ * 生成wav
+ */
+const wavAudio = (indexFilePath, originFilePath, fileName) => {
+  //存放wav文件夹
+  const outputDir = path.join(indexFilePath, WAV_AUDIO_DIR);
+  ensureDirSync(outputDir);
+
+  const outputFile = path.join(outputDir, fileName.replace(".mp3", ".wav"));
+
+  return new Promise((resolve, reject) => {
+    const watermarkCommand = ffmpeg(originFilePath);
+    watermarkCommand
+      .output(outputFile)
+      .on("error", (err) => {
+        logger("生成wav出错: " + err);
+        reject();
+      })
+      .on("end", () => {
+        logger("wav文件生成完成: " + outputFile);
+        resolve();
+      })
+      .run();
+  });
+};
+
+/**
+ * 打包物料
+ */
+const archiveZip = (fileName, inputPath, originFilePath) => {
+  const zipDir = path.join(inputPath, "zip");
+  const timestamp = new Date().getTime();
+
+  ensureDirSync(zipDir);
+  const zipStream = fs.createWriteStream(
+    path.join(zipDir, `package${timestamp}.zip`)
+  );
+  const archive = archiver("zip", {
+    zlib: { level: 9 },
+  });
+
+  return new Promise((resolve, reject) => {
+    zipStream.on("close", function () {
+      logger("压缩数据：" + archive.pointer() + " total bytes");
+      logger(
+        "完成归档archiver has been finalized and the output file descriptor has closed."
+      );
+      resolve();
+    });
+
+    archive.on("warning", function (err) {
+      if (err.code === "ENOENT") {
+        logger("压缩-warning：" + err);
+      } else {
+        throw err;
+      }
+    });
+
+    archive.on("error", function (err) {
+      logger("压缩失败！" + err);
+      reject();
+    });
+
+    archive.pipe(zipStream);
+    const directories = [WAV_AUDIO_DIR, WM_AUDIO_DIR];
+
+    directories.forEach((dir) => {
+      const dirPath = path.join(inputPath, dir);
+      archive.directory(dirPath, dir);
+    });
+
+    archive.file(originFilePath, {
+      name: path.join(SOURCE_AUDIO_DIR, fileName),
+    });
+    // 完成归档
+    archive.finalize();
+  });
+};
+
+/**
+ * 获取 元数据
+ */
+const getMetadata = async (
+  fileName,
+  indexFilePath,
+  originFilePath,
+  { rowFileName, title, keyword }
+) => {
+  //源音频数据
+  const photoMetadataComand = ffmpeg(originFilePath);
+
+  const metaDataParams = {
+    userid: 192375294,
+    username: "张杰",
+    title,
+    keyword,
+    en_keyword: "",
+    en_title: "",
+    size: "",
+    pr: 0,
+    sampling: "", // 采样率
+    duration: "",
+    tag_ids: "3",
+    source_from: "sound_1",
+  };
+
+  await new Promise((resolve, reject) => {
+    photoMetadataComand.ffprobe(function (err, metadata) {
+      if (metadata) {
+        const formatStream = metadata.format;
+        const audioStream = metadata.streams.find(
+          (s) => s.codec_type === "audio"
+        );
+
+        metaDataParams.size = formatStream.size;
+        metaDataParams.duration = audioStream.duration;
+        metaDataParams.sampling = audioStream.sample_rate;
+
+        resolve();
+      } else {
+        reject(err);
+      }
+    });
+  });
+
+  return metaDataParams;
+};
+
+/**
+ * 接口
+ */
+const postData = (dataParams, indexFilePath) => {
+  const formData = new FormData();
+
+  const zipFiles = fs
+    .readdirSync(path.join(indexFilePath, ZIP_FILES_DIR))
+    .find((file) => file.endsWith(".zip"));
+
+  const packageZip = path.join(indexFilePath, ZIP_FILES_DIR, zipFiles);
+
+  formData.append("file", fs.createReadStream(packageZip));
+  for (const key in dataParams) {
+    if (Object.hasOwnProperty.call(dataParams, key)) {
+      const value = dataParams[key];
+      formData.append(key, value);
+    }
+  }
+
+  logger("等待接口返回结果……");
+
+  //   return axios.post("http://127.0.0.1:9999/upload/photo", formData, {
+  // return axios.post("http://192.168.102.61:9999/upload/sound", formData, {
+  return axios.post("http://192.168.101.149:9999/upload/sound", formData, {
+    headers: {
+      "Content-Type": "multipart/form-data",
+    },
+    timeout: 300000,
+  });
+};
+
+/**
+ * 接口重试机制
+ */
+async function postDataWithRetry(dataParams, indexFilePath) {
+  while (retryCount < maxRetries) {
+    try {
+      const resData = await postData(dataParams, indexFilePath);
+      if (resData.data.code === 200) {
+        logger("请求成功！");
+        logger(resData.data);
+        fs.rmdirSync(indexFilePath, { recursive: true });
+        return; // 请求成功，结束循环
+      } else if (resData.data.code === 300) {
+        // 重复上传，不捕获此错误
+        logger(`第${index}条文件-${index}重复上传！`);
+        fs.rmdirSync(indexFilePath, { recursive: true });
+        return; // 结束循环
+      } else {
+        // 其他错误，抛出异常
+        throw new Error("请求失败！" + resData.data);
+      }
+    } catch (error) {
+      logger(`请求失败，重试中... (${retryCount + 1}/${maxRetries})`);
+      logger(error);
+      retryCount++;
+      // 延时等待一段时间后再进行重试
+      await new Promise((resolve) => setTimeout(resolve, 100)); // 等待1秒
+    }
+  }
+  // 如果达到最大重试次数仍然失败，则抛出异常
+  throw new Error("请求失败，重试次数已达到上限！");
+}
+
+/**
+ * 任务
+ */
+const task = async (row, index) => {
+  try {
+    logger(
+      "**************************" + row.fileName + "**************************"
+    );
+    // Excel的列名分别为： fileName title keyword
+    let fileName = row.fileName;
+    const title = row.title;
+    // const keywordArr = row.keyword.split(",");
+    // const filteredArray = keywordArr.filter((item) => item.trim() !== "");
+    // const keyword = filteredArray.join(" ");
+
+    const keyword = row.keyword;
+
+    if (!fileName.includes(".")) {
+      fileName = row.fileName + ".mp3";
+    }
+
+    const getPathStartTime = new Date();
+    // 源音频文件夹路径
+    const originFilePath = await findFileInDir(
+      path.join(workDir, ORIGIN_FILE_DIR),
+      fileName
+    );
+
+    const getPathEndTime = new Date();
+    const timeInSeconds1 = ((getPathEndTime - getPathStartTime) / 1000).toFixed(
+      2
+    );
+
+    logger(`第${index}条Path路径搜索时间：${timeInSeconds1}秒`);
+    logger(`-------------------${new Date()}------------------`);
+
+    logger("原文件路径：" + originFilePath);
+
+    if (!originFilePath) {
+      logger(`音频文件 ${fileName} 不存在`);
+      return;
+    }
+
+    //index文件夹   output/0
+    const indexFilePath = path.join(workDir, "output", index + "");
+
+    const workStartTime = new Date();
+    await fs_asnyc.access(originFilePath, fs_asnyc.constants.F_OK);
+    logFileSize(originFilePath);
+    const dataParams = await getMetadata(
+      fileName,
+      indexFilePath,
+      originFilePath,
+      {
+        title,
+        keyword,
+      }
+    );
+    await wavAudio(indexFilePath, originFilePath, fileName);
+    await watermarkAudio(
+      indexFilePath,
+      originFilePath,
+      fileName,
+      dataParams.duration
+    );
+    await archiveZip(fileName, indexFilePath, originFilePath);
+    const workEndTime = new Date();
+    const timeInSeconds = ((workEndTime - workStartTime) / 1000).toFixed(2);
+
+    logger(`第${index}条4090处理总时间：${timeInSeconds}秒`);
+    logger(`-------------------${new Date()}------------------`);
+
+    // 重试机制
+    await postDataWithRetry(dataParams, indexFilePath);
+
+    logger(
+      `----------------------------------------第${index}条结束---------------------------------end`
+    );
+  } catch (error) {
+    // 可以约定code，来表示不同的错误信息
+    if (error.code === "ENOENT") {
+      logger(`音频文件 ${fileName} 不存在`);
+    } else {
+      logger("音频任务处理失败：" + error);
+    }
+    fs.rmdirSync(indexFilePath, { recursive: true });
+    disposeError(fileName);
+
+    //失败的时候，复制文件到错误文件夹中
+    const failPath = path.join(workDir, Error_Files_Dir, fileName);
+    moveFailFiles(originFilePath, failPath);
+  }
+};
+
+const main = () => {
+  //当前任务hash
+  const hashOrigin = generateUniqueHash();
+  const hash = hashOrigin.slice(0, 8);
+  logger("音频批量任务任务开始---" + hash);
+  logger("当前目录： " + workDir + "工作目录： " + __dirname);
+
+  const jsonData = readExcel(excelDir);
+
+  const run = (index) => {
+    try {
+      logger(
+        `run-------------------------------------第${index}条开始------------------------------------`
+      );
+      const row = jsonData[index];
+
+      if (!row) {
+        logger("最后一条已结束！");
+        return;
+      }
+      task(row, index)
+        .then(() => {
+          taskIndex++;
+          run(taskIndex);
+        })
+        .catch(() => {
+          taskIndex++;
+          run(taskIndex);
+        });
+    } catch (error) {
+      logger("捕获错误！" + error);
+      taskIndex++;
+      run(taskIndex);
+    }
+  };
+
+  for (let i = 0; i < queueCount; i++) {
+    run(i + taskIndex);
+  }
+};
+
+main();

package/utils/logger.js

@@ -0,0 +1,48 @@
+const XLSX = require("xlsx");
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * 普通日志
+ * @param {*} log 日志内容
+ */
+const logger = (log) => {
+  console.log(log);
+  fs.writeFileSync("log.txt", log + "\n", {
+    flag: "a",
+  });
+};
+
+//错误日志
+const disposeError = (err) => {
+  logger("---任务失败---" + err);
+  logger(
+    `******************************************************************end`
+  );
+  fs.writeFileSync("error.txt", err + "\n", {
+    flag: "a",
+  });
+};
+
+/**
+ * 读取Excel
+ * @param {*} path Excel路径
+ * @returns JSON
+ */
+const readExcel = (path) => {
+  const workbook = XLSX.readFile(path);
+
+  // 获取第一个工作表（Sheet）
+  const firstSheetName = workbook.SheetNames[0];
+  const worksheet = workbook.Sheets[firstSheetName];
+
+  // 将工作表转换为 JSON 对象
+  const jsonData = XLSX.utils.sheet_to_json(worksheet);
+  return jsonData;
+};
+
+module.exports = {
+  readExcel,
+  logger,
+  disposeError,
+};

package/utils/settleFiles.js

@@ -0,0 +1,58 @@
+const fs = require("fs");
+const path = require("path");
+const { logger } = require("../utils/logger");
+
+function findFileInDir(dir, fileName) {
+  const files = fs.readdirSync(dir);
+  for (const file of files) {
+    const filePath = path.join(dir, file);
+    const stat = fs.statSync(filePath);
+    if (stat.isDirectory()) {
+      const result = findFileInDir(filePath, fileName);
+      if (result) {
+        return result;
+      }
+    } else if (file.startsWith(fileName)) {
+      return filePath;
+    }
+  }
+  return null;
+}
+
+function logFileSize(path) {
+  const fileSize = fs.statSync(path).size / (1024 * 1024);
+  const formattedSize = fileSize.toFixed(2); // 保留两位小数
+  logger(`音频大小：${formattedSize}M`);
+}
+
+/**
+ * 确保目录存在，如果不存在则创建它
+ */
+function ensureDirSync(dirpath) {
+  try {
+    if (!fs.existsSync(dirpath)) {
+      fs.mkdirSync(dirpath, { recursive: true });
+      logger(`目录创建成功：${dirpath}`);
+    }
+  } catch (err) {
+    logger(`创建目录时出错：${err}`);
+    throw err;
+  }
+}
+
+/**
+ * 上传失败后，存入新文件夹（手动创建）
+ */
+const moveFailFiles = (originFilePath, failPath) => {
+  if (originFilePath) {
+    fs.copyFileSync(originFilePath, failPath);
+    logger(`${originFilePath}上传失败，已移入错误文件夹！！！`);
+  }
+};
+
+module.exports = {
+  findFileInDir,
+  logFileSize,
+  ensureDirSync,
+  moveFailFiles,
+};