feat: add QOI image codec

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

Author: elmarco

.cargo/config.toml

@@ -1,2 +1,5 @@
 [alias]
 xtask = "run --package xtask --"
+
+[patch.crates-io]
+qoi = { git = "https://github.com/elmarco/qoi-rust.git", branch = "raw" }

Cargo.lock

@@ -27,6 +27,7 @@ test = false
 default = ["rustls"]
 rustls = ["ironrdp-tls/rustls"]
 native-tls = ["ironrdp-tls/native-tls"]
+qoi = ["ironrdp/qoi"]
 
 [dependencies]
 # Protocols

crates/ironrdp-client/Cargo.toml

@@ -16,7 +16,9 @@ doctest = false
 test = false
 
 [features]
+default = []
 arbitrary = ["dep:arbitrary"]
+qoi = ["ironrdp-pdu/qoi"]
 
 [dependencies]
 ironrdp-svc = { path = "../ironrdp-svc", version = "0.3" } # public

crates/ironrdp-connector/Cargo.toml

@@ -19,6 +19,7 @@ doctest = false
 default = []
 std = ["alloc", "ironrdp-error/std", "ironrdp-core/std"]
 alloc = ["ironrdp-core/alloc", "ironrdp-error/alloc"]
+qoi = []
 
 [dependencies]
 bitflags = "2.4"

crates/ironrdp-pdu/Cargo.toml

@@ -39,6 +39,9 @@ const GUID_REMOTEFX: Guid = Guid(0x7677_2f12, 0xbd72, 0x4463, 0xaf, 0xb3, 0xb7,
 const GUID_IMAGE_REMOTEFX: Guid = Guid(0x2744_ccd4, 0x9d8a, 0x4e74, 0x80, 0x3c, 0x0e, 0xcb, 0xee, 0xa1, 0x9c, 0x54);
 #[rustfmt::skip]
 const GUID_IGNORE: Guid = Guid(0x9c43_51a6, 0x3535, 0x42ae, 0x91, 0x0c, 0xcd, 0xfc, 0xe5, 0x76, 0x0b, 0x58);
+#[rustfmt::skip]
+#[cfg(feature="qoi")]
+const GUID_QOI: Guid = Guid(0x4dae_9af8, 0xb399, 0x4df6, 0xb4, 0x3a, 0x66, 0x2f, 0xd9, 0xc0, 0xf5, 0xd6);
 
 #[derive(Debug, PartialEq, Eq)]
 pub struct Guid(u32, u16, u16, u8, u8, u8, u8, u8, u8, u8, u8);
@@ -166,6 +169,8 @@ impl Encode for Codec {
             CodecProperty::RemoteFx(_) => GUID_REMOTEFX,
             CodecProperty::ImageRemoteFx(_) => GUID_IMAGE_REMOTEFX,
             CodecProperty::Ignore => GUID_IGNORE,
+            #[cfg(feature = "qoi")]
+            CodecProperty::Qoi => GUID_QOI,
             _ => return Err(other_err!("invalid codec")),
         };
         guid.encode(dst)?;
@@ -203,6 +208,8 @@ impl Encode for Codec {
                     }
                 };
             }
+            #[cfg(feature = "qoi")]
+            CodecProperty::Qoi => dst.write_u16(0),
             CodecProperty::Ignore => dst.write_u16(0),
             CodecProperty::None => dst.write_u16(0),
         };
@@ -226,6 +233,8 @@ impl Encode for Codec {
                     RemoteFxContainer::ClientContainer(container) => container.size(),
                     RemoteFxContainer::ServerContainer(size) => *size,
                 },
+                #[cfg(feature = "qoi")]
+                CodecProperty::Qoi => 0,
                 CodecProperty::Ignore => 0,
                 CodecProperty::None => 0,
             }
@@ -260,6 +269,8 @@ impl<'de> Decode<'de> for Codec {
                         _ => unreachable!(),
                     }
                 }
+                #[cfg(feature = "qoi")]
+                GUID_QOI => CodecProperty::Qoi,
                 GUID_IGNORE => CodecProperty::Ignore,
                 _ => CodecProperty::None,
             }
@@ -271,6 +282,8 @@ impl<'de> Decode<'de> for Codec {
                         "invalid codec property length"
                     ));
                 }
+                #[cfg(feature = "qoi")]
+                GUID_QOI => CodecProperty::Qoi,
                 GUID_IGNORE => CodecProperty::Ignore,
                 _ => CodecProperty::None,
             }
@@ -292,6 +305,8 @@ pub enum CodecProperty {
     RemoteFx(RemoteFxContainer),
     ImageRemoteFx(RemoteFxContainer),
     Ignore,
+    #[cfg(feature = "qoi")]
+    Qoi,
     None,
 }
 
