X-Git-Url: https://git.nihav.org/?a=blobdiff_plain;f=src%2Fformats.rs;fp=src%2Fformats.rs;h=0000000000000000000000000000000000000000;hb=5641dccfbf2a70d589cf094a0d4ed5a10f919f00;hp=53b28dcfcdb9ede589ad8c3ee2b3d0d6e0aeb8e8;hpb=b74ff9fac35d41737d71d97227fad233aa4a4b49;p=nihav.git diff --git a/src/formats.rs b/src/formats.rs deleted file mode 100644 index 53b28dc..0000000 --- a/src/formats.rs +++ /dev/null @@ -1,511 +0,0 @@ -use std::str::FromStr; -use std::string::*; -use std::fmt; - -#[derive(Debug,Copy,Clone,PartialEq)] -pub struct NASoniton { - bits: u8, - be: bool, - packed: bool, - planar: bool, - float: bool, - signed: bool, -} - -pub const SONITON_FLAG_BE :u32 = 0x01; -pub const SONITON_FLAG_PACKED :u32 = 0x02; -pub const SONITON_FLAG_PLANAR :u32 = 0x04; -pub const SONITON_FLAG_FLOAT :u32 = 0x08; -pub const SONITON_FLAG_SIGNED :u32 = 0x10; - -pub const SND_U8_FORMAT: NASoniton = NASoniton { bits: 8, be: false, packed: false, planar: false, float: false, signed: false }; -pub const SND_S16_FORMAT: NASoniton = NASoniton { bits: 16, be: false, packed: false, planar: false, float: false, signed: true }; -pub const SND_S16P_FORMAT: NASoniton = NASoniton { bits: 16, be: false, packed: false, planar: true, float: false, signed: true }; -pub const SND_F32P_FORMAT: NASoniton = NASoniton { bits: 32, be: false, packed: false, planar: true, float: true, signed: true }; - -impl NASoniton { - pub fn new(bits: u8, flags: u32) -> Self { - let is_be = (flags & SONITON_FLAG_BE) != 0; - let is_pk = (flags & SONITON_FLAG_PACKED) != 0; - let is_pl = (flags & SONITON_FLAG_PLANAR) != 0; - let is_fl = (flags & SONITON_FLAG_FLOAT) != 0; - let is_sg = (flags & SONITON_FLAG_SIGNED) != 0; - NASoniton { bits: bits, be: is_be, packed: is_pk, planar: is_pl, float: is_fl, signed: is_sg } - } - - pub fn get_bits(&self) -> u8 { self.bits } - pub fn is_be(&self) -> bool { self.be } - pub fn is_packed(&self) -> bool { self.packed } - pub fn is_planar(&self) -> bool { self.planar } - pub fn is_float(&self) -> bool { self.float } - pub fn is_signed(&self) -> bool { self.signed } - - pub fn get_audio_size(&self, length: u64) -> usize { - if self.packed { - ((length * (self.bits as u64) + 7) >> 3) as usize - } else { - (length * (((self.bits + 7) >> 3) as u64)) as usize - } - } -} - -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) - } -} - -#[derive(Debug,Clone,Copy,PartialEq)] -pub enum NAChannelType { - C, L, R, Cs, Ls, Rs, Lss, Rss, LFE, Lc, Rc, Lh, Rh, Ch, LFE2, Lw, Rw, Ov, Lhs, Rhs, Chs, Ll, Rl, Cl, Lt, Rt, Lo, Ro -} - -impl NAChannelType { - 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, - } - } - 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, - } - } - 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, - } - } -} - -#[derive(Clone,Copy,Debug,PartialEq)] -pub struct ChannelParseError {} - -impl FromStr for NAChannelType { - type Err = ChannelParseError; - - fn from_str(s: &str) -> Result { - match s { - "C" => Ok(NAChannelType::C), - "L" => Ok(NAChannelType::L), - "R" => Ok(NAChannelType::R), - "Cs" => Ok(NAChannelType::Cs), - "Ls" => Ok(NAChannelType::Ls), - "Rs" => Ok(NAChannelType::Rs), - "Lss" => Ok(NAChannelType::Lss), - "Rss" => Ok(NAChannelType::Rss), - "LFE" => Ok(NAChannelType::LFE), - "Lc" => Ok(NAChannelType::Lc), - "Rc" => Ok(NAChannelType::Rc), - "Lh" => Ok(NAChannelType::Lh), - "Rh" => Ok(NAChannelType::Rh), - "Ch" => Ok(NAChannelType::Ch), - "LFE2" => Ok(NAChannelType::LFE2), - "Lw" => Ok(NAChannelType::Lw), - "Rw" => Ok(NAChannelType::Rw), - "Ov" => Ok(NAChannelType::Ov), - "Lhs" => Ok(NAChannelType::Lhs), - "Rhs" => Ok(NAChannelType::Rhs), - "Chs" => Ok(NAChannelType::Chs), - "Ll" => Ok(NAChannelType::Ll), - "Rl" => Ok(NAChannelType::Rl), - "Cl" => Ok(NAChannelType::Cl), - "Lt" => Ok(NAChannelType::Lt), - "Rt" => Ok(NAChannelType::Rt), - "Lo" => Ok(NAChannelType::Lo), - "Ro" => Ok(NAChannelType::Ro), - _ => Err(ChannelParseError{}), - } - } -} - -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(), - NAChannelType::Cs => "Cs".to_string(), - NAChannelType::Ls => "Ls".to_string(), - NAChannelType::Rs => "Rs".to_string(), - NAChannelType::Lss => "Lss".to_string(), - NAChannelType::Rss => "Rss".to_string(), - NAChannelType::LFE => "LFE".to_string(), - NAChannelType::Lc => "Lc".to_string(), - NAChannelType::Rc => "Rc".to_string(), - NAChannelType::Lh => "Lh".to_string(), - NAChannelType::Rh => "Rh".to_string(), - NAChannelType::Ch => "Ch".to_string(), - NAChannelType::LFE2 => "LFE2".to_string(), - NAChannelType::Lw => "Lw".to_string(), - NAChannelType::Rw => "Rw".to_string(), - NAChannelType::Ov => "Ov".to_string(), - NAChannelType::Lhs => "Lhs".to_string(), - NAChannelType::Rhs => "Rhs".to_string(), - NAChannelType::Chs => "Chs".to_string(), - NAChannelType::Ll => "Ll".to_string(), - NAChannelType::Rl => "Rl".to_string(), - NAChannelType::Cl => "Cl".to_string(), - NAChannelType::Lt => "Lt".to_string(), - NAChannelType::Rt => "Rt".to_string(), - NAChannelType::Lo => "Lo".to_string(), - NAChannelType::Ro => "Ro".to_string(), - }; - write!(f, "{}", name) - } -} - -#[derive(Clone)] -pub struct NAChannelMap { - ids: Vec, -} - -const MS_CHANNEL_MAP: [NAChannelType; 11] = [ - NAChannelType::L, - NAChannelType::R, - NAChannelType::C, - NAChannelType::LFE, - NAChannelType::Ls, - NAChannelType::Rs, - NAChannelType::Lss, - NAChannelType::Rss, - NAChannelType::Cs, - NAChannelType::Lc, - NAChannelType::Rc, -]; - -impl NAChannelMap { - pub fn new() -> Self { NAChannelMap { ids: Vec::new() } } - pub fn add_channel(&mut self, ch: NAChannelType) { - self.ids.push(ch); - } - pub fn add_channels(&mut self, chs: &[NAChannelType]) { - for i in 0..chs.len() { - self.ids.push(chs[i]); - } - } - pub fn num_channels(&self) -> usize { - self.ids.len() - } - pub fn get_channel(&self, idx: usize) -> NAChannelType { - self.ids[idx] - } - pub fn find_channel_id(&self, t: NAChannelType) -> Option { - for i in 0..self.ids.len() { - if self.ids[i] as i32 == t as i32 { return Some(i as u8); } - } - None - } - pub fn from_ms_mapping(chmap: u32) -> Self { - let mut cm = NAChannelMap::new(); - for i in 0..MS_CHANNEL_MAP.len() { - if ((chmap >> i) & 1) != 0 { - cm.add_channel(MS_CHANNEL_MAP[i]); - } - } - cm - } -} - -impl fmt::Display for NAChannelMap { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let mut map = String::new(); - for el in self.ids.iter() { - if map.len() > 0 { map.push(','); } - map.push_str(&*el.to_string()); - } - write!(f, "{}", map) - } -} - -impl FromStr for NAChannelMap { - type Err = ChannelParseError; - - fn from_str(s: &str) -> Result { - let mut chm = NAChannelMap::new(); - for tok in s.split(',') { - chm.add_channel(NAChannelType::from_str(tok)?); - } - Ok(chm) - } -} - -#[derive(Debug,Clone,Copy,PartialEq)] -pub enum RGBSubmodel { - RGB, - SRGB, -} - -impl fmt::Display for RGBSubmodel { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - RGBSubmodel::RGB => "RGB".to_string(), - RGBSubmodel::SRGB => "sRGB".to_string(), - }; - write!(f, "{}", name) - } -} - -#[derive(Debug,Clone,Copy,PartialEq)] -pub enum YUVSubmodel { - YCbCr, - YIQ, - YUVJ, -} - -impl fmt::Display for YUVSubmodel { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - YUVSubmodel::YCbCr => "YCbCr".to_string(), - YUVSubmodel::YIQ => "YIQ".to_string(), - YUVSubmodel::YUVJ => "YUVJ".to_string(), - }; - write!(f, "{}", name) - } -} - -#[derive(Debug, Clone,Copy,PartialEq)] -pub enum ColorModel { - RGB(RGBSubmodel), - YUV(YUVSubmodel), - CMYK, - HSV, - LAB, - XYZ, -} - -impl ColorModel { - pub fn get_default_components(&self) -> usize { - match *self { - ColorModel::CMYK => 4, - _ => 3, - } - } -} - -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::CMYK => "CMYK".to_string(), - ColorModel::HSV => "HSV".to_string(), - ColorModel::LAB => "LAB".to_string(), - ColorModel::XYZ => "XYZ".to_string(), - }; - write!(f, "{}", name) - } -} - -#[derive(Clone,Copy,PartialEq)] -pub struct NAPixelChromaton { - h_ss: u8, - v_ss: u8, - packed: bool, - depth: u8, - shift: u8, - comp_offs: u8, - next_elem: u8, -} - -pub const FORMATON_FLAG_BE :u32 = 0x01; -pub const FORMATON_FLAG_ALPHA :u32 = 0x02; -pub const FORMATON_FLAG_PALETTE :u32 = 0x04; - - -#[derive(Clone,Copy,PartialEq)] -pub struct NAPixelFormaton { - model: ColorModel, - components: u8, - comp_info: [Option; 5], - elem_size: u8, - be: bool, - alpha: bool, - palette: bool, -} - -macro_rules! chromaton { - ($hs: expr, $vs: expr, $pck: expr, $d: expr, $sh: expr, $co: expr, $ne: expr) => ({ - Some(NAPixelChromaton{ h_ss: $hs, v_ss: $vs, packed: $pck, depth: $d, shift: $sh, comp_offs: $co, next_elem: $ne }) - }); - (yuv8; $hs: expr, $vs: expr, $co: expr) => ({ - Some(NAPixelChromaton{ h_ss: $hs, v_ss: $vs, packed: false, depth: 8, shift: 0, comp_offs: $co, next_elem: 1 }) - }); - (packrgb; $d: expr, $s: expr, $co: expr, $ne: expr) => ({ - Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: $d, shift: $s, comp_offs: $co, next_elem: $ne }) - }); - (pal8; $co: expr) => ({ - Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: $co, next_elem: 3 }) - }); -} - -pub const YUV420_FORMAT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::YUV(YUVSubmodel::YUVJ), components: 3, - comp_info: [ - chromaton!(0, 0, false, 8, 0, 0, 1), - chromaton!(yuv8; 1, 1, 1), - chromaton!(yuv8; 1, 1, 2), - None, None], - elem_size: 0, be: false, alpha: false, palette: false }; - -pub const YUV410_FORMAT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::YUV(YUVSubmodel::YUVJ), components: 3, - comp_info: [ - chromaton!(0, 0, false, 8, 0, 0, 1), - chromaton!(yuv8; 2, 2, 1), - chromaton!(yuv8; 2, 2, 2), - None, None], - elem_size: 0, be: false, alpha: false, palette: false }; -pub const YUVA410_FORMAT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::YUV(YUVSubmodel::YUVJ), components: 4, - comp_info: [ - chromaton!(0, 0, false, 8, 0, 0, 1), - chromaton!(yuv8; 2, 2, 1), - chromaton!(yuv8; 2, 2, 2), - chromaton!(0, 0, false, 8, 0, 3, 1), - None], - elem_size: 0, be: false, alpha: true, palette: false }; - -pub const PAL8_FORMAT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::RGB(RGBSubmodel::RGB), components: 3, - comp_info: [ - chromaton!(pal8; 0), - chromaton!(pal8; 1), - chromaton!(pal8; 2), - None, None], - elem_size: 3, be: false, alpha: false, palette: true }; - -pub const RGB565_FORMAT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::RGB(RGBSubmodel::RGB), components: 3, - comp_info: [ - chromaton!(packrgb; 5, 11, 0, 2), - chromaton!(packrgb; 6, 5, 0, 2), - chromaton!(packrgb; 5, 0, 0, 2), - None, None], - elem_size: 2, be: false, alpha: false, palette: false }; - -pub const RGB24_FORMAT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::RGB(RGBSubmodel::RGB), components: 3, - comp_info: [ - chromaton!(packrgb; 8, 0, 2, 3), - chromaton!(packrgb; 8, 0, 1, 3), - chromaton!(packrgb; 8, 0, 0, 3), - None, None], - elem_size: 3, be: false, alpha: false, palette: false }; - -impl NAPixelChromaton { - pub fn get_subsampling(&self) -> (u8, u8) { (self.h_ss, self.v_ss) } - pub fn is_packed(&self) -> bool { self.packed } - pub fn get_depth(&self) -> u8 { self.depth } - pub fn get_shift(&self) -> u8 { self.shift } - pub fn get_offset(&self) -> u8 { self.comp_offs } - pub fn get_step(&self) -> u8 { self.next_elem } - - pub fn get_width(&self, width: usize) -> usize { - (width + ((1 << self.h_ss) - 1)) >> self.h_ss - } - pub fn get_height(&self, height: usize) -> usize { - (height + ((1 << self.v_ss) - 1)) >> self.v_ss - } - pub fn get_linesize(&self, width: usize) -> usize { - let d = self.depth as usize; - if self.packed { - (self.get_width(width) * d + d - 1) >> 3 - } else { - self.get_width(width) - } - } - pub fn get_data_size(&self, width: usize, height: usize) -> usize { - let nh = (height + ((1 << self.v_ss) - 1)) >> self.v_ss; - self.get_linesize(width) * nh - } -} - -impl fmt::Display for NAPixelChromaton { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let pfmt = if self.packed { - let mask = ((1 << self.depth) - 1) << self.shift; - format!("packed(+{},{:X}, step {})", self.comp_offs, mask, self.next_elem) - } else { - format!("planar({},{})", self.comp_offs, self.next_elem) - }; - write!(f, "({}x{}, {})", self.h_ss, self.v_ss, pfmt) - } -} - -impl NAPixelFormaton { - pub fn new(model: ColorModel, - comp1: Option, - comp2: Option, - comp3: Option, - comp4: Option, - comp5: Option, - flags: u32, elem_size: u8) -> Self { - let mut chromatons: [Option; 5] = [None; 5]; - let mut ncomp = 0; - let be = (flags & FORMATON_FLAG_BE) != 0; - let alpha = (flags & FORMATON_FLAG_ALPHA) != 0; - let palette = (flags & FORMATON_FLAG_PALETTE) != 0; - if let Some(c) = comp1 { chromatons[0] = Some(c); ncomp += 1; } - if let Some(c) = comp2 { chromatons[1] = Some(c); ncomp += 1; } - if let Some(c) = comp3 { chromatons[2] = Some(c); ncomp += 1; } - if let Some(c) = comp4 { chromatons[3] = Some(c); ncomp += 1; } - if let Some(c) = comp5 { chromatons[4] = Some(c); ncomp += 1; } - NAPixelFormaton { model: model, - components: ncomp, - comp_info: chromatons, - elem_size: elem_size, - be: be, alpha: alpha, palette: palette } - } - - pub fn get_model(&self) -> ColorModel { self.model } - pub fn get_num_comp(&self) -> usize { self.components as usize } - pub fn get_chromaton(&self, idx: usize) -> Option { - if idx < self.comp_info.len() { return self.comp_info[idx]; } - None - } - pub fn is_be(&self) -> bool { self.be } - pub fn has_alpha(&self) -> bool { self.alpha } - pub fn is_paletted(&self) -> bool { self.palette } - pub fn get_elem_size(&self) -> u8 { self.elem_size } -} - -impl fmt::Display for NAPixelFormaton { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - 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); - for i in 0..self.comp_info.len() { - if let Some(chr) = self.comp_info[i] { - str = format!("{} {}", str, chr); - } - } - write!(f, "[{}]", str) - } -} - -#[cfg(test)] -mod test { - use super::*; - - #[test] - fn test_fmt() { - println!("{}", SND_S16_FORMAT); - println!("{}", SND_U8_FORMAT); - println!("{}", SND_F32P_FORMAT); - println!("formaton yuv- {}", YUV420_FORMAT); - println!("formaton pal- {}", PAL8_FORMAT); - println!("formaton rgb565- {}", RGB565_FORMAT); - } -}