feat: add supports_stream to check if byte stream is supported by parser

Author: ok-nick

sdk/src/asset_handlers/bmff_io.rs

@@ -1640,6 +1640,15 @@ impl AssetIO for BmffIO {
     fn supported_types(&self) -> &[&str] {
         &SUPPORTED_TYPES
     }
+
+    fn supports_stream(&self, stream: &mut dyn CAIRead) -> Result<bool> {
+        stream.rewind()?;
+
+        let mut header = [0u8; 12];
+        stream.read_exact(&mut header)?;
+
+        Ok(header[4..8] == *b"ftyp")
+    }
 }
 
 impl CAIWriter for BmffIO {

sdk/src/asset_handlers/c2pa_io.rs

@@ -128,6 +128,11 @@ impl AssetIO for C2paIO {
         &SUPPORTED_TYPES
     }
 
+    fn supports_stream(&self, _stream: &mut dyn CAIRead) -> Result<bool> {
+        // TODO: complex
+        Ok(true)
+    }
+
     fn composed_data_ref(&self) -> Option<&dyn ComposedManifestRef> {
         Some(self)
     }

sdk/src/asset_handlers/gif_io.rs

@@ -379,6 +379,15 @@ impl AssetIO for GifIO {
     fn supported_types(&self) -> &[&str] {
         &["gif", "image/gif"]
     }
+
+    fn supports_stream(&self, stream: &mut dyn CAIRead) -> Result<bool> {
+        stream.rewind()?;
+
+        let mut header = [0u8; 6];
+        stream.read_exact(&mut header)?;
+
+        Ok(header == *b"GIF87a" || header == *b"GIF89a")
+    }
 }
 
 impl GifIO {

sdk/src/asset_handlers/jpeg_io.rs

@@ -14,7 +14,7 @@
 use std::{
     collections::HashMap,
     fs::File,
-    io::{BufReader, Cursor, Write},
+    io::{BufReader, Cursor, SeekFrom, Write},
     path::*,
 };
 
@@ -568,6 +568,15 @@ impl AssetIO for JpegIO {
     fn supported_types(&self) -> &[&str] {
         &SUPPORTED_TYPES
     }
+
+    fn supports_stream(&self, stream: &mut dyn CAIRead) -> Result<bool> {
+        stream.rewind()?;
+
+        let mut header = [0u8; 3];
+        stream.read_exact(&mut header)?;
+
+        Ok(header == [0xFF, 0xD8, 0xFF])
+    }
 }
 
 impl RemoteRefEmbed for JpegIO {

sdk/src/asset_handlers/mp3_io.rs

@@ -344,6 +344,10 @@ impl AssetIO for Mp3IO {
     fn supported_types(&self) -> &[&str] {
         &SUPPORTED_TYPES
     }
+    fn supports_stream(&self, _stream: &mut dyn CAIRead) -> Result<bool> {
+        // TODO: complex
+        Ok(true)
+    }
 }
 
 impl CAIWriter for Mp3IO {

sdk/src/asset_handlers/pdf_io.rs

@@ -11,13 +11,12 @@
 // specific language governing permissions and limitations under
 // each license.
 
-use std::{fs::File, path::Path};
+use std::{fs::File, io::SeekFrom, path::Path};
 
 use crate::{
     asset_handlers::pdf::{C2paPdf, Pdf},
     asset_io::{AssetIO, CAIRead, CAIReader, CAIWriter, ComposedManifestRef, HashObjectPositions},
-    Error,
-    Error::{JumbfNotFound, NotImplemented, PdfReadError},
+    Error::{self, JumbfNotFound, NotImplemented, PdfReadError},
 };
 
 static SUPPORTED_TYPES: [&str; 2] = ["pdf", "application/pdf"];
@@ -109,6 +108,15 @@ impl AssetIO for PdfIO {
         &SUPPORTED_TYPES
     }
 
+    fn supports_stream(&self, stream: &mut dyn CAIRead) -> crate::Result<bool> {
+        stream.rewind()?;
+
+        let mut header = [0u8; 5];
+        stream.read_exact(&mut header)?;
+
+        Ok(header == *b"%PDF-")
+    }
+
     fn composed_data_ref(&self) -> Option<&dyn ComposedManifestRef> {
         Some(self)
     }

sdk/src/asset_handlers/png_io.rs

@@ -196,6 +196,7 @@ fn read_string(asset_reader: &mut dyn CAIRead, max_read: u32) -> Result<String>
 
     Ok(String::from_utf8_lossy(&s).to_string())
 }
+
 pub struct PngIO {}
 
 impl CAIReader for PngIO {
@@ -569,6 +570,15 @@ impl AssetIO for PngIO {
     fn supported_types(&self) -> &[&str] {
         &SUPPORTED_TYPES
     }
+
+    fn supports_stream(&self, stream: &mut dyn CAIRead) -> Result<bool> {
+        stream.rewind()?;
+
+        let mut header = [0u8; 8];
+        stream.read_exact(&mut header)?;
+
+        Ok(header == [0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A])
+    }
 }
 
 fn get_xmp_insertion_point(asset_reader: &mut dyn CAIRead) -> Option<(u64, u32)> {

sdk/src/asset_handlers/riff_io.rs

@@ -386,6 +386,16 @@ impl AssetIO for RiffIO {
     fn supported_types(&self) -> &[&str] {
         &SUPPORTED_TYPES
     }
+
+    fn supports_stream(&self, stream: &mut dyn CAIRead) -> Result<bool> {
+        stream.rewind()?;
+
+        let mut header = [0u8; 4];
+        stream.read_exact(&mut header)?;
+
+        // TODO: if we want to detect the subtype we can do extra parsing on the next few bytes
+        Ok(header == *b"RIFF")
+    }
 }
 
 impl CAIWriter for RiffIO {

sdk/src/asset_handlers/svg_io.rs

@@ -159,6 +159,11 @@ impl AssetIO for SvgIO {
     fn supported_types(&self) -> &[&str] {
         &SUPPORTED_TYPES
     }
+
+    fn supports_stream(&self, _stream: &mut dyn CAIRead) -> Result<bool> {
+        // TODO: complex
+        Ok(true)
+    }
 }
 
 // create manifest entry

sdk/src/asset_handlers/tiff_io.rs

@@ -1332,6 +1332,7 @@ where
 
     asset_reader.read_to_vec(xmp_ifd_entry.value_count).ok()
 }
+
 pub struct TiffIO {}
 
 impl CAIReader for TiffIO {
@@ -1426,6 +1427,24 @@ impl AssetIO for TiffIO {
     fn supported_types(&self) -> &[&str] {
         &SUPPORTED_TYPES
     }
+
+    fn supports_stream(&self, stream: &mut dyn CAIRead) -> Result<bool> {
+        stream.rewind()?;
+
+        let mut header = [0u8; 4];
+        stream.read_exact(&mut header)?;
+
+        Ok(
+            // Little-endian TIFF
+            header == [0x49, 0x49, 0x2A, 0x00]
+            // Big-endian TIFF
+            || header == [0x4D, 0x4D, 0x00, 0x2A]
+            // Little-endian BigTIFF
+            || header == [0x49, 0x49, 0x2B, 0x00]
+            // Big-endian BigTIFF
+            || header == [0x4D, 0x4D, 0x00, 0x2B],
+        )
+    }
 }
 
 impl CAIWriter for TiffIO {