First commit

src/fourcc.rs

@@ -0,0 +1,120 @@
+use std::fmt::Debug;
+use std::io;
+
+/// A Four-character Code
+/// 
+/// For idetifying chunks, structured contiguous slices or segments
+/// within a WAV file.
+#[derive(Eq, PartialEq, Hash, Copy, Clone)]
+pub struct FourCC([u8; 4]);
+
+impl FourCC {
+    pub const fn make(s: &[u8; 4]) -> Self {
+        Self(*s)
+    }
+}
+
+impl From<[char; 4]> for FourCC {
+    fn from(chars : [char; 4]) -> Self {
+        Self([chars[0] as u8 , chars[1] as u8, chars[2] as u8, chars[3] as u8])
+    }
+}
+
+impl From<[u8; 4]> for FourCC {
+    fn from(bytes: [u8; 4]) -> Self {
+        FourCC(bytes)
+    }
+}
+
+impl From<FourCC> for [u8; 4] {
+    fn from(fourcc: FourCC) -> Self {
+        fourcc.0
+    }
+}
+
+
+impl From<&FourCC> for [char;4] {
+    fn from( f: &FourCC) -> Self {
+        [f.0[0] as char, f.0[1] as char, f.0[2] as char, f.0[3] as char,]
+    }
+}
+
+impl From<FourCC> for [char;4] {
+    fn from( f: FourCC) -> Self {
+        [f.0[0] as char, f.0[1] as char, f.0[2] as char, f.0[3] as char,]
+    }
+}
+
+
+impl From<&FourCC> for String {
+    fn from(f: &FourCC) -> Self { 
+        let chars: [char;4] = f.into();
+        chars.iter().collect::<String>() 
+    }
+}
+
+impl From<FourCC> for String {
+    fn from(f: FourCC) -> Self { 
+        let chars: [char;4] = f.into();
+        chars.iter().collect::<String>() 
+    }
+}
+
+impl Debug for FourCC {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
+        let s : String = self.into();
+        write!(f, "FourCC({})", s)
+    }
+}
+
+pub trait ReadFourCC: io::Read {
+    fn read_fourcc(&mut self) -> Result<FourCC, io::Error>;
+}
+
+pub trait WriteFourCC: io::Write {
+    fn write_fourcc(&mut self, fourcc :FourCC) -> Result<(), io::Error>;
+}
+
+impl<T> ReadFourCC for T where T: io::Read { 
+    fn read_fourcc(&mut self) -> Result<FourCC, io::Error> {
+        let mut buf : [u8; 4] = [0 ; 4];
+        self.read_exact(&mut buf)?;
+        Ok( FourCC::from(buf) )
+    }
+}
+
+impl<T> WriteFourCC for T where T: io::Write {
+    fn write_fourcc(&mut self, fourcc :FourCC) -> Result<(), io::Error> {
+        let buf : [u8; 4] = fourcc.into();
+        self.write_all(&buf)?;
+        Ok(())
+    }
+}
+
+
+pub const RIFF_SIG: FourCC = FourCC::make(b"RIFF");
+pub const WAVE_SIG: FourCC = FourCC::make(b"WAVE");
+pub const RF64_SIG: FourCC = FourCC::make(b"RF64"); 
+pub const DS64_SIG: FourCC = FourCC::make(b"ds64"); 
+pub const BW64_SIG: FourCC = FourCC::make(b"BW64");
+
+pub const DATA_SIG: FourCC = FourCC::make(b"data");
+pub const FMT__SIG: FourCC = FourCC::make(b"fmt ");
+
+pub const BEXT_SIG: FourCC = FourCC::make(b"bext");
+
+pub const JUNK_SIG: FourCC = FourCC::make(b"JUNK");
+pub const FLLR_SIG: FourCC = FourCC::make(b"FLLR");
+
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_to_string() {
+        let a = FourCC::make(b"a1b2");
+        let s : String = a.into();
+        assert_eq!(s, "a1b2");
+    }
+}