EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust
PSD: a memory budget for one decode and a capped smart-object bake (#1138)
vangel764a08f8fdf404
diff --git a/crates/engine/src/psd_import.rs b/crates/engine/src/psd_import.rsindex b025a7a5f..32b9038e8 100644--- a/crates/engine/src/psd_import.rs+++ b/crates/engine/src/psd_import.rs@@ -202,7 +202,8 @@ fn smart_object_layer(proj: &mut Project, cx: &mut Ctx, comp: &Comp, index: usizlet bb = so.placed_bounds(cw as f64, ch as f64);let area = ((bb[2] - bb[0]) * (bb[3] - bb[1])).max(1.0);let k = ((cw as f64 * ch as f64) / area).sqrt().clamp(1.0, 4.0);- let (w, h) = so.placed_size(cw as f64, ch as f64, k);+ // At most 4× the document across and 2^24 pixels, however far the file moves a corner.+ let (k, (w, h)) = so.bake_scale(cw as f64, ch as f64, k, (cx.psd.width, cx.psd.height));(w, h, k, bb)} else {(cw, ch, 1.0, [0.0; 4])diff --git a/crates/psd/src/lib.rs b/crates/psd/src/lib.rsindex 1c0fd3d4d..a78165998 100644--- a/crates/psd/src/lib.rs+++ b/crates/psd/src/lib.rs@@ -56,6 +56,79 @@ fn decode_pixels(w: usize, h: usize) -> Result<usize> {}}+fn too_large(w: usize, h: usize) -> Error {+ Error::Unsupported(format!("{w}×{h} pixels is too large to decode"))+}++/// What one decode (the composite, or one layer) may hold in memory at once: 4 GiB, 1 GiB where+/// pointers are 32 bits wide (WebAssembly). [`MAX_DECODE_PIXELS`] bounds one image; this bounds+/// the sum of the buffers a decode keeps alive together.+#[cfg(target_pointer_width = "32")]+const DECODE_BUDGET: u64 = 1 << 30;+#[cfg(not(target_pointer_width = "32"))]+const DECODE_BUDGET: u64 = 4 << 30;++/// The bytes the buffers of one decode hold right now, against a limit. A decode charges a buffer+/// before it allocates it (and releases it when it drops it), so a file that would need more+/// than the limit fails with an error instead of an out-of-memory abort.+struct Budget {+ limit: u64,+ live: u64,+}++impl Budget {+ fn new(limit: u64) -> Budget {+ Budget { limit, live: 0 }+ }++ fn charge(&mut self, bytes: u64) -> Result<()> {+ self.check(bytes)?;+ self.live += bytes;+ Ok(())+ }++ /// Whether `bytes` more would still fit, without taking them. A decode checks its whole+ /// expected peak first, so one that cannot fit fails before it has allocated anything.+ fn check(&self, bytes: u64) -> Result<()> {+ match self.live.checked_add(bytes) {+ Some(total) if total <= self.limit => Ok(()),+ _ => {+ const MIB: u64 = 1 << 20;+ Err(Error::Unsupported(format!(+ "decoding needs {} MiB more with {} MiB in use, over the {} MiB memory budget",+ bytes / MIB,+ self.live / MIB,+ self.limit / MIB+ )))+ }+ }+ }++ fn release(&mut self, bytes: u64) {+ self.live = self.live.saturating_sub(bytes);+ }++ /// An empty vector with room for `n` items, charged.+ fn vec<T>(&mut self, n: usize) -> Result<Vec<T>> {+ self.charge((n as u64).saturating_mul(std::mem::size_of::<T>() as u64))?;+ let mut v = Vec::new();+ v.try_reserve_exact(n).map_err(|_| Error::Unsupported(format!("out of memory for {n} items")))?;+ Ok(v)+ }++ /// `n` copies of `value`, charged.+ fn filled<T: Clone>(&mut self, n: usize, value: T) -> Result<Vec<T>> {+ let mut v = self.vec::<T>(n)?;+ v.resize(n, value);+ Ok(v)+ }+}++/// Inflate a zlib stream to at most `limit` bytes.+fn inflate(src: &[u8], limit: usize) -> Result<Vec<u8>> {+ miniz_oxide::inflate::decompress_to_vec_zlib_with_limit(src, limit).map_err(|e| Error::Invalid(format!("zip: {e:?}")))+}+/// Whether `bytes` start like a Photoshop document.pub fn is_psd(bytes: &[u8]) -> bool {bytes.len() >= 6 && &bytes[..4] == b"8BPS" && matches!(u16::from_be_bytes([bytes[4], bytes[5]]), 1 | 2)@@ -788,38 +861,59 @@ impl Psd {}}- /// Decode one channel of `w`×`h` samples at `offset` (compression field first). Values 0..1.- fn decode_channel(&self, offset: usize, len: usize, w: usize, h: usize) -> Result<Vec<f32>> {+ /// The raw big-endian bytes of one channel of `w`×`h` samples at `offset` (compression field+ /// first): `row_bytes(w) × h` of them with the compression and the prediction undone. The+ /// buffer is charged to `budget`; the caller releases it once it is dropped.+ fn channel_bytes(&self, offset: usize, len: usize, w: usize, h: usize, budget: &mut Budget) -> Result<Vec<u8>> {let end = offset.checked_add(len).filter(|&e| e <= self.data.len()).ok_or(Error::Truncated)?;- let mut r = Reader::at(&self.data[..end], offset);+ let mut r = Reader::at(self.data.get(..end).ok_or(Error::Truncated)?, offset);let comp = r.u16()?;decode_pixels(w, h)?;let rowb = self.row_bytes(w);- let raw = match comp {- 0 => r.bytes(rowb * h)?.to_vec(),+ let size = rowb.checked_mul(h).ok_or_else(|| too_large(w, h))?;+ match comp {+ 0 => {+ let src = r.bytes(size)?;+ let mut v = budget.vec::<u8>(size)?;+ v.extend_from_slice(src);+ Ok(v)+ }1 => {let mut counts = Vec::with_capacity(h.min(r.remaining() / 2));for _ in 0..h {counts.push(if self.psb { r.u32()? as usize } else { r.u16()? as usize });}- let mut out = Vec::with_capacity(rowb * h);+ let mut out = budget.vec::<u8>(size)?;for c in counts {unpack_bits(r.bytes(c)?, rowb, &mut out)?;}- out+ Ok(out)}2 | 3 => {let rest = r.bytes(r.remaining())?;- let mut v = miniz_oxide::inflate::decompress_to_vec_zlib_with_limit(rest, rowb * h).map_err(|e| Error::Invalid(format!("zip: {e:?}")))?;- v.resize(rowb * h, 0);+ budget.charge(size as u64)?;+ let mut v = inflate(rest, size)?;+ v.resize(size, 0);if comp == 3 {self.unpredict(&mut v, w, h);}- v+ Ok(v)}- c => return Err(Error::Unsupported(format!("compression {c}"))),- };- Ok(self.samples(&raw, w, h))+ c => Err(Error::Unsupported(format!("compression {c}"))),+ }+ }++ /// One channel as `w * h` floats (0..1), charged to `budget` (the caller releases it).+ fn channel_floats(&self, offset: usize, len: usize, w: usize, h: usize, budget: &mut Budget) -> Result<Vec<f32>> {+ let raw = self.channel_bytes(offset, len, w, h, budget)?;+ let mut out = budget.filled(decode_pixels(w, h)?, 0.0f32)?;+ self.for_each_sample(&raw, w, h, |i, v| {+ if let Some(o) = out.get_mut(i) {+ *o = v;+ }+ });+ budget.release(raw.len() as u64);+ Ok(out)}fn row_bytes(&self, w: usize) -> usize {@@ -862,29 +956,30 @@ impl Psd {}}- fn samples(&self, raw: &[u8], w: usize, h: usize) -> Vec<f32> {+ /// Hand every sample of `raw` (`w`×`h`, row-major, in order) to `f` as a float. Samples a short+ /// `raw` does not have are not reported.+ fn for_each_sample(&self, raw: &[u8], w: usize, h: usize, mut f: impl FnMut(usize, f32)) {+ let n = w.saturating_mul(h);match self.depth {1 => {let rowb = w.div_ceil(8);- let mut out = Vec::with_capacity(w * h);for y in 0..h {for x in 0..w {let b = raw.get(y * rowb + x / 8).copied().unwrap_or(0);// 1 = black.- out.push(if b & (0x80 >> (x % 8)) != 0 { 0.0 } else { 1.0 });+ f(y * w + x, if b & (0x80 >> (x % 8)) != 0 { 0.0 } else { 1.0 });}}- out}- 16 => raw.as_chunks::<2>().0.iter().take(w * h).map(|c| u16::from_be_bytes([c[0], c[1]]) as f32 / 65535.0).collect(),- 32 => raw.as_chunks::<4>().0.iter().take(w * h).map(|c| f32::from_be_bytes([c[0], c[1], c[2], c[3]])).collect(),- _ => raw.iter().take(w * h).map(|&b| b as f32 / 255.0).collect(),+ 16 => raw.as_chunks::<2>().0.iter().take(n).enumerate().for_each(|(i, c)| f(i, u16::from_be_bytes([c[0], c[1]]) as f32 / 65535.0)),+ 32 => raw.as_chunks::<4>().0.iter().take(n).enumerate().for_each(|(i, c)| f(i, f32::from_be_bytes([c[0], c[1], c[2], c[3]]))),+ _ => raw.iter().take(n).enumerate().for_each(|(i, &b)| f(i, b as f32 / 255.0)),}}- /// Convert colour channels (in the document's mode) to RGB.- fn to_rgb(&self, ch: &[Option<Vec<f32>>], i: usize) -> [f32; 3] {- let g = |k: usize| ch.get(k).and_then(|c| c.as_ref()).map_or(0.0, |c| c[i]);+ /// Convert colour values (the document mode's channels, missing ones 0) to RGB.+ fn rgb_from(&self, v: [f32; 4]) -> [f32; 3] {+ let g = |k: usize| v.get(k).copied().unwrap_or(0.0);let rgb = match self.mode {ColorMode::Rgb => [g(0), g(1), g(2)],ColorMode::Cmyk => {@@ -902,55 +997,101 @@ impl Psd {if self.depth == 32 && self.mode != ColorMode::Lab { rgb.map(srgb_encode) } else { rgb }}+ /// Write merged-image channel `c` (raw bytes) into the result: the first three colour channels+ /// and the alpha channel into their slot of a pixel, the fourth CMYK channel into `black`.+ fn store_merged_channel(&self, c: usize, raw: &[u8], data: &mut [[f32; 4]], black: &mut Option<Vec<f32>>) {+ let (w, h, cc) = (self.width as usize, self.height as usize, self.mode.color_channels());+ if c < cc.min(3) {+ self.for_each_sample(raw, w, h, |i, v| {+ if let Some(p) = data.get_mut(i) {+ p[c] = v;+ }+ });+ } else if c == 3 && c < cc {+ if let Some(k) = black {+ self.for_each_sample(raw, w, h, |i, v| {+ if let Some(o) = k.get_mut(i) {+ *o = v;+ }+ });+ }+ } else if c == cc && self.merged_alpha {+ self.for_each_sample(raw, w, h, |i, v| {+ if let Some(p) = data.get_mut(i) {+ p[3] = v;+ }+ });+ }+ }+/// The merged (flattened) image.pub fn composite(&self) -> Result<Pixels> {+ self.composite_with_budget(DECODE_BUDGET)+ }++ /// [`Self::composite`] with at most `limit` bytes live at once. The channels are written+ /// straight into the result, so the peak is the result (16 bytes a pixel), the CMYK black+ /// channel, and the one buffer a channel (or, for ZIP, all channels) decodes through.+ pub(crate) fn composite_with_budget(&self, limit: u64) -> Result<Pixels> {+ let mut budget = Budget::new(limit);let (w, h) = (self.width as usize, self.height as usize);- decode_pixels(w, h)?;+ let n = decode_pixels(w, h)?;let mut r = Reader::at(&self.data, self.merged_offset);let comp = r.u16()?;let nch = self.channels as usize;let cc = self.mode.color_channels();let want = (cc + usize::from(self.merged_alpha)).min(nch);let rowb = self.row_bytes(w);- let mut planes: Vec<Option<Vec<f32>>> = vec![None; nch];+ let size = rowb.checked_mul(h).ok_or_else(|| too_large(w, h))?;+ // The peak: the result, the CMYK black channel and what the channels decode through.+ let black_bytes = if self.mode == ColorMode::Cmyk && want > 3 { 4 * n as u64 } else { 0 };+ let transient = if matches!(comp, 2 | 3) { (size as u64).saturating_mul(want as u64) } else { size as u64 };+ budget.check((16 * n as u64).saturating_add(black_bytes).saturating_add(transient))?;+ // Opaque black until a channel says otherwise.+ let mut data = budget.filled(n, [0.0f32, 0.0, 0.0, 1.0])?;+ let mut black = if self.mode == ColorMode::Cmyk && want > 3 { Some(budget.filled(n, 0.0f32)?) } else { None };match comp {0 => {- for p in planes.iter_mut().take(want) {- *p = Some(self.samples(r.bytes(rowb * h)?, w, h));+ for c in 0..want {+ self.store_merged_channel(c, r.bytes(size)?, &mut data, &mut black);}}1 => {- let mut counts = Vec::with_capacity((nch * h).min(r.remaining() / 2));- for _ in 0..nch * h {+ let total = nch.saturating_mul(h);+ let mut counts = Vec::with_capacity(total.min(r.remaining() / 2));+ for _ in 0..total {counts.push(if self.psb { r.u32()? as usize } else { r.u16()? as usize });}- for (c, p) in planes.iter_mut().enumerate().take(want) {- let mut out = Vec::with_capacity(rowb * h);+ for c in 0..want {+ let mut out = budget.vec::<u8>(size)?;for row in 0..h {- unpack_bits(r.bytes(counts[c * h + row])?, rowb, &mut out)?;+ let count = *counts.get(c * h + row).ok_or(Error::Truncated)?;+ unpack_bits(r.bytes(count)?, rowb, &mut out)?;}- *p = Some(self.samples(&out, w, h));+ self.store_merged_channel(c, &out, &mut data, &mut black);+ budget.release(size as u64);}}2 | 3 => {let rest = r.bytes(r.remaining())?;- let v = miniz_oxide::inflate::decompress_to_vec_zlib_with_limit(rest, want * rowb * h).map_err(|e| Error::Invalid(format!("zip: {e:?}")))?;- for (c, p) in planes.iter_mut().enumerate().take(want) {- let mut plane = v.get(c * rowb * h..(c + 1) * rowb * h).ok_or(Error::Truncated)?.to_vec();+ // One stream holds every channel: what it may decode to is what they need.+ let total = size.checked_mul(want).ok_or_else(|| too_large(w, h))?;+ budget.charge(total as u64)?;+ let mut v = inflate(rest, total)?;+ for c in 0..want {+ let plane = v.get_mut(c * size..(c + 1) * size).ok_or(Error::Truncated)?;if comp == 3 {- self.unpredict(&mut plane, w, h);+ self.unpredict(plane, w, h);}- *p = Some(self.samples(&plane, w, h));+ self.store_merged_channel(c, plane, &mut data, &mut black);}}c => return Err(Error::Unsupported(format!("compression {c}"))),}- let alpha = if self.merged_alpha && nch > cc { planes[cc].take() } else { None };- let mut data = Vec::with_capacity(w * h);- for i in 0..w * h {- let [r, g, b] = self.to_rgb(&planes, i);- let a = alpha.as_ref().map_or(1.0, |a| a[i]);- data.push([r, g, b, a]);+ for (i, p) in data.iter_mut().enumerate() {+ let k = black.as_ref().and_then(|k| k.get(i)).copied().unwrap_or(0.0);+ let [r, g, b] = self.rgb_from([p[0], p[1], p[2], k]);+ *p = [r, g, b, p[3]];}Ok(Pixels { width: w as u32, height: h as u32, data })}@@ -958,6 +1099,14 @@ impl Psd {/// One layer's pixels with its layer mask (and vector-less fill colour) applied to alpha./// `canvas`: document-sized with the layer in place; otherwise the layer's own bounds.pub fn layer_pixels(&self, index: usize, canvas: bool) -> Result<Pixels> {+ self.layer_pixels_with_budget(index, canvas, DECODE_BUDGET)+ }++ /// [`Self::layer_pixels`] with at most `limit` bytes live at once: the result (16 bytes a+ /// pixel) with the channels written straight into it, the CMYK black channel, the one channel+ /// being decoded, and the mask.+ pub(crate) fn layer_pixels_with_budget(&self, index: usize, canvas: bool, limit: u64) -> Result<Pixels> {+ let mut budget = Budget::new(limit);let l = self.layers.get(index).ok_or_else(|| Error::Invalid(format!("no layer {index}")))?;let doc = Rect { top: 0, left: 0, bottom: self.height as i32, right: self.width as i32 };// Fill layers often have no pixel data: they cover the canvas (or the mask).@@ -971,22 +1120,26 @@ impl Psd {fill_rect};let (ow, oh) = (out_rect.width() as usize, out_rect.height() as usize);- let mut out = vec![[0.0f32; 4]; decode_pixels(ow, oh)?];+ let n = decode_pixels(ow, oh)?;let src = fill_rect;let (sw, sh) = (src.width() as usize, src.height() as usize);- if sw > 0 && sh > 0 {- let mut planes: Vec<Option<Vec<f32>>> = vec![None; self.mode.color_channels()];- let mut alpha = None;- if l.has_pixels() {- for c in &l.channels {- match c.id {- -1 => alpha = Some(self.decode_channel(c.offset, c.len, sw, sh)?),- id if id >= 0 && (id as usize) < planes.len() => planes[id as usize] = Some(self.decode_channel(c.offset, c.len, sw, sh)?),- _ => {}- }- }+ // The peak: the result, then either the CMYK black channel with the channel being decoded,+ // or the mask as floats with its bytes. Checked before anything is allocated.+ let plane = |w: usize, h: usize| (self.row_bytes(w) as u64).saturating_mul(h as u64);+ let mut pixels_peak = 0u64;+ if l.has_pixels() && sw > 0 && sh > 0 {+ pixels_peak = plane(sw, sh).saturating_add(if self.mode == ColorMode::Cmyk { 4 * n as u64 } else { 0 });+ }+ let mut mask_peak = 0u64;+ if let Some(m) = l.mask.filter(|m| !m.disabled) {+ let (mw, mh) = (m.rect.width() as usize, m.rect.height() as usize);+ if mw > 0 && mh > 0 && l.channels.iter().any(|c| c.id == -2) {+ mask_peak = plane(mw, mh).saturating_add((mw as u64).saturating_mul(mh as u64).saturating_mul(4));}- let fill = l.fill.map(|c| c.map(|v| v as f32));+ }+ budget.check((16 * n as u64).saturating_add(pixels_peak.max(mask_peak)))?;+ let mut out = budget.filled(n, [0.0f32; 4])?;+ if sw > 0 && sh > 0 {// The source rows / columns that land inside the output (64-bit: file bounds can span// the whole i32 range).let span = |s0: i32, n: usize, o0: i32, on: usize| {@@ -997,16 +1150,77 @@ impl Psd {};let (ys, oy) = span(src.top, sh, out_rect.top, oh);let (xs, ox) = span(src.left, sw, out_rect.left, ow);- for y in ys {- let dy = (y as i64 - oy) as usize;- for x in xs.clone() {- let dx = (x as i64 - ox) as usize;- let i = y * sw + x;- let (rgb, a) = match fill {- Some(f) if !l.has_pixels() => (f, 1.0),- _ => (self.to_rgb(&planes, i), alpha.as_ref().map_or(1.0, |a| a[i])),- };- out[dy * ow + dx] = [rgb[0], rgb[1], rgb[2], a];+ let dest = |y: usize, x: usize| (y as i64 - oy) as usize * ow + (x as i64 - ox) as usize;+ let fill = l.fill.map(|c| c.map(|v| v as f32));+ match fill {+ Some(f) if !l.has_pixels() => {+ for y in ys {+ for x in xs.clone() {+ if let Some(p) = out.get_mut(dest(y, x)) {+ *p = [f[0], f[1], f[2], 1.0];+ }+ }+ }+ }+ _ => {+ // Opaque unless there is an alpha channel.+ for y in ys.clone() {+ for x in xs.clone() {+ if let Some(p) = out.get_mut(dest(y, x)) {+ p[3] = 1.0;+ }+ }+ }+ let cc = self.mode.color_channels();+ let mut black: Option<Vec<f32>> = None;+ if l.has_pixels() {+ for c in &l.channels {+ let slot = match c.id {+ -1 => 3,+ id if id >= 0 && (id as usize) < cc => id as usize,+ _ => continue,+ };+ let raw = self.channel_bytes(c.offset, c.len, sw, sh, &mut budget)?;+ // The fourth CMYK channel is the black plate, not a slot of the result.+ let to_black = c.id == 3;+ if to_black && black.is_none() {+ black = Some(budget.filled(out.len(), 0.0f32)?);+ }+ // Samples arrive in row-major order of the source.+ let (mut sy, mut sx) = (0usize, 0usize);+ self.for_each_sample(&raw, sw, sh, |_, v| {+ if ys.contains(&sy) && xs.contains(&sx) {+ let d = dest(sy, sx);+ if to_black {+ if let Some(o) = black.as_mut().and_then(|k| k.get_mut(d)) {+ *o = v;+ }+ } else if let Some(p) = out.get_mut(d) {+ p[slot] = v;+ }+ }+ sx += 1;+ if sx == sw {+ sx = 0;+ sy += 1;+ }+ });+ budget.release(raw.len() as u64);+ }+ }+ for y in ys {+ for x in xs.clone() {+ let d = dest(y, x);+ let k = black.as_ref().and_then(|k| k.get(d)).copied().unwrap_or(0.0);+ if let Some(p) = out.get_mut(d) {+ let [r, g, b] = self.rgb_from([p[0], p[1], p[2], k]);+ *p = [r, g, b, p[3]];+ }+ }+ }+ if let Some(k) = black {+ budget.release(k.len() as u64 * 4);+ }}}}@@ -1015,7 +1229,7 @@ impl Psd {let mc = l.channels.iter().find(|c| c.id == -2);let (mw, mh) = (m.rect.width() as usize, m.rect.height() as usize);let mask = match mc {- Some(c) if mw > 0 && mh > 0 => Some(self.decode_channel(c.offset, c.len, mw, mh)?),+ Some(c) if mw > 0 && mh > 0 => Some(self.channel_floats(c.offset, c.len, mw, mh, &mut budget)?),_ => None,};let def = m.default_color as f32 / 255.0;@@ -1025,13 +1239,15 @@ impl Psd {let px = out_rect.left + x as i32;let inside = py >= m.rect.top && py < m.rect.bottom && px >= m.rect.left && px < m.rect.right;let mut v = match (&mask, inside) {- (Some(mk), true) => mk[(py - m.rect.top) as usize * mw + (px - m.rect.left) as usize],+ (Some(mk), true) => mk.get((py - m.rect.top) as usize * mw + (px - m.rect.left) as usize).copied().unwrap_or(def),_ => def,};if m.inverted {v = 1.0 - v;}- out[y * ow + x][3] *= v;+ if let Some(p) = out.get_mut(y * ow + x) {+ p[3] *= v;+ }}}}@@ -1147,5 +1363,7 @@ fn lab_to_rgb(l: f32, a: f32, b: f32) -> [f32; 3] {[r, g, bb].map(|v| srgb_encode(v.clamp(0.0, 1.0)))}+#[cfg(test)]+mod memory_tests;#[cfg(test)]mod tests;diff --git a/crates/psd/src/memory_tests.rs b/crates/psd/src/memory_tests.rsnew file mode 100644index 000000000..8fbe8307f--- /dev/null+++ b/crates/psd/src/memory_tests.rs@@ -0,0 +1,398 @@+//! Tests for the decode memory budget, with the previous decoder (one `Vec<f32>` per channel and a+//! result vector, no budget) kept as the reference the new one must reproduce bit for bit.++use super::write::*;+use super::*;++/// The decoder as it was before the budget: copied unchanged except for the names.+impl Psd {+ /// Decode one channel of `w`×`h` samples at `offset` (compression field first). Values 0..1.+ fn ref_decode_channel(&self, offset: usize, len: usize, w: usize, h: usize) -> Result<Vec<f32>> {+ let end = offset.checked_add(len).filter(|&e| e <= self.data.len()).ok_or(Error::Truncated)?;+ let mut r = Reader::at(&self.data[..end], offset);+ let comp = r.u16()?;+ decode_pixels(w, h)?;+ let rowb = self.row_bytes(w);+ let raw = match comp {+ 0 => r.bytes(rowb * h)?.to_vec(),+ 1 => {+ let mut counts = Vec::with_capacity(h.min(r.remaining() / 2));+ for _ in 0..h {+ counts.push(if self.psb { r.u32()? as usize } else { r.u16()? as usize });+ }+ let mut out = Vec::with_capacity(rowb * h);+ for c in counts {+ unpack_bits(r.bytes(c)?, rowb, &mut out)?;+ }+ out+ }+ 2 | 3 => {+ let rest = r.bytes(r.remaining())?;+ let mut v = miniz_oxide::inflate::decompress_to_vec_zlib_with_limit(rest, rowb * h).map_err(|e| Error::Invalid(format!("zip: {e:?}")))?;+ v.resize(rowb * h, 0);+ if comp == 3 {+ self.unpredict(&mut v, w, h);+ }+ v+ }+ c => return Err(Error::Unsupported(format!("compression {c}"))),+ };+ Ok(self.ref_samples(&raw, w, h))+ }++ fn ref_samples(&self, raw: &[u8], w: usize, h: usize) -> Vec<f32> {+ match self.depth {+ 1 => {+ let rowb = w.div_ceil(8);+ let mut out = Vec::with_capacity(w * h);+ for y in 0..h {+ for x in 0..w {+ let b = raw.get(y * rowb + x / 8).copied().unwrap_or(0);+ // 1 = black.+ out.push(if b & (0x80 >> (x % 8)) != 0 { 0.0 } else { 1.0 });+ }+ }+ out+ }+ 16 => raw.as_chunks::<2>().0.iter().take(w * h).map(|c| u16::from_be_bytes([c[0], c[1]]) as f32 / 65535.0).collect(),+ 32 => raw.as_chunks::<4>().0.iter().take(w * h).map(|c| f32::from_be_bytes([c[0], c[1], c[2], c[3]])).collect(),+ _ => raw.iter().take(w * h).map(|&b| b as f32 / 255.0).collect(),+ }+ }++ /// Convert colour channels (in the document's mode) to RGB.+ fn ref_to_rgb(&self, ch: &[Option<Vec<f32>>], i: usize) -> [f32; 3] {+ let g = |k: usize| ch.get(k).and_then(|c| c.as_ref()).map_or(0.0, |c| c[i]);+ let rgb = match self.mode {+ ColorMode::Rgb => [g(0), g(1), g(2)],+ ColorMode::Cmyk => {+ // Stored inverted (1 = no ink).+ let k = g(3);+ [g(0) * k, g(1) * k, g(2) * k]+ }+ ColorMode::Indexed if self.palette.len() >= 768 => {+ let idx = (g(0) * 255.0).round() as usize & 255;+ [self.palette[idx] as f32 / 255.0, self.palette[256 + idx] as f32 / 255.0, self.palette[512 + idx] as f32 / 255.0]+ }+ ColorMode::Lab => lab_to_rgb(g(0) * 100.0, g(1) * 255.0 - 128.0, g(2) * 255.0 - 128.0),+ _ => [g(0); 3],+ };+ if self.depth == 32 && self.mode != ColorMode::Lab { rgb.map(srgb_encode) } else { rgb }+ }++ /// The merged (flattened) image.+ fn ref_composite(&self) -> Result<Pixels> {+ let (w, h) = (self.width as usize, self.height as usize);+ decode_pixels(w, h)?;+ let mut r = Reader::at(&self.data, self.merged_offset);+ let comp = r.u16()?;+ let nch = self.channels as usize;+ let cc = self.mode.color_channels();+ let want = (cc + usize::from(self.merged_alpha)).min(nch);+ let rowb = self.row_bytes(w);+ let mut planes: Vec<Option<Vec<f32>>> = vec![None; nch];+ match comp {+ 0 => {+ for p in planes.iter_mut().take(want) {+ *p = Some(self.ref_samples(r.bytes(rowb * h)?, w, h));+ }+ }+ 1 => {+ let mut counts = Vec::with_capacity((nch * h).min(r.remaining() / 2));+ for _ in 0..nch * h {+ counts.push(if self.psb { r.u32()? as usize } else { r.u16()? as usize });+ }+ for (c, p) in planes.iter_mut().enumerate().take(want) {+ let mut out = Vec::with_capacity(rowb * h);+ for row in 0..h {+ unpack_bits(r.bytes(counts[c * h + row])?, rowb, &mut out)?;+ }+ *p = Some(self.ref_samples(&out, w, h));+ }+ }+ 2 | 3 => {+ let rest = r.bytes(r.remaining())?;+ let v = miniz_oxide::inflate::decompress_to_vec_zlib_with_limit(rest, want * rowb * h).map_err(|e| Error::Invalid(format!("zip: {e:?}")))?;+ for (c, p) in planes.iter_mut().enumerate().take(want) {+ let mut plane = v.get(c * rowb * h..(c + 1) * rowb * h).ok_or(Error::Truncated)?.to_vec();+ if comp == 3 {+ self.unpredict(&mut plane, w, h);+ }+ *p = Some(self.ref_samples(&plane, w, h));+ }+ }+ c => return Err(Error::Unsupported(format!("compression {c}"))),+ }+ let alpha = if self.merged_alpha && nch > cc { planes[cc].take() } else { None };+ let mut data = Vec::with_capacity(w * h);+ for i in 0..w * h {+ let [r, g, b] = self.ref_to_rgb(&planes, i);+ let a = alpha.as_ref().map_or(1.0, |a| a[i]);+ data.push([r, g, b, a]);+ }+ Ok(Pixels { width: w as u32, height: h as u32, data })+ }++ /// One layer's pixels with its layer mask (and vector-less fill colour) applied to alpha.+ /// `canvas`: document-sized with the layer in place; otherwise the layer's own bounds.+ fn ref_layer_pixels(&self, index: usize, canvas: bool) -> Result<Pixels> {+ let l = self.layers.get(index).ok_or_else(|| Error::Invalid(format!("no layer {index}")))?;+ let doc = Rect { top: 0, left: 0, bottom: self.height as i32, right: self.width as i32 };+ // Fill layers often have no pixel data: they cover the canvas (or the mask).+ let fill_rect =+ if l.fill.is_some() && !l.has_pixels() { l.mask.filter(|m| !m.rect.is_empty() && m.default_color == 0).map_or(doc, |m| m.rect) } else { l.rect };+ let out_rect = if canvas {+ doc+ } else if fill_rect.is_empty() {+ Rect { top: 0, left: 0, bottom: 1, right: 1 }+ } else {+ fill_rect+ };+ let (ow, oh) = (out_rect.width() as usize, out_rect.height() as usize);+ let mut out = vec![[0.0f32; 4]; decode_pixels(ow, oh)?];+ let src = fill_rect;+ let (sw, sh) = (src.width() as usize, src.height() as usize);+ if sw > 0 && sh > 0 {+ let mut planes: Vec<Option<Vec<f32>>> = vec![None; self.mode.color_channels()];+ let mut alpha = None;+ if l.has_pixels() {+ for c in &l.channels {+ match c.id {+ -1 => alpha = Some(self.ref_decode_channel(c.offset, c.len, sw, sh)?),+ id if id >= 0 && (id as usize) < planes.len() => planes[id as usize] = Some(self.ref_decode_channel(c.offset, c.len, sw, sh)?),+ _ => {}+ }+ }+ }+ let fill = l.fill.map(|c| c.map(|v| v as f32));+ // The source rows / columns that land inside the output (64-bit: file bounds can span+ // the whole i32 range).+ let span = |s0: i32, n: usize, o0: i32, on: usize| {+ let off = i64::from(o0) - i64::from(s0);+ let lo = off.clamp(0, n as i64);+ let hi = (off + on as i64).clamp(lo, n as i64);+ (lo as usize..hi as usize, off)+ };+ let (ys, oy) = span(src.top, sh, out_rect.top, oh);+ let (xs, ox) = span(src.left, sw, out_rect.left, ow);+ for y in ys {+ let dy = (y as i64 - oy) as usize;+ for x in xs.clone() {+ let dx = (x as i64 - ox) as usize;+ let i = y * sw + x;+ let (rgb, a) = match fill {+ Some(f) if !l.has_pixels() => (f, 1.0),+ _ => (self.ref_to_rgb(&planes, i), alpha.as_ref().map_or(1.0, |a| a[i])),+ };+ out[dy * ow + dx] = [rgb[0], rgb[1], rgb[2], a];+ }+ }+ }+ // Layer mask: multiplies alpha (also outside the mask rect, by its default colour).+ if let Some(m) = l.mask.filter(|m| !m.disabled) {+ let mc = l.channels.iter().find(|c| c.id == -2);+ let (mw, mh) = (m.rect.width() as usize, m.rect.height() as usize);+ let mask = match mc {+ Some(c) if mw > 0 && mh > 0 => Some(self.ref_decode_channel(c.offset, c.len, mw, mh)?),+ _ => None,+ };+ let def = m.default_color as f32 / 255.0;+ for y in 0..oh {+ let py = out_rect.top + y as i32;+ for x in 0..ow {+ let px = out_rect.left + x as i32;+ let inside = py >= m.rect.top && py < m.rect.bottom && px >= m.rect.left && px < m.rect.right;+ let mut v = match (&mask, inside) {+ (Some(mk), true) => mk[(py - m.rect.top) as usize * mw + (px - m.rect.left) as usize],+ _ => def,+ };+ if m.inverted {+ v = 1.0 - v;+ }+ out[y * ow + x][3] *= v;+ }+ }+ }+ Ok(Pixels { width: ow as u32, height: oh as u32, data: out })+ }+}++// ---------------------------------------------------------------------------------------------+// Tests++fn grad(w: u32, h: u32) -> Vec<[f32; 4]> {+ (0..w * h)+ .map(|i| [(i % w) as f32 / (w - 1).max(1) as f32, (i / w) as f32 / (h - 1).max(1) as f32, 0.25 + (i % 7) as f32 / 16.0, 0.3 + (i % 5) as f32 / 8.0])+ .collect()+}++/// Layers covering: full canvas pixels with alpha, a partly off-canvas layer, a masked layer with+/// an inverted mask and a default colour, a solid layer.+fn doc(depth: u16, mode: ColorMode, rle: bool) -> WDoc {+ let mut d = WDoc::new(40, 30);+ d.depth = depth;+ d.mode = mode;+ d.rle = rle;+ let bg = WLayer::pixels("bg", Rect::new(0, 0, 40, 30), grad(40, 30));+ let off = WLayer::pixels("off", Rect::new(-5, -4, 18, 13), grad(18, 13));+ let solid = WLayer::solid("solid", Rect::new(30, 20, 15, 15), [0.2, 0.6, 0.9, 1.0]);+ let mut masked = WLayer::pixels("masked", Rect::new(10, 8, 12, 12), grad(12, 12));+ masked.mask =+ Some(WMask { rect: Rect::new(12, 10, 12, 12), data: (0..144).map(|i| (i % 12) as f32 / 11.0).collect(), default_color: 255, disabled: false });+ d.layers = vec![bg, off, solid, masked];+ d+}++fn assert_same_as_reference(p: &Psd, what: &str) {+ assert_eq!(p.composite().unwrap(), p.ref_composite().unwrap(), "composite {what}");+ for i in 0..p.layers.len() {+ for canvas in [false, true] {+ assert_eq!(p.layer_pixels(i, canvas).unwrap(), p.ref_layer_pixels(i, canvas).unwrap(), "layer {i} canvas={canvas} {what}");+ }+ }+}++#[test]+fn pixels_match_the_one_buffer_per_channel_reference() {+ for depth in [8u16, 16] {+ for mode in [ColorMode::Rgb, ColorMode::Grayscale, ColorMode::Cmyk] {+ for rle in [true, false] {+ let p = Psd::parse(write(&doc(depth, mode, rle))).unwrap();+ assert_same_as_reference(&p, &format!("{depth}-bit {mode:?} rle={rle}"));+ }+ }+ }+}++/// A copy of `bytes` with a different size, depth and merged-image section (`comp`, then `body`).+fn with_merged(bytes: &[u8], size: Option<(u32, u32)>, depth: Option<u16>, comp: u16, body: &[u8]) -> Vec<u8> {+ let offset = Psd::parse(bytes.to_vec()).unwrap().merged_offset;+ let mut v = bytes[..offset].to_vec();+ if let Some((w, h)) = size {+ v[14..18].copy_from_slice(&h.to_be_bytes());+ v[18..22].copy_from_slice(&w.to_be_bytes());+ }+ if let Some(d) = depth {+ v[22..24].copy_from_slice(&d.to_be_bytes());+ }+ v.extend_from_slice(&comp.to_be_bytes());+ v.extend_from_slice(body);+ v+}++/// Channel planes for a 6×5 image: values that exercise the whole range.+fn planes(nch: usize, bytes_per_sample: usize, n: usize) -> Vec<u8> {+ let mut v = vec![];+ for c in 0..nch {+ for i in 0..n {+ let t = ((i * 37 + c * 91) % 251) as f32 / 250.0;+ match bytes_per_sample {+ 1 => v.push((t * 255.0) as u8),+ 2 => v.extend_from_slice(&((t * 65535.0) as u16).to_be_bytes()),+ _ => v.extend_from_slice(&(t * 1.5 - 0.1).to_be_bytes()),+ }+ }+ }+ v+}++#[test]+fn merged_image_matches_the_reference_for_32_bit_and_zip() {+ for mode in [ColorMode::Rgb, ColorMode::Grayscale, ColorMode::Cmyk] {+ let mut small = WDoc::new(6, 5);+ small.mode = mode;+ small.rle = false;+ let base = write(&small);+ let info = Psd::parse(base.clone()).unwrap();+ // The merged image only reads the colour channels and, when flagged, the alpha channel.+ let nch = (mode.color_channels() + usize::from(info.merged_alpha)).min(info.channels as usize);+ let n = 30;+ // 32-bit float, raw.+ let p = Psd::parse(with_merged(&base, None, Some(32), 0, &planes(nch, 4, n))).unwrap();+ assert_eq!(p.depth, 32);+ assert_eq!(p.composite().unwrap(), p.ref_composite().unwrap(), "32-bit {mode:?}");+ // ZIP without and with prediction, 8 and 16 bit; 32-bit ZIP without prediction.+ for (depth, bps) in [(8u16, 1usize), (16, 2), (32, 4)] {+ let raw = planes(nch, bps, n);+ let zip = miniz_oxide::deflate::compress_to_vec_zlib(&raw, 6);+ let p = Psd::parse(with_merged(&base, None, Some(depth), 2, &zip)).unwrap();+ assert_eq!(p.composite().unwrap(), p.ref_composite().unwrap(), "zip {depth}-bit {mode:?}");+ if depth == 32 {+ continue;+ }+ // Prediction: each row stores differences to its left neighbour.+ let mut pred = raw.clone();+ for plane in pred.chunks_exact_mut(n * bps) {+ for row in plane.chunks_exact_mut(6 * bps) {+ if bps == 1 {+ for i in (1..6).rev() {+ row[i] = row[i].wrapping_sub(row[i - 1]);+ }+ } else {+ for i in (1..6).rev() {+ let a = u16::from_be_bytes([row[i * 2], row[i * 2 + 1]]);+ let b = u16::from_be_bytes([row[i * 2 - 2], row[i * 2 - 1]]);+ row[i * 2..i * 2 + 2].copy_from_slice(&a.wrapping_sub(b).to_be_bytes());+ }+ }+ }+ }+ let zip = miniz_oxide::deflate::compress_to_vec_zlib(&pred, 6);+ let p = Psd::parse(with_merged(&base, None, Some(depth), 3, &zip)).unwrap();+ assert_eq!(p.composite().unwrap(), p.ref_composite().unwrap(), "zip+prediction {depth}-bit {mode:?}");+ }+ }+}++#[test]+fn budget_counts_the_sum_of_the_buffers_of_a_decode() {+ let mut b = Budget::new(100);+ b.charge(60).unwrap();+ assert!(b.charge(41).is_err(), "60 + 41 is over 100 although each alone fits");+ b.check(40).unwrap();+ assert!(b.check(41).is_err());+ b.release(30);+ b.charge(70).unwrap();+ assert!(b.vec::<u8>(1).unwrap_err().to_string().contains("memory budget"));+ assert!(Budget::new(u64::MAX).vec::<u64>(usize::MAX / 2).is_err(), "a size that cannot be reserved is an error, not an abort");++ // The same for a real decode: the result (16 bytes a pixel) and a channel's bytes together.+ let p = Psd::parse(write(&doc(8, ColorMode::Rgb, true))).unwrap();+ let n = 40 * 30;+ let peak = 16 * n + n;+ assert!(p.composite_with_budget(peak).is_ok());+ for limit in [peak - 1, 16 * n, 16 * n - 1, 1000, 0] {+ let e = p.composite_with_budget(limit).unwrap_err();+ assert!(e.to_string().contains("memory budget"), "{limit}: {e}");+ }+ // A layer: the result plus its channel; the mask comes after the channels are gone.+ let bg = p.layers.iter().position(|l| l.name == "bg").unwrap();+ assert!(p.layer_pixels_with_budget(bg, true, 16 * n + n).is_ok());+ assert!(p.layer_pixels_with_budget(bg, true, 16 * n).unwrap_err().to_string().contains("memory budget"));+ assert_eq!(p.layer_pixels_with_budget(bg, true, 16 * n + n).unwrap(), p.layer_pixels(bg, true).unwrap());+}++#[test]+fn a_huge_header_with_a_tiny_zip_stream_is_refused_before_it_allocates() {+ // 16384 × 16384, RGB + alpha: a few hundred bytes of zlib that inflate to gigabytes of zeros.+ let mut small = WDoc::new(2, 2);+ small.rle = false;+ let base = write(&small);+ let zeros = vec![0u8; 1 << 20];+ let stream = miniz_oxide::deflate::compress_to_vec_zlib(&zeros, 9);+ let bytes = with_merged(&base, Some((16384, 16384)), None, 2, &stream);+ assert!(bytes.len() < 8192);+ let p = Psd::parse(bytes).unwrap();+ assert_eq!((p.width, p.height), (16384, 16384));+ let e = p.composite().unwrap_err();+ assert!(e.to_string().contains("memory budget"), "{e}");+ // The same file with the compression types that read straight from the file.+ for comp in [0u16, 1, 3] {+ let p = Psd::parse(with_merged(&base, Some((16384, 16384)), None, comp, &stream)).unwrap();+ let e = p.composite().unwrap_err();+ assert!(e.to_string().contains("memory budget"), "comp {comp}: {e}");+ }+ // And a smaller image under a small budget: the stream is not inflated.+ let p = Psd::parse(with_merged(&base, Some((4096, 4096)), None, 2, &stream)).unwrap();+ assert!(p.composite_with_budget(1 << 20).unwrap_err().to_string().contains("memory budget"));+}diff --git a/crates/psd/src/placed.rs b/crates/psd/src/placed.rsindex 156a8e271..25490e4da 100644--- a/crates/psd/src/placed.rs+++ b/crates/psd/src/placed.rs@@ -12,6 +12,10 @@use crate::descriptor::{DValue, Descriptor};use crate::{Pixels, SmartObject};+/// The most pixels a baked smart object may have: 2^24 (256 MiB as float RGBA). The size comes+/// from the file's transform, which is untrusted.+pub const MAX_BAKE_PIXELS: u64 = 1 << 24;+/// A placed layer's warp.#[derive(Clone, Debug, Default, PartialEq)]pub struct Warp {@@ -252,9 +256,27 @@ impl SmartObject {(((bb[2] - bb[0]) * k).ceil().clamp(1.0, 16384.0) as u32, ((bb[3] - bb[1]) * k).ceil().clamp(1.0, 16384.0) as u32)}+ /// The scale and size to bake a `w`×`h` content at, wanting `k` pixels per document pixel but+ /// never more than [`MAX_BAKE_PIXELS`] pixels, nor more than 4× the `doc` size across either+ /// way: a quad corner far outside the document lowers `k` (possibly below 1) instead of asking+ /// for a gigantic image. Returns the scale actually used and the size in pixels.+ pub fn bake_scale(&self, w: f64, h: f64, k: f64, doc: (u32, u32)) -> (f64, (u32, u32)) {+ let bb = self.placed_bounds(w, h);+ let (bw, bh) = ((bb[2] - bb[0]).max(1.0), (bb[3] - bb[1]).max(1.0));+ if !(bw.is_finite() && bh.is_finite() && k.is_finite() && k > 0.0) {+ return (1.0, (1, 1));+ }+ let (max_w, max_h) = ((f64::from(doc.0) * 4.0).max(1.0), (f64::from(doc.1) * 4.0).max(1.0));+ let capped = k.min(max_w / bw).min(max_h / bh).min((MAX_BAKE_PIXELS as f64 / (bw * bh)).sqrt());+ // Rounding up could step over a cap, so a lowered scale rounds down.+ let side = |len: f64| if capped < k { (len * capped).floor() } else { (len * capped).ceil() }.clamp(1.0, 16384.0) as u32;+ (capped, (side(bw), side(bh)))+ }+/// Bake the content (straight RGBA) as placed: warped and mapped by the quad, rendered at/// `k` pixels per document pixel (into `size` pixels when given; see [`Self::placed_size`]).- /// Returns the pixels and their document-space origin.+ /// Returns the pixels and their document-space origin. `None` when the content is empty or+ /// the baked image would exceed [`MAX_BAKE_PIXELS`].pub fn render_placed(&self, content: &Pixels, k: f64, size: Option<(u32, u32)>) -> Option<(Pixels, [f64; 2])> {let (cw, ch) = (content.width as f64, content.height as f64);if content.width == 0 || content.height == 0 {@@ -266,6 +288,7 @@ impl SmartObject {None => self.placed_size(cw, ch, k),};let (ow, oh) = (ow as usize, oh as usize);+ let count = ow.checked_mul(oh).filter(|&c| c as u64 <= MAX_BAKE_PIXELS)?;// A forward grid, filled triangle by triangle with inverse barycentric sampling.let n = 48usize;let mut dst = Vec::with_capacity((n + 1) * (n + 1));@@ -278,7 +301,9 @@ impl SmartObject {src.push(s);}}- let mut out = vec![[0.0f32; 4]; ow * oh];+ let mut out: Vec<[f32; 4]> = Vec::new();+ out.try_reserve_exact(count).ok()?;+ out.resize(count, [0.0; 4]);let sample = |x: f64, y: f64| -> [f32; 4] {let (fx, fy) = ((x - 0.5).clamp(0.0, cw - 1.0), (y - 0.5).clamp(0.0, ch - 1.0));let (x0, y0) = (fx.floor() as usize, fy.floor() as usize);@@ -407,4 +432,34 @@ mod tests {assert!(at(35, 10)[1] > 0.9, "{:?}", at(35, 10));assert_eq!(at(38, 1)[3], 0.0, "outside the trapezoid");}+ #[test]+ fn an_absurd_quad_corner_bakes_within_four_times_the_document_and_2_pow_24_pixels() {+ let doc = (1920u32, 1080u32);+ for far in [1e4, 1e6, 1e12] {+ let s = SmartObject { uuid: "x".into(), quad: [[0.0, 0.0], [far, 5.0], [far, far], [0.0, 20.0]], size: None, warp: None };+ assert!(s.needs_bake());+ // What the importer asks for: the unbounded size is the 16384² clamp, 4 GiB as float RGBA.+ assert_eq!(s.placed_size(100.0, 100.0, 4.0), (16384, 16384));+ let (k, (w, h)) = s.bake_scale(100.0, 100.0, 4.0, doc);+ assert!(k > 0.0 && k <= 4.0, "{k}");+ assert!(w <= doc.0 * 4 && h <= doc.1 * 4, "{w}x{h}");+ assert!(u64::from(w) * u64::from(h) <= MAX_BAKE_PIXELS, "{w}x{h}");+ }+ // A quad inside the document keeps the scale and the size it always had.+ let s = SmartObject { uuid: "x".into(), quad: [[0.0, 0.0], [400.0, 50.0], [400.0, 150.0], [0.0, 200.0]], size: None, warp: None };+ let (k, size) = s.bake_scale(100.0, 100.0, 2.0, doc);+ assert_eq!((k, size), (2.0, s.placed_size(100.0, 100.0, 2.0)));+ // Not-a-number corners stay small too.+ let s = SmartObject { uuid: "x".into(), quad: [[f64::NAN; 2]; 4], size: None, warp: None };+ let (_, (w, h)) = s.bake_scale(100.0, 100.0, 4.0, doc);+ assert!(u64::from(w) * u64::from(h) <= MAX_BAKE_PIXELS);+ }++ #[test]+ fn render_placed_refuses_an_output_over_the_pixel_cap() {+ let content = Pixels { width: 2, height: 1, data: vec![[1.0, 0.0, 0.0, 1.0], [0.0, 1.0, 0.0, 1.0]] };+ let s = SmartObject { uuid: "x".into(), quad: [[0.0, 0.0], [40.0, 5.0], [40.0, 15.0], [0.0, 20.0]], size: None, warp: None };+ assert!(s.render_placed(&content, 1.0, Some((16384, 16384))).is_none());+ assert!(s.render_placed(&content, 1.0, Some((u32::MAX, u32::MAX))).is_none());+ }}