Usage - Musfiq0/enhanced-screens-comparison GitHub Wiki

📋 Usage Guide

Learn how to effectively use Enhanced Screenshot Comparison Tool for all your video comparison needs. Choose your preferred interface below for detailed documentation.

🚀 Quick Start

Choose Your Interface

Enhanced Screenshot Comparison Tool offers three interfaces to suit different user preferences and workflows:

🖱️ GUI (Graphical User Interface) - Recommended for Beginners

  • Visual drag & drop interface
  • Point-and-click configuration
  • Real-time preview and settings
  • Perfect for occasional use

👉 Complete GUI Documentation

⌨️ Console (Interactive CLI) - Great for Learning

  • Guided prompts and setup
  • Step-by-step configuration
  • Menu-driven interface
  • Learn all features interactively

👉 Complete Console Documentation

🚀 Advanced CLI - Professional Automation

  • Full command-line arguments
  • Scriptable and automatable
  • Batch processing capabilities
  • Maximum power and control

👉 Complete Advanced CLI Documentation

🎮 Getting Started

Using the Launcher (Recommended)

# Double-click or run:
START_HERE.bat

# Choose from the menu:
# 1. 🖼️ Launch GUI Application (Visual interface)
# 2. ⌨️ Run Console Version (Interactive)  
# 3. 🚀 Advanced CLI (Professional automation)
# 4. 🔨 Build Windows Executable

Direct Launch Methods

# GUI Mode (Visual interface)
python gui_app.py

# Console Mode (Interactive prompts)
python comparev2.py

# Advanced CLI Mode (Professional automation)
python comp-cli.py -h

� Interface Comparison

Feature GUI Console Advanced CLI
Ease of Use ★★★★★ ★★★★☆ ★★★☆☆
Learning Curve Minimal Gentle Moderate
Automation ★☆☆☆☆ ★☆☆☆☆ ★★★★★
Batch Processing ★★☆☆☆ ★★☆☆☆ ★★★★★
Visual Feedback ★★★★★ ★★★☆☆ ★★☆☆☆
Scripting Support ☆☆☆☆☆ ☆☆☆☆☆ ★★★★★
Remote Access ☆☆☆☆☆ ★★★★★ ★★★★★

🎯 Choose Based on Your Needs

🖱️ Choose GUI if you:

  • Prefer visual interfaces
  • Want drag & drop functionality
  • Need visual feedback during setup
  • Are new to video comparison
  • Process videos occasionally

⌨️ Choose Console if you:

  • Like terminal interfaces but want guidance
  • Want to learn all features step-by-step
  • Need remote access capabilities
  • Prefer interactive prompts
  • Want full feature access with help

🚀 Choose Advanced CLI if you:

  • Need automation and scripting
  • Process videos in batches
  • Want maximum control and efficiency
  • Are comfortable with command-line tools
  • Integrate with other workflows

🔧 Quick Feature Overview

Common Features (All Interfaces)

  • Video Processing: VapourSynth backend for professional quality
  • Crop & Resize: Extensive presets and custom options
  • Frame Selection: Custom frames or interval-based
  • Upload Integration: Direct slow.pics upload
  • Format Support: MP4, MKV, AVI, MOV, WMV, FLV, WEBM, M4V

Advanced Features

  • Trim & Padding: Process specific video segments
  • Individual Processing: Configure each video independently (CLI)
  • Batch Processing: Handle multiple videos efficiently (CLI)
  • Error Recovery: Robust handling of processing issues
  • Configuration Saving: Reuse complex setups (CLI)

🚀 Workflow Examples

Beginner Workflow (GUI)

  1. Launch GUI → Drag videos → Configure settings → Generate → Upload
  2. Time: 5-10 minutes per comparison
  3. Best for: Learning, occasional use

Intermediate Workflow (Console)

  1. Launch Console → Follow prompts → Configure each video → Process → Upload
  2. Time: 3-5 minutes per comparison
  3. Best for: Regular use, learning advanced features

Professional Workflow (Advanced CLI)

  1. Create configuration → Script batch processing → Automate uploads
  2. Time: Seconds per comparison (after setup)
  3. Best for: Production workflows, automation

📖 Documentation Links

Detailed Interface Guides

Additional Resources

🎯 Quick Help

Need Help Choosing?

  • First time user: Start with GUI
  • Comfortable with terminals: Try Console
  • Need automation: Use Advanced CLI

Common Questions

  • "Which is fastest?" - Advanced CLI for batch processing, GUI for single comparisons
  • "Which has most features?" - All interfaces have the same core features
  • "Can I switch between them?" - Yes! Output is compatible across all interfaces
  • "Which should I learn first?" - GUI → Console → Advanced CLI progression