@@ -625,15 +640,19 @@ bitflags! {
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 #[repr(u8)]
 pub enum CodecId {
-    None = 0x0,
-    RemoteFx = 0x3,
+    None = 0x00,
+    RemoteFx = 0x03,
+    #[cfg(feature = "qoi")]
+    Qoi = 0x0A,
 }
 
 impl CodecId {
     pub const fn from_u8(value: u8) -> Option<Self> {
         match value {
-            0 => Some(Self::None),
-            3 => Some(Self::RemoteFx),
+            0x00 => Some(Self::None),
+            0x03 => Some(Self::RemoteFx),
+            #[cfg(feature = "qoi")]
+            0x0A => Some(Self::Qoi),
             _ => None,
         }
     }
@@ -696,6 +715,14 @@ pub fn client_codecs_capabilities(config: &[&str]) -> Result<BitmapCodecs, Strin
         });
     }
 
+    #[cfg(feature = "qoi")]
+    if config.remove("qoi").unwrap_or(true) {
+        codecs.push(Codec {
+            id: CodecId::Qoi as u8,
+            property: CodecProperty::Qoi,
+        });
+    }
+
     let codec_names = config.keys().copied().collect::<Vec<_>>().join(", ");
     if !codec_names.is_empty() {
         return Err(format!("Unknown codecs: {}", codec_names));
@@ -717,6 +744,7 @@ pub fn client_codecs_capabilities(config: &[&str]) -> Result<BitmapCodecs, Strin
 /// # List of codecs
 ///
 /// * `remotefx` (on by default)
+/// * `qoi` (on by default, when feature "qoi")
 ///
 /// # Returns
 ///
@@ -736,6 +764,14 @@ pub fn server_codecs_capabilities(config: &[&str]) -> Result<BitmapCodecs, Strin
         });
     }
 
+    #[cfg(feature = "qoi")]
+    if config.remove("qoi").unwrap_or(true) {
+        codecs.push(Codec {
+            id: 0,
+            property: CodecProperty::Qoi,
+        });
+    }
+
     let codec_names = config.keys().copied().collect::<Vec<_>>().join(", ");
     if !codec_names.is_empty() {
         return Err(format!("Unknown codecs: {}", codec_names));

crates/ironrdp-pdu/src/rdp/capability_sets/bitmap_codecs.rs

@@ -19,9 +19,10 @@ name = "perfenc"
 required-features = ["__bench"]
 
 [features]
-default = ["rayon"]
+default = ["rayon", "qoi"]
 helper = ["dep:x509-cert", "dep:rustls-pemfile"]
 rayon = ["dep:rayon"]
+qoi = ["dep:qoi", "ironrdp-pdu/qoi"]
 
 # Internal (PRIVATE!) features used to aid testing.
 # Don't rely on these whatsoever. They may disappear at any time.
@@ -50,6 +51,7 @@ rustls-pemfile = { version = "2.2.0", optional = true }
 rayon = { version = "1.10.0", optional = true }
 bytes = "1"
 visibility = { version = "0.1", optional = true }
+qoi = { version = "0.4", optional = true }
 
 [dev-dependencies]
 tokio = { version = "1", features = ["sync", "fs"] }

crates/ironrdp-server/Cargo.toml

@@ -48,8 +48,16 @@ async fn main() -> Result<(), anyhow::Error> {
             (None, None)
         }
         OptCodec::None => (None, None),
+        #[cfg(feature = "qoi")]
+        OptCodec::Qoi => (None, Some(0)),
     };
-    let mut encoder = UpdateEncoder::new(DesktopSize { width, height }, flags, remotefx);
+    let mut encoder = UpdateEncoder::new(
+        DesktopSize { width, height },
+        flags,
+        remotefx,
+        #[cfg(feature = "qoi")]
+        qoicodec,
+    );
 
     let mut total_raw = 0u64;
     let mut total_enc = 0u64;
@@ -148,6 +156,8 @@ enum OptCodec {
     RemoteFX,
     Bitmap,
     None,
+    #[cfg(feature = "qoi")]
+    Qoi,
 }
 
 impl Default for OptCodec {
@@ -164,6 +174,8 @@ impl core::str::FromStr for OptCodec {
             "remotefx" => Ok(Self::RemoteFX),
             "bitmap" => Ok(Self::Bitmap),
             "none" => Ok(Self::None),
+            #[cfg(feature = "qoi")]
+            "qoi" => Ok(Self::Qoi),
             _ => Err(anyhow::anyhow!("unknown codec: {}", s)),
         }
     }

crates/ironrdp-server/examples/perfenc.rs

