VectorCraft: An open-source, vector art tool written by scratch in pure Rust
refactor(affinity): move model.rs items to model/{bounds,read}.rs
aiongg83fbc0176009
diff --git a/crates/affinity/src/model.rs b/crates/affinity/src/model.rsindex 7f10f8823..a6d18f339 100644--- a/crates/affinity/src/model.rs+++ b/crates/affinity/src/model.rs@@ -8,6 +8,16 @@ use crate::paint::{self, Paint, Stroke};use crate::stream::{ObjId, Stream, Tag};use crate::{Archive, Error, Limits, stream};+mod bounds;+mod read;++pub(crate) use bounds::rect;+pub use bounds::{kind_bounds, nodes_bounds};+pub(crate) use read::Reader;+pub use read::read;+#[cfg(test)]+pub(crate) use read::read_within;+/// Affine map `x' = a·x + c·y + e`, `y' = b·x + d·y + f` (kurbo's coefficient order).#[derive(Debug, Clone, Copy, PartialEq)]pub struct Affine(pub [f64; 6]);@@ -459,743 +469,3 @@ pub struct Document {/// colorimetric intent and black-point compensation in every document checked.pub cmyk_profile: Option<Vec<u8>>,}--/// Largest embedded colour profile kept (real CMYK profiles are a few megabytes).-const MAX_PROFILE_BYTES: usize = 32 << 20;--/// Deepest layer nesting followed; deeper content is reported, not imported.-const MAX_TREE_DEPTH: usize = 128;-/// Total layer nodes imported.-const MAX_NODES: usize = 500_000;--/// Pixels decoded from pixel layers over a whole document (2 GB as RGBA). The archive's limits-/// count the bytes extracted from it, and a layer of one flat colour needs none (#1704).-const MAX_LAYER_PIXELS: u64 = 512 << 20;--/// Embedded documents inside embedded documents are followed this deep.-const MAX_EMBED_DEPTH: usize = 4;-/// Characters of all stories together (a story may be shared by many text layers).-const MAX_DOCUMENT_CHARS: usize = 16 << 20;-/// Table cells of all tables together (each becomes a text object with its edge lines).-const MAX_DOCUMENT_CELLS: usize = 1 << 18;--/// What a whole read may still use. Shared objects can be linked from many layers, and embedded-/// documents are read with what their embedding document left, so linking or embedding the-/// same content many times can't multiply the work.-#[derive(Clone, Copy, Debug)]-pub(crate) struct Budget {- /// Layer nodes ([`MAX_NODES`] in all).- pub(crate) nodes: usize,- /// Pixels the pixel layers may decode ([`MAX_LAYER_PIXELS`] in all).- pub(crate) pixels: u64,- /// Characters of stories ([`MAX_DOCUMENT_CHARS`] in all).- pub(crate) chars: usize,- /// Table cells ([`MAX_DOCUMENT_CELLS`] in all).- pub(crate) cells: usize,-}--impl Budget {- pub(crate) const FULL: Budget = Budget { nodes: MAX_NODES, pixels: MAX_LAYER_PIXELS, chars: MAX_DOCUMENT_CHARS, cells: MAX_DOCUMENT_CELLS };-}--/// Read a document: archive, `doc.dat` and the model.-pub fn read(bytes: &[u8], limits: Limits) -> Result<Document, Error> {- read_within(bytes, limits, MAX_LAYER_PIXELS)-}--/// [`read`], its pixel layers holding at most `pixels` pixels together.-pub(crate) fn read_within(bytes: &[u8], limits: Limits, pixels: u64) -> Result<Document, Error> {- read_at(bytes, limits, &mut Budget { pixels, ..Budget::FULL }, Affine::IDENTITY, 0).document-}--/// A document read by [`read_at`] (or why it couldn't be), with the bytes its archive extracted-/// either way.-struct ReadAt {- document: Result<Document, Error>,- extracted: usize,-}--/// Read a document whose spreads are placed by `base` (for embedded documents, nested `depth`-/// deep). What it uses is taken from `budget`, also when it fails part of the way.-/// The most characters of a layer's name kept.-const MAX_NAME_CHARS: usize = 1024;--fn read_at(bytes: &[u8], limits: Limits, budget: &mut Budget, base: Affine, depth: usize) -> ReadAt {- let mut archive = match Archive::open(bytes, limits) {- Ok(a) => a,- Err(e) => return ReadAt { document: Err(e), extracted: 0 },- };- let document = read_archive(&mut archive, budget, base, depth);- ReadAt { document, extracted: archive.extracted() }-}--fn read_archive(archive: &mut Archive, budget: &mut Budget, base: Affine, depth: usize) -> Result<Document, Error> {- let doc = archive.read("doc.dat")?;- let s = stream::parse(&doc)?;- let mut reader = Reader::new(&s, archive, base, depth);- reader.budget = *budget;- let document = reader.document();- *budget = reader.budget;- document-}--pub(crate) struct Reader<'s, 'a, 'b> {- pub(crate) s: &'s Stream,- pub(crate) archive: &'b mut Archive<'a>,- pub(crate) dpi: f64,- pub(crate) warnings: BTreeMap<String, usize>,- active: HashSet<ObjId>,- /// Where the spreads go: the identity, or an embedding document's placement.- base: Affine,- /// The linear part of `base`, which also scales frame text.- pub(crate) type_base: Affine,- /// How deep inside embedded documents this one is.- depth: usize,- /// An embedded document's content, waiting to become its node's children.- pending: Option<Vec<Node>>,- /// The master spreads, in the order of [`Document::masters`].- master_ids: Vec<ObjId>,- /// What the rest of the read may use.- pub(crate) budget: Budget,-}--impl<'s, 'a, 'b> Reader<'s, 'a, 'b> {- pub(crate) fn new(s: &'s Stream, archive: &'b mut Archive<'a>, base: Affine, depth: usize) -> Self {- let [a, b, c, d, ..] = base.0;- Self {- s,- archive,- dpi: 72.0,- warnings: BTreeMap::new(),- active: HashSet::new(),- base,- type_base: Affine([a, b, c, d, 0.0, 0.0]),- depth,- pending: None,- master_ids: Vec::new(),- budget: Budget::FULL,- }- }-- pub(crate) fn warn(&mut self, what: impl Into<String>) {- *self.warnings.entry(what.into()).or_default() += 1;- }-- /// The document.- fn document(&mut self) -> Result<Document, Error> {- let s = self.s;- let root = s.root;- self.dpi = s.obj(root, b"UVCn").and_then(|u| s.f64(u, b"UPPI")).filter(|d| *d > 0.0 && *d < 100_000.0).unwrap_or(72.0);- let saved_by = s.obj(root, b"NVer").map(|v| {- let product = s.str(v, b"Prod").unwrap_or("Affinity");- match (s.int(v, b"Majr"), s.int(v, b"Minr"), s.int(v, b"Bild")) {- (Some(a), Some(b), Some(c)) => format!("{product} {a}.{b}.{c}"),- _ => product.to_string(),- }- });- let doc = s.obj(root, b"DocR").ok_or(Error::Malformed("document has no root node"))?;- self.master_ids = s.objs(doc, b"MpCh").into_iter().filter(|m| s.is(*m, b"Sprd")).collect();- let mut spreads = Vec::new();- for spread in s.objs(doc, b"Chld") {- if let Some(sp) = self.spread(doc, spread)? {- spreads.push(sp);- }- }- if spreads.is_empty() {- return Err(Error::Malformed("document has no pages"));- }- let mut masters = Vec::new();- for master in self.master_ids.clone() {- match self.spread(doc, master)? {- Some(sp) => masters.push(sp),- // Keep the indices of `MasterInstance::master` valid.- None => masters.push(Spread {- bounds: Rect { x0: 0.0, y0: 0.0, x1: 0.0, y1: 0.0 },- pages: Vec::new(),- transparent: true,- nodes: Vec::new(),- }),- }- }- let cmyk_profile = s- .obj(root, b"CMYP")- .and_then(|p| s.bytes(p, b"Data"))- .filter(|b| b.len() <= MAX_PROFILE_BYTES && b.get(16..20) == Some(b"CMYK".as_slice()))- .map(<[u8]>::to_vec);- let warnings = std::mem::take(&mut self.warnings).into_iter().map(|(w, n)| if n > 1 { format!("{w} ({n}×)") } else { w }).collect();- Ok(Document { dpi: self.dpi, spreads, masters, saved_by, warnings, cmyk_profile })- }-- /// A spread (`Sprd`) of the document `doc`, or of its master spreads.- fn spread(&mut self, doc: ObjId, spread: ObjId) -> Result<Option<Spread>, Error> {- let s = self.s;- if !s.is(spread, b"Sprd") {- self.warn("an unknown kind of page");- return Ok(None);- }- let pages = pages(s, spread);- let default_size = s.floats::<2>(doc, b"DfSz").filter(|[w, h]| *w > 0.0 && *h > 0.0).map(|[w, h]| Rect { x0: 0.0, y0: 0.0, x1: w, y1: h });- let bounds = s.floats::<4>(spread, b"SprB").map(rect).or_else(|| pages.iter().copied().reduce(union)).or(default_size).unwrap_or(Rect {- x0: 0.0,- y0: 0.0,- x1: 0.0,- y1: 0.0,- });- let transparent = s.bool(spread, b"SprT").unwrap_or(false);- let (nodes, mask) = self.children(spread, self.base, 0)?;- if mask.is_some() {- self.warn("mask layers directly on a page (imported without them)");- }- Ok(Some(Spread { bounds, pages, transparent, nodes }))- }-- /// The children of `parent`, and the mask layer among them that masks the parent (with its- /// placement), read later over just what it masks.- #[allow(clippy::type_complexity)]- fn children(&mut self, parent: ObjId, world: Affine, depth: usize) -> Result<(Vec<Node>, Option<(ObjId, Affine)>), Error> {- let s = self.s;- let mut out = Vec::new();- let mut mask = None;- for c in s.objs(parent, b"Chld") {- if s.is(c, b"MRst") {- // A mask layer inside a group or layer masks that container.- if s.bool(c, b"Visi") == Some(false) {- continue;- }- let local = s.floats::<6>(c, b"Xfrm").map(Affine::from_xfrm).unwrap_or(Affine::IDENTITY);- if mask.is_none() {- mask = Some((c, local.then(world)));- } else {- self.warn("several pixel masks on one layer (only the first is used)");- }- continue;- }- if let Some(n) = self.node(c, world, depth + 1)? {- out.push(n);- }- }- Ok((out, mask))- }-- fn node(&mut self, id: ObjId, parent: Affine, depth: usize) -> Result<Option<Node>, Error> {- let s = self.s;- if depth > MAX_TREE_DEPTH {- self.warn("layers nested deeper than 128 levels");- return Ok(None);- }- let Some(left) = self.budget.nodes.checked_sub(1) else {- return Err(Error::Limit("too many layers"));- };- self.budget.nodes = left;- // A node that contains itself (a shared object linked back into its own subtree).- if !self.active.insert(id) {- self.warn("a layer that contains itself");- return Ok(None);- }- let local = s.floats::<6>(id, b"Xfrm").map(Affine::from_xfrm).unwrap_or(Affine::IDENTITY);- let world = local.then(parent);- let class = s.class(id).unwrap_or(Tag(0));- // A layer name is short; a long one is cut, as every visit of a shared object keeps a copy.- let name: String = s.str(id, b"Desc").unwrap_or_default().chars().take(MAX_NAME_CHARS).collect();- let visible = s.bool(id, b"Visi").unwrap_or(true);- let locked = s.bool(id, b"Edtb").is_some_and(|e| !e);- let opacity = s.f64(id, b"Opac").map_or(1.0, |o| o.clamp(0.0, 1.0));- let blend = match s.enumeration(id, b"Blnd") {- None if s.bool(id, b"PasT") != Some(false) && is_container(class) => Blend::PassThrough,- None => Blend::Normal,- Some((i, v)) => Blend::from_enum(i, v).unwrap_or_else(|| {- self.warn("an unknown blend mode (imported as Normal)");- Blend::Normal- }),- };- let kind = if !world.is_finite() {- self.warn("a layer with an invalid transform");- Kind::Unsupported- } else {- self.kind(id, class, world, parent)?- };- // This node's embedded content, before its children's `node` calls can take it.- let embedded = self.pending.take();- // A compound's children are its operands, already merged into its outline.- let (mut children, child_mask) = if class == Tag::of(b"Comp") { (Vec::new(), None) } else { self.children(id, world, depth)? };- if let Some(embedded) = embedded {- children.extend(embedded);- }- // Pixel masks are read only over what they mask (they can span a whole spread at print- // resolution, a gigapixel).- let over = mask_extent(&kind, &children);- let child_mask = match child_mask {- Some((c, at)) => crate::raster::mask(self, c, at, over)?,- None => None,- };- let (mask, attached_mask) = self.attached_masks(id, world, over)?;- let pixel_mask = attached_mask.or(child_mask);- self.active.remove(&id);- let mut node = Node { class, name, visible, locked, opacity, blend, kind, mask, pixel_mask, effects: Vec::new(), children };- // Gradient overlays are laid out over the node's bounds, also while it is hidden.- let bounds = tree_bounds(&node);- node.effects = self.effects(id, world, bounds);- Ok(Some(node))- }-- fn kind(&mut self, id: ObjId, class: Tag, world: Affine, parent: Affine) -> Result<Kind, Error> {- let s = self.s;- Ok(match &class.0.to_be_bytes() {- b"Scop" => Kind::Layer,- b"Grup" => Kind::Group,- b"PCrv" | b"ShpN" | b"Comp" | b"SNEN" | b"SNRR" | b"ShRN" => {- // Affinity 3.2.3's two-board public fixture marks board shapes with an `aprp`- // property object in `phrp`, while older documents use `ABEn`. Ordinary shapes- // in that fixture have neither. See the pinned corpus and validation audit.- if s.bool(id, b"ABEn") == Some(true) || s.obj(id, b"phrp").is_some_and(|p| s.is(p, b"aprp")) {- return Ok(self.artboard(id, world));- }- let Some((local, even_odd)) = crate::geometry::outline(self, id, class, world) else {- self.warn(format!("a {} that could not be read", describe(class)));- return Ok(Kind::Unsupported);- };- let (fills, strokes) = paint::node_paint(self, id, world);- Kind::Shape { path: local.transformed(world), fills, strokes, even_odd }- }- b"TxtT" => match crate::text::table(self, id, world) {- Some(t) => Kind::Table(t),- None => {- self.warn("tables that could not be read");- Kind::Unsupported- }- },- b"TxtA" | b"TxtF" | b"TxtC" => match crate::text::read(self, id, world) {- Some(t) => Kind::Text(t),- None => {- self.warn("text whose story could not be read (master-page text, or an unknown layout)");- Kind::Unsupported- }- },- b"ImgN" | b"Rstr" => match crate::raster::node_image(self, id, world)? {- Some(img) => Kind::Image(img),- None => Kind::Unsupported,- },- b"MPIN" => {- // `SLnk` links the instance with the master spread it shows.- let linked = s.obj(id, b"SLnk").map(|l| s.objs(l, b"ILOb")).unwrap_or_default();- let master = linked.iter().find_map(|o| self.master_ids.iter().position(|m| m == o));- let at = |t: &[u8; 4], default: usize| s.int(id, t).and_then(|v| usize::try_from(v).ok()).unwrap_or(default).min(4096);- match master {- Some(master) => Kind::MasterInstance { master, page: at(b"PgOf", 0), master_page: at(b"MPOf", 0), count: at(b"PgCt", 1) },- None => {- self.warn("master page instances without their master");- Kind::Unsupported- }- }- }- b"EmbN" => match self.embedded_document(id, world) {- // The embedded document itself, as editable content.- Some(nodes) => {- self.pending = Some(nodes);- Kind::Group- }- None => match crate::raster::embedded(self, id, world)? {- Some(img) => {- self.warn("embedded documents and symbols (imported as pictures of them)");- Kind::Image(img)- }- None => {- self.warn("embedded documents and symbols without a cached picture");- Kind::Unsupported- }- },- },- b"FRst" => {- // A fill layer paints its whole bitmap area; its gradient lives in page space.- let b = s.obj(id, b"Bitm");- let size = |t: &[u8; 4]| b.and_then(|b| s.int(b, t)).map(|v| v as f64).filter(|v| *v > 0.0);- match (size(b"BmpW"), size(b"BmpH")) {- (Some(w), Some(h)) => {- let local = Path { subpaths: vec![crate::shapes::rectangle(0.0, 0.0, w, h)] };- let fills = paint::fills(self, id, parent, b"BFFl");- Kind::Shape { path: local.transformed(world), fills, strokes: Vec::new(), even_odd: false }- }- _ => {- self.warn("fill layers without an area");- Kind::Unsupported- }- }- }- _ => {- self.warn(format!("{} layers", describe(class)));- Kind::Unsupported- }- })- }-- /// The enabled layer effects (`FiEf`) of node `id`. The angle convention was measured on the- /// public MIT fx fixture (Patchy): an angle of π/2 with offset 10 shadows 10 below.- fn effects(&mut self, id: ObjId, world: Affine, bounds: Option<Rect>) -> Vec<Effect> {- let s = self.s;- let mut out = Vec::new();- for e in s.objs(id, b"FiEf").into_iter().take(64) {- if s.bool(e, b"Enab") == Some(false) {- continue;- }- // "Scale with object": lengths follow the node's transform; otherwise they are absolute.- let k = if s.bool(e, b"SclO") == Some(true) { world.scale() } else { 1.0 };- let len = |t: &[u8; 4]| s.f64(e, t).filter(|v| v.is_finite() && *v >= 0.0 && *v < 1e6).unwrap_or(0.0) * k;- let opacity = s.f64(e, b"Opac").filter(|v| v.is_finite()).unwrap_or(1.0).clamp(0.0, 1.0);- let angle = s.f64(e, b"Angl").filter(|v| v.is_finite()).unwrap_or(0.0);- let color = s.obj(e, b"Colr").and_then(|c| crate::paint::color(self, c));- let class = s.class(e).map(|c| c.0.to_be_bytes());- match (class.as_ref(), color) {- (Some(b"Shad"), Some(color)) => out.push(Effect::DropShadow { color, opacity, radius: len(b"Radi"), distance: len(b"Offs"), angle }),- (Some(b"InnS"), Some(color)) => out.push(Effect::InnerShadow { color, opacity, radius: len(b"Radi"), distance: len(b"Offs"), angle }),- (Some(b"OutG"), Some(color)) => out.push(Effect::OuterGlow { color, opacity, radius: len(b"Radi") }),- (Some(b"Strk"), Some(color)) if s.enumeration(e, b"Ftyp").is_none_or(|(t, _)| t == 0) => {- let align = s.enumeration(e, b"Alig").map_or(0, |(a, _)| a);- out.push(Effect::Outline { color, opacity, width: len(b"Radi"), align });- }- (Some(b"Strk"), _) => self.warn("gradient outline effects (left out)"),- (Some(b"BevE" | b"EmbE"), _) => {- // No radius, no bevel (as Affinity draws it).- let size = len(b"Radi");- if size > 0.0 {- let white = crate::paint::Color::Rgb { r: 1.0, g: 1.0, b: 1.0, a: 1.0 };- let black = crate::paint::Color::Rgb { r: 0.0, g: 0.0, b: 0.0, a: 1.0 };- let highlight = s.obj(e, b"HiCl").and_then(|c| crate::paint::color(self, c)).unwrap_or(white);- let shadow = s.obj(e, b"ShCl").and_then(|c| crate::paint::color(self, c)).unwrap_or(black);- let shadow_opacity = s.f64(e, b"ShOp").filter(|v| v.is_finite()).unwrap_or(0.75).clamp(0.0, 1.0);- let depth = s.f64(e, b"Dept").filter(|v| v.is_finite()).unwrap_or(5.0);- let azimuth = s.f64(e, b"Azim").filter(|v| v.is_finite()).unwrap_or(std::f64::consts::FRAC_PI_4 * 3.0);- let inner = s.enumeration(e, b"Beve").is_none_or(|(k, _)| k == 0);- out.push(Effect::Bevel { size, depth, angle: azimuth, highlight, highlight_opacity: opacity, shadow, shadow_opacity, inner });- }- }- (Some(b"ColO"), Some(color)) => {- let blend = self.effect_blend(e);- out.push(Effect::ColorOverlay { color, opacity, blend });- }- (Some(b"GrdO"), _) => {- let blend = self.effect_blend(e);- // The gradient's unit space spans the node's bounding box from -1 to 1, centred- // on it (y down): checked against the stored previews of real documents.- let space =- bounds.map(|b| Affine([(b.x1 - b.x0) / 2.0, 0.0, 0.0, (b.y1 - b.y0) / 2.0, (b.x0 + b.x1) / 2.0, (b.y0 + b.y1) / 2.0]));- match (s.obj(e, b"GrFl"), space) {- (Some(fill), Some(space)) => match paint::descriptor(self, fill, space) {- Some(Paint::Gradient(gradient)) => out.push(Effect::GradientOverlay { gradient, opacity, blend }),- Some(Paint::Solid(color)) => out.push(Effect::ColorOverlay { color, opacity, blend }),- _ => {}- },- // Nothing visible to lay it over.- (Some(_), None) => {}- (None, _) => self.warn("gradient overlay effects that could not be read (left out)"),- }- }- (Some(b"ColO"), None) => self.warn("colour overlay effects that could not be read (left out)"),- (Some(b"Gaus"), _) => self.warn("blur effects (left out)"),- _ => self.warn("layer effects of other kinds (left out)"),- }- }- out- }-- /// A layer effect's blend mode (`BlnM`); unknown modes are Normal (warned).- fn effect_blend(&mut self, e: ObjId) -> Blend {- match self.s.enumeration(e, b"BlnM") {- None => Blend::Normal,- Some((i, v)) => Blend::from_enum(i, v).unwrap_or_else(|| {- self.warn("an unknown blend mode (imported as Normal)");- Blend::Normal- }),- }- }-- /// Vector shapes attached to a node (`AdCh`) mask it: it shows only inside their outlines;- /// an attached mask layer is a pixel mask. Adjustments attached the same way are reported.- fn attached_masks(&mut self, id: ObjId, world: Affine, over: Option<Rect>) -> Result<(Option<Path>, Option<Image>), Error> {- let s = self.s;- let attached = s.objs(id, b"AdCh");- let mut mask: Option<Path> = None;- let mut pixels: Option<Image> = None;- for a in attached {- let class = s.class(a).unwrap_or(Tag(0));- if s.bool(a, b"Visi") == Some(false) {- continue;- }- if class == Tag::of(b"PCrv") || class == Tag::of(b"ShpN") || class == Tag::of(b"Comp") {- let local = s.floats::<6>(a, b"Xfrm").map(Affine::from_xfrm).unwrap_or(Affine::IDENTITY).then(world);- if let Some((p, _)) = crate::geometry::outline(self, a, class, local) {- mask.get_or_insert_with(Path::default).subpaths.extend(p.transformed(local).subpaths);- }- } else if class == Tag::of(b"MRst") {- let local = s.floats::<6>(a, b"Xfrm").map(Affine::from_xfrm).unwrap_or(Affine::IDENTITY).then(world);- match crate::raster::mask(self, a, local, over)? {- Some(m) if pixels.is_none() => pixels = Some(m),- Some(_) => self.warn("several pixel masks on one layer (only the first is used)"),- None => {}- }- } else {- self.warn(format!("{} layers attached to other layers (imported without them)", describe(class)));- }- }- Ok((mask, pixels))- }-- /// The content of an Affinity document embedded in this one (`EmbN` whose `EmbC` entry holds- /// `EmDc`, four more bytes and a complete Affinity document): its first spread's nodes,- /// placed so the centre of its page, first artboard or content is the node's origin.- fn embedded_document(&mut self, id: ObjId, world: Affine) -> Option<Vec<Node>> {- let s = self.s;- let entry = s.obj(id, b"Bitm").and_then(|b| s.obj(b, b"EmCn")).and_then(|c| s.entry(c, b"EmbC"))?.to_string();- if entry.is_empty() {- return None;- }- if self.depth >= MAX_EMBED_DEPTH {- self.warn("embedded documents nested more than four deep");- return None;- }- let data = self.archive.read(&entry).ok()?;- let inner = data.strip_prefix(b"EmDc").and_then(|d| d.get(4..))?;- if !crate::is_affinity(inner) {- return None;- }- // A first reading finds its page and resolution, the second places it.- // Both readings are charged to the budget and the archive's limits, also when they fail:- // each does the work.- let mut budget = self.budget;- let probe = read_at(inner, self.archive.remaining(), &mut budget, Affine::IDENTITY, self.depth + 1);- self.budget = budget;- if self.archive.charge(probe.extracted).is_err() {- self.warn("embedded documents beyond the size limit (left out)");- return None;- }- let probe = match probe.document {- Ok(d) => d,- Err(e) => {- self.warn(format!("embedded documents that could not be read ({e})"));- return None;- }- };- let spread = probe.spreads.first()?;- // `PBBx` 2 places the content's own bounds (as with a cached picture); otherwise its page.- let content = s.obj(id, b"Bitm").and_then(|b| s.enumeration(b, b"PBBx")).is_some_and(|(k, _)| k == 2);- let first_board = spread.nodes.iter().find_map(|n| if let Kind::Artboard { rect, .. } = &n.kind { Some(*rect) } else { None });- let page = if content { None } else { spread.pages.first().copied().or(first_board) };- let page = page.or_else(|| nodes_bounds(&spread.nodes)).unwrap_or(spread.bounds);- // Its pixels aren't needed any more: never hold both readings' at once.- drop(probe);- // Its document pixels are the node's units, whatever either document's resolution.- let k = 1.0;- let (cx, cy) = ((page.x0 + page.x1) / 2.0, (page.y0 + page.y1) / 2.0);- let base = Affine([k, 0.0, 0.0, k, -cx * k, -cy * k]).then(world);- if !base.is_finite() {- self.warn("embedded documents with an invalid placement");- return None;- }- let mut budget = self.budget;- let placed = read_at(inner, self.archive.remaining(), &mut budget, base, self.depth + 1);- self.budget = budget;- if self.archive.charge(placed.extracted).is_err() {- self.warn("embedded documents beyond the size limit (left out)");- return None;- }- let doc = placed.document.ok()?;- for w in doc.warnings {- self.warn(format!("{w} [in embedded documents]"));- }- if doc.spreads.len() > 1 {- self.warn("embedded documents with several pages (the first is used)");- }- let mut nodes = doc.spreads.into_iter().next()?.nodes;- // Its master page instances count its own masters, which aren't kept: in this document- // they would show other masters.- fn strip_masters(nodes: &mut [Node], depth: usize) -> bool {- let mut found = false;- for n in nodes {- if matches!(n.kind, Kind::MasterInstance { .. }) {- n.kind = Kind::Unsupported;- found = true;- }- if depth < MAX_TREE_DEPTH {- found |= strip_masters(&mut n.children, depth + 1);- }- }- found- }- if strip_masters(&mut nodes, 0) {- self.warn("master pages of embedded documents (left out)");- }- Some(nodes)- }-- fn artboard(&mut self, id: ObjId, world: Affine) -> Kind {- let s = self.s;- let Some(b) = s.floats::<4>(id, b"ShpB").map(rect).filter(|b| b.x1 > b.x0 && b.y1 > b.y0) else {- self.warn("an artboard without valid bounds (its children are kept without clipping)");- return Kind::Unsupported;- };- let corners =- [Point { x: b.x0, y: b.y0 }, Point { x: b.x1, y: b.y0 }, Point { x: b.x1, y: b.y1 }, Point { x: b.x0, y: b.y1 }].map(|p| world.apply(p));- let [a, b2, c, d, ..] = world.0;- if b2.abs() > 1e-9 || c.abs() > 1e-9 || a <= 0.0 || d <= 0.0 {- self.warn("a rotated or flipped artboard (export bounds are its bounding box; artwork keeps its outline)");- }- let xs = corners.map(|p| p.x);- let ys = corners.map(|p| p.y);- let rect = Rect {- x0: xs.iter().copied().fold(f64::INFINITY, f64::min),- y0: ys.iter().copied().fold(f64::INFINITY, f64::min),- x1: xs.iter().copied().fold(f64::NEG_INFINITY, f64::max),- y1: ys.iter().copied().fold(f64::NEG_INFINITY, f64::max),- };- if ![rect.x0, rect.y0, rect.x1, rect.y1].iter().all(|v| v.is_finite()) || rect.x1 <= rect.x0 || rect.y1 <= rect.y0 {- self.warn("an artboard with an invalid transformed size (its children are kept without clipping)");- return Kind::Unsupported;- }- let class = s.class(id).unwrap_or(Tag::of(b"ShpN"));- let (path, even_odd) = crate::geometry::outline(self, id, class, world).unwrap_or_else(|| {- self.warn("an artboard whose outline could not be read (clipped to its rectangle)");- (Path { subpaths: vec![crate::shapes::rectangle(b.x0, b.y0, b.x1, b.y1)] }, false)- });- let (background, strokes) = paint::node_paint(self, id, world);- Kind::Artboard { rect, path: path.transformed(world), even_odd, background, strokes }- }-}--/// The bounds of what visible `nodes` draw (control points of outlines, corners of images, frames-/// and tables), in document pixels.-pub fn nodes_bounds(nodes: &[Node]) -> Option<Rect> {- let mut out = None;- walk_bounds(nodes, true, 0, &mut out);- out-}--/// The bounds of `node` and everything in it, hidden or not.-fn tree_bounds(node: &Node) -> Option<Rect> {- let mut out = None;- walk_bounds(std::slice::from_ref(node), false, 0, &mut out);- out-}--fn walk_bounds(nodes: &[Node], visible_only: bool, depth: usize, out: &mut Option<Rect>) {- if depth > MAX_TREE_DEPTH {- return;- }- for n in nodes.iter().filter(|n| n.visible || !visible_only) {- kind_points(&n.kind, &mut |p| add_point(out, p));- walk_bounds(&n.children, visible_only, depth + 1, out);- }-}--/// What a pixel mask over a node of `kind` with `children` is read over: the bounds of what they-/// draw, strokes included, or `None` (all of the mask) when some of it has no bounds known here:-/// artistic text, whose glyphs only the layout places.-fn mask_extent(kind: &Kind, children: &[Node]) -> Option<Rect> {- fn visit(kind: &Kind, children: &[Node], depth: usize, out: &mut Option<Rect>) -> bool {- if depth > MAX_TREE_DEPTH || matches!(kind, Kind::Text(t) if t.frame.is_none()) {- return false;- }- let mut own = kind_bounds(kind);- if let (Some(r), Kind::Shape { strokes, .. } | Kind::Artboard { strokes, .. }) = (own, kind) {- // As far as a stroke can reach out of its path, miter joins included.- let reach = strokes.iter().map(|s| s.width * s.miter_limit.clamp(1.0, 10.0)).filter(|w| w.is_finite()).fold(0.0, f64::max);- own = Some(Rect { x0: r.x0 - reach, y0: r.y0 - reach, x1: r.x1 + reach, y1: r.y1 + reach });- }- if let Some(r) = own {- *out = Some(out.map_or(r, |o| union(o, r)));- }- children.iter().filter(|n| n.visible).all(|n| visit(&n.kind, &n.children, depth + 1, out))- }- let mut out = None;- if visit(kind, children, 0, &mut out) { out } else { None }-}--/// The bounds of what one node's own kind draws (not its children): its outline's points, its-/// image's or frame's corners, or artistic text's anchor.-pub fn kind_bounds(kind: &Kind) -> Option<Rect> {- let mut out = None;- kind_points(kind, &mut |p| add_point(&mut out, p));- out-}--fn add_point(out: &mut Option<Rect>, p: Point) {- if p.x.is_finite() && p.y.is_finite() {- let r = Rect { x0: p.x, y0: p.y, x1: p.x, y1: p.y };- *out = Some(out.map_or(r, |o| union(o, r)));- }-}--fn kind_points(kind: &Kind, add: &mut dyn FnMut(Point)) {- let corners = |r: Rect, m: Affine| [(r.x0, r.y0), (r.x1, r.y0), (r.x1, r.y1), (r.x0, r.y1)].map(|(x, y)| m.apply(Point { x, y }));- match kind {- Kind::Shape { path, .. } | Kind::Artboard { path, .. } => {- for sp in &path.subpaths {- add(sp.start);- for seg in &sp.segments {- seg.iter().for_each(|p| add(*p));- }- }- }- Kind::Image(img) => {- corners(Rect { x0: 0.0, y0: 0.0, x1: f64::from(img.width), y1: f64::from(img.height) }, img.transform).into_iter().for_each(add)- }- Kind::Text(t) => match t.frame {- Some(f) => corners(f, t.transform).into_iter().for_each(add),- None => add(t.transform.apply(t.anchor)),- },- Kind::Table(t) => {- if let (Some(&x0), Some(&x1), Some(&y0), Some(&y1)) = (t.columns.first(), t.columns.last(), t.rows.first(), t.rows.last()) {- corners(Rect { x0, y0, x1, y1 }, t.transform).into_iter().for_each(add);- }- }- Kind::Layer | Kind::Group | Kind::Unsupported | Kind::MasterInstance { .. } => {}- }-}--/// Page rectangles: `SpMd.PagR[].rctp` (Publisher 2, Affinity 3) or `SprB` split into `PagC`-/// equal pages (Publisher 1 facing spreads).-fn pages(s: &Stream, spread: ObjId) -> Vec<Rect> {- if let Some(md) = s.obj(spread, b"SpMd") {- let v: Vec<Rect> =- s.objs(md, b"PagR").into_iter().filter_map(|p| s.floats::<4>(p, b"rctp").map(rect)).filter(|r| r.x1 > r.x0 && r.y1 > r.y0).collect();- if !v.is_empty() {- return v;- }- }- match (s.floats::<4>(spread, b"SprB").map(rect), s.int(spread, b"PagC")) {- (Some(b), Some(n @ 2..=16)) => {- let w = (b.x1 - b.x0) / n as f64;- (0..n).map(|i| Rect { x0: b.x0 + w * i as f64, x1: b.x0 + w * (i + 1) as f64, ..b }).collect()- }- _ => Vec::new(),- }-}--pub(crate) fn union(a: Rect, b: Rect) -> Rect {- Rect { x0: a.x0.min(b.x0), y0: a.y0.min(b.y0), x1: a.x1.max(b.x1), y1: a.y1.max(b.y1) }-}--fn is_container(class: Tag) -> bool {- class == Tag::of(b"Scop") || class == Tag::of(b"Grup")-}--pub(crate) fn rect(v: [f64; 4]) -> Rect {- Rect { x0: v[0], y0: v[1], x1: v[2], y1: v[3] }-}--/// A readable name for a layer class in warnings.-pub(crate) fn describe(class: Tag) -> &'static str {- match &class.0.to_be_bytes() {- b"PCrv" => "curve",- b"ShpN" | b"SNEN" | b"SNRR" | b"ShRN" => "shape",- b"Comp" => "compound",- b"Rstr" => "pixel",- b"ImgN" => "image",- b"EmbN" => "embedded document",- b"MPIN" => "master page instance",- b"FRst" => "fill",- b"MRst" => "mask",- b"Slic" | b"SlcP" => "slice",- b"3DLA" => "3D",- [_, _, b'R', b'A'] => "adjustment",- _ => "unknown",- }-}diff --git a/crates/affinity/src/model/bounds.rs b/crates/affinity/src/model/bounds.rsnew file mode 100644index 000000000..0a48193e2--- /dev/null+++ b/crates/affinity/src/model/bounds.rs@@ -0,0 +1,142 @@+use super::read::MAX_TREE_DEPTH;+use super::*;++/// The bounds of what visible `nodes` draw (control points of outlines, corners of images, frames+/// and tables), in document pixels.+pub fn nodes_bounds(nodes: &[Node]) -> Option<Rect> {+ let mut out = None;+ walk_bounds(nodes, true, 0, &mut out);+ out+}++/// The bounds of `node` and everything in it, hidden or not.+pub(super) fn tree_bounds(node: &Node) -> Option<Rect> {+ let mut out = None;+ walk_bounds(std::slice::from_ref(node), false, 0, &mut out);+ out+}++fn walk_bounds(nodes: &[Node], visible_only: bool, depth: usize, out: &mut Option<Rect>) {+ if depth > MAX_TREE_DEPTH {+ return;+ }+ for n in nodes.iter().filter(|n| n.visible || !visible_only) {+ kind_points(&n.kind, &mut |p| add_point(out, p));+ walk_bounds(&n.children, visible_only, depth + 1, out);+ }+}++/// What a pixel mask over a node of `kind` with `children` is read over: the bounds of what they+/// draw, strokes included, or `None` (all of the mask) when some of it has no bounds known here:+/// artistic text, whose glyphs only the layout places.+pub(super) fn mask_extent(kind: &Kind, children: &[Node]) -> Option<Rect> {+ fn visit(kind: &Kind, children: &[Node], depth: usize, out: &mut Option<Rect>) -> bool {+ if depth > MAX_TREE_DEPTH || matches!(kind, Kind::Text(t) if t.frame.is_none()) {+ return false;+ }+ let mut own = kind_bounds(kind);+ if let (Some(r), Kind::Shape { strokes, .. } | Kind::Artboard { strokes, .. }) = (own, kind) {+ // As far as a stroke can reach out of its path, miter joins included.+ let reach = strokes.iter().map(|s| s.width * s.miter_limit.clamp(1.0, 10.0)).filter(|w| w.is_finite()).fold(0.0, f64::max);+ own = Some(Rect { x0: r.x0 - reach, y0: r.y0 - reach, x1: r.x1 + reach, y1: r.y1 + reach });+ }+ if let Some(r) = own {+ *out = Some(out.map_or(r, |o| union(o, r)));+ }+ children.iter().filter(|n| n.visible).all(|n| visit(&n.kind, &n.children, depth + 1, out))+ }+ let mut out = None;+ if visit(kind, children, 0, &mut out) { out } else { None }+}++/// The bounds of what one node's own kind draws (not its children): its outline's points, its+/// image's or frame's corners, or artistic text's anchor.+pub fn kind_bounds(kind: &Kind) -> Option<Rect> {+ let mut out = None;+ kind_points(kind, &mut |p| add_point(&mut out, p));+ out+}++fn add_point(out: &mut Option<Rect>, p: Point) {+ if p.x.is_finite() && p.y.is_finite() {+ let r = Rect { x0: p.x, y0: p.y, x1: p.x, y1: p.y };+ *out = Some(out.map_or(r, |o| union(o, r)));+ }+}++fn kind_points(kind: &Kind, add: &mut dyn FnMut(Point)) {+ let corners = |r: Rect, m: Affine| [(r.x0, r.y0), (r.x1, r.y0), (r.x1, r.y1), (r.x0, r.y1)].map(|(x, y)| m.apply(Point { x, y }));+ match kind {+ Kind::Shape { path, .. } | Kind::Artboard { path, .. } => {+ for sp in &path.subpaths {+ add(sp.start);+ for seg in &sp.segments {+ seg.iter().for_each(|p| add(*p));+ }+ }+ }+ Kind::Image(img) => {+ corners(Rect { x0: 0.0, y0: 0.0, x1: f64::from(img.width), y1: f64::from(img.height) }, img.transform).into_iter().for_each(add)+ }+ Kind::Text(t) => match t.frame {+ Some(f) => corners(f, t.transform).into_iter().for_each(add),+ None => add(t.transform.apply(t.anchor)),+ },+ Kind::Table(t) => {+ if let (Some(&x0), Some(&x1), Some(&y0), Some(&y1)) = (t.columns.first(), t.columns.last(), t.rows.first(), t.rows.last()) {+ corners(Rect { x0, y0, x1, y1 }, t.transform).into_iter().for_each(add);+ }+ }+ Kind::Layer | Kind::Group | Kind::Unsupported | Kind::MasterInstance { .. } => {}+ }+}++/// Page rectangles: `SpMd.PagR[].rctp` (Publisher 2, Affinity 3) or `SprB` split into `PagC`+/// equal pages (Publisher 1 facing spreads).+pub(super) fn pages(s: &Stream, spread: ObjId) -> Vec<Rect> {+ if let Some(md) = s.obj(spread, b"SpMd") {+ let v: Vec<Rect> =+ s.objs(md, b"PagR").into_iter().filter_map(|p| s.floats::<4>(p, b"rctp").map(rect)).filter(|r| r.x1 > r.x0 && r.y1 > r.y0).collect();+ if !v.is_empty() {+ return v;+ }+ }+ match (s.floats::<4>(spread, b"SprB").map(rect), s.int(spread, b"PagC")) {+ (Some(b), Some(n @ 2..=16)) => {+ let w = (b.x1 - b.x0) / n as f64;+ (0..n).map(|i| Rect { x0: b.x0 + w * i as f64, x1: b.x0 + w * (i + 1) as f64, ..b }).collect()+ }+ _ => Vec::new(),+ }+}++pub(crate) fn union(a: Rect, b: Rect) -> Rect {+ Rect { x0: a.x0.min(b.x0), y0: a.y0.min(b.y0), x1: a.x1.max(b.x1), y1: a.y1.max(b.y1) }+}++pub(super) fn is_container(class: Tag) -> bool {+ class == Tag::of(b"Scop") || class == Tag::of(b"Grup")+}++pub(crate) fn rect(v: [f64; 4]) -> Rect {+ Rect { x0: v[0], y0: v[1], x1: v[2], y1: v[3] }+}++/// A readable name for a layer class in warnings.+pub(crate) fn describe(class: Tag) -> &'static str {+ match &class.0.to_be_bytes() {+ b"PCrv" => "curve",+ b"ShpN" | b"SNEN" | b"SNRR" | b"ShRN" => "shape",+ b"Comp" => "compound",+ b"Rstr" => "pixel",+ b"ImgN" => "image",+ b"EmbN" => "embedded document",+ b"MPIN" => "master page instance",+ b"FRst" => "fill",+ b"MRst" => "mask",+ b"Slic" | b"SlcP" => "slice",+ b"3DLA" => "3D",+ [_, _, b'R', b'A'] => "adjustment",+ _ => "unknown",+ }+}diff --git a/crates/affinity/src/model/read.rs b/crates/affinity/src/model/read.rsnew file mode 100644index 000000000..755e93745--- /dev/null+++ b/crates/affinity/src/model/read.rs@@ -0,0 +1,605 @@+use super::bounds::{describe, is_container, mask_extent, nodes_bounds, pages, rect, tree_bounds, union};+use super::*;++/// Largest embedded colour profile kept (real CMYK profiles are a few megabytes).+const MAX_PROFILE_BYTES: usize = 32 << 20;++/// Deepest layer nesting followed; deeper content is reported, not imported.+pub(super) const MAX_TREE_DEPTH: usize = 128;++/// Total layer nodes imported.+const MAX_NODES: usize = 500_000;++/// Pixels decoded from pixel layers over a whole document (2 GB as RGBA). The archive's limits+/// count the bytes extracted from it, and a layer of one flat colour needs none (#1704).+const MAX_LAYER_PIXELS: u64 = 512 << 20;++/// Embedded documents inside embedded documents are followed this deep.+const MAX_EMBED_DEPTH: usize = 4;++/// Characters of all stories together (a story may be shared by many text layers).+const MAX_DOCUMENT_CHARS: usize = 16 << 20;++/// Table cells of all tables together (each becomes a text object with its edge lines).+const MAX_DOCUMENT_CELLS: usize = 1 << 18;++/// What a whole read may still use. Shared objects can be linked from many layers, and embedded+/// documents are read with what their embedding document left, so linking or embedding the+/// same content many times can't multiply the work.+#[derive(Clone, Copy, Debug)]+pub(crate) struct Budget {+ /// Layer nodes ([`MAX_NODES`] in all).+ pub(crate) nodes: usize,+ /// Pixels the pixel layers may decode ([`MAX_LAYER_PIXELS`] in all).+ pub(crate) pixels: u64,+ /// Characters of stories ([`MAX_DOCUMENT_CHARS`] in all).+ pub(crate) chars: usize,+ /// Table cells ([`MAX_DOCUMENT_CELLS`] in all).+ pub(crate) cells: usize,+}++impl Budget {+ pub(crate) const FULL: Budget = Budget { nodes: MAX_NODES, pixels: MAX_LAYER_PIXELS, chars: MAX_DOCUMENT_CHARS, cells: MAX_DOCUMENT_CELLS };+}++/// Read a document: archive, `doc.dat` and the model.+pub fn read(bytes: &[u8], limits: Limits) -> Result<Document, Error> {+ read_within(bytes, limits, MAX_LAYER_PIXELS)+}++/// [`read`], its pixel layers holding at most `pixels` pixels together.+pub(crate) fn read_within(bytes: &[u8], limits: Limits, pixels: u64) -> Result<Document, Error> {+ read_at(bytes, limits, &mut Budget { pixels, ..Budget::FULL }, Affine::IDENTITY, 0).document+}++/// A document read by [`read_at`] (or why it couldn't be), with the bytes its archive extracted+/// either way.+struct ReadAt {+ document: Result<Document, Error>,+ extracted: usize,+}++/// Read a document whose spreads are placed by `base` (for embedded documents, nested `depth`+/// deep). What it uses is taken from `budget`, also when it fails part of the way.+/// The most characters of a layer's name kept.+const MAX_NAME_CHARS: usize = 1024;++fn read_at(bytes: &[u8], limits: Limits, budget: &mut Budget, base: Affine, depth: usize) -> ReadAt {+ let mut archive = match Archive::open(bytes, limits) {+ Ok(a) => a,+ Err(e) => return ReadAt { document: Err(e), extracted: 0 },+ };+ let document = read_archive(&mut archive, budget, base, depth);+ ReadAt { document, extracted: archive.extracted() }+}++fn read_archive(archive: &mut Archive, budget: &mut Budget, base: Affine, depth: usize) -> Result<Document, Error> {+ let doc = archive.read("doc.dat")?;+ let s = stream::parse(&doc)?;+ let mut reader = Reader::new(&s, archive, base, depth);+ reader.budget = *budget;+ let document = reader.document();+ *budget = reader.budget;+ document+}++pub(crate) struct Reader<'s, 'a, 'b> {+ pub(crate) s: &'s Stream,+ pub(crate) archive: &'b mut Archive<'a>,+ pub(crate) dpi: f64,+ pub(crate) warnings: BTreeMap<String, usize>,+ active: HashSet<ObjId>,+ /// Where the spreads go: the identity, or an embedding document's placement.+ base: Affine,+ /// The linear part of `base`, which also scales frame text.+ pub(crate) type_base: Affine,+ /// How deep inside embedded documents this one is.+ depth: usize,+ /// An embedded document's content, waiting to become its node's children.+ pending: Option<Vec<Node>>,+ /// The master spreads, in the order of [`Document::masters`].+ master_ids: Vec<ObjId>,+ /// What the rest of the read may use.+ pub(crate) budget: Budget,+}++impl<'s, 'a, 'b> Reader<'s, 'a, 'b> {+ pub(crate) fn new(s: &'s Stream, archive: &'b mut Archive<'a>, base: Affine, depth: usize) -> Self {+ let [a, b, c, d, ..] = base.0;+ Self {+ s,+ archive,+ dpi: 72.0,+ warnings: BTreeMap::new(),+ active: HashSet::new(),+ base,+ type_base: Affine([a, b, c, d, 0.0, 0.0]),+ depth,+ pending: None,+ master_ids: Vec::new(),+ budget: Budget::FULL,+ }+ }++ pub(crate) fn warn(&mut self, what: impl Into<String>) {+ *self.warnings.entry(what.into()).or_default() += 1;+ }++ /// The document.+ fn document(&mut self) -> Result<Document, Error> {+ let s = self.s;+ let root = s.root;+ self.dpi = s.obj(root, b"UVCn").and_then(|u| s.f64(u, b"UPPI")).filter(|d| *d > 0.0 && *d < 100_000.0).unwrap_or(72.0);+ let saved_by = s.obj(root, b"NVer").map(|v| {+ let product = s.str(v, b"Prod").unwrap_or("Affinity");+ match (s.int(v, b"Majr"), s.int(v, b"Minr"), s.int(v, b"Bild")) {+ (Some(a), Some(b), Some(c)) => format!("{product} {a}.{b}.{c}"),+ _ => product.to_string(),+ }+ });+ let doc = s.obj(root, b"DocR").ok_or(Error::Malformed("document has no root node"))?;+ self.master_ids = s.objs(doc, b"MpCh").into_iter().filter(|m| s.is(*m, b"Sprd")).collect();+ let mut spreads = Vec::new();+ for spread in s.objs(doc, b"Chld") {+ if let Some(sp) = self.spread(doc, spread)? {+ spreads.push(sp);+ }+ }+ if spreads.is_empty() {+ return Err(Error::Malformed("document has no pages"));+ }+ let mut masters = Vec::new();+ for master in self.master_ids.clone() {+ match self.spread(doc, master)? {+ Some(sp) => masters.push(sp),+ // Keep the indices of `MasterInstance::master` valid.+ None => masters.push(Spread {+ bounds: Rect { x0: 0.0, y0: 0.0, x1: 0.0, y1: 0.0 },+ pages: Vec::new(),+ transparent: true,+ nodes: Vec::new(),+ }),+ }+ }+ let cmyk_profile = s+ .obj(root, b"CMYP")+ .and_then(|p| s.bytes(p, b"Data"))+ .filter(|b| b.len() <= MAX_PROFILE_BYTES && b.get(16..20) == Some(b"CMYK".as_slice()))+ .map(<[u8]>::to_vec);+ let warnings = std::mem::take(&mut self.warnings).into_iter().map(|(w, n)| if n > 1 { format!("{w} ({n}×)") } else { w }).collect();+ Ok(Document { dpi: self.dpi, spreads, masters, saved_by, warnings, cmyk_profile })+ }++ /// A spread (`Sprd`) of the document `doc`, or of its master spreads.+ fn spread(&mut self, doc: ObjId, spread: ObjId) -> Result<Option<Spread>, Error> {+ let s = self.s;+ if !s.is(spread, b"Sprd") {+ self.warn("an unknown kind of page");+ return Ok(None);+ }+ let pages = pages(s, spread);+ let default_size = s.floats::<2>(doc, b"DfSz").filter(|[w, h]| *w > 0.0 && *h > 0.0).map(|[w, h]| Rect { x0: 0.0, y0: 0.0, x1: w, y1: h });+ let bounds = s.floats::<4>(spread, b"SprB").map(rect).or_else(|| pages.iter().copied().reduce(union)).or(default_size).unwrap_or(Rect {+ x0: 0.0,+ y0: 0.0,+ x1: 0.0,+ y1: 0.0,+ });+ let transparent = s.bool(spread, b"SprT").unwrap_or(false);+ let (nodes, mask) = self.children(spread, self.base, 0)?;+ if mask.is_some() {+ self.warn("mask layers directly on a page (imported without them)");+ }+ Ok(Some(Spread { bounds, pages, transparent, nodes }))+ }++ /// The children of `parent`, and the mask layer among them that masks the parent (with its+ /// placement), read later over just what it masks.+ #[allow(clippy::type_complexity)]+ fn children(&mut self, parent: ObjId, world: Affine, depth: usize) -> Result<(Vec<Node>, Option<(ObjId, Affine)>), Error> {+ let s = self.s;+ let mut out = Vec::new();+ let mut mask = None;+ for c in s.objs(parent, b"Chld") {+ if s.is(c, b"MRst") {+ // A mask layer inside a group or layer masks that container.+ if s.bool(c, b"Visi") == Some(false) {+ continue;+ }+ let local = s.floats::<6>(c, b"Xfrm").map(Affine::from_xfrm).unwrap_or(Affine::IDENTITY);+ if mask.is_none() {+ mask = Some((c, local.then(world)));+ } else {+ self.warn("several pixel masks on one layer (only the first is used)");+ }+ continue;+ }+ if let Some(n) = self.node(c, world, depth + 1)? {+ out.push(n);+ }+ }+ Ok((out, mask))+ }++ fn node(&mut self, id: ObjId, parent: Affine, depth: usize) -> Result<Option<Node>, Error> {+ let s = self.s;+ if depth > MAX_TREE_DEPTH {+ self.warn("layers nested deeper than 128 levels");+ return Ok(None);+ }+ let Some(left) = self.budget.nodes.checked_sub(1) else {+ return Err(Error::Limit("too many layers"));+ };+ self.budget.nodes = left;+ // A node that contains itself (a shared object linked back into its own subtree).+ if !self.active.insert(id) {+ self.warn("a layer that contains itself");+ return Ok(None);+ }+ let local = s.floats::<6>(id, b"Xfrm").map(Affine::from_xfrm).unwrap_or(Affine::IDENTITY);+ let world = local.then(parent);+ let class = s.class(id).unwrap_or(Tag(0));+ // A layer name is short; a long one is cut, as every visit of a shared object keeps a copy.+ let name: String = s.str(id, b"Desc").unwrap_or_default().chars().take(MAX_NAME_CHARS).collect();+ let visible = s.bool(id, b"Visi").unwrap_or(true);+ let locked = s.bool(id, b"Edtb").is_some_and(|e| !e);+ let opacity = s.f64(id, b"Opac").map_or(1.0, |o| o.clamp(0.0, 1.0));+ let blend = match s.enumeration(id, b"Blnd") {+ None if s.bool(id, b"PasT") != Some(false) && is_container(class) => Blend::PassThrough,+ None => Blend::Normal,+ Some((i, v)) => Blend::from_enum(i, v).unwrap_or_else(|| {+ self.warn("an unknown blend mode (imported as Normal)");+ Blend::Normal+ }),+ };+ let kind = if !world.is_finite() {+ self.warn("a layer with an invalid transform");+ Kind::Unsupported+ } else {+ self.kind(id, class, world, parent)?+ };+ // This node's embedded content, before its children's `node` calls can take it.+ let embedded = self.pending.take();+ // A compound's children are its operands, already merged into its outline.+ let (mut children, child_mask) = if class == Tag::of(b"Comp") { (Vec::new(), None) } else { self.children(id, world, depth)? };+ if let Some(embedded) = embedded {+ children.extend(embedded);+ }+ // Pixel masks are read only over what they mask (they can span a whole spread at print+ // resolution, a gigapixel).+ let over = mask_extent(&kind, &children);+ let child_mask = match child_mask {+ Some((c, at)) => crate::raster::mask(self, c, at, over)?,+ None => None,+ };+ let (mask, attached_mask) = self.attached_masks(id, world, over)?;+ let pixel_mask = attached_mask.or(child_mask);+ self.active.remove(&id);+ let mut node = Node { class, name, visible, locked, opacity, blend, kind, mask, pixel_mask, effects: Vec::new(), children };+ // Gradient overlays are laid out over the node's bounds, also while it is hidden.+ let bounds = tree_bounds(&node);+ node.effects = self.effects(id, world, bounds);+ Ok(Some(node))+ }++ fn kind(&mut self, id: ObjId, class: Tag, world: Affine, parent: Affine) -> Result<Kind, Error> {+ let s = self.s;+ Ok(match &class.0.to_be_bytes() {+ b"Scop" => Kind::Layer,+ b"Grup" => Kind::Group,+ b"PCrv" | b"ShpN" | b"Comp" | b"SNEN" | b"SNRR" | b"ShRN" => {+ // Affinity 3.2.3's two-board public fixture marks board shapes with an `aprp`+ // property object in `phrp`, while older documents use `ABEn`. Ordinary shapes+ // in that fixture have neither. See the pinned corpus and validation audit.+ if s.bool(id, b"ABEn") == Some(true) || s.obj(id, b"phrp").is_some_and(|p| s.is(p, b"aprp")) {+ return Ok(self.artboard(id, world));+ }+ let Some((local, even_odd)) = crate::geometry::outline(self, id, class, world) else {+ self.warn(format!("a {} that could not be read", describe(class)));+ return Ok(Kind::Unsupported);+ };+ let (fills, strokes) = paint::node_paint(self, id, world);+ Kind::Shape { path: local.transformed(world), fills, strokes, even_odd }+ }+ b"TxtT" => match crate::text::table(self, id, world) {+ Some(t) => Kind::Table(t),+ None => {+ self.warn("tables that could not be read");+ Kind::Unsupported+ }+ },+ b"TxtA" | b"TxtF" | b"TxtC" => match crate::text::read(self, id, world) {+ Some(t) => Kind::Text(t),+ None => {+ self.warn("text whose story could not be read (master-page text, or an unknown layout)");+ Kind::Unsupported+ }+ },+ b"ImgN" | b"Rstr" => match crate::raster::node_image(self, id, world)? {+ Some(img) => Kind::Image(img),+ None => Kind::Unsupported,+ },+ b"MPIN" => {+ // `SLnk` links the instance with the master spread it shows.+ let linked = s.obj(id, b"SLnk").map(|l| s.objs(l, b"ILOb")).unwrap_or_default();+ let master = linked.iter().find_map(|o| self.master_ids.iter().position(|m| m == o));+ let at = |t: &[u8; 4], default: usize| s.int(id, t).and_then(|v| usize::try_from(v).ok()).unwrap_or(default).min(4096);+ match master {+ Some(master) => Kind::MasterInstance { master, page: at(b"PgOf", 0), master_page: at(b"MPOf", 0), count: at(b"PgCt", 1) },+ None => {+ self.warn("master page instances without their master");+ Kind::Unsupported+ }+ }+ }+ b"EmbN" => match self.embedded_document(id, world) {+ // The embedded document itself, as editable content.+ Some(nodes) => {+ self.pending = Some(nodes);+ Kind::Group+ }+ None => match crate::raster::embedded(self, id, world)? {+ Some(img) => {+ self.warn("embedded documents and symbols (imported as pictures of them)");+ Kind::Image(img)+ }+ None => {+ self.warn("embedded documents and symbols without a cached picture");+ Kind::Unsupported+ }+ },+ },+ b"FRst" => {+ // A fill layer paints its whole bitmap area; its gradient lives in page space.+ let b = s.obj(id, b"Bitm");+ let size = |t: &[u8; 4]| b.and_then(|b| s.int(b, t)).map(|v| v as f64).filter(|v| *v > 0.0);+ match (size(b"BmpW"), size(b"BmpH")) {+ (Some(w), Some(h)) => {+ let local = Path { subpaths: vec![crate::shapes::rectangle(0.0, 0.0, w, h)] };+ let fills = paint::fills(self, id, parent, b"BFFl");+ Kind::Shape { path: local.transformed(world), fills, strokes: Vec::new(), even_odd: false }+ }+ _ => {+ self.warn("fill layers without an area");+ Kind::Unsupported+ }+ }+ }+ _ => {+ self.warn(format!("{} layers", describe(class)));+ Kind::Unsupported+ }+ })+ }++ /// The enabled layer effects (`FiEf`) of node `id`. The angle convention was measured on the+ /// public MIT fx fixture (Patchy): an angle of π/2 with offset 10 shadows 10 below.+ fn effects(&mut self, id: ObjId, world: Affine, bounds: Option<Rect>) -> Vec<Effect> {+ let s = self.s;+ let mut out = Vec::new();+ for e in s.objs(id, b"FiEf").into_iter().take(64) {+ if s.bool(e, b"Enab") == Some(false) {+ continue;+ }+ // "Scale with object": lengths follow the node's transform; otherwise they are absolute.+ let k = if s.bool(e, b"SclO") == Some(true) { world.scale() } else { 1.0 };+ let len = |t: &[u8; 4]| s.f64(e, t).filter(|v| v.is_finite() && *v >= 0.0 && *v < 1e6).unwrap_or(0.0) * k;+ let opacity = s.f64(e, b"Opac").filter(|v| v.is_finite()).unwrap_or(1.0).clamp(0.0, 1.0);+ let angle = s.f64(e, b"Angl").filter(|v| v.is_finite()).unwrap_or(0.0);+ let color = s.obj(e, b"Colr").and_then(|c| crate::paint::color(self, c));+ let class = s.class(e).map(|c| c.0.to_be_bytes());+ match (class.as_ref(), color) {+ (Some(b"Shad"), Some(color)) => out.push(Effect::DropShadow { color, opacity, radius: len(b"Radi"), distance: len(b"Offs"), angle }),+ (Some(b"InnS"), Some(color)) => out.push(Effect::InnerShadow { color, opacity, radius: len(b"Radi"), distance: len(b"Offs"), angle }),+ (Some(b"OutG"), Some(color)) => out.push(Effect::OuterGlow { color, opacity, radius: len(b"Radi") }),+ (Some(b"Strk"), Some(color)) if s.enumeration(e, b"Ftyp").is_none_or(|(t, _)| t == 0) => {+ let align = s.enumeration(e, b"Alig").map_or(0, |(a, _)| a);+ out.push(Effect::Outline { color, opacity, width: len(b"Radi"), align });+ }+ (Some(b"Strk"), _) => self.warn("gradient outline effects (left out)"),+ (Some(b"BevE" | b"EmbE"), _) => {+ // No radius, no bevel (as Affinity draws it).+ let size = len(b"Radi");+ if size > 0.0 {+ let white = crate::paint::Color::Rgb { r: 1.0, g: 1.0, b: 1.0, a: 1.0 };+ let black = crate::paint::Color::Rgb { r: 0.0, g: 0.0, b: 0.0, a: 1.0 };+ let highlight = s.obj(e, b"HiCl").and_then(|c| crate::paint::color(self, c)).unwrap_or(white);+ let shadow = s.obj(e, b"ShCl").and_then(|c| crate::paint::color(self, c)).unwrap_or(black);+ let shadow_opacity = s.f64(e, b"ShOp").filter(|v| v.is_finite()).unwrap_or(0.75).clamp(0.0, 1.0);+ let depth = s.f64(e, b"Dept").filter(|v| v.is_finite()).unwrap_or(5.0);+ let azimuth = s.f64(e, b"Azim").filter(|v| v.is_finite()).unwrap_or(std::f64::consts::FRAC_PI_4 * 3.0);+ let inner = s.enumeration(e, b"Beve").is_none_or(|(k, _)| k == 0);+ out.push(Effect::Bevel { size, depth, angle: azimuth, highlight, highlight_opacity: opacity, shadow, shadow_opacity, inner });+ }+ }+ (Some(b"ColO"), Some(color)) => {+ let blend = self.effect_blend(e);+ out.push(Effect::ColorOverlay { color, opacity, blend });+ }+ (Some(b"GrdO"), _) => {+ let blend = self.effect_blend(e);+ // The gradient's unit space spans the node's bounding box from -1 to 1, centred+ // on it (y down): checked against the stored previews of real documents.+ let space =+ bounds.map(|b| Affine([(b.x1 - b.x0) / 2.0, 0.0, 0.0, (b.y1 - b.y0) / 2.0, (b.x0 + b.x1) / 2.0, (b.y0 + b.y1) / 2.0]));+ match (s.obj(e, b"GrFl"), space) {+ (Some(fill), Some(space)) => match paint::descriptor(self, fill, space) {+ Some(Paint::Gradient(gradient)) => out.push(Effect::GradientOverlay { gradient, opacity, blend }),+ Some(Paint::Solid(color)) => out.push(Effect::ColorOverlay { color, opacity, blend }),+ _ => {}+ },+ // Nothing visible to lay it over.+ (Some(_), None) => {}+ (None, _) => self.warn("gradient overlay effects that could not be read (left out)"),+ }+ }+ (Some(b"ColO"), None) => self.warn("colour overlay effects that could not be read (left out)"),+ (Some(b"Gaus"), _) => self.warn("blur effects (left out)"),+ _ => self.warn("layer effects of other kinds (left out)"),+ }+ }+ out+ }++ /// A layer effect's blend mode (`BlnM`); unknown modes are Normal (warned).+ fn effect_blend(&mut self, e: ObjId) -> Blend {+ match self.s.enumeration(e, b"BlnM") {+ None => Blend::Normal,+ Some((i, v)) => Blend::from_enum(i, v).unwrap_or_else(|| {+ self.warn("an unknown blend mode (imported as Normal)");+ Blend::Normal+ }),+ }+ }++ /// Vector shapes attached to a node (`AdCh`) mask it: it shows only inside their outlines;+ /// an attached mask layer is a pixel mask. Adjustments attached the same way are reported.+ fn attached_masks(&mut self, id: ObjId, world: Affine, over: Option<Rect>) -> Result<(Option<Path>, Option<Image>), Error> {+ let s = self.s;+ let attached = s.objs(id, b"AdCh");+ let mut mask: Option<Path> = None;+ let mut pixels: Option<Image> = None;+ for a in attached {+ let class = s.class(a).unwrap_or(Tag(0));+ if s.bool(a, b"Visi") == Some(false) {+ continue;+ }+ if class == Tag::of(b"PCrv") || class == Tag::of(b"ShpN") || class == Tag::of(b"Comp") {+ let local = s.floats::<6>(a, b"Xfrm").map(Affine::from_xfrm).unwrap_or(Affine::IDENTITY).then(world);+ if let Some((p, _)) = crate::geometry::outline(self, a, class, local) {+ mask.get_or_insert_with(Path::default).subpaths.extend(p.transformed(local).subpaths);+ }+ } else if class == Tag::of(b"MRst") {+ let local = s.floats::<6>(a, b"Xfrm").map(Affine::from_xfrm).unwrap_or(Affine::IDENTITY).then(world);+ match crate::raster::mask(self, a, local, over)? {+ Some(m) if pixels.is_none() => pixels = Some(m),+ Some(_) => self.warn("several pixel masks on one layer (only the first is used)"),+ None => {}+ }+ } else {+ self.warn(format!("{} layers attached to other layers (imported without them)", describe(class)));+ }+ }+ Ok((mask, pixels))+ }++ /// The content of an Affinity document embedded in this one (`EmbN` whose `EmbC` entry holds+ /// `EmDc`, four more bytes and a complete Affinity document): its first spread's nodes,+ /// placed so the centre of its page, first artboard or content is the node's origin.+ fn embedded_document(&mut self, id: ObjId, world: Affine) -> Option<Vec<Node>> {+ let s = self.s;+ let entry = s.obj(id, b"Bitm").and_then(|b| s.obj(b, b"EmCn")).and_then(|c| s.entry(c, b"EmbC"))?.to_string();+ if entry.is_empty() {+ return None;+ }+ if self.depth >= MAX_EMBED_DEPTH {+ self.warn("embedded documents nested more than four deep");+ return None;+ }+ let data = self.archive.read(&entry).ok()?;+ let inner = data.strip_prefix(b"EmDc").and_then(|d| d.get(4..))?;+ if !crate::is_affinity(inner) {+ return None;+ }+ // A first reading finds its page and resolution, the second places it.+ // Both readings are charged to the budget and the archive's limits, also when they fail:+ // each does the work.+ let mut budget = self.budget;+ let probe = read_at(inner, self.archive.remaining(), &mut budget, Affine::IDENTITY, self.depth + 1);+ self.budget = budget;+ if self.archive.charge(probe.extracted).is_err() {+ self.warn("embedded documents beyond the size limit (left out)");+ return None;+ }+ let probe = match probe.document {+ Ok(d) => d,+ Err(e) => {+ self.warn(format!("embedded documents that could not be read ({e})"));+ return None;+ }+ };+ let spread = probe.spreads.first()?;+ // `PBBx` 2 places the content's own bounds (as with a cached picture); otherwise its page.+ let content = s.obj(id, b"Bitm").and_then(|b| s.enumeration(b, b"PBBx")).is_some_and(|(k, _)| k == 2);+ let first_board = spread.nodes.iter().find_map(|n| if let Kind::Artboard { rect, .. } = &n.kind { Some(*rect) } else { None });+ let page = if content { None } else { spread.pages.first().copied().or(first_board) };+ let page = page.or_else(|| nodes_bounds(&spread.nodes)).unwrap_or(spread.bounds);+ // Its pixels aren't needed any more: never hold both readings' at once.+ drop(probe);+ // Its document pixels are the node's units, whatever either document's resolution.+ let k = 1.0;+ let (cx, cy) = ((page.x0 + page.x1) / 2.0, (page.y0 + page.y1) / 2.0);+ let base = Affine([k, 0.0, 0.0, k, -cx * k, -cy * k]).then(world);+ if !base.is_finite() {+ self.warn("embedded documents with an invalid placement");+ return None;+ }+ let mut budget = self.budget;+ let placed = read_at(inner, self.archive.remaining(), &mut budget, base, self.depth + 1);+ self.budget = budget;+ if self.archive.charge(placed.extracted).is_err() {+ self.warn("embedded documents beyond the size limit (left out)");+ return None;+ }+ let doc = placed.document.ok()?;+ for w in doc.warnings {+ self.warn(format!("{w} [in embedded documents]"));+ }+ if doc.spreads.len() > 1 {+ self.warn("embedded documents with several pages (the first is used)");+ }+ let mut nodes = doc.spreads.into_iter().next()?.nodes;+ // Its master page instances count its own masters, which aren't kept: in this document+ // they would show other masters.+ fn strip_masters(nodes: &mut [Node], depth: usize) -> bool {+ let mut found = false;+ for n in nodes {+ if matches!(n.kind, Kind::MasterInstance { .. }) {+ n.kind = Kind::Unsupported;+ found = true;+ }+ if depth < MAX_TREE_DEPTH {+ found |= strip_masters(&mut n.children, depth + 1);+ }+ }+ found+ }+ if strip_masters(&mut nodes, 0) {+ self.warn("master pages of embedded documents (left out)");+ }+ Some(nodes)+ }++ fn artboard(&mut self, id: ObjId, world: Affine) -> Kind {+ let s = self.s;+ let Some(b) = s.floats::<4>(id, b"ShpB").map(rect).filter(|b| b.x1 > b.x0 && b.y1 > b.y0) else {+ self.warn("an artboard without valid bounds (its children are kept without clipping)");+ return Kind::Unsupported;+ };+ let corners =+ [Point { x: b.x0, y: b.y0 }, Point { x: b.x1, y: b.y0 }, Point { x: b.x1, y: b.y1 }, Point { x: b.x0, y: b.y1 }].map(|p| world.apply(p));+ let [a, b2, c, d, ..] = world.0;+ if b2.abs() > 1e-9 || c.abs() > 1e-9 || a <= 0.0 || d <= 0.0 {+ self.warn("a rotated or flipped artboard (export bounds are its bounding box; artwork keeps its outline)");+ }+ let xs = corners.map(|p| p.x);+ let ys = corners.map(|p| p.y);+ let rect = Rect {+ x0: xs.iter().copied().fold(f64::INFINITY, f64::min),+ y0: ys.iter().copied().fold(f64::INFINITY, f64::min),+ x1: xs.iter().copied().fold(f64::NEG_INFINITY, f64::max),+ y1: ys.iter().copied().fold(f64::NEG_INFINITY, f64::max),+ };+ if ![rect.x0, rect.y0, rect.x1, rect.y1].iter().all(|v| v.is_finite()) || rect.x1 <= rect.x0 || rect.y1 <= rect.y0 {+ self.warn("an artboard with an invalid transformed size (its children are kept without clipping)");+ return Kind::Unsupported;+ }+ let class = s.class(id).unwrap_or(Tag::of(b"ShpN"));+ let (path, even_odd) = crate::geometry::outline(self, id, class, world).unwrap_or_else(|| {+ self.warn("an artboard whose outline could not be read (clipped to its rectangle)");+ (Path { subpaths: vec![crate::shapes::rectangle(b.x0, b.y0, b.x1, b.y1)] }, false)+ });+ let (background, strokes) = paint::node_paint(self, id, world);+ Kind::Artboard { rect, path: path.transformed(world), even_odd, background, strokes }+ }+}