ProCraft for Android: An Android native painting app written in Rust
Rust
fix(layers): large artworks open, save and close without holding up the app or its memory
Joshd557ba00e156
diff --git a/apps/procraft-android/android/app/src/main/java/io/github/artcraftandroid/procraft/canvas/CanvasViewModel.kt b/apps/procraft-android/android/app/src/main/java/io/github/artcraftandroid/procraft/canvas/CanvasViewModel.ktindex dd1fe3f..ebc95aa 100644--- a/apps/procraft-android/android/app/src/main/java/io/github/artcraftandroid/procraft/canvas/CanvasViewModel.kt+++ b/apps/procraft-android/android/app/src/main/java/io/github/artcraftandroid/procraft/canvas/CanvasViewModel.kt@@ -1728,7 +1728,11 @@ class CanvasViewModel(app: Application) : AndroidViewModel(app) {panel = Panel.NONEscreen = Screen.GALLERYviewModelScope.launch {- withContext(Dispatchers.IO) { dir?.let { runCatching { s.save(it.path) } } }+ withContext(Dispatchers.IO) {+ dir?.let { runCatching { s.save(it.path) } }+ // its memory free at once, not when the object is collected+ s.releaseCanvas()+ }galleryVersion++refreshGallery()}diff --git a/apps/procraft-android/src/lib.rs b/apps/procraft-android/src/lib.rsindex c919591..a684494 100644--- a/apps/procraft-android/src/lib.rs+++ b/apps/procraft-android/src/lib.rs@@ -321,6 +321,8 @@ pub(crate) struct State {pub(crate) info: project::ArtworkInfo,/// Saved layer pixels waiting for the canvas (an opened artwork before it is shown).pub(crate) pending_pixels: Vec<(procraft_engine::document::LayerId, project::Opened)>,+ /// Let go of (see [`CanvasSession::release_canvas`]): no canvas is made again.+ pub(crate) closed: bool,/// A model open to paint on, in place of the flat canvas (the document is its current/// texture set's).pub(crate) scene: Option<scene3d::Scene>,@@ -549,7 +551,7 @@ impl State {/// Creates the canvas once there is a GPU.#[cfg_attr(not(any(target_os = "android", test)), allow(dead_code))]pub(crate) fn ensure_canvas(&mut self) {- if self.canvas.is_some() {+ if self.canvas.is_some() || self.closed {return;}let Some(gpu) = self.gpu.as_ref() else { return };@@ -565,6 +567,8 @@ impl State {log::error!("opening a layer: {e}");}}+ // as read: not changed+ c.take_changed();self.canvas = Some(c);}Err(e) => {@@ -664,7 +668,7 @@ impl Shared {pub(crate) fn make_canvas(&self) {let (gpu, doc, ids) = {let st = self.lock();- let Some(gpu) = st.gpu.as_ref().filter(|_| st.canvas.is_none()) else { return };+ let Some(gpu) = st.gpu.as_ref().filter(|_| st.canvas.is_none() && !st.closed) else { return };(gpu.clone(), st.doc.clone(), st.pending_pixels.iter().map(|(id, _)| *id).collect::<Vec<_>>())};let made = Canvas::new(&gpu, &doc).map(|mut c| {@@ -676,6 +680,9 @@ impl Shared {};match layer.pixels(doc.width(), doc.height()) {Ok(pixels) => {+ if let Ok(mut saved) = self.saving.lock() {+ saved.read(*id, &pixels);+ }// past what fits, kept compressed until neededlet opened =if c.has_room() { c.upload_layer(&gpu, *id, &pixels) } else { c.park_pixels(*id, &pixels) };@@ -686,6 +693,8 @@ impl Shared {Err(e) => log::error!("layer {id:?}: {e}"),}}+ // as read: not changed+ c.take_changed();c});let mut st = self.lock();@@ -827,6 +836,7 @@ impl CanvasSession {guide_before: None,name,pending_pixels: project::opened(pixels),+ closed: false,fit_insets: [0.0; 4],backdrops: Vec::new(),saved_view: None,@@ -1197,6 +1207,17 @@ impl CanvasSession {self.shared.lock().fit_insets = [left, top, right, bottom];}+ /// Lets go of the canvas and everything it holds, on the GPU and off it (its layers, parked+ /// or not, and a model's), once the artwork is saved and left: a large artwork's memory is+ /// free at once rather than whenever this object is collected. Nothing is drawn after.+ pub fn release_canvas(&self) {+ let mut st = self.shared.lock();+ st.closed = true;+ st.canvas = None;+ st.pending_pixels.clear();+ st.scene = None;+ }+/// The artwork opens fitted, not as it was left (Canvas Orientation Memory off).pub fn forget_saved_view(&self) {self.shared.lock().saved_view = None;diff --git a/apps/procraft-android/src/project.rs b/apps/procraft-android/src/project.rsindex fc1c4cc..5d6244f 100644--- a/apps/procraft-android/src/project.rs+++ b/apps/procraft-android/src/project.rs@@ -107,6 +107,8 @@ pub(crate) fn file_error(context: &str, e: impl std::fmt::Display) -> MobileErro/// What a save writes, read under the lock: the artwork's file, the layers not already in the/// folder as they are (each with its hash) and the picture (if shown).pub(crate) struct SaveSnapshot {+ /// The layers that had changed, counted as changed again if the save fails.+ changed: Vec<LayerId>,file: ArtworkFile,layers: Vec<(LayerId, u64, Vec<u8>)>,/// Layers still the PNG files they were opened from (not shown yet), written as they are.@@ -129,6 +131,18 @@ impl Saved {pub(crate) fn known(&self, dir: &Path) -> std::collections::HashMap<LayerId, u64> {if self.dir == dir { self.layers.clone() } else { Default::default() }}++ /// An artwork opened from `dir`: its layer files are what the last save there wrote, their+ /// hashes known as each is read ([`Saved::read`]).+ pub(crate) fn opened(&mut self, dir: &Path) {+ self.dir = dir.to_path_buf();+ self.layers.clear();+ }++ /// Layer `id` read from its file with these pixels: a save that finds it unchanged leaves it.+ pub(crate) fn read(&mut self, id: LayerId, rgba: &[u8]) {+ self.layers.insert(id, pixels_hash(rgba));+ }}/// A quick hash of pixels, to tell a changed layer from one saved already.@@ -193,9 +207,19 @@ impl crate::State {let mut layers = Vec::new();let mut files = Vec::new();let mut composite = None;+ let mut changed_ids = Vec::new();if let (Some(canvas), Some(gpu)) = (self.canvas.as_mut(), self.gpu.as_ref()) {canvas.render(gpu, &mut self.doc, None);+ let changed_now = canvas.take_changed();+ changed_ids = changed_now.iter().copied().collect();for layer in self.doc.layers() {+ // unchanged since it was read or saved, its file there: left as it is, unread+ if !changed_now.contains(&layer.id)+ && known.contains_key(&layer.id)+ && layer_path(dir, layer.id).exists()+ {+ continue;+ }let rgba = canvas.read_layer(gpu, layer.id).map_err(|e| file_error("reading a layer", e))?;layers.extend(changed(layer.id, rgba));}@@ -220,14 +244,31 @@ impl crate::State {}}}- Ok(SaveSnapshot { file, layers, files, composite, model })+ Ok(SaveSnapshot { changed: changed_ids, file, layers, files, composite, model })+ }+}++/// Writes a save; if it fails, the layers it had as changed count as changed again.+fn write_or_keep_changed(+ session: &CanvasSession,+ saved: &mut Saved,+ dir: &Path,+ snapshot: SaveSnapshot,+) -> Result<(), MobileError> {+ let changed = snapshot.changed.clone();+ let result = write_artwork(saved, dir, snapshot);+ if result.is_err()+ && let Some(canvas) = session.shared.lock().canvas.as_mut()+ {+ canvas.mark_changed(changed);}+ result}/// Writes a save into `dir` (made if missing): the layers that changed since the last save there,/// the thumbnail and the document.fn write_artwork(saved: &mut Saved, dir: &Path, snapshot: SaveSnapshot) -> Result<(), MobileError> {- let SaveSnapshot { file, layers, files, composite, model } = snapshot;+ let SaveSnapshot { file, layers, files, composite, model, .. } = snapshot;if saved.dir != dir {saved.dir = dir.to_path_buf();saved.layers.clear();@@ -354,6 +395,8 @@ impl CanvasSession {}let scene = file.model.as_ref().map(|m| crate::scene3d::open_saved_model(&dir, m)).transpose()?;let session = CanvasSession::with_document(doc, file.name, Vec::new());+ // its files are as the last save left them: one unchanged since isn't written again+ session.shared.saving.lock().unwrap_or_else(|e| e.into_inner()).opened(&dir);{let mut st = session.shared.lock();st.pending_pixels = pngs;@@ -377,7 +420,7 @@ impl CanvasSession {let known = saved.known(Path::new(&dir));st.with_colour(|st| st.save_snapshot(Path::new(&dir), &known))?};- write_artwork(&mut saved, Path::new(&dir), snapshot)+ write_or_keep_changed(self, &mut saved, Path::new(&dir), snapshot)}/// Saves as [`CanvasSession::save`] does, but only when nothing is under way that saving@@ -394,7 +437,7 @@ impl CanvasSession {let known = saved.known(Path::new(&dir));st.with_colour(|st| st.save_snapshot(Path::new(&dir), &known))?};- write_artwork(&mut saved, Path::new(&dir), snapshot).map(|()| true)+ write_or_keep_changed(self, &mut saved, Path::new(&dir), snapshot).map(|()| true)}/// A number that changes whenever the artwork does (new steps, undo and redo, layerdiff --git a/apps/procraft-android/src/tests.rs b/apps/procraft-android/src/tests.rsindex 52cf641..72003b4 100644--- a/apps/procraft-android/src/tests.rs+++ b/apps/procraft-android/src/tests.rs@@ -370,6 +370,19 @@ fn artworks_save_and_open() {// as the render thread makes it: the layers go up with the state let go between themopened.shared.make_canvas();assert!(opened.shared.lock().pending_pixels.is_empty());+ // shown, and nothing changed: its files are known as read, so a save rewrites none+ let before = written(&dir);+ opened.save(dir.to_string_lossy().into_owned()).unwrap();+ assert_eq!(written(&dir), before, "unchanged layers left as they were");+ // a stroke on the bottom layer: only its file is written again+ let bottom = opened.layers().first().map(|l| l.id).unwrap();+ assert!(opened.select_layer(bottom));+ opened.stroke_begin(PointerKind::Finger, vec![sample(50.0, 50.0, 0.0)]);+ opened.stroke_end(vec![]);+ opened.save(dir.to_string_lossy().into_owned()).unwrap();+ let after = written(&dir);+ assert_ne!(after.first(), before.first(), "the painted layer written");+ assert_eq!(after.get(1), before.get(1), "the other left as it was");assert_eq!(opened.name(), "Test Piece");assert_eq!(opened.artwork_info().author, "A. Painter");assert_eq!(opened.artwork_info().created_ms, info.created_ms);diff --git a/crates/gpu/src/canvas.rs b/crates/gpu/src/canvas.rsindex fb5d9ea..87936be 100644--- a/crates/gpu/src/canvas.rs+++ b/crates/gpu/src/canvas.rs@@ -1203,6 +1203,11 @@ pub struct Canvas {/// Layers' pixels kept compressed off the GPU: those parked (no texture), and copies of/// resident ones unchanged since, so that letting them go again costs nothing.parked: HashMap<LayerId, Vec<u8>>,+ /// Small pictures of the parked layers, so their thumbnails need no texture.+ pictures: HashMap<LayerId, Pictures>,+ /// Layers whose pixels changed since [`Canvas::take_changed`] took them, so a save reads only+ /// those.+ changed: HashSet<LayerId>,/// What the layers' textures may take before those needed least lately are parked (0: none/// are), and when each was last needed, counted in renders.resident_budget: u64,@@ -1404,6 +1409,8 @@ impl Canvas {cache_composites: false,caches: None,parked: HashMap::new(),+ pictures: HashMap::new(),+ changed: HashSet::new(),resident_budget: 0,needed_at: HashMap::new(),renders: 0,@@ -1864,6 +1871,25 @@ impl Canvas {self.set_cache_composites(bytes > 0);}+ /// A parked layer's small pictures, if they are big enough for a thumbnail `max_side` across.+ fn parked_pictures(&self, id: LayerId, max_side: u32) -> Option<&Pictures> {+ if self.layers.contains_key(&id) || max_side > PARKED_PICTURE_SIDE {+ return None;+ }+ self.pictures.get(&id)+ }++ /// The layers whose pixels changed since this was last done (by painting, undo, uploads and+ /// every other change), forgotten here: a save reads only these.+ pub fn take_changed(&mut self) -> HashSet<LayerId> {+ std::mem::take(&mut self.changed)+ }++ /// Layers to count as changed again (a save of them that failed).+ pub fn mark_changed(&mut self, ids: impl IntoIterator<Item = LayerId>) {+ self.changed.extend(ids);+ }+/// How many layers are parked (kept compressed, without a texture).pub fn parked_layers(&self) -> usize {self.parked.keys().filter(|id| !self.layers.contains_key(*id)).count()@@ -1904,6 +1930,8 @@ impl Canvas {let restored = !self.layers.contains_key(&id) && self.restore(gpu, id);if written {self.parked.remove(&id);+ self.pictures.remove(&id);+ self.changed.insert(id);}self.needed_at.insert(id, self.renders);// the staged pixels sent on now and then, so many in a row don't pile up@@ -1983,6 +2011,7 @@ impl Canvas {}if !self.parked.contains_key(&id) {let Ok(pixels) = self.read_layer(gpu, id) else { continue };+ self.pictures.insert(id, Pictures::of(&pixels, self.width, self.height));self.parked.insert(id, procraft_engine::applz4::encode(&pixels));}self.layers.remove(&id);@@ -2313,6 +2342,7 @@ impl Canvas {}self.layers.retain(|id, _| keep.contains(id));self.parked.retain(|id, _| keep.contains(id));+ self.pictures.retain(|id, _| keep.contains(id));self.needed_at.retain(|id, _| keep.contains(id));}@@ -4014,6 +4044,7 @@ impl Canvas {return Err(GpuError::Readback(format!("layer {id:?}: {} bytes, expected {expected}", rgba.len())));}self.layers.remove(&id);+ self.pictures.insert(id, Pictures::of(rgba, self.width, self.height));self.parked.insert(id, procraft_engine::applz4::encode(rgba));self.caches = None;self.invalidate();@@ -4632,6 +4663,10 @@ impl Canvas {max_side: u32,) -> Result<Thumbnail, GpuError> {self.render(gpu, doc, None);+ let mask = doc.layer(id).is_some_and(|l| l.kind == LayerKind::Mask);+ if let Some(p) = self.parked_pictures(id, max_side).filter(|_| !mask) {+ return Ok(shrink(p.drawn.as_ref().unwrap_or(&p.whole), max_side));+ }self.restore_all(gpu, [id], false);let full = self.full();// a mask is white where nothing is painted on it@@ -4669,15 +4704,21 @@ impl Canvas {return Ok(Vec::new());}self.render(gpu, doc, None);- let ids: Vec<LayerId> = doc- .layers()+ let paint: Vec<LayerId> = doc.layers().iter().filter(|l| l.kind == LayerKind::Paint).map(|l| l.id).collect();+ let ids: Vec<LayerId> = paint.iter().copied().filter(|id| self.layers.contains_key(id)).collect();+ // a parked layer's from its small picture+ let parked: HashMap<LayerId, u8> = paint.iter()- .filter(|l| l.kind == LayerKind::Paint)- .map(|l| l.id)- .filter(|id| self.layers.contains_key(id))+ .filter(|id| !self.layers.contains_key(*id))+ .filter_map(|id| {+ let w = &self.pictures.get(id)?.whole;+ let px = (u64::from(x) * u64::from(w.width) / u64::from(self.width.max(1))) as usize;+ let py = (u64::from(y) * u64::from(w.height) / u64::from(self.height.max(1))) as usize;+ Some((*id, *w.rgba.get((py * w.width as usize + px) * 4 + 3)?))+ }).collect();if ids.is_empty() {- return Ok(Vec::new());+ return Ok(paint.iter().filter_map(|id| Some((*id, *parked.get(id)?))).collect());}// one pixel of each layer, each in its own 256-byte row of a bufferlet buffer = gpu.device.create_buffer(&wgpu::BufferDescriptor {@@ -4711,10 +4752,12 @@ impl Canvas {gpu.device.poll(wgpu::PollType::wait_indefinitely()).map_err(|e| GpuError::Readback(e.to_string()))?;rx.recv().map_err(|e| GpuError::Readback(e.to_string()))?.map_err(|e| GpuError::Readback(e.to_string()))?;let mapped = buffer.slice(..).get_mapped_range().map_err(|e| GpuError::Readback(e.to_string()))?;- let out = ids.iter().enumerate().map(|(i, id)| (*id, mapped.get(256 * i + 3).copied().unwrap_or(0))).collect();+ let read: HashMap<LayerId, u8> =+ ids.iter().enumerate().map(|(i, id)| (*id, mapped.get(256 * i + 3).copied().unwrap_or(0))).collect();drop(mapped);buffer.unmap();- Ok(out)+ // in the document's order, parked or not+ Ok(paint.iter().filter_map(|id| Some((*id, *read.get(id).or_else(|| parked.get(id))?))).collect())}/// Layer `id` over the whole canvas (not cropped to what is drawn) fitted to `max_side`, as@@ -4727,6 +4770,9 @@ impl Canvas {max_side: u32,) -> Result<Thumbnail, GpuError> {self.render(gpu, doc, None);+ if let Some(p) = self.parked_pictures(id, max_side) {+ return Ok(shrink(&p.whole, max_side));+ }self.restore_all(gpu, [id], false);let full = self.full();self.sample_layer(gpu, id, full, max_side)@@ -4790,6 +4836,7 @@ impl Canvas {}let Some(layer) = self.layers.get(&id) else { return Ok(()) };self.caches = None;+ self.changed.insert(id);gpu.queue.write_texture(copy_at(&layer.texture, 0, 0),rgba,@@ -5537,6 +5584,61 @@ fn painted_bounds(t: &Thumbnail, painted: impl Fn([u8; 4]) -> bool) -> Option<[ub}+/// The longest side of a parked layer's small pictures, pixels: as big as any thumbnail asked for.+const PARKED_PICTURE_SIDE: u32 = 192;++/// A parked layer's small pictures: the whole layer, and what is drawn on it (none if nothing).+struct Pictures {+ whole: Thumbnail,+ drawn: Option<Thumbnail>,+}++impl Pictures {+ /// Of a layer's pixels (premultiplied RGBA, `width` x `height`).+ fn of(rgba: &[u8], width: u32, height: u32) -> Pictures {+ let full = Thumbnail { width, height, rgba: rgba.to_vec() };+ let whole = shrink(&full, PARKED_PICTURE_SIDE);+ let drawn = alpha_bounds(&full).map(|b| shrink(&crop(&full, b), PARKED_PICTURE_SIDE));+ Pictures { whole, drawn }+ }+}++/// A picture box-filtered to fit `side` pixels (never enlarged).+fn shrink(t: &Thumbnail, side: u32) -> Thumbnail {+ let (width, height) = (t.width.max(1), t.height.max(1));+ let scale = (side.max(1) as f32 / width.max(height) as f32).min(1.0);+ let w = ((width as f32 * scale).round() as u32).clamp(1, width);+ let h = ((height as f32 * scale).round() as u32).clamp(1, height);+ if (w, h) == (width, height) {+ return Thumbnail { width, height, rgba: t.rgba.clone() };+ }+ let mut sums = vec![0u32; w as usize * h as usize * 4];+ let mut counts = vec![0u32; w as usize * h as usize];+ for (y, row) in t.rgba.chunks_exact(width as usize * 4).enumerate() {+ let ty = (y as u64 * u64::from(h) / u64::from(height)) as usize;+ for (x, px) in row.as_chunks::<4>().0.iter().enumerate() {+ let tx = (x as u64 * u64::from(w) / u64::from(width)) as usize;+ let i = ty * w as usize + tx;+ if let Some(c) = counts.get_mut(i) {+ *c += 1;+ }+ for (k, v) in px.iter().enumerate() {+ if let Some(sum) = sums.get_mut(i * 4 + k) {+ *sum += u32::from(*v);+ }+ }+ }+ }+ let rgba = sums+ .as_chunks::<4>()+ .0+ .iter()+ .zip(&counts)+ .flat_map(|(sum, n)| sum.iter().map(move |v| ((v + n / 2) / (*n).max(1)) as u8).collect::<Vec<_>>())+ .collect();+ Thumbnail { width: w, height: h, rgba }+}+/// Part [x0, y0, x1, y1) of a thumbnail.fn crop(t: &Thumbnail, [x0, y0, x1, y1]: [u32; 4]) -> Thumbnail {let row = t.width as usize * 4;diff --git a/crates/gpu/tests/layers.rs b/crates/gpu/tests/layers.rsindex 5b368fb..f8068bf 100644--- a/crates/gpu/tests/layers.rs+++ b/crates/gpu/tests/layers.rs@@ -470,6 +470,19 @@ fn parked_layers_come_back_as_they_were() {pictures.push(canvas.layer_picture(&gpu, doc, low, 8).unwrap().rgba);}assert_eq!(pictures[0], pictures[1], "its picture");+ let mut thumbs = Vec::new();+ for (doc, canvas) in t.docs.iter_mut().zip(t.canvases.iter_mut()) {+ thumbs.push(canvas.layer_thumbnail(&gpu, doc, low, 8).unwrap().rgba);+ }+ assert_eq!(thumbs[0], thumbs[1], "its thumbnail");+ // every layer's coverage at a point, parked ones too+ for (x, y) in [(2, 2), (8, 8), (13, 9)] {+ let mut alphas = Vec::new();+ for (doc, canvas) in t.docs.iter_mut().zip(t.canvases.iter_mut()) {+ alphas.push(canvas.alphas_at(&gpu, doc, x, y).unwrap());+ }+ assert_eq!(alphas[0], alphas[1], "coverage at {x}, {y}");+ }// merged down, duplicated, hidden: the layers they read and write come back firstlet (upper, lower) = (ids[5], ids[4]);t.each(|doc, canvas| {