Getting Support

  • Check the specific interface documentation for detailed instructions
  • Use python script.py --help for quick command references
  • Visit the wiki for comprehensive guides

Choose your preferred interface above and dive into the detailed documentation to become a video comparison expert! 🎬✨ 4. Stop anytime using the "Stop Processing" button if needed

Results

  • Local storage: Screenshots saved in organized folders
  • Automatic upload: (If enabled) Uploaded to slow.pics with proper naming
  • Browser opening: Results automatically open in your browser
  • Folder access: Direct access to output directories

⌨️ CLI Usage (Power Users)

The Enhanced Screenshot Comparison Tool offers three powerful CLI interfaces for different user needs:

🎯 Interactive CLI (comparev2.py) - Guided Experience

Perfect for users who want full functionality with guided setup:

python comparev2.py

Features:

  • Step-by-step prompts with intelligent defaults
  • Learn as you go - see all available options
  • Error recovery with helpful suggestions
  • Beginner-friendly while maintaining full power

⚡ Advanced CLI (comp-cli.py) - Professional Automation

Enhanced with Short Commands: Complete command-line interface with efficient short aliases:

# Quick help (short form)
python comp-cli.py -h
python comp-cli.py -lp          # List presets
python comp-cli.py -d           # Demo system

# Basic comparison (short form)
python comp-cli.py -V source.mkv encode.mkv -n "Source" "Encode"

# Professional workflow (short form)
python comp-cli.py -V netflix.mkv bluray.mkv webdl.mkv \\
    -n "Netflix" "Blu-ray" "Web-DL" \\
    -cp 2.40:1 -r 1080p -f 1000,5000,10000,15000 \\
    -u -ser "Attack on Titan" -sea 1 -epi 1

Key Features:

  • Short & Long commands - Use -V or --videos, -s or --source
  • Individual video processing - Per-video crop (-vc), resize (-vr), order (-vpo)
  • Efficient automation - Minimal typing for maximum functionality
  • Professional workflows - Encoding validation, release comparison

Quick Command Reference

Feature Short Long Example
Videos -V --videos -V file1.mkv file2.mkv
Source/Encode -s / -e --source / --encode -s orig.mkv -e enc.mkv
Crop -cp / -cc --crop-preset / --crop-custom -cp 2.35:1
Resolution -r / -rc --resolution / --resolution-custom -r 1080p
Frames -f / -fi --frames / --frames-interval -f 1000,5000
Upload -u --upload -u -col "Test"

NEW: Individual Video Processing (Short Form)

# Different settings per video
python comp-cli.py -V netflix.mkv amazon.mkv bluray.mkv \\
    -n "Netflix" "Amazon" "Blu-ray" \\
    -vc "netflix" "amazon" "2.40:1" \\
    -vr "1080p" "1080p" "none"

# Mixed processing order
python comp-cli.py -V dirty.mkv clean.mkv \\
    -vc "dirty-lines" "none" \\
    -vpo "crop-first" "resize-first"

Benefits:

  • Faster typing - Short commands for common operations
  • Optimized processing - Each video gets ideal treatment
  • Flexible workflows - Mix short and long forms as needed

🚀 Launcher Menu (START_HERE.bat) - Easy Access

Windows batch launcher providing easy access to all interfaces:

START_HERE.bat

Menu Options:

  1. GUI Application (Recommended) - Visual interface
  2. Interactive Console - Step-by-step CLI
  3. Advanced CLI - Professional automation
  4. Setup Development Environment
  5. Build Windows Executable
  6. System Maintenance Tools

📚 Advanced CLI Examples (Short Commands)

Quick Operations

# System check
python comp-cli.py -d           # Demo/check system
python comp-cli.py -lp          # List all presets

# Basic comparisons
python comp-cli.py -V source.mkv encode.mkv -n "Source" "Encode"
python comp-cli.py -m source-encode -s orig.mkv -e comp.mkv

# With crop and resolution
python comp-cli.py -V file1.mkv file2.mkv -cp 2.35:1 -r 1080p -u

Professional Workflows (Short Form)

Encoding Validation

# Quick encoding test
python comp-cli.py -m source-encode -s master.mkv -e x264.mkv \\
    -cp 2.35:1 -r 1080p -f 1500,4500,8500,12500 \\
    -u -col "x264 Quality Test"

Multi-Source Comparison

