@doedja/scenecut 1.0.1 → 1.0.2

package/README.md

@@ -4,10 +4,15 @@ Fast, accurate scene change detection for Node.js using Xvid's motion estimation
 
 ## Features
 
-- **Fast**: WebAssembly-accelerated motion estimation (35-45 fps on typical hardware)
-- **Accurate**: Uses Xvid's proven motion estimation algorithm from vapoursynth-wwxd
-- **Multiple output formats**: Aegisub keyframes, timecodes, CSV, JSON
-- **Easy to use**: Simple CLI and programmatic API
+- **Fast**: WebAssembly-accelerated motion estimation with SIMD, double-buffered frame pipeline, and quick-reject filtering
+- **Accurate**: Uses Xvid's proven motion estimation algorithm with configurable thresholds that actually work
+- **Confidence scoring**: Each scene change includes a 0-1 confidence score from the motion estimator
+- **Fade/dissolve detection**: Catches gradual transitions that per-frame analysis misses
+- **Temporal smoothing**: Optional sliding window filter to suppress false positives and flash frames
+- **Multiple output formats**: Aegisub keyframes, timecodes, CSV (with confidence + duration), JSON
+- **Scene duration**: Each scene includes duration and frame count
+- **Cancellable**: AbortController support with `--timeout` for long videos
+- **Batch thumbnails**: Extract scene images in a single FFmpeg pass
 - **Cross-platform**: Works on Windows, Linux, and macOS
 
 ## Installation
@@ -30,7 +35,6 @@ npm install @doedja/scenecut
 
 ```bash
 # Simple - detects scenes and saves to Aegisub format (default)
-# Creates input_keyframes.txt
 scenecut "input.mkv"
 
 # Specify custom output filename
@@ -39,11 +43,20 @@ scenecut "video.mkv" -o keyframes.txt
 # For timecode output
 scenecut "video.mp4" --format timecode -o timecodes.txt
 
-# JSON format with full metadata
+# JSON format with full metadata, confidence, and duration
 scenecut "movie.avi" --format json
 
 # CSV format for spreadsheet analysis
 scenecut "movie.avi" --format csv -o scenes.csv
+
+# High sensitivity for subtle scene changes
+scenecut "anime.mkv" --sensitivity high --verbose
+
+# Abort after 2 minutes
+scenecut "long-movie.mkv" --timeout 120
+
+# Extract scene thumbnails
+scenecut "video.mp4" --thumbnails ./thumbs
 ```
 
 ### CLI Options
@@ -52,26 +65,20 @@ scenecut "movie.avi" --format csv -o scenes.csv
 |--------|-------|-------------|---------|
 | `--format` | `-f` | Output format: `aegisub`, `json`, `csv`, `timecode` | `aegisub` |
 | `--output` | `-o` | Output file path | `{filename}_keyframes.txt` |
-| `--sensitivity` | `-s` | Detection sensitivity: `low`, `medium`, `high` | `medium` |
+| `--sensitivity` | `-s` | Detection sensitivity: `low`, `medium`, `high` | `low` |
+| `--timeout` | `-t` | Abort after N seconds | no timeout |
+| `--thumbnails` | | Extract scene thumbnails to directory | - |
 | `--quiet` | `-q` | Suppress progress output | `false` |
-| `--verbose` | `-v` | Show detailed output including each scene | `false` |
+| `--verbose` | `-v` | Show detailed output including confidence | `false` |
 | `--help` | `-h` | Show help message | - |
 
-### Examples
-
-```bash
-# Default - creates anime_keyframes.txt in Aegisub format
-scenecut "anime.mkv"
-
-# High sensitivity for subtle scene changes
-scenecut "anime.mkv" --sensitivity high
-
-# JSON format with full metadata
-scenecut "video.mp4" --format json -o results.json
+### Sensitivity Levels
 
-# Verbose mode with detailed scene information
-scenecut "movie.mkv" --verbose
-```
+| Level | IntraThresh | IntraThresh2 | Use case |
+|-------|------------|-------------|----------|
+| `low` | 3000 | 150 | Fewer detections, only hard cuts (default) |
+| `medium` | 2000 | 90 | Balanced |
+| `high` | 1000 | 50 | More detections, catches subtle transitions |
 
 ## Output Formats
 
@@ -89,33 +96,23 @@ fps 23.976
 
 **Aegisub Workflow:**
 1. Generate keyframes: `scenecut "video.mkv" -f aegisub -o keyframes.txt`
