X-Git-Url: https://git.nihav.org/?a=blobdiff_plain;f=nihav-core%2Fsrc%2Fformats.rs;h=fdb7a1b7640a303d17a7552970ec3ad2fc2d151f;hb=e6aaad5c5273cd814b5748b7faf3751835a37217;hp=6d7f1a152caba62dfa1c78c402c963c933109483;hpb=00eac62b31ccdaf994779da3f39c00414e5a585b;p=nihav.git diff --git a/nihav-core/src/formats.rs b/nihav-core/src/formats.rs index 6d7f1a1..fdb7a1b 100644 --- a/nihav-core/src/formats.rs +++ b/nihav-core/src/formats.rs @@ -62,6 +62,8 @@ pub const SND_U8_FORMAT: NASoniton = NASoniton { bits: 8, be: false, packed: fal pub const SND_S16_FORMAT: NASoniton = NASoniton { bits: 16, be: false, packed: false, planar: false, float: false, signed: true }; /// Predefined format for planar 16-bit signed audio. pub const SND_S16P_FORMAT: NASoniton = NASoniton { bits: 16, be: false, packed: false, planar: true, float: false, signed: true }; +/// Predefined format for planar 32-bit signed audio. +pub const SND_S32P_FORMAT: NASoniton = NASoniton { bits: 32, be: false, packed: false, planar: true, float: false, signed: true }; /// Predefined format for planar 32-bit floating point audio. pub const SND_F32P_FORMAT: NASoniton = NASoniton { bits: 32, be: false, packed: false, planar: true, float: true, signed: true }; @@ -101,7 +103,7 @@ impl NASoniton { } /// Returns soniton description as a short string. - pub fn to_short_string(&self) -> String { + pub fn to_short_string(self) -> String { let ltype = if self.float { 'f' } else if self.signed { 's' } else { 'u' }; let endianness = if self.bits == 8 { "" } else if self.be { "be" } else { "le" }; let planar = if self.planar { "p" } else { "" }; @@ -114,7 +116,7 @@ impl fmt::Display for NASoniton { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let fmt = if self.float { "float" } else if self.signed { "int" } else { "uint" }; let end = if self.be { "BE" } else { "LE" }; - write!(f, "({} bps, {} planar: {} packed: {} {})", self.bits, end, self.packed, self.planar, fmt) + write!(f, "({} bps, {} planar: {} packed: {} {})", self.bits, end, self.planar, self.packed, fmt) } } @@ -146,35 +148,29 @@ pub enum NAChannelType { impl NAChannelType { /// Reports whether this is some center channel. pub fn is_center(self) -> bool { - match self { - NAChannelType::C => true, NAChannelType::Ch => true, - NAChannelType::Cl => true, NAChannelType::Ov => true, - NAChannelType::LFE => true, NAChannelType::LFE2 => true, - NAChannelType::Cs => true, NAChannelType::Chs => true, - _ => false, - } + matches!(self, + NAChannelType::C | NAChannelType::Ch | + NAChannelType::Cl | NAChannelType::Ov | + NAChannelType::LFE | NAChannelType::LFE2 | + NAChannelType::Cs | NAChannelType::Chs) } /// Reports whether this is some left channel. pub fn is_left(self) -> bool { - match self { - NAChannelType::L => true, NAChannelType::Ls => true, - NAChannelType::Lss => true, NAChannelType::Lc => true, - NAChannelType::Lh => true, NAChannelType::Lw => true, - NAChannelType::Lhs => true, NAChannelType::Ll => true, - NAChannelType::Lt => true, NAChannelType::Lo => true, - _ => false, - } + matches!(self, + NAChannelType::L | NAChannelType::Ls | + NAChannelType::Lss | NAChannelType::Lc | + NAChannelType::Lh | NAChannelType::Lw | + NAChannelType::Lhs | NAChannelType::Ll | + NAChannelType::Lt | NAChannelType::Lo) } /// Reports whether this is some right channel. pub fn is_right(self) -> bool { - match self { - NAChannelType::R => true, NAChannelType::Rs => true, - NAChannelType::Rss => true, NAChannelType::Rc => true, - NAChannelType::Rh => true, NAChannelType::Rw => true, - NAChannelType::Rhs => true, NAChannelType::Rl => true, - NAChannelType::Rt => true, NAChannelType::Ro => true, - _ => false, - } + matches!(self, + NAChannelType::R | NAChannelType::Rs | + NAChannelType::Rss | NAChannelType::Rc | + NAChannelType::Rh | NAChannelType::Rw | + NAChannelType::Rhs | NAChannelType::Rl | + NAChannelType::Rt | NAChannelType::Ro) } } @@ -216,9 +212,9 @@ impl FromStr for NAChannelType { } } -impl ToString for NAChannelType { - fn to_string(&self) -> String { - match *self { +impl fmt::Display for NAChannelType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { NAChannelType::C => "C".to_string(), NAChannelType::L => "L".to_string(), NAChannelType::R => "R".to_string(), @@ -247,7 +243,8 @@ impl ToString for NAChannelType { NAChannelType::Rt => "Rt".to_string(), NAChannelType::Lo => "Lo".to_string(), NAChannelType::Ro => "Ro".to_string(), - } + }; + write!(f, "{}", name) } } @@ -318,7 +315,7 @@ impl fmt::Display for NAChannelMap { let mut map = String::new(); for el in self.ids.iter() { if !map.is_empty() { map.push(','); } - map.push_str(&*el.to_string()); + map.push_str(&el.to_string()); } write!(f, "{}", map) } @@ -397,17 +394,11 @@ impl ColorModel { } /// Reports whether the current colour model is RGB. pub fn is_rgb(self) -> bool { - match self { - ColorModel::RGB(_) => true, - _ => false, - } + matches!(self, ColorModel::RGB(_)) } /// Reports whether the current colour model is YUV. pub fn is_yuv(self) -> bool { - match self { - ColorModel::YUV(_) => true, - _ => false, - } + matches!(self, ColorModel::YUV(_)) } /// Returns short name for the current colour mode. pub fn get_short_name(self) -> &'static str { @@ -425,8 +416,8 @@ impl ColorModel { impl fmt::Display for ColorModel { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - ColorModel::RGB(fmt) => format!("RGB({})", fmt).to_string(), - ColorModel::YUV(fmt) => format!("YUV({})", fmt).to_string(), + ColorModel::RGB(fmt) => format!("RGB({})", fmt), + ColorModel::YUV(fmt) => format!("YUV({})", fmt), ColorModel::CMYK => "CMYK".to_string(), ColorModel::HSV => "HSV".to_string(), ColorModel::LAB => "LAB".to_string(), @@ -669,44 +660,37 @@ impl NAPixelFormaton { /// Reports whether the format is not packed. pub fn is_unpacked(&self) -> bool { if self.palette { return false; } - for chr in self.comp_info.iter() { - if let Some(ref chromaton) = chr { - if chromaton.is_packed() { return false; } - } + for chromaton in self.comp_info.iter().flatten() { + if chromaton.is_packed() { return false; } } true } /// Returns the maximum component bit depth. pub fn get_max_depth(&self) -> u8 { let mut mdepth = 0; - for chr in self.comp_info.iter() { - if let Some(ref chromaton) = chr { - mdepth = mdepth.max(chromaton.depth); - } + for chromaton in self.comp_info.iter().flatten() { + mdepth = mdepth.max(chromaton.depth); } mdepth } /// Returns the total amount of bits needed for components. pub fn get_total_depth(&self) -> u8 { let mut depth = 0; - for chr in self.comp_info.iter() { - if let Some(ref chromaton) = chr { - depth += chromaton.depth; - } + for chromaton in self.comp_info.iter().flatten() { + depth += chromaton.depth; } depth } /// Returns the maximum component subsampling. pub fn get_max_subsampling(&self) -> u8 { let mut ssamp = 0; - for chr in self.comp_info.iter() { - if let Some(ref chromaton) = chr { - let (ss_v, ss_h) = chromaton.get_subsampling(); - ssamp = ssamp.max(ss_v).max(ss_h); - } + for chromaton in self.comp_info.iter().flatten() { + let (ss_v, ss_h) = chromaton.get_subsampling(); + ssamp = ssamp.max(ss_v).max(ss_h); } ssamp } + #[allow(clippy::cognitive_complexity)] /// Returns a short string description of the format if possible. pub fn to_short_string(&self) -> Option { match self.model { @@ -724,12 +708,10 @@ impl NAPixelFormaton { let mut start_off = 0; let mut start_shift = 0; let mut use_shift = true; - for comp in self.comp_info.iter() { - if let Some(comp) = comp { - start_off = start_off.min(comp.comp_offs); - start_shift = start_shift.min(comp.shift); - if comp.comp_offs != 0 { use_shift = false; } - } + for comp in self.comp_info.iter().flatten() { + start_off = start_off.min(comp.comp_offs); + start_shift = start_shift.min(comp.shift); + if comp.comp_offs != 0 { use_shift = false; } } for component in 0..(self.components as usize) { for (comp, cname) in self.comp_info.iter().zip(b"rgba".iter()) { @@ -768,7 +750,7 @@ impl NAPixelFormaton { break; } } - name += if self.be { "be" } else { "le" }; + name += if self.be { "be" } else { "le" }; return Some(name); } if depth == 24 || depth != 8 * self.components { @@ -778,7 +760,7 @@ impl NAPixelFormaton { name.push('p'); } if self.get_max_depth() > 8 { - name += if self.be { "be" } else { "le" }; + name += if self.be { "be" } else { "le" }; } Some(name) }, @@ -828,13 +810,13 @@ impl fmt::Display for NAPixelFormaton { let end = if self.be { "BE" } else { "LE" }; let palstr = if self.palette { "palette " } else { "" }; let astr = if self.alpha { "alpha " } else { "" }; - let mut str = format!("Formaton for {} ({}{}elem {} size {}): ", self.model, palstr, astr,end, self.elem_size); + let mut string = format!("Formaton for {} ({}{}elem {} size {}): ", self.model, palstr, astr,end, self.elem_size); for i in 0..self.comp_info.len() { if let Some(chr) = self.comp_info[i] { - str = format!("{} {}", str, chr); + string = format!("{} {}", string, chr); } } - write!(f, "[{}]", str) + write!(f, "[{}]", string) } } @@ -856,7 +838,7 @@ fn parse_rgb_format(s: &str) -> Result { 'A' | 'a' => { order[3] = i; has_alpha = true; }, '0'..='9' => { pstate = 1; bits_start = i; - bits = ((ch as u8) - b'0') as u32; + bits = u32::from((ch as u8) - b'0'); }, _ => return Err(FormatParseError {}), }; @@ -865,7 +847,7 @@ fn parse_rgb_format(s: &str) -> Result { if i > 4 + bits_start { return Err(FormatParseError {}); } match ch { '0'..='9' => { - bits = (bits * 10) + (((ch as u8) - b'0') as u32); + bits = (bits * 10) + u32::from((ch as u8) - b'0'); }, 'B' | 'b' => { pstate = 2; } 'L' | 'l' => { pstate = 2; is_be = false; } @@ -960,18 +942,18 @@ fn parse_yuv_format(s: &str) -> Result { return Ok(NAPixelFormaton { model: ColorModel::YUV(YUVSubmodel::YUVJ), components: 1, comp_info: [ - Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 0, next_elem: 1 }), + Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: false, depth: 8, shift: 0, comp_offs: 0, next_elem: 1 }), None, None, None, None], - elem_size: 1, be: false, alpha: false, palette: false }); + elem_size: 1, be: true, alpha: false, palette: false }); }, "y8a" | "y400a" | "graya" => { return Ok(NAPixelFormaton { model: ColorModel::YUV(YUVSubmodel::YUVJ), components: 2, comp_info: [ - Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 0, next_elem: 2 }), - Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 1, next_elem: 2 }), + Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: false, depth: 8, shift: 0, comp_offs: 0, next_elem: 2 }), + Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: false, depth: 8, shift: 0, comp_offs: 1, next_elem: 2 }), None, None, None], - elem_size: 1, be: false, alpha: true, palette: false }); + elem_size: 1, be: true, alpha: true, palette: false }); }, "uyvy" | "y422" => { return Ok(NAPixelFormaton { @@ -1025,8 +1007,8 @@ fn parse_yuv_format(s: &str) -> Result { let mut parse_end = components as usize; for ch in s.chars().skip(components as usize) { parse_end += 1; - if ch >= '0' && ch <= '9' { - format = format * 10 + (((ch as u8) - b'0') as u32); + if ch.is_ascii_digit() { + format = format * 10 + u32::from((ch as u8) - b'0'); if format > 444 { return Err(FormatParseError {}); } } else { is_planar = ch == 'p'; @@ -1037,7 +1019,7 @@ fn parse_yuv_format(s: &str) -> Result { let depth = if s.len() == parse_end { 8 } else { let mut val = 0; for ch in s.chars().skip(parse_end) { - if ch >= '0' && ch <= '9' { + if ch.is_ascii_digit() { val = val * 10 + ((ch as u8) - b'0'); if val > 16 { return Err(FormatParseError {}); } } else { @@ -1061,8 +1043,8 @@ fn parse_yuv_format(s: &str) -> Result { 444 => [[0, 0], [0, 0], [0, 0], [0, 0]], _ => return Err(FormatParseError {}), }; - for (chro, ss) in chromatons.iter_mut().take(components as usize).zip(subsamp.iter()) { - *chro = Some(NAPixelChromaton{ h_ss: ss[0], v_ss: ss[1], packed: !is_planar, depth, shift: 0, comp_offs: next_elem, next_elem }); + for (i, (chro, ss)) in chromatons.iter_mut().take(components as usize).zip(subsamp.iter()).enumerate() { + *chro = Some(NAPixelChromaton{ h_ss: ss[0], v_ss: ss[1], packed: !is_planar, depth, shift: 0, comp_offs: if is_planar { i as u8 } else { next_elem }, next_elem }); } Ok(NAPixelFormaton { model: ColorModel::YUV(YUVSubmodel::YUVJ), components, @@ -1074,6 +1056,7 @@ fn parse_yuv_format(s: &str) -> Result { impl FromStr for NAPixelFormaton { type Err = FormatParseError; + #[allow(clippy::single_match)] fn from_str(s: &str) -> Result { match s { "pal8" => return Ok(PAL8_FORMAT),