modified: outdb

modified:   src/deserializer.rs
	modified:   src/objects.rs
	modified:   src/serializer.rs

src/deserializer.rs

@@ -186,7 +186,7 @@ pub fn parse_bytes(data: &[u8]) -> XDatabase {
                             playlists.push(XPlaylist {header: header, data: playlist,args: Vec::new(), elems: Vec::new()});
                         }
                     },
-                    _ => { u = 1; }
+                    _ => { u = 1; info!("Unknown stuff happened"); }
                 }
                 i += u;
                 chunk_header = None;

src/objects.rs

@@ -66,7 +66,10 @@ pub struct Database {
     unknown1: [u8; 32],
     language: u16,
     persistent_id: u64,
-    hash: [u8; 20]
+    hash: [u8; 20],
+    unk: [u8; 30],
+    unk1: [u8; 32],
+    unk2: [u8; 20]
 }
 
 #[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
@@ -154,7 +157,14 @@ pub struct TrackItem {
     unk39_hash: [u8; 20],
     unk40: [u8; 18],
     album_id: u16,
-    mhii_link: u32
+    mhii_link: u32,
+    unk: [u8; 32],
+    unk1: [u8; 32],
+    unk2: [u8; 32],
+    unk3: [u8; 32],
+    unk4: [u8; 32],
+    unk5: [u8; 32],
+    unk6: [u8; 32]
 }
 
 #[derive(Serialize, Deserialize, PartialEq, Debug)]
@@ -210,7 +220,9 @@ pub struct Playlist {
     unk3: u32,
     string_mhod_count: u16,
     podcast_flag: u16,
-    list_sort_order: u32
+    list_sort_order: u32,
+    unk1: [u8; 22],
+    unk2: [u8; 22],
 }
 
 #[derive(Serialize, Deserialize, PartialEq, Debug)]

src/serializer.rs

@@ -10,25 +10,7 @@ fn string_to_ipod16(str: &String) -> Vec<u8> {
 fn x_args_to_bytes(args: &Vec<XArgument>) -> Vec<u8> {
     args.iter()
         .filter(|arg| arg.arg_type <= 15)
-        .map(|arg| {
-            let s = string_to_ipod16(&arg.val);
-            let mut b = bincode::serialize(&StringEntry {
-                entry_type: arg.arg_type,
-                unk1: 0,
-                unk2: 0,
-                position: 1,
-                length: s.len() as u32,
-                unknown: 0,
-                unk4: 0
-            }).unwrap();
-            let h = bincode::serialize(&ChunkHeader { 
-                chunk_type: ChunkType::StringTypes.into(), 
-                end_of_chunk: 0x18, 
-                children_count: 16 + 0x18 + s.len() as u32
-            }).unwrap();
-            b = [h, b, s].concat();
-            return b;
-        })
+        .map(serialize_string_arg)
         .flatten()
         .collect()
 }
@@ -55,7 +37,7 @@ fn serialize_string_arg(xarg: &XArgument) -> Vec<u8> {
         unk2: 0,
         position: 1,
         length: s.len() as u32,
-        unknown: 0,
+        unknown: 1,
         unk4: 0
     }).unwrap();
     let h = bincode::serialize(&ChunkHeader { 
@@ -113,7 +95,6 @@ pub fn to_bytes(xdb: XDatabase) -> Vec<u8> {
     let mut bytes: Vec<u8> = Vec::new();
     for i in 0..xdb.children.len() {
         let data_set = xdb.children.get(i).unwrap();
-        info!("Serializer: {:?}", data_set);
         match &data_set.child {
             XSomeList::Playlists(playlists) => {
                 let mut pl_bytes = Vec::new();
@@ -128,14 +109,14 @@ pub fn to_bytes(xdb: XDatabase) -> Vec<u8> {
                         args.append(&mut a);
                     }
 
-                    pl_bytes.append(&mut generate_header(ChunkType::Playlist, 36,args.len()));
+                    pl_bytes.append(&mut generate_header(ChunkType::Playlist, 172,args.len()));
                     pl_bytes.append(&mut bincode::serialize(&playlist.data).unwrap());
-                    pl_bytes.append(&mut generate_zeroes(148));
+                    pl_bytes.append(&mut generate_zeroes(104));
                     pl_bytes.append(&mut args);
                 }
                 let mhlp = ChunkHeader { chunk_type: ChunkType::PlaylistList.into(), end_of_chunk: 92, children_count: playlists.len() as u32 };
                 let mut mhlp = bincode::serialize(&mhlp).unwrap();
-                bytes.append(&mut generate_header(ChunkType::DataSet, 84, mhlp.len() + pl_bytes.len() + 808));
+                bytes.append(&mut generate_header(ChunkType::DataSet, 84, mhlp.len() + pl_bytes.len() + 80)); // 728
                 bytes.append(&mut bincode::serialize(&data_set.data).unwrap());
                 bytes.append(&mut generate_zeroes(92));
                 bytes.append(&mut mhlp);
@@ -168,7 +149,7 @@ pub fn to_bytes(xdb: XDatabase) -> Vec<u8> {
                     let mut args = x_args_to_bytes(&track.args);
                     tr_bytes.append(&mut generate_header(ChunkType::TrackItem, 612,args.len()));
                     tr_bytes.append(&mut bincode::serialize(&track.data).unwrap());
-                    tr_bytes.append(&mut generate_zeroes(332));
+                    tr_bytes.append(&mut generate_zeroes(108));
                     tr_bytes.append(&mut args);
                 }
                 let mhlt = ChunkHeader { chunk_type: ChunkType::TrackList.into(), end_of_chunk: 92, children_count: tracks.len() as u32 };
@@ -186,6 +167,6 @@ pub fn to_bytes(xdb: XDatabase) -> Vec<u8> {
     let sdb_len = sdb.len();
     let h = xdb.header.unwrap();
     bytes = [sdb, generate_zeroes(h.end_of_chunk - sdb_len as u32), bytes].concat();
-    bytes = [generate_header(ChunkType::Database, (h.end_of_chunk - 12) as usize, bytes.len()), bytes].concat();
+    bytes = [generate_header(ChunkType::Database, (h.end_of_chunk - 12) as usize, bytes.len() - (h.end_of_chunk - 12) as usize), bytes].concat();
     bytes
 }