composer_utils.rs (3699B) - raw

      1 use std::{io::Error, string::FromUtf8Error};
      2 
      3 #[derive(Debug, Clone)]
      4 pub struct ModuleTag {
      5     tag_type: u8,
      6     buffer: Vec<u8>,
      7 }
      8 
      9 impl ModuleTag {
     10     pub fn new(module_type: u8, buffer: Vec<u8>) -> ModuleTag {
     11         ModuleTag {
     12             tag_type: module_type,
     13             buffer,
     14         }
     15     }
     16 
     17     pub fn to_string(&self) -> Result<String, FromUtf8Error> {
     18         Ok(String::from_utf8(self.buffer.clone())?)
     19     }
     20 
     21     pub fn get_tag_type(&self) -> u8 {
     22         self.tag_type
     23     }
     24 
     25     pub fn get_size(&self) -> usize {
     26         self.buffer.len()
     27     }
     28 
     29     pub fn get_buffer(&self) -> &Vec<u8> {
     30         &self.buffer
     31     }
     32 
     33     pub fn set_buffer(&mut self, buffer: Vec<u8>) {
     34         self.buffer = buffer;
     35     }
     36 }
     37 
     38 #[derive(Debug, Clone)]
     39 pub struct ComposerModule {
     40     tags: Vec<(ModuleTag, ModuleTag)>, // file name => file content
     41 }
     42 
     43 impl ComposerModule {
     44     pub fn parse(buffer: Vec<u8>) -> Result<ComposerModule, Error> {
     45         let mut offset = 0;
     46         let magic = u32::from_be_bytes([buffer[offset], buffer[offset + 1], buffer[offset + 2], buffer[offset + 3]]);
     47 
     48         offset += 4;
     49 
     50         if magic != 0x33c60001 {
     51             return Err(Error::new(std::io::ErrorKind::InvalidData, "Invalid magic"));
     52         }
     53 
     54         // skip content length
     55         offset += 4;
     56 
     57         let mut tags = Vec::new();
     58 
     59         loop {
     60             if offset >= buffer.len() {
     61                 break;
     62             }
     63 
     64             fn read_u24(buffer: &Vec<u8>, offset: &mut usize) -> Result<u32, Error> {
     65                 let b1 = buffer[*offset] as u32;
     66                 let b2 = buffer[*offset + 1] as u32;
     67                 let b3 = buffer[*offset + 2] as u32;
     68                 *offset += 3;
     69                 Ok(b1 | (b2 << 8) | (b3 << 16))
     70             }
     71 
     72             let tag_size = read_u24(&buffer, &mut offset)?;
     73             let tag_type = buffer[offset];
     74             offset += 1;
     75             let tag_buffer = buffer[offset..offset + tag_size as usize].to_vec();
     76             offset += tag_size as usize;
     77 
     78             let padding = 4 - (tag_size % 4);
     79 
     80             if padding != 4 {
     81                 offset += padding as usize;
     82             }
     83 
     84             tags.push(ModuleTag::new(tag_type, tag_buffer));
     85         }
     86 
     87         let tags = tags.chunks(2).map(|chunk| {
     88             (chunk[0].clone(), chunk[1].clone())
     89         }).collect();
     90 
     91         Ok(ComposerModule {
     92             tags,
     93         })
     94     }
     95 
     96     pub fn to_bytes(&self) -> Vec<u8> {
     97         let mut tag_buffer = Vec::new();
     98 
     99         fn write_u24(buffer: &mut Vec<u8>, value: u32) {
    100             buffer.push((value & 0xff) as u8);
    101             buffer.push(((value >> 8) & 0xff) as u8);
    102             buffer.push(((value >> 16) & 0xff) as u8);
    103         }
    104 
    105         fn write_tag(buffer: &mut Vec<u8>, tag: ModuleTag) {
    106             write_u24(buffer, tag.get_size() as u32);
    107             buffer.push(tag.get_tag_type());
    108             buffer.extend(tag.get_buffer());
    109 
    110             let padding = 4 - (tag.get_size() % 4);
    111 
    112             if padding != 4 {
    113                 for _ in 0..padding {
    114                     buffer.push(0);
    115                 }
    116             }
    117         }
    118 
    119         for (tag1, tag2) in &self.tags {
    120             write_tag(&mut tag_buffer, tag1.clone());
    121             write_tag(&mut tag_buffer, tag2.clone());
    122         }
    123 
    124         let mut buffer = Vec::new();
    125 
    126         buffer.extend_from_slice(&[0x33, 0xc6, 0, 1]);
    127         buffer.extend_from_slice(&(tag_buffer.len() as u32).to_le_bytes());
    128         buffer.extend(tag_buffer);
    129 
    130         buffer
    131     }
    132 
    133     pub fn get_tags(&self) -> Vec<(ModuleTag, ModuleTag)> {
    134         self.tags.clone()
    135     }
    136 
    137     pub fn set_tags(&mut self, tags: Vec<(ModuleTag, ModuleTag)>) {
    138         self.tags = tags;
    139     }
    140 }
    141