# Streaming service comparison
python comp-cli.py -V netflix.mkv amazon.mkv bluray.mkv \\
    -n "Netflix" "Prime" "Blu-ray" \\
    -cp streaming -r 1080p -fi 2000 -fc 8 \\
    -u -ser "Your Show" -sea 1 -epi 5

Individual Video Processing

# Different settings per video
python comp-cli.py -V netflix_4k.mkv amazon_hdr.mkv bluray_1080p.mkv \\
    -n "Netflix 4K" "Amazon HDR" "Blu-ray" \\
    -vc "netflix" "amazon" "0,138,0,138" \\
    -vr "1920x1080" "1920x1080" "none" \\
    -vpo "resize-first" "crop-first" "none" \\
    -u -col "Multi-Source Comparison"

# Quality issue handling  
python comp-cli.py -V dirty.mkv pillarbox.mkv clean.mkv \\
    -vc "dirty-lines" "pillarbox" "none" \\
    -vpo "crop-first" "crop-first" "resize-first" \\
    -r 1080p -u

Time & Frame Control

# Custom frames with trimming
python comp-cli.py -V video.mkv -cc 0,138,0,138 \\
    -ts 120 -te 60 -f 1000,5000,10000 -u

# Interval-based with offset
python comp-cli.py -V content.mkv -fi 3000 -fc 6 -fo 500 \\
    -cp streaming -r 1080p

Batch & Automation (Short Form)

# Save template
python comp-cli.py -V template.mkv -cp 2.35:1 -r 1080p \\
    -fi 1800 -fc 6 -scfg episode_template.json

# Use template  
python comp-cli.py -cfg episode_template.json \\
    -V S01E02_net.mkv S01E02_bd.mkv \\
    -n "Netflix S01E02" "Blu-ray S01E02" \\
    -u -ser "Your Series" -sea 1 -epi 2

# Upload existing screenshots
python comp-cli.py -uo -sd ./Screenshots/old_comparison/ \\
    -col "Previous Results" -nb

--processing-order resize-first \
--upload


### Individual Video Processing Examples

