use std::sync::Arc;
use std::fmt;
+pub use crate::compr::deflate::{DEFLATE_MODE_DESCRIPTION, DEFLATE_OPTION_VALUES, DEFLATE_MODE_NONE, DEFLATE_MODE_FAST, DEFLATE_MODE_BETTER, DEFLATE_MODE_BEST};
+
+/// Common name for keyframe interval option.
+pub const KEYFRAME_OPTION: &str = "key_int";
+/// Common description for keyframe interval option.
+pub const KEYFRAME_OPTION_DESC: &str = "Keyframe interval (0 - automatic)";
+
+/// Common name for frame skipping mode.
+pub const FRAME_SKIP_OPTION: &str = "frame_skip";
+/// Common description for frame skipping mode.
+pub const FRAME_SKIP_OPTION_DESC: &str = "Frame skipping mode";
+/// Frame skipping option value for no skipped frames.
+pub const FRAME_SKIP_OPTION_VAL_NONE: &str = "none";
+/// Frame skipping option value for decoding only keyframes.
+pub const FRAME_SKIP_OPTION_VAL_KEYFRAME: &str = "keyframes";
+/// Frame skipping option value for decoding only intra frames.
+pub const FRAME_SKIP_OPTION_VAL_INTRA: &str = "intra";
+
/// A list specifying option parsing and validating errors.
#[derive(Clone,Copy,Debug,PartialEq)]
pub enum OptionError {
impl NAOptionDefinition {
/// Tries to parse input string(s) as an option and returns new option and number of arguments used (1 or 2) on success.
- pub fn parse(&self, name: &String, value: Option<&String>) -> OptionResult<(NAOption, usize)> {
+ pub fn parse(&self, name: &str, value: Option<&String>) -> OptionResult<(NAOption, usize)> {
let no_name = "no".to_owned() + self.name;
let opt_no_name = "--no".to_owned() + self.name;
- if name == &no_name || name == &opt_no_name {
+ if name == no_name || name == opt_no_name {
match self.opt_type {
NAOptionDefinitionType::Bool => return Ok((NAOption { name: self.name, value: NAValue::Bool(false) }, 1)),
_ => return Err(OptionError::InvalidFormat),
};
}
let opt_name = "--".to_owned() + self.name;
- if self.name != name && &opt_name != name {
+ if self.name != name && opt_name != name {
return Err(OptionError::WrongName);
}
match self.opt_type {
NAOptionDefinitionType::None => Ok((NAOption { name: self.name, value: NAValue::None }, 1)),
NAOptionDefinitionType::Bool => Ok((NAOption { name: self.name, value: NAValue::Bool(true) }, 1)),
NAOptionDefinitionType::Int(_, _) => {
- if let Some(str) = value {
- let ret = str.parse::<i64>();
+ if let Some(strval) = value {
+ let ret = strval.parse::<i64>();
if let Ok(val) = ret {
let opt = NAOption { name: self.name, value: NAValue::Int(val) };
self.check(&opt)?;
}
},
NAOptionDefinitionType::Float(_, _) => {
- if let Some(str) = value {
- let ret = str.parse::<f64>();
+ if let Some(strval) = value {
+ let ret = strval.parse::<f64>();
if let Ok(val) = ret {
let opt = NAOption { name: self.name, value: NAValue::Float(val) };
self.check(&opt)?;
}
},
NAOptionDefinitionType::String(_) => {
- if let Some(str) = value {
- let opt = NAOption { name: self.name, value: NAValue::String(str.to_string()) };
+ if let Some(strval) = value {
+ let opt = NAOption { name: self.name, value: NAValue::String(strval.to_string()) };
self.check(&opt)?;
Ok((opt, 2))
} else {
Ok(())
},
NAValue::String(ref cur_str) => {
- if let NAOptionDefinitionType::String(Some(ref strings)) = self.opt_type {
- for str in strings.iter() {
- if cur_str == str {
+ if let NAOptionDefinitionType::String(Some(strings)) = self.opt_type {
+ for string in strings.iter() {
+ if cur_str == string {
return Ok(());
}
}
NAOptionDefinitionType::None => write!(f, "{}: {}", self.name, self.description),
NAOptionDefinitionType::Bool => write!(f, "[no]{}: {}", self.name, self.description),
NAOptionDefinitionType::String(ref str_list) => {
- if let Some(ref opts) = str_list {
+ if let Some(opts) = str_list {
write!(f, "{} {}: {}", self.name, opts.join("|"), self.description)
} else {
write!(f, "{} <string>: {}", self.name, self.description)
#[test]
fn test_option_parsing() {
let mut def = NAOptionDefinition { name: "option", description: "", opt_type: NAOptionDefinitionType::Float(None, None) };
- assert_eq!(def.parse(&"--option".to_string(), None), Err(OptionError::ParseError));
- assert_eq!(def.parse(&"--nooption".to_string(), None), Err(OptionError::InvalidFormat));
- assert_eq!(def.parse(&"--option".to_string(), Some(&"42".to_string())),
+ assert_eq!(def.parse("--option", None), Err(OptionError::ParseError));
+ assert_eq!(def.parse("--nooption", None), Err(OptionError::InvalidFormat));
+ assert_eq!(def.parse("--option", Some(&"42".to_string())),
Ok((NAOption{name:"option",value: NAValue::Float(42.0)}, 2)));
def.opt_type = NAOptionDefinitionType::Float(None, Some(40.0));
- assert_eq!(def.parse(&"--option".to_string(), Some(&"42".to_string())),
+ assert_eq!(def.parse("--option", Some(&"42".to_string())),
Err(OptionError::InvalidValue));
let def = NAOptionDefinition { name: "option", description: "", opt_type: NAOptionDefinitionType::Bool };
- assert_eq!(def.parse(&"option".to_string(), None),
+ assert_eq!(def.parse("option", None),
Ok((NAOption{name: "option", value: NAValue::Bool(true) }, 1)));
- assert_eq!(def.parse(&"nooption".to_string(), None),
+ assert_eq!(def.parse("nooption", None),
Ok((NAOption{name: "option", value: NAValue::Bool(false) }, 1)));
}
}