Cargo.lock

@@ -90,7 +90,7 @@ checksum = "d75a2a4b1b190afb6f5425f10f6a8f959d2ea0b9c2b1d79553551850539e4674"
 
 [[package]]
 name = "itunesdb"
-version = "0.1.20"
+version = "0.1.19"
 dependencies = [
  "bincode",
  "env_logger",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "itunesdb"
-version = "0.1.20"
+version = "0.1.19"
 edition = "2021"
 authors = ["alterwain"]
 

src/artworkdb.rs

@@ -1,214 +0,0 @@
-pub mod deserializer {
-    use log::info;
-    use crate::artworkdb::aobjects::{ADataSet, ADatabase, AImageItem, ASomeList};
-    use crate::artworkdb::objects::{ChunkHeader, ChunkType, DataSet, Database, ImageItem, ImageName};
-
-    enum ChunkState {
-        Header,
-        Data
-    }
-
-    pub fn parse_bytes(data: &[u8]) -> ADatabase {
-        let mut adb = ADatabase {data: None, header: None, children: Vec::new() };
-        let mut state = ChunkState::Header;
-        let mut chunk_header: Option<ChunkHeader> = None;
-        let mut last_type: u32 = 0;
-        let mut i = 0;
-        while i < data.len() {
-            state = match state {
-                ChunkState::Header => {
-                    if i + 12 >= data.len() { break; }
-                    chunk_header = Some(bincode::deserialize(&data[i..i + 12]).unwrap());
-                    i += 12;
-                    ChunkState::Data
-                },
-                ChunkState::Data => {
-                    let mut u = 0;
-                    let header = chunk_header.unwrap();
-                    match ChunkType::from(header.chunk_type) {
-                        ChunkType::ArtworkDB => {
-                            u = usize::try_from(header.end_of_chunk).unwrap() - 12;
-                            let db: Database = bincode::deserialize(&data[i..i+u]).unwrap();
-                            info!("val: {:?}", db);
-                            adb.data = Some(db);
-                            adb.header = Some(header);
-                        },
-                        ChunkType::DataSet => {
-                            u = usize::try_from(header.end_of_chunk).unwrap() - 12;
-                            let ds: DataSet = bincode::deserialize(&data[i..i + u]).unwrap();
-                            last_type = ds.data_type;
-                            adb.children.push(ADataSet { header, data: ds, child: match ds.data_type {
-                                _ => ASomeList::Images(Vec::new()), // 1
-                            }});
-                        },
-                        ChunkType::ImageList => {
-                            u = usize::try_from(header.end_of_chunk).unwrap() - 12;
-                        },
-                        ChunkType::ImageItem => {
-                            u = usize::try_from(header.end_of_chunk).unwrap() - 12;
-                            let ai: ImageItem = bincode::deserialize(&data[i..i+u]).unwrap();
-                            if let ASomeList::Images(images) = &mut adb.find_dataset(1).child {
-                                images.push(AImageItem { data: ai, name: None });
-                            }
-                        },
-                        ChunkType::LocationTag => {
-                            u = usize::try_from(header.end_of_chunk).unwrap() - 12;
-                        },
-                        ChunkType::ImageName => {
-                            u = usize::try_from(header.end_of_chunk).unwrap() - 12;
-                            let ds: ImageName = bincode::deserialize(&data[i..i + u]).unwrap();
-                            if let ASomeList::Images(images) = &mut adb.find_dataset(1).child {
-                                images.last_mut().unwrap().name = Some(ds);
-                            }
-                        },
-                        _ => { u = 1; info!("Unknown stuff happened"); }
-                    }
-                    i += u;
-                    chunk_header = None;
-                    ChunkState::Header
-                }
-            }
-        }
-        adb
-    }
-}
-
-pub mod aobjects {
-    use crate::artworkdb::objects::{ChunkHeader, DataSet, Database, ImageItem, ImageName};
-
-    #[derive(Debug, serde::Serialize)]
-    pub struct ADatabase {
-        pub header: Option<ChunkHeader>,
-        pub data: Option<Database>,
-        pub children: Vec<ADataSet>
-    }
-
-    impl ADatabase {
-        pub(crate) fn find_dataset(&mut self, p0: u32) -> &mut ADataSet {
-            self.children.iter_mut().find(|d| d.data.data_type == p0).unwrap()
-        }
-    }
-
-    #[derive(Debug, serde::Serialize)]
-    pub struct ADataSet {
-        pub header: ChunkHeader,
-        pub data: DataSet,
-        pub child: ASomeList
-    }
-
-    #[derive(Debug, serde::Serialize)]
-    pub enum ASomeList {
-        Images(Vec<AImageItem>), // 1
-        Albums, // 2
-        Files, // 3
-    }
-
-    #[derive(Debug, serde::Serialize)]
-    pub struct AImageItem {
-        pub data: ImageItem,
-        pub name: Option<ImageName>,
-    }
-}
-
-pub mod objects {
-    use serde::{Deserialize, Serialize};
-
-    pub enum ChunkType {
-        ArtworkDB,
-        DataSet,
-        ImageList,
-        ImageItem,
-        LocationTag,
-        ImageName,
-        Unknown,
-    }
-
-    impl From<[u8; 4]> for ChunkType {
-        fn from(value: [u8; 4]) -> Self {
-            match value {
-                [0x6D, 0x68, 0x66, 0x64] => ChunkType::ArtworkDB,
-                [0x6D, 0x68, 0x73, 0x64] => ChunkType::DataSet,
-                [0x6D, 0x68, 0x6C, 0x69] => ChunkType::ImageList,
-                [0x6D, 0x68, 0x69, 0x69] => ChunkType::ImageItem,
-                [0x6D, 0x68, 0x6F, 0x64] => ChunkType::LocationTag,
-                [0x6D, 0x68, 0x6E, 0x69] => ChunkType::ImageName,
-                _ => ChunkType::Unknown,
-            }
-        }
-    }
-
-    impl From<ChunkType> for [u8; 4] {
-        fn from(value: ChunkType) -> Self {
-            match value {
-                ChunkType::ArtworkDB => [0x6D, 0x68, 0x66, 0x64],
-                ChunkType::DataSet => [0x6D, 0x68, 0x73, 0x64],
-                ChunkType::Unknown => [0x00, 0x00, 0x00, 0x00],
-                ChunkType::ImageList => [0x6D, 0x68, 0x6C, 0x69],
-                ChunkType::ImageItem => [0x6D, 0x68, 0x69, 0x69],
-                ChunkType::LocationTag => [0x6D, 0x68, 0x6F, 0x64],
-                ChunkType::ImageName => [0x6D, 0x68, 0x6E, 0x69],
-            }
-        }
-    }
-
-    #[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Copy)]
-    pub struct ChunkHeader {
-        pub chunk_type: [u8; 4],
-        pub end_of_chunk: u32,
-        pub children_count: u32,
-    }
-
-    #[derive(Serialize, Deserialize, PartialEq, Debug)]
-    pub struct Database {
-        unknown1: u32,
-        unknown2: u32,
-        number_of_children: u32,
-        unknown3: u32,
-        next_id_for_mhii: u32,
-        unknown5: u64,
-        unknown6: u64,
-        unknown7: u32,
-        unknown8: u32,
-        unknown9: u32,
-        unknown10: u64
-    }
-
-    #[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Copy)]
-    pub struct DataSet {
-        pub data_type: u32,
-    }
-
-    #[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Copy)]
-    pub struct LocationTag {
-        tag_type: u32,
-        unk1: u32,
-        unk2: u32,
-    }
-
-    #[derive(Serialize, Deserialize, PartialEq, Debug)]
-    pub struct ImageItem {
-        number_of_children: u32,
-        id: u32,
-        song_dbid: u64,
-        unknown4: u32,
-        rating: u32,
-        unknown6: u32,
-        original_date: u32,
-        digitized_date: u32,
-        source_image_size: u32
-    }
-
-    #[derive(Serialize, Deserialize, PartialEq, Debug)]
-    pub struct ImageName {
-        number_of_children: u32,
-        correlation_id: u32,
-        ithmb_offset: u32,
-        image_size: u32,
-        vertical_padding: u16,
-        horizontal_padding: u16,
-        image_height: u16,
-        image_width: u16,
-        unknown: u32,
-        image_size_n: u32,
-    }
-}

src/lib.rs

@@ -3,7 +3,7 @@ pub mod objects;
 pub mod xobjects;
 pub mod deserializer;
 pub mod serializer;
-mod artworkdb;
+
 /*
 [lib]
 crate-type = ["staticlib", "cdylib", "lib"]