#### Mixed Quality Sources
```bash
# Handle different source qualities optimally
python comp-cli.py \
    --videos "netflix_4k.mkv" "amazon_1080p.mkv" "bluray_2160p.mkv" \
    --names "Netflix 4K" "Amazon 1080p" "Blu-ray 4K" \
    --video-crops "netflix" "amazon" "2.35:1" \
    --video-resolutions "1920x1080" "none" "1920x1080" \
    --video-processing-orders "resize-first" "crop-first" "resize-first" \
    --upload \
    --collection-name "Multi-Quality Comparison"

Streaming Service Comparison

# Compare different streaming services with their optimal settings
python comp-cli.py \
    --videos "netflix.mkv" "disney.mkv" "amazon.mkv" "hulu.mkv" \
    --names "Netflix" "Disney+" "Prime Video" "Hulu" \
    --video-crops "netflix" "disney" "amazon" "hulu" \
    --video-resolutions "1920x1080" "1920x1080" "1920x1080" "1920x1080" \
    --upload \
    --series-name "Streaming Service Comparison" \
    --season 1 --episode 1

Quality Issue Handling

# Handle various quality issues per video
python comp-cli.py \
    --videos "dirty_lines.mkv" "pillarboxed.mkv" "overscan.mkv" "clean.mkv" \
    --names "Dirty Source" "Pillarboxed" "Overscan Issue" "Clean Reference" \
    --video-crops "dirty-lines" "pillarbox" "overscan" "none" \
    --video-processing-orders "crop-first" "crop-first" "crop-first" "resize-first" \
    --video-resolutions "1920x1080" "1920x1080" "1920x1080" "none" \
    --upload \
    --collection-name "Quality Issue Comparison"

Batch Processing & Automation

Configuration File Workflow

# 1. Create configuration template
python comp-cli.py \
    --videos template1.mkv template2.mkv \
    --crop-preset 2.40:1 \
    --resolution 1080p \
    --frames-interval 1800 \
    --frames-count 6 \
    --save-config episode_template.json

# 2. Use template for batch processing
python comp-cli.py \
    --config episode_template.json \
    --videos "S01E01_netflix.mkv" "S01E01_bluray.mkv" \
    --names "Netflix S01E01" "Blu-ray S01E01" \
    --upload \
    --series-name "Your Series" \
    --season 1 --episode 1

# 3. Repeat for multiple episodes
python comp-cli.py \
    --config episode_template.json \
    --videos "S01E02_netflix.mkv" "S01E02_bluray.mkv" \
    --names "Netflix S01E02" "Blu-ray S01E02" \
    --upload \
    --series-name "Your Series" \
    --season 1 --episode 2

Upload Existing Screenshots

# Upload previously generated screenshots
python comp-cli.py \
    --upload-only \
    --screenshots-dir "./Screenshots/comparison_20250706_143022/" \
    --collection-name "Previous Comparison Results" \
    --no-browser

Advanced Frame Selection

Specific Frame Numbers

# Target specific frames (frame numbers)
python comp-cli.py \
    --videos source.mkv encode.mkv \
    --frames 1000,5000,10000,15000,20000,25000 \
    --crop-preset 2.40:1 \
    --resolution 1080p

Interval-Based Selection

# Generate frames at regular intervals
python comp-cli.py \
    --videos netflix.mkv bluray.mkv \
    --frames-interval 3000 \
    --frames-count 10 \
    --frames-offset 500 \
    --upload

Time-Based Processing

# Process specific time range with padding
python comp-cli.py \
    --videos movie_a.mkv movie_b.mkv \
    --trim-start 300 \
    --trim-end 180 \
    --pad-start 60 \
    --pad-end 30 \
    --frames-interval 2400 \
    --frames-count 12

Crop Presets & Custom Processing

Using Presets

# Cinema aspect ratios
python comp-cli.py --videos movie.mkv --crop-preset 2.35:1
python comp-cli.py --videos movie.mkv --crop-preset 2.40:1
python comp-cli.py --videos movie.mkv --crop-preset academy

# Streaming service presets
python comp-cli.py --videos show.mkv --crop-preset netflix
python comp-cli.py --videos show.mkv --crop-preset amazon
python comp-cli.py --videos show.mkv --crop-preset disney

# Common issues
python comp-cli.py --videos content.mkv --crop-preset dirty-lines
python comp-cli.py --videos content.mkv --crop-preset pillarbox
python comp-cli.py --videos content.mkv --crop-preset overscan

Custom Crop Values

# Custom crop (left,top,right,bottom pixels to remove)
python comp-cli.py \
    --videos source.mkv \
    --crop-custom 0,138,0,138 \
    --resolution 1080p

Resolution & Quality Options

Resolution Presets

# Standard resolutions
python comp-cli.py --videos video.mkv --resolution 480p
python comp-cli.py --videos video.mkv --resolution 720p  
python comp-cli.py --videos video.mkv --resolution 1080p
python comp-cli.py --videos video.mkv --resolution 1440p
python comp-cli.py --videos video.mkv --resolution 4k

# Custom resolution
python comp-cli.py \
    --videos video.mkv \
    --resolution-custom 1920x804

Resize Methods

# Common resolution for all videos
python comp-cli.py \
    --videos video1.mkv video2.mkv video3.mkv \
    --resize-method common \
    --resolution 1080p

# Individual optimal resolutions
python comp-cli.py \
    --videos video1.mkv video2.mkv \
    --resize-method individual

# No resizing
python comp-cli.py \
    --videos video1.mkv video2.mkv \
    --resize-method none

Error Handling & Debugging

Verbose Output

# Detailed processing information
python comp-cli.py \
    --videos source.mkv encode.mkv \
    --verbose \
    --upload

# Quiet mode for automation
python comp-cli.py \
    --videos source.mkv encode.mkv \
    --quiet \
    --upload \
    --no-browser

Integration Examples

CI/CD Pipeline

#!/bin/bash
# Automated encoding validation in CI/CD
python comp-cli.py \
    --mode source-encode \
    --source "${SOURCE_VIDEO}" \
    --encode "${ENCODED_OUTPUT}" \
    --crop-preset 2.35:1 \
    --resolution 1080p \
    --frames 1000,5000,10000 \
    --upload \
    --collection-name "CI Build ${BUILD_NUMBER}" \
    --quiet \
    --no-browser

Batch Script for Multiple Files

@echo off
REM Windows batch processing
for %%f in (*.mkv) do (
    python comp-cli.py ^
        --videos "%%f" "encoded_%%f" ^
        --names "Original" "Encoded" ^
        --crop-preset 2.40:1 ^
        --resolution 1080p ^
        --upload ^
        --collection-name "Batch %%f" ^
        --quiet
)

🔧 CLI Mode Comparison

Feature Interactive CLI Advanced CLI
Learning Curve Beginner-friendly Professional
Automation Limited Full
All Features ✅ ✅
Guided Setup ✅ ❌
Scripting ❌ ✅
Batch Processing ❌ ✅
Configuration Files ❌ ✅

Interactive CLI Workflow Example

# Start interactive mode
python comparev2.py

# Follow the prompts:
[?] Choose comparison mode:
  > Multiple Sources
    Source vs Encode

[?] How many videos to compare? 3

[Video 1] Select file: C:\Videos\source.mkv
[Video 1] Display name: Source
[Video 1] Crop preset: No Crop
[Video 1] Target resolution: 1080p

# ... repeat for each video

[?] Frame selection method:
    Interval
  > Custom frames

[?] Enter frame numbers (comma-separated): 1000,5000,10000

[✓] Processing complete!
[🌐] Uploading to slow.pics...
[✓] Upload complete: https://slow.pics/c/example123

Advanced CLI Quick Start

# Show all options
python comp-cli.py --help

# List available presets
python comp-cli.py --list-presets

# Check system capabilities
python comp-cli.py --demo

# Simple comparison
python comp-cli.py --videos file1.mkv file2.mkv

# Professional workflow with configuration
python comp-cli.py \
    --mode source-encode \
    --source original.mkv --encode compressed.mkv \
    --crop-preset netflix --resolution 1080p \
    --frames-interval 2000 --frames-count 8 \
    --upload --collection-name "Encoding Quality Test" \
    --save-config encoding_workflow.json

Command Line Options Summary

Interactive CLI (comparev2.py)

python comparev2.py --help     # Show help
python comparev2.py --demo     # Show backends
python comparev2.py --version  # Version info

Advanced CLI (comp-cli.py) - Short & Long Forms

# Video inputs (short/long)
-V / --videos FILE1 FILE2...        # Multiple videos
-s / --source FILE                  # Source video
-e / --encode FILE                  # Encode video  
-n / --names "Name1" "Name2"...     # Display names

# Processing (short/long)
-cp / --crop-preset PRESET         # Predefined crops
-cc / --crop-custom L,T,R,B        # Custom crop values
-r / --resolution PRESET           # Resolution presets
-po / --processing-order ORDER     # Global processing order

# Individual Video Processing (short/long)
-vc / --video-crops "c1" "c2"...           # Per-video crop settings
-vr / --video-resolutions "r1" "r2"...     # Per-video resolutions  
-vpo / --video-processing-orders "o1"...   # Per-video processing orders

# Frame selection (short/long)
-f / --frames F1,F2,F3...          # Specific frames
-fi / --frames-interval N          # Automatic intervals
-fc / --frames-count N             # Number of frames
-fo / --frames-offset N            # Starting offset

# Upload and output (short/long)
-u / --upload                      # Enable slow.pics upload
-col / --collection-name "Name"    # Upload collection name
-o / --output-dir PATH             # Custom output directory
-cfg / --config CONFIG.json       # Load configuration
-scfg / --save-config CONFIG.json # Save configuration

# Common short combinations
-ts / --trim-start N               # Trim start seconds
-te / --trim-end N                 # Trim end seconds  
-q / --quiet                       # Quiet mode
-v / --verbose                     # Verbose mode

💡 Pro Tip: Mix short and long forms! Use -V file1.mkv file2.mkv --collection-name "My Test"

When to Use Individual Video Processing

Use Individual Settings When:

  • Different source qualities: 4K vs 1080p vs 720p sources
  • Mixed streaming services: Each has different logo placement
  • Encoding artifacts: Some videos have dirty lines, others don't
  • Processing optimization: Prevent quality loss with proper order
  • Professional workflows: Maximum control over each video

Use Global Settings When:

  • Similar source material: All videos from same source
  • Batch processing: Consistent settings across multiple files
  • Simple comparisons: Basic source vs encode validation
  • Learning the tool: Start simple, then add individual settings

Examples of When Individual Processing Helps:

Mixed Quality Sources:

# 4K source needs downscaling, 1080p source doesn't
--video-resolutions "1920x1080" "none"

Different Streaming Services:

# Each service has logos in different positions
--video-crops "netflix" "amazon" "disney"

Dirty Source Handling:

# Remove artifacts before scaling to prevent spreading
--video-processing-orders "crop-first" "resize-first"

Professional Encoding Validation:

# Source needs full processing, encode is clean
--video-crops "dirty-lines" "none" \
--video-resolutions "1920x1080" "none"

🔧 Configuration Guide

Video Settings

Crop Presets

Choose from extensive presets:

  • Cinema Formats: 2.40:1, 2.35:1, 1.85:1 letterbox removal
  • Streaming Services: Logo removal for Netflix, Amazon, etc.
  • Technical: Dirty line removal, overscan correction
  • Custom: Manual crop specification

Resolution Options

  • 480p: 854×480 (Legacy/testing)
  • 720p: 1280×720 (Standard HD)
  • 1080p: 1920×1080 (Full HD, recommended)
  • 1440p: 2560×1440 (QHD)
  • 4K: 3840×2160 (Ultra HD)

Trim Settings

  • Start Time: Skip opening credits/intros
  • End Time: Skip ending credits/outros
  • Duration: Limit processing to specific segments

Global Settings

File Management

  • Auto-clear before: Remove old screenshots before generating new ones
  • Auto-clear after: Remove local screenshots after successful upload
  • Organized folders: Group screenshots by video source

Upload Configuration

  • Enable slow.pics: Automatic upload to comparison hosting
  • Episode support: Choose between single episode or season pack mode
  • Collection naming: Automatic "ShowName S01E01 source vs encode" format
  • Browser opening: Automatically open results in browser

Processing Settings

Backend Selection

The application automatically chooses the best available backend:

  1. VapourSynth (Highest quality, if installed)
  2. OpenCV (Reliable default)
  3. PIL (Universal fallback)

Performance Options

  • Frame interval: Balance between quality and processing time
  • Resolution scaling: Optimize for your hardware capabilities
  • Parallel processing: Automatic optimization based on system resources

🚀 Automation and Advanced Workflows

Professional Encoding Validation

Use the Advanced CLI for systematic encoding quality validation:

# Single encode validation
python comp-cli.py \
    --mode source-encode \
    --source "master/episode.mkv" \
    --encode "outputs/episode_x264.mkv" \
    --crop-preset 2.35:1 \
    --resolution 1080p \
    --frames-interval 2500 --frames-count 8 \
    --upload \
    --collection-name "Episode 1 - x264 Quality Check" \
    --verbose

Batch Processing Workflows

PowerShell Batch Script

# Process entire season with consistent settings
$sourceDir = "C:\Videos\Sources"
$encodeDir = "C:\Videos\Encoded" 
$episodes = Get-ChildItem $sourceDir -Filter "*.mkv"

foreach ($episode in $episodes) {
    $encodePath = Join-Path $encodeDir $episode.Name
    
    if (Test-Path $encodePath) {
        Write-Host "Processing: $($episode.BaseName)"
        
        & python comp-cli.py `
            --mode source-encode `
            --source $episode.FullName `
            --encode $encodePath `
            --crop-preset netflix `
            --resolution 1080p `
            --frames 1500,4500,8500,12500,16500 `
            --upload `
            --series-name "My Series" `
            --season 1 `
            --episode ($episodes.IndexOf($episode) + 1) `
            --verbose
            
        if ($LASTEXITCODE -eq 0) {
            Write-Host "SUCCESS: $($episode.BaseName)" -ForegroundColor Green
        } else {
            Write-Host "FAILED: $($episode.BaseName)" -ForegroundColor Red
        }
    }
}

