From a55f2eb130ca1f458c6586664c49586d3acb8df1 Mon Sep 17 00:00:00 2001 From: Connor Slade Date: Mon, 2 Sep 2024 22:08:45 -0400 Subject: [PATCH] Add little endian serde functions --- common/src/serde/deserializer.rs | 65 ++++++- common/src/serde/serializer.rs | 24 +-- goo_format/src/default.rs | 4 +- goo_format/src/file.rs | 10 +- goo_format/src/{header_info.rs => header.rs} | 184 +++++++++--------- goo_format/src/layer_content.rs | 72 +++---- goo_format/src/lib.rs | 4 +- goo_format/src/preview_image.rs | 4 +- mslicer/src/app/mod.rs | 4 +- remote_send/src/mqtt/misc.rs | 4 +- remote_send/src/mqtt/packets/connect.rs | 2 +- remote_send/src/mqtt/packets/publish.rs | 4 +- remote_send/src/mqtt/packets/publish_ack.rs | 4 +- remote_send/src/mqtt/packets/subscribe.rs | 2 +- remote_send/src/mqtt/packets/subscribe_ack.rs | 2 +- 15 files changed, 224 insertions(+), 165 deletions(-) rename goo_format/src/{header_info.rs => header.rs} (76%) diff --git a/common/src/serde/deserializer.rs b/common/src/serde/deserializer.rs index a28c9e3..395e78a 100644 --- a/common/src/serde/deserializer.rs +++ b/common/src/serde/deserializer.rs @@ -1,3 +1,5 @@ +use std::mem; + use super::SizedString; pub struct Deserializer<'a> { @@ -18,6 +20,18 @@ impl<'a> Deserializer<'a> { self.offset } + pub fn advance_by(&mut self, amount: usize) { + self.offset += amount; + } + + pub fn advance(&mut self) { + self.advance_by(mem::size_of::()); + } + + pub fn jump_to(&mut self, pos: usize) { + self.offset = pos; + } + pub fn read_bool(&mut self) -> bool { self.read_u8() != 0 } @@ -28,13 +42,19 @@ impl<'a> Deserializer<'a> { value } - pub fn read_u16(&mut self) -> u16 { + pub fn read_u16_be(&mut self) -> u16 { let value = u16::from_be_bytes([self.buffer[self.offset], self.buffer[self.offset + 1]]); self.offset += 2; value } - pub fn read_u32(&mut self) -> u32 { + pub fn read_u16_le(&mut self) -> u16 { + let value = u16::from_le_bytes([self.buffer[self.offset], self.buffer[self.offset + 1]]); + self.offset += 2; + value + } + + pub fn read_u32_be(&mut self) -> u32 { let value = u32::from_be_bytes([ self.buffer[self.offset], self.buffer[self.offset + 1], @@ -45,7 +65,18 @@ impl<'a> Deserializer<'a> { value } - pub fn read_u64(&mut self) -> u64 { + pub fn read_u32_le(&mut self) -> u32 { + let value = u32::from_le_bytes([ + self.buffer[self.offset], + self.buffer[self.offset + 1], + self.buffer[self.offset + 2], + self.buffer[self.offset + 3], + ]); + self.offset += 4; + value + } + + pub fn read_u64_be(&mut self) -> u64 { let value = u64::from_be_bytes([ self.buffer[self.offset], self.buffer[self.offset + 1], @@ -60,7 +91,22 @@ impl<'a> Deserializer<'a> { value } - pub fn read_f32(&mut self) -> f32 { + pub fn read_u64_le(&mut self) -> u64 { + let value = u64::from_le_bytes([ + self.buffer[self.offset], + self.buffer[self.offset + 1], + self.buffer[self.offset + 2], + self.buffer[self.offset + 3], + self.buffer[self.offset + 4], + self.buffer[self.offset + 5], + self.buffer[self.offset + 6], + self.buffer[self.offset + 7], + ]); + self.offset += 8; + value + } + + pub fn read_f32_be(&mut self) -> f32 { let value = f32::from_be_bytes([ self.buffer[self.offset], self.buffer[self.offset + 1], @@ -71,6 +117,17 @@ impl<'a> Deserializer<'a> { value } + pub fn read_f32_le(&mut self) -> f32 { + let value = f32::from_le_bytes([ + self.buffer[self.offset], + self.buffer[self.offset + 1], + self.buffer[self.offset + 2], + self.buffer[self.offset + 3], + ]); + self.offset += 4; + value + } + pub fn read_bytes(&mut self, length: usize) -> &'a [u8] { let value = &self.buffer[self.offset..self.offset + length]; self.offset += length; diff --git a/common/src/serde/serializer.rs b/common/src/serde/serializer.rs index 4dfc2d2..c34722a 100644 --- a/common/src/serde/serializer.rs +++ b/common/src/serde/serializer.rs @@ -3,10 +3,10 @@ use super::SizedString; pub trait Serializer { fn write_bool(&mut self, data: bool); fn write_u8(&mut self, data: u8); - fn write_u16(&mut self, data: u16); - fn write_u32(&mut self, data: u32); - fn write_u64(&mut self, data: u64); - fn write_f32(&mut self, data: f32); + fn write_u16_be(&mut self, data: u16); + fn write_u32_be(&mut self, data: u32); + fn write_u64_be(&mut self, data: u64); + fn write_f32_be(&mut self, data: f32); fn write_bytes(&mut self, data: &[u8]); fn write_sized_string(&mut self, data: &SizedString); } @@ -46,22 +46,22 @@ impl Serializer for SizedSerializer<'_> { self.offset += 1; } - fn write_u16(&mut self, data: u16) { + fn write_u16_be(&mut self, data: u16) { self.buffer[self.offset..self.offset + 2].copy_from_slice(&data.to_be_bytes()); self.offset += 2; } - fn write_u32(&mut self, data: u32) { + fn write_u32_be(&mut self, data: u32) { self.buffer[self.offset..self.offset + 4].copy_from_slice(&data.to_be_bytes()); self.offset += 4; } - fn write_u64(&mut self, data: u64) { + fn write_u64_be(&mut self, data: u64) { self.buffer[self.offset..self.offset + 8].copy_from_slice(&data.to_be_bytes()); self.offset += 8; } - fn write_f32(&mut self, data: f32) { + fn write_f32_be(&mut self, data: f32) { self.buffer[self.offset..self.offset + 4].copy_from_slice(&data.to_be_bytes()); self.offset += 4; } @@ -87,19 +87,19 @@ impl Serializer for DynamicSerializer { self.buffer.push(data); } - fn write_u16(&mut self, data: u16) { + fn write_u16_be(&mut self, data: u16) { self.buffer.extend_from_slice(&data.to_be_bytes()); } - fn write_u32(&mut self, data: u32) { + fn write_u32_be(&mut self, data: u32) { self.buffer.extend_from_slice(&data.to_be_bytes()); } - fn write_u64(&mut self, data: u64) { + fn write_u64_be(&mut self, data: u64) { self.buffer.extend_from_slice(&data.to_be_bytes()); } - fn write_f32(&mut self, data: f32) { + fn write_f32_be(&mut self, data: f32) { self.buffer.extend_from_slice(&data.to_be_bytes()); } diff --git a/goo_format/src/default.rs b/goo_format/src/default.rs index a606bb4..4166989 100644 --- a/goo_format/src/default.rs +++ b/goo_format/src/default.rs @@ -1,8 +1,8 @@ use common::serde::SizedString; -use crate::{header_info::ExposureDelayMode, HeaderInfo, LayerContent, PreviewImage}; +use crate::{header::ExposureDelayMode, Header, LayerContent, PreviewImage}; -impl Default for HeaderInfo { +impl Default for Header { fn default() -> Self { Self { version: SizedString::new(b"V3.0"), diff --git a/goo_format/src/file.rs b/goo_format/src/file.rs index 3251d21..453161e 100644 --- a/goo_format/src/file.rs +++ b/goo_format/src/file.rs @@ -6,15 +6,15 @@ use common::{ serde::{Deserializer, Serializer, SizedString}, }; -use crate::{HeaderInfo, LayerContent, ENDING_STRING}; +use crate::{Header, LayerContent, ENDING_STRING}; pub struct File { - pub header: HeaderInfo, + pub header: Header, pub layers: Vec, } impl File { - pub fn new(header: HeaderInfo, layers: Vec) -> Self { + pub fn new(header: Header, layers: Vec) -> Self { Self { header, layers } } @@ -37,7 +37,7 @@ impl File { + slice_config.first_layers as f32 * bottom_layer_time; Self::new( - HeaderInfo { + Header { x_resolution: slice_config.platform_resolution.x as u16, y_resolution: slice_config.platform_resolution.y as u16, x_size: slice_config.platform_size.x, @@ -87,7 +87,7 @@ impl File { pub fn deserialize(buf: &[u8]) -> Result { let mut des = Deserializer::new(buf); - let header = HeaderInfo::deserialize(&mut des)?; + let header = Header::deserialize(&mut des)?; let mut layers = Vec::with_capacity(header.layer_count as usize); for _ in 0..header.layer_count { diff --git a/goo_format/src/header_info.rs b/goo_format/src/header.rs similarity index 76% rename from goo_format/src/header_info.rs rename to goo_format/src/header.rs index d13a647..f427aa6 100644 --- a/goo_format/src/header_info.rs +++ b/goo_format/src/header.rs @@ -7,7 +7,7 @@ use common::serde::{Deserializer, Serializer, SizedString}; use crate::{PreviewImage, DELIMITER, MAGIC_TAG}; /// The header section of a `.goo` file. -pub struct HeaderInfo { +pub struct Header { /// Format version, should be "V3.0". pub version: SizedString<4>, /// Name of software that generated the file. @@ -142,12 +142,12 @@ pub enum ExposureDelayMode { StaticTime, } -impl HeaderInfo { +impl Header { pub const SIZE: usize = 0x2FB95; } // this is fine -impl HeaderInfo { +impl Header { pub fn serialize(&self, ser: &mut T) { ser.write_sized_string(&self.version); ser.write_bytes(MAGIC_TAG); @@ -157,60 +157,60 @@ impl HeaderInfo { ser.write_sized_string(&self.printer_name); ser.write_sized_string(&self.printer_type); ser.write_sized_string(&self.profile_name); - ser.write_u16(self.anti_aliasing_level); - ser.write_u16(self.grey_level); - ser.write_u16(self.blur_level); + ser.write_u16_be(self.anti_aliasing_level); + ser.write_u16_be(self.grey_level); + ser.write_u16_be(self.blur_level); self.small_preview.serializes(ser); ser.write_bytes(DELIMITER); self.big_preview.serializes(ser); ser.write_bytes(DELIMITER); - ser.write_u32(self.layer_count); - ser.write_u16(self.x_resolution); - ser.write_u16(self.y_resolution); + ser.write_u32_be(self.layer_count); + ser.write_u16_be(self.x_resolution); + ser.write_u16_be(self.y_resolution); ser.write_bool(self.x_mirror); ser.write_bool(self.y_mirror); - ser.write_f32(self.x_size); - ser.write_f32(self.y_size); - ser.write_f32(self.z_size); - ser.write_f32(self.layer_thickness); - ser.write_f32(self.exposure_time); + ser.write_f32_be(self.x_size); + ser.write_f32_be(self.y_size); + ser.write_f32_be(self.z_size); + ser.write_f32_be(self.layer_thickness); + ser.write_f32_be(self.exposure_time); ser.write_u8(self.exposure_delay_mode as u8); - ser.write_f32(self.turn_off_time); - ser.write_f32(self.bottom_before_lift_time); - ser.write_f32(self.bottom_after_lift_time); - ser.write_f32(self.bottom_after_retract_time); - ser.write_f32(self.before_lift_time); - ser.write_f32(self.after_lift_time); - ser.write_f32(self.after_retract_time); - ser.write_f32(self.bottom_exposure_time); - ser.write_u32(self.bottom_layers); - ser.write_f32(self.bottom_lift_distance); - ser.write_f32(self.bottom_lift_speed); - ser.write_f32(self.lift_distance); - ser.write_f32(self.lift_speed); - ser.write_f32(self.bottom_retract_distance); - ser.write_f32(self.bottom_retract_speed); - ser.write_f32(self.retract_distance); - ser.write_f32(self.retract_speed); - ser.write_f32(self.bottom_second_lift_distance); - ser.write_f32(self.bottom_second_lift_speed); - ser.write_f32(self.second_lift_distance); - ser.write_f32(self.second_lift_speed); - ser.write_f32(self.bottom_second_retract_distance); - ser.write_f32(self.bottom_second_retract_speed); - ser.write_f32(self.second_retract_distance); - ser.write_f32(self.second_retract_speed); - ser.write_u16(self.bottom_light_pwm as u16); - ser.write_u16(self.light_pwm as u16); + ser.write_f32_be(self.turn_off_time); + ser.write_f32_be(self.bottom_before_lift_time); + ser.write_f32_be(self.bottom_after_lift_time); + ser.write_f32_be(self.bottom_after_retract_time); + ser.write_f32_be(self.before_lift_time); + ser.write_f32_be(self.after_lift_time); + ser.write_f32_be(self.after_retract_time); + ser.write_f32_be(self.bottom_exposure_time); + ser.write_u32_be(self.bottom_layers); + ser.write_f32_be(self.bottom_lift_distance); + ser.write_f32_be(self.bottom_lift_speed); + ser.write_f32_be(self.lift_distance); + ser.write_f32_be(self.lift_speed); + ser.write_f32_be(self.bottom_retract_distance); + ser.write_f32_be(self.bottom_retract_speed); + ser.write_f32_be(self.retract_distance); + ser.write_f32_be(self.retract_speed); + ser.write_f32_be(self.bottom_second_lift_distance); + ser.write_f32_be(self.bottom_second_lift_speed); + ser.write_f32_be(self.second_lift_distance); + ser.write_f32_be(self.second_lift_speed); + ser.write_f32_be(self.bottom_second_retract_distance); + ser.write_f32_be(self.bottom_second_retract_speed); + ser.write_f32_be(self.second_retract_distance); + ser.write_f32_be(self.second_retract_speed); + ser.write_u16_be(self.bottom_light_pwm as u16); + ser.write_u16_be(self.light_pwm as u16); ser.write_bool(self.per_layer_settings); - ser.write_u32(self.printing_time); - ser.write_f32(self.total_volume); - ser.write_f32(self.total_weight); - ser.write_f32(self.total_price); + ser.write_u32_be(self.printing_time); + ser.write_f32_be(self.total_volume); + ser.write_f32_be(self.total_weight); + ser.write_f32_be(self.total_price); ser.write_sized_string(&self.price_unit); - ser.write_u32(Self::SIZE as u32); + ser.write_u32_be(Self::SIZE as u32); ser.write_bool(self.grey_scale_level); - ser.write_u16(self.transition_layers); + ser.write_u16_be(self.transition_layers); } pub fn deserialize(des: &mut Deserializer) -> Result { @@ -222,60 +222,60 @@ impl HeaderInfo { let printer_name = des.read_sized_string(); let printer_type = des.read_sized_string(); let profile_name = des.read_sized_string(); - let anti_aliasing_level = des.read_u16(); - let grey_level = des.read_u16(); - let blur_level = des.read_u16(); + let anti_aliasing_level = des.read_u16_be(); + let grey_level = des.read_u16_be(); + let blur_level = des.read_u16_be(); let small_preview = PreviewImage::deserializes(des); ensure!(des.read_bytes(2) == [0xd, 0xa]); let big_preview = PreviewImage::deserializes(des); ensure!(des.read_bytes(2) == [0xd, 0xa]); - let layer_count = des.read_u32(); - let x_resolution = des.read_u16(); - let y_resolution = des.read_u16(); + let layer_count = des.read_u32_be(); + let x_resolution = des.read_u16_be(); + let y_resolution = des.read_u16_be(); let x_mirror = des.read_bool(); let y_mirror = des.read_bool(); - let x_size = des.read_f32(); - let y_size = des.read_f32(); - let z_size = des.read_f32(); - let layer_thickness = des.read_f32(); - let exposure_time = des.read_f32(); + let x_size = des.read_f32_be(); + let y_size = des.read_f32_be(); + let z_size = des.read_f32_be(); + let layer_thickness = des.read_f32_be(); + let exposure_time = des.read_f32_be(); let exposure_delay_mode = ExposureDelayMode::from_bool(des.read_bool()); - let turn_off_time = des.read_f32(); - let bottom_before_lift_time = des.read_f32(); - let bottom_after_lift_time = des.read_f32(); - let bottom_after_retract_time = des.read_f32(); - let before_lift_time = des.read_f32(); - let after_lift_time = des.read_f32(); - let after_retract_time = des.read_f32(); - let bottom_exposure_time = des.read_f32(); - let bottom_layers = des.read_u32(); - let bottom_lift_distance = des.read_f32(); - let bottom_lift_speed = des.read_f32(); - let lift_distance = des.read_f32(); - let lift_speed = des.read_f32(); - let bottom_retract_distance = des.read_f32(); - let bottom_retract_speed = des.read_f32(); - let retract_distance = des.read_f32(); - let retract_speed = des.read_f32(); - let bottom_second_lift_distance = des.read_f32(); - let bottom_second_lift_speed = des.read_f32(); - let second_lift_distance = des.read_f32(); - let second_lift_speed = des.read_f32(); - let bottom_second_retract_distance = des.read_f32(); - let bottom_second_retract_speed = des.read_f32(); - let second_retract_distance = des.read_f32(); - let second_retract_speed = des.read_f32(); - let bottom_light_pwm = des.read_u16().min(255) as u8; - let light_pwm = des.read_u16().min(255) as u8; + let turn_off_time = des.read_f32_be(); + let bottom_before_lift_time = des.read_f32_be(); + let bottom_after_lift_time = des.read_f32_be(); + let bottom_after_retract_time = des.read_f32_be(); + let before_lift_time = des.read_f32_be(); + let after_lift_time = des.read_f32_be(); + let after_retract_time = des.read_f32_be(); + let bottom_exposure_time = des.read_f32_be(); + let bottom_layers = des.read_u32_be(); + let bottom_lift_distance = des.read_f32_be(); + let bottom_lift_speed = des.read_f32_be(); + let lift_distance = des.read_f32_be(); + let lift_speed = des.read_f32_be(); + let bottom_retract_distance = des.read_f32_be(); + let bottom_retract_speed = des.read_f32_be(); + let retract_distance = des.read_f32_be(); + let retract_speed = des.read_f32_be(); + let bottom_second_lift_distance = des.read_f32_be(); + let bottom_second_lift_speed = des.read_f32_be(); + let second_lift_distance = des.read_f32_be(); + let second_lift_speed = des.read_f32_be(); + let bottom_second_retract_distance = des.read_f32_be(); + let bottom_second_retract_speed = des.read_f32_be(); + let second_retract_distance = des.read_f32_be(); + let second_retract_speed = des.read_f32_be(); + let bottom_light_pwm = des.read_u16_be().min(255) as u8; + let light_pwm = des.read_u16_be().min(255) as u8; let advance_mode = des.read_bool(); - let printing_time = des.read_u32(); - let total_volume = des.read_f32(); - let total_weight = des.read_f32(); - let total_price = des.read_f32(); + let printing_time = des.read_u32_be(); + let total_volume = des.read_f32_be(); + let total_weight = des.read_f32_be(); + let total_price = des.read_f32_be(); let price_unit = des.read_sized_string(); - ensure!(des.read_u32() == Self::SIZE as u32); + ensure!(des.read_u32_be() == Self::SIZE as u32); let grey_scale_level = des.read_bool(); - let transition_layers = des.read_u16(); + let transition_layers = des.read_u16_be(); Ok(Self { version, @@ -349,7 +349,7 @@ impl ExposureDelayMode { } } -impl Debug for HeaderInfo { +impl Debug for Header { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_struct("HeaderInfo") .field("version", &self.version) diff --git a/goo_format/src/layer_content.rs b/goo_format/src/layer_content.rs index 3132052..94a37f1 100644 --- a/goo_format/src/layer_content.rs +++ b/goo_format/src/layer_content.rs @@ -48,25 +48,25 @@ pub struct LayerContent { impl LayerContent { pub fn serialize(&self, ser: &mut T) { - ser.write_u16(self.pause as u16); - ser.write_f32(self.pause_position_z); - ser.write_f32(self.layer_position_z); - ser.write_f32(self.layer_exposure_time); - ser.write_f32(self.layer_off_time); - ser.write_f32(self.before_lift_time); - ser.write_f32(self.after_lift_time); - ser.write_f32(self.after_retract_time); - ser.write_f32(self.lift_distance); - ser.write_f32(self.lift_speed); - ser.write_f32(self.second_lift_distance); - ser.write_f32(self.second_lift_speed); - ser.write_f32(self.retract_distance); - ser.write_f32(self.retract_speed); - ser.write_f32(self.second_retract_distance); - ser.write_f32(self.second_retract_speed); - ser.write_u16(self.light_pwm as u16); + ser.write_u16_be(self.pause as u16); + ser.write_f32_be(self.pause_position_z); + ser.write_f32_be(self.layer_position_z); + ser.write_f32_be(self.layer_exposure_time); + ser.write_f32_be(self.layer_off_time); + ser.write_f32_be(self.before_lift_time); + ser.write_f32_be(self.after_lift_time); + ser.write_f32_be(self.after_retract_time); + ser.write_f32_be(self.lift_distance); + ser.write_f32_be(self.lift_speed); + ser.write_f32_be(self.second_lift_distance); + ser.write_f32_be(self.second_lift_speed); + ser.write_f32_be(self.retract_distance); + ser.write_f32_be(self.retract_speed); + ser.write_f32_be(self.second_retract_distance); + ser.write_f32_be(self.second_retract_speed); + ser.write_u16_be(self.light_pwm as u16); ser.write_bytes(DELIMITER); - ser.write_u32(self.data.len() as u32 + 2); + ser.write_u32_be(self.data.len() as u32 + 2); ser.write_bytes(&[0x55]); ser.write_bytes(&self.data); ser.write_u8(calculate_checksum(&self.data)); @@ -74,25 +74,25 @@ impl LayerContent { } pub fn deserialize(des: &mut Deserializer) -> Result { - let pause_flag = des.read_u16(); - let pause_position_z = des.read_f32(); - let layer_position_z = des.read_f32(); - let layer_exposure_time = des.read_f32(); - let layer_off_time = des.read_f32(); - let before_lift_time = des.read_f32(); - let after_lift_time = des.read_f32(); - let after_retract_time = des.read_f32(); - let lift_distance = des.read_f32(); - let lift_speed = des.read_f32(); - let second_lift_distance = des.read_f32(); - let second_lift_speed = des.read_f32(); - let retract_distance = des.read_f32(); - let retract_speed = des.read_f32(); - let second_retract_distance = des.read_f32(); - let second_retract_speed = des.read_f32(); - let light_pwm = des.read_u16().min(255) as u8; + let pause_flag = des.read_u16_be(); + let pause_position_z = des.read_f32_be(); + let layer_position_z = des.read_f32_be(); + let layer_exposure_time = des.read_f32_be(); + let layer_off_time = des.read_f32_be(); + let before_lift_time = des.read_f32_be(); + let after_lift_time = des.read_f32_be(); + let after_retract_time = des.read_f32_be(); + let lift_distance = des.read_f32_be(); + let lift_speed = des.read_f32_be(); + let second_lift_distance = des.read_f32_be(); + let second_lift_speed = des.read_f32_be(); + let retract_distance = des.read_f32_be(); + let retract_speed = des.read_f32_be(); + let second_retract_distance = des.read_f32_be(); + let second_retract_speed = des.read_f32_be(); + let light_pwm = des.read_u16_be().min(255) as u8; ensure!(des.read_bytes(2) == DELIMITER); - let data_len = des.read_u32() as usize - 2; + let data_len = des.read_u32_be() as usize - 2; ensure!(des.read_u8() == 0x55); let data = des.read_bytes(data_len); let checksum = des.read_u8(); diff --git a/goo_format/src/lib.rs b/goo_format/src/lib.rs index 7f9d419..da4d825 100644 --- a/goo_format/src/lib.rs +++ b/goo_format/src/lib.rs @@ -3,13 +3,13 @@ mod default; mod encoded_layer; mod file; -mod header_info; +mod header; mod layer_content; mod preview_image; pub use encoded_layer::{LayerDecoder, LayerEncoder}; pub use file::File; -pub use header_info::HeaderInfo; +pub use header::Header; pub use layer_content::LayerContent; pub use preview_image::PreviewImage; diff --git a/goo_format/src/preview_image.rs b/goo_format/src/preview_image.rs index f8d61b0..9941943 100644 --- a/goo_format/src/preview_image.rs +++ b/goo_format/src/preview_image.rs @@ -48,7 +48,7 @@ impl PreviewImage { pub fn serializes(&self, serializer: &mut T) { for pixel in self.data.iter() { - serializer.write_u16(*pixel); + serializer.write_u16_be(*pixel); } } @@ -56,7 +56,7 @@ impl PreviewImage { let mut out = Self::empty(); for pixel in out.data.iter_mut() { - *pixel = deserializer.read_u16(); + *pixel = deserializer.read_u16_be(); } out diff --git a/mslicer/src/app/mod.rs b/mslicer/src/app/mod.rs index f5c2c77..04ddd30 100644 --- a/mslicer/src/app/mod.rs +++ b/mslicer/src/app/mod.rs @@ -20,7 +20,9 @@ use tracing::{info, warn}; use crate::{ plugins::{ - anti_alias, elephant_foot_fixer::{self}, PluginManager + anti_alias, + elephant_foot_fixer::{self}, + PluginManager, }, render::{camera::Camera, rendered_mesh::RenderedMesh}, ui::{ diff --git a/remote_send/src/mqtt/misc.rs b/remote_send/src/mqtt/misc.rs index 706376c..ccce556 100644 --- a/remote_send/src/mqtt/misc.rs +++ b/remote_send/src/mqtt/misc.rs @@ -15,7 +15,7 @@ pub trait MqttSerializer { impl<'a> MqttDeserialize<'a> for Deserializer<'a> { fn read_string(&mut self) -> Cow<'a, str> { - let len = self.read_u16(); + let len = self.read_u16_be(); let buf = self.read_bytes(len as usize); String::from_utf8_lossy(buf) } @@ -28,7 +28,7 @@ where fn write_string(&mut self, data: &str) { assert!(data.len() <= u16::MAX as usize); let len = data.len() as u16; - self.write_u16(len); + self.write_u16_be(len); self.write_bytes(data.as_bytes()); } } diff --git a/remote_send/src/mqtt/packets/connect.rs b/remote_send/src/mqtt/packets/connect.rs index 838a5f2..3e22f27 100644 --- a/remote_send/src/mqtt/packets/connect.rs +++ b/remote_send/src/mqtt/packets/connect.rs @@ -43,7 +43,7 @@ impl ConnectPacket { let protocol_name = des.read_string().into_owned(); let protocol_level = des.read_u8(); let connect_flags = ConnectFlags::from_bits(des.read_u8()).unwrap(); - let keep_alive = des.read_u16(); + let keep_alive = des.read_u16_be(); let client_id = des.read_string().into_owned(); let will_topic = connect_flags diff --git a/remote_send/src/mqtt/packets/publish.rs b/remote_send/src/mqtt/packets/publish.rs index e4b290d..3d822c6 100644 --- a/remote_send/src/mqtt/packets/publish.rs +++ b/remote_send/src/mqtt/packets/publish.rs @@ -36,7 +36,7 @@ impl PublishPacket { let topic = des.read_string().into_owned(); let packet_id = (flags.contains(PublishFlags::QOS1) || flags.contains(PublishFlags::QOS2)) - .then(|| des.read_u16()); + .then(|| des.read_u16_be()); let data = des .read_bytes(packet.remaining_length as usize - des.pos()) .to_vec(); @@ -53,7 +53,7 @@ impl PublishPacket { let mut ser = DynamicSerializer::new(); ser.write_string(&self.topic); if self.flags.contains(PublishFlags::QOS1) || self.flags.contains(PublishFlags::QOS2) { - ser.write_u16(self.packet_id.unwrap()); + ser.write_u16_be(self.packet_id.unwrap()); } ser.write_bytes(&self.data); diff --git a/remote_send/src/mqtt/packets/publish_ack.rs b/remote_send/src/mqtt/packets/publish_ack.rs index 3d2da84..ed0eb29 100644 --- a/remote_send/src/mqtt/packets/publish_ack.rs +++ b/remote_send/src/mqtt/packets/publish_ack.rs @@ -13,7 +13,7 @@ impl PublishAckPacket { pub fn to_packet(&self) -> Packet { let mut ser = DynamicSerializer::new(); - ser.write_u16(self.packet_id); + ser.write_u16_be(self.packet_id); let data = ser.into_inner(); Packet { @@ -28,7 +28,7 @@ impl PublishAckPacket { assert_eq!(packet.packet_type, Self::PACKET_TYPE); let mut des = Deserializer::new(&packet.remaining_bytes); - let packet_id = des.read_u16(); + let packet_id = des.read_u16_be(); Ok(Self { packet_id }) } diff --git a/remote_send/src/mqtt/packets/subscribe.rs b/remote_send/src/mqtt/packets/subscribe.rs index a67f0e3..eedeaea 100644 --- a/remote_send/src/mqtt/packets/subscribe.rs +++ b/remote_send/src/mqtt/packets/subscribe.rs @@ -17,7 +17,7 @@ impl SubscribePacket { pub fn from_packet(packet: &Packet) -> Result { let mut des = Deserializer::new(&packet.remaining_bytes); - let packet_id = des.read_u16(); + let packet_id = des.read_u16_be(); let mut filters = Vec::new(); while !des.is_empty() { let topic = des.read_string().into_owned(); diff --git a/remote_send/src/mqtt/packets/subscribe_ack.rs b/remote_send/src/mqtt/packets/subscribe_ack.rs index c5f1899..a814aa2 100644 --- a/remote_send/src/mqtt/packets/subscribe_ack.rs +++ b/remote_send/src/mqtt/packets/subscribe_ack.rs @@ -20,7 +20,7 @@ impl SubscribeAckPacket { pub fn to_packet(&self) -> Packet { let mut ser = DynamicSerializer::new(); - ser.write_u16(self.packet_id); + ser.write_u16_be(self.packet_id); for return_code in &self.return_codes { match return_code { SubscribeReturnCode::Failure => ser.write_u8(0x80),