oximedia-cli 0.1.8

Command-line interface for OxiMedia
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

//! Video stabilisation command.
//!
//! Provides `oximedia stabilize` using `oximedia-stabilize` to remove unwanted
//! camera shake via configurable motion models and quality presets.

use anyhow::{Context, Result};
use colored::Colorize;
use std::path::PathBuf;

/// Options for the `stabilize` command.
pub struct StabilizeOptions {
    pub input: PathBuf,
    pub output: PathBuf,
    pub mode: String,
    pub quality: String,
    pub smoothing: u32,
    pub zoom: bool,
}

/// Entry point called from `main.rs`.
pub async fn run_stabilize(opts: StabilizeOptions, json_output: bool) -> Result<()> {
    use oximedia_stabilize::{StabilizeConfig, Stabilizer};

    let stab_mode = parse_mode(&opts.mode)?;
    let quality = parse_quality(&opts.quality)?;

    // Smoothing strength as normalised 0.0-1.0 from the frame-count window
    let smoothing_strength = (opts.smoothing as f64 / 100.0).clamp(0.01, 1.0);

    let config = StabilizeConfig::new()
        .with_mode(stab_mode)
        .with_quality(quality)
        .with_smoothing_strength(smoothing_strength)
        .with_zoom_optimization(opts.zoom);

    config
        .validate()
        .with_context(|| "Invalid stabilisation configuration")?;

    let _stabilizer =
        Stabilizer::new(config.clone()).with_context(|| "Failed to initialise Stabilizer")?;

    if json_output {
        let obj = serde_json::json!({
            "operation": "stabilize",
            "input": opts.input.to_string_lossy(),
            "output": opts.output.to_string_lossy(),
            "mode": opts.mode,
            "quality": opts.quality,
            "smoothing_frames": opts.smoothing,
            "smoothing_strength": smoothing_strength,
            "zoom": opts.zoom,
            "enable_multipass": config.enable_multipass,
            "feature_count": config.feature_count,
        });
        println!("{}", serde_json::to_string_pretty(&obj)?);
        return Ok(());
    }

    println!("{}", "Video Stabilise".green().bold());
    println!("  Input:            {}", opts.input.display());
    println!("  Output:           {}", opts.output.display());
    println!("  Mode:             {}", mode_label(&opts.mode).cyan());
    println!(
        "  Quality:          {}",
        quality_label(&opts.quality).cyan()
    );
    println!("  Smoothing window: {} frames", opts.smoothing);
    println!("  Smoothing str.:   {:.3}", smoothing_strength);
    println!(
        "  Auto-zoom:        {}",
        if opts.zoom { "yes" } else { "no" }
    );
    println!("  Multi-pass:       {}", config.enable_multipass);
    println!("  Feature count:    {}", config.feature_count);

    println!(
        "\n{} Stabiliser configured. Full frame pipeline requires I/O integration.",
        "Note:".yellow()
    );
    println!("{} {}", "Would write:".dimmed(), opts.output.display());

    Ok(())
}

/// Map CLI mode string to `StabilizationMode`.
fn parse_mode(mode: &str) -> Result<oximedia_stabilize::StabilizationMode> {
    use oximedia_stabilize::StabilizationMode;
    match mode.to_lowercase().as_str() {
        "translation" => Ok(StabilizationMode::Translation),
        "affine" => Ok(StabilizationMode::Affine),
        "perspective" => Ok(StabilizationMode::Perspective),
        "3d" | "threed" => Ok(StabilizationMode::ThreeD),
        other => anyhow::bail!(
            "Unknown stabilisation mode '{}'. Use: translation, affine, perspective, 3d",
            other
        ),
    }
}

/// Map CLI quality string to `QualityPreset`.
fn parse_quality(quality: &str) -> Result<oximedia_stabilize::QualityPreset> {
    use oximedia_stabilize::QualityPreset;
    match quality.to_lowercase().as_str() {
        "fast" => Ok(QualityPreset::Fast),
        "balanced" => Ok(QualityPreset::Balanced),
        "maximum" | "max" => Ok(QualityPreset::Maximum),
        other => anyhow::bail!(
            "Unknown quality preset '{}'. Use: fast, balanced, maximum",
            other
        ),
    }
}

fn mode_label(mode: &str) -> &'static str {
    match mode.to_lowercase().as_str() {
        "translation" => "Translation",
        "affine" => "Affine",
        "perspective" => "Perspective",
        "3d" => "3D",
        _ => "Unknown",
    }
}

fn quality_label(quality: &str) -> &'static str {
    match quality.to_lowercase().as_str() {
        "fast" => "Fast",
        "balanced" => "Balanced",
        "maximum" | "max" => "Maximum",
        _ => "Unknown",
    }
}