Cleanup (#9)

* Move geo-specific stuff to geo mod

* Rename ObjectStoreCursor to AsyncCursor

* Rename to async-tiff

Author: kylebarron

Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "aiocogeo"
+name = "async-tiff"
 version = "0.1.0"
 edition = "2021"
 

README.md

@@ -1,6 +1,16 @@
-# aiocogeo-rs
-Exploratory rust version of aiocogeo
+# async-tiff
 
+An async [TIFF](https://en.wikipedia.org/wiki/TIFF) reader.
+
+The existing [`tiff` crate](https://crates.io/crates/tiff) is great, but only supports synchronous reading of TIFF files. Furthermore, due to low maintenance bandwidth it is not designed for extensibility (see [#250](https://github.com/image-rs/image-tiff/issues/250)).
+
+This crate is designed to be a minimal, low-level interface to read tiled TIFF files in an async way.
+
+It additionally exposes geospatial-specific TIFF tag metadata.
+
+### Tests
+
+Download the following file for use in the tests.
 
 ```
 aws s3 cp s3://naip-visualization/ny/2022/60cm/rgb/40073/m_4007307_sw_18_060_20220803.tif ./ --request-payer

src/async_reader.rs

@@ -1,9 +1,11 @@
+use std::io::{Cursor, SeekFrom};
+use std::ops::Range;
+use std::sync::Arc;
+
+use byteorder::{BigEndian, LittleEndian, ReadBytesExt};
 use bytes::Bytes;
 use futures::future::{BoxFuture, FutureExt, TryFutureExt};
 use object_store::ObjectStore;
-use std::io::SeekFrom;
-use std::ops::Range;
-use std::sync::Arc;
 
 use crate::error::{AiocogeoError, Result};
 
@@ -111,3 +113,112 @@ impl AsyncFileReader for ObjectReader {
         .boxed()
     }
 }
+
+#[derive(Debug, Clone, Copy, Default)]
+pub enum Endianness {
+    #[default]
+    LittleEndian,
+    BigEndian,
+}
+
+/// A wrapper around an [ObjectStore] that provides a seek-oriented interface
+// TODO: in the future add buffering to this
+pub(crate) struct AsyncCursor {
+    reader: Box<dyn AsyncFileReader>,
+    offset: usize,
+    endianness: Endianness,
+}
+
+/// Macro to generate functions to read scalar values from the cursor
+macro_rules! impl_read_byteorder {
+    ($method_name:ident, $typ:ty) => {
+        pub(crate) async fn $method_name(&mut self) -> $typ {
+            let mut buf = Cursor::new(self.read(<$typ>::BITS as usize / 8).await);
+            match self.endianness {
+                Endianness::LittleEndian => buf.$method_name::<LittleEndian>().unwrap(),
+                Endianness::BigEndian => buf.$method_name::<BigEndian>().unwrap(),
+            }
+        }
+    };
+}
+
+impl AsyncCursor {
+    pub(crate) fn new(reader: Box<dyn AsyncFileReader>) -> Self {
+        Self {
+            reader,
+            offset: 0,
+            endianness: Default::default(),
+        }
+    }
+
+    pub(crate) fn set_endianness(&mut self, endianness: Endianness) {
+        self.endianness = endianness;
+    }
+
+    pub(crate) fn into_inner(self) -> Box<dyn AsyncFileReader> {
+        self.reader
+    }
+
+    pub(crate) async fn read(&mut self, length: usize) -> Bytes {
+        let range = self.offset..self.offset + length;
+        self.offset += length;
+        self.reader.get_bytes(range).await.unwrap()
+    }
+
+    /// Read a u8 from the cursor
+    pub(crate) async fn read_u8(&mut self) -> u8 {
+        let buf = self.read(1).await;
+        Cursor::new(buf).read_u8().unwrap()
+    }
+
+    /// Read a i8 from the cursor
+    pub(crate) async fn read_i8(&mut self) -> i8 {
+        let buf = self.read(1).await;
+        Cursor::new(buf).read_i8().unwrap()
+    }
+
+    impl_read_byteorder!(read_u16, u16);
+    impl_read_byteorder!(read_u32, u32);
+    impl_read_byteorder!(read_u64, u64);
+    impl_read_byteorder!(read_i16, i16);
+    impl_read_byteorder!(read_i32, i32);
+    impl_read_byteorder!(read_i64, i64);
+
+    pub(crate) async fn read_f32(&mut self) -> f32 {
+        let mut buf = Cursor::new(self.read(4).await);
+        match self.endianness {
+            Endianness::LittleEndian => buf.read_f32::<LittleEndian>().unwrap(),
+            Endianness::BigEndian => buf.read_f32::<BigEndian>().unwrap(),
+        }
+    }
+
+    pub(crate) async fn read_f64(&mut self) -> f64 {
+        let mut buf = Cursor::new(self.read(8).await);
+        match self.endianness {
+            Endianness::LittleEndian => buf.read_f64::<LittleEndian>().unwrap(),
+            Endianness::BigEndian => buf.read_f64::<BigEndian>().unwrap(),
+        }
+    }
+
+    #[allow(dead_code)]
+    pub(crate) fn reader(&self) -> &dyn AsyncFileReader {
+        &self.reader
+    }
+
+    pub(crate) async fn get_range(&mut self, range: Range<usize>) -> Result<Bytes> {
+        self.reader.get_bytes(range).await
+    }
+
+    /// Advance cursor position by a set amount
+    pub(crate) fn advance(&mut self, amount: usize) {
+        self.offset += amount;
+    }
+
+    pub(crate) fn seek(&mut self, offset: usize) {
+        self.offset = offset;
+    }
+
+    pub(crate) fn position(&self) -> usize {
+        self.offset
+    }
+}

src/cog.rs

@@ -1,6 +1,6 @@
 use bytes::Bytes;
 
-use crate::cursor::{Endianness, ObjectStoreCursor};
+use crate::async_reader::{AsyncCursor, Endianness};
 use crate::error::Result;
 use crate::ifd::ImageFileDirectories;
 use crate::AsyncFileReader;
@@ -13,7 +13,7 @@ pub struct COGReader {
 
 impl COGReader {
     pub async fn try_open(reader: Box<dyn AsyncFileReader>) -> Result<Self> {
-        let mut cursor = ObjectStoreCursor::new(reader);
+        let mut cursor = AsyncCursor::new(reader);
         let magic_bytes = cursor.read(2).await;
         // Should be b"II" for little endian or b"MM" for big endian
         if magic_bytes == Bytes::from_static(b"II") {

src/cursor.rs

@@ -0,0 +1,6 @@
+mod affine;
+mod geo_key_directory;
+mod partial_reads;
+
+pub use affine::AffineTransform;
+pub use geo_key_directory::{GeoKeyDirectory, GeoKeyTag};