feat(graphics,egfx): add progressive RFX server encode and mixed-codec frames

Add server-side progressive encode pipeline and multi-codec frame
support:

ironrdp-graphics: Progressive RFX encoder producing first-pass and
upgrade-pass tile data via forward DWT + SRL quantization. Quality
level control for adaptive bandwidth usage.

ironrdp-egfx: send_remotefx_progressive_frame() for WireToSurface2
progressive transmission. MixedTilePayload enum and send_mixed_frame()
for combining ClearCodec + Progressive RFX tiles in a single
StartFrame/EndFrame pair.

Author: lamco-office

crates/ironrdp-egfx/src/server.rs

@@ -864,6 +864,31 @@ pub struct GraphicsPipelineServer {
     compression_mode: CompressionMode,
 }
 
+/// Payload for a single tile within a mixed-codec frame.
+///
+/// Each variant corresponds to a different EGFX codec. Used with
+/// [`GraphicsPipelineServer::send_mixed_frame()`] to pack multiple codec
+/// types into a single `StartFrame`/`EndFrame` pair.
+pub enum MixedTilePayload {
+    /// Lossless ClearCodec tile (text, UI elements, icons).
+    /// `bitmap_data` is a pre-encoded ClearCodec bitmap stream.
+    ClearCodec {
+        destination: InclusiveRectangle,
+        bitmap_data: Vec<u8>,
+    },
+    /// RemoteFX Progressive tile (photos, gradients).
+    /// `progressive_data` is a valid progressive block stream.
+    RemoteFxProgressive {
+        codec_context_id: u32,
+        progressive_data: Vec<u8>,
+    },
+    /// H.264 AVC420 tile (video, high-motion content).
+    Avc420 {
+        regions: Vec<Avc420Region>,
+        h264_data: Vec<u8>,
+    },
+}
+
 impl GraphicsPipelineServer {
     /// Create a new GraphicsPipelineServer
     pub fn new(handler: Box<dyn GraphicsPipelineHandler>) -> Self {
@@ -1455,6 +1480,91 @@ impl GraphicsPipelineServer {
         Some(frame_id)
     }
 
+    // ========================================================================
+    // Mixed-Codec Frame Support
+    // ========================================================================
+
+    /// Queue a mixed-codec frame containing tiles encoded with different codecs.
+    ///
+    /// This is the core of multi-codec EGFX: a single frame update can contain
+    /// ClearCodec tiles (lossless text), Progressive tiles (photos), and H.264
+    /// tiles (video), all sent between one `StartFrame`/`EndFrame` pair.
+    ///
+    /// This matches how Azure VDI achieves its visual quality — each tile uses
+    /// the codec best suited to its content type.
+    ///
+    /// Returns `Some(frame_id)` if queued, `None` if not ready or backpressured.
+    pub fn send_mixed_frame(
+        &mut self,
+        surface_id: u16,
+        tiles: Vec<MixedTilePayload>,
+        timestamp_ms: u32,
+    ) -> Option<u32> {
+        if !self.is_ready() {
+            return None;
+        }
+        if self.should_backpressure() {
+            return None;
+        }
+        if tiles.is_empty() {
+            return None;
+        }
+
+        let surface = self.surfaces.get(surface_id)?;
+        let pixel_format = surface.pixel_format;
+
+        let timestamp = Self::make_timestamp(timestamp_ms);
+        let frame_id = self.frames.begin_frame(timestamp);
+
+        self.output_queue
+            .push_back(GfxPdu::StartFrame(StartFramePdu { timestamp, frame_id }));
+
+        for tile in tiles {
+            match tile {
+                MixedTilePayload::ClearCodec {
+                    destination,
+                    bitmap_data,
+                } => {
+                    self.output_queue.push_back(GfxPdu::WireToSurface1(WireToSurface1Pdu {
+                        surface_id,
+                        codec_id: Codec1Type::ClearCodec,
+                        pixel_format,
+                        destination_rectangle: destination,
+                        bitmap_data,
+                    }));
+                }
+                MixedTilePayload::RemoteFxProgressive {
+                    codec_context_id,
+                    progressive_data,
+                } => {
+                    self.output_queue.push_back(GfxPdu::WireToSurface2(WireToSurface2Pdu {
+                        surface_id,
+                        codec_id: Codec2Type::RemoteFxProgressive,
+                        codec_context_id,
+                        pixel_format,
+                        bitmap_data: progressive_data,
+                    }));
+                }
+                MixedTilePayload::Avc420 { regions, h264_data } => {
+                    let encoded_stream = encode_avc420_bitmap_stream(&regions, &h264_data);
+                    let target_rect = Self::compute_dest_rect(&regions, surface.width, surface.height);
+
+                    self.output_queue.push_back(GfxPdu::WireToSurface1(WireToSurface1Pdu {
+                        surface_id,
+                        codec_id: Codec1Type::Avc420,
+                        pixel_format,
+                        destination_rectangle: target_rect,
+                        bitmap_data: encoded_stream,
+                    }));
+                }
+            }
+        }
+
+        self.output_queue.push_back(GfxPdu::EndFrame(EndFramePdu { frame_id }));
+
+        Some(frame_id)
+    }
+
     // ========================================================================
     // Output Management
     // ========================================================================