Configuration File Approach

# Step 1: Create template configuration
python comp-cli.py \
    --videos template1.mkv template2.mkv \
    --crop-preset 2.40:1 \
    --resolution 1080p \
    --frames-interval 2000 \
    --frames-count 6 \
    --save-config series_template.json

# Step 2: Use template for multiple comparisons
python comp-cli.py \
    --config series_template.json \
    --videos "episode1_source.mkv" "episode1_encode.mkv" \
    --names "Source" "x265 Encode" \
    --upload --collection-name "Episode 1 Quality"

Continuous Integration Examples

GitHub Actions Workflow

name: Encoding Quality Check
on:
  push:
    paths: ['encoded/*.mkv']

jobs:
  quality-check:
    runs-on: windows-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Setup Python Environment
        uses: actions/setup-python@v4
        with:
          python-version: '3.11'
          
      - name: Install Dependencies
        run: pip install -r requirements.txt
        
      - name: Run Quality Comparison
        run: |
          python comp-cli.py \
            --mode source-encode \
            --source "sources/master.mkv" \
            --encode "encoded/compressed.mkv" \
            --frames 1000,5000,10000 \
            --resolution 1080p \
            --output-dir "./quality-results" \
            --save-config "quality-check.json"
            
      - name: Upload Artifacts
        uses: actions/upload-artifact@v3
        with:
          name: quality-comparison
          path: ./quality-results/

