image-video-optimizer 3.0.4 → 3.0.5

package/bin/cli.js

@@ -7,7 +7,7 @@ const optimizer = require('../src/index');
 program
   .name('image-video-optimizer')
   .description('Optimize and compress images and videos in a directory')
-  .version('3.0.1')
+  .version('3.0.5')
   .argument('[target-dir]', 'Target directory to optimize (default: current directory)', process.cwd())
   .action(async (targetDir) => {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "image-video-optimizer",
-  "version": "3.0.4",
+  "version": "3.0.5",
   "description": "CLI tool to optimize and compress images and videos with configurable settings",
   "main": "src/index.js",
   "bin": {

package/src/videoProcessor.js

@@ -1,113 +1,141 @@
+const ffmpeg = require('fluent-ffmpeg');
 const fs = require('fs');
-const sharp = require('sharp');
 const path = require('path');
 
 /**
- * Process a single image file
- * @param {string} imagePath - Path to the image
+ * Process a single video file
+ * @param {string} videoPath - Path to the video
  * @param {object} config - Configuration object
  * @returns {Promise<{success: boolean, originalSize: number, optimizedSize: number, message: string}>}
  */
-async function processImage(imagePath, config) {
-  try {
-    const stat = await fs.promises.stat(imagePath);
-    const originalSize = stat.size;
-    const tmpPath = imagePath + '.tmp';
-    const ext = path.extname(imagePath).toLowerCase();
-    const directory = path.dirname(imagePath);
-    const filename = path.basename(imagePath, ext);
+async function processVideo(videoPath, config) {
+  return new Promise((resolve) => {
+    try {
+      fs.stat(videoPath, async (err, stat) => {
+        if (err) {
+          return resolve({
+            success: false,
+            originalSize: 0,
+            optimizedSize: 0,
+            message: `✗ ${path.basename(videoPath)} - Cannot access file`,
+            error: true
+          });
+        }
 
-    // Determine output format
-    const outputFormat = config.img_format.toLowerCase();
-    const outputExt = outputFormat === 'jpg' ? '.jpg' : `.${outputFormat}`;
-    const finalPath = path.join(directory, filename + outputExt);
+        const originalSize = stat.size;
+        const tmpPath = videoPath + '.tmp.mp4';
+        const ext = path.extname(videoPath).toLowerCase();
+        const directory = path.dirname(videoPath);
+        const filename = path.basename(videoPath, ext);
+        const finalPath = path.join(directory, filename + '.mp4');
 
-    // Check if format conversion is needed
-    const needsFormatConversion = ext !== outputExt && ext !== (outputFormat === 'jpg' ? '.jpeg' : outputExt);
+        // Create ffmpeg command
+        // Map codec names to ffmpeg codec names
+        const codecMap = {
+          'h264': 'libx264',
+          'h265': 'libx265',
+          'vp8': 'libvpx',
+          'vp9': 'libvpx-vp9'
+        };
+        
+        const outputCodec = codecMap[config.video_encode.toLowerCase()] || config.video_encode || 'libx264';
+        
+        const command = ffmpeg(videoPath)
+          .videoCodec(outputCodec)
+          .size(`${config.video_max_width}x?`)
+          .outputOptions([
+            '-preset fast',
+            '-crf 28'
+          ])
+          .output(tmpPath);
 
-    // Read and process image
-    let image = sharp(imagePath);
+        command
+          .on('end', async () => {
+            try {
+              const tmpStat = await new Promise((res, rej) => {
+                fs.stat(tmpPath, (err, stat) => {
+                  if (err) rej(err);
+                  else res(stat);
+                });
+              });
 
-    // Get image metadata
-    const metadata = await image.metadata();
+              const optimizedSize = tmpStat.size;
 
-    // Resize if width exceeds max_width
-    let wasResized = false;
-    if (metadata.width > config.img_max_width) {
-      image = image.resize(config.img_max_width, null, {
-        withoutEnlargement: true
-      });
-      wasResized = true;
-    }
-
-    // Convert to target format with optimization
-    if (outputFormat === 'jpg' || outputFormat === 'jpeg') {
-      image = image.jpeg({ quality: 80, progressive: true });
-    } else if (outputFormat === 'png') {
-      image = image.png({ compressionLevel: 9 });
-    } else if (outputFormat === 'webp') {
-      image = image.webp({ quality: 80 });
-    } else if (outputFormat === 'gif') {
-      image = image.gif();
-    } else if (outputFormat === 'tiff') {
-      image = image.tiff();
-    } else {
-      // Default to jpeg for unknown formats
-      image = image.jpeg({ quality: 80, progressive: true });
-    }
-
-    // Write to temporary file
-    await image.toFile(tmpPath);
-
-    // Check if optimized file is smaller
-    const tmpStat = await fs.promises.stat(tmpPath);
-    const optimizedSize = tmpStat.size;
+              if (optimizedSize < originalSize) {
+                // Remove original and rename temp to final
+                await fs.promises.unlink(videoPath);
+                await fs.promises.rename(tmpPath, finalPath);
 
-    // Decide whether to replace: if smaller OR if format conversion needed OR if resized
-    const shouldReplace = optimizedSize < originalSize || needsFormatConversion || wasResized;
+                resolve({
+                  success: true,
+                  originalSize,
+                  optimizedSize,
+                  message: `✓ ${path.basename(videoPath)} → ${path.basename(finalPath)} (${(originalSize / 1024 / 1024).toFixed(1)}MB → ${(optimizedSize / 1024 / 1024).toFixed(1)}MB)`,
+                  filePath: finalPath
+                });
+              } else {
+                // Remove temp file if not smaller
+                await fs.promises.unlink(tmpPath);
 
-    if (shouldReplace) {
-      // Remove original and rename temp to final path
-      if (finalPath !== imagePath) {
-        await fs.promises.unlink(imagePath);
-      }
-      await fs.promises.rename(tmpPath, finalPath);
-
-      const action = needsFormatConversion ? `${path.basename(imagePath)} → ${path.basename(finalPath)}` : path.basename(finalPath);
-      const sizeInfo = optimizedSize < originalSize 
-        ? `(${(originalSize / 1024).toFixed(1)}KB → ${(optimizedSize / 1024).toFixed(1)}KB)`
-        : `(${(originalSize / 1024).toFixed(1)}KB)`;
-
-      return {
-        success: true,
-        originalSize,
-        optimizedSize,
-        message: `✓ ${action} ${sizeInfo}`,
-        filePath: finalPath
-      };
-    } else {
-      // Remove temp file if not replacing
-      await fs.promises.unlink(tmpPath);
-
-      return {
+                resolve({
+                  success: false,
+                  originalSize,
+                  optimizedSize,
+                  message: `○ ${path.basename(videoPath)} - Already optimized (${(originalSize / 1024 / 1024).toFixed(1)}MB)`,
+                  filePath: videoPath
+                });
+              }
+            } catch (error) {
+              resolve({
+                success: false,
+                originalSize,
+                optimizedSize: 0,
+                message: `✗ ${path.basename(videoPath)} - Post-processing error: ${error.message}`,
+                error: true
+              });
+            }
+          })
+          .on('error', (err) => {
+            // Clean up temp file on error
+            fs.unlink(tmpPath, () => {
+              let errorMsg = err.message;
+              
+              // Provide helpful suggestions for common errors
+              if (err.message.includes('Unknown encoder') || err.message.includes('Encoder (')) {
+                errorMsg = `Codec "${outputCodec}" not supported. Try: video_encode=h264`;
+              } else if (err.message.includes('No such file') || err.message.includes('does not exist')) {
+                errorMsg = `Input file not found or cannot be read`;
+              } else if (err.message.includes('ENOENT') || err.message.includes('ffmpeg')) {
+                errorMsg = `FFmpeg not found. Install with: brew install ffmpeg`;
+              } else if (err.message.includes('Conversion failed') || err.message.includes('exited with code')) {
+                errorMsg = `Video encoding failed. Check file format and try different codec`;
+              } else {
+                errorMsg = `Encoding error: ${err.message.substring(0, 80)}`;
+              }
+              
+              resolve({
+                success: false,
+                originalSize,
+                optimizedSize: 0,
+                message: `✗ ${path.basename(videoPath)} - ${errorMsg}`,
+                error: true
+              });
+            });
+          })
+          .run();
+      });
+    } catch (error) {
+      resolve({
         success: false,
-        originalSize,
-        optimizedSize,
-        message: `○ ${path.basename(imagePath)} - Already optimized (${(originalSize / 1024).toFixed(1)}KB)`,
-        filePath: imagePath
-      };
+        originalSize: 0,
+        optimizedSize: 0,
+        message: `✗ ${path.basename(videoPath)} - Error: ${error.message}`,
+        error: true
+      });
     }
-  } catch (error) {
-    return {
-      success: false,
-      originalSize: 0,
-      optimizedSize: 0,
-      message: `✗ ${path.basename(imagePath)} - Error: ${error.message}`,
-      error: true
-    };
-  }
+  });
 }
 
 module.exports = {
-  processImage
+  processVideo
 };