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
⌨️ 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)
- Launch GUI → Drag videos → Configure settings → Generate → Upload
- Time: 5-10 minutes per comparison
- Best for: Learning, occasional use
Intermediate Workflow (Console)
- Launch Console → Follow prompts → Configure each video → Process → Upload
- Time: 3-5 minutes per comparison
- Best for: Regular use, learning advanced features
Professional Workflow (Advanced CLI)
- Create configuration → Script batch processing → Automate uploads
- Time: Seconds per comparison (after setup)
- Best for: Production workflows, automation
📖 Documentation Links
Detailed Interface Guides
- GUI Documentation - Complete visual interface guide
- Console Documentation - Interactive CLI reference
- Advanced CLI Documentation - Professional automation guide
Additional Resources
- Installation Guide - Setup and requirements
- Configuration Guide - Advanced settings and presets
- Features Overview - Complete feature list
- Troubleshooting - Common issues and solutions
🎯 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:
- GUI Application (Recommended) - Visual interface
- Interactive Console - Step-by-step CLI
- Advanced CLI - Professional automation
- Setup Development Environment
- Build Windows Executable
- 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:
- VapourSynth (Highest quality, if installed)
- OpenCV (Reliable default)
- 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
- Check the FAQ above
- Review relevant wiki pages for detailed guidance
- 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
- Prepare video files in organized folders
- Use consistent naming for easy identification
- Configure templates for recurring comparison types
- 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:
Other Resources
- Features Overview - Complete feature list and capabilities
- Console Interface - Interactive CLI reference
- Configuration - Settings and customization options
- Installation - Setup and requirements
Master these usage patterns and you'll be creating professional video comparisons in no time! 🚀