image-video-optimizer 3.0.0 → 3.0.1

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('1.0.0')
+  .version('3.0.1')
   .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.0",
+  "version": "3.0.1",
   "description": "CLI tool to optimize and compress images and videos with configurable settings",
   "main": "src/index.js",
   "bin": {

package/src/videoProcessor.js

@@ -1,134 +1,140 @@
 const ffmpeg = require('fluent-ffmpeg');
+const fs = require('fs');
 const path = require('path');
-const fs = require('fs').promises;
-
-// Set ffmpeg and ffprobe paths if using static binaries
-try {
-  const ffmpegStatic = require('ffmpeg-static');
-  const ffprobeStatic = require('ffprobe-static');
-  ffmpeg.setFfmpegPath(ffmpegStatic);
-  ffmpeg.setFfprobePath(ffprobeStatic.path);
-} catch (error) {
-  // Fallback to system ffmpeg/ffprobe if static binaries not available
-  console.warn('Note: ffmpeg-static not found, using system ffmpeg/ffprobe');
-}
 
 /**
- * Get video metadata (width, height, duration, etc.)
- * @param {string} videoPath - Path to video file
- * @returns {Promise<Object>} Video metadata
+ * 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}>}
  */
-function getVideoMetadata(videoPath) {
-  return new Promise((resolve, reject) => {
-    ffmpeg.ffprobe(videoPath, (err, metadata) => {
-      if (err) {
-        reject(new Error(`Could not read video metadata: ${err.message}`));
-      } else {
-        const videoStream = metadata.streams.find(s => s.codec_type === 'video');
-        if (videoStream) {
-          resolve({
-            width: videoStream.width,
-            height: videoStream.height,
-            duration: metadata.format.duration,
-            codec: videoStream.codec_name,
-            bitrate: metadata.format.bit_rate
+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
           });
-        } else {
-          reject(new Error('No video stream found in file'));
         }
-      }
-    });
-  });
-}
-
-/**
- * Process (resize and encode) a video
- * @param {string} inputPath - Path to input video
- * @param {string} outputPath - Path to output video
- * @param {Object} config - Configuration object
- * @returns {Promise<Object>} Processing result
- */
-function processVideo(inputPath, outputPath, config) {
-  return new Promise(async (resolve) => {
-    try {
-      const metadata = await getVideoMetadata(inputPath);
-      const currentWidth = metadata.width;
-      const currentHeight = metadata.height;
-      const maxWidth = parseInt(config.video_max_width) || 720;
-      const videoEncode = config.video_encode || 'h264';
 
-      let command = ffmpeg(inputPath)
-        .videoCodec(videoEncode)
-        .audioCodec('aac')
-        .audioChannels(2)
-        .audioFrequency(48000)
-        .format('mp4');
+        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');
 
-      // Only resize if video is wider than max_width
-      if (currentWidth > maxWidth) {
-        const scaleFactor = maxWidth / currentWidth;
-        const newHeight = Math.round(currentHeight * scaleFactor);
+        // Create ffmpeg command
+        // Map codec names to ffmpeg codec names
+        const codecMap = {
+          'h264': 'libx264',
+          'h265': 'libx265',
+          'vp8': 'libvpx',
+          'vp9': 'libvpx-vp9'
+        };
         
-        // Ensure dimensions are even (required for most codecs)
-        const finalHeight = newHeight % 2 === 0 ? newHeight : newHeight - 1;
-        const finalWidth = maxWidth % 2 === 0 ? maxWidth : maxWidth - 1;
+        const outputCodec = codecMap[config.video_encode.toLowerCase()] || config.video_encode || 'libx264';
         
-        command = command.size(`${finalWidth}x${finalHeight}`);
-      }
+        const command = ffmpeg(videoPath)
+          .videoCodec(outputCodec)
+          .size(`${config.video_max_width}x?`)
+          .outputOptions([
+            '-preset fast',
+            '-crf 28',
+            '-c:a aac'  // Use AAC for audio (widely compatible)
+          ])
+          .output(tmpPath);
 
-      // Set bitrate based on resolution to maintain quality while reducing size
-      const bitrate = currentWidth > maxWidth ? '2000k' : '3000k';
-      command = command.videoBitrate(bitrate);
+        command
+          .on('end', async () => {
+            try {
+              const tmpStat = await new Promise((res, rej) => {
+                fs.stat(tmpPath, (err, stat) => {
+                  if (err) rej(err);
+                  else res(stat);
+                });
+              });
 
-      command
-        .on('start', (cmdline) => {
-          // Processing started
-        })
-        .on('end', () => {
-          resolve({
-            success: true,
-            inputPath,
-            outputPath,
-            originalWidth: currentWidth,
-            originalHeight: currentHeight,
-            resized: currentWidth > maxWidth,
-            duration: metadata.duration
-          });
-        })
-        .on('error', (err) => {
-          resolve({
-            success: false,
-            inputPath,
-            error: err.message
-          });
-        })
-        .output(outputPath)
-        .run();
+              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);
 
+                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);
+
+                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 = `Video codec error. Check available codecs with: ffmpeg -encoders | grep lib`;
+              } else if (err.message.includes('is not available')) {
+                errorMsg = `Codec not available. Verify FFmpeg installation: ffmpeg -version`;
+              } else if (err.message.includes('ENOENT') || err.message.includes('ffmpeg')) {
+                errorMsg = `FFmpeg not found. Install with: brew install ffmpeg (macOS) or apt-get install ffmpeg (Linux)`;
+              } else if (err.message.includes('Conversion failed') || err.message.includes('exited with code')) {
+                errorMsg = `Video encoding failed. Try a different codec in config: video_encode=h265 or video_encode=vp8`;
+              }
+              
+              resolve({
+                success: false,
+                originalSize,
+                optimizedSize: 0,
+                message: `✗ ${path.basename(videoPath)} - ${errorMsg}`,
+                error: true
+              });
+            });
+          })
+          .run();
+      });
     } catch (error) {
       resolve({
         success: false,
-        inputPath,
-        error: error.message
+        originalSize: 0,
+        optimizedSize: 0,
+        message: `✗ ${path.basename(videoPath)} - Error: ${error.message}`,
+        error: true
       });
     }
   });
 }
 
-/**
- * Check if ffmpeg is available on the system
- * @returns {Promise<boolean>} True if ffmpeg is available
- */
-function isFfmpegAvailable() {
-  return new Promise((resolve) => {
-    ffmpeg.getAvailableFormats((err) => {
-      resolve(!err);
-    });
-  });
-}
-
 module.exports = {
-  processVideo,
-  getVideoMetadata,
-  isFfmpegAvailable
+  processVideo
 };