use super::content::RENDER_TILE; use super::ctx::Ctx; use super::render::{band_rows_for, render, render_bands, render_tiled_with}; use super::{Buffer, Document, Rect, Rgba8Image, pattern, proxy, uniform}; /// Documents above this many pixels get thumbnails from a proxy (see [`proxy`]) when that is /// faithful; smaller ones are reduced from the exact composite. pub const PROXY_THUMBNAIL_PIXELS: u64 = 16 << 20; /// Downscaled RGBA8 render of the document (area-averaged) for thumbnails, navigators and /// histograms, at most `max_side` pixels on its longer side. Large documents are reduced from a /// downsampled proxy (about twice the thumbnail's size), so a thumbnail of a 200 MP document /// costs milliseconds and no full-size composite; the rest stream the exact composite in bands. pub fn thumbnail(doc: &Document, max_side: u32) -> Rgba8Image { thumbnail_buffer(doc, max_side).to_rgba8() } /// Width and height of [`thumbnail`]`(doc, max_side)`. pub fn thumbnail_size(doc: &Document, max_side: u32) -> (u32, u32) { let b = doc.bounds(); let longest = b.width().max(b.height()).max(1); let scale = (max_side as f32 / longest as f32).min(1.0); (((b.width() as f32 * scale).round() as u32).max(1), ((b.height() as f32 * scale).round() as u32).max(1)) } /// [`thumbnail`] as straight-alpha floats (for callers that colour-convert it first). pub fn thumbnail_buffer(doc: &Document, max_side: u32) -> Buffer { let b = doc.bounds(); let longest = b.width().max(b.height()).max(1); let (w, h) = thumbnail_size(doc, max_side); let k = longest / max_side.max(1).saturating_mul(2); if k >= 2 && doc.size.area() > PROXY_THUMBNAIL_PIXELS && proxy::proxy_faithful(doc) { render_reduced(&proxy::proxy_document(doc, k), w, h) } else { render_reduced(doc, w, h) } } /// The document's composite area-averaged (premultiplied) down to `w`×`h` (clamped to the /// document size), rendered in bands so no full-size composite is held. pub fn render_reduced(doc: &Document, w: u32, h: u32) -> Buffer { render_reduced_in_bands(doc, doc.bounds(), w, h, None, 0) } /// [`render_reduced`] of any area of the document plane, `rect`, which may lie past the canvas /// (layer pixels there are kept until a crop deletes them). The buffer's rect is in output pixels /// from (0, 0). pub fn render_reduced_rect(doc: &Document, rect: Rect, w: u32, h: u32) -> Buffer { render_reduced_in_bands(doc, rect, w, h, None, 0) } /// The part of [`render_reduced`]`(doc, w, h)` that a change to `damage` (document pixels) can /// affect: the output pixels whose source areas meet it, rendered from just those areas, with the /// same values the whole reduction gives them. The buffer's rect is in output pixels (empty when /// `damage` misses the document), so a reduced canvas texture can update only what a stroke touched. pub fn render_reduced_damage(doc: &Document, w: u32, h: u32, damage: Rect) -> Buffer { render_reduced_in_bands(doc, doc.bounds(), w, h, Some(damage), 0) } /// [`render_reduced_rect`] (or, with `damage`, [`render_reduced_damage`]) of area `b` with an /// explicit band height (see [`render_bands`]). pub(crate) fn render_reduced_in_bands(doc: &Document, b: Rect, w: u32, h: u32, damage: Option, band_rows: i32) -> Buffer { render_reduced_with(doc, b, w, h, damage, band_rows, true, &mut ReducedStats::default()) } /// What a reduced render composited (tests check that one-colour areas are not composited). #[derive(Debug, Default)] pub(crate) struct ReducedStats { /// Whether one-colour areas were looked for ([`uniform::UniformAreas`]). pub(crate) uniform: bool, /// Document pixels composited one by one. pub(crate) composited: u64, } /// A tile of a reduced render: one colour (premultiplied), or its composited pixels. enum Part { Solid([f32; 4]), Px(Buffer), } /// A column of document tiles in a reduced render (`b`-relative source columns). struct TileColumn { /// The columns rendered: the tile's, within the source area. x0: usize, x1: usize, /// The whole tile's columns within `b`, whose values decide whether it is one colour. whole: (i64, i64), /// Runs of (output column, how many of the rendered columns it averages). runs: Vec<(usize, f32)>, } /// [`render_reduced_in_bands`]; `uniform` off composites every pixel (the reference in tests). #[allow(clippy::too_many_arguments)] pub(crate) fn render_reduced_with( doc: &Document, b: Rect, w: u32, h: u32, damage: Option, band_rows: i32, uniform: bool, stats: &mut ReducedStats, ) -> Buffer { let (fw, fh) = (b.width() as usize, b.height() as usize); let (w, h) = (w.clamp(1, b.width().max(1)) as usize, h.clamp(1, b.height().max(1)) as usize); let full = Rect::from_xywh(0, 0, w as u32, h as u32); if fw == 0 || fh == 0 { return Buffer::transparent(if damage.is_some() { Rect::EMPTY } else { full }); } // Output column / row of each document column / row: output pixel t covers [t·f/n, (t+1)·f/n). let span = |t: usize, f: usize, n: usize| (t * f / n, ((t + 1) * f / n).max(t * f / n + 1).min(f)); // The output pixel whose span holds document column / row `x` (spans are contiguous: n <= f). let cell = |x: usize, f: usize, n: usize| ((x + 1) * n).saturating_sub(1) / f; // Output pixels to produce and the document area they cover. let out = match damage { None => full, Some(d) => { let d = d.intersect(&b); if d.is_empty() { return Buffer::transparent(Rect::EMPTY); } let (x0, x1) = ((d.x0 - b.x0) as usize, (d.x1 - b.x0) as usize); let (y0, y1) = ((d.y0 - b.y0) as usize, (d.y1 - b.y0) as usize); Rect::new(cell(x0, fw, w) as i32, cell(y0, fh, h) as i32, cell(x1 - 1, fw, w) as i32 + 1, cell(y1 - 1, fh, h) as i32 + 1) } }; let (ox0, oy0, ow, oh) = (out.x0 as usize, out.y0 as usize, out.width() as usize, out.height() as usize); let (sx0, sx1) = (span(ox0, fw, w).0, span(ox0 + ow - 1, fw, w).1); let (sy0, sy1) = (span(oy0, fh, h).0, span(oy0 + oh - 1, fh, h).1); let src = Rect::new(b.x0 + sx0 as i32, b.y0 + sy0 as i32, b.x0 + sx1 as i32, b.y0 + sy1 as i32); if (w, h) == (fw, fh) { let mut px = render(doc, src); px.rect = out; return px; } let map = |f: usize, n: usize| { let mut m = vec![0u32; f]; for t in 0..n { let (a, z) = span(t, f, n); m[a..z].fill(t as u32); } m }; let (cols, rows) = (map(fw, w), map(fh, h)); let cols = &cols[sx0..sx1]; let mut acc = vec![[0.0f32; 4]; ow * oh]; // Each output row sums its source rows in a band (in order, top to bottom), each row's pixels // left to right: `row(y, out)` adds source row `y` (band-relative) to output row `out`. let sum_band = |acc: &mut [[f32; 4]], by0: usize, by1: usize, row: &(dyn Fn(usize, &mut [[f32; 4]]) + Sync)| { let (t0, t1) = (rows[by0] as usize, rows[by1 - 1] as usize + 1); let sum_row = |t: usize, out: &mut [[f32; 4]]| { let (a, z) = span(t, fh, h); for y in a.max(by0)..z.min(by1) { row(y - by0, out); } }; let part = &mut acc[(t0 - oy0) * ow..(t1 - oy0) * ow]; #[cfg(not(target_arch = "wasm32"))] { use rayon::prelude::*; part.par_chunks_mut(ow).enumerate().for_each(|(i, out)| sum_row(t0 + i, out)); } #[cfg(target_arch = "wasm32")] for (i, out) in part.chunks_mut(ow).enumerate() { sum_row(t0 + i, out); } }; let add = |o: &mut [f32; 4], p: &[f32; 4]| { for i in 0..3 { o[i] += p[i] * p[3]; } o[3] += p[3]; }; if let Some(uniform) = uniform.then(|| uniform::UniformAreas::new(doc)).flatten() { stats.uniform = true; // One-colour tiles (a new document's background, the empty parts of a sparse one) are // composited once per colour and summed per run of source columns, not per pixel // (#4017). Tiles lie on the document's tile grid whatever `damage` is, so a damage // render sums exactly what the whole reduction does. let patterns = pattern::PreparedPatterns::new(&doc.patterns, pattern::PREPARED_PATTERN_BYTES).in_mode(doc.pixel_format().mode); let cx = Ctx::for_doc(doc, &patterns); let t = RENDER_TILE as usize; // The document tile grid (the surfaces' own), in `b`-relative coordinates: the start of // the tile holding `v` (negative when `b` starts inside a tile). let grid = |v: usize, o: i32| (i64::from(o) + v as i64).div_euclid(t as i64) * t as i64 - i64::from(o); let tile_cols: Vec = (grid(sx0, b.x0)..sx1 as i64) .step_by(t) .map(|gx| { let (x0, x1) = ((gx.max(0) as usize).max(sx0), ((gx + t as i64) as usize).min(sx1)); let mut runs: Vec<(usize, f32)> = Vec::new(); for &c in &cols[x0 - sx0..x1 - sx0] { match runs.last_mut() { Some((last, n)) if *last == c as usize - ox0 => *n += 1.0, _ => runs.push((c as usize - ox0, 1.0)), } } TileColumn { x0, x1, whole: (gx.max(0), (gx + t as i64).min(fw as i64)), runs } }) .collect(); let band_h = band_rows_for(src.width(), band_rows).max(RENDER_TILE) as usize; let mut y = grid(sy0, b.y0); while y < sy1 as i64 { let y1 = (y + band_h as i64).min(sy1 as i64); let tiles: Vec<(Rect, Rect)> = (y..y1) .step_by(t) .flat_map(|gy| { tile_cols.iter().map(move |&TileColumn { x0, x1, whole: (gx0, gx1), .. }| { let at = |x0: i64, y0: i64, x1: i64, y1: i64| Rect::new(b.x0 + x0 as i32, b.y0 + y0 as i32, b.x0 + x1 as i32, b.y0 + y1 as i32); let (gy0, gy1) = (gy.max(0), (gy + t as i64).min(fh as i64)); (at(gx0, gy0, gx1, gy1), at(x0 as i64, gy0.max(sy0 as i64), x1 as i64, gy1.min(sy1 as i64))) }) }) .collect(); let one = |(whole, part): &(Rect, Rect)| -> Part { let render = |r: Rect| render_tiled_with(doc, r, RENDER_TILE, &cx); match uniform.color(*whole, |r| render(r).px.first().copied()) { Some(p) => Part::Solid([p[0] * p[3], p[1] * p[3], p[2] * p[3], p[3]]), None => Part::Px(render(*part)), } }; #[cfg(not(target_arch = "wasm32"))] let parts: Vec = { use rayon::prelude::*; tiles.par_iter().map(one).collect() }; #[cfg(target_arch = "wasm32")] let parts: Vec = tiles.iter().map(one).collect(); stats.composited += parts.iter().map(|p| if let Part::Px(b) = p { b.px.len() as u64 } else { 0 }).sum::(); let (by0, by1) = (y.max(sy0 as i64) as usize, y1 as usize); let n = tile_cols.len(); let band_y = y; sum_band(&mut acc, by0, by1, &|row: usize, out: &mut [[f32; 4]]| { let y = (by0 + row) as i64; let j = (y - band_y) as usize / t; let ty = (y - (band_y + (j * t) as i64).max(sy0 as i64)) as usize; for (TileColumn { x0, x1, runs, .. }, part) in tile_cols.iter().zip(parts.iter().skip(j * n).take(n)) { match part { Part::Solid(pa) => { for &(c, k) in runs { let o = &mut out[c]; for i in 0..4 { o[i] += pa[i] * k; } } } Part::Px(buf) => { let tw = x1 - x0; for (p, &c) in buf.px.iter().skip(ty * tw).take(tw).zip(&cols[x0 - sx0..x1 - sx0]) { add(&mut out[c as usize - ox0], p); } } } } }); y = y1; } } else { let ok: Result<(), ()> = render_bands(doc, src, band_rows, |band| { stats.composited += band.px.len() as u64; let (by0, by1) = ((band.rect.y0 - b.y0) as usize, (band.rect.y1 - b.y0) as usize); let sw = sx1 - sx0; sum_band(&mut acc, by0, by1, &|y: usize, out: &mut [[f32; 4]]| { for (p, &c) in band.px[y * sw..(y + 1) * sw].iter().zip(cols) { add(&mut out[c as usize - ox0], p); } }); Ok(()) }); debug_assert!(ok.is_ok()); } let col_w: Vec = (0..ow) .map(|x| { let (x0, x1) = span(ox0 + x, fw, w); (x1 - x0).max(1) }) .collect(); let norm_row = |row: usize, out: &mut [[f32; 4]]| { let (y0, y1) = span(oy0 + row, fh, h); let rh = (y1 - y0).max(1); for (p, &cw) in out.iter_mut().zip(&col_w) { let a = p[3]; if a > 0.0 { let n = (rh * cw) as f32; *p = [p[0] / a, p[1] / a, p[2] / a, a / n]; } else { *p = [0.0; 4]; } } }; #[cfg(not(target_arch = "wasm32"))] { use rayon::prelude::*; acc.par_chunks_mut(ow).enumerate().for_each(|(row, out)| norm_row(row, out)); } #[cfg(target_arch = "wasm32")] for (row, out) in acc.chunks_mut(ow).enumerate() { norm_row(row, out); } Buffer { rect: out, px: acc } }