Release Comparison Workflows

Multi-Source Release Analysis

# Compare different release sources
python comp-cli.py \
    --videos \
        "releases/Series.S01E01.Netflix.mkv" \
        "releases/Series.S01E01.BluRay.mkv" \
        "releases/Series.S01E01.WebDL.mkv" \
        "releases/Series.S01E01.HDTV.mkv" \
    --names "Netflix" "Blu-ray" "Web-DL" "HDTV" \
    --crop-preset streaming \
    --resolution 1080p \
    --frames 2000,6000,10000,14000,18000 \
    --upload \
    --series-name "Series Name" \
    --season 1 --episode 1 \
    --collection-type single

Automated Season Processing

# Process entire season with organized output
for episode in {1..24}; do
    printf -v ep_num "%02d" $episode
    
    python comp-cli.py \
        --videos \
            "season1/S01E${ep_num}_source.mkv" \
            "season1/S01E${ep_num}_encode.mkv" \
        --names "Source" "Encode" \
        --mode source-encode \
        --crop-preset 2.35:1 \
        --resolution 1080p \
        --frames-interval 3000 \
        --frames-count 6 \
        --output-dir "comparisons/S01E${ep_num}" \
        --upload \
        --series-name "Series Name" \
        --season 1 --episode $episode \
        --quiet
        
    echo "Completed Episode ${ep_num}"