-2. In Aegisub: **Video** → **Open Keyframes** → Select `keyframes.txt`
+2. In Aegisub: **Video** > **Open Keyframes** > Select `keyframes.txt`
 3. Keyframes appear as visual markers on the timeline for precise subtitle timing
 
-### Timecode Format (`.txt`)
-
-Simple timecode list (HH:MM:SS.mmm):
-
-```
-00:00:00.000
-00:00:05.964
-00:00:11.970
-```
-
 ### CSV Format (`.csv`)
 
-Spreadsheet-compatible format:
+Includes confidence scores and scene durations:
 
 ```csv
-frame,timestamp,timecode
-0,0.0,00:00:00.000
-143,5.964,00:00:05.964
-287,11.970,00:00:11.970
+frame,timestamp,timecode,confidence,duration,frameCount
+0,0.0,00:00:00.000,1.0000,5.964,143
+143,5.964,00:00:05.964,0.7234,6.006,144
+287,11.970,00:00:11.970,0.8912,4.171,100
 ```
 
 ### JSON Format (`.json`)
 
-Complete metadata and scene information:
+Complete metadata with confidence, duration, and codec info:
 
 ```json
 {
@@ -123,26 +120,46 @@ Complete metadata and scene information:
     {
       "frameNumber": 0,
       "timestamp": 0.0,
-      "timecode": "00:00:00.000"
+      "timecode": "00:00:00.000",
+      "confidence": 1.0,
+      "duration": 5.964,
+      "frameCount": 143
     },
     {
       "frameNumber": 143,
       "timestamp": 5.964,
-      "timecode": "00:00:05.964"
+      "timecode": "00:00:05.964",
+      "confidence": 0.7234,
+      "duration": 6.006,
+      "frameCount": 144
     }
   ],
   "metadata": {
     "totalFrames": 3000,
     "duration": 125.08,
     "fps": 23.976,
-    "resolution": {
-      "width": 1920,
-      "height": 1080
-    }
+    "resolution": { "width": 1920, "height": 1080 },
+    "codec": "h264",
+    "pixelFormat": "yuv420p",
+    "bitrate": 5000000
+  },
+  "stats": {
+    "processingTime": 28.5,
+    "framesPerSecond": 105.2
   }
 }
 ```
 
+### Timecode Format (`.txt`)
+
+Simple timecode list (HH:MM:SS.mmm):
+
+```
+00:00:00.000
+00:00:05.964
+00:00:11.970
+```
+
 ## Programmatic API
 
 ### Basic Usage
@@ -150,43 +167,62 @@ Complete metadata and scene information:
 ```javascript
 const { detectSceneChanges } = require('@doedja/scenecut');
 
-(async () => {
-  const results = await detectSceneChanges('input.mp4');
+const results = await detectSceneChanges('input.mp4');
 
-  console.log(`Found ${results.scenes.length} scenes`);
-  results.scenes.forEach(scene => {
-    console.log(`Scene at frame ${scene.frameNumber} (${scene.timecode})`);
-  });
-})();
+console.log(`Found ${results.scenes.length} scenes`);
+results.scenes.forEach(scene => {
+  console.log(`Scene at ${scene.timecode} (confidence: ${(scene.confidence * 100).toFixed(0)}%, duration: ${scene.duration?.toFixed(1)}s)`);
+});
 ```
 
