style: apply stable rustfmt to clearcodec modules

Author: glamberson

crates/ironrdp-graphics/src/clearcodec/mod.rs

@@ -7,16 +7,16 @@
 mod glyph_cache;
 mod vbar_cache;
 
-pub use self::glyph_cache::{GlyphCache, GlyphEntry, GLYPH_CACHE_SIZE};
+pub use self::glyph_cache::{GLYPH_CACHE_SIZE, GlyphCache, GlyphEntry};
 pub use self::vbar_cache::{FullVBar, ShortVBar, VBarCache};
 
 /// Glyph cache size as u16 for index arithmetic. GLYPH_CACHE_SIZE=4000 fits in u16.
 const GLYPH_CACHE_WRAP: u16 = 4_000;
 
-use ironrdp_core::{invalid_field_err, DecodeResult, ReadCursor};
+use ironrdp_core::{DecodeResult, ReadCursor, invalid_field_err};
 use ironrdp_pdu::codecs::clearcodec::{
-    decode_bands_layer, decode_residual_layer, decode_subcodec_layer, encode_residual_layer, ClearCodecBitmapStream,
-    CompositePayload, RgbRunSegment, SubcodecId, VBar, FLAG_GLYPH_INDEX,
+    ClearCodecBitmapStream, CompositePayload, FLAG_GLYPH_INDEX, RgbRunSegment, SubcodecId, VBar, decode_bands_layer,
+    decode_residual_layer, decode_subcodec_layer, encode_residual_layer,
 };
 
 /// ClearCodec decoder maintaining persistent cache state across frames.