done

Quality Assurance Workflows

Encoder Comparison Matrix

# Compare multiple encoding methods
declare -a encoders=("x264" "x265" "av1" "vp9")
declare -a sources=("episode01.mkv" "episode02.mkv" "episode03.mkv")

for source in "${sources[@]}"; do
    episode_name=$(basename "$source" .mkv)
    
    # Create array of encoded versions
    encoded_files=()
    names=("Source")
    
    for encoder in "${encoders[@]}"; do
        encoded_file="encoded/${episode_name}_${encoder}.mkv"
        if [ -f "$encoded_file" ](/Musfiq0/enhanced-screens-comparison/wiki/--f-"$encoded_file"-); then
            encoded_files+=("$encoded_file")
            names+=("${encoder^^}")
        fi
    done
    
    # Run comparison
    python comp-cli.py \
        --videos "sources/$source" "${encoded_files[@]}" \
        --names "${names[@]}" \
        --crop-preset 2.40:1 \
        --resolution 1080p \
        --frames 1500,4500,8500,12500 \
        --upload \
        --collection-name "${episode_name} - Encoder Comparison" \
        --verbose
done

Integration with External Tools

FFmpeg Integration

# Pre-process videos before comparison
function prepare_and_compare() {
    local source="$1"
    local encode="$2"
    local temp_dir="temp_$(date +%s)"
    
    mkdir -p "$temp_dir"
    
    # Extract specific segment for focused comparison
    ffmpeg -i "$source" -ss 00:05:00 -t 00:02:00 -c copy "$temp_dir/source_segment.mkv"
    ffmpeg -i "$encode" -ss 00:05:00 -t 00:02:00 -c copy "$temp_dir/encode_segment.mkv"
    
    # Run comparison on segment
    python comp-cli.py \
        --mode source-encode \
        --source "$temp_dir/source_segment.mkv" \
        --encode "$temp_dir/encode_segment.mkv" \
        --frames 100,500,1000,1500,2000 \
        --resolution 1080p \
        --upload \
        --collection-name "$(basename "$source" .mkv) - Segment Analysis"
    
    # Cleanup
    rm -rf "$temp_dir"
}

# Usage
prepare_and_compare "master.mkv" "compressed.mkv"

MediaInfo Integration

# Generate comparison with technical details
function detailed_comparison() {
    local video1="$1"
    local video2="$2"
    
    # Get technical info
    echo "Technical Analysis:" > comparison_notes.txt
    echo "Source: $(mediainfo --Inform="Video;%Format% %Width%x%Height% %BitRate/String%" "$video1")" >> comparison_notes.txt
    echo "Encode: $(mediainfo --Inform="Video;%Format% %Width%x%Height% %BitRate/String%" "$video2")" >> comparison_notes.txt
    
    # Run comparison
    python comp-cli.py \
        --videos "$video1" "$video2" \
        --names "Source $(mediainfo --Inform="General;%FileSize/String%" "$video1")" \
                "Encode $(mediainfo --Inform="General;%FileSize/String%" "$video2")" \
        --mode source-encode \
        --frames 1000,5000,10000,15000 \
        --upload \
        --collection-name "Technical Comparison - $(basename "$video1" .mkv)" \
        --verbose
}

Monitoring and Reporting

Automated Quality Reports

# Generate weekly quality reports
#!/bin/bash
report_date=$(date +%Y%m%d)
report_dir="reports/quality_report_$report_date"
mkdir -p "$report_dir"

echo "Quality Report - $(date)" > "$report_dir/summary.txt"
echo "=============================" >> "$report_dir/summary.txt"

processed_count=0
failed_count=0

