Add bitrate input type

Author: aNNiMON

src/model.rs

@@ -1,4 +1,8 @@
-use std::sync::Arc;
+use std::{
+    fmt::{Display, Formatter},
+    str::FromStr,
+    sync::Arc,
+};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) enum Pane {
@@ -15,6 +19,50 @@ pub(crate) struct TrimData {
     pub(crate) precise: bool,
 }
 
+#[derive(Debug, PartialEq)]
+pub(crate) enum BitrateType {
+    K,
+    M,
+}
+pub(crate) struct Bitrate(pub u32, pub BitrateType);
+
+impl Display for BitrateType {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", if *self == BitrateType::K { "k" } else { "M" })
+    }
+}
+
+impl Display for Bitrate {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        if self.0 == 0 {
+            write!(f, "0")
+        } else {
+            write!(f, "{}{}", self.0, self.1)
+        }
+    }
+}
+
+impl FromStr for Bitrate {
+    type Err = &'static str;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let s = s.trim();
+        let (value_str, unit_str) = s
+            .find(|c: char| !c.is_ascii_digit())
+            .map_or((s, ""), |idx| s.split_at(idx));
+        if value_str.is_empty() {
+            Ok(Bitrate(0, BitrateType::K))
+        } else {
+            let value = value_str.parse::<u32>().map_err(|_| "Invalid value")?;
+            let unit = match unit_str.to_ascii_lowercase().as_str() {
+                "" | "k" | "K" => BitrateType::K,
+                "m" | "M" => BitrateType::M,
+                _ => return Err("Invalid unit"),
+            };
+            Ok(Bitrate(value, unit))
+        }
+    }
+}
+
 pub(crate) type ValidationCallback = Arc<dyn Fn(&str) -> Result<String, &str> + Send + Sync>;
 pub(crate) type ValueFormatter = Arc<dyn Fn(&str) -> String + Send + Sync>;
 
@@ -23,6 +71,7 @@ pub(crate) enum InputType {
     Integer,
     PositiveInteger,
     PositiveDecimal,
+    Bitrate,
 }
 
 #[derive(Debug, Clone, Copy)]

src/params/parameter.rs

@@ -208,7 +208,7 @@ impl Parameter {
                     name: Arc::from(self.name.clone()), // todo: global param name to Arc
                     value: value.clone(),
                     constraints: *constraints,
-                    validator: Arc::clone(&validator),
+                    validator: Arc::clone(validator),
                 }));
             }
             ParameterData::Trim(data) => {

src/params/video_bitrate.rs

@@ -1,5 +1,8 @@
+use std::sync::Arc;
+
 use crate::{
-    params::{Parameter, ParameterData, SelectOption, macros::select_non_default_option},
+    model::{Bitrate, BitrateType, InputConstraints, InputType},
+    params::{Parameter, ParameterData, SelectOption, macros::select_non_default_custom_value},
     visitors::CommandBuilder,
 };
 
@@ -8,26 +11,54 @@ pub(crate) struct VideoBitrate;
 impl VideoBitrate {
     pub(crate) const ID: &'static str = "vbitrate";
     pub(crate) const NAME: &'static str = "Video Bitrate";
-    const DEFAULT: &'static str = "auto";
+    const DEFAULT: &'static str = "0";
     const VARIANTS: [&str; 12] = [
-        "16k", "32k", "auto", "64k", "128k", "256k", "512k", "1M", "2M", "4M", "8M", "16M",
+        "16k", "32k", "0", "64k", "128k", "256k", "512k", "1M", "2M", "4M", "8M", "16M",
     ];
 
     pub fn new_parameter() -> Parameter {
         Parameter::new(
             Self::ID,
             Self::NAME,
-            ParameterData::Select {
+            ParameterData::CustomSelect {
                 options: SelectOption::from_slice(&Self::VARIANTS),
                 selected_index: 2,
+                value: Self::DEFAULT.to_owned(),
+                constraints: InputConstraints {
+                    length: 5,
+                    input_type: InputType::Bitrate,
+                },
+                validator: Arc::new(Self::validate),
+                formatter: Some(Arc::new(Self::format_value)),
             },
         )
     }
 
+    fn validate(value: &str) -> Result<String, &str> {
+        if let Ok(bitrate) = value.parse::<Bitrate>()
+            && let Bitrate(value, unit) = &bitrate
+            && (*value == 0
+                || ((4..=9999).contains(value) && *unit == BitrateType::K)
+                || ((1..=999).contains(value) && *unit == BitrateType::M))
+        {
+            Ok(bitrate.to_string())
+        } else {
+            Err("Invalid value. Expected a number in range 4k..999M, or 0 - auto")
+        }
+    }
+
+    fn format_value(value: &str) -> String {
+        if value == Self::DEFAULT {
+            "auto".to_owned()
+        } else {
+            value.to_owned()
+        }
+    }
+
     pub fn build_command(cb: &mut CommandBuilder, data: &ParameterData) {
-        if let Some(option) = select_non_default_option!(data) {
+        if let Some(value) = select_non_default_custom_value!(data) {
             cb.args.push("-b:v".into());
-            cb.args.push(option.value.clone());
+            cb.args.push(Self::format_value(value));
         }
     }
 }

src/ui/modal_custom_select.rs

@@ -82,6 +82,9 @@ impl KeyboardHandler for CustomSelectModal {
                     | (InputType::PositiveDecimal, '0'..='9' | '.') => {
                         self.input.handle_event(&Event::Key(key));
                     }
+                    (InputType::Bitrate, '0'..='9' | 'k' | 'K' | 'm' | 'M') => {
+                        self.input.handle_event(&Event::Key(key));
+                    }
                     _ => {}
                 }
             }