+use std::str::FromStr;
use std::string::*;
use std::fmt;
signed: bool,
}
-bitflags! {
- pub flags SonitonFlags: u8 {
- const SONITON_FLAG_BE = 0x01,
- const SONITON_FLAG_PACKED = 0x02,
- const SONITON_FLAG_PLANAR = 0x04,
- const SONITON_FLAG_FLOAT = 0x08,
- const SONITON_FLAG_SIGNED = 0x10,
- }
-}
+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: SonitonFlags) -> Self {
- let is_be = (flags.bits & SONITON_FLAG_BE.bits) != 0;
- let is_pk = (flags.bits & SONITON_FLAG_PACKED.bits) != 0;
- let is_pl = (flags.bits & SONITON_FLAG_PLANAR.bits) != 0;
- let is_fl = (flags.bits & SONITON_FLAG_FLOAT.bits) != 0;
- let is_sg = (flags.bits & SONITON_FLAG_SIGNED.bits) != 0;
+ 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 }
}
}
}
+#[derive(Clone,Copy,Debug,PartialEq)]
+pub struct ChannelParseError {}
+
+impl FromStr for NAChannelType {
+ type Err = ChannelParseError;
+
+ fn from_str(s: &str) -> Result<Self, Self::Err> {
+ 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 {
ids: Vec<NAChannelType>,
}
+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) {
}
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<Self, Self::Err> {
+ let mut chm = NAChannelMap::new();
+ for tok in s.split(',') {
+ chm.add_channel(NAChannelType::from_str(tok)?);
+ }
+ Ok(chm)
+ }
}
#[derive(Debug,Clone,Copy,PartialEq)]
next_elem: u8,
}
-bitflags! {
- pub flags FormatonFlags: u8 {
- const FORMATON_FLAG_BE = 0x01,
- const FORMATON_FLAG_ALPHA = 0x02,
- const FORMATON_FLAG_PALETTE = 0x04,
- }
-}
+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)]
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: [
comp3: Option<NAPixelChromaton>,
comp4: Option<NAPixelChromaton>,
comp5: Option<NAPixelChromaton>,
- flags: FormatonFlags, elem_size: u8) -> Self {
+ flags: u32, elem_size: u8) -> Self {
let mut chromatons: [Option<NAPixelChromaton>; 5] = [None; 5];
let mut ncomp = 0;
- let be = (flags.bits & FORMATON_FLAG_BE.bits) != 0;
- let alpha = (flags.bits & FORMATON_FLAG_ALPHA.bits) != 0;
- let palette = (flags.bits & FORMATON_FLAG_PALETTE.bits) != 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; }
projects / nihav.git / blobdiff