diff --git a/Makefile b/Makefile index b5f04aa..e53fb4a 100644 --- a/Makefile +++ b/Makefile @@ -1,4 +1,4 @@ -.PHONY: fmt fmt-check clippy test-local test-debugger-socket clean coverage coverage-xml coverage-json coverage-report-json coverage-domain-list coverage-domain-evidence coverage-domain-audit coverage-domain-gate test ci ci-domains cobertura +.PHONY: fmt fmt-check clippy test-unit test-local test-integration test-debugger-socket clean coverage coverage-xml coverage-json coverage-report-json coverage-domain-list coverage-domain-evidence coverage-domain-audit coverage-domain-gate test ci ci-domains cobertura fmt: cargo fmt --all @@ -9,8 +9,15 @@ fmt-check: clippy: cargo clippy --workspace --all-targets --all-features -- -D warnings -test-local: - cargo test --workspace --all-targets --all-features --no-fail-fast +test-unit: + cargo test --workspace --lib --bins --all-features --no-fail-fast + +# Compatibility entry point: repository-local verification is unit-only. +test-local: test-unit + +# Explicit opt-in, orchestrated by ../tooling; test sources stay in this repository. +test-integration: + cargo test --workspace --tests --all-features --no-fail-fast test-debugger-socket: cargo test -p prometeu-host-desktop-winit --lib runner::tests -- --ignored @@ -19,7 +26,7 @@ clean: cargo llvm-cov clean --workspace coverage: - cargo llvm-cov --workspace --all-features --html --output-dir target/llvm-cov + cargo llvm-cov --workspace --lib --bins --all-features --html --output-dir target/llvm-cov coverage-report-json: cargo llvm-cov report --json --output-path target/llvm-cov/report.json @@ -46,9 +53,9 @@ coverage-domain-evidence: coverage-domain-gate: ./scripts/coverage-domain-evidence.sh --check-all -test: fmt-check clippy test-local test-debugger-socket +test: fmt-check clippy test-unit # Local and GitHub entry point; Jenkins exposes the same targets as stages. -CI_DOMAIN_STEPS = clean fmt-check clippy test-local test-debugger-socket coverage coverage-report-json coverage-xml coverage-json coverage-domain-audit coverage-domain-gate +CI_DOMAIN_STEPS = clean fmt-check clippy test-unit coverage coverage-report-json coverage-xml coverage-json coverage-domain-audit coverage-domain-gate ci: ci-domains ci-domains: diff --git a/README.md b/README.md index a6e2b47..3cf472b 100644 --- a/README.md +++ b/README.md @@ -133,7 +133,14 @@ The authoritative target used by both GitHub and Jenkins is: make ci-domains ``` -The five debugger socket tests bind localhost sockets and are marked ignored in Rust test metadata; both `make test` and `make ci-domains` select only `runner::tests` through `test-debugger-socket`. Physical audio and other manual probes remain opt-in. See [quality-gate prerequisites and commands](docs/vm-arch/COVERAGE_DOMAINS.md#commands-and-ci). +`make test-unit` selects library and binary unit-test harnesses with +`--lib --bins --all-features`; `test-local` remains an alias. Both `make test` +and `make ci-domains` run only this suite. Integration targets under `tests/`, +installed-process qualification and the five ignored debugger socket tests are +excluded from the pipeline. They remain available explicitly through +`make test-integration` and `make test-debugger-socket`, orchestrated by +`../tooling`. Tests and fixtures stay in this repository. Physical audio and manual probes remain opt-in. See +[quality-gate prerequisites and commands](docs/vm-arch/COVERAGE_DOMAINS.md#commands-and-ci). ## Coverage Governance @@ -170,7 +177,7 @@ make coverage-domain-evidence DOMAIN=host/headless ``` `make ci-domains` runs formatting, strict workspace/all-target/all-feature Clippy, -all-target tests, the five debugger socket tests, fresh coverage and every domain +library/binary unit tests, fresh unit-only coverage and every domain ownership/evidence gate. Both CI providers archive available evidence on failure. A failing run never lowers a configured floor; local and CI checks use the same repository-owned commands. Reports identify their revision, source/configuration diff --git a/crates/console/prometeu-system/src/services/vm_runtime/render_worker.rs b/crates/console/prometeu-system/src/services/vm_runtime/render_worker.rs index 3be9b2d..194a4c4 100644 --- a/crates/console/prometeu-system/src/services/vm_runtime/render_worker.rs +++ b/crates/console/prometeu-system/src/services/vm_runtime/render_worker.rs @@ -40,6 +40,19 @@ impl LatestRenderFrameStore { pub fn latest_frame(&self) -> Option { self.latest.lock().unwrap().clone() } + + /// Copy only a different complete publication; paused observers need not copy pixels. + pub fn latest_frame_after( + &self, + previous: Option<(RenderOwnership, FrameId)>, + ) -> Option { + self.latest + .lock() + .unwrap() + .as_ref() + .filter(|frame| previous != Some((frame.ownership, frame.frame_id))) + .cloned() + } } impl RenderWorkerFrameSink for LatestRenderFrameStore { diff --git a/crates/host/prometeu-host-desktop-winit/src/lib.rs b/crates/host/prometeu-host-desktop-winit/src/lib.rs index 2d4d32b..69e9dfb 100644 --- a/crates/host/prometeu-host-desktop-winit/src/lib.rs +++ b/crates/host/prometeu-host-desktop-winit/src/lib.rs @@ -6,6 +6,7 @@ pub mod input; pub mod log_sink; pub mod runner; pub mod stats; +pub mod studio; pub mod utilities; pub mod wall_clock; @@ -18,6 +19,9 @@ use winit::event_loop::EventLoop; #[derive(Parser, Debug)] #[command(author, version, about, long_about = None)] struct Cli { + /// Run an interactive Studio session without creating a desktop window. + #[arg(long, requires = "run", conflicts_with = "debug")] + studio: bool, /// Run a cartridge #[arg(long, value_name = "PATH", conflicts_with = "debug")] run: Option, @@ -54,6 +58,23 @@ struct Cli { pub fn run() -> Result<(), Box> { let cli = Cli::parse(); + if cli.studio { + let bootstrap = studio::wire::Bootstrap::read(std::io::stdin().lock())?; + let mut runner = + HostRunner::new(cli.fs_root, cli.cap.as_ref().and_then(|path| load_cap_config(path))); + if let Some(path) = cli.memcard { + runner + .install_memcard(path, cli.create_memcard) + .map_err(|e| format!("Cannot install memory card: {e:?}"))?; + } + runner.set_boot_target(BootTarget::Cartridge { + path: cli.run.expect("--studio requires --run"), + debug: false, + debug_port: 0, + }); + return studio::run(runner, bootstrap).map_err(Into::into); + } + let fs_root = cli.fs_root; let cap_config = cli.cap.as_ref().and_then(|path| load_cap_config(path)); diff --git a/crates/host/prometeu-host-desktop-winit/src/runner.rs b/crates/host/prometeu-host-desktop-winit/src/runner.rs index bcf0719..fdd3569 100644 --- a/crates/host/prometeu-host-desktop-winit/src/runner.rs +++ b/crates/host/prometeu-host-desktop-winit/src/runner.rs @@ -151,6 +151,7 @@ pub struct HostRunner { render_frame_store: LatestRenderFrameStore, /// Tracks whether a new logical frame or host-only surface invalidation requires presentation. presentation: PresentationState, + studio_capture: bool, } impl HostRunner { @@ -238,9 +239,161 @@ impl HostRunner { audio: HostAudio::new(), render_frame_store, presentation: PresentationState::default(), + studio_capture: false, } } + /// One canonical interactive slice, shared by desktop and Studio pacing. + fn tick_machine(&mut self) { + self.audio.service(); + if !self.debugger.waiting_for_start { + if self.studio_capture { + let mut platform = crate::studio::platform::StudioPlatform { + hardware: &mut self.hardware, + store: &self.render_frame_store, + }; + self.firmware.tick(&self.input.signals, &mut platform); + } else { + self.firmware.tick(&self.input.signals, &mut self.hardware); + } + self.stats.record_host_cpu_time(self.firmware.os.vm().last_frame_cpu_time_us()); + } + self.hardware.audio.set_paused( + self.firmware.game_lifecycle_audio_paused() + || self.firmware.os.vm().paused() + || self.debugger.waiting_for_start, + ); + self.audio.service(); + } + + pub(crate) fn studio_audio_init(&mut self) { + if let Err(error) = self.audio.init(self.hardware.audio.transport()) { + eprintln!("[HostAudio] Disabled: {error}"); + } + } + + pub(crate) fn studio_boot_step(&mut self, disposable: bool) -> Result { + self.studio_capture = true; + if matches!(self.firmware.state, FirmwareState::GameRunning(_)) { + return Ok(true); + } + if matches!(self.firmware.state, FirmwareState::AppCrashes(_)) { + return Err("Cartridge failed during Studio boot".into()); + } + self.firmware.os.memcard().poll(Instant::now()); + if let FirmwareState::LoadCartridge(step) = &mut self.firmware.state + && step.needs_memcard_choice() + && !self.firmware.os.memcard().preparation_active() + { + let choice = if disposable { + prometeu_system::memcard::admission::Choice::MemoryFresh + } else { + prometeu_system::memcard::admission::Choice::Persistent + }; + step.choose_memcard( + &mut self.firmware.os, + choice, + self.hardware.wall_clock().utc_unix_seconds(), + ) + .map_err(|e| format!("Studio save selection failed: {e:?}"))?; + } + self.tick_machine(); + self.studio_logs(); + Ok(matches!(self.firmware.state, FirmwareState::GameRunning(_))) + } + + pub(crate) fn studio_step( + &mut self, + signals: prometeu_hal::InputSignals, + ) -> Result<(), String> { + self.input.signals = signals; + self.tick_machine(); + self.studio_logs(); + if matches!(self.firmware.state, FirmwareState::AppCrashes(_)) { + return Err("Cartridge faulted during Studio Play".into()); + } + Ok(()) + } + + pub(crate) fn studio_pause(&mut self, paused: bool) { + self.input.clear_guest_signals(); + self.firmware.os.vm().set_paused(paused); + self.hardware.audio.set_paused(paused); + self.audio.service(); + } + + pub(crate) fn studio_dimensions(&self) -> (usize, usize) { + self.hardware.display_size() + } + pub(crate) fn studio_tick_index(&mut self) -> u64 { + self.firmware.os.frame_index() + } + + pub(crate) fn studio_frame( + &mut self, + previous: Option<(RenderOwnership, prometeu_hal::FrameId)>, + ) -> Option { + let active = self.firmware.os.vm().active_render_ownership(); + self.render_frame_store + .latest_frame_after(previous) + .filter(|frame| should_present_worker_frame(&self.firmware.state, frame, active)) + } + + fn studio_logs(&mut self) { + let last = self.log_sink.last_seq(); + let events = match last { + Some(seq) => self.firmware.os.logs_after(seq), + None => self.firmware.os.recent_logs(4096), + }; + self.log_sink.process_events(events); + } + + pub(crate) fn studio_stop(&mut self, disposable: bool) -> Result<(), String> { + self.studio_pause(true); + let deadline = Instant::now() + Duration::from_secs(2); + loop { + let service = self.firmware.os.memcard(); + service.poll(Instant::now()); + if !service.session.io_active() + && !service.session.has_deferred_write() + && !service.preparation_active() + { + break; + } + if Instant::now() >= deadline { + return Err("Save IO has not finished; retry Stop".into()); + } + let lane = service.lane.clone(); + lane.wait_for_progress(lane.progress_stamp(), Duration::from_millis(5)); + } + if self.firmware.os.memcard().session.unsaved() && !disposable { + return Err("Unsaved game data; resume and save before stopping".into()); + } + self.firmware + .os + .stop_background_io() + .map_err(|e| format!("Save shutdown failed: {e:?}"))?; + self.firmware.os.memcard().session.end_session(); + self.firmware.os.memcard().poll(Instant::now()); + self.firmware + .os + .memcard() + .uninstall_card() + .map_err(|e| format!("Save detach failed: {e:?}"))?; + self.firmware + .os + .vm() + .stop_render_worker() + .map_err(|e| format!("Render shutdown failed: {e:?}"))?; + Ok(()) + } + + pub(crate) fn studio_abort(&mut self) { + self.studio_pause(true); + let _ = self.firmware.os.vm().stop_render_worker(); + let _ = self.firmware.os.stop_background_io(); + } + fn window(&self) -> &'static Window { self.window.expect("window not created yet") } @@ -435,18 +588,7 @@ impl ApplicationHandler for HostRunner { while self.accumulator >= self.frame_target_dt { // Reclaim returned audio owners before another guest attempt, even // when the previous attempt paused or stopped at backpressure. - self.audio.service(); - // Unless the debugger is waiting for a 'start' command, advance the system. - if !self.debugger.waiting_for_start { - self.firmware.tick(&self.input.signals, &mut self.hardware); - self.stats.record_host_cpu_time(self.firmware.os.vm().last_frame_cpu_time_us()); - } - - let is_paused = self.firmware.game_lifecycle_audio_paused() - || self.firmware.os.vm().paused() - || self.debugger.waiting_for_start; - self.hardware.audio.set_paused(is_paused); - self.audio.service(); + self.tick_machine(); self.accumulator -= self.frame_target_dt; self.stats.record_frame(); @@ -500,6 +642,73 @@ impl ApplicationHandler for HostRunner { #[cfg(test)] mod tests { use super::*; + + #[test] + fn studio_can_boot_and_publish_without_a_window() { + let cart = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../../test-cartridges/dummy-boy"); + let mut host = HostRunner::new(None, None); + host.set_boot_target(BootTarget::Cartridge { + path: cart.to_string_lossy().into_owned(), + debug: false, + debug_port: 0, + }); + let deadline = Instant::now() + Duration::from_secs(5); + while !host.studio_boot_step(true).unwrap() { + assert!(Instant::now() < deadline); + std::thread::sleep(Duration::from_millis(1)); + } + host.studio_pause(true); + host.studio_pause(false); + for _ in 0..60 { + host.studio_step(Default::default()).unwrap(); + std::thread::sleep(Duration::from_millis(2)); + } + let frame = host.studio_frame(None); + let published = host.render_frame_store.latest_frame().map(|f| (f.frame_id, f.ownership)); + let active = host.firmware.os.vm().active_render_ownership(); + assert!( + frame.is_some(), + "store {published:?}, owner {active:?}, state {:?}, frame {}", + host.firmware.state, + host.firmware.os.frame_index() + ); + let frame = frame.unwrap(); + assert!(host.studio_frame(Some((frame.ownership, frame.frame_id))).is_none()); + // Exercise the same audio transport/callback through Studio lifecycle, + // without requiring a physical output device in this contract test. + use prometeu_hal::{AudioBridge, LoopMode, sample::Sample}; + let (mut callback, mut reclaimer) = crate::audio::AudioCallback::new(); + assert_eq!( + host.hardware.audio.play_sample( + Arc::new(Sample::new(48000, vec![1000; 32])), + 0, + 255, + 0, + 1.0, + 0, + LoopMode::On, + ), + prometeu_hal::AudioOpStatus::Ok + ); + host.hardware.audio.finish_frame(); + let transport = host.hardware.audio.transport(); + let mut pcm = [0.0; 64]; + callback.render(&transport, &mut pcm); + assert!(pcm.iter().any(|sample| *sample != 0.0)); + reclaimer.service(&transport); + host.studio_pause(true); + callback.render(&transport, &mut pcm); + assert!(pcm.iter().all(|sample| *sample == 0.0)); + reclaimer.service(&transport); + host.studio_pause(false); + callback.render(&transport, &mut pcm); + assert!(pcm.iter().any(|sample| *sample != 0.0)); + reclaimer.service(&transport); + host.studio_stop(true).unwrap(); + callback.render(&transport, &mut pcm); + assert!(pcm.iter().all(|sample| *sample == 0.0)); + } use prometeu_firmware::BootTarget; use prometeu_firmware::firmware::firmware_state::{ GameRunningStep, HubHomeStep, ShellRunningStep, diff --git a/crates/host/prometeu-host-desktop-winit/src/studio/mod.rs b/crates/host/prometeu-host-desktop-winit/src/studio/mod.rs new file mode 100644 index 0000000..251df5a --- /dev/null +++ b/crates/host/prometeu-host-desktop-winit/src/studio/mod.rs @@ -0,0 +1,255 @@ +//! Interactive Play integration, separate from the automation host. +pub(crate) mod platform; +mod transport; +pub mod wire; + +use crate::runner::HostRunner; +use prometeu_hal::InputSignals; +use std::{ + io, + time::{Duration, Instant}, +}; +use transport::Transport; +use wire::*; + +fn number64(p: &[u8]) -> u64 { + u64::from_le_bytes(p.try_into().unwrap()) +} +fn result( + transport: &Transport, + command: u16, + request: u64, + status: u16, + epoch: u64, + tick: u64, + text: &str, +) -> io::Result<()> { + let mut p = Vec::with_capacity(20 + text.len()); + p.extend_from_slice(&command.to_le_bytes()); + p.extend_from_slice(&status.to_le_bytes()); + p.extend_from_slice(&epoch.to_le_bytes()); + p.extend_from_slice(&tick.to_le_bytes()); + p.extend_from_slice(text.as_bytes()); + transport.send(RESULT, request, p) +} +fn input(p: &[u8], width: usize, height: usize) -> io::Result<(u64, InputSignals)> { + if p.len() != 20 { + return Err(invalid("Invalid Studio input length")); + } + let mask = u16::from_le_bytes(p[8..10].try_into().unwrap()); + if mask & !0x1fff != 0 || p[10..12] != [0, 0] { + return Err(invalid("Invalid Studio input bits")); + } + let x = i32::from_le_bytes(p[12..16].try_into().unwrap()); + let y = i32::from_le_bytes(p[16..20].try_into().unwrap()); + if mask & 0x1000 != 0 && (x < 0 || y < 0 || x as usize >= width || y as usize >= height) { + return Err(invalid("Studio touch outside display")); + } + let bit = |n: u16| mask & (1u16 << n) != 0; + Ok(( + number64(&p[..8]), + InputSignals { + up_signal: bit(0), + down_signal: bit(1), + left_signal: bit(2), + right_signal: bit(3), + a_signal: bit(4), + b_signal: bit(5), + x_signal: bit(6), + y_signal: bit(7), + l_signal: bit(8), + r_signal: bit(9), + start_signal: bit(10), + select_signal: bit(11), + f_signal: bit(12), + x_pos: x, + y_pos: y, + }, + )) +} + +pub(crate) fn run(mut runner: HostRunner, boot: Bootstrap) -> io::Result<()> { + let transport = Transport::connect(&boot)?; + runner.studio_audio_init(); + let (width, height) = runner.studio_dimensions(); + frame_bytes(width as u32, height as u32, width as u32)?; + let mut ready = false; + let mut started = false; + let mut state = 0u32; + let mut epoch = 1u64; + let mut signals = InputSignals::default(); + let mut next_tick = Instant::now(); + let boot_deadline = Instant::now() + Duration::from_secs(10); + let slice = Duration::from_nanos(1_000_000_000 / 60); + let mut last_request = 0; + let mut last_frame = None; + let outcome = (|| -> io::Result<()> { + loop { + if let Some(error) = transport.failure() { + return Err(invalid(&error)); + } + if ready && transport.idle() > Duration::from_secs(5) { + return Err(invalid("Studio control heartbeat expired")); + } + for _ in 0..64 { + let Some(message) = transport.next() else { + break; + }; + let h = message.header; + if h.kind == INPUT { + let (received, input) = input(&message.payload, width, height)?; + if received == epoch && state == 1 { + signals = input; + } + continue; + } + if h.kind == PING { + if !message.payload.is_empty() { + return Err(invalid("Invalid PING payload")); + } + let mut p = Vec::with_capacity(20); + p.extend_from_slice(&epoch.to_le_bytes()); + p.extend_from_slice(&runner.studio_tick_index().to_le_bytes()); + p.extend_from_slice(&state.to_le_bytes()); + transport.send(PONG, h.request, p)?; + continue; + } + if !matches!(h.kind, START | PAUSE | RESUME | STOP) + || !message.payload.is_empty() + || h.request == 0 + { + return Err(invalid("Invalid Studio control command")); + } + if h.request <= last_request { + result( + &transport, + h.kind, + h.request, + 1, + epoch, + runner.studio_tick_index(), + "Stale or duplicate request", + )?; + continue; + } + last_request = h.request; + if h.kind == STOP { + signals = InputSignals::default(); + state = 2; + epoch = epoch.checked_add(1).ok_or_else(|| invalid("epoch exhausted"))?; + match runner.studio_stop(boot.disposable) { + Ok(()) => { + result( + &transport, + STOP, + h.request, + 0, + epoch, + runner.studio_tick_index(), + "", + )?; + transport.finish(h.request)?; + return Ok(()); + } + Err(error) => { + result( + &transport, + STOP, + h.request, + 2, + epoch, + runner.studio_tick_index(), + &error, + )?; + continue; + } + } + } + if !ready { + result( + &transport, + h.kind, + h.request, + 1, + epoch, + runner.studio_tick_index(), + "Cartridge is not ready", + )?; + continue; + } + match h.kind { + START if state == 0 => { + started = true; + state = 1; + runner.studio_pause(false); + next_tick = Instant::now(); + } + START if state == 2 && !started => { + started = true; + } + PAUSE if state == 1 || state == 0 => { + state = 2; + epoch += 1; + signals = InputSignals::default(); + runner.studio_pause(true); + } + RESUME if state == 2 && started => { + state = 1; + epoch += 1; + signals = InputSignals::default(); + runner.studio_pause(false); + next_tick = Instant::now(); + } + PAUSE if state == 2 => {} + RESUME if state == 1 => {} + _ => { + result( + &transport, + h.kind, + h.request, + 1, + epoch, + runner.studio_tick_index(), + "Invalid execution state", + )?; + continue; + } + } + result(&transport, h.kind, h.request, 0, epoch, runner.studio_tick_index(), "")?; + } + if !ready { + if Instant::now() > boot_deadline { + return Err(invalid("Studio cartridge boot timed out")); + } + ready = runner.studio_boot_step(boot.disposable).map_err(|e| invalid(&e))?; + if ready { + runner.studio_pause(true); + let mut p = Vec::new(); + for n in [width as u32, height as u32, 60, RGBA8] { + p.extend_from_slice(&n.to_le_bytes()); + } + p.extend_from_slice(env!("CARGO_PKG_VERSION").as_bytes()); + transport.send(READY, 0, p)?; + } + } else if state == 1 && Instant::now() >= next_tick { + runner.studio_step(signals).map_err(|e| invalid(&e))?; + next_tick += slice; + if next_tick + Duration::from_millis(100) < Instant::now() { + next_tick = Instant::now(); + } + } + // Completion is asynchronous and can arrive after Pause stopped logical ticks. + if ready && let Some(frame) = runner.studio_frame(last_frame) { + last_frame = Some((frame.ownership, frame.frame_id)); + transport.publish(epoch, frame); + } + std::thread::sleep(Duration::from_millis(1)); + } + })(); + if let Err(error) = &outcome { + eprintln!("[Studio] {error}"); + let _ = transport.send(ERROR, 0, error.to_string().into_bytes()); + runner.studio_abort(); + } + outcome +} diff --git a/crates/host/prometeu-host-desktop-winit/src/studio/platform.rs b/crates/host/prometeu-host-desktop-winit/src/studio/platform.rs new file mode 100644 index 0000000..77bc2b6 --- /dev/null +++ b/crates/host/prometeu-host-desktop-winit/src/studio/platform.rs @@ -0,0 +1,69 @@ +//! Observe complete synchronous submissions without changing machine/render semantics. +use prometeu_drivers::hardware::Hardware; +use prometeu_hal::*; +use prometeu_system::LatestRenderFrameStore; + +pub(crate) struct StudioPlatform<'a> { + pub hardware: &'a mut Hardware, + pub store: &'a LatestRenderFrameStore, +} +impl RenderSubmissionSink for StudioPlatform<'_> { + fn submit_render_submission( + &mut self, + submission: RenderSubmission, + ) -> Result<(), RenderSubmitError> { + let marker = (submission.frame_id, submission.ownership); + self.hardware.submit_render_submission(submission)?; + if marker.1.app_mode == app_mode::AppMode::Game { + let (w, h) = self.hardware.display_size(); + let frame = OwnedRgba8888Frame::packed( + marker.0, + marker.1, + w, + h, + self.hardware.gfx.front_buffer().to_vec(), + ) + .map_err(|_| RenderSubmitError::SubmissionRejected)?; + self.store.publish_frame(frame); + } + Ok(()) + } +} +impl RuntimePlatform for StudioPlatform<'_> { + fn wall_clock(&self) -> &dyn WallClock { + self.hardware.wall_clock() + } + fn display_size(&self) -> (usize, usize) { + self.hardware.display_size() + } + fn render_submission_sink(&mut self) -> &mut dyn RenderSubmissionSink { + self + } + fn render_backend(&mut self) -> &mut dyn RenderBackend { + self.hardware + } + fn game2d_frame_composer(&mut self) -> &mut dyn Game2DFrameComposer { + self.hardware + } + fn audio(&self) -> &dyn AudioBridge { + self.hardware.audio() + } + fn audio_mut(&mut self) -> &mut dyn AudioBridge { + self.hardware.audio_mut() + } + fn input(&self) -> &dyn InputPlatform { + self.hardware.input() + } + fn input_mut(&mut self) -> &mut dyn InputPlatform { + self.hardware.input_mut() + } + fn assets(&self) -> &dyn AssetBridge { + self.hardware.assets() + } + fn assets_mut(&mut self) -> &mut dyn AssetBridge { + self.hardware.assets_mut() + } + fn telemetry(&self) -> &dyn TelemetryPlatform { + self.hardware.telemetry() + } +} diff --git a/crates/host/prometeu-host-desktop-winit/src/studio/transport.rs b/crates/host/prometeu-host-desktop-winit/src/studio/transport.rs new file mode 100644 index 0000000..54f93de --- /dev/null +++ b/crates/host/prometeu-host-desktop-winit/src/studio/transport.rs @@ -0,0 +1,260 @@ +use super::wire::*; +use prometeu_hal::OwnedRgba8888Frame; +use std::io::{self, Read}; +use std::net::{Ipv4Addr, Shutdown, SocketAddr, TcpStream}; +use std::sync::{ + Arc, Condvar, Mutex, + atomic::{AtomicBool, Ordering}, + mpsc::{self, Receiver, SyncSender}, +}; +use std::thread::JoinHandle; +use std::time::{Duration, Instant}; + +struct Publication { + epoch: u64, + frame: Arc, +} +#[derive(Default)] +struct Video { + latest: Option, + flight: Option<(u64, u64)>, +} +struct Shared { + video: Mutex