368 lines
15 KiB
Rust
368 lines
15 KiB
Rust
pub mod deserializer {
|
|
use log::info;
|
|
use crate::artworkdb::aobjects::{ADataSet, ADatabase, AImageItem, AImageName, SecondTypeTag, ThirdTypeTag};
|
|
use crate::artworkdb::objects::{ChunkHeader, ChunkType, DataSet, Database, ImageFile, ImageItem, ImageName, LocationTag};
|
|
|
|
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: Vec::new()});
|
|
},
|
|
ChunkType::ImageList | ChunkType::AlbumList | ChunkType::FileList => {
|
|
u = usize::try_from(header.end_of_chunk).unwrap() - 12;
|
|
},
|
|
ChunkType::ImageItem => {
|
|
info!("ImageItem tag");
|
|
u = usize::try_from(header.end_of_chunk).unwrap() - 12;
|
|
let ai: ImageItem = bincode::deserialize(&data[i..i+u]).unwrap();
|
|
let images = &mut adb.find_dataset(last_type).child;
|
|
images.push(AImageItem { data: Some(ai), tag: Vec::new(), file: None });
|
|
},
|
|
ChunkType::FileImage => {
|
|
u = usize::try_from(header.end_of_chunk).unwrap() - 12;
|
|
let ai: ImageFile = bincode::deserialize(&data[i..i+u]).unwrap();
|
|
let images = &mut adb.find_dataset(last_type).child;
|
|
images.push(AImageItem { data: None, tag: Vec::new(), file: Some(ai) });
|
|
},
|
|
ChunkType::LocationTag => {
|
|
u = usize::try_from(header.end_of_chunk).unwrap() - 12;
|
|
let ds: LocationTag = bincode::deserialize(&data[i..i + u]).unwrap();
|
|
let images = &mut adb.find_dataset(last_type).child;
|
|
let mut str = None;
|
|
match ds.tag_type {
|
|
3 => {
|
|
let mut bytes = Vec::new();
|
|
let str_end = u32::from_le_bytes(data[i+12..i+16].try_into().unwrap()) as usize;
|
|
let mut h = i+24;
|
|
u += 12 + str_end;
|
|
while h < i+24+str_end {
|
|
bytes.push(u16::from_le_bytes(data[h..h+2].try_into().unwrap()));
|
|
h+=2;
|
|
}
|
|
let g = String::from_utf16(&bytes).unwrap();
|
|
info!("str: {}", g);
|
|
str = Some(g);
|
|
images.last_mut().unwrap().tag.last_mut().unwrap().child.as_mut().unwrap().tag = Some(ThirdTypeTag { data: ds, str });
|
|
},
|
|
2 => {
|
|
images.last_mut().unwrap().tag.push(SecondTypeTag { data: ds, str, child: None });
|
|
},
|
|
_ => { u = usize::try_from(header.children_count).unwrap() - 12; }
|
|
}
|
|
},
|
|
ChunkType::ImageName => {
|
|
info!("ImageName tag");
|
|
u = usize::try_from(header.end_of_chunk).unwrap() - 12;
|
|
let ds: ImageName = bincode::deserialize(&data[i..i + u]).unwrap();
|
|
let images = &mut adb.find_dataset(last_type).child;
|
|
images.last_mut().unwrap().tag.last_mut().unwrap().child = Some(AImageName { iname: ds, tag: None });
|
|
},
|
|
_ => { u = 1; info!("Unknown stuff happened {:X?}", header.chunk_type.to_vec()); }
|
|
}
|
|
i += u;
|
|
chunk_header = None;
|
|
ChunkState::Header
|
|
}
|
|
}
|
|
}
|
|
adb
|
|
}
|
|
}
|
|
|
|
pub mod serializer {
|
|
use log::info;
|
|
use crate::artworkdb::aobjects::ADatabase;
|
|
use crate::artworkdb::objects::{ChunkHeader, ChunkType};
|
|
|
|
pub fn to_bytes(adb: ADatabase) -> Vec<u8> {
|
|
let mut bytes: Vec<u8> = Vec::new();
|
|
for i in 0..(adb.children.len()) {
|
|
let data_set = adb.children.get(i).unwrap();
|
|
let mut entry_bytes = Vec::new();
|
|
|
|
match data_set.data.data_type {
|
|
1 => {
|
|
entry_bytes.append(&mut generate_header_raw(ChunkType::ImageList, 80, data_set.child.len()));
|
|
entry_bytes.append(&mut [0; 80].to_vec());
|
|
}, // Image List
|
|
2 => {
|
|
entry_bytes.append(&mut generate_header_raw(ChunkType::AlbumList, 80, 0));
|
|
entry_bytes.append(&mut [0; 80].to_vec());
|
|
}, // Album list
|
|
3 => {
|
|
entry_bytes.append(&mut generate_header_raw(ChunkType::FileList, 80, data_set.child.len()));
|
|
entry_bytes.append(&mut [0; 80].to_vec());
|
|
}, // File list
|
|
_ => { info!("Unknown data_set type!"); }
|
|
}
|
|
|
|
for img in data_set.child.iter() {
|
|
let mut args = Vec::new();
|
|
if img.data.is_some() {
|
|
for o in &img.tag {
|
|
let mut inameb = Vec::new();
|
|
if let Some(name) = &o.child {
|
|
|
|
let mut nb = Vec::new();
|
|
|
|
let arg = name.tag.as_ref().unwrap();
|
|
let mut str_b = string_to_ipod16(arg.str.as_ref().unwrap());
|
|
str_b = [3u32.to_le_bytes().to_vec(), 0u32.to_le_bytes().to_vec(), 0u32.to_le_bytes().to_vec(), (str_b.len() as u32).to_le_bytes().to_vec(), 2u32.to_le_bytes().to_vec(), 0u32.to_le_bytes().to_vec(), str_b ].concat();
|
|
nb.append(&mut generate_header(ChunkType::LocationTag, 12, str_b.len()));
|
|
nb.append(&mut str_b);
|
|
|
|
inameb.append(&mut generate_header(ChunkType::ImageName, 64, nb.len()));
|
|
inameb.append(&mut [0; 32].to_vec());
|
|
inameb.append(&mut bincode::serialize(&name.iname).unwrap());
|
|
inameb.append(&mut nb);
|
|
}
|
|
|
|
let mut data = [2u32.to_le_bytes(), 0u32.to_le_bytes(), 0u32.to_le_bytes()].concat();
|
|
args.append(&mut generate_header_raw(ChunkType::LocationTag, 12, inameb.len()));
|
|
args.append(&mut data);
|
|
args.append(&mut inameb);
|
|
}
|
|
let mut item = Vec::new();
|
|
item.append(&mut generate_header(ChunkType::ImageItem, 140, args.len()));
|
|
item.append(&mut bincode::serialize(img.data.as_ref().unwrap()).unwrap());
|
|
item.append(&mut [0; 100].to_vec());
|
|
entry_bytes.append(&mut item);
|
|
}
|
|
|
|
if img.file.is_some() {
|
|
entry_bytes.append(&mut generate_header(ChunkType::FileImage, 112, 0));
|
|
entry_bytes.append(&mut bincode::serialize(img.file.as_ref().unwrap()).unwrap());
|
|
entry_bytes.append(&mut [0; 100].to_vec());
|
|
}
|
|
|
|
entry_bytes.append(&mut args);
|
|
}
|
|
|
|
bytes.append(&mut generate_header(ChunkType::DataSet, 84, entry_bytes.len()));
|
|
bytes.append(&mut bincode::serialize(&data_set.data).unwrap());
|
|
bytes.append(&mut [0; 80].to_vec());
|
|
|
|
bytes.append(&mut entry_bytes);
|
|
}
|
|
|
|
let sdb = bincode::serialize(&adb.data.as_ref().unwrap()).unwrap();
|
|
bytes = [generate_header(ChunkType::ArtworkDB, 56 + 64, bytes.len()), sdb, [0; 64].to_vec(), bytes].concat();
|
|
bytes
|
|
}
|
|
|
|
fn string_to_ipod16(str: &str) -> Vec<u8> {
|
|
str.encode_utf16().flat_map(|f| [f as u8, (f >> 8) as u8]).collect()
|
|
}
|
|
|
|
fn generate_header(ct: ChunkType, header_size: usize, data_len: usize) -> Vec<u8> {
|
|
let header_size = 12 + header_size as u32;
|
|
let header = ChunkHeader{ chunk_type: ct.into(), end_of_chunk: header_size, children_count: header_size + data_len as u32};
|
|
bincode::serialize(&header).unwrap()
|
|
}
|
|
|
|
fn generate_header_raw(ct: ChunkType, header_size: usize, child_cnt: usize) -> Vec<u8> {
|
|
let header_size = 12 + header_size as u32;
|
|
let header = ChunkHeader{ chunk_type: ct.into(), end_of_chunk: header_size, children_count: child_cnt as u32};
|
|
bincode::serialize(&header).unwrap()
|
|
}
|
|
}
|
|
|
|
pub mod aobjects {
|
|
use crate::artworkdb::objects::{ChunkHeader, DataSet, Database, ImageFile, ImageItem, ImageName, LocationTag};
|
|
|
|
#[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: Vec<AImageItem>
|
|
}
|
|
|
|
#[derive(Debug, serde::Serialize)]
|
|
pub struct AImageItem {
|
|
pub tag: Vec<SecondTypeTag>,
|
|
pub data: Option<ImageItem>,
|
|
pub file: Option<ImageFile>,
|
|
}
|
|
|
|
#[derive(Debug, serde::Serialize)]
|
|
pub struct AImageName {
|
|
pub iname: ImageName,
|
|
pub tag: Option<ThirdTypeTag>,
|
|
}
|
|
|
|
#[derive(Debug, serde::Serialize)]
|
|
pub struct SecondTypeTag {
|
|
pub data: LocationTag,
|
|
pub str: Option<String>,
|
|
pub child: Option<AImageName>
|
|
}
|
|
|
|
#[derive(Debug, serde::Serialize)]
|
|
pub struct ThirdTypeTag {
|
|
pub data: LocationTag,
|
|
pub str: Option<String>
|
|
}
|
|
}
|
|
|
|
pub mod objects {
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
pub enum ChunkType {
|
|
ArtworkDB,
|
|
DataSet,
|
|
ImageList,
|
|
AlbumList,
|
|
FileList,
|
|
ImageItem,
|
|
LocationTag,
|
|
ImageName,
|
|
FileImage,
|
|
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,
|
|
[0x6D, 0x68, 0x6C, 0x61] => ChunkType::AlbumList,
|
|
[0x6D, 0x68, 0x6C, 0x66] => ChunkType::FileList,
|
|
[0x6D, 0x68, 0x69, 0x66] => ChunkType::FileImage,
|
|
_ => 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],
|
|
ChunkType::AlbumList => [0x6D, 0x68, 0x6C, 0x61],
|
|
ChunkType::FileList => [0x6D, 0x68, 0x6C, 0x66],
|
|
ChunkType::FileImage => [0x6D, 0x68, 0x69, 0x66],
|
|
}
|
|
}
|
|
}
|
|
|
|
#[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 {
|
|
pub 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 ImageFile {
|
|
unknown1: u32,
|
|
correlation_id: u32,
|
|
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,
|
|
}
|
|
} |