image-video-optimizer 1.0.0 → 1.1.1

package/README.md

@@ -141,4 +141,4 @@ Download from [ffmpeg.org](https://ffmpeg.org/download.html) and add to PATH
 
 ## License
 
-MIT
+nirvána

package/package.json

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

package/src/imageProcessor.js

@@ -25,11 +25,61 @@ class ImageProcessor {
       }
 
       const outputPath = this.generateOutputPath(inputPath, targetFormat);
+      const parsedPath = path.parse(inputPath);
       
       // Check if output path would be same as input path
       if (outputPath === inputPath) {
-        console.log(`Output path same as input, skipping: ${path.basename(inputPath)}`);
-        return { processed: false, reason: 'same_path' };
+        // Use temporary name for processing
+        const tempPath = path.join(parsedPath.dir, `${parsedPath.name}_temp.${targetFormat}`);
+        console.log(`Using temporary path for processing: ${path.basename(tempPath)}`);
+        
+        let sharpInstance = sharp(inputPath);
+        
+        if (needsResize) {
+          const newHeight = Math.round((maxWidth / metadata.width) * metadata.height);
+          sharpInstance = sharpInstance.resize(maxWidth, newHeight, {
+            fit: 'inside',
+            withoutEnlargement: true
+          });
+          console.log(`Resizing to: ${maxWidth}x${newHeight}`);
+        }
+        
+        switch (targetFormat.toLowerCase()) {
+          case 'jpg':
+          case 'jpeg':
+            sharpInstance = sharpInstance.jpeg({ quality: 85 });
+            break;
+          case 'png':
+            sharpInstance = sharpInstance.png({ compressionLevel: 8 });
+            break;
+          case 'webp':
+            sharpInstance = sharpInstance.webp({ quality: 85 });
+            break;
+          default:
+            sharpInstance = sharpInstance.jpeg({ quality: 85 });
+        }
+        
+        await sharpInstance.toFile(tempPath);
+        
+        const compressionResult = this.checkCompression(inputPath, tempPath);
+        
+        if (compressionResult.effective) {
+          // Replace original with processed file
+          fs.unlinkSync(inputPath);
+          fs.renameSync(tempPath, outputPath);
+          console.log(`✓ Processed: ${path.basename(inputPath)} (${compressionResult.compressionPercent}% reduction)`);
+          return {
+            processed: true,
+            outputPath,
+            originalSize: compressionResult.originalSize,
+            newSize: compressionResult.newSize,
+            compressionPercent: compressionResult.compressionPercent
+          };
+        } else {
+          console.log(`✗ Ineffective compression, keeping original: ${path.basename(inputPath)}`);
+          fs.unlinkSync(tempPath);
+          return { processed: false, reason: 'ineffective_compression' };
+        }
       }
       
       let sharpInstance = sharp(inputPath);

package/src/videoProcessor.js

@@ -44,6 +44,74 @@ class VideoProcessor {
             return;
           }
           
+          const outputPath = this.generateOutputPath(inputPath);
+          const parsedPath = path.parse(inputPath);
+          
+          // Check if output path would be same as input path
+          if (outputPath === inputPath) {
+            // Use temporary name for processing
+            const tempPath = path.join(parsedPath.dir, `${parsedPath.name}_temp.mp4`);
+            console.log(`Using temporary path for processing: ${path.basename(tempPath)}`);
+            
+            let ffmpegCommand = ffmpeg(inputPath);
+            
+            if (needsResize) {
+              const newHeight = Math.round((maxWidth / videoStream.width) * videoStream.height);
+              ffmpegCommand = ffmpegCommand.videoFilters(`scale=${maxWidth}:${newHeight}`);
+              console.log(`Resizing to: ${maxWidth}x${newHeight}`);
+            }
+            
+            switch (encodeFormat.toLowerCase()) {
+              case 'h264':
+                ffmpegCommand = ffmpegCommand.videoCodec('libx264').audioCodec('aac');
+                break;
+              case 'h265':
+                ffmpegCommand = ffmpegCommand.videoCodec('libx265').audioCodec('aac');
+                break;
+              case 'vp9':
+                ffmpegCommand = ffmpegCommand.videoCodec('libvpx-vp9').audioCodec('libvorbis');
+                break;
+              default:
+                ffmpegCommand = ffmpegCommand.videoCodec('libx264').audioCodec('aac');
+            }
+            
+            ffmpegCommand
+              .outputOptions('-crf 23')
+              .outputOptions('-preset medium')
+              .format('mp4')
+              .output(tempPath)
+              .on('end', () => {
+                const compressionResult = this.checkCompression(inputPath, tempPath);
+                
+                if (compressionResult.effective) {
+                  // Replace original with processed file
+                  fs.unlinkSync(inputPath);
+                  fs.renameSync(tempPath, outputPath);
+                  console.log(`✓ Processed: ${path.basename(inputPath)} (${compressionResult.compressionPercent}% reduction)`);
+                  resolve({
+                    processed: true,
+                    outputPath,
+                    originalSize: compressionResult.originalSize,
+                    newSize: compressionResult.newSize,
+                    compressionPercent: compressionResult.compressionPercent
+                  });
+                } else {
+                  console.log(`✗ Ineffective compression, keeping original: ${path.basename(inputPath)}`);
+                  fs.unlinkSync(tempPath);
+                  resolve({ processed: false, reason: 'ineffective_compression' });
+                }
+              })
+              .on('error', (err) => {
+                console.error(`Error processing video ${inputPath}:`, err.message);
+                if (fs.existsSync(tempPath)) {
+                  fs.unlinkSync(tempPath);
+                }
+                resolve({ processed: false, error: err.message });
+              })
+              .run();
+            return;
+          }
+          
           let ffmpegCommand = ffmpeg(inputPath);
           
           if (needsResize) {
@@ -98,7 +166,6 @@ class VideoProcessor {
             })
             .run();
         });
-        
       } catch (error) {
         console.error(`Error processing video ${inputPath}:`, error.message);
         resolve({ processed: false, error: error.message });