Basic format detection and factory

Author: hfiguiere

Cargo.toml

@@ -7,7 +7,7 @@ edition = "2021"
 
 [dependencies]
 # mp4 = { path = "lib/mp4", version = "0.1.0" }
-
+lazy_static = "1.4.0"
 
 [workspace]
 members = [

src/cr3.rs

@@ -1,15 +1,24 @@
+use super::rawfile::ReadAndSeek;
 use super::{Error, RawFile, RawFileImpl, Result, Type, TypeId};
 use crate::thumbnail::Thumbnail;
 
 /// Canon CR3 File
-pub struct Cr3File {}
+pub struct Cr3File {
+    reader: Box<dyn ReadAndSeek>,
+}
+
+impl Cr3File {
+    pub fn factory(reader: Box<dyn ReadAndSeek>) -> Box<dyn RawFile> {
+        Box::new(Cr3File { reader })
+    }
+}
 
 impl RawFileImpl for Cr3File {
     fn identify_id(&self) -> TypeId {
         0
     }
 
-    fn thumbnail_for_size(&self, size: u32) -> Result<Thumbnail> {
+    fn thumbnail_for_size(&self, _size: u32) -> Result<Thumbnail> {
         Err(Error::NotSupported)
     }
 

src/factory.rs

@@ -0,0 +1,39 @@
+/*
+ * libopenraw - factory.rs
+ *
+ * Copyright (C) 2022 Hubert Figuière
+ *
+ * This library is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+use std::collections::HashMap;
+
+use super::cr3::Cr3File;
+use super::rawfile::RawFileFactory;
+use super::Type;
+
+lazy_static::lazy_static! {
+    static ref FACTORY_MAP: HashMap<Type, RawFileFactory> = {
+        let mut m = HashMap::new();
+
+        m.insert(Type::Cr3, Cr3File::factory as RawFileFactory);
+
+        m
+    };
+}
+
+pub fn get_raw_file_factory(t: Type) -> Option<&'static RawFileFactory> {
+    FACTORY_MAP.get(&t)
+}

src/identify.rs

@@ -0,0 +1,133 @@
+/*
+ * libopenraw - identify.rs
+ *
+ * Copyright (C) 2022 Hubert Figuière
+ *
+ * This library is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+use std::collections::HashMap;
+use std::ffi::{OsStr, OsString};
+
+use super::{Error, Result, Type};
+use crate::raf;
+use crate::rawfile::ReadAndSeek;
+
+lazy_static::lazy_static! {
+    static ref EXT_TO_TYPE: HashMap<OsString, Type> = {
+        let mut m = HashMap::new();
+        // The extension MUST be lowercase
+        m.insert(OsString::from("cr3"), Type::Cr3);
+
+        m
+    };
+}
+
+/// Get the type associated to the extension.
+/// `ext` must be lowercase ASCII.
+pub(crate) fn type_for_extension(ext: &OsStr) -> Option<Type> {
+    EXT_TO_TYPE.get(ext).cloned()
+}
+
+/// Return the `Type` based on the content of the file.
+pub(crate) fn type_for_content(content: &mut dyn ReadAndSeek) -> Result<Option<Type>> {
+    use crate::Type::*;
+
+    // Buffer to read the content to identify
+    // Size is max of (14, RAF_MAGIC.len())
+    // Change as needed
+    let mut buf = [0_u8; 16];
+
+    let len = content.read(&mut buf)?;
+    if len <= 4 {
+        return Err(Error::BufferTooSmall);
+    }
+
+    if &buf[0..4] == b"\0MRM" {
+        return Ok(Some(Mrw));
+    }
+    if len >= 12 && &buf[4..12] == b"ftypcrx " {
+        return Ok(Some(Cr3));
+    }
+    if len >= 14 && &buf[0..14] == b"II\x1a\0\0\0HEAPCCDR" {
+        return Ok(Some(Crw));
+    }
+    if &buf[0..4] == b"IIRO" {
+        return Ok(Some(Orf));
+    }
+    if &buf[0..4] == b"IIU\0" {
+        return Ok(Some(Rw2));
+    }
+    if len >= raf::RAF_MAGIC.len() && &buf[0..raf::RAF_MAGIC.len()] == raf::RAF_MAGIC {
+        return Ok(Some(Raf));
+    }
+    if &buf[0..4] == b"II\x2a\0" || &buf[0..4] == b"MM\0\x2a" {
+        // TIFF based format
+        if len >= 12 {
+            if &buf[8..11] == b"CR\x02" {
+                return Ok(Some(Cr2));
+            }
+        }
+        if len >= 8 {
+            // XXX missing the TIFF part.
+        }
+    }
+
+    Ok(None)
+}
+
+#[cfg(test)]
+mod test {
+    #[test]
+    fn test_type_for_extension() {
+        use std::ffi::OsString;
+
+        use super::type_for_extension;
+        use crate::Type;
+
+        assert_eq!(type_for_extension(&OsString::from("CR3")), None);
+        assert_eq!(type_for_extension(&OsString::from("cr3")), Some(Type::Cr3));
+        assert_eq!(type_for_extension(&OsString::from("NOPE")), None);
+    }
+
+    #[test]
+    fn test_type_for_content() {
+        use super::type_for_content;
+        use crate::{Error, Type};
+        use std::io::Cursor;
+
+        let mut four_bytes = Cursor::new([0_u8; 4].as_slice());
+        assert_eq!(
+            type_for_content(&mut four_bytes),
+            Err(Error::BufferTooSmall)
+        );
+
+        // Canon
+        let mut crw = Cursor::new(include_bytes!("../testdata/identify/content_crw").as_slice());
+        assert_eq!(type_for_content(&mut crw), Ok(Some(Type::Crw)));
+
+        let mut cr2 = Cursor::new(include_bytes!("../testdata/identify/content_cr2").as_slice());
+        assert_eq!(type_for_content(&mut cr2), Ok(Some(Type::Cr2)));
+
+        let mut cr3 = Cursor::new(include_bytes!("../testdata/identify/content_cr3").as_slice());
+        assert_eq!(type_for_content(&mut cr3), Ok(Some(Type::Cr3)));
+
+        let mut mrw = Cursor::new(include_bytes!("../testdata/identify/content_mrw").as_slice());
+        assert_eq!(type_for_content(&mut mrw), Ok(Some(Type::Mrw)));
+
+        let mut raf = Cursor::new(include_bytes!("../testdata/identify/content_raf").as_slice());
+        assert_eq!(type_for_content(&mut raf), Ok(Some(Type::Raf)));
+    }
+}

src/lib.rs

@@ -1,25 +1,110 @@
+/*
+ * libopenraw - lib.rs
+ *
+ * Copyright (C) 2022 Hubert Figuière
+ *
+ * This library is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
 mod cr3;
+mod factory;
+mod identify;
+mod raf;
 mod rawfile;
 mod thumbnail;
 
 pub use rawfile::RawFile;
 pub use rawfile::RawFileImpl;
 
+/// Standard Result for libopenraw
 pub type Result<T> = std::result::Result<T, Error>;
 
-#[derive(Debug)]
+/// Standard Error for libopenraw
+#[derive(Debug, PartialEq)]
 pub enum Error {
     /// File format is unrecognized
     UnrecognizedFormat,
     /// Not supported
     NotSupported,
     /// Not found in file
     NotFound,
+    /// Buffer too small: we expect a bigger amount of data
+    BufferTooSmall,
+    /// IO Error
+    IoError(String),
+}
+
+impl From<std::io::Error> for Error {
+    fn from(err: std::io::Error) -> Error {
+        Error::IoError(err.to_string())
+    }
 }
 
+impl std::fmt::Display for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match *self {
+            Self::UnrecognizedFormat => write!(f, "Unrecognized format"),
+            Self::NotSupported => write!(f, "Operation not supported"),
+            Self::NotFound => write!(f, "Data not found"),
+            Self::BufferTooSmall => write!(f, "Buffer is too small"),
+            Self::IoError(ref err) => write!(f, "IO Error: {}", err),
+        }
+    }
+}
+
+impl std::error::Error for Error {}
+
+/// RAW file type. This list the type of files, which
+/// coincidentally match the vendor, except for DNG.
+///
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 pub enum Type {
+    /// Sony Alpha
+    Arw,
+    /// Canon RAW CIFF based
+    Crw,
+    /// Canon RAW TIFF based
+    Cr2,
+    /// Canon RAW MPEG4 ISO based
     Cr3,
+    /// Adobe Digital Negative
+    Dng,
+    /// Epson RAW
+    Erf,
+    /// GoPro RAW
+    Gpr,
+    /// Minolta RAW
+    Mrw,
+    /// Nikon RAW
+    Nef,
+    /// Nikon RAW (NRW variant)
+    Nrw,
+    /// Olympus RAW
+    Orf,
+    /// Pentax RAW
+    Pef,
+    /// Fujfilm RAW
+    Raf,
+    /// Panasonic RAW (old)
+    Raw,
+    /// Panasonic RAW
+    Rw2,
+    /// Sony RAW (old)
+    Sr2,
     #[cfg(test)]
+    /// Value for testing only
     Test,
 }
 

src/raf.rs

@@ -0,0 +1,21 @@
+/*
+ * libopenraw - raf.rs
+ *
+ * Copyright (C) 2022 Hubert Figuière
+ *
+ * This library is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+pub(crate) const RAF_MAGIC: &[u8] = b"FUJIFILMCCD-RAW ";