@@ -510,10 +510,10 @@ fn bgra_to_run_segments(bgra: &[u8], pixel_count: usize) -> Vec<RgbRunSegment> {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-
     use ironrdp_pdu::codecs::clearcodec::{FLAG_CACHE_RESET, FLAG_GLYPH_HIT};
 
+    use super::*;
+
     fn make_residual_only_stream(width: u16, height: u16, blue: u8, green: u8, red: u8) -> Vec<u8> {
         let pixel_count = u32::from(width) * u32::from(height);
         let mut data = Vec::new();
@@ -568,7 +568,7 @@ mod tests {
         stream.push(FLAG_GLYPH_INDEX); // flags
         stream.push(0x00); // seq
         stream.extend_from_slice(&42u16.to_le_bytes()); // glyph_index = 42
-                                                        // Composite with 1-pixel residual (white)
+        // Composite with 1-pixel residual (white)
         let residual = [0xFF, 0xFF, 0xFF, 0x01]; // BGR white, run=1
         stream.extend_from_slice(&4u32.to_le_bytes()); // residual bytes
         stream.extend_from_slice(&0u32.to_le_bytes()); // bands bytes
@@ -614,7 +614,7 @@ mod tests {
 
         let pixels = decoder.decode(&stream, 2, 1).unwrap();
         assert_eq!(pixels.len(), 2 * 4); // 2 pixels * BGRA
-                                         // Pixel 0: red (BGR: 0x00, 0x00, 0xFF)
+        // Pixel 0: red (BGR: 0x00, 0x00, 0xFF)
         assert_eq!(&pixels[0..4], &[0x00, 0x00, 0xFF, 0xFF]);
         // Pixel 1: blue (BGR: 0xFF, 0x00, 0x00)
         assert_eq!(&pixels[4..8], &[0xFF, 0x00, 0x00, 0xFF]);

crates/ironrdp-graphics/src/clearcodec/vbar_cache.rs

@@ -181,7 +181,7 @@ mod tests {
         let full = VBarCache::reconstruct_full_vbar(&short, 4, 0xAA, 0xBB, 0xCC);
         // Height=4: 1 bg row, 2 data rows, 1 bg row
         assert_eq!(full.pixels.len(), 12); // 4 * 3
-                                           // Row 0: background
+        // Row 0: background
         assert_eq!(&full.pixels[0..3], &[0xAA, 0xBB, 0xCC]);
         // Row 1-2: pixel data
         assert_eq!(&full.pixels[3..9], &[0xFF, 0x00, 0x00, 0x00, 0xFF, 0x00]);

crates/ironrdp-pdu/src/codecs/clearcodec/bands.rs

@@ -6,7 +6,7 @@
 //! (full V-bar storage + short V-bar storage) to exploit recurring vertical
 //! column patterns typical of text glyphs.
 
-use ironrdp_core::{ensure_size, invalid_field_err, DecodeResult, ReadCursor};
+use ironrdp_core::{DecodeResult, ReadCursor, ensure_size, invalid_field_err};
 
 /// Maximum band height per the spec.
 pub const MAX_BAND_HEIGHT: u16 = 52;

crates/ironrdp-pdu/src/codecs/clearcodec/mod.rs

@@ -11,14 +11,14 @@ mod residual;
 mod rlex;
 mod subcodec;
 
-use ironrdp_core::{cast_length, ensure_size, invalid_field_err, DecodeResult, ReadCursor};
+use ironrdp_core::{DecodeResult, ReadCursor, cast_length, ensure_size, invalid_field_err};
 
 pub use self::bands::{
-    decode_bands_layer, Band, ShortVBarCacheMiss, VBar, MAX_BAND_HEIGHT, SHORT_VBAR_CACHE_SIZE, VBAR_CACHE_SIZE,
+    Band, MAX_BAND_HEIGHT, SHORT_VBAR_CACHE_SIZE, ShortVBarCacheMiss, VBAR_CACHE_SIZE, VBar, decode_bands_layer,
 };
-pub use self::residual::{decode_residual_layer, encode_residual_layer, RgbRunSegment};
-pub use self::rlex::{decode_rlex, RlexData, RlexSegment, MAX_PALETTE_COUNT};
-pub use self::subcodec::{decode_subcodec_layer, Subcodec, SubcodecId};
+pub use self::residual::{RgbRunSegment, decode_residual_layer, encode_residual_layer};
+pub use self::rlex::{MAX_PALETTE_COUNT, RlexData, RlexSegment, decode_rlex};
+pub use self::subcodec::{Subcodec, SubcodecId, decode_subcodec_layer};
 
 // --- Flag constants ---
 

crates/ironrdp-pdu/src/codecs/clearcodec/residual.rs

@@ -4,7 +4,7 @@
 //! run-length-encoded BGR pixel runs. This forms the base layer onto which
 //! bands and subcodec regions are composited.
 
-use ironrdp_core::{ensure_size, DecodeResult, ReadCursor};
+use ironrdp_core::{DecodeResult, ReadCursor, ensure_size};
 
 /// A single BGR run-length segment.
 ///

crates/ironrdp-pdu/src/codecs/clearcodec/rlex.rs

@@ -4,7 +4,7 @@
 //! It encodes each pixel as a pair: a "run" of repeated color followed
 //! by a "suite" (sequential palette walk from startIndex to stopIndex).
 
-use ironrdp_core::{ensure_size, invalid_field_err, DecodeResult, ReadCursor};
+use ironrdp_core::{DecodeResult, ReadCursor, ensure_size, invalid_field_err};
 
 /// Maximum palette size per spec.
 pub const MAX_PALETTE_COUNT: u8 = 127;
@@ -184,10 +184,10 @@ mod tests {
         data.push(2); // palette_count
         data.extend_from_slice(&[0x00, 0x00, 0x00]); // black BGR
         data.extend_from_slice(&[0xFF, 0xFF, 0xFF]); // white BGR
-                                                     // Segment: packed byte, stop_index=0 (1 bit), suite_depth=0 (7 bits), run=5
+        // Segment: packed byte, stop_index=0 (1 bit), suite_depth=0 (7 bits), run=5
         data.push(0x00); // packed: stop=0, depth=0
         data.push(5); // run_length=5
-                      // Segment: stop_index=1, suite_depth=0, run=3
+        // Segment: stop_index=1, suite_depth=0, run=3
         data.push(0x01); // packed: stop=1, depth=0
         data.push(3); // run_length=3
 

crates/ironrdp-pdu/src/codecs/clearcodec/subcodec.rs

@@ -4,7 +4,7 @@
 //! raw BGR pixels, NSCodec, or RLEX. Each subcodec region specifies its
 //! position, dimensions, and the codec used to compress its bitmap data.
 
-use ironrdp_core::{cast_length, ensure_size, invalid_field_err, DecodeResult, ReadCursor};
+use ironrdp_core::{DecodeResult, ReadCursor, cast_length, ensure_size, invalid_field_err};
 
 /// Subcodec identifier.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -103,7 +103,7 @@ mod tests {
         data.extend_from_slice(&2u16.to_le_bytes()); // height
         data.extend_from_slice(&12u32.to_le_bytes()); // bitmapDataByteCount = 2*2*3 = 12
         data.push(0x00); // subCodecId = Raw
-                         // 4 pixels BGR
+        // 4 pixels BGR
         data.extend_from_slice(&[0xFF, 0x00, 0x00]); // blue
         data.extend_from_slice(&[0x00, 0xFF, 0x00]); // green
         data.extend_from_slice(&[0x00, 0x00, 0xFF]); // red