-### Advanced Usage with Options
+### Advanced Usage
 
 ```javascript
 const { detectSceneChanges } = require('@doedja/scenecut');
 
+const controller = new AbortController();
+
+// Auto-cancel after 60 seconds
+setTimeout(() => controller.abort(), 60000);
+
 const results = await detectSceneChanges('input.mp4', {
-  sensitivity: 'high',        // 'low' | 'medium' | 'high'
-  searchRange: 'medium',      // Motion search range
+  sensitivity: 'high',
+  searchRange: 'medium',
+  signal: controller.signal,
+
+  // Temporal smoothing to reduce false positives
+  temporalSmoothing: {
+    enabled: true,
+    windowSize: 5,
+    minConsecutive: 2
+  },
 
-  // Progress callback
   onProgress: (progress) => {
-    console.log(`Progress: ${progress.percent}%`);
-    console.log(`Frame: ${progress.currentFrame}/${progress.totalFrames}`);
-    console.log(`FPS: ${progress.fps}, ETA: ${progress.eta}s`);
+    console.log(`${progress.percent}% | ${progress.fps?.toFixed(1)} fps | ETA: ${progress.eta?.toFixed(0)}s | ${progress.scenesDetected} scenes`);
   },
 
-  // Scene detection callback
   onScene: (scene) => {
-    console.log(`Scene detected at frame ${scene.frameNumber}`);
-    console.log(`Timecode: ${scene.timecode}`);
+    console.log(`Scene at frame ${scene.frameNumber} (${scene.timecode}) confidence: ${scene.confidence?.toFixed(2)}`);
   }
 });
 
-console.log('Detection complete!');
 console.log(`Total scenes: ${results.scenes.length}`);
-console.log(`Video duration: ${results.metadata.duration}s`);
-console.log(`Resolution: ${results.metadata.resolution.width}x${results.metadata.resolution.height}`);
+console.log(`Video: ${results.metadata.codec} ${results.metadata.resolution.width}x${results.metadata.resolution.height}`);
+```
+
+### Extract Scene Thumbnails
+
+```javascript
+const { extractSceneImages } = require('@doedja/scenecut');
+
+const results = await extractSceneImages('input.mp4', {
+  sensitivity: 'low'
+}, {
+  outputDir: './thumbnails',
+  format: 'jpg',
+  quality: 85,
+  filenameTemplate: 'scene_{frame}'
+});
 ```
 
 ### API Reference
@@ -197,69 +233,89 @@ Detects scene changes in a video file.
 
 **Parameters:**
 - `videoPath` (string): Path to input video file
-- `options` (object, optional):
-  - `sensitivity` ('low' | 'medium' | 'high'): Detection sensitivity (default: 'medium')
-  - `searchRange` ('auto' | 'small' | 'medium' | 'large'): Motion search range (default: 'medium')
-  - `onProgress` (function): Callback for progress updates
+- `options` (DetectionOptions, optional):
+  - `sensitivity` ('low' | 'medium' | 'high' | 'custom'): Detection sensitivity
+  - `customThresholds` ({ intraThresh, intraThresh2 }): Custom threshold values (when sensitivity='custom')
+  - `searchRange` ('auto' | 'small' | 'medium' | 'large'): Motion search range
+  - `signal` (AbortSignal): For cancellation support
+  - `temporalSmoothing` ({ enabled, windowSize, minConsecutive }): Temporal smoothing config
+  - `onProgress` (function): Progress callback with fps, eta, scenesDetected
   - `onScene` (function): Callback for each detected scene
 
-**Returns:** Promise<DetectionResult>
+**Returns:** `Promise<DetectionResult>`
 
-**DetectionResult:**
 ```typescript
-{
+interface DetectionResult {
   scenes: Array<{
     frameNumber: number;
-    timestamp: number;      // Seconds
-    timecode: string;       // HH:MM:SS.mmm
+    timestamp: number;        // Seconds
+    timecode: string;         // HH:MM:SS.mmm
+    confidence: number;       // 0-1
+    duration: number;         // Seconds until next scene
+    frameCount: number;       // Frames until next scene
   }>;
   metadata: {
     totalFrames: number;
-    duration: number;       // Seconds
+    duration: number;
     fps: number;
-    resolution: {
-      width: number;
-      height: number;
-    };
+    resolution: { width: number; height: number };
+    codec?: string;
+    pixelFormat?: string;
+    bitrate?: number;
+  };
+  stats: {
+    processingTime: number;
+    framesPerSecond: number;
   };
 }
 ```
 
-## Supported Video Formats
+#### `extractSceneImages(videoPath, options?, imageOptions?)`
 
-Keyframes supports any video format that FFmpeg can decode, including:
+Detects scenes and extracts thumbnail images in a single FFmpeg pass.
 
-- MP4 (`.mp4`, `.m4v`)
-- Matroska (`.mkv`)
-- AVI (`.avi`)
-- WebM (`.webm`)
-- MOV (`.mov`)
-- FLV (`.flv`)
-- And many more...
+**Additional parameter:**
+- `imageOptions` (FrameImageOptions):
+  - `outputDir` (string): Output directory
+  - `format` ('jpg' | 'png' | 'bmp'): Image format
+  - `quality` (number): JPEG quality 1-100
+  - `width` (number): Output width (maintains aspect ratio)
+  - `filenameTemplate` (string): Use `{frame}` and `{timestamp}` placeholders
 
 ## How It Works
 
