//! Bounded decoding steps retain progress while the shared lane services saves. use super::*; use prometeu_hal::background_work::{BackgroundWork, WorkStep}; use prometeu_hal::cartridge::AssetsPayloadReader; #[derive(Clone)] pub(super) struct Resources { handles: Arc>, generations: Arc>, source: Arc>, telemetry: Arc>, gfx: BankPolicy, sound: BankPolicy, scene: BankPolicy, } impl Resources { pub(super) fn new(m: &AssetManager) -> Self { Self { handles: m.handles.clone(), generations: m.target_generations.clone(), source: m.assets_data.clone(), telemetry: m.pipeline_telemetry.clone(), gfx: m.gfx_policy.clone(), sound: m.sound_policy.clone(), scene: m.scene_policy.clone(), } } fn current(&self, job: &AssetLoadJob) -> bool { AssetManager::is_current_target_generation( &self.generations, job.slot, job.request_generation, ) } } pub(super) fn schedule( queue: Arc, lane: Arc, resources: Resources, ) { { let mut state = queue.state.lock().unwrap(); if state.scheduled || state.shutdown { return; } state.scheduled = true; } let owner = queue.clone(); let failure_queue = queue.clone(); let failures = resources.clone(); let mut active: Option<(AssetLoadJob, Decoder, Instant)> = None; if lane .submit_asset(Box::new(move |canceled| { if canceled || owner.state.lock().unwrap().shutdown { let mut state = owner.state.lock().unwrap(); state.scheduled = false; state.active = None; return WorkStep::Failed; } if active.is_none() { let job = { let mut state = owner.state.lock().unwrap(); match state.pending.pop_front() { Some(job) => { state.active = Some(job.clone()); job } None => { state.scheduled = false; return WorkStep::Complete; } } }; if !resources.current(&job) { resources.telemetry.lock().unwrap().record_stale_discard(); owner.complete_active(job.handle_id, job.request_generation); return WorkStep::Yield; } if let Some(handle) = resources.handles.write().unwrap().get_mut(&job.handle_id) { handle.status = LoadStatus::LOADING; handle.progress = ASSET_PROGRESS_LOADING; } let start = Instant::now(); resources.telemetry.lock().unwrap().record_started(0); match Decoder::new(&job.entry, &resources.source) { Ok(decoder) => active = Some((job, decoder, start)), Err(_) => { AssetManager::complete_load_job( &resources.handles, &job, LoadStatus::ERROR, ); AssetManager::record_load_job_finished( &resources.telemetry, &job, start, LoadStatus::ERROR, ); owner.complete_active(job.handle_id, job.request_generation); return WorkStep::Yield; } } return WorkStep::Yield; } let (job, decoder, start) = active.as_mut().unwrap(); if !resources.current(job) { resources.telemetry.lock().unwrap().record_stale_discard(); owner.complete_active(job.handle_id, job.request_generation); active = None; return WorkStep::Yield; } match decoder.step() { Ok(None) => WorkStep::Yield, outcome => { let generations = resources.generations.read().unwrap(); let status = if let Ok(Some(bank)) = outcome { if generations.get(&job.slot).copied().unwrap_or(0) == job.request_generation { match bank { Decoded::Glyph(bank) => { let resident = resources.gfx.put_resident( job.asset_id, Arc::new(bank), job.entry.decoded_size as usize, ); resources.gfx.stage( job.handle_id, resident, job.entry.decoded_size as usize, ); } Decoded::Sound(bank) => { let resident = resources.sound.put_resident( job.asset_id, Arc::new(bank), job.entry.decoded_size as usize, ); resources.sound.stage( job.handle_id, resident, job.entry.decoded_size as usize, ); } Decoded::Scene(bank) => { let resident = resources.scene.put_resident( job.asset_id, Arc::new(bank), job.entry.decoded_size as usize, ); resources.scene.stage( job.handle_id, resident, job.entry.decoded_size as usize, ); } } LoadStatus::READY } else { LoadStatus::ERROR } } else { LoadStatus::ERROR }; drop(generations); AssetManager::complete_load_job(&resources.handles, job, status); AssetManager::record_load_job_finished( &resources.telemetry, job, *start, status, ); owner.complete_active(job.handle_id, job.request_generation); active = None; WorkStep::Yield } } })) .is_err() { let mut state = failure_queue.state.lock().unwrap(); state.scheduled = false; for job in state.pending.drain(..) { AssetManager::complete_load_job(&failures.handles, &job, LoadStatus::ERROR); } } } enum Decoded { Glyph(GlyphBank), Sound(SoundBank), Scene(SceneBank), } enum State { Glyph { bank: GlyphBank, packed: usize, position: usize, palette_bytes: usize, palette_position: usize, }, Sound { sample_rate: u32, data: Vec, remaining: usize, }, Scene { layers: [SceneLayer; SCENE_LAYER_COUNT_V1], layer: usize, tiles_left: usize, header: bool, decoded: usize, }, Done, } struct Decoder { reader: AssetsPayloadReader, entry: AssetEntry, state: State, position: usize, } impl Decoder { fn new(entry: &AssetEntry, source: &Arc>) -> Result { let reader = source .read() .unwrap() .open_slice(entry.offset, entry.size) .map_err(|e| e.to_string())? .open_reader() .map_err(|e| e.to_string())?; let state = match entry.bank_type { BankType::GLYPH => { let (tile_size, width, height, packed, palette_count, palette_bytes) = AssetManager::decode_glyph_bank_layout(entry)?; State::Glyph { bank: GlyphBank { tile_size, width, height, pixel_indices: Vec::with_capacity(width * height), palettes: vec![[Color::BLACK; 16]; palette_count], }, packed, position: 0, palette_bytes, palette_position: 0, } } BankType::SOUNDS => { let sample_rate = entry.metadata_as_sound_bank()?.sample_rate; State::Sound { sample_rate, data: Vec::with_capacity(entry.size as usize / 2), remaining: entry.size as usize, } } BankType::SCENE => { entry.metadata_as_scene_bank()?; State::Scene { layers: std::array::from_fn(|_| SceneLayer { active: false, glyph_asset_id: 0, tile_size: TileSize::Size8, parallax_factor: ParallaxFactor { x: 1.0, y: 1.0 }, tilemap: TileMap { width: 0, height: 0, tiles: Vec::new() }, }), layer: 0, tiles_left: 0, header: false, decoded: 0, } } }; Ok(Self { reader, entry: entry.clone(), state, position: 0 }) } fn step(&mut self) -> Result, String> { let mut bytes = [0; 4096]; match &mut self.state { State::Glyph { bank, packed, position, palette_bytes, palette_position } => { if *position < *packed { let n = (*packed - *position).min(bytes.len()); self.reader.read_exact(&mut bytes[..n]).map_err(|e| e.to_string())?; for &v in &bytes[..n] { if bank.pixel_indices.len() < bank.width * bank.height { bank.pixel_indices.push(v >> 4) } if bank.pixel_indices.len() < bank.width * bank.height { bank.pixel_indices.push(v & 15) } } *position += n; return Ok(None); } if *palette_position < *palette_bytes { let n = (*palette_bytes - *palette_position).min(bytes.len()); self.reader.read_exact(&mut bytes[..n]).map_err(|e| e.to_string())?; for (i, rgba) in bytes[..n].as_chunks::<4>().0.iter().enumerate() { let at = *palette_position / 4 + i; bank.palettes[at / 16][at % 16] = Color::rgba(rgba[0], rgba[1], rgba[2], rgba[3]); } *palette_position += n; return Ok(None); } let State::Glyph { bank, .. } = std::mem::replace(&mut self.state, State::Done) else { unreachable!() }; Ok(Some(Decoded::Glyph(bank))) } State::Sound { sample_rate, data, remaining } => { if *remaining > 0 { let n = (*remaining).min(bytes.len()); self.reader.read_exact(&mut bytes[..n]).map_err(|e| e.to_string())?; for pair in bytes[..n].as_chunks::<2>().0 { data.push(i16::from_le_bytes([pair[0], pair[1]])); } *remaining -= n; return Ok(None); } let rate = *sample_rate; let data = std::mem::take(data); self.state = State::Done; Ok(Some(Decoded::Sound(SoundBank::new(vec![Arc::new(Sample::new(rate, data))])))) } State::Scene { layers, layer, tiles_left, header, decoded } => { if !*header { self.reader .read_exact(&mut bytes[..SCENE_HEADER_BYTES_V1]) .map_err(|e| e.to_string())?; if bytes[..4] != SCENE_PAYLOAD_MAGIC_V1 || u16::from_le_bytes([bytes[4], bytes[5]]) != SCENE_PAYLOAD_VERSION_V1 || u16::from_le_bytes([bytes[6], bytes[7]]) as usize != SCENE_LAYER_COUNT_V1 { return Err("Invalid scene header".into()); } self.position += SCENE_HEADER_BYTES_V1; *header = true; return Ok(None); } if *tiles_left > 0 { let n = (*tiles_left).min(bytes.len() / SCENE_TILE_RECORD_BYTES_V1); let count = n * SCENE_TILE_RECORD_BYTES_V1; self.reader.read_exact(&mut bytes[..count]).map_err(|e| e.to_string())?; for b in bytes[..count].as_chunks::().0 { layers[*layer - 1].tilemap.tiles.push(Tile { active: b[0] & 1 != 0, glyph: Glyph { glyph_id: u16::from_le_bytes([b[2], b[3]]), palette_id: b[1], }, flip_x: b[0] & 2 != 0, flip_y: b[0] & 4 != 0, }); } *tiles_left -= n; self.position += count; return Ok(None); } if *layer < layers.len() { self.reader .read_exact(&mut bytes[..SCENE_LAYER_HEADER_BYTES_V1]) .map_err(|e| e.to_string())?; self.position += SCENE_LAYER_HEADER_BYTES_V1; let u32at = |at| u32::from_le_bytes(bytes[at..at + 4].try_into().unwrap()); let width = u32at(16) as usize; let height = u32at(20) as usize; let count = u32at(24) as usize; let tile_size = match bytes[5] { 8 => TileSize::Size8, 16 => TileSize::Size16, 32 => TileSize::Size32, _ => return Err("Invalid scene tile size".into()), }; let x = f32::from_le_bytes(bytes[8..12].try_into().unwrap()); let y = f32::from_le_bytes(bytes[12..16].try_into().unwrap()); if !x.is_finite() || !y.is_finite() || width.checked_mul(height) != Some(count) || count .checked_mul(SCENE_TILE_RECORD_BYTES_V1) .and_then(|n| n.checked_add(self.position)) .is_none_or(|n| n as u64 > self.entry.size) { return Err("Invalid scene layer range".into()); } *decoded = decoded .checked_add(SCENE_DECODED_LAYER_OVERHEAD_BYTES_V1) .and_then(|n| { count.checked_mul(size_of::()).and_then(|b| n.checked_add(b)) }) .ok_or("Scene size overflow")?; layers[*layer] = SceneLayer { active: bytes[0] & 1 != 0, glyph_asset_id: i32::from_le_bytes(bytes[1..5].try_into().unwrap()), tile_size, parallax_factor: ParallaxFactor { x, y }, tilemap: TileMap { width, height, tiles: Vec::with_capacity(count) }, }; *layer += 1; *tiles_left = count; return Ok(None); } if self.position as u64 != self.entry.size || *decoded as u64 != self.entry.decoded_size { return Err("Invalid scene payload size".into()); } let State::Scene { layers, .. } = std::mem::replace(&mut self.state, State::Done) else { unreachable!() }; Ok(Some(Decoded::Scene(SceneBank { layers }))) } State::Done => Err("Decoder already complete".into()), } } } #[cfg(test)] mod tests { use super::*; use prometeu_hal::background_work::{AssetWork, WorkUnavailable}; #[derive(Default)] struct ManualLane(Mutex>); impl BackgroundWork for ManualLane { fn submit_asset(&self, work: AssetWork) -> Result<(), WorkUnavailable> { self.0.lock().unwrap().push_back(work); Ok(()) } } impl ManualLane { fn step(&self) -> bool { let Some(mut work) = self.0.lock().unwrap().pop_front() else { return false }; if work(false) == WorkStep::Yield { self.0.lock().unwrap().push_back(work); } true } } #[test] fn shared_decoder_yields_and_matches_existing_glyph_format() { let mut data = vec![0x12; 32]; data.extend([255; 64]); let entry = AssetEntry { asset_id: 7, asset_name: "glyph".into(), bank_type: BankType::GLYPH, codec: AssetCodec::None, offset: 0, size: data.len() as u64, decoded_size: 128, metadata: serde_json::json!({"tile_size":8,"width":8,"height":8,"palette_count":1,"palette_authored":1}), }; let expected = AssetManager::decode_glyph_bank_from_buffer(&entry, &data).unwrap(); let banks = Arc::new(crate::memory_banks::MemoryBanks::new()); let mut manager = AssetManager::new( vec![entry], AssetsPayloadSource::from_bytes(data), banks.clone(), banks.clone(), banks, ); let lane = Arc::new(ManualLane::default()); assert!(manager.bind_background_work(lane.clone())); let handle = manager.load(7, 0).unwrap(); let mut steps = 0; while lane.step() { steps += 1; assert!(steps < 20); } assert!(steps >= 4); assert_eq!(manager.status(handle), LoadStatus::READY); let staging = manager.gfx_policy.staging.read().unwrap(); let (actual, _) = staging.get(&handle).unwrap(); assert_eq!(actual.pixel_indices, expected.pixel_indices); assert_eq!(actual.palettes, expected.palettes); } fn decode_in_steps(entry: &AssetEntry, bytes: Vec) -> Decoded { let source = Arc::new(RwLock::new(AssetsPayloadSource::from_bytes(bytes))); let mut decoder = Decoder::new(entry, &source).unwrap(); for _ in 0..100 { if let Some(result) = decoder.step().unwrap() { return result; } } panic!("decoder did not finish") } #[test] fn resumable_sound_and_scene_preserve_existing_formats() { let pcm: Vec = (0..5000).map(|n| n as i16 - 2500).collect(); let bytes: Vec = pcm.iter().flat_map(|n| n.to_le_bytes()).collect(); let entry = AssetEntry { asset_id: 1, asset_name: "pcm".into(), bank_type: BankType::SOUNDS, offset: 0, size: bytes.len() as u64, decoded_size: bytes.len() as u64, codec: AssetCodec::None, metadata: serde_json::json!({"sample_rate":44100,"channels":1}), }; let Decoded::Sound(bank) = decode_in_steps(&entry, bytes) else { panic!() }; assert_eq!(bank.samples[0].data, pcm); let scene = crate::asset::tests::test_scene(); let bytes = crate::asset::tests::encode_scene_payload(&scene); let entry = crate::asset::tests::test_scene_asset_entry("scene", &bytes, &scene); let Decoded::Scene(actual) = decode_in_steps(&entry, bytes) else { panic!() }; for (a, b) in actual.layers.iter().zip(scene.layers.iter()) { assert_eq!(a.active, b.active); assert_eq!(a.glyph_asset_id, b.glyph_asset_id); assert_eq!(a.tile_size, b.tile_size); assert_eq!(a.parallax_factor.x, b.parallax_factor.x); assert_eq!(a.tilemap.width, b.tilemap.width); assert_eq!(a.tilemap.height, b.tilemap.height); assert_eq!(a.tilemap.tiles.len(), b.tilemap.tiles.len()); for (x, y) in a.tilemap.tiles.iter().zip(&b.tilemap.tiles) { assert_eq!( (x.active, x.glyph.glyph_id, x.glyph.palette_id, x.flip_x, x.flip_y), (y.active, y.glyph.glyph_id, y.glyph.palette_id, y.flip_x, y.flip_y) ); } } } #[test] fn shared_preload_waits_for_worker_and_frame_publication() { let bytes = vec![0; 8192]; let entry = AssetEntry { asset_id: 1, asset_name: "pcm".into(), bank_type: BankType::SOUNDS, offset: 0, size: bytes.len() as u64, decoded_size: bytes.len() as u64, codec: AssetCodec::None, metadata: serde_json::json!({"sample_rate":44100,"channels":1}), }; let banks = Arc::new(crate::memory_banks::MemoryBanks::new()); let mut manager = AssetManager::new( vec![], AssetsPayloadSource::empty(), banks.clone(), banks.clone(), banks, ); let lane = Arc::new(ManualLane::default()); assert!(manager.bind_background_work(lane.clone())); manager.initialize_for_cartridge( vec![entry], vec![PreloadEntry { asset_id: 1, slot: 0 }], AssetsPayloadSource::from_bytes(bytes), ); assert_eq!(manager.preloads_ready(), Ok(false)); while lane.step() {} assert_eq!(manager.preloads_ready(), Ok(false)); manager.apply_commits(); assert_eq!(manager.preloads_ready(), Ok(true)); assert_eq!(manager.slot_info(SlotRef::audio(0)).asset_id, Some(1)); } }