feat: Add ironrdp-egfx

Based on ironrdp-pdu/gfx code.

Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>

Author: elmarco

Cargo.lock

@@ -35,6 +35,7 @@ ironrdp-core = { version = "0.1", path = "crates/ironrdp-core" }
 ironrdp-connector = { version = "0.2", path = "crates/ironrdp-connector" }
 ironrdp-dvc = { version = "0.1", path = "crates/ironrdp-dvc" }
 ironrdp-displaycontrol = { version = "0.1", path = "crates/ironrdp-displaycontrol" }
+ironrdp-egfx = { version = "0.1", path = "crates/ironrdp-egfx" }
 ironrdp-error = { version = "0.1", path = "crates/ironrdp-error" }
 ironrdp-futures = { version = "0.1", path = "crates/ironrdp-futures" }
 ironrdp-fuzzing = { path = "crates/ironrdp-fuzzing" }

Cargo.toml

@@ -0,0 +1,7 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+

crates/ironrdp-egfx/CHANGELOG.md

@@ -0,0 +1,28 @@
+[package]
+name = "ironrdp-egfx"
+version = "0.1.1"
+readme = "README.md"
+description = "Graphics pipeline dynamic channel extension implementation"
+edition.workspace = true
+license.workspace = true
+homepage.workspace = true
+repository.workspace = true
+authors.workspace = true
+keywords.workspace = true
+categories.workspace = true
+
+[lib]
+doctest = false
+test = false
+
+[dependencies]
+bit_field = "0.10.2"
+bitflags.workspace = true
+ironrdp-core.workspace = true
+ironrdp-dvc.workspace = true
+ironrdp-graphics.workspace = true
+ironrdp-pdu.workspace = true
+tracing.workspace = true
+
+[lints]
+workspace = true

crates/ironrdp-egfx/Cargo.toml

@@ -0,0 +1 @@
+../../LICENSE-APACHE

crates/ironrdp-egfx/LICENSE-APACHE

@@ -0,0 +1 @@
+../../LICENSE-MIT

crates/ironrdp-egfx/LICENSE-MIT

@@ -0,0 +1,9 @@
+#  IronRDP Graphics Pipeline Virtual Channel Extension [MS-RDPEGFX][1] implementation.
+
+Display pipeline Virtual Channel Extension [MS-RDPEGFX][1] implementation.
+
+This library includes:
+- Display pipeline DVC PDUs parsing
+- Display pipeline DVC processing (TODO)
+
+[1]: https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-rdpegfx/da5c75f9-cd99-450c-98c4-014a496942b0

crates/ironrdp-egfx/README.md

@@ -0,0 +1,70 @@
+use ironrdp_core::{impl_as_any, ReadCursor};
+use ironrdp_dvc::{DvcClientProcessor, DvcMessage, DvcProcessor};
+use ironrdp_graphics::zgfx;
+use ironrdp_pdu::{decode_cursor, decode_err, PduResult};
+use tracing::trace;
+
+use crate::{
+    pdu::{CapabilitiesAdvertisePdu, CapabilitiesV8Flags, CapabilitySet, GfxPdu},
+    CHANNEL_NAME,
+};
+
+pub trait GraphicsPipelineHandler: Send {
+    fn capabilities(&self) -> Vec<CapabilitySet> {
+        vec![CapabilitySet::V8 {
+            flags: CapabilitiesV8Flags::empty(),
+        }]
+    }
+
+    fn handle_pdu(&mut self, pdu: GfxPdu) {
+        trace!(?pdu);
+    }
+}
+
+/// A client for the Graphics Pipeline Virtual Channel.
+pub struct GraphicsPipelineClient {
+    handler: Box<dyn GraphicsPipelineHandler>,
+    decompressor: zgfx::Decompressor,
+    decompressed_buffer: Vec<u8>,
+}
+
+impl GraphicsPipelineClient {
+    pub fn new(handler: Box<dyn GraphicsPipelineHandler>) -> Self {
+        Self {
+            handler,
+            decompressor: zgfx::Decompressor::new(),
+            decompressed_buffer: Vec::with_capacity(1024 * 16),
+        }
+    }
+}
+
+impl_as_any!(GraphicsPipelineClient);
+
+impl DvcProcessor for GraphicsPipelineClient {
+    fn channel_name(&self) -> &str {
+        CHANNEL_NAME
+    }
+
+    fn start(&mut self, _channel_id: u32) -> PduResult<Vec<DvcMessage>> {
+        let pdu = GfxPdu::CapabilitiesAdvertise(CapabilitiesAdvertisePdu(self.handler.capabilities()));
+
+        Ok(vec![Box::new(pdu)])
+    }
+
+    fn process(&mut self, _channel_id: u32, payload: &[u8]) -> PduResult<Vec<DvcMessage>> {
+        self.decompressed_buffer.clear();
+        self.decompressor
+            .decompress(payload, &mut self.decompressed_buffer)
+            .map_err(|e| decode_err!(e))?;
+
+        let mut cursor = ReadCursor::new(self.decompressed_buffer.as_slice());
+        while !cursor.is_empty() {
+            let pdu = decode_cursor(&mut cursor).map_err(|e| decode_err!(e))?;
+            self.handler.handle_pdu(pdu);
+        }
+
+        Ok(vec![])
+    }
+}
+
+impl DvcClientProcessor for GraphicsPipelineClient {}

crates/ironrdp-egfx/src/client.rs

@@ -0,0 +1,8 @@
+#![doc = include_str!("../README.md")]
+#![doc(html_logo_url = "https://cdnweb.devolutions.net/images/projects/devolutions/logos/devolutions-icon-shadow.svg")]
+
+pub const CHANNEL_NAME: &str = "Microsoft::Windows::RDS::Graphics";
+
+pub mod client;
+pub mod pdu;
+pub mod server;

crates/ironrdp-egfx/src/lib.rs

@@ -0,0 +1,218 @@
+use core::fmt;
+
+use ironrdp_pdu::{
+    cast_length, ensure_fixed_part_size, ensure_size, geometry::InclusiveRectangle, invalid_field_err, Decode,
+    DecodeResult, Encode, EncodeResult, ReadCursor, WriteCursor,
+};
+
+use bit_field::BitField;
+use bitflags::bitflags;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct QuantQuality {
+    pub quantization_parameter: u8,
+    pub progressive: bool,
+    pub quality: u8,
+}
+
+impl QuantQuality {
+    const NAME: &'static str = "GfxQuantQuality";
+
+    const FIXED_PART_SIZE: usize = 1 /* data */ + 1 /* quality */;
+}
+
+impl Encode for QuantQuality {
+    fn encode(&self, dst: &mut WriteCursor<'_>) -> EncodeResult<()> {
+        ensure_fixed_part_size!(in: dst);
+
+        let mut data = 0u8;
+        data.set_bits(0..6, self.quantization_parameter);
+        data.set_bit(7, self.progressive);
+        dst.write_u8(data);
+        dst.write_u8(self.quality);
+        Ok(())
+    }
+
+    fn name(&self) -> &'static str {
+        Self::NAME
+    }
+
+    fn size(&self) -> usize {
+        Self::FIXED_PART_SIZE
+    }
+}
+
+impl<'de> Decode<'de> for QuantQuality {
+    fn decode(src: &mut ReadCursor<'de>) -> DecodeResult<Self> {
+        ensure_fixed_part_size!(in: src);
+
+        let data = src.read_u8();
+        let qp = data.get_bits(0..6);
+        let progressive = data.get_bit(7);
+        let quality = src.read_u8();
+        Ok(QuantQuality {
+            quantization_parameter: qp,
+            progressive,
+            quality,
+        })
+    }
+}
+
+#[derive(Clone, PartialEq, Eq)]
+pub struct Avc420BitmapStream<'a> {
+    pub rectangles: Vec<InclusiveRectangle>,
+    pub quant_qual_vals: Vec<QuantQuality>,
+    pub data: &'a [u8],
+}
+
+impl fmt::Debug for Avc420BitmapStream<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Avc420BitmapStream")
+            .field("rectangles", &self.rectangles)
+            .field("quant_qual_vals", &self.quant_qual_vals)
+            .field("data_len", &self.data.len())
+            .finish()
+    }
+}
+
+impl Avc420BitmapStream<'_> {
+    const NAME: &'static str = "Avc420BitmapStream";
+
+    const FIXED_PART_SIZE: usize = 4 /* nRect */;
+}
+
+impl Encode for Avc420BitmapStream<'_> {
+    fn encode(&self, dst: &mut WriteCursor<'_>) -> EncodeResult<()> {
+        ensure_size!(in: dst, size: self.size());
+
+        dst.write_u32(cast_length!("len", self.rectangles.len())?);
+        for rectangle in &self.rectangles {
+            rectangle.encode(dst)?;
+        }
+        for quant_qual_val in &self.quant_qual_vals {
+            quant_qual_val.encode(dst)?;
+        }
+        dst.write_slice(self.data);
+
+        Ok(())
+    }
+
+    fn name(&self) -> &'static str {
+        Self::NAME
+    }
+
+    fn size(&self) -> usize {
+        // Each rectangle is 8 bytes and 2 bytes for each quant val
+        Self::FIXED_PART_SIZE + self.rectangles.len() * 10 + self.data.len()
+    }
+}
+
+impl<'de> Decode<'de> for Avc420BitmapStream<'de> {
+    fn decode(src: &mut ReadCursor<'de>) -> DecodeResult<Self> {
+        ensure_fixed_part_size!(in: src);
+
+        let num_regions = src.read_u32();
+        let mut rectangles = Vec::with_capacity(num_regions as usize);
+        let mut quant_qual_vals = Vec::with_capacity(num_regions as usize);
+        for _ in 0..num_regions {
+            rectangles.push(InclusiveRectangle::decode(src)?);
+        }
+        for _ in 0..num_regions {
+            quant_qual_vals.push(QuantQuality::decode(src)?);
+        }
+        let data = src.remaining();
+        Ok(Avc420BitmapStream {
+            rectangles,
+            quant_qual_vals,
+            data,
+        })
+    }
+}
+
+bitflags! {
+    #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+    pub struct Encoding: u8 {
+        const LUMA_AND_CHROMA = 0x00;
+        const LUMA = 0x01;
+        const CHROMA = 0x02;
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Avc444BitmapStream<'a> {
+    pub encoding: Encoding,
+    pub stream1: Avc420BitmapStream<'a>,
+    pub stream2: Option<Avc420BitmapStream<'a>>,
+}
+
+impl Avc444BitmapStream<'_> {
+    const NAME: &'static str = "Avc444BitmapStream";
+
+    const FIXED_PART_SIZE: usize = 4 /* streamInfo */;
+}
+
+impl Encode for Avc444BitmapStream<'_> {
+    fn encode(&self, dst: &mut WriteCursor<'_>) -> EncodeResult<()> {
+        ensure_fixed_part_size!(in: dst);
+
+        let mut stream_info = 0u32;
+        stream_info.set_bits(0..30, cast_length!("stream1size", self.stream1.size())?);
+        stream_info.set_bits(30..32, self.encoding.bits().into());
+        dst.write_u32(stream_info);
+        self.stream1.encode(dst)?;
+        if let Some(stream) = self.stream2.as_ref() {
+            stream.encode(dst)?;
+        }
+        Ok(())
+    }
+
+    fn name(&self) -> &'static str {
+        Self::NAME
+    }
+
+    fn size(&self) -> usize {
+        let stream2_size = if let Some(stream) = self.stream2.as_ref() {
+            stream.size()
+        } else {
+            0
+        };
+
+        Self::FIXED_PART_SIZE + self.stream1.size() + stream2_size
+    }
+}
+
+impl<'de> Decode<'de> for Avc444BitmapStream<'de> {
+    fn decode(src: &mut ReadCursor<'de>) -> DecodeResult<Self> {
+        ensure_fixed_part_size!(in: src);
+
+        let stream_info = src.read_u32();
+        let stream_len = stream_info.get_bits(0..30);
+        let encoding = Encoding::from_bits_truncate(stream_info.get_bits(30..32).try_into().unwrap());
+
+        if stream_len == 0 {
+            if encoding == Encoding::LUMA_AND_CHROMA {
+                return Err(invalid_field_err!("encoding", "invalid encoding"));
+            }
+
+            let stream1 = Avc420BitmapStream::decode(src)?;
+            Ok(Avc444BitmapStream {
+                encoding,
+                stream1,
+                stream2: None,
+            })
+        } else {
+            let (mut stream1, mut stream2) = src.split_at(stream_len as usize);
+            let stream1 = Avc420BitmapStream::decode(&mut stream1)?;
+            let stream2 = if encoding == Encoding::LUMA_AND_CHROMA {
+                Some(Avc420BitmapStream::decode(&mut stream2)?)
+            } else {
+                None
+            };
+            Ok(Avc444BitmapStream {
+                encoding,
+                stream1,
+                stream2,
+            })
+        }
+    }
+}