core/format: use common format parsing error

[nihav.git] / nihav-core / src / formats.rs

diff --git a/nihav-core/src/formats.rs b/nihav-core/src/formats.rs
index 2c2e717d93e3cd6bf35bf2fe2f5dafb3d0ede950..fc8e3548a7331f11072f2045d595222f75960f72 100644 (file)
--- a/nihav-core/src/formats.rs
+++ b/nihav-core/src/formats.rs
@@ -7,6 +7,10 @@ use std::str::FromStr;
 use std::string::*;
 use std::fmt;
 
+/// Generic format parsing error.
+#[derive(Clone,Copy,Debug,PartialEq)]
+pub struct FormatParseError {}
+
 /// Audio format definition.
 ///
 /// The structure describes how audio samples are stored and what characteristics they have.
@@ -95,6 +99,15 @@ impl NASoniton {
             (length * u64::from((self.bits + 7) >> 3)) as usize
         }
     }
+
+    /// Returns soniton description as a short 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 { "" };
+        let packed = if self.packed { "x" } else { "" };
+        format!("{}{}{}{}{}", ltype, self.bits, endianness, planar, packed)
+    }
 }
 
 impl fmt::Display for NASoniton {
@@ -105,6 +118,25 @@ impl fmt::Display for NASoniton {
     }
 }
 
+impl FromStr for NASoniton {
+    type Err = FormatParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "u8" => Ok(NASoniton { bits: 8, be: true, packed: false, planar: false, float: false, signed: false }),
+            "s16be" => Ok(NASoniton { bits: 16, be:  true, packed: false, planar: false, float: false, signed: true }),
+            "s16le" => Ok(NASoniton { bits: 16, be: false, packed: false, planar: false, float: false, signed: true }),
+            "s24be" => Ok(NASoniton { bits: 24, be:  true, packed: false, planar: false, float: false, signed: true }),
+            "s24le" => Ok(NASoniton { bits: 24, be: false, packed: false, planar: false, float: false, signed: true }),
+            "s32be" => Ok(NASoniton { bits: 32, be:  true, packed: false, planar: false, float: false, signed: true }),
+            "s32le" => Ok(NASoniton { bits: 32, be: false, packed: false, planar: false, float: false, signed: true }),
+            "f32be" => Ok(NASoniton { bits: 32, be:  true, packed: false, planar: false, float: true, signed: true }),
+            "f32le" => Ok(NASoniton { bits: 32, be: false, packed: false, planar: false, float: true, signed: true }),
+            _ => Err(FormatParseError{}),
+        }
+    }
+}
+
 /// Known channel types.
 #[derive(Debug,Clone,Copy,PartialEq)]
 pub enum NAChannelType {
@@ -146,12 +178,8 @@ impl NAChannelType {
     }
 }
 
-/// Generic channel configuration parsing error.
-#[derive(Clone,Copy,Debug,PartialEq)]
-pub struct ChannelParseError {}
-
 impl FromStr for NAChannelType {
-    type Err = ChannelParseError;
+    type Err = FormatParseError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
@@ -183,14 +211,14 @@ impl FromStr for NAChannelType {
             "Rt"    => Ok(NAChannelType::Rt),
             "Lo"    => Ok(NAChannelType::Lo),
             "Ro"    => Ok(NAChannelType::Ro),
-            _   => Err(ChannelParseError{}),
+            _   => Err(FormatParseError{}),
         }
     }
 }
 
-impl fmt::Display for NAChannelType {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let name = match *self {
+impl ToString for NAChannelType {
+    fn to_string(&self) -> String {
+        match *self {
             NAChannelType::C    => "C".to_string(),
             NAChannelType::L    => "L".to_string(),
             NAChannelType::R    => "R".to_string(),
@@ -219,8 +247,7 @@ impl fmt::Display for NAChannelType {
             NAChannelType::Rt   => "Rt".to_string(),
             NAChannelType::Lo   => "Lo".to_string(),
             NAChannelType::Ro   => "Ro".to_string(),
-        };
-        write!(f, "{}", name)
+        }
     }
 }
 
@@ -298,7 +325,7 @@ impl fmt::Display for NAChannelMap {
 }
 
 impl FromStr for NAChannelMap {
-    type Err = ChannelParseError;
+    type Err = FormatParseError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let mut chm = NAChannelMap::new();
@@ -706,6 +733,10 @@ mod test {
         println!("{}", SND_S16_FORMAT);
         println!("{}", SND_U8_FORMAT);
         println!("{}", SND_F32P_FORMAT);
+        assert_eq!(SND_U8_FORMAT.to_short_string(), "u8");
+        assert_eq!(SND_F32P_FORMAT.to_short_string(), "f32lep");
+        let s16fmt = SND_S16_FORMAT.to_short_string();
+        assert_eq!(NASoniton::from_str(s16fmt.as_str()).unwrap(), SND_S16_FORMAT);
         println!("formaton yuv- {}", YUV420_FORMAT);
         println!("formaton pal- {}", PAL8_FORMAT);
         println!("formaton rgb565- {}", RGB565_FORMAT);