-Keyframes uses Xvid's motion estimation algorithm to detect scene changes:
-
-1. **Frame Extraction**: FFmpeg extracts grayscale frames from the video
-2. **Motion Analysis**: WebAssembly-compiled C code analyzes motion vectors between consecutive frames
-3. **Scene Detection**: Frames with high motion complexity are identified as scene changes
-4. **Output Formatting**: Results are formatted according to the requested output format
-
-The algorithm is based on [vapoursynth-wwxd](https://github.com/dubhater/vapoursynth-wwxd) by dubhater, which itself uses Xvid's motion estimation code.
+1. **Frame Extraction**: FFmpeg extracts grayscale frames via streaming ring buffer with zero-copy alternating buffers
+2. **Quick Reject**: Sampled pixel comparison (every 64th pixel) skips nearly-identical frames without touching WASM
+3. **Motion Analysis**: WebAssembly-compiled Xvid motion estimation with configurable thresholds and SIMD acceleration
+4. **Confidence Scoring**: Raw sSAD scores are normalized to 0-1 confidence values
+5. **Fade Detection**: Drift comparison against last keyframe catches gradual dissolves lasting 30+ frames
+6. **Temporal Smoothing**: Optional sliding window filter suppresses flashes and merges detection clusters
+7. **Double Buffering**: Previous frame stays in WASM memory between calls, halving memory copies
 
 ## Performance
 
-Optimized for speed and accuracy:
-- **Processing speed**: 35-45 fps on 1080p video (modern hardware)
-- **Memory usage**: ~200-300 MB with efficient buffer management
-- **Accuracy**: Matches vapoursynth-wwxd output (100% accurate)
-- **Optimizations**: WASM SIMD, pre-allocated buffers, ring buffer streaming
+- **Processing speed**: 80-150+ fps on 1080p video (with quick-reject, most frames skip WASM entirely)
+- **Memory usage**: ~200-300 MB with pre-allocated WASM buffers and buffer pooling
+- **4K support**: Auto-sized ring buffer scales to any resolution
+- **Optimizations**: WASM SIMD, double-buffered frames, pre-allocated macroblock array, zero-alloc frame extraction, quick-reject filtering
 
 ## Requirements
 
 - **Node.js**: 18.0.0 or higher
-- **FFmpeg**: Automatically installed via `@ffmpeg-installer/ffmpeg`
+- **FFmpeg & FFprobe**: Automatically installed via `@ffmpeg-installer/ffmpeg` and `@ffprobe-installer/ffprobe`
+
+## Building from Source
+
+```bash
+# Install dependencies
+npm install
+
+# Build WASM (requires Emscripten SDK)
+npm run build:wasm
+
+# Build TypeScript + bundle
+npm run build
+```
 
 ## License
 
@@ -269,12 +325,7 @@ This project is based on:
 - [vapoursynth-wwxd](https://github.com/dubhater/vapoursynth-wwxd) by dubhater (GPL-2.0)
 - Xvid's motion estimation algorithm (GPL-2.0)
 
-## Contributing
-
-Contributions are welcome! Please feel free to submit issues or pull requests.
-
 ## Credits
 
 - Original vapoursynth-wwxd plugin: [dubhater](https://github.com/dubhater)
 - Xvid motion estimation algorithm: [Xvid Team](https://www.xvid.com)
-- JavaScript/WASM port: This project

package/bin/cli.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 /**
  * Keyframes CLI - Simple command-line interface for scene detection
@@ -9,7 +9,7 @@
  *   keyframes video.mp4 --sensitivity high
  */
 
-const { detectSceneChanges } = require('../dist/keyframes.cjs.js');
+const { detectSceneChanges, extractSceneImages } = require('../dist/keyframes.cjs.js');
 const path = require('path');
 const fs = require('fs');
 
@@ -28,18 +28,21 @@ Examples:
   scenecut video.mkv --output keyframes.txt --format aegisub
   scenecut movie.mp4 --sensitivity high --format timecode
   scenecut video.mp4 --format csv --output scenes.csv
+  scenecut video.mp4 --thumbnails ./thumbs --timeout 120
 
 Options:
   --output, -o <file>       Output file (default: {filename}_keyframes.txt)
   --format, -f <format>     Output format: json|csv|aegisub|timecode (default: aegisub)
-  --sensitivity, -s <level> Sensitivity: low|medium|high (default: medium)
+  --sensitivity, -s <level> Sensitivity: low|medium|high (default: low)
+  --timeout, -t <seconds>   Abort after N seconds (default: no timeout)
+  --thumbnails <dir>        Extract scene thumbnails to directory
   --quiet, -q               Suppress progress output
   --verbose, -v             Show detailed output
   --help, -h                Show this help
 
 Formats:
-  json                      JSON with full metadata
-  csv                       CSV with frame,timestamp,timecode
+  json                      JSON with full metadata, confidence, and duration
+  csv                       CSV with frame,timestamp,timecode,confidence,duration
   aegisub (or txt)          Aegisub keyframes format (frame numbers)
   timecode (or tc)          Simple timecode list (HH:MM:SS.mmm)
 
@@ -60,9 +63,11 @@ if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
 let videoPath = null;
 let outputPath = null; // Will be derived from video filename if not specified
 let outputFormat = 'aegisub'; // Default to Aegisub format
-let sensitivity = 'medium';
+let sensitivity = 'low';
 let quiet = false;
 let verbose = false;
+let timeout = 0;
+let thumbnailDir = null;
 
 for (let i = 0; i < args.length; i++) {
   const arg = args[i];
@@ -73,6 +78,10 @@ for (let i = 0; i < args.length; i++) {
     outputFormat = args[++i];
   } else if (arg === '--sensitivity' || arg === '-s') {
     sensitivity = args[++i];
+  } else if (arg === '--timeout' || arg === '-t') {
+    timeout = parseInt(args[++i], 10);
+  } else if (arg === '--thumbnails') {
+    thumbnailDir = args[++i];
   } else if (arg === '--quiet' || arg === '-q') {
     quiet = true;
   } else if (arg === '--verbose' || arg === '-v') {
@@ -122,6 +131,12 @@ async function run() {
     console.log(`Input:  ${videoPath}`);
     console.log(`Size:   ${fileSize} MB`);
     console.log(`Output: ${path.resolve(outputPath)}`);
+    if (timeout > 0) {
+      console.log(`Timeout: ${timeout}s`);
+    }
+    if (thumbnailDir) {
+      console.log(`Thumbnails: ${path.resolve(thumbnailDir)}`);
+    }
     console.log('='.repeat(60));
     console.log();
   }
@@ -131,26 +146,35 @@ async function run() {
   let lastProgressFrame = 0;
   let sceneCount = 0;
 
+  // Set up AbortController for timeout
+  let controller = null;
+  let timeoutHandle = null;
+  if (timeout > 0) {
+    controller = new AbortController();
+    timeoutHandle = setTimeout(() => {
+      controller.abort();
+    }, timeout * 1000);
+  }
+
   try {
-    const results = await detectSceneChanges(videoPath, {
+    const options = {
       sensitivity,
       searchRange: 'medium',
+      signal: controller ? controller.signal : undefined,
       onProgress: (progress) => {
         if (quiet) return;
 
         const now = Date.now();
         // Update every 3 seconds
         if (now - lastProgressTime > 3000 || progress.percent === 100) {
-          const framesSinceLastUpdate = progress.currentFrame - lastProgressFrame;
-          const timeSinceLastUpdate = (now - lastProgressTime) / 1000;
-          const currentFps = framesSinceLastUpdate / timeSinceLastUpdate;
-
+          const fps = progress.fps || 0;
           const progressBar = createProgressBar(progress.percent);
           const etaStr = progress.eta ? ` ETA: ${formatTime(progress.eta)}` : '';
+          const scenesStr = progress.scenesDetected ? ` [${progress.scenesDetected} scenes]` : '';
 
           process.stdout.write(
             `\r${progressBar} ${progress.percent.toString().padStart(3)}% ` +
-            `[${currentFps.toFixed(1)} fps]${etaStr}${' '.repeat(10)}`
+            `[${fps.toFixed(1)} fps]${etaStr}${scenesStr}${' '.repeat(10)}`
           );
 
           lastProgressTime = now;
@@ -160,11 +184,27 @@ async function run() {
       onScene: (scene) => {
         sceneCount++;
         if (verbose && !quiet) {
+          const confidenceStr = scene.confidence != null ? ` (confidence: ${(scene.confidence * 100).toFixed(0)}%)` : '';
           console.log();
-          console.log(`  Scene ${sceneCount}: Frame ${scene.frameNumber} at ${scene.timecode}`);
+          console.log(`  Scene ${sceneCount}: Frame ${scene.frameNumber} at ${scene.timecode}${confidenceStr}`);
         }
       }
-    });
+    };
+
+    let results;
+    if (thumbnailDir) {
+      results = await extractSceneImages(videoPath, options, {
+        outputDir: thumbnailDir,
+        format: 'jpg',
+        quality: 85
+      });
+    } else {
+      results = await detectSceneChanges(videoPath, options);
+    }
+
+    if (timeoutHandle) {
+      clearTimeout(timeoutHandle);
+    }
 
     const endTime = Date.now();
     const elapsed = (endTime - startTime) / 1000;
@@ -177,6 +217,15 @@ async function run() {
       console.log(`Scenes detected:  ${results.scenes.length}`);
       console.log(`Processing time:  ${formatTime(elapsed)}`);
       console.log(`Processing speed: ${(results.metadata.totalFrames / elapsed).toFixed(1)} fps`);
+      if (results.metadata.codec) {
+        console.log(`Video codec:      ${results.metadata.codec}`);
+      }
+      if (results.metadata.pixelFormat) {
+        console.log(`Pixel format:     ${results.metadata.pixelFormat}`);
+      }
+      if (results.metadata.bitrate) {
+        console.log(`Bitrate:          ${(results.metadata.bitrate / 1000).toFixed(0)} kbps`);
+      }
       console.log('='.repeat(60));
     }
 
@@ -193,7 +242,7 @@ async function run() {
         outputPath = outputPath.replace('.json', '.txt');
       }
     } else if (outputFormat === 'timecode' || outputFormat === 'tc') {
-      output = formatTimecode(results);
+      output = formatTimecodeList(results);
       if (outputPath.endsWith('.json')) {
         outputPath = outputPath.replace('.json', '.txt');
       }
@@ -206,13 +255,17 @@ async function run() {
 
     if (!quiet) {
       console.log(`Results saved to: ${path.resolve(outputPath)}`);
-      console.log();
 
-      // Print scene list
-      console.log('Scene List:');
-      results.scenes.forEach((scene, i) => {
-        console.log(`  ${(i + 1).toString().padStart(3)}. Frame ${scene.frameNumber.toString().padStart(6)} at ${scene.timecode}`);
-      });
+      if (verbose) {
+        console.log();
+        // Print scene list
+        console.log('Scene List:');
+        results.scenes.forEach((scene, i) => {
+          const confidenceStr = scene.confidence != null ? ` (${(scene.confidence * 100).toFixed(0)}%)` : '';
+          const durationStr = scene.duration != null ? ` [${formatTime(scene.duration)}]` : '';
+          console.log(`  ${(i + 1).toString().padStart(3)}. Frame ${scene.frameNumber.toString().padStart(6)} at ${scene.timecode}${confidenceStr}${durationStr}`);
+        });
+      }
     } else {
       // In quiet mode, just print the output
       console.log(output);
@@ -221,6 +274,16 @@ async function run() {
     process.exit(0);
 
   } catch (error) {
+    if (timeoutHandle) {
+      clearTimeout(timeoutHandle);
+    }
+
+    if (error.message === 'Detection aborted') {
+      console.error();
+      console.error('Detection aborted (timeout or cancellation).');
+      process.exit(2);
+    }
+
     console.error();
     console.error('Error:', error.message);
     if (verbose) {
@@ -235,7 +298,7 @@ function createProgressBar(percent) {
   const width = 30;
   const filled = Math.round((percent / 100) * width);
   const empty = width - filled;
-  return '[' + '█'.repeat(filled) + '░'.repeat(empty) + ']';
+  return '[' + '\u2588'.repeat(filled) + '\u2591'.repeat(empty) + ']';
 }
 
 function formatTime(seconds) {
@@ -253,9 +316,12 @@ function formatTime(seconds) {
 }
 
 function formatCSV(results) {
-  let csv = 'frame,timestamp,timecode\n';
+  let csv = 'frame,timestamp,timecode,confidence,duration,frameCount\n';
   results.scenes.forEach(scene => {
-    csv += `${scene.frameNumber},${scene.timestamp},${scene.timecode || ''}\n`;
+    const conf = scene.confidence != null ? scene.confidence.toFixed(4) : '';
+    const dur = scene.duration != null ? scene.duration.toFixed(3) : '';
+    const fc = scene.frameCount != null ? scene.frameCount : '';
+    csv += `${scene.frameNumber},${scene.timestamp},${scene.timecode || ''},${conf},${dur},${fc}\n`;
   });
   return csv;
 }
@@ -271,7 +337,7 @@ function formatAegisub(results) {
   return output;
 }
 
-function formatTimecode(results) {
+function formatTimecodeList(results) {
   // Simple timecode list - one per line
   // Can be used with various subtitle tools
   let output = '';