Image rendering ("show" command) demo

Author: ameyer1024

Cargo.lock

@@ -15,6 +15,7 @@ members = [
     "crates/kernel",
     "crates/lz4",
     "crates/shell",
+    "crates/show",
     "crates/ulib",
 ]
 

Cargo.toml

@@ -8,4 +8,5 @@ FS_PATH="../../disk-image"
 DESTDIR="$FS_PATH" ../shell/build.sh
 DESTDIR="$FS_PATH" ../console/build.sh
 DESTDIR="$FS_PATH" ../display-server/build.sh
+DESTDIR="$FS_PATH" ../show/build.sh
 ../init/build.sh

crates/kernel/scripts/compile-init.sh

@@ -0,0 +1 @@
+*.elf

crates/show/.gitignore

@@ -0,0 +1,14 @@
+[package]
+name = "show"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+bytemuck = { version = "1.19.0", default-features = false }
+display-client = { path = "../display-client" }
+lz4 = { path = "../lz4" }
+ulib = { path = "../ulib", features = ["heap-impl"] }
+gfx = { path = "../gfx" }
+
+[dev-dependencies]
+ulib = { path = "../ulib", features = ["test"] }

crates/show/Cargo.toml

@@ -0,0 +1,6 @@
+fn main() {
+    let crate_root = std::env::var("CARGO_MANIFEST_DIR").unwrap();
+    println!("cargo::rerun-if-changed=../ulib/script.ld");
+    println!("cargo::rustc-link-arg-bins=-T{crate_root}/../ulib/script.ld");
+    println!("cargo::rustc-link-arg-bins=-n");
+}

crates/show/build.rs

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+
+set -ex
+cd "$(dirname "$0")"
+
+BIN="show"
+TARGET=aarch64-unknown-none-softfloat
+PROFILE=${PROFILE-"release"}
+
+cargo rustc --profile="${PROFILE}" \
+    --target="${TARGET}" \
+    --bin="${BIN}" \
+    -- -C relocation-model=static
+
+if test "$PROFILE" = "dev" ; then
+    BINARY=../../target/${TARGET}/debug/${BIN}
+else
+    BINARY=../../target/${TARGET}/${PROFILE}/${BIN}
+fi
+
+cp "${BINARY}" "${BIN}".elf
+
+if test -n "$DESTDIR" ; then
+    cp "${BINARY}" "$DESTDIR/"
+fi

crates/show/build.sh

@@ -0,0 +1,127 @@
+#![no_std]
+#![cfg_attr(not(test), no_main)]
+
+extern crate alloc;
+extern crate display_client;
+
+#[macro_use]
+extern crate ulib;
+
+use display_client::proto;
+
+use ulib::sys::FileDesc;
+
+// TODO: stat for file length
+fn read_all(fd: FileDesc) -> alloc::vec::Vec<u8> {
+    let mut out = alloc::vec::Vec::new();
+    let mut buf = [0u8; 512];
+    let mut offset = 0;
+    loop {
+        match ulib::sys::pread(fd, &mut buf, offset) {
+            Ok(0) => break,
+            Ok(len) => {
+                out.extend(&buf[..len]);
+                offset += len as u64;
+            }
+            Err(e) => {
+                println!("Error reading file: {e}");
+                ulib::sys::exit(1);
+            }
+        }
+    }
+    out
+}
+
+#[no_mangle]
+fn main(argc: usize, argv: *const *const u8) {
+    let argv_array = unsafe { core::slice::from_raw_parts(argv, argc) };
+    let args = argv_array
+        .iter()
+        .copied()
+        .map(|arg| unsafe { core::ffi::CStr::from_ptr(arg) }.to_bytes())
+        .map(|arg| core::str::from_utf8(arg).unwrap())
+        .collect::<alloc::vec::Vec<_>>();
+
+    let file = args[1];
+
+    let img_data;
+    let img_width;
+    let img_height;
+
+    if file.ends_with("qoi") {
+        let Ok(file) = ulib::sys::openat(3, file.as_bytes(), 0, 0) else {
+            println!("Error opening file {}", file);
+            ulib::sys::exit(1);
+        };
+
+        let img = read_all(file);
+        let (header, data) = gfx::format::qoi::read_qoi_header(&img).unwrap();
+        let width = header.width as usize;
+        let height = header.height as usize;
+        let mut output = alloc::vec![0u32; width * height];
+        gfx::format::qoi::decode_qoi(&header, data, &mut output, width);
+
+        img_width = width;
+        img_height = height;
+        img_data = output;
+    } else {
+        println!("Unknown file format, exiting.");
+        ulib::sys::exit(1);
+    }
+
+    let mut buf = display_client::connect(img_width as u16, img_height as u16);
+    buf.set_title(alloc::format!("show - {}", file).as_bytes());
+
+    let (width, height) = (
+        buf.video_meta.width as usize,
+        buf.video_meta.height as usize,
+    );
+    let row_stride = buf.video_meta.row_stride as usize / 4;
+
+    'outer: loop {
+        while let Some(ev) = buf.server_to_client_queue().try_recv() {
+            match ev.kind {
+                proto::EventKind::INPUT => {
+                    use proto::EventData;
+                    let data = proto::InputEvent::parse(&ev).expect("TODO");
+                    if data.kind == proto::InputEvent::KIND_KEY {
+                        match proto::ScanCode(data.data2) {
+                            proto::ScanCode::ESCAPE | proto::ScanCode::Q => {
+                                break 'outer;
+                            }
+                            _ => (),
+                        }
+                    }
+                }
+                proto::EventKind::REQUEST_CLOSE => {
+                    break 'outer;
+                }
+                _ => (),
+            }
+        }
+
+        let fb = buf.video_mem();
+        gfx::blit_buffer(
+            fb, width, height, row_stride, 0, 0, &img_data, img_width, img_height, img_width,
+        );
+
+        buf.client_to_server_queue()
+            .try_send(proto::Event {
+                kind: proto::EventKind::PRESENT,
+                data: [0; 7],
+            })
+            .ok();
+
+        // signal(video)? for sync
+        ulib::sys::sem_down(buf.get_sem_fd(buf.present_sem)).unwrap();
+
+        unsafe { ulib::sys::sys_sleep_ms(1000) };
+    }
+
+    buf.client_to_server_queue()
+        .try_send(proto::Event {
+            kind: proto::EventKind::DISCONNECT,
+            data: [0; 7],
+        })
+        .ok();
+}