[feat] Works on specific areas

Cargo.toml

@@ -34,7 +34,9 @@ bindgen = ["libraw-sys/bindgen"]
 exif = ["dep:libc"]
 openmp = ["libraw-sys/openmp"]
 openmp_static = ["libraw-sys/openmp_static"]
-default = ["exif"]
+debug = []
+
+default = ["exif", "debug"]
 
 [build-dependencies]
 anyhow = "1.0.58"

examples/dcraw_half.rs

@@ -1,6 +1,5 @@
 use libraw_r::traits::LRString;
-use std::path::Path;
-use std::sync::Arc;
+use std::{io::Seek, path::Path};
 
 pub fn main() -> anyhow::Result<()> {
     for arg in std::env::args().skip(1) {
@@ -9,8 +8,8 @@ pub fn main() -> anyhow::Result<()> {
         //     .build();
         let p = libraw_r::EmptyProcessor::new()?;
         let file = std::fs::File::open(&arg)?;
-        let mut buffered = std::io::BufReader::new(file);
-        let mut p = p.open(&mut buffered)?;
+        let buffered = std::io::BufReader::new(file);
+        let mut p = p.open(buffered)?;
         println!(
             "Processing {arg} ({}, {})",
             p.idata().make.as_ascii(),
@@ -19,7 +18,7 @@ pub fn main() -> anyhow::Result<()> {
         p.unpack()?;
         p.dcraw_process()?;
         p.dcraw_ppm_tiff_writer(Path::new(&arg).with_extension("ppm"))?;
-        drop(buffered);
+        // drop(buffered);
         println!("Writing to {arg}.ppm");
     }
     Ok(())

io/io.cpp

@@ -1,11 +1,16 @@
 #include "io.h"
 #include "riio.h"
 #include <libraw.h>
+#include <libraw/libraw_const.h>
+#define ID lr->get_internal_data_pointer()->internal_data
 
 class LibrawIO : public LibRaw_abstract_datastream {
 public:
   LibrawIO(LibrawOpaqueDatastream *lod) { this->inner = lod; }
-  virtual ~LibrawIO() {}
+  virtual ~LibrawIO() {
+    printf("LibrawIO::~LibrawIO()\n");
+    lod_drop(this->inner);
+  }
 
   virtual int valid() { return lod_valid(inner); }
   virtual int read(void *ptr, size_t size, size_t nmemb) {
@@ -15,7 +20,7 @@ class LibrawIO : public LibRaw_abstract_datastream {
   virtual INT64 tell() { return lod_tell(inner); }
   virtual INT64 size() { return lod_size(inner); }
   virtual int scanf_one(const char *fmt, void *val) {
-      return lod_scanf_one(inner, fmt, val);
+    return lod_scanf_one(inner, fmt, val);
   }
   virtual int get_char() { return lod_get_char(inner); }
   virtual char *gets(char *str, int maxlen) {
@@ -26,11 +31,47 @@ class LibrawIO : public LibRaw_abstract_datastream {
   LibrawOpaqueDatastream *inner;
 };
 
-int libraw_open_io(libraw_data_t *libraw,
-                              LibrawOpaqueDatastream *io) {
-  LibrawIO* libraw_io = new LibrawIO(io);
+/* int libraw_open_io(libraw_data_t *libraw, LibrawOpaqueDatastream *io) { */
+/*   LibRaw *lr = (LibRaw *)libraw->parent_class; */
+/*   LibrawIO *stream; */
+/*   stream = new LibrawIO(io); */
+/*   if (!stream || !stream->valid()) { */
+/*     delete stream; */
+/*     return LIBRAW_IO_ERROR; */
+/*   } */
+/*   ID.input_internal = 0; // preserve from deletion on error */
+/*   int ret = lr->open_datastream(stream); */
+/*   if (ret == LIBRAW_SUCCESS) */
+/*   { */
+/*     ID.input_internal = 1; // flag to delete datastream on recycle */
+/*   } */
+/*   else */
+/*   { */
+/*     delete stream; */
+/*     ID.input_internal = 0; */
+/*   } */
+/*   return ret; */
+/* } */
+int libraw_open_io(libraw_data_t *libraw, LibrawOpaqueDatastream *io) {
   LibRaw *lr = (LibRaw *)libraw->parent_class;
-  /* printf("libraw_open_io\n"); */
+  LibRaw_abstract_datastream *stream;
+  stream = new LibrawIO(io);
+  if (!stream->valid()) {
+    delete stream;
+    return LIBRAW_IO_ERROR;
+  }
+  /* ID.input_internal = 0; // preserve from deletion on error */
+  int ret = lr->open_datastream(stream);
+  /* if (ret == LIBRAW_SUCCESS) { */
+  /*   ID.input_internal = 1; // flag to delete datastream on recycle */
+  /* } else { */
+  /*   delete stream; */
+  /*   ID.input_internal = 0; */
+  /* } */
+  return ret;
+}
 
-  return lr->open_datastream(libraw_io);
+int libraw_valid_check(libraw_data_t *libraw) {
+  LibRaw *lr = (LibRaw *)libraw->parent_class;
+  return ID.input->valid();
 }

io/io.h

@@ -8,6 +8,7 @@ extern "C" {
 int libraw_open_io(libraw_data_t *libraw,
                               LibrawOpaqueDatastream *io);
 
+int libraw_valid_check(libraw_data_t *libraw);
 #ifdef __cplusplus
 }
 #endif

io/riio.h

@@ -32,6 +32,8 @@ char *lod_gets(struct LibrawOpaqueDatastream *this_, char *buffer, int size);
 
 int lod_scanf_one(struct LibrawOpaqueDatastream *this_, const char *fmt, void *val);
 
+void lod_drop(struct LibrawOpaqueDatastream *this_);
+
 #ifdef __cplusplus
 } // extern "C"
 #endif // __cplusplus

src/dcraw.rs

@@ -31,7 +31,7 @@ impl Processor<'_> {
     }
 
     pub fn dcraw_ppm_tiff_writer(
-        self,
+        &mut self,
         path: impl AsRef<std::path::Path>,
     ) -> Result<(), LibrawError> {
         LibrawError::check(unsafe {

src/io.rs

@@ -1,4 +1,17 @@
 pub mod bindings;
+
+#[cfg(feature = "debug")]
+pub trait MaybeDebug: core::fmt::Debug {}
+
+#[cfg(feature = "debug")]
+impl<T: core::fmt::Debug> MaybeDebug for T {}
+
+#[cfg(not(feature = "debug"))]
+pub trait MaybeDebug {}
+
+#[cfg(not(feature = "debug"))]
+impl<T> MaybeDebug for T {}
+
 ///  Input layer abstraction
 ///
 ///  class LibRaw_abstract_datastream - abstract RAW read interface
@@ -108,7 +121,7 @@ pub mod bindings;
 // #endif
 // };
 // ```
-pub trait LibrawDatastream: Read + Seek + Eof {
+pub trait LibrawDatastream: Read + Seek + Eof + MaybeDebug {
     /// # Safety
     ///
     /// This function will be called from ffi (c++)
@@ -134,7 +147,7 @@ pub trait LibrawDatastream: Read + Seek + Eof {
     }
     /// # Safety
     ///
-    /// 
+    ///
     unsafe fn seek(&mut self, offset: i64, whence: u32) -> i32 {
         match whence {
             sys::SEEK_SET => {
@@ -188,9 +201,9 @@ pub trait LibrawDatastream: Read + Seek + Eof {
     }
 }
 
-impl<T: Read + Seek + Eof> LibrawDatastream for T {}
+impl<T: Read + Seek + Eof + MaybeDebug> LibrawDatastream for T {}
 
-pub trait LibrawBufferedDatastream: LibrawDatastream + BufRead {
+pub trait LibrawBufferedDatastream: LibrawDatastream + BufRead + MaybeDebug {
     /// # Safety
     ///
     /// This function is unsafe because it dereferences a raw pointer and is called from ffi.
@@ -223,7 +236,7 @@ pub trait LibrawBufferedDatastream: LibrawDatastream + BufRead {
     }
 }
 
-impl<T: LibrawDatastream + BufRead> LibrawBufferedDatastream for T {}
+impl<T: LibrawDatastream + BufRead + MaybeDebug> LibrawBufferedDatastream for T {}
 
 use core::ops::{Deref, DerefMut};
 // pub trait Libraw
@@ -341,12 +354,13 @@ fn read_until<R: BufRead + ?Sized>(
 
 // impl<T: LibrawBufferedDatastream> AbstractDatastream<T> {
 #[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub struct LibrawOpaqueDatastream<'a> {
     inner: Box<dyn LibrawBufferedDatastream + 'a>,
 }
 
 impl<'a> LibrawOpaqueDatastream<'a> {
-    pub fn new(inner: impl LibrawBufferedDatastream + 'a) -> Self {
+    pub fn new(inner: impl LibrawBufferedDatastream + MaybeDebug + 'a) -> Self {
         Self {
             inner: Box::new(inner),
         }
@@ -384,6 +398,7 @@ pub unsafe extern "C" fn lod_seek(
 ) -> i32 {
     assert!(!this.is_null());
     let this = unsafe { &mut *this };
+    // this.inner.tell();
     LibrawDatastream::seek(&mut this.inner, offset, whence)
 }
 
@@ -434,5 +449,41 @@ pub unsafe extern "C" fn lod_scanf_one(
     fmt: *const libc::c_char,
     val: *mut libc::c_void,
 ) -> libc::c_int {
-    todo!();
+    assert!(!this.is_null());
+    use core::ffi::*;
+    let this = unsafe { &mut *this };
+    let fmt = unsafe { CStr::from_ptr(fmt) };
+    // let val = unsafe { &mut *(val as *mut u32) };
+    // let mut buf = [0u8; 4];
+    // todo!()
+    match fmt.to_bytes() {
+        b"%d" => {
+            let val = unsafe { &mut *(val as *mut i32) };
+            let mut buf = [0u8; 4];
+            if this.inner.read_exact(&mut buf).is_err() {
+                return -1;
+            }
+            *val = i32::from_ne_bytes(buf);
+            1
+        }
+        b"%f" => {
+            let val = unsafe { &mut *(val as *mut f32) };
+            let mut buf = [0u8; 4];
+            if this.inner.read_exact(&mut buf).is_err() {
+                return -1;
+            }
+            *val = f32::from_ne_bytes(buf);
+            1
+        }
+        b"%s" => unimplemented!("skipped for now"),
+        _ => return -1,
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn lod_drop(this: *mut LibrawOpaqueDatastream) {
+    assert!(!this.is_null());
+    let this = unsafe { this.read() };
+    panic!("dropping");
+    drop(this)
 }

src/lib.rs

@@ -4,7 +4,9 @@ pub mod dcraw;
 pub mod image;
 pub mod io;
 pub mod processor;
+pub use io::{LibrawBufferedDatastream, LibrawDatastream, MaybeDebug};
 use processor::Processor;
+
 // pub mod dcraw;
 // pub mod defaults;
 // #[cfg(feature = "exif")]
@@ -13,16 +15,14 @@ use processor::Processor;
 // pub mod progress;
 pub mod traits;
 
-use alloc::sync::Arc;
 pub use error::LibrawError;
 
 extern crate alloc;
 extern crate libraw_sys as sys;
 use core::ptr::NonNull;
-use core::sync::atomic::AtomicBool;
 use semver::Version;
 use std::ffi::CString;
-use std::ops::Drop;
+use std::mem::ManuallyDrop;
 use std::path::Path;
 
 /// Returns the version of libraw the bindings were generated against
@@ -54,14 +54,18 @@ impl EmptyProcessor {
         })
     }
 
-    pub fn open<'reader, T: std::io::BufRead + std::io::Seek + 'reader>(
+    pub fn open<'reader, T: std::io::BufRead + std::io::Seek + MaybeDebug + 'reader>(
         mut self,
         reader: T,
     ) -> Result<Processor<'reader>, LibrawError> {
         let mut io = io::LibrawOpaqueDatastream::new(reader);
-        let ret = unsafe { io::bindings::libraw_open_io(self.inner.as_mut(), &mut io) };
+        let ret = unsafe {
+            io::bindings::libraw_open_io(self.inner.as_mut(), core::ptr::addr_of_mut!(io))
+        };
         LibrawError::check(ret)?;
-        core::mem::forget(io);
-        Ok(unsafe { Processor::new(self.inner) })
+        let mut p = unsafe { Processor::new(self.inner) };
+        let _ = ManuallyDrop::new(io);
+        // p.unpack()?;
+        Ok(p)
     }
 }

src/processor.rs

@@ -18,6 +18,11 @@ impl<'reader> Processor<'reader> {
         unsafe { &self.inner.as_ref().idata }
     }
 
+    pub fn valid(&mut self) -> Result<(), LibrawError> {
+        let ret = unsafe { crate::io::bindings::libraw_valid_check(self.inner.as_mut()) };
+        LibrawError::check(ret)
+    }
+
     pub fn unpack(&mut self) -> Result<(), LibrawError> {
         let ret = unsafe { sys::libraw_unpack(self.inner.as_mut()) };
         LibrawError::check(ret)