ironrdp-session

pub struct ActiveStage { /* ... */ }

impl ActiveStage {
    pub fn new(
        user_channel_id: u16,
        io_channel_id: u16,
        no_server_pointer: bool,
        pointer_software_rendering: bool,
        desktop_size: DesktopSize,
    ) -> Self;
    
    pub fn process(
        &mut self,
        image: &mut dyn image::DecodedImage,
        payload: &[u8],
        output_buf: &mut WriteBuf,
    ) -> SessionResult<ActiveStageOutput>;
}

pub enum ActiveStageOutput {
    GraphicsUpdate,
    PointerDefault,
    PointerHidden,
    PointerPosition { x: u16, y: u16 },
    PointerBitmap { /* ... */ },
    Terminate(GracefulDisconnectReason),
}

pub enum GracefulDisconnectReason {
    UserInitiated,
    ServerInitiated,
    // ... other reasons
}

pub trait DecodedImage {
    fn width(&self) -> usize;
    fn height(&self) -> usize;
    
    fn from_bitmap(&mut self, region: &BitmapRegion<'_>) -> SessionResult<()>;
    fn read_to_buffer(&self, buffer: &mut [u8]) -> SessionResult<()>;
}

use ironrdp_session::image::{DecodedImage, BitmapRegion};
use ironrdp_session::SessionResult;

struct MyImage {
    width: usize,
    height: usize,
    data: Vec<u8>, // BGRA format
}

impl DecodedImage for MyImage {
    fn width(&self) -> usize { self.width }
    fn height(&self) -> usize { self.height }
    
    fn from_bitmap(&mut self, region: &BitmapRegion<'_>) -> SessionResult<()> {
        // Decode bitmap data into self.data at the specified region
        // region.left, region.top, region.width, region.height
        // region.pixel_format, region.pixel_data
        Ok(())
    }
    
    fn read_to_buffer(&self, buffer: &mut [u8]) -> SessionResult<()> {
        buffer.copy_from_slice(&self.data);
        Ok(())
    }
}

pub struct BitmapRegion<'a> {
    pub left: usize,
    pub top: usize,
    pub width: usize,
    pub height: usize,
    pub pixel_format: PixelFormat,
    pub pixel_data: &'a [u8],
}

pub mod fast_path;

pub mod x224;

pub mod legacy;

pub mod pointer;

pub mod rfx;

use ironrdp_session::{ActiveStage, ActiveStageOutput};
use ironrdp_connector::{ConnectionResult, DesktopSize};
use ironrdp_core::WriteBuf;

// After connection is established
let result: ConnectionResult = /* ... */;

let mut session = ActiveStage::new(
    result.user_channel_id,
    result.io_channel_id,
    result.no_server_pointer,
    result.pointer_software_rendering,
    result.desktop_size,
);

let mut image = MyImage::new(result.desktop_size.width, result.desktop_size.height);
let mut output = WriteBuf::new();

loop {
    // ... receive PDU data into input_buf
    
    match session.process(&mut image, &input_buf, &mut output)? {
        ActiveStageOutput::GraphicsUpdate => {
            // Image was updated, render it
            render_frame(&image);
        },
        ActiveStageOutput::PointerPosition { x, y } => {
            // Move cursor to (x, y)
        },
        ActiveStageOutput::Terminate(reason) => {
            println!("Session terminated: {:?}", reason);
            break;
        },
        _ => {}
    }
    
    // Send any output PDUs
    if !output.filled().is_empty() {
        // ... send output.filled() over network
        output.clear();
    }
}

pub type SessionResult<T> = Result<T, SessionError>;
pub type SessionError = ironrdp_error::Error<SessionErrorKind>;

#[non_exhaustive]
pub enum SessionErrorKind {
    Pdu(ironrdp_pdu::PduError),
    Encode(ironrdp_core::EncodeError),
    Decode(ironrdp_core::DecodeError),
    Reason(String),
    General,
    Custom,
}