for source_file in pending_analysis/*.mkv; do
    if [ -f "$source_file" ](/Musfiq0/enhanced-screens-comparison/wiki/--f-"$source_file"-); then
        base_name=$(basename "$source_file" .mkv)
        encode_file="encoded/${base_name}_processed.mkv"
        
        if [ -f "$encode_file" ](/Musfiq0/enhanced-screens-comparison/wiki/--f-"$encode_file"-); then
            echo "Processing: $base_name" >> "$report_dir/summary.txt"
            
            if python comp-cli.py \
                --mode source-encode \
                --source "$source_file" \
                --encode "$encode_file" \
                --frames-interval 5000 \
                --frames-count 4 \
                --output-dir "$report_dir/$base_name" \
                --quiet; then
                
                echo "  ✅ SUCCESS" >> "$report_dir/summary.txt"
                ((processed_count++))
            else
                echo "  ❌ FAILED" >> "$report_dir/summary.txt"
                ((failed_count++))
            fi
        fi
    fi
done

echo "" >> "$report_dir/summary.txt"
echo "Summary:" >> "$report_dir/summary.txt"
echo "  Processed: $processed_count" >> "$report_dir/summary.txt"
echo "  Failed: $failed_count" >> "$report_dir/summary.txt"
echo "  Success Rate: $(( processed_count * 100 / (processed_count + failed_count) ))%" >> "$report_dir/summary.txt"

🐛 Troubleshooting

Common Issues

Video Loading Problems

# Check supported formats
python comparev2.py --demo

# Verify file integrity
# Try opening the video in a media player first

Processing Errors

  • Check file permissions: Ensure videos are accessible
  • Verify disk space: Screenshots require storage space
  • Try different backend: Use CLI demo mode to check available backends
  • Reduce resolution: If processing 4K fails, try 1080p

Upload Failures

  • Check internet connection: Ensure stable connectivity
  • Use retry function: "Upload Existing" button in GUI
  • Manual upload: Screenshots are saved locally as backup

Performance Issues

  • Close other applications: Free up system resources
  • Lower target resolution: Reduce processing load
  • Use interval mode: Instead of many custom frames
  • Check available RAM: 8GB+ recommended for 4K processing

Error Messages

"VapourSynth not found"

# This is normal if VapourSynth isn't installed
# Application automatically falls back to OpenCV
# Install VapourSynth for higher quality processing

"Could not open video file"

  • Verify file path and permissions
  • Check if video file is corrupted
  • Try copying file to a simpler path (no special characters)

"Upload failed"

  • Check internet connectivity
  • slow.pics might be temporarily unavailable
  • Use local screenshots as backup

Getting Help

Debug Information

# Show system information
python comparev2.py --demo

# Check dependencies
python -c "import cv2, numpy, PIL; print('Core dependencies OK')"

Support Resources

  1. Check the FAQ above
  2. Review relevant wiki pages for detailed guidance
  3. Open an issue on the GitHub repository with:
    • Error messages
    • System information
    • Steps to reproduce

💡 Tips and Best Practices

Workflow Optimization

  • Use meaningful names: "Netflix 1080p" vs "Local Encode"
  • Consistent settings: Use same resolution/crop for fair comparisons
  • Strategic frame selection: Choose scenes with detail, motion, or challenging content
  • Test with small batches: Start with 2-3 videos before large comparisons

Quality Guidelines

  • Install VapourSynth: For professional-quality processing
  • Choose appropriate resolution: Match or slightly exceed source resolution
  • Use proper crops: Remove letterboxes for accurate comparisons
  • Select good frames: Avoid static scenes or fade transitions

Sharing Results

  • Use descriptive collection names: Include show name, episode, sources
  • Include context: Add notes about encoding settings or source types
  • Organize uploads: Use episode support for season comparisons
  • Backup locally: Keep local copies before clearing screenshots

🎯 Advanced Usage

Batch Processing

  1. Prepare video files in organized folders
  2. Use consistent naming for easy identification
  3. Configure templates for recurring comparison types
  4. Use CLI mode for scripting and automation

Custom Workflows

  • Episode series: Use episode support for consistent naming
  • Quality testing: Compare different encoding parameters
  • Source analysis: Compare different masters or releases
  • Format testing: Evaluate different video formats

Integration Options

  • Scripting: CLI mode supports automation
  • File organization: Structured output for further processing
  • Upload APIs: Results compatible with various hosting services
  • Metadata preservation: Source information maintained in outputs

📖 Additional Documentation

Advanced CLI Reference

For complete Advanced CLI documentation with detailed examples, configuration file formats, and professional workflow guides:

👉 Advanced CLI Documentation

Other Resources

Master these usage patterns and you'll be creating professional video comparisons in no time! 🚀