@@ -46,14 +46,27 @@ impl fmt::Debug for UpdateEncoder {
 
 impl UpdateEncoder {
     #[cfg_attr(feature = "__bench", visibility::make(pub))]
-    pub(crate) fn new(desktop_size: DesktopSize, surface_flags: CmdFlags, remotefx: Option<(EntropyBits, u8)>) -> Self {
-        let bitmap_updater = if !surface_flags.contains(CmdFlags::SET_SURFACE_BITS) {
-            BitmapUpdater::Bitmap(BitmapHandler::new())
-        } else if remotefx.is_some() {
-            let (algo, id) = remotefx.unwrap();
-            BitmapUpdater::RemoteFx(RemoteFxHandler::new(algo, id, desktop_size))
+    pub(crate) fn new(
+        desktop_size: DesktopSize,
+        surface_flags: CmdFlags,
+        remotefx: Option<(EntropyBits, u8)>,
+        #[cfg(feature = "qoi")] qoi_codec_id: Option<u8>,
+    ) -> Self {
+        let bitmap_updater = if surface_flags.contains(CmdFlags::SET_SURFACE_BITS) {
+            let mut up = BitmapUpdater::None(NoneHandler);
+
+            if let Some((algo, id)) = remotefx {
+                up = BitmapUpdater::RemoteFx(RemoteFxHandler::new(algo, id, desktop_size));
+            }
+
+            #[cfg(feature = "qoi")]
+            if let Some(id) = qoi_codec_id {
+                up = BitmapUpdater::Qoi(QoiHandler::new(id));
+            }
+
+            up
         } else {
-            BitmapUpdater::None(NoneHandler)
+            BitmapUpdater::Bitmap(BitmapHandler::new())
         };
 
         Self {
@@ -264,6 +277,8 @@ enum BitmapUpdater {
     None(NoneHandler),
     Bitmap(BitmapHandler),
     RemoteFx(RemoteFxHandler),
+    #[cfg(feature = "qoi")]
+    Qoi(QoiHandler),
 }
 
 impl BitmapUpdater {
@@ -272,6 +287,8 @@ impl BitmapUpdater {
             Self::None(up) => up.handle(bitmap),
             Self::Bitmap(up) => up.handle(bitmap),
             Self::RemoteFx(up) => up.handle(bitmap),
+            #[cfg(feature = "qoi")]
+            Self::Qoi(up) => up.handle(bitmap),
         }
     }
 
@@ -385,6 +402,47 @@ impl BitmapUpdateHandler for RemoteFxHandler {
     }
 }
 
+#[cfg(feature = "qoi")]
+#[derive(Clone, Debug)]
+struct QoiHandler {
+    codec_id: u8,
+}
+
+#[cfg(feature = "qoi")]
+impl QoiHandler {
+    fn new(codec_id: u8) -> Self {
+        Self { codec_id }
+    }
+}
+
+#[cfg(feature = "qoi")]
+impl BitmapUpdateHandler for QoiHandler {
+    fn handle(&mut self, bitmap: &BitmapUpdate) -> Result<UpdateFragmenter> {
+        use ironrdp_graphics::image_processing::PixelFormat::*;
+
+        let channels = match bitmap.format {
+            ARgb32 => qoi::RawChannels::Argb,
+            XRgb32 => qoi::RawChannels::Xrgb,
+            ABgr32 => qoi::RawChannels::Abgr,
+            XBgr32 => qoi::RawChannels::Xbgr,
+            BgrA32 => qoi::RawChannels::Bgra,
+            BgrX32 => qoi::RawChannels::Bgrx,
+            RgbA32 => qoi::RawChannels::Rgba,
+            RgbX32 => qoi::RawChannels::Rgbx,
+        };
+
+        let enc = qoi::Encoder::new_raw(
+            &bitmap.data,
+            bitmap.width.get().into(),
+            bitmap.height.get().into(),
+            bitmap.stride,
+            channels,
+        )?;
+        let data = enc.encode_to_vec()?;
+        set_surface(bitmap, self.codec_id, &data)
+    }
+}
+
 fn set_surface(bitmap: &BitmapUpdate, codec_id: u8, data: &[u8]) -> Result<UpdateFragmenter> {
     let destination = ExclusiveRectangle {
         left: bitmap.x,

crates/ironrdp-server/src/encoder/mod.rs

@@ -54,6 +54,14 @@ impl RdpServerOptions {
             .iter()
             .any(|codec| matches!(codec.property, CodecProperty::RemoteFx(_)))
     }
+
+    #[cfg(feature = "qoi")]
+    fn has_qoi(&self) -> bool {
+        self.codecs
+            .0
+            .iter()
+            .any(|codec| matches!(codec.property, CodecProperty::Qoi))
+    }
 }
 
 #[derive(Clone)]
@@ -678,6 +686,8 @@ impl RdpServer {
         }
 
         let mut rfxcodec = None;
+        #[cfg(feature = "qoi")]
+        let mut qoicodec = None;
         let mut surface_flags = CmdFlags::empty();
         for c in result.capabilities {
             match c {
@@ -739,6 +749,10 @@ impl RdpServer {
                                 }
                             }
                             CodecProperty::NsCodec(_) => (),
+                            #[cfg(feature = "qoi")]
+                            CodecProperty::Qoi if self.opts.has_qoi() => {
+                                qoicodec = Some(codec.id);
+                            }
                             _ => (),
                         }
                     }
@@ -748,7 +762,13 @@ impl RdpServer {
         }
 
         let desktop_size = self.display.lock().await.size().await;
-        let encoder = UpdateEncoder::new(desktop_size, surface_flags, rfxcodec);
+        let encoder = UpdateEncoder::new(
+            desktop_size,
+            surface_flags,
+            rfxcodec,
+            #[cfg(feature = "qoi")]
+            qoicodec,
+        );
 
         let state = self
             .client_loop(reader, writer, result.io_channel_id, result.user_channel_id, encoder)