Skip to content

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.kt
index 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.NONE
screen = Screen.GALLERY
viewModelScope.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.rs
index 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 needed
let 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.rs
index 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, layer
diff --git a/apps/procraft-android/src/tests.rs b/apps/procraft-android/src/tests.rs
index 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 them
opened.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.rs
index 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 buffer
let 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<[u
b
}
+/// 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.rs
index 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 first
let (upper, lower) = (ids[5], ids[4]);
t.each(|doc, canvas| {