refactor(cdr): use shared craft-cdr from craft-libs (#8857)

* refactor(cdr): depend on shared craft-cdr from craft-libs (#1665)

Replaces the local crates/cdr (vectorcraft-cdr) crate with craft-cdr
from storytold/craft-libs#2697 (storytold/craft-libs#778), keeping
VectorCraft's document/artboard/layer/shape mapping in crates/engine.

Co-authored-by: dotCooCoo <[email protected]>

* build(cdr): pin craft-cdr to craft-libs main (75d179f8df)

* build(cdr): pin craft-cdr to craft-libs main (9b28b56bc7)

* docs(cdr): point CDR/CMX provenance and test paths to craft-cdr

---------

Co-authored-by: dotCooCoo <[email protected]>
This commit is contained in:
Dylan M. Taylor
2026-11-20 20:27:55 -05:00
committed by GitHub
co-authored by dotCooCoo
parent ef2cf470e3
commit 82d5aabeec
39 changed files with 42 additions and 9671 deletions
Generated
+10 -11
View File
@@ -1009,6 +1009,15 @@ dependencies = [
"ruzstd",
]
[[package]]
name = "craft-cdr"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=9b28b56bc7207ef7ce806f37df72cb94c0ad5c37#9b28b56bc7207ef7ce806f37df72cb94c0ad5c37"
dependencies = [
"crc32fast",
"flate2",
]
[[package]]
name = "craft-cms"
version = "0.1.0"
@@ -6724,16 +6733,6 @@ dependencies = [
"vectorcraft-text",
]
[[package]]
name = "vectorcraft-cdr"
version = "0.24.1"
dependencies = [
"crc32fast",
"flate2",
"proptest",
"vectorcraft-cdr",
]
[[package]]
name = "vectorcraft-cli"
version = "0.24.1"
@@ -6818,6 +6817,7 @@ version = "0.24.1"
dependencies = [
"cfb",
"chrono",
"craft-cdr",
"craft-docpath",
"craft-image-codecs",
"craft-jxl",
@@ -6849,7 +6849,6 @@ dependencies = [
"vectorcraft-apischema",
"vectorcraft-brush",
"vectorcraft-cad",
"vectorcraft-cdr",
"vectorcraft-color",
"vectorcraft-doc",
"vectorcraft-eps",
+2 -1
View File
@@ -27,6 +27,8 @@ craft-gzip = { git = "https://github.com/storytold/craft-libs", rev = "d7c9632bf
# craft-update: app-specific pretend versions apply to startup and manual checks.
# Native Affinity documents (craft-libs#914).
craft-affinity = { git = "https://github.com/storytold/craft-libs", rev = "d7c9632bfb3040cf45db394e7500cc93c81c49e0" }
# Bounded CDR (v1-v27) and CMX (32-bit) reader (craft-libs#778).
craft-cdr = { git = "https://github.com/storytold/craft-libs", rev = "9b28b56bc7207ef7ce806f37df72cb94c0ad5c37" }
# SVG parsing, limits, SVGZ and writer (craft-libs#778).
craft-svg = { git = "https://github.com/storytold/craft-libs", rev = "d7c9632bfb3040cf45db394e7500cc93c81c49e0", features = ["tree"] }
craft-mime = { git = "https://github.com/storytold/craft-libs", rev = "d7c9632bfb3040cf45db394e7500cc93c81c49e0" }
@@ -78,7 +80,6 @@ vectorcraft-affinity = { path = "crates/affinity" }
vectorcraft-scriptcheck = { path = "crates/scriptcheck" }
vectorcraft-js = { path = "crates/js" }
vectorcraft-apischema = { path = "crates/apischema" }
vectorcraft-cdr = { path = "crates/cdr" }
# foundation
kurbo = { version = "0.13", features = ["serde"] }
-22
View File
@@ -1,22 +0,0 @@
[package]
name = "vectorcraft-cdr"
description = "Bounded reader for .cdr drawings of versions 1 to 27 and .cmx files: WL records, RIFF index, compressed lists, ZIP packages, shapes, fills, outlines, pages and layers"
version.workspace = true
edition.workspace = true
license.workspace = true
rust-version.workspace = true
[lints]
workspace = true
[features]
# Synthetic-file builders for tests and fuzz seeds; not a .cdr writer.
synth = []
[dependencies]
crc32fast = { workspace = true }
flate2 = { workspace = true }
[dev-dependencies]
proptest = { workspace = true }
vectorcraft-cdr = { path = ".", features = ["synth"] }
-33
View File
@@ -1,33 +0,0 @@
The record layouts this crate reads are described in the Kaitai Struct
specification `coreldraw_cdr.ksy`
(https://github.com/kaitai-io/coreldraw_cdr.ksy, commit
9d8e2704b946961f5114115f1a488750a3c86ed0), which is published under the
license below. No part of that specification is copied into this crate;
`PROVENANCE.md` cites it by line.
Some layouts are also taken from the fork of that specification by Zach Wolfe
(https://github.com/filestar/coreldraw_cdr.ksy, branch new_stuff, commit
2189b68f07e0cafe9afec3dcf699ebc0342144c7), which is published under the same
license and copyright notice.
MIT License
Copyright (c) 2020 Kaitai team
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
-127
View File
@@ -1,127 +0,0 @@
# Where each layout comes from
The reader relies on the record layouts below. Code cites a row by its id (`R1` ...), and
`tests/it/provenance.rs` fails when a cited id has no row here.
Sources:
- **K**: the Kaitai Struct specification `coreldraw_cdr.ksy` (MIT, notice in `LICENSE-kaitai.txt`),
https://github.com/kaitai-io/coreldraw_cdr.ksy/blob/9d8e2704b946961f5114115f1a488750a3c86ed0/coreldraw_cdr.ksy
- **KF**: the fork of K by Zach Wolfe, `filestar/coreldraw_cdr.ksy`, branch `new_stuff`, under the same
MIT license and notice as K (`LICENSE-kaitai.txt`),
https://github.com/filestar/coreldraw_cdr.ksy/blob/2189b68f07e0cafe9afec3dcf699ebc0342144c7/coreldraw_cdr.ksy
- **KR**: the README and the `bin/cdr-unpk` script of the Kaitai Struct specification (MIT), at
the same commit as K,
https://github.com/kaitai-io/coreldraw_cdr.ksy/blob/9d8e2704b946961f5114115f1a488750a3c86ed0/README.md
and https://github.com/kaitai-io/coreldraw_cdr.ksy/blob/9d8e2704b946961f5114115f1a488750a3c86ed0/bin/cdr-unpk
- **Z**: the PKWARE ZIP specification, APPNOTE.TXT version 6.3.10,
https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT, and RFC 1951 (DEFLATE),
https://www.rfc-editor.org/rfc/rfc1951
- **F**: the magic database of the `file` utility (BSD-2-Clause),
https://github.com/file/file/blob/b778217dbd35/magic/Magdir/images and
https://github.com/file/file/blob/b778217dbd35/magic/Magdir/riff
- **PR**: the PRONOM registry's signatures for versions 1.0, 2.0 and 4.0,
https://pronom.nationalarchives.gov.uk/fmt/467.xml,
https://pronom.nationalarchives.gov.uk/fmt/466.xml and
https://pronom.nationalarchives.gov.uk/fmt/465.xml
- **S**: own inspection of the bytes of public sample files, checked against the picture each file
carries of its drawing where it has one (versions 2 and 4 to 25; files of versions 1 and 3 carry
none). The files come from:
- **TP**: https://telparia.com/fileFormatSamples/image/cdr/, by file name
- **LT**: https://git.libreoffice.org/libcdr-test at commit
`dafe4fe53d685d89df20a5c0bb18f318ccefb4a8`, `testset/<version>/<file>`
- **UC**: https://svn.code.sf.net/p/uniconvertor/code/formats/CDR/testing%20base/ at revision
434, by file name
- **TDF**: attachments to The Document Foundation's bug tracker,
https://bugs.documentfoundation.org/attachment.cgi?id=<id>
- **NR**: Natural Resources Canada's tactile maps,
https://ftp.maps.canada.ca/pub/nrcan_rncan/raster/tactile/approach-approch/cdr/banff_ap_en.cdr and
https://ftp.maps.canada.ca/pub/nrcan_rncan/raster/tactile/atlas-atlas/cdr/ab_en_br.cdr
- **DM**: the clip art of https://discmaster.textfiles.com/browse/31541, by file name
- **CX**: the `.cmx` files of https://telparia.com/fileFormatSamples/image/cmx/, by file name. The
nine with 32-bit coordinates are `balloon.cmx`, `bars.cmx`, `bluecros.cmx`, `bluedrop.cmx`,
`gold_bar.cmx`, `goldblue.cmx`, `PC.CMX`, `squares.cmx` and `thatch.cmx`; they carry no picture
of their drawing.
- **CN**: the `.cmx` notes of an MIT OR Apache-2.0 drawing program, which mark each layout
"confirmed" when the program's authors found it in sample files,
https://github.com/tracedraw/tracedraw/blob/2ac6d02e97773e040a51be6cfb27cc424e3deeaa/docs/cmx-format.md.
The same program's `.cmx` reader at that commit,
https://github.com/tracedraw/tracedraw/blob/2ac6d02e97773e040a51be6cfb27cc424e3deeaa/crates/cdr/src/cmx.rs,
was read for the order of fields that the notes do not spell out (the table entries, the rendering
attributes and the curve body); no code was copied from it
Status: `public-spec` (K, KF, KR, Z, F or PR), `sample` (S), `public-notes` (a layout CN marks
confirmed that no CX file shows), `unconfirmed` (a point no source states and no sample file shows;
listed so it can be checked against a file, with what the reader does when it is wrong).
Public specifications cover only parts of versions 1 to 4: the rows that cite K, F or PR, such as
the version 3 fill (R34) and page settings (R38). The other rows of those versions rest on the
sample files they name.
The test inputs are the synthetic files that `src/synth.rs` builds from the rows below; no sample
file is committed.
| Id | What the code relies on | Source | Status |
|---|---|---|---|
| R1 | `RIFF`, the body length, then the form type `CDR` or `cdr` and a version character: `1` to `9`, `A` (10) to `H` (17), `J` (18) on, `I` unused; `cdr8` is 8.01 from the form type alone, whatever its `vrsn` chunk names, `CDR ` is 3, `CDRX` is another format. Files of versions 23 to 25 carry `O` (23), `P` (24), `Q` (24.3, with a `vrsn` of 2430) and `R` (25), which count differently from the version 24 update on, so their `vrsn` chunk decides (R2) | K L68-L133; S: LT `testset/23` to `testset/25`, such as `circle_redfill_nooutline_cdr25.cdr` | public-spec (letters from version 23: sample; letters of versions 26 and 27: unconfirmed, and the `vrsn` chunk decides when the file has one) |
| R2 | `vrsn`: the version as a u16, in hundreds | K L276-L278 | public-spec |
| R3 | `LIST cmpr`: two (compressed, uncompressed) u32 pairs, then two blocks of `CPng`, `01 00 04 00` and a zlib stream; the first inflates to the chunk stream, the second to a pool of u32 sizes that each chunk's size field indexes | K L193-L220, L2626-L2682 | public-spec |
| R4 | A chunk is an id, a u32 size and the body, padded to an even length; a `LIST` body starts with its form type; from version 7 a `LIST stlt` holds the style tables, not chunks | K L68-L78, L135-L155, L307-L334 | public-spec |
| R5 | Coordinates: i16 in 1/1000 inch before version 6, else i32 in 1/254000 inch; header fields, counts and offsets are u16 before version 6, else u32 | K L58-L66, L2688-L2700 | public-spec |
| R6 | `loda` and `lobj`: length, argument count, offsets table, types table, object type; count + 1 offsets bound the arguments; the types table runs in reverse; object types (1 rectangle, 2 ellipse, 3 curve, 0x14 polygon) and argument types (10 outline, 20 fill, 30 coordinates, 1000 name, 11000 polygon, 19130 page size) | K L335-L450, L846-L893 | public-spec |
| R7 | Angles: i16 tenths of a degree before version 6, else i32 millionths of a degree | K L2835-L2855 | public-spec |
| R8 | `trfd`: length, count, offsets table; each entry has 8 bytes first from version 13, a u16 type, and type 8 is a matrix after 6 bytes (from version 6) of six f64 `a c tx b d ty`, `tx` and `ty` in coordinate units; the matrices of one record apply in file order | K L895-L953, L2808-L2834 | public-spec |
| R9 | Name argument (1000): Windows-1252 up to a NUL before version 12, UTF-16LE from it | K L601-L630 | public-spec |
| R10 | `mcfg`: 12 bytes (13 on), 4 (9 to 12), 28 (6) or none, then the page width and height as coordinates | K L1670-L1765 | public-spec |
| R11 | `fild` (`fill` before 7): id; from 13 a record tagged 1300 with its length, which records tagged 2400 or more may precede; the fill type u16 (0 none, 1 uniform, others not read); uniform: 2 bytes then a color before 13, from 13 a record tagged 1300 holding a property list (u8 type, u32 length, body; 0 ends it; 1 a color, 8 a palette id and a UTF-16 name, 3 a UTF-16 name) | K L1025-L1302; S: LT `testset/15` to `testset/25` `circle_redfill_nooutline_cdr<version>.cdr`, whose fill records hold a record tagged 2400 before the one tagged 1300 | public-spec (2400 records: sample) |
| R12 | `outl`: id; from 13 records (u32 id, u32 length, body) up to id 1, whose body follows; a record of id 2 holds a property list laid out as R11's, and the reader takes the outline's color from it when it names a library color; line type, caps and join u16; 2 bytes (6 to 12); width; stretch u16; 2 bytes (6 on); nib angle; 52 bytes (6 to 12) or 46 (13 on); the color; 16 bytes (10 before 6); the dash count u16 and the dashes, in multiples of the width; the arrowhead ids 22 bytes after the first dash in versions 6 to 12, 20 bytes from 13. Caps 0 butt, 1 round, 2 square; joins 0 miter, 1 round, 2 bevel | K L954-L1024; KF L1225-L1249 (the id 2 record); S: caps and joins in UC `outl_line_caps_cdr7.cdr` and `outl_corner_cdr7.cdr`; arrowhead ids, matched against the drawing's `arrw` records, in TP `web_cd.cdr` (6), UC `rogan_logo_cdr7.cdr`, `rogan_logo_cdr8.cdr` and `rogan_logo_cdr11.cdr`, NR `ab_en_br.cdr` (9) and `banff_ap_en.cdr` (10), TDF 76820 (12) and 140638 (13) | public-spec (caps, joins and arrowhead places: sample; arrowheads before version 6: no sample names one, and the reader does not look for them; the id 2 record: no sample names a library color in it, and a wrong guess changes only the outline's color) |
| R13 | Bit 0 of the outline's line type: no outline | S: LT `square_blackfill_nooutline_cdr<version>.cdr` and the other `nooutline` files of `testset/15` to `testset/25`, whose outline records all have line type 1 and whose pictures show no outline | sample |
| R14 | A color record from version 5: model u16, palette u16, 4 bytes, four value bytes. Models: 2 CMYK in percent, 3 and 17 CMYK 0 to 255, 4 CMY 0 to 255, 5 blue, green, red, 9 gray 0 to 255, 20 registration, 21 blue, green, red and a tint in percent already applied; 1, 14 and 25 a library color's number (u16) and tint in percent (u16) | K L2856-L2965; S: model 25 in LT `testset/12/square_pantoneblackfill_nooutline.cdr` (number 14, tint 100), model 1 in UC `rogan_logo_cdr11.cdr` (number 4, tint 50) | public-spec (library values of models 1 and 25: sample; model 14: unconfirmed, and its color opens as a spot color without a look) |
| R15 | Rectangle coordinates: width, height and one radius, three more radii from version 9, running counterclockwise from the corner at (width, 0) | K L674-L700 | public-spec |
| R16 | Point list: u32 count (before version 6 as R39 gives it), the points, then one type byte each, the count held to what fits; type bits 7 and 6 move, line, curve end, control point; bit 3 closes the subpath | K L782-L787, L840-L845, L2701-L2807 | public-spec |
| R17 | Ellipse coordinates: width, height, start and end angles, pie flag (u16 before 6, else u32); the radii are half the width and height; the angles turn from the ellipse's own axes, which a negative width or height points the other way | K L754-L781; S: the pies of negative height in the ellipse-sector drawings of versions 12 and 13 in UC | public-spec (axis direction of a negative size: sample) |
| R18 | Polygon argument (11000): 4 bytes before 13, the side count u32, the next point u32 (the u32 after it when it is 0 or 1, else 4 bytes), 4 more from 13, rx and ry f64, the centre; the base curve is one side on a circle of 1000 mm from the top vertex to the vertex it runs to clockwise, copied once for each side | K L631-L655; S: the polygons and stars of UC `shapes_cdr10.cdr` | public-spec (base curve: sample) |
| R19 | `flgs`: byte 3 the record type, byte 2 marks the master page. On a layer, group or object, bit 0x01 of byte 1 hides it and bit 0x10 of byte 0 locks it. A layer's own `loda` names what it is by its object type: 11 a grid, 12 guides, 17 the desktop, any other a drawing layer (version 3 one less, R32). Only a layer without a `loda` is taken by the low four bits of its byte 0: 0x0a guides, or a grid when bit 0x10 is also set; in versions 7 to 13 0x02 the same way; 0x08 the desktop when byte 2 is set and a drawing layer when it is clear; any other a drawing layer, except [0, 1, 1] in versions 7 to 13, the desktop | K L1602-L1639 (record types); KF L1831-L1866 (the hidden and lock bits); S: every grid layer of versions 14 to 25 in the sample files (631) carries byte 1 = 1, and 206 of the 927 of versions 7 to 13 do; desktop layers carry byte 1 = 0 except TDF 114901's [0, 1, 1]; the drawing layers with byte 1 = 1 (TDF 114901, NR `banff_ap_en.cdr` and `symbology_en.cdr`) also carry bit 0x08; of the group and object lists in the sample files, only one object of TDF 60491 (version 14) sets either bit, the lock bit; in every sample file of versions 3 to 25 the layer's object type agrees with its name; byte 0 does not: TDF 114901 (version 8) flags its master page's guides [2, 1, 1], desktop [0, 1, 1], grid [0x12, 0, 1] and drawing layer [8, 1, 0], and NR `ab_en_br.cdr` (version 9) flags drawing layers 0x10 and its guides 0x1a; over the sample files of versions 3 to 25, drawing layers carry 0, 0x10, 0x40, or 0x08, 0x18 or 0x58 with byte 2 clear, desktop layers 0x08, 0x18 or 0x48 with byte 2 set, guides 0x0a, 0x4a, 0x02 or (in `ab_en_br.cdr`) 0x1a, and grids 0x1a, 0x5a or 0x12 | public-spec (layer types: sample; byte 0 of a layer without a `loda`: unconfirmed, as no sample has such a layer, and a wrong guess drops or shows that layer's objects; bit 0x10 is also the lock bit, so a locked guides layer without a `loda` reads as a grid) |
| R20 | Fill and outline arguments (20, 10): a u32 record id | K L452-L460, L548-L556 | public-spec |
| R21 | Page size argument (19130): width and height | K L666-L672 | public-spec |
| R22 | `LIST page` holds `LIST layr` lists, directly or in a list it holds (a `LIST gobj` in the samples); a layer holds `LIST obj ` and `LIST grp `; a page, layer or object keeps its own `loda` (and an object its `trfd`, in a `trfl` list) among its chunks or in a `LIST lgob` | K L1602-L1639 (record types); S: the chunk trees of every sample file of versions 3 to 25 | sample |
| R23 | Guideline (object type 0x16), argument 16000: 12 bytes, the angle in millionths of a degree, then points from the page centre; version 7 keeps them in a `guid` chunk: a u32 count, the count again, 40-byte records laid out the same way | S: argument 16000 in NR `ab_en_br.cdr` (9) and TDF 194220 (13); the `guid` chunk of TDF 123971 (7). Pictures do not show guidelines | sample |
| R24 | ZIP: the end of central directory record (signature `PK\5\6`, 22 bytes and a comment of up to 65,535 bytes) gives the member count and where the central directory lies; each central directory entry (46 bytes, then name, extra field and comment) gives the flags, method, CRC-32, sizes and its local header; a local header is 30 bytes, then its name and extra field, then the member's bytes. Flag bit 0 marks an encrypted member; method 0 is stored and 8 deflated; 0xFFFF and 0xFFFFFFFF mark ZIP64 fields, and a ZIP64 locator (`PK\6\7`, 20 bytes) precedes the end record of a ZIP64 archive; disk numbers other than 0 mark an archive split across files | Z 4.3.7, 4.3.12, 4.3.15, 4.3.16, 4.4.1.4, 4.4.4, 4.4.5, 4.4.7, 4.4.8, 4.4.13 | public-spec |
| R25 | Versions 14 and 15 save a ZIP package whose member `content/riffData.cdr` is the RIFF file | KR README L33, `cdr-unpk` L30 | public-spec |
| R26 | From version 16 the package's member `content/root.dat` is the RIFF file; `content/dataFileList.dat` names the data streams, one per line, members of `content/data/`; a redirect's stream number counts lines from 0 | KR README L34, L40, `cdr-unpk` L34-L66; K L173-L180 | public-spec |
| R27 | In a package of version 16 on, a chunk outside a compressed list whose size is 16 (in `root.dat` or in a redirected list's body) is a redirect record: stream u32, length u32, offset u32 and a reserved u32; its body is `length` bytes at `offset` of the stream; stream `0xFFFFFFFF` holds the body (at most 8 bytes) in the record after the length; a redirected list's body starts with its form type | K L144-L193 | public-spec |
| R28 | Templates have the form type `CDT` and a letter of their own; the `vrsn` chunk names the version. The reader takes any letter `A` to `Z` there | none: no sample template | unconfirmed (a template is read as a drawing of the version its `vrsn` chunk names, and one without that chunk is refused) |
| R29 | Rectangle coordinates from version 15: width and height as f64 coordinate units, scale x and y (f64, repeating the transform's scale), the scale-with flag (u8) and 7 bytes, then the four radii as f64, 16 bytes apart (a corner type byte and 15 bytes after the first), in the order of R15. With the flag clear each radius is a share of half the shorter side; with it set the radii are multiplied by 254000 coordinate units, which makes them inches | K L674-L752; S: LT `square_blackfill_nooutline_roundedcorners_cdr<version>.cdr` of `testset/15` to `testset/25` (flag clear, a share of 0.25) | public-spec (radius share with the flag clear: sample; that the scale is not applied: unconfirmed, as every sample has a scale of 1, and a wrong guess changes only the corners' size) |
| R30 | Object type 0x25 (version 10 on) is a path: 4 bytes, two u16 counts that add up to the point count, 16 bytes, then the points and their type bytes as in R16 | K L788-L799, L892; S: TDF 78250 (version 15) and UC `shapes_cdr10.cdr`, `shapes_cdr11.cdr`, `shapes_cdr12.cdr` and `shapes_x3.cdr` (versions 10 to 13), whose type bytes start where the counts put them; no sample before version 10 holds the type | public-spec (from version 10: sample) |
| R31 | Version 3 is a RIFF file with the form type `CDR ` (a space) and a `vrsn` of 300; version 4 has the form type `CDR4` and a `vrsn` chunk. Both use the 16-bit fields of R5 and R7. Their pages, layers, groups and objects are read by the rules of R19 and R22 | K L117-L134; PR fmt/465; F `riff` L786; S: TP `FOX.CDR` and `DALI.CDR` (3), DM `lion1.cdr` and `tiger.cdr` (4) | public-spec (pages and layers as R19 and R22: sample) |
| R32 | Version 3 counts its object types from 0: rectangle 0, ellipse 1, curve 2, text 3, bitmap 4; later versions use these plus one | S: the rectangles, curves and text of TP `ARMYSTF1.CDR`, `DALI.CDR` and `FOX.CDR`, which come out whole | sample (ellipse 1 and bitmap 4: unconfirmed, as no sample holds them; a bitmap is left out with a warning) |
| R33 | Version 3 keeps an object's transforms in argument 100 of its `lobj`: a u16, the entry count (u16), then 10-byte entries of a type (u16) and, at byte 6, where the entry's data starts, counted from the start of the argument. Type 0x8c is a matrix as R37, and the matrices apply in file order. Type 0x14 is an envelope, which this reader does not apply: the shape keeps its outline, placed by the matrices alone, and the drawing's warnings name the envelopes. A group's own `lobj` holds an argument 100 that places all of the group's objects after their own transforms | K L851; S: the matrices of every version 3 file in TP, whose drawings come out whole | sample (envelope type 0x14: unconfirmed, as no sample holds one; it is not applied, with a warning) |
| R34 | Version 3 fill, argument 20: a type byte (0 none, 1 uniform, 2 and 4 fountain, 6 texture, 7 and 10 pattern); a uniform fill's color follows as R36 | K L452-L547 | public-spec |
| R35 | Version 3 outline, argument 10: a flags byte with bit 0 set when the object is outlined, the width (coordinate), the stretch (u16), the nib angle, the color as R36, 7 bytes, the dash count (u8) and 10 bytes that hold the dashes as one byte each, the join (u16 at byte 30) and the caps (u16 at byte 32) numbered as R12, then the two arrowhead ids (u32). Dashes are read in multiples of the width as R12 | K L548-L592; S: the outlines of the version 3 files in TP | public-spec (flag bit: sample; dash unit, and the join, where bytes 32 and 33 of some samples hold 2 and 2: unconfirmed, and a wrong guess changes only how corners, ends and dashes are drawn) |
| R36 | A color before version 5: in versions 1 to 3 a model byte and four value bytes, in version 4 a model u16, four u16 values and 2 bytes. Model 1 is cyan, magenta, yellow and black in percent. Model 0 is an ink number (u16) and a tint in percent (u16): ink 0 is black at the tint, ink 1 is white, and other numbers are inks of a numbered library that the file does not store. Other models are read as R14 | K L2882-L2908; S: model 1 in TP `ARMYSTF1.CDR` (3) and DM `lion1.cdr` (4), model 0 in TP `ARROW5.CDR` (3) and `WI.CDR` (1) | sample (ink 1, and models other than 0 and 1: unconfirmed; an ink of another number opens as a spot color without a look) |
| R37 | A matrix of versions 3 and 4: six i32 `a c tx b d ty`, the four factors in 16.16 fixed point and `tx` and `ty` in coordinate units. A version 4 `trfd` entry of type 8 holds one where R8 has six f64 | S: TP `FOX.CDR` and `DALI.CDR` (3), DM `lion1.cdr` and `tiger.cdr` (4) | sample |
| R38 | `mcfg` of version 3: 2 bytes, then the page's two corners as four coordinates; the page size is the distance between them | K L1676-L1678, L1745-L1756 | public-spec |
| R39 | A point list before version 6 starts with a u16 count and another u16 (1 in some curves of versions 1, 2 and 4, 0 in the others), where K reads the two as one u32 | S: TP `DALI.CDR` (3), DM `headup.cdr` and `lion1.cdr` (4), TP `WI.CDR` (1), `FLAG.CDR` and `MENU.CDR` (2) | sample |
| R40 | Versions 1 and 2 are not RIFF files. A file starts with `WL`, a marker byte, a zero byte and five u32: the start of the settings, the start and the end of the object records, the start of the trailer and that value minus two. Version 1 has the marker `e` and its settings start at byte 28. Version 2 has the marker `m` or `l`, and its settings start after a 1-bit picture of the drawing, whose header starts where the u32 at byte 28 says. The reader takes these three markers | F `images` L4159-L4172; PR fmt/467, fmt/466; S: TP `WI.CDR` (`e`), `FLAG.CDR` (`m`), `MENU.CDR` and `DRINKS.CDR` (`l`) | public-spec (markers `e` and `m`: F and PR; the offsets and the marker `l`: sample) |
| R41 | The page's box in a file of version 1 or 2: four i16 two bytes after the start of the settings (left, top, right, bottom) in 1/1000 inch around the page's centre, y pointing up | S: TP `WI.CDR`, `FLAG.CDR` and `MENU.CDR` | sample |
| R42 | The records of a file of version 1 or 2 run from the front of the stacking order to the back. Every record starts with the u32 24. A group or layer record is 28 bytes, and bit 0x40 of its flags byte at 26 is clear. A drawn object has that bit set (0x40 in files with the markers `e` and `m`, 0xc0 with `l`) and a u16 body size at byte 28; it is the body size plus 32 bytes long. A drawn object of another type than those of R43 gives its length otherwise, and the records after it are not read | S: TP `WI.CDR`, `FLAG.CDR`, `MENU.CDR` and `DRINKS.CDR`; the order checked against the picture of `MENU.CDR` | sample |
| R43 | A drawn object of version 1 or 2: a point (two i16) at byte 32; six i32 in 16.16 fixed point at 36, `a b tx c d ty`, with x' = a x + b y + tx + the point's x and y' = c x + d y + ty + the point's y; the object type at 60 (0 rectangle, 1 ellipse, 2 curve, 3 text); a byte at 67 that is not 0 when the object is outlined, the outline's width (u16) at 68 and its color at 74; the fill type (0 none, 1 uniform) and its color after it, at 94 and 95 with the marker `e` and at 105 and 106 with `l` and `m`; the shape from byte 114 with `e` and 136 with `l` and `m`. Colors are as R36 | S: TP `WI.CDR` (`e`), `FLAG.CDR` (`m`) and `MENU.CDR` (`l`), checked against the pictures of `FLAG.CDR` and `MENU.CDR` | sample |
| R44 | Shapes of version 1 or 2: a rectangle's width and height (i16), then a corner radius; an ellipse's width and height, then two angles; a curve's point list as R39 and R16 | S: rectangles in TP `FLAG.CDR`, ellipses and curves in TP `WI.CDR`, curves in TP `MENU.CDR` | sample (the radius of files with the marker `e`, which no sample shows, and how the angles make an arc: unconfirmed; a radius is kept only when it is at most half the shorter side, and an ellipse whose angles differ is left out with a warning) |
| R45 | `LIST stlt` from version 7: a u32 style count, and when it is not 0: the fill table (a u32 count, entries of a table id, 4 bytes and a `fild` id, 12 bytes each, 60 from version 13), the outline table (12-byte entries laid out the same way, naming `outl` ids), the text tables (fonts of 44 bytes, 60 from version 10; alignments of 12; spacings of 52; tables of 152 and 784; bullets whose length a u32 inside them sets; indents of 28; hyphenation of 32, 36 from 13; drop caps of 28; from 8.01 a table of 12), then the styles: kind (u32), id, parent id, 8 bytes, name length and name (bytes before 12, UTF-16 units from it), the fill and outline table ids, then 16 bytes (20 from 8.01) for kinds above 1 and 20 more for kinds above 2. An object names its style in argument 200 (u16 before version 6, u32 from it). An object without argument 20 or 10 takes the fill or outline of its style; a style whose table id is 0 takes its parent's | K L593-L600, L852, L1926-L2198; S: UC `outl_width_cdr7.cdr`, one of whose lines carries argument 200 and neither 10 nor 20 and names the style whose outline is black and 0.003 inch wide and whose fill is none, as the file's picture shows; the table parses exactly to the end of the list in each of the 498 sample files of versions 7 to 15 that has one, and every object with argument 200 in them names a style whose table ids are in the tables; argument 200 is 2 bytes on all 844 objects of versions 4 and 5 in the sample files that carry it, and 4 bytes on all 18 of version 6 | public-spec (what the table ids name, and that an object takes its style's fill and outline: sample; a style taking its parent's entry: unconfirmed, as only text styles in the samples leave theirs to the parent, and a wrong guess draws a shape without that fill or outline) |
| R46 | A clipping container carries argument 8005; its first u32 is the id that the `spnd` chunk (a u32, a u16 before version 6) of one `LIST grp ` in the document's `LIST clpt` holds. That group's objects are the ones the container clips; they keep their own transforms, in page space like the container's | K L252, L860-L862, L1895-L1901 (the argument and the chunk); S: LT `powerclipsquare_blackfill_whiterectangleinside` of `testset/12` to `testset/25` and eight UC files of versions 7 to 13, in each of which the id in argument 8005 matches one group's `spnd`; in the UC file of version 7 the group's box, -1.96 to 1.97 inches across, overlaps the container's, -1.81 to 1.84 inches, and the file's picture shows the group cut to the container | public-spec (what the id names, and the space of the group's objects: sample) |
| R47 | Argument 8000 marks an object seen through: a lens or a transparency. From version 13 it holds records of a u32 version, a u32 length and a body; a body of version 1300 that is 117 bytes long holds an f64 at byte 61 and a merge mode byte at byte 77, which the reader applies as a uniform transparency. VectorCraft reads the f64 as the transparency in percent (0 opaque, 100 clear) and maps the merge modes 0 normal, 9 multiply, 11 lighten, 12 darken, 14 color, 15 hue, 16 saturation, 17 luminosity, 24 difference, 28 screen, 29 overlay, 30 soft light, 31 hard light, 33 color dodge, 34 color burn and 36 exclusion to its blend modes. Other merge modes, other records (a lens record of version 13 is 84 bytes) and the argument before version 13 are not applied, and the reader names them with lenses in the warnings | K L859 (the argument); KF L707-L798 (the records, the 117-byte body and the merge modes); S: the version 1300 record of LT `square_blackfill_nooutline_transparency50percent` of `testset/15` to `testset/25` is 117 bytes long, with 50.0 at byte 61 and 0 at byte 77; the lens records of UC `corel_lens_test_x3.cdr` (13) are 84 bytes long; of the sample files of versions 7 to 25, the argument is on the see-through objects that the pictures of LT `square_blackfill_nooutline_transparency50percent` of `testset/12` to `testset/25`, TDF 80103 and eight UC lens test files of versions 7 to 13 show, and otherwise only on text in UC `fancytext_cdr7.cdr` to `fancytext_x3.cdr` and on two objects of TDF 114901. The value K reads at byte 10 (14 from version 13) is not the transparency in these samples | public-spec (the argument: K; what it marks: sample; the direction of the value: VectorCraft's own reading, as every sample is at 50%, and a wrong reading shows a 25% transparency at 75%; the layout before version 13: unconfirmed, and it is not read) |
| R48 | Bit 2 (0x04) of the outline's line type marks the outline dashed; the dashes of an outline without it are not drawn | S: every outline of versions 6 to 25 in the sample files with that bit set (316 of them, in 29 files) stores dashes; TDF 76771 (version 15) stores dashes 2 and 1 in an outline of line type 0x22, and the file's picture draws that outline solid | sample |
| R49 | Bit 4 (0x10) of the outline's line type puts the outline behind the fill | S: UC `outl_behind_fill_cdr7.cdr` to `outl_behind_fill_x3.cdr`, whose outline of line type 0x12 the file's picture shows behind the fill, and whose other outlines (0x02) it shows over the fill | sample |
| R50 | Bit 5 (0x20) of the outline's line type scales the outline's width and dashes with the shape's matrix. The engine multiplies them by the square root of the matrix's area factor (VectorCraft's own value for a matrix that scales x and y differently) | S: UC `outl_scale_with_cdr7.cdr` to `outl_scale_with_cdr12.cdr`, of whose outlines only one, 3.969 mm wide, has line type 0x22 and the others 0x02 or 0x01; TDF 76771 (version 15), whose outline of line type 0x22 is 10 mm wide on a shape that the matrix stretches and skews, and whose picture draws that outline several times wider and skewed | sample (the bit; the single width for a matrix that scales x and y differently: VectorCraft's own) |
| R51 | A `trfd` offsets table holds one offset more than the entries; each entry runs from its offset to the next, and the last offset is the record's end | KF L1079, L1113-L1121; S: every `trfd` of versions 4 to 25 in the sample files (25,425 records) has the extra offset, equal to the record's length | public-spec |
| R52 | Byte 0 of argument 14001 is the fill's winding flag. VectorCraft reads a byte other than 0 as the nonzero fill rule, and 0 or an object without the argument as even-odd | KF L575-L583, L1047; S: the argument is 4 bytes in the sample files that carry it, with byte 0 = 1 on LT `complexshape_blackfill_nooutline` of `testset/12` and `testset/15` to `testset/25` and on objects of TDF 127576 (13) and 60026 (14), and 0 on 27 objects of TP `example.cdr` (17) | public-spec (the flag: KF; which rule each value means, and the rule without the argument: VectorCraft's own reading, and a wrong reading fills or leaves holes where a curve's subpaths overlap) |
| R53 | A `.cmx` file is a RIFF form of type `CMX1`, little-endian (a `RIFX` form is big-endian and is refused); its chunks are laid out as R4. A chunk can run short of its contents: when the bytes after it don't read as a chunk id (an ASCII letter, then three ASCII letters, digits or spaces), the next id is the first at an even distance of 2 to 64 bytes that names a chunk the reader uses or whose length keeps it inside its list (VectorCraft's own rule) | CN "Container"; S: all 14 CX files are `RIFF` forms of type `CMX1`; in `balloon.cmx`, `bars.cmx`, `bluecros.cmx`, `bluedrop.cmx`, `gold_bar.cmx`, `goldblue.cmx`, `squares.cmx` and `thatch.cmx` 16 bytes follow `ccmm` and 4 follow `rlst` before the next id | sample |
| R54 | `cont`: byte 52 is the coordinate size as an ASCII digit, `4` for 32-bit coordinates and `2` for 16-bit ones (refused); bytes 64 to 72 hold an f64, the size of a coordinate unit in meters. A value that isn't above 0 and at most 1 reads as 0.1 µm (VectorCraft's own fallback) | CN "Container"; S: the nine CX files with `4` all hold 1e-7; `abydos.cmx`, `CM33.CMX`, `LIZARDS.CMX`, `output.000.cmx` and `test.cmx` hold `2` | sample |
| R55 | A table (`rclr`, `rpen`, `rott`, `rdot`, `rotl`) is a u16 entry count, then one field list per entry; an instruction's body is field lists too. A field is a u8 tag, a u16 length counting its 3 header bytes, and the data; 0xff ends the list. Objects name table entries from 1 | CN "Tables"; S: every one of these tables in the nine CX files with 32-bit coordinates reads its count of entries with no bytes left | sample |
| R56 | A color entry: a property list in field 10 (a u32 length, then parts laid out as R11's, the color in part 1 as R14), or in older files the model and palette bytes in field 1 and the values in field 2. Models of the older fields: 2 cyan, magenta, yellow and black in percent; 3 the same in 0 to 255; 4 cyan, magenta and yellow in 0 to 255; 5 red, green and blue in 0 to 255; 9 gray in 0 to 255, 255 white. Other models read as black with a warning | CN "Tables" (`rclr`); S: every color of the nine CX files is model 2 in the older fields | sample (model 2), public-notes (field 10), unconfirmed (models 3 and 5 of the older fields, read as the program of CN reads them, and models 4 and 9, read as R14's; a wrong reading gives a wrong color) |
| R57 | `rpen` field 1: the width as a u32 in coordinate units (then an aspect, an angle and a matrix, not read). `rott` field 1: a flags byte (1 no outline, 2 solid, 4 dashed, 8 behind the fill, 16 scaled with the object), then the caps in the low 4 bits and the join in the high 4 bits, numbered as R12. `rdot` field 1: a u16 count, then the dash and gap lengths in outline widths (u16 each). A pattern whose lengths are all 0 draws a solid line, as R48's | CN "Tables"; S: line types 0x02 and 0x22 with caps and joins 0x00, 0x01 and 0x11 in the CX files | public-notes (the flags 4, 8 and 16 and the cap and join numbering; bit 0x20, set in `balloon.cmx`, is not read) |
| R58 | `rotl` field 1: six u16, the 1-based entries of the outline's line type, screen, color, arrowhead pair, pen and dash pattern | CN "Tables"; S: every `rotl` entry of the CX files names entries that exist | sample |
| R59 | `rota`: a u16 count, then pairs of u16 (start and end arrowheads, 0 for none), not field lists | CN "Tables"; S: `rota` is `01 00 00 00 00 00` in every CX file | sample (pairs of 0), public-notes (other values) |
| R60 | A `page` chunk is a stream of instructions: a u16 size counting the whole instruction and an i16 code, or 0xFFFF, a u32 size and the code (the long form); then field lists. Codes: 9 and 10 begin and end a page, 11 and 12 a layer, 13 and 14 a group, 67 a curve; 20 and 21 a text object, 65 its drawn characters, 66 an ellipse, 68 a rectangle, 69 an image, 88 and 89 add and remove a clipping path, 111 a jump whose field 1 is the u32 file offset to go on from (the bytes jumped over hold images). Objects are drawn in file order, the first at the back | CN "page: instructions"; S: codes 9 to 14 and 67 in the CX files; in `squares.cmx` the large square comes first and the two smaller ones inside it after | sample (9 to 14, 67, the order), public-notes (the long form and the other codes) |
| R61 | Field 4 of instruction 9: the page's width and height, u32 each in coordinate units. Without it, field 1 gives the drawing's bounds: a u16 page number, a u32, then the left, top, right and bottom edges as i32 in coordinate units; the page takes the bounds' size and is centered on them (VectorCraft's own choice). Without either, the page has no size, and the importer gives it 612 × 792 pt as it does a `.cdr` page without one (VectorCraft's own size) | CN "page: instructions"; S: none of the CX files has field 4; in all nine with 32-bit coordinates, the four edges in field 1 match the extent of the file's curves | public-notes (field 4), sample (field 1) |
| R62 | A layer's name: field 4 as a u32 count and UTF-16 units, or field 1 from byte 12 as a u16 count and 8-bit characters (read as Windows-1252, VectorCraft's own choice); a layer without a name is left unnamed, as a `.cdr` layer is. A curve: field 1 its rendering attributes, field 2 a u16 point count, the points as i32 x and y, then a type byte for each as R16; coordinates are from the page's center, y up. A field 2 too short for its count is read as whole points with their type bytes when its length is a multiple of 9, and the curve is left out as damaged otherwise (VectorCraft's own rule) | CN "page: instructions" and "Coordinates"; S: the 8-bit names `Layer 1`, `Desktop`, `Grid` and `Guides` of the CX files (the last three hold nothing in every file); every curve of the CX files has field 2 of exactly 2 + 9 bytes per point | sample (8-bit names, curves), public-notes (field 4) |
| R63 | Rendering attributes: a mask (1 fill, 2 outline, 4 lens, 8 canvas, 16 container; lenses, canvases and containers are not read, with a warning), then a field list for the fill when the mask names it and one for the outline. The fill's field 1 is a u16 type and a field list; type 0 is no fill, type 1 a uniform fill whose field 1 is the color entry (u16) and a screen (u16); other types (2 fountain and more) are not read. The outline's field 1 is its `rotl` entry (u16) | CN "Rendering attributes"; S: masks 1, 2 and 3, fill types 1, 2 and 6, and uniform fills with a 4-byte field 1 in the CX files | sample |
-98
View File
@@ -1,98 +0,0 @@
# vectorcraft-cdr
A bounded Rust reader for `.cdr` drawings of versions 1 to 27 (and `.cdt` templates).
It reads the `WL` files of versions 1 and 2, the RIFF chunk tree of versions 3 and later with its
compressed lists, the ZIP packages that versions 14 and later save (with the data streams of
versions 16 and later) and the records listed below, and hands the engine a drawing in points,
with each object's transform. It does not write `.cdr` files.
## What is read
| In the `.cdr` file | Read as |
|---|---|
| ZIP packages: `content/riffData.cdr` (versions 14 and 15), `content/root.dat` with the data streams `content/dataFileList.dat` names (16 on) | the RIFF chunk tree; a data stream is inflated only when a chunk the reader reads, or a list it splits, points into it |
| Pages, the page size in `mcfg` or a page's own size | pages, laid out by the engine as artboards side by side |
| Layers (drawing, desktop, guides and grid layers), the master page's among them | layers by name and kind |
| The hidden and locked flags of layers, groups and objects | flags |
| Guidelines (object type 0x16, and the version 7 `guid` chunk) | guidelines at their point and angle |
| Groups (`LIST grp `) | groups |
| Clipping containers and the groups of `LIST clpt` they clip | the container with the objects it clips |
| Curves (point lists of moves, lines and cubic curves) and paths (object type 0x25, version 10 on) | paths |
| Rectangles (one corner radius, four from version 9) | rectangles with each corner's radius |
| Ellipses, arcs and pies | ellipses, and paths for arcs and pies |
| Polygons and stars (a base side copied for each side) | paths |
| Uniform fills: CMYK, CMY, RGB, gray, registration, library colors | colors, spot colors with their tints |
| The fill's winding flag | the nonzero fill rule, or even-odd |
| Outlines: width, caps, joins, dashes, the no-outline and behind-the-fill flags, and from version 13 a library color named in their property list | outlines |
| Uniform transparency (version 13 on) and its merge mode | the shape's opacity and blend mode |
| Styles (`LIST stlt`, versions 7 to 15) that objects name | the fill and outline of an object that has none of its own |
Text, bitmaps, linked groups (blends, contours, brush strokes), B-spline curves, fountain,
pattern, texture and PostScript fills, outline arrowheads, lenses, transparency other than uniform
transparency of version 13 and later, and merge modes without a VectorCraft blend mode are not
read; the drawing's
`warnings` name each kind it held. Drawings of versions after 27 are refused, and so are packages
that are encrypted, ZIP64 archives or split across files.
VectorCraft reads a uniform transparency's stored value as the transparency in percent (0 opaque,
100 clear), and a winding flag other than 0 as the nonzero fill rule. These are VectorCraft's own
readings: no public source states either direction.
## Versions 1 to 4
Public specifications cover only parts of these versions, such as the version 3 fill and page
settings. For the rest, the reader follows the layouts of public sample files that
`PROVENANCE.md` lists (rows R31 to R44), and its tests read the synthetic files that
`src/synth.rs` builds from those rows.
| Version | Read | Left out or refused |
|---|---|---|
| 1 and 2 (`WL` files) | the page size; rectangles with one corner radius, whole ellipses and curves, each with its matrix; uniform fills and outlines with their width and color, in CMYK percent and the inks black and white. The objects come in on one page and one layer, front to back | text and objects of other types, and ellipses whose two angles differ (arcs and pies), with the unsupported-objects warning; fills of other types, with the unsupported-fills warning; inks of a numbered library, which read as spot colors without a look; groups and layers, whose records are passed over; dashes, caps, joins and arrowheads, which the reader does not look for; the records after a drawn object of another type, with the unsupported-objects warning |
| 3 (RIFF, form type `CDR `) | the page size from the page's corners; pages, layers and groups; rectangles, ellipses, arcs and curves with the matrices of the object and of the groups around it; uniform fills; outlines with their width, color, caps, joins and dashes | text and bitmaps; envelopes, with the envelopes warning (the objects and groups under one keep their outlines and matrices); fountain, pattern and texture fills; arrowheads |
| 4 (RIFF, form type `CDR4`) | as version 5, with the colors and the fixed-point transforms of version 4 | as version 5 |
A file is taken for version 1 or 2 by its content only when, after `WL`, its marker byte is one of
`e`, `l` and `m`, the next byte is zero, and the offsets of its header fit the file. The reader
reports version 1 for the marker `e` and version 2 for the other two. A RIFF file that names
a version before 3 is refused, and so is the version 4 template form type `CDST`, which reads as
not a `.cdr` drawing.
## `.cmx` files
`read_cmx` reads `.cmx` exchange files with 32-bit coordinates (rows R53 to R63) into the same
drawing model, with a version of 0. It reads the color, pen, line type, dash, outline and
arrowhead tables, then each page's instructions in drawing order:
| In the `.cmx` file | Read as |
|---|---|
| Pages, with the size the page gives, or else the size of the drawing's bounds that the page stores | pages; a page sized to the bounds is centered on them |
| Layers, by their UTF-16 or 8-bit name | drawing layers, unnamed when the file gives no name; a layer that holds nothing is left out |
| Groups | groups |
| Curves (moves, lines and cubic curves, as `.cdr` point lists) | paths |
| Uniform fills: CMYK in percent or 0 to 255, CMY, RGB, gray, and library colors with their names | colors, spot colors |
| Outlines: width, color, caps, joins, dashes, the no-outline, behind-the-fill and scaled-with flags | outlines |
Text, images, rectangles, ellipses, clipping paths, fills other than uniform ones, outline
arrowheads and lenses are not read; the drawing's `warnings` name each kind it held. A clipping
path is left out and the objects it clips are read without it. Files in big-endian byte order and
files with 16-bit coordinates are refused.
## Provenance
`PROVENANCE.md` lists every record layout the reader relies on, with its public source and status.
Code cites the rows by id (`R1` ...), and `tests/it/provenance.rs` fails when a cited id has no row.
The test inputs are synthetic drawings built by `src/synth.rs` and `src/synth_cmx.rs` (the
`synth` feature); no third-party file is committed.
## Limits
`Limits` bounds the input size, the bytes inflated from compressed lists and package members, the
size of one package member, the number of members, the nesting depth, the chunk count, the
objects, the coordinates and the outline dashes of one read. Past a limit the reader stops with an
error or leaves the rest out with a warning; it does not recurse and does not panic. Each record
of a version 1 or 2 file counts toward the chunk count, and the transform entries of a version 3
object are held to the arguments one record may have. A package's
data stream is read once however many lines of `content/dataFileList.dat` name it. A redirected
list whose bytes overlap those of an earlier redirected list is left out with the damage warning.
Other records may share bytes, and the bytes read again may add up to the member limit; past it
the records are left out with the limit warning.
-816
View File
@@ -1,816 +0,0 @@
//! The drawing the chunk index holds: pages, layers, objects and the fills and outlines they name
//! (R19 to R23). Records are decoded only when an object refers to them.
use std::collections::HashMap;
use crate::bytes::Rd;
use crate::geometry;
use crate::inline;
use crate::layout::{self, Profile};
use crate::limits::Budget;
use crate::model::{Blend, Color, Drawing, Flags, Geometry, Guideline, Layer, LayerKind, Matrix, Object, Outline, Page, Pt, Shape};
use crate::records::{self, Loda};
use crate::riff::{Chunk, Index, push};
use crate::styles::Styles;
use crate::{Error, Warning};
/// Object types (R6).
const RECTANGLE: u32 = 1;
const ELLIPSE: u32 = 2;
const CURVE: u32 = 3;
const POLYGON: u32 = 0x14;
const GUIDELINE: u32 = 0x16;
const PATH: u32 = 0x25;
/// Argument types (R6, R20, R21, R33, R52).
const ARG_OUTLINE: u32 = 10;
const ARG_FILL: u32 = 20;
const ARG_COORDS: u32 = 30;
const ARG_TRANSFORMS: u32 = 100;
const ARG_STYLE: u32 = 200;
const ARG_NAME: u32 = 1000;
const ARG_LENS: u32 = 8000;
const ARG_CONTAINER: u32 = 8005;
const ARG_POLYGON: u32 = 11000;
const ARG_WINDING: u32 = 14001;
const ARG_GUIDE: u32 = 16000;
const ARG_PAGE_SIZE: u32 = 19130;
/// What a RIFF file that names a version before 3 is refused as.
const BEFORE_3: &str = "RIFF files of versions before 3";
/// What one read keeps while mapping.
struct Ctx<'a, 'b> {
ix: &'b Index<'a>,
p: Profile,
budget: &'b mut Budget,
warn: &'b mut Vec<Warning>,
/// Fill and outline records by id, decoded on first use.
fill_chunks: HashMap<u32, &'b [u8]>,
outline_chunks: HashMap<u32, &'b [u8]>,
fills: HashMap<u32, Option<Color>>,
outlines: HashMap<u32, Option<Outline>>,
/// The styles objects name in argument 200 (R45): `Err` when the file's style table doesn't
/// parse.
styles: Result<Styles, ()>,
/// The groups of `LIST clpt` that containers clip, by the id in their `spnd` chunk (R46).
clips: HashMap<u32, &'b Chunk>,
/// The clipped groups being read, innermost last.
open_clips: Vec<u32>,
/// Whether the walk of a clipped group stopped at the clipped chunk limit.
clip_cut: bool,
}
/// The most clipped groups read one inside another: VectorCraft's own limit.
const MAX_CLIP_DEPTH: usize = 64;
pub(crate) fn drawing(ix: &Index, budget: &mut Budget, warn: &mut Vec<Warning>) -> Result<Drawing, Error> {
let root = ix.root().ok_or(Error::NotCdr)?;
let version = ix.version();
// A template whose `vrsn` chunk doesn't name a version read (R28).
if version == 0 {
return Err(Error::NotCdr);
}
// Versions 1 and 2 are `WL` files (R40); no source shows a RIFF file that names a version
// before 3.
if version < layout::OLDEST_RIFF {
return Err(Error::Unsupported(BEFORE_3));
}
let p = layout::for_version(version).ok_or(Error::Version(version))?;
let mut found = Found::default();
collect(ix, root, &mut found);
let page_size = found.mcfg.and_then(|c| page_size(ix.data(c), &p));
// Before version 7 a `LIST stlt` holds chunks, not the style table (R4).
let styles = match found.stlt {
Some(c) if version >= 700 => Styles::read(ix.data(c), version, budget)?.ok_or(()),
_ => Ok(Styles::default()),
};
let mut cx = Ctx {
ix,
p,
budget,
warn,
fill_chunks: HashMap::new(),
outline_chunks: HashMap::new(),
fills: HashMap::new(),
outlines: HashMap::new(),
styles,
clips: HashMap::new(),
open_clips: Vec::new(),
clip_cut: false,
};
// The `spnd` id is a u16 in files of 16-bit fields (R46).
let spnd = |b: &[u8]| if p.short { Rd::new(b).u16().map(u32::from) } else { Rd::new(b).u32() };
for g in found.clpt.iter().flat_map(|c| ix.children(c)).filter(|g| g.is_list(b"grp ")) {
if let Some(id) = ix.children(g).iter().find(|c| &c.id == b"spnd").and_then(|c| spnd(ix.data(c))) {
cx.clips.entry(id).or_insert(g);
}
}
for c in &found.fills {
if let Some(id) = Rd::new(ix.data(c)).u32() {
cx.fill_chunks.entry(id).or_insert(ix.data(c));
}
}
for c in &found.outlines {
if let Some(id) = Rd::new(ix.data(c)).u32() {
cx.outline_chunks.entry(id).or_insert(ix.data(c));
}
}
let mut guides = found.guid.map(|c| guid_chunk(ix.data(c), &cx.p, cx.budget, cx.warn)).unwrap_or_default();
let mut pages = Vec::new();
let mut master = Vec::new();
for page in &found.pages {
let (is_master, read) = cx.page(page);
if is_master {
// Guidelines on any of the master page's layers show on every page.
for mut layer in read.layers {
guides.append(&mut layer.guides);
if !layer.objects.is_empty() && layer.kind != LayerKind::Grid {
master.push(layer);
}
}
} else {
pages.push(read);
}
}
// A file of only a master page keeps it as its page.
if pages.is_empty() && !master.is_empty() {
pages.push(Page { size: None, layers: std::mem::take(&mut master) });
}
Ok(Drawing { version, page_size, pages, master, guides, warnings: std::mem::take(cx.warn) })
}
#[derive(Default)]
struct Found<'i> {
fills: Vec<&'i Chunk>,
outlines: Vec<&'i Chunk>,
mcfg: Option<&'i Chunk>,
guid: Option<&'i Chunk>,
stlt: Option<&'i Chunk>,
clpt: Vec<&'i Chunk>,
pages: Vec<&'i Chunk>,
}
/// Every fill, outline, `LIST clpt` and page in file order, and the first `mcfg`, `guid` and
/// `LIST stlt`; pages are not looked into.
fn collect<'i>(ix: &'i Index, root: &'i Chunk, found: &mut Found<'i>) {
let mut stack: Vec<&Chunk> = ix.children(root).iter().rev().collect();
while let Some(c) = stack.pop() {
match &c.id {
b"fild" | b"fill" => found.fills.push(c),
b"outl" => found.outlines.push(c),
b"mcfg" => found.mcfg = found.mcfg.or(Some(c)),
b"guid" => found.guid = found.guid.or(Some(c)),
// Before version 7 the list holds chunks, which are looked through.
_ if c.is_list(b"stlt") => {
found.stlt = found.stlt.or(Some(c));
stack.extend(ix.children(c).iter().rev());
}
_ if c.is_list(b"clpt") => found.clpt.push(c),
_ if c.is_list(b"page") => found.pages.push(c),
_ => stack.extend(ix.children(c).iter().rev()),
}
}
}
/// The page size in `mcfg` (R10); in version 3 the distance between the page's two corners, after
/// 2 bytes (R38).
fn page_size(b: &[u8], p: &Profile) -> Option<(f64, f64)> {
let mut r = Rd::at(b, p.mcfg_skip);
if p.mcfg_corners {
r.skip(2)?;
let (x0, y0, x1, y1) = (records::coord(&mut r, p)?, records::coord(&mut r, p)?, records::coord(&mut r, p)?, records::coord(&mut r, p)?);
return sane_size(x1 - x0, y1 - y0);
}
sane_size(records::coord(&mut r, p)?, records::coord(&mut r, p)?)
}
fn sane_size(w: f64, h: f64) -> Option<(f64, f64)> {
let (w, h) = (w.abs(), h.abs());
(w > 0.0 && h > 0.0).then_some((w, h))
}
/// The version 7 `guid` chunk (R23): two counts, then 40-byte records laid out as argument 16000.
/// Each guideline counts toward the objects a read maps; past them the rest are left out.
fn guid_chunk(b: &[u8], p: &Profile, budget: &mut Budget, warn: &mut Vec<Warning>) -> Vec<Guideline> {
let mut r = Rd::new(b);
let Some(n) = r.u32() else { return Vec::new() };
let _again = r.u32();
let fits = r.left() / 40;
if n as usize > fits {
push(warn, Warning::Damaged);
}
let n = (n as usize).min(fits);
let mut out = Vec::new();
for i in 0..n {
if !budget.take_object() {
push(warn, Warning::TooDeep);
break;
}
out.extend(b.get(8 + i * 40..8 + (i + 1) * 40).and_then(|g| guideline(g, p)));
}
out
}
/// A guideline record (R23): 12 bytes, the angle in millionths of a degree, then a point.
fn guideline(b: &[u8], p: &Profile) -> Option<Guideline> {
if p.short {
return None;
}
let mut r = Rd::at(b, 12);
let angle = f64::from(r.i32()?) / 1_000_000.0;
let at = Pt { x: records::coord(&mut r, p)?, y: records::coord(&mut r, p)? };
Some(Guideline { at, angle, hidden: false })
}
/// Marks the guidelines from `from` on hidden when `flags` hide what holds them.
fn hide_guides(guides: &mut [Guideline], from: usize, flags: Flags) {
if flags.hidden {
for g in guides.iter_mut().skip(from) {
g.hidden = true;
}
}
}
/// A list's flags (R19): four bytes.
fn flags(ix: &Index, list: &Chunk) -> Option<[u8; 4]> {
let c = ix.children(list).iter().find(|c| &c.id == b"flgs")?;
ix.data(c).get(..4)?.try_into().ok()
}
/// Whether a layer, group or object list is hidden (bit 0x01 of byte 1) or locked (bit 0x10 of
/// byte 0) (R19).
fn state(ix: &Index, list: &Chunk) -> Flags {
flags(ix, list).map_or(Flags::default(), |[b0, b1, _, _]| Flags { hidden: b1 & 0x01 != 0, locked: b0 & 0x10 != 0 })
}
/// `o` with `f` added to its own flags: the objects of a group left ungrouped keep the group's.
fn inherit(o: &mut Object, f: Flags) {
let own = match o {
Object::Shape(s) => &mut s.flags,
Object::Group { flags, .. } => flags,
Object::Clip { container, .. } => &mut container.flags,
};
own.hidden |= f.hidden;
own.locked |= f.locked;
}
/// What a layer's object type makes it (R19): 11 a grid, 12 guides, 17 the desktop, any other a
/// drawing layer. Version 3 counts its types from 0, one less (R32).
fn layer_kind_of_type(kind: u32, types_from_zero: bool) -> LayerKind {
match kind.saturating_add(u32::from(types_from_zero)) {
11 => LayerKind::Grid,
12 => LayerKind::Guides,
17 => LayerKind::Desktop,
_ => LayerKind::Drawing,
}
}
/// What a layer's flags make it, for a layer without an object type of its own (R19). The low
/// four bits of byte 0 hold the kind: 0x0a guides, or a grid with bit 0x10 set (versions 7 to 13
/// also flag them 0x02); 0x08 the desktop when byte 2 is set, a drawing layer when it is clear.
/// Versions 7 to 13 may flag the master page's desktop layer 0 with bytes 1 and 2 set. Bit 0x10
/// alone does not make a grid.
fn layer_kind(f: [u8; 4], version_below_14: bool) -> LayerKind {
let [b0, b1, b2, _] = f;
let grid_bit = b0 & 0x10 != 0;
match b0 & 0x0f {
0x0a if grid_bit => LayerKind::Grid,
0x0a => LayerKind::Guides,
0x02 if version_below_14 && grid_bit => LayerKind::Grid,
0x02 if version_below_14 => LayerKind::Guides,
0x08 if b2 != 0 => LayerKind::Desktop,
0 if version_below_14 && b1 == 1 && b2 == 1 => LayerKind::Desktop,
_ => LayerKind::Drawing,
}
}
/// The first chunk of one of `ids` that a page, layer or object keeps for itself: among its own
/// chunks, or in its `lgob` list and the `trfl` list there (R22).
fn own_chunk<'i>(ix: &'i Index, list: &'i Chunk, ids: &[&[u8; 4]]) -> Option<&'i Chunk> {
let mut stack: Vec<(&Chunk, u8)> = ix.children(list).iter().rev().map(|c| (c, 0)).collect();
while let Some((c, depth)) = stack.pop() {
if ids.contains(&&c.id) {
return Some(c);
}
if depth < 2 && (c.is_list(b"lgob") || c.is_list(b"trfl")) {
stack.extend(ix.children(c).iter().rev().map(|k| (k, depth + 1)));
}
}
None
}
/// The `loda` (or `lobj`) a page, layer or object keeps for itself.
fn own_loda<'i>(ix: &'i Index, list: &'i Chunk) -> Option<&'i Chunk> {
own_chunk(ix, list, &[b"loda", b"lobj"])
}
/// A page's layer lists in file order: its own, and those in the lists it holds, such as the
/// `gobj` list of files of versions 7 to 13 (R22).
fn page_layers<'i>(ix: &'i Index, page: &'i Chunk) -> Vec<&'i Chunk> {
let mut out = Vec::new();
let mut stack: Vec<&Chunk> = ix.children(page).iter().rev().collect();
while let Some(c) = stack.pop() {
if c.is_list(b"layr") {
out.push(c);
} else if c.id == crate::riff::LIST && !c.is_list(b"lgob") {
stack.extend(ix.children(c).iter().rev());
}
}
out
}
/// One frame of the object walk: a list's chunks, the next one to look at, and the objects so far.
struct Frame<'i> {
chunks: &'i [Chunk],
next: usize,
objects: Vec<Object>,
/// Whether its objects form a group in the frame below.
group: bool,
/// The group's own flags.
flags: Flags,
/// The first of the guidelines read inside it.
guides_from: usize,
/// What places its objects after their own transforms: the matrices of the version 3 groups
/// around them (R33). The identity in other versions, whose objects hold their whole transform.
outer: Matrix,
}
impl<'a, 'b> Ctx<'a, 'b> {
/// A page: whether it is the master page, and its layers.
fn page(&mut self, page: &Chunk) -> (bool, Page) {
let ix = self.ix;
let is_master = flags(ix, page).is_some_and(|f| f[2] != 0);
let size = own_loda(ix, page)
.and_then(|c| records::loda(ix.data(c), &self.p, &self.budget.limits, self.warn))
.and_then(|l| l.arg(ARG_PAGE_SIZE).and_then(|b| self.size_arg(b)));
let mut layers = Vec::new();
for l in page_layers(ix, page) {
let layer = self.layer(l);
let empty = layer.objects.is_empty() && layer.guides.is_empty();
// The entries that stand for the master page's layers hold nothing of the page's own.
if empty && (is_master || layer.kind != LayerKind::Drawing) {
continue;
}
layers.push(layer);
}
(is_master, Page { size, layers })
}
fn size_arg(&self, b: &[u8]) -> Option<(f64, f64)> {
let mut r = Rd::new(b);
sane_size(records::coord(&mut r, &self.p)?, records::coord(&mut r, &self.p)?)
}
fn layer(&mut self, list: &Chunk) -> Layer {
let ix = self.ix;
let loda = own_loda(ix, list).and_then(|c| records::loda(ix.data(c), &self.p, &self.budget.limits, self.warn));
// The layer's own object type says what it is; its flags, only when it has none (R19).
let kind = match &loda {
Some(l) => layer_kind_of_type(l.kind, self.p.types_from_zero),
None => flags(ix, list).map_or(LayerKind::Drawing, |f| layer_kind(f, self.p.old_master_flags)),
};
let name = loda.and_then(|l| l.arg(ARG_NAME).map(|b| records::name(b, &self.p, self.warn))).unwrap_or_default();
let mut guides = Vec::new();
let objects = self.objects(ix.children(list), &mut guides);
let flags = state(ix, list);
hide_guides(&mut guides, 0, flags);
Layer { name, kind, flags, objects, guides }
}
/// The objects of a layer's chunks, groups nested, front to back; guidelines go to `guides`.
fn objects(&mut self, chunks: &'b [Chunk], guides: &mut Vec<Guideline>) -> Vec<Object> {
let ix = self.ix;
let mut stack = vec![Frame {
chunks,
next: 0,
objects: Vec::new(),
group: false,
flags: Flags::default(),
guides_from: guides.len(),
outer: Matrix::IDENTITY,
}];
loop {
let Some(top) = stack.last_mut() else { return Vec::new() };
let (here, outer) = (top.chunks, top.outer);
let Some(c) = here.get(top.next) else {
let Some(done) = stack.pop() else { return Vec::new() };
// A hidden group hides the guidelines inside it.
hide_guides(guides, done.guides_from, done.flags);
match stack.last_mut() {
// A group counts toward the objects a read maps; past them its objects stay,
// ungrouped, with the group's flags.
Some(parent) if done.group && !done.objects.is_empty() => {
if self.budget.take_object() {
parent.objects.push(Object::Group { objects: done.objects, flags: done.flags });
} else {
push(self.warn, Warning::TooDeep);
let mut objects = done.objects;
for o in &mut objects {
inherit(o, done.flags);
}
parent.objects.extend(objects);
}
}
Some(parent) if !done.group => parent.objects.extend(done.objects),
Some(_) => {}
None => return done.objects,
}
continue;
};
top.next += 1;
// Every chunk of a clipped group counts, empty groups included, each time a container
// names the group; past the limit the group is left out.
if !self.open_clips.is_empty() && !self.budget.take_clipped_chunk() {
push(self.warn, Warning::TooDeep);
self.clip_cut = true;
return Vec::new();
}
if c.is_list(b"obj ") {
if let Some(o) = self.object(c, guides, &outer) {
top.objects.push(o);
}
} else if c.is_list(b"grp ") {
let own = self.group_placement(c);
let flags = state(ix, c);
let guides_from = guides.len();
stack.push(Frame { chunks: ix.children(c), next: 0, objects: Vec::new(), group: true, flags, guides_from, outer: outer.after(&own) });
} else if c.is_list(b"lnkg") {
// Linked groups (brush strokes, blends, contours) place their objects with a
// matrix of their own, which this reader doesn't apply: they are left out.
push(self.warn, Warning::UnsupportedObjects);
} else if c.id == crate::riff::LIST && !c.is_list(b"lgob") {
// Other lists under a layer are looked through (R22).
let guides_from = guides.len();
stack.push(Frame { chunks: ix.children(c), next: 0, objects: Vec::new(), group: false, flags: Flags::default(), guides_from, outer });
}
}
}
/// The matrix a group places its objects with. Only a version 3 group has one, in the
/// transforms argument of its own `lobj` (R33); one that can't be read is damage, and the
/// group's objects stay where their own transforms put them.
fn group_placement(&mut self, list: &Chunk) -> Matrix {
if !self.p.inline_styles {
return Matrix::IDENTITY;
}
let ix = self.ix;
let Some(arg) =
own_loda(ix, list).and_then(|c| records::loda(ix.data(c), &self.p, &self.budget.limits, self.warn)).and_then(|l| l.arg(ARG_TRANSFORMS))
else {
return Matrix::IDENTITY;
};
self.placement(arg)
}
/// The matrices of a transforms argument (R33). An envelope among them is not applied: the
/// shapes keep their outlines, placed by the matrices alone, with the envelopes warning.
fn placement(&mut self, arg: &[u8]) -> Matrix {
match inline::transforms(arg, &self.p, &self.budget.limits, self.warn) {
Some(t) => {
if t.envelope {
push(self.warn, Warning::Envelopes);
}
t.matrix
}
None => {
push(self.warn, Warning::Damaged);
Matrix::IDENTITY
}
}
}
/// One `LIST obj `: a shape placed by its own transform and then by `outer`, or `None` (a
/// guideline goes to `guides`).
fn object(&mut self, list: &Chunk, guides: &mut Vec<Guideline>, outer: &Matrix) -> Option<Object> {
let ix = self.ix;
let Some(loda) = own_loda(ix, list).and_then(|c| records::loda(ix.data(c), &self.p, &self.budget.limits, self.warn)) else {
push(self.warn, Warning::Damaged);
return None;
};
// Guidelines count toward the objects a read maps.
if !self.budget.take_object() {
push(self.warn, Warning::TooDeep);
return None;
}
let flags = state(ix, list);
if loda.kind == GUIDELINE {
guides.extend(loda.arg(ARG_GUIDE).and_then(|b| guideline(b, &self.p)).map(|g| Guideline { hidden: flags.hidden, ..g }));
return None;
}
if self.p.inline_styles {
return self.inline_object(&loda, outer, flags);
}
let geometry = self.geometry(&loda)?;
// A uniform transparency from version 13 applies (R47); a lens, and a transparency of
// another kind or version, is not applied: the shape shows opaque.
let (opacity, blend) = match loda.arg(ARG_LENS) {
None => (1.0, Blend::Normal),
Some(b) => match records::transparency(b).filter(|_| self.p.tagged) {
Some(t) => t,
None => {
push(self.warn, Warning::Lenses);
(1.0, Blend::Normal)
}
},
};
let nonzero = self.nonzero(&loda);
// A transform that is there but can't be read is damage; the shape stays where it is.
let matrix = match own_chunk(ix, list, &[b"trfd"]) {
None => Matrix::IDENTITY,
Some(c) => records::trfd(ix.data(c), &self.p).unwrap_or_else(|| {
push(self.warn, Warning::Damaged);
Matrix::IDENTITY
}),
};
// Without a fill or outline argument of its own, an object takes its style's (R45). The
// style id is a u16 in files of 16-bit fields.
let style = loda.arg(ARG_STYLE).and_then(|b| if self.p.short { self.short_id(b) } else { self.id(b) });
let fill_id = match loda.arg(ARG_FILL) {
Some(b) => self.id(b),
None => style.and_then(|s| self.style_entry(s, Styles::fill)),
};
let outline_id = match loda.arg(ARG_OUTLINE) {
Some(b) => self.id(b),
None => style.and_then(|s| self.style_entry(s, Styles::outline)),
};
let fill = fill_id.and_then(|id| self.fill(id));
let outline = outline_id.and_then(|id| self.outline(id));
let shape = Box::new(Shape { geometry, matrix, fill, outline, nonzero, opacity, blend, flags });
// A container clips the group its argument 8005 names (R46).
Some(match loda.arg(ARG_CONTAINER).and_then(|b| self.id(b)) {
Some(id) => self.clip(shape, id, guides),
None => Object::Shape(shape),
})
}
/// `container` and the objects of the clipped group `id`, which keep their own transforms.
/// A group that isn't there is damage; one already being read, past the depth limit or past
/// the chunks clipped groups may walk is left out with the limit warning, the guidelines it
/// holds included. Either way the container stays, as a plain shape.
fn clip(&mut self, container: Box<Shape>, id: u32, guides: &mut Vec<Guideline>) -> Object {
let Some(&group) = self.clips.get(&id) else {
push(self.warn, Warning::Damaged);
return Object::Shape(container);
};
if self.open_clips.contains(&id) || self.open_clips.len() >= MAX_CLIP_DEPTH {
push(self.warn, Warning::TooDeep);
return Object::Shape(container);
}
self.open_clips.push(id);
let (ix, mark) = (self.ix, guides.len());
let objects = self.objects(ix.children(group), guides);
self.open_clips.pop();
if std::mem::take(&mut self.clip_cut) {
guides.truncate(mark);
return Object::Shape(container);
}
// The clipped group's own flags hide or lock the objects it holds; it and the container
// hide its guidelines.
let flags = state(ix, group);
hide_guides(guides, mark, flags);
hide_guides(guides, mark, container.flags);
if objects.is_empty() {
return Object::Shape(container);
}
let mut objects = objects;
for o in &mut objects {
inherit(o, flags);
}
Object::Clip { container, objects }
}
/// The record id that argument `b` names; an argument too short for one is damage.
fn id(&mut self, b: &[u8]) -> Option<u32> {
let id = id_of(b);
if id.is_none() {
push(self.warn, Warning::Damaged);
}
id
}
/// A u16 id at the start of argument `b`; an argument too short for one is damage.
fn short_id(&mut self, b: &[u8]) -> Option<u32> {
let id = Rd::new(b).u16().map(u32::from);
if id.is_none() {
push(self.warn, Warning::Damaged);
}
id
}
/// Whether the object's fill rule is nonzero: byte 0 of argument 14001 set (R52). Without the
/// argument the fill is even-odd; an argument without its byte is damage.
fn nonzero(&mut self, loda: &Loda) -> bool {
let Some(b) = loda.arg(ARG_WINDING) else { return false };
match b.first() {
Some(v) => *v != 0,
None => {
push(self.warn, Warning::Damaged);
false
}
}
}
/// The fill or outline record that style `id` names; a style table that doesn't parse is
/// damage, and the object is drawn without it.
fn style_entry(&mut self, id: u32, entry: fn(&Styles, u32) -> Option<u32>) -> Option<u32> {
match &self.styles {
Ok(s) => entry(s, id),
Err(()) => {
push(self.warn, Warning::Damaged);
None
}
}
}
/// A version 3 object, whose transforms, fill and outline are arguments of its own record
/// (R33, R34, R35). A fill or an outline that is there but can't be read is damage.
fn inline_object(&mut self, loda: &Loda, outer: &Matrix, flags: Flags) -> Option<Object> {
let own = match loda.arg(ARG_TRANSFORMS) {
None => Matrix::IDENTITY,
Some(arg) => self.placement(arg),
};
let geometry = self.geometry(loda)?;
let fill = loda.arg(ARG_FILL).and_then(|b| {
let read = inline::fill(b, &self.p, self.warn);
if read.is_none() {
push(self.warn, Warning::Damaged);
}
read.flatten()
});
let outline = loda.arg(ARG_OUTLINE).and_then(|b| {
let read = inline::outline(b, &self.p, self.warn);
if read.is_none() {
push(self.warn, Warning::Damaged);
}
read.flatten()
});
// Past the dashes a read takes, the outline is solid.
let outline = outline.map(|mut o| {
if !o.dashes.is_empty() && !self.budget.take_dashes(o.dashes.len()) {
o.dashes = Vec::new();
push(self.warn, Warning::TooDeep);
}
o
});
let nonzero = self.nonzero(loda);
let shape = Shape { nonzero, flags, ..Shape::new(geometry, outer.after(&own), fill, outline) };
Some(Object::Shape(Box::new(shape)))
}
fn geometry(&mut self, loda: &Loda) -> Option<Geometry> {
let coords = loda.arg(ARG_COORDS);
// Version 3 counts the first object types from 0, one below the later numbers (R32).
let kind = if self.p.types_from_zero && loda.kind <= 4 { loda.kind + 1 } else { loda.kind };
// A shape without its coordinates, or a polygon without its sides, is damage like a shape
// whose coordinates can't be read; one left out at the coordinate limit is not.
self.budget.coordinates_refused();
let g = match kind {
RECTANGLE => coords.and_then(|c| geometry::rect(c, &self.p)),
ELLIPSE => coords.and_then(|c| geometry::ellipse(c, &self.p)),
CURVE => coords.and_then(|c| geometry::point_list(c, &self.p, self.budget, self.warn)).map(Geometry::Path),
PATH if self.p.paths => coords.and_then(|c| geometry::path_record(c, &self.p, self.budget, self.warn)).map(Geometry::Path),
POLYGON => match loda.arg(ARG_POLYGON) {
Some(sides) => coords
.and_then(|c| geometry::point_list(c, &self.p, self.budget, self.warn))
.and_then(|base| geometry::polygon(&base, sides, &self.p, self.budget, self.warn)),
None => {
push(self.warn, Warning::Damaged);
return None;
}
},
_ => {
push(self.warn, Warning::UnsupportedObjects);
return None;
}
};
if g.is_none() && !self.budget.coordinates_refused() {
push(self.warn, Warning::Damaged);
}
g
}
fn fill(&mut self, id: u32) -> Option<Color> {
if let Some(f) = self.fills.get(&id) {
return f.clone();
}
// A record that is missing or can't be read is damage, and the shape is drawn without a
// fill; id 0 without a record is no fill.
if id != 0 && !self.fill_chunks.contains_key(&id) {
push(self.warn, Warning::Damaged);
}
let read = self.fill_chunks.get(&id).and_then(|b| {
let read = records::fill(b, &self.p, self.warn);
if read.is_none() {
push(self.warn, Warning::Damaged);
}
read.and_then(|(_, c)| c)
});
self.fills.insert(id, read.clone());
read
}
/// The outline of record `id`. Its dashes count toward the read's dashes for every shape that
/// uses it; past them the shape's outline is solid.
fn outline(&mut self, id: u32) -> Option<Outline> {
if !self.outlines.contains_key(&id) {
// A record that is missing is damage, as one that can't be read is; id 0 without a
// record is no outline.
if id != 0 && !self.outline_chunks.contains_key(&id) {
push(self.warn, Warning::Damaged);
}
let read = self.outline_chunks.get(&id).and_then(|b| {
let read = records::outline(b, &self.p, self.warn);
if read.is_none() {
push(self.warn, Warning::Damaged);
}
read.and_then(|(_, o)| o)
});
// An outline with more dashes than the read may still take is kept solid.
let read = read.map(|mut o| {
if o.dashes.len() > self.budget.dashes_left() {
o.dashes = Vec::new();
push(self.warn, Warning::TooDeep);
}
o
});
self.outlines.insert(id, read);
}
let o = self.outlines.get_mut(&id)?.as_mut()?;
// The dashes left only shrink, so an outline refused once is refused for every later
// shape: its dashes are dropped from the cache, and later shapes take it solid.
if !o.dashes.is_empty() && !self.budget.take_dashes(o.dashes.len()) {
o.dashes = Vec::new();
push(self.warn, Warning::TooDeep);
}
Some(o.clone())
}
}
/// A fill or outline argument: the record id (R20).
fn id_of(b: &[u8]) -> Option<u32> {
Rd::new(b).u32()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn layer_flags_name_the_kinds() {
assert_eq!(layer_kind([0, 0, 0, 0x98], true), LayerKind::Drawing);
assert_eq!(layer_kind([0x0a, 0, 0, 0x98], true), LayerKind::Guides);
assert_eq!(layer_kind([0x02, 1, 1, 0x98], true), LayerKind::Guides);
assert_eq!(layer_kind([0x08, 0, 1, 0x98], true), LayerKind::Desktop);
assert_eq!(layer_kind([0, 1, 1, 0x98], true), LayerKind::Desktop);
assert_eq!(layer_kind([0x1a, 0, 1, 0x98], true), LayerKind::Grid);
assert_eq!(layer_kind([0x12, 0, 1, 0x98], true), LayerKind::Grid);
// From version 14 the master page flags its layers by byte 0 alone.
assert_eq!(layer_kind([0x0a, 0, 1, 0x98], false), LayerKind::Guides);
assert_eq!(layer_kind([0x08, 0, 1, 0x98], false), LayerKind::Desktop);
assert_eq!(layer_kind([0x5a, 1, 1, 0x98], false), LayerKind::Grid);
assert_eq!(layer_kind([0x02, 1, 1, 0x98], false), LayerKind::Drawing);
assert_eq!(layer_kind([0, 1, 1, 0x98], false), LayerKind::Drawing);
// Drawing layers flagged 0x10, 0x08, 0x18, 0x40 and 0x58 with byte 2 clear, as sample
// files flag them, and desktop and guides layers with bit 0x40 or 0x10 set.
for f in [[0x10, 0, 0, 0x98], [0x08, 1, 0, 0x98], [0x18, 1, 0, 0x98], [0x40, 0, 0, 0x98], [0x58, 1, 0, 0x98]] {
assert_eq!(layer_kind(f, true), LayerKind::Drawing, "{f:?}");
assert_eq!(layer_kind(f, false), LayerKind::Drawing, "{f:?}");
}
assert_eq!(layer_kind([0x18, 0, 1, 0x98], true), LayerKind::Desktop);
assert_eq!(layer_kind([0x48, 0, 1, 0x98], false), LayerKind::Desktop);
assert_eq!(layer_kind([0x4a, 1, 1, 0x98], true), LayerKind::Guides);
}
/// An outline record refused at the dash limit keeps no dashes in the cache, so the shapes
/// that use it later copy none.
#[test]
fn an_outline_past_the_dash_limit_keeps_no_dashes() {
let v = crate::synth::V(1100);
let pen = crate::synth::Pen { line_type: 4, width: 1.0, cap: 0, join: 0 };
let record = v.outline(1, pen, &crate::synth::color(5, [0, 0, 0, 255]), &[3, 1, 3]);
let file = crate::synth::riff(1100, &[]);
let mut budget = Budget::new(crate::Limits { dashes: 4, ..crate::Limits::default() });
let mut warn = Vec::new();
let ix = crate::riff::Index::build(&file, None, &mut budget, &mut warn).unwrap();
let mut cx = Ctx {
ix: &ix,
p: layout::for_version(1100).unwrap(),
budget: &mut budget,
warn: &mut warn,
fill_chunks: HashMap::new(),
outline_chunks: HashMap::from([(1, record.as_slice())]),
fills: HashMap::new(),
outlines: HashMap::new(),
styles: Ok(Styles::default()),
clips: HashMap::new(),
open_clips: Vec::new(),
clip_cut: false,
};
assert_eq!(cx.outline(1).map(|o| o.dashes.len()), Some(3));
for _ in 0..3 {
assert_eq!(cx.outline(1).map(|o| o.dashes.len()), Some(0));
assert_eq!(cx.outlines.get(&1).and_then(|o| o.as_ref()).map(|o| o.dashes.len()), Some(0));
}
assert_eq!(*cx.warn, vec![Warning::TooDeep]);
}
}
-76
View File
@@ -1,76 +0,0 @@
//! Little-endian reads that fail instead of panicking.
/// A cursor over one record's bytes. Every read returns `None` past the end.
#[derive(Clone, Copy, Debug)]
pub(crate) struct Rd<'a> {
b: &'a [u8],
pos: usize,
}
impl<'a> Rd<'a> {
pub(crate) fn new(b: &'a [u8]) -> Self {
Rd { b, pos: 0 }
}
pub(crate) fn at(b: &'a [u8], pos: usize) -> Self {
Rd { b, pos }
}
pub(crate) fn pos(&self) -> usize {
self.pos
}
pub(crate) fn left(&self) -> usize {
self.b.len().saturating_sub(self.pos)
}
pub(crate) fn skip(&mut self, n: usize) -> Option<()> {
let end = self.pos.checked_add(n)?;
(end <= self.b.len()).then(|| self.pos = end)
}
pub(crate) fn bytes(&mut self, n: usize) -> Option<&'a [u8]> {
let end = self.pos.checked_add(n)?;
let s = self.b.get(self.pos..end)?;
self.pos = end;
Some(s)
}
fn array<const N: usize>(&mut self) -> Option<[u8; N]> {
self.bytes(N)?.try_into().ok()
}
pub(crate) fn u8(&mut self) -> Option<u8> {
Some(self.array::<1>()?[0])
}
pub(crate) fn u16(&mut self) -> Option<u16> {
self.array().map(u16::from_le_bytes)
}
pub(crate) fn i16(&mut self) -> Option<i16> {
self.array().map(i16::from_le_bytes)
}
pub(crate) fn u32(&mut self) -> Option<u32> {
self.array().map(u32::from_le_bytes)
}
pub(crate) fn i32(&mut self) -> Option<i32> {
self.array().map(i32::from_le_bytes)
}
/// A finite f64; NaN and the infinities read as `None`.
pub(crate) fn f64(&mut self) -> Option<f64> {
self.array().map(f64::from_le_bytes).filter(|v| v.is_finite())
}
pub(crate) fn fourcc(&mut self) -> Option<[u8; 4]> {
self.array()
}
}
/// The u32 at `pos` of `b`.
pub(crate) fn u32_at(b: &[u8], pos: usize) -> Option<u32> {
Rd::at(b, pos).u32()
}
-651
View File
@@ -1,651 +0,0 @@
//! Reader for `.cmx` exchange files with 32-bit coordinates: the RIFF form `CMX1` (R53), its
//! header (R54), the color, pen, line type, dash, outline and arrowhead tables (R55 to R59) and the
//! instructions of each page (R60): pages, layers, groups and curves (R61, R62) with uniform fills
//! and outlines (R63). Text, images, rectangles, ellipses, clipping paths, other fills and lenses
//! are left out with a warning.
use crate::bytes::{Rd, u32_at};
use crate::geometry::path_of;
use crate::layout::{self, Profile};
use crate::limits::Budget;
use crate::model::{Cap, Color, Drawing, Geometry, Join, Layer, LayerKind, Matrix, Object, Outline, Page, Pt, Shape};
use crate::records::{name, property_color};
use crate::riff::{LIST, push};
use crate::{Error, Warning};
const FORM: [u8; 4] = *b"CMX1";
/// Meters per coordinate unit when the header gives no usable value: the 0.1 µm of every sample
/// file with 32-bit coordinates (R54).
const DEFAULT_UNIT: f64 = 1e-7;
/// How far past a chunk that runs short the next chunk id is looked for (R53).
const RESYNC: usize = 64;
/// The chunks the reader uses (R53 to R60).
const READ_IDS: [[u8; 4]; 9] = [*b"LIST", *b"cont", *b"page", *b"rclr", *b"rpen", *b"rott", *b"rdot", *b"rotl", *b"rota"];
/// The most UTF-16 units read of a layer's name; [`name`] keeps 256 of them.
const MAX_NAME_UNITS: usize = 4096;
// Instruction codes (R60).
const BEGIN_PAGE: i16 = 9;
const END_PAGE: i16 = 10;
const BEGIN_LAYER: i16 = 11;
const END_LAYER: i16 = 12;
const BEGIN_GROUP: i16 = 13;
const END_GROUP: i16 = 14;
const BEGIN_TEXT: i16 = 20;
const END_TEXT: i16 = 21;
const GLYPH_RUN: i16 = 65;
const ELLIPSE: i16 = 66;
const CURVE: i16 = 67;
const RECTANGLE: i16 = 68;
const IMAGE: i16 = 69;
const ADD_CLIP: i16 = 88;
const REMOVE_CLIP: i16 = 89;
const JUMP: i16 = 111;
/// Does `bytes` start as a CMX file: a RIFF or RIFX form of type `CMX1` (R53)?
pub(crate) fn is_cmx(bytes: &[u8]) -> bool {
matches!(bytes.get(0..4), Some(b"RIFF" | b"RIFX")) && bytes.get(8..12) == Some(FORM.as_slice())
}
/// A chunk outside the `LIST` chunks: its id, its body and where the body starts in the file.
struct Chunk<'a> {
id: [u8; 4],
body: &'a [u8],
start: usize,
}
/// The tables that page instructions refer to by 1-based index (R55 to R59).
#[derive(Default)]
struct Tables {
colors: Vec<Option<Color>>,
/// Outline widths in points.
pens: Vec<Option<f64>>,
/// Flags, and the caps and join.
line_types: Vec<Option<(u8, u8)>>,
dashes: Vec<Vec<u16>>,
/// Line type, screen, color, arrowheads, pen and dashes.
outlines: Vec<Option<[u16; 6]>>,
arrowheads: Vec<(u16, u16)>,
}
pub(crate) fn drawing(bytes: &[u8], budget: &mut Budget) -> Result<Drawing, Error> {
if !is_cmx(bytes) {
return Err(Error::NotCmx);
}
if bytes.get(0..4) == Some(b"RIFX") {
return Err(Error::Unsupported("big-endian CMX files"));
}
let mut warn = Vec::new();
let chunks = chunks(bytes, budget, &mut warn)?;
let cont = chunks.iter().find(|c| c.id == *b"cont").map(|c| c.body).ok_or(Error::Damaged("CMX header"))?;
match cont.get(52) {
Some(b'4') => {}
Some(b'2') => return Err(Error::Unsupported("CMX files with 16-bit coordinates")),
_ => return Err(Error::Damaged("CMX header")),
}
let meters = Rd::at(cont, 64).f64().filter(|m| *m > 0.0 && *m <= 1.0).unwrap_or(DEFAULT_UNIT);
let unit = meters / 0.0254 * 72.0;
let tables = Tables::read(&chunks, unit, budget, &mut warn)?;
let mut pages = Vec::new();
for c in chunks.iter().filter(|c| c.id == *b"page") {
pages.push(PageRead::new(&tables, unit, budget, &mut warn).read(c)?);
}
Ok(Drawing { version: 0, page_size: None, pages, master: Vec::new(), guides: Vec::new(), warnings: warn })
}
/// The chunks of the file in order, those inside `LIST` chunks in place (R53).
fn chunks<'a>(b: &'a [u8], budget: &mut Budget, warn: &mut Vec<Warning>) -> Result<Vec<Chunk<'a>>, Error> {
let declared = u32_at(b, 4).and_then(|n| (n as usize).checked_add(8)).unwrap_or(b.len());
if declared > b.len() {
// The file was cut short of the size its header gives.
push(warn, Warning::Damaged);
}
let end = declared.min(b.len());
let mut out = Vec::new();
// (position, end, depth) of the lists still to walk; a list's children go before the rest of
// the list that holds it.
let mut stack = vec![(12usize, end, 0usize)];
while let Some((mut pos, end, depth)) = stack.pop() {
while pos.saturating_add(8) <= end {
let Some(id) = Rd::at(b, pos).fourcc() else { break };
if !is_id(&id) {
match resync(b, pos, end) {
Some(next) => {
pos = next;
continue;
}
None => {
push(warn, Warning::Damaged);
break;
}
}
}
budget.take_chunk()?;
let size = u32_at(b, pos + 4).map_or(0, |s| s as usize);
let start = pos + 8;
let stop = start.saturating_add(size);
if stop > end {
// Stray bytes that happen to start with four letters give a length past the list:
// look for the next chunk id after them. A chunk the reader uses is kept, cut at
// the end of the list.
if !READ_IDS.contains(&id)
&& let Some(next) = resync(b, pos, end)
{
pos = next;
continue;
}
push(warn, Warning::Damaged);
}
let stop = stop.min(end);
let next = stop.saturating_add(size & 1);
if id == LIST {
if depth >= budget.limits.depth {
push(warn, Warning::TooDeep);
pos = next;
continue;
}
stack.push((next, end, depth));
stack.push((start + 4, stop, depth + 1));
break;
}
if let Some(body) = b.get(start..stop) {
out.push(Chunk { id, body, start });
}
pos = next;
}
}
Ok(out)
}
/// Is `t` a chunk id: an ASCII letter, then three ASCII letters, digits or spaces (R53)?
fn is_id(t: &[u8]) -> bool {
matches!(t, [first, rest @ ..] if t.len() == 4 && first.is_ascii_alphabetic() && rest.iter().all(|c| c.is_ascii_alphanumeric() || *c == b' '))
}
/// Where the next chunk after `pos` lies: the first chunk id at an even distance of 2 to [`RESYNC`]
/// bytes that names a chunk the reader uses, or another chunk whose length keeps it inside the list
/// that ends at `end` (R53).
fn resync(b: &[u8], pos: usize, end: usize) -> Option<usize> {
let fits = |p: usize| u32_at(b, p + 4).and_then(|s| (p + 8).checked_add(s as usize)).is_some_and(|stop| stop <= end);
let chunk_at = |p: usize| Rd::at(b, p).fourcc().is_some_and(|id| is_id(&id) && (READ_IDS.contains(&id) || fits(p)));
(pos + 2..=pos.saturating_add(RESYNC).min(end.saturating_sub(8))).step_by(2).find(|&p| chunk_at(p))
}
/// The end of the field list at `pos` of `b`: after its 0xff, or the end of `b` when a field runs
/// past it (R55).
fn list_end(b: &[u8], mut pos: usize) -> usize {
while let Some(&tag) = b.get(pos) {
if tag == 0xff {
return pos + 1;
}
match Rd::at(b, pos + 1).u16().map(usize::from).filter(|n| *n >= 3) {
Some(n) if pos + n <= b.len() => pos += n,
_ => break,
}
}
b.len()
}
/// The data of field `tag` in the field list `b` (R55).
fn field(b: &[u8], tag: u8) -> Option<&[u8]> {
let mut pos = 0;
while let Some(&t) = b.get(pos) {
if t == 0xff {
return None;
}
let n = usize::from(Rd::at(b, pos + 1).u16()?);
let data = b.get(pos + 3..pos.checked_add(n)?).filter(|_| n >= 3)?;
if t == tag {
return Some(data);
}
pos += n;
}
None
}
/// The field lists of a table: a u16 count, then that many lists (R55). Each entry counts toward
/// the chunk limit.
fn entries<'a>(d: &'a [u8], budget: &mut Budget) -> Result<Vec<&'a [u8]>, Error> {
let count = Rd::new(d).u16().map_or(0, usize::from);
let mut out = Vec::new();
let mut pos = 2;
for _ in 0..count {
if pos >= d.len() {
break;
}
budget.take_chunk()?;
let end = list_end(d, pos);
out.push(d.get(pos..end).unwrap_or_default());
pos = end;
}
Ok(out)
}
impl Tables {
/// The first chunk of each table; a table that is missing is empty.
fn read(chunks: &[Chunk], unit: f64, budget: &mut Budget, warn: &mut Vec<Warning>) -> Result<Tables, Error> {
let first = |id: &[u8; 4]| chunks.iter().find(|c| c.id == *id).map_or(&[][..], |c| c.body);
// A color record of field 10 holds a property list as a `.cdr` fill does (R56).
let record = layout::for_version(1300);
let mut t = Tables::default();
for e in entries(first(b"rclr"), budget)? {
t.colors.push(color(e, record.as_ref(), warn));
}
for e in entries(first(b"rpen"), budget)? {
t.pens.push(field(e, 1).and_then(|f| Rd::new(f).u32()).map(|w| f64::from(w) * unit));
}
for e in entries(first(b"rott"), budget)? {
t.line_types.push(field(e, 1).and_then(|f| Some((*f.first()?, f.get(1).copied().unwrap_or(0)))));
}
for e in entries(first(b"rdot"), budget)? {
let mut r = Rd::new(field(e, 1).unwrap_or_default());
let n = r.u16().map_or(0, usize::from);
t.dashes.push((0..n).map_while(|_| r.u16()).collect());
}
for e in entries(first(b"rotl"), budget)? {
t.outlines.push(field(e, 1).and_then(|f| {
let mut r = Rd::new(f);
Some([r.u16()?, r.u16()?, r.u16()?, r.u16()?, r.u16()?, r.u16()?])
}));
}
// Arrowhead pairs are plain u16 pairs after the count, not field lists (R59).
let mut r = Rd::new(first(b"rota"));
let n = r.u16().map_or(0, usize::from);
for _ in 0..n {
let Some(pair) = r.u16().zip(r.u16()) else { break };
budget.take_chunk()?;
t.arrowheads.push(pair);
}
Ok(t)
}
/// Entry `index` (1-based) of `list`, or `None` with a warning when there is none.
fn get<T: Clone>(list: &[Option<T>], index: u16, warn: &mut Vec<Warning>) -> Option<T> {
let found = usize::from(index).checked_sub(1).and_then(|i| list.get(i)).cloned().flatten();
if found.is_none() {
push(warn, Warning::Damaged);
}
found
}
fn color(&self, index: u16, warn: &mut Vec<Warning>) -> Color {
Tables::get(&self.colors, index, warn).unwrap_or(Color::Rgb([0.0; 3]))
}
/// The outline of `rotl` entry `index`, or `None` when its line type draws none (R57, R58).
fn outline(&self, index: u16, budget: &mut Budget, warn: &mut Vec<Warning>) -> Option<Outline> {
let [line, _screen, color, arrows, pen, dash] = Tables::get(&self.outlines, index, warn)?;
let (flags, caps_join) = Tables::get(&self.line_types, line, warn).unwrap_or((2, 0));
if flags & 1 != 0 {
return None;
}
let width = Tables::get(&self.pens, pen, warn).unwrap_or(0.0);
let mut dashes = Vec::new();
if flags & 4 != 0 {
let stored = usize::from(dash).checked_sub(1).and_then(|i| self.dashes.get(i));
match stored {
// A pattern of zero lengths draws as a solid line, as in a `.cdr` outline (R48).
Some(d) if d.iter().all(|x| *x == 0) => {}
Some(d) if budget.take_dashes(d.len()) => dashes = d.iter().map(|x| f64::from(*x)).collect(),
Some(_) => push(warn, Warning::TooDeep),
None => push(warn, Warning::Damaged),
}
}
if usize::from(arrows).checked_sub(1).and_then(|i| self.arrowheads.get(i)).is_some_and(|(s, e)| *s != 0 || *e != 0) {
push(warn, Warning::Arrowheads);
}
Some(Outline {
width,
color: self.color(color, warn),
cap: match caps_join & 0x0f {
1 => Cap::Round,
2 => Cap::Square,
_ => Cap::Butt,
},
join: match caps_join >> 4 {
1 => Join::Round,
2 => Join::Bevel,
_ => Join::Miter,
},
dashes,
behind_fill: flags & 8 != 0,
scale_with: flags & 16 != 0,
})
}
}
/// A color entry (R56): the property list of field 10 when there is one, else the model and
/// palette bytes of field 1 and the values of field 2. Colors in other models read as black with a
/// warning.
fn color(e: &[u8], record: Option<&Profile>, warn: &mut Vec<Warning>) -> Option<Color> {
if let (Some(f), Some(p)) = (field(e, 10), record) {
let mut r = Rd::new(f);
let len = r.u32()? as usize;
return property_color(r.bytes(len.min(r.left()))?, p, warn);
}
let model = *field(e, 1)?.first()?;
let v = field(e, 2)?;
let byte = |i: usize| v.get(i).map(|b| f32::from(*b));
let pct = |i: usize| byte(i).map(|x| (x / 100.0).clamp(0.0, 1.0));
let full = |i: usize| byte(i).map(|x| x / 255.0);
Some(match model {
2 => Color::Cmyk([pct(0)?, pct(1)?, pct(2)?, pct(3)?]),
3 => Color::Cmyk([full(0)?, full(1)?, full(2)?, full(3)?]),
4 => Color::Cmyk([full(0)?, full(1)?, full(2)?, 0.0]),
5 => Color::Rgb([full(0)?, full(1)?, full(2)?]),
9 => Color::Gray(1.0 - full(0)?),
_ => {
push(warn, Warning::UnknownColors);
Color::Rgb([0.0; 3])
}
})
}
/// The objects of one layer while it is read: the layer's own list, then one list for each group
/// left open.
struct LayerRead {
name: String,
lists: Vec<Vec<Object>>,
}
impl LayerRead {
/// The layer, its open groups closed. Lists are drawn back to front (R60), and the model holds
/// them front to back.
fn finish(mut self) -> Layer {
while self.lists.len() > 1 {
close_group(&mut self.lists);
}
let mut objects = self.lists.pop().unwrap_or_default();
objects.reverse();
Layer { name: self.name, kind: LayerKind::Drawing, flags: Default::default(), objects, guides: Vec::new() }
}
}
/// Close the innermost open group of `lists` into the one that holds it.
fn close_group(lists: &mut Vec<Vec<Object>>) {
if lists.len() < 2 {
return;
}
let mut objects = lists.pop().unwrap_or_default();
objects.reverse();
if let Some(top) = lists.last_mut() {
top.push(Object::Group { objects, flags: Default::default() });
}
}
/// The reading of one page chunk.
struct PageRead<'t, 'b> {
tables: &'t Tables,
unit: f64,
budget: &'b mut Budget,
warn: &'b mut Vec<Warning>,
size: Option<(f64, f64)>,
/// The page's center in the file's coordinates when the page takes its size from the
/// drawing's bounds; points are moved by it so the art lies on the page.
center: (f64, f64),
layers: Vec<Layer>,
open: Option<LayerRead>,
/// Groups nested past the depth limit that are still open; their content is left out.
skipped: usize,
}
impl<'t, 'b> PageRead<'t, 'b> {
fn new(tables: &'t Tables, unit: f64, budget: &'b mut Budget, warn: &'b mut Vec<Warning>) -> Self {
PageRead { tables, unit, budget, warn, size: None, center: (0.0, 0.0), layers: Vec::new(), open: None, skipped: 0 }
}
/// The instructions of a page chunk: a u16 size counting the whole instruction and an i16 code,
/// or 0xFFFF, a u32 size and the code; then the code's field lists (R60).
fn read(mut self, c: &Chunk) -> Result<Page, Error> {
let d = c.body;
let mut pos = 0usize;
while pos.saturating_add(4) <= d.len() {
self.budget.take_chunk()?;
let mut r = Rd::at(d, pos);
let (size, code, head) = match r.u16() {
Some(0xFFFF) => match (r.u32(), r.i16()) {
(Some(size), Some(code)) => (size as usize, code, 8),
_ => break,
},
Some(size) => match r.i16() {
Some(code) => (usize::from(size), code, 4),
None => break,
},
None => break,
};
if size < head {
push(self.warn, Warning::Damaged);
break;
}
let end = pos.saturating_add(size);
if end > d.len() {
push(self.warn, Warning::Damaged);
}
let body = d.get(pos + head..end.min(d.len())).unwrap_or_default();
if code == JUMP {
// Field 1 is the file offset the instructions go on from; the bytes passed over
// hold the page's images (R60).
let target = field(body, 1).and_then(|f| Rd::new(f).u32()).and_then(|t| (t as usize).checked_sub(c.start));
pos = target.filter(|t| *t >= end && *t <= d.len()).unwrap_or(end);
if pos > end {
push(self.warn, Warning::UnsupportedObjects);
}
continue;
}
self.instruction(code, body);
pos = end;
}
if pos < d.len() {
// An instruction whose head runs past the page was not read.
push(self.warn, Warning::Damaged);
}
self.close_layer();
// A layer that holds nothing (the special layers every sample file lists empty) is left
// out. The file lists layers back to front.
let mut layers = self.layers;
layers.retain(|l| !l.objects.is_empty());
layers.reverse();
Ok(Page { size: self.size, layers })
}
fn instruction(&mut self, code: i16, body: &[u8]) {
match code {
BEGIN_PAGE => {
// Field 4: the page's width and height (R61).
let mut r = Rd::new(field(body, 4).unwrap_or_default());
if let (Some(w), Some(h)) = (r.u32(), r.u32()) {
let (w, h) = (f64::from(w) * self.unit, f64::from(h) * self.unit);
self.size = (w > 0.0 && h > 0.0).then_some((w, h));
}
if self.size.is_none() {
self.size_from_bounds(field(body, 1).unwrap_or_default());
}
}
BEGIN_LAYER => {
self.close_layer();
// A layer without a name is left unnamed, as in a `.cdr` drawing.
let name = self.layer_name(body).unwrap_or_default();
self.open = Some(LayerRead { name, lists: vec![Vec::new()] });
}
END_LAYER => self.close_layer(),
BEGIN_GROUP => {
let open = self.layer().lists.len();
if self.skipped > 0 || open > self.budget.limits.depth {
self.skipped += 1;
push(self.warn, Warning::TooDeep);
} else if self.budget.take_object() {
self.layer().lists.push(Vec::new());
} else {
// Past the object limit the group's content joins the group that holds it.
self.skipped += 1;
push(self.warn, Warning::TooDeep);
}
}
END_GROUP => {
if self.skipped > 0 {
self.skipped -= 1;
} else {
close_group(&mut self.layer().lists);
}
}
CURVE if self.skipped == 0 => {
if let Some(shape) = self.curve(body) {
if self.budget.take_object() {
if let Some(list) = self.layer().lists.last_mut() {
list.push(Object::Shape(Box::new(shape)));
}
} else {
push(self.warn, Warning::TooDeep);
}
}
}
BEGIN_TEXT | GLYPH_RUN | ELLIPSE | RECTANGLE | IMAGE | ADD_CLIP => push(self.warn, Warning::UnsupportedObjects),
// These and the other codes (text styles and characters, color contexts) draw nothing
// on their own.
END_PAGE | END_TEXT | REMOVE_CLIP => {}
_ => {}
}
}
/// A page without a size of its own is sized to the drawing's bounds in field 1 (R61): a u16
/// page number, a u32 of flags, then the left, top, right and bottom edges as i32 in
/// coordinate units. The page is centered on those bounds.
fn size_from_bounds(&mut self, f: &[u8]) {
let mut r = Rd::new(f);
if r.u16().is_none() || r.u32().is_none() {
return;
}
let (Some(l), Some(t), Some(rt), Some(b)) = (r.i32(), r.i32(), r.i32(), r.i32()) else {
return;
};
let (l, t, rt, b) = (f64::from(l) * self.unit, f64::from(t) * self.unit, f64::from(rt) * self.unit, f64::from(b) * self.unit);
let (w, h) = ((rt - l).abs(), (t - b).abs());
if w > 0.0 && h > 0.0 {
self.size = Some((w, h));
self.center = ((l + rt) / 2.0, (t + b) / 2.0);
}
}
/// The open layer, or a new unnamed one when objects come before any layer begins.
fn layer(&mut self) -> &mut LayerRead {
self.open.get_or_insert_with(|| LayerRead { name: String::new(), lists: vec![Vec::new()] })
}
fn close_layer(&mut self) {
self.skipped = 0;
if let Some(l) = self.open.take() {
self.layers.push(l.finish());
}
}
/// A layer's name: field 4 as a u32 count and UTF-16 units, else field 1 from byte 12 as a
/// u16 count and 8-bit characters (R62).
fn layer_name(&mut self, body: &[u8]) -> Option<String> {
// A field 4 that can't be read leaves the name to field 1.
let wide = field(body, 4).and_then(|f| {
let mut r = Rd::new(f);
let n = (r.u32()? as usize).min(MAX_NAME_UNITS).min(r.left() / 2);
Some((r.bytes(n * 2)?, layout::for_version(1200)?))
});
if let Some((units, l)) = wide {
let s = name(units, &l, self.warn);
if !s.trim().is_empty() {
return Some(s);
}
}
let mut r = Rd::at(field(body, 1)?, 12);
let n = usize::from(r.u16()?).min(r.left());
let s = name(r.bytes(n)?, &layout::for_version(1100)?, self.warn);
(!s.trim().is_empty()).then_some(s)
}
/// A curve (R62): field 1 its rendering attributes, field 2 a u16 point count, the points (i32
/// x and y) and one type byte for each. Points are from the page's center, y up.
fn curve(&mut self, body: &[u8]) -> Option<Shape> {
let mut r = Rd::new(field(body, 2).unwrap_or_default());
let Some(count) = r.u16().map(usize::from) else {
// A curve without its points is lost.
push(self.warn, Warning::Damaged);
return None;
};
// `stored` points are read, so the type bytes are found after all of them, and the first
// `n`, those that have a type byte, are kept. When the field holds every point, a short
// field has lost type bytes. When it holds whole points and their types for fewer points,
// the count is too large. Otherwise the field lost points, and its type bytes can't be
// found: the curve is lost.
let left = r.left();
let (stored, n) = match count.checked_mul(8).filter(|c| *c <= left) {
Some(c) => (count, count.min(left - c)),
None if left.is_multiple_of(9) => (left / 9, left / 9),
None => {
push(self.warn, Warning::Damaged);
return None;
}
};
if n < count {
push(self.warn, Warning::Damaged);
}
if !self.budget.take_coordinates(stored) {
push(self.warn, Warning::TooDeep);
return None;
}
let mut points = Vec::with_capacity(stored);
for _ in 0..stored {
let (x, y) = (f64::from(r.i32()?) * self.unit, f64::from(r.i32()?) * self.unit);
points.push(Pt { x: x - self.center.0, y: y - self.center.1 });
}
points.truncate(n);
let path = path_of(&points, r.bytes(n)?);
if path.subpaths.is_empty() {
return None;
}
let (fill, outline) = self.attributes(field(body, 1).unwrap_or_default());
Some(Shape::new(Geometry::Path(path), Matrix::IDENTITY, fill, outline))
}
/// Rendering attributes (R63): a mask (1 fill, 2 outline, 4 lens), then a field list for the
/// fill and one for the outline when the mask names them.
fn attributes(&mut self, a: &[u8]) -> (Option<Color>, Option<Outline>) {
let Some(&mask) = a.first() else { return (None, None) };
let mut pos = 1;
let mut fill = None;
if mask & 1 != 0 {
let end = list_end(a, pos);
let list = a.get(pos..end).unwrap_or_default();
pos = end;
// Field 1: the fill type (u16), then its own field list; type 1, uniform, names its
// color in field 1.
let v = field(list, 1).unwrap_or_default();
match Rd::new(v).u16() {
Some(0) | None => {}
Some(1) => {
let index = field(v.get(2..).unwrap_or_default(), 1).and_then(|c| Rd::new(c).u16());
fill = Some(match index {
Some(i) => self.tables.color(i, self.warn),
None => {
push(self.warn, Warning::Damaged);
Color::Rgb([0.0; 3])
}
});
}
Some(_) => push(self.warn, Warning::UnsupportedFills),
}
}
let mut outline = None;
if mask & 2 != 0 {
let list = a.get(pos..list_end(a, pos)).unwrap_or_default();
match field(list, 1).and_then(|f| Rd::new(f).u16()) {
Some(i) => outline = self.tables.outline(i, self.budget, self.warn),
None => push(self.warn, Warning::Damaged),
}
}
if mask & 4 != 0 {
push(self.warn, Warning::Lenses);
}
// A canvas (8) or a container (16) is not read.
if mask & (8 | 16) != 0 {
push(self.warn, Warning::UnsupportedObjects);
}
(fill, outline)
}
}
-455
View File
@@ -1,455 +0,0 @@
//! The coordinates argument (30) of each object type read as geometry: curves (R16), rectangles
//! (R15), ellipses and arcs (R17) and polygons (R18).
use std::f64::consts::PI;
use crate::Warning;
use crate::bytes::Rd;
use crate::layout::Profile;
use crate::limits::Budget;
use crate::model::{Geometry, Path, Pt, Segment, SubPath};
use crate::records::{angle, coord};
use crate::riff::push;
/// The most sides a polygon record may give (VectorCraft's own bound).
const MAX_POLYGON_SIDES: u32 = 1000;
/// The base curve of a polygon lies on a circle of 1000 mm (R18), in points.
const POLYGON_UNIT_RADIUS: f64 = 1000.0 / 25.4 * 72.0;
/// What a point type byte asks for (R16): bits 7 and 6.
#[derive(Clone, Copy, PartialEq, Eq)]
enum Op {
Move,
Line,
Curve,
Control,
}
fn op(t: u8) -> Op {
match t >> 6 {
0 => Op::Move,
1 => Op::Line,
2 => Op::Curve,
_ => Op::Control,
}
}
/// Bit 3 closes the subpath (R16).
const CLOSES: u8 = 0x08;
/// A point list (R16): the count, the points, then one type byte each. The count is a u32 from
/// version 6 and a u16 followed by another u16 before it (R39). It is held to what the bytes hold;
/// `None` when the points are past the budget.
pub(crate) fn point_list(b: &[u8], p: &Profile, budget: &mut Budget, warn: &mut Vec<Warning>) -> Option<Path> {
let mut r = Rd::new(b);
let count = if p.short {
let count = usize::from(r.u16()?);
r.skip(2)?;
count
} else {
r.u32()? as usize
};
points(b, r, count, p, budget, warn)
}
/// A path record (object type 0x25, R30): 4 bytes, two u16 counts whose sum is the point count, 16
/// bytes, then the points and their type bytes as in a point list.
pub(crate) fn path_record(b: &[u8], p: &Profile, budget: &mut Budget, warn: &mut Vec<Warning>) -> Option<Path> {
let mut r = Rd::new(b);
r.skip(4)?;
let count = usize::from(r.u16()?) + usize::from(r.u16()?);
r.skip(16)?;
points(b, r, count, p, budget, warn)
}
/// `count` points from `r` over `b`, then their type bytes. A list cut short is read two ways: as
/// all `count` points with the type bytes after them, and as the points and type bytes the bytes
/// hold split evenly. The reading that keeps more points with a type byte wins, the first on a tie.
fn points(b: &[u8], mut r: Rd, count: usize, p: &Profile, budget: &mut Budget, warn: &mut Vec<Warning>) -> Option<Path> {
let each = 2 * p.word();
let left = r.left();
let split = (left / (each + 1)).min(count);
let whole = count.checked_mul(each).filter(|len| *len <= left).map(|len| (left - len).min(count));
let stored = match whole {
Some(typed) if typed >= split => count,
_ => split,
};
let types = b.get(r.pos() + stored * each..)?;
let n = stored.min(types.len());
if count > n {
push(warn, Warning::Damaged);
}
if !budget.take_coordinates(n) {
push(warn, Warning::TooDeep);
return None;
}
let mut points = Vec::with_capacity(n);
for _ in 0..n {
points.push(Pt { x: coord(&mut r, p)?, y: coord(&mut r, p)? });
}
Some(path_of(&points, types))
}
/// The subpaths that points and their type bytes draw.
pub(crate) fn path_of(points: &[Pt], types: &[u8]) -> Path {
let mut subpaths = Vec::new();
let mut cur: Option<SubPath> = None;
// The last two control points: a curve end uses only those.
let mut controls: Vec<Pt> = Vec::with_capacity(2);
for (&pt, &t) in points.iter().zip(types) {
let o = op(t);
if o == Op::Control {
if controls.len() == 2 {
controls.remove(0);
}
controls.push(pt);
continue;
}
if o == Op::Move || cur.is_none() {
subpaths.extend(cur.take());
cur = Some(SubPath { start: pt, segments: Vec::new(), closed: t & CLOSES != 0 && o == Op::Move });
controls.clear();
if o == Op::Move {
continue;
}
}
let Some(sp) = cur.as_mut() else { continue };
let seg = match (o, controls.as_slice()) {
(Op::Curve, [c1, c2]) => Segment::Cubic(*c1, *c2, pt),
_ => Segment::Line(pt),
};
controls.clear();
sp.segments.push(seg);
if t & CLOSES != 0 {
sp.closed = true;
}
}
subpaths.extend(cur);
// A closed subpath with no segments, or an open one with none, draws nothing.
subpaths.retain(|s| !s.segments.is_empty());
Path { subpaths }
}
/// A rectangle record (R15): width, height, then one corner radius for every corner, four from
/// version 9.
pub(crate) fn rect(b: &[u8], p: &Profile) -> Option<Geometry> {
if p.f64_rect {
return rect_f64(b, p);
}
let mut r = Rd::new(b);
let (w, h) = (coord(&mut r, p)?, coord(&mut r, p)?);
let first = coord(&mut r, p)?.abs();
let mut radii = [first; 4];
if p.four_radii {
for slot in radii.iter_mut().skip(1) {
*slot = coord(&mut r, p)?.abs();
}
}
Some(Geometry::Rect { w, h, radii })
}
/// A rectangle record from version 15 (R29): width and height as f64 coordinate units, two scale
/// factors that repeat the transform's (not applied), the scale-with flag and 7 bytes, then the
/// four radii as f64 16 bytes apart. With the flag clear each radius is a share of half the shorter
/// side; with it set the radius is in inches. A corner is held to half the shorter side, and
/// sizes to the range of the 32-bit coordinates of earlier versions.
fn rect_f64(b: &[u8], p: &Profile) -> Option<Geometry> {
let mut r = Rd::new(b);
let size = |v: f64| (v.abs() <= f64::from(i32::MAX)).then(|| v * p.unit());
let (w, h) = (size(r.f64()?)?, size(r.f64()?)?);
r.skip(8 + 8)?;
let inches = r.u8()? != 0;
r.skip(7)?;
let short = w.abs().min(h.abs());
let mut radii = [0.0; 4];
for (k, slot) in radii.iter_mut().enumerate() {
if k > 0 {
r.skip(16)?;
}
let v = r.f64()?.abs();
let radius = if inches { v * 72.0 } else { v * short / 2.0 };
*slot = radius.min(short / 2.0);
}
Some(Geometry::Rect { w, h, radii })
}
/// An ellipse record (R17): the box's width and height, the start and end angles and whether
/// the arc closes through the centre. Equal angles make a whole ellipse.
pub(crate) fn ellipse(b: &[u8], p: &Profile) -> Option<Geometry> {
let mut r = Rd::new(b);
let (w, h) = (coord(&mut r, p)?, coord(&mut r, p)?);
let (a1, a2) = (angle(&mut r, p)?, angle(&mut r, p)?);
let pie = if p.short { r.u16()? != 0 } else { r.u32()? != 0 };
let sweep = (a2 - a1).rem_euclid(360.0);
if sweep.abs() < 1e-9 {
return Some(Geometry::Ellipse { w, h });
}
Some(Geometry::Path(arc(w, h, a1, sweep, pie)))
}
/// The arc of the ellipse in the box from the origin to (`w`, `h`), from `start` degrees through
/// `sweep` degrees, in the ellipse's own axes; a pie runs from the centre and closes there. The
/// radii are half the size, and a negative width or height points its axis the other way (R17), so
/// with a negative height 0 to 180 degrees is the half below the centre.
fn arc(w: f64, h: f64, start: f64, sweep: f64, pie: bool) -> Path {
let (cx, cy, rx, ry) = (w / 2.0, h / 2.0, w / 2.0, h / 2.0);
let at = |t: f64| Pt { x: cx + rx * t.cos(), y: cy + ry * t.sin() };
let tangent = |t: f64| Pt { x: -rx * t.sin(), y: ry * t.cos() };
let pieces = (sweep / 90.0).ceil().max(1.0) as usize;
let step = sweep.to_radians() / pieces as f64;
let k = 4.0 / 3.0 * (step / 4.0).tan();
let t0 = start.to_radians();
let mut segments = Vec::with_capacity(pieces + 2);
if pie {
segments.push(Segment::Line(at(t0)));
}
for i in 0..pieces {
let (a, b) = (t0 + step * i as f64, t0 + step * (i + 1) as f64);
let (p0, p1, d0, d1) = (at(a), at(b), tangent(a), tangent(b));
segments.push(Segment::Cubic(Pt { x: p0.x + k * d0.x, y: p0.y + k * d0.y }, Pt { x: p1.x - k * d1.x, y: p1.y - k * d1.y }, p1));
}
let start = if pie { Pt { x: cx, y: cy } } else { at(t0) };
Path { subpaths: vec![SubPath { start, segments, closed: pie }] }
}
/// A polygon (R18): its base curve, one side of the outline on a circle of 1000 mm with its top
/// vertex first, copied once per side and turned clockwise each time by the vertices the side
/// spans, then scaled by (`rx`, `ry`) and moved to the centre the polygon argument (11000) gives.
/// A star whose sides skip vertices draws as one outline, or as several when the side count and
/// the step share a factor.
pub(crate) fn polygon(base: &Path, b: &[u8], p: &Profile, budget: &mut Budget, warn: &mut Vec<Warning>) -> Option<Geometry> {
let mut r = Rd::new(b);
if !p.tagged {
r.skip(4)?;
}
let sides = r.u32()?;
// The next point: the first field, or the second when the first is 0 or 1.
let (first, second) = (r.u32()?, r.u32()?);
let next = if first > 1 { first } else { second };
if p.tagged {
r.skip(4)?;
}
let (rx, ry) = (r.f64()?, r.f64()?);
let (cx, cy) = (coord(&mut r, p)?, coord(&mut r, p)?);
let side = base.subpaths.first()?;
if !(1..=MAX_POLYGON_SIDES).contains(&sides) {
push(warn, Warning::Damaged);
return None;
}
if !budget.take_coordinates(side.segments.len().saturating_mul(3).saturating_mul(sides as usize)) {
push(warn, Warning::TooDeep);
return None;
}
// The base curve's own unit radius, measured from its first point, keeps the scale right
// whatever unit the file's coordinates are in.
let unit = side.start.x.hypot(side.start.y);
let unit = if unit > 0.0 { unit } else { POLYGON_UNIT_RADIUS };
let place = |q: Pt, turn: f64| {
let (s, c) = turn.sin_cos();
let (x, y) = (q.x * c - q.y * s, q.x * s + q.y * c);
Pt { x: x / unit * POLYGON_UNIT_RADIUS * rx + cx, y: y / unit * POLYGON_UNIT_RADIUS * ry + cy }
};
let step = side_step(side, sides, next);
let outlines = gcd(sides, step);
let each = sides / outlines;
let angle = |k: u32| -2.0 * PI * f64::from(k % sides) / f64::from(sides);
let mut subpaths = Vec::with_capacity(outlines as usize);
for o in 0..outlines {
let mut segments = Vec::with_capacity(side.segments.len() * each as usize);
for j in 0..each {
let turn = angle(o + j * step);
segments.extend(side.segments.iter().map(|s| match *s {
Segment::Line(a) => Segment::Line(place(a, turn)),
Segment::Cubic(a, b, c) => Segment::Cubic(place(a, turn), place(b, turn), place(c, turn)),
}));
}
subpaths.push(SubPath { start: place(side.start, angle(o)), segments, closed: true });
}
Some(Geometry::Path(Path { subpaths }))
}
/// How many vertices the base side moves on from its first point (R18): the vertex its last
/// point lies at, clockwise; else the next-point field when it names one; else 1.
fn side_step(side: &SubPath, sides: u32, next: u32) -> u32 {
let field = if (1..sides).contains(&next) { next } else { 1 };
let Some(end) = side.segments.last().map(|s| match *s {
Segment::Line(e) | Segment::Cubic(_, _, e) => e,
}) else {
return field;
};
let (r0, r1) = (side.start.x.hypot(side.start.y), end.x.hypot(end.y));
if !(r0 > 0.0 && (r1 - r0).abs() <= r0 * 1e-3) {
return field;
}
let turned = (side.start.y.atan2(side.start.x) - end.y.atan2(end.x)) / (2.0 * PI / f64::from(sides));
let k = turned.round();
if !k.is_finite() || (turned - k).abs() > 1e-3 {
return field;
}
match k.rem_euclid(f64::from(sides)) as u32 {
0 => field,
k => k,
}
}
fn gcd(a: u32, b: u32) -> u32 {
let (mut a, mut b) = (a, b);
while b != 0 {
(a, b) = (b, a % b);
}
a.max(1)
}
#[cfg(test)]
mod tests {
use super::*;
fn pt(x: f64, y: f64) -> Pt {
Pt { x, y }
}
#[test]
fn type_bytes_make_moves_lines_curves_and_closes() {
let points = [pt(0.0, 0.0), pt(10.0, 0.0), pt(10.0, 5.0), pt(5.0, 10.0), pt(0.0, 10.0), pt(20.0, 20.0), pt(30.0, 20.0)];
// move (closed), line, control, control, curve end closing; move, line.
let types = [0x08, 0x40, 0xC0, 0xC0, 0x88, 0x00, 0x40];
let path = path_of(&points, &types);
assert_eq!(path.subpaths.len(), 2);
let first = &path.subpaths[0];
assert!(first.closed);
assert_eq!(first.segments, vec![Segment::Line(pt(10.0, 0.0)), Segment::Cubic(pt(10.0, 5.0), pt(5.0, 10.0), pt(0.0, 10.0))]);
assert!(!path.subpaths[1].closed);
}
#[test]
fn a_point_list_short_of_type_bytes_reads_them_after_all_its_points() {
let p = crate::layout::for_version(1300).unwrap_or_else(|| panic!("profile"));
// Three points, (0, 0), (1 inch, 0) and (0, 0), and type bytes for the first two only.
let mut b = 3u32.to_le_bytes().to_vec();
for v in [0i32, 0, 254_000, 0, 0, 0] {
b.extend(v.to_le_bytes());
}
b.extend([0x00, 0x40]);
let mut warn = vec![];
let path = point_list(&b, &p, &mut Budget::new(crate::Limits::default()), &mut warn).unwrap_or_else(|| panic!("path"));
assert_eq!(path.subpaths.len(), 1);
assert_eq!(path.subpaths[0].segments, vec![Segment::Line(pt(72.0, 0.0))]);
assert_eq!(warn, vec![Warning::Damaged]);
// A count past the points the bytes hold keeps the points that have a type byte.
// Eight points and their eight type bytes take the bytes of nine points.
let mut b = 9u32.to_le_bytes().to_vec();
for i in 0..8 {
b.extend((i * 254_000i32).to_le_bytes());
b.extend(0i32.to_le_bytes());
}
b.extend([0x00, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]);
let mut warn = vec![];
let path = point_list(&b, &p, &mut Budget::new(crate::Limits::default()), &mut warn).unwrap_or_else(|| panic!("path"));
assert_eq!(path.subpaths[0].segments.len(), 7);
assert!(matches!(path.subpaths[0].segments[6], Segment::Line(end) if (end.x - 504.0).abs() < 1e-9 && end.y == 0.0));
assert_eq!(warn, vec![Warning::Damaged]);
}
#[test]
fn a_run_of_control_points_keeps_the_last_two() {
let points: Vec<Pt> = (0..7).map(|i| pt(f64::from(i), 0.0)).collect();
let path = path_of(&points, &[0x00, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0x80]);
assert_eq!(path.subpaths[0].segments, vec![Segment::Cubic(pt(4.0, 0.0), pt(5.0, 0.0), pt(6.0, 0.0))]);
}
#[test]
fn a_curve_end_without_two_controls_is_a_line() {
let path = path_of(&[pt(0.0, 0.0), pt(1.0, 1.0)], &[0x00, 0x80]);
assert_eq!(path.subpaths[0].segments, vec![Segment::Line(pt(1.0, 1.0))]);
}
#[test]
fn a_quarter_arc_ends_on_the_ellipse() {
let p = arc(20.0, 10.0, 0.0, 90.0, false);
let sp = &p.subpaths[0];
assert_eq!(sp.start, pt(20.0, 5.0));
let Some(Segment::Cubic(_, _, end)) = sp.segments.last() else { panic!("no curve") };
assert!((end.x - 10.0).abs() < 1e-9 && (end.y - 10.0).abs() < 1e-9);
let pie = arc(20.0, 10.0, 0.0, 180.0, true);
assert!(pie.subpaths[0].closed && pie.subpaths[0].start == pt(10.0, 5.0));
}
#[test]
fn a_negative_height_turns_the_arc_below_the_centre() {
let p = arc(20.0, -10.0, 0.0, 180.0, false);
let sp = &p.subpaths[0];
assert_eq!(sp.start, pt(20.0, -5.0));
let Some(Segment::Cubic(_, _, mid)) = sp.segments.first() else { panic!("no curve") };
assert!((mid.x - 10.0).abs() < 1e-9 && (mid.y + 10.0).abs() < 1e-9, "{mid:?}");
}
/// A version 13 polygon argument: `sides`, the two next-point fields, then rx = ry = 1 at the
/// origin.
fn polygon_arg(sides: u32, first: u32, second: u32) -> Vec<u8> {
let mut b = Vec::new();
for v in [sides, first, second, 0] {
b.extend(v.to_le_bytes());
}
b.extend(1.0f64.to_le_bytes());
b.extend(1.0f64.to_le_bytes());
b.extend([0; 8]);
b
}
/// Vertex `k` of `sides`, counted clockwise from the top, on the base circle.
fn vertex(k: u32, sides: u32) -> Pt {
let a = PI / 2.0 - 2.0 * PI * f64::from(k) / f64::from(sides);
pt(POLYGON_UNIT_RADIUS * a.cos(), POLYGON_UNIT_RADIUS * a.sin())
}
fn ends(sp: &SubPath) -> Vec<Pt> {
sp.segments
.iter()
.map(|s| match *s {
Segment::Line(e) | Segment::Cubic(_, _, e) => e,
})
.collect()
}
fn close(a: &[Pt], b: &[Pt]) -> bool {
a.len() == b.len() && a.iter().zip(b).all(|(p, q)| (p.x - q.x).abs() < 1e-6 && (p.y - q.y).abs() < 1e-6)
}
fn star(sides: u32, step: u32, first: u32, second: u32) -> Path {
let p = crate::layout::for_version(1300).unwrap();
let base = Path { subpaths: vec![SubPath { start: vertex(0, sides), segments: vec![Segment::Line(vertex(step, sides))], closed: false }] };
let mut budget = Budget::new(crate::Limits::default());
let Some(Geometry::Path(path)) = polygon(&base, &polygon_arg(sides, first, second), &p, &mut budget, &mut vec![]) else {
panic!("no polygon")
};
path
}
#[test]
fn a_star_whose_sides_skip_a_vertex_chains_its_points() {
// {5/2}: each side runs two vertices on, so the outline visits 2, 4, 1, 3 and 0.
let path = star(5, 2, 2, 0);
assert_eq!(path.subpaths.len(), 1);
let want: Vec<Pt> = [2, 4, 1, 3, 0].iter().map(|&k| vertex(k, 5)).collect();
assert!(close(&ends(&path.subpaths[0]), &want), "{:?}", ends(&path.subpaths[0]));
// The base side alone tells the step when the field doesn't.
assert!(close(&ends(&star(5, 2, 0, 0).subpaths[0]), &want));
}
#[test]
fn a_star_sharing_a_factor_with_its_sides_draws_one_outline_for_each() {
// {6/2}: two triangles, 0-2-4 and 1-3-5.
let path = star(6, 2, 0, 2);
assert_eq!(path.subpaths.len(), 2);
assert!(close(&ends(&path.subpaths[0]), &[vertex(2, 6), vertex(4, 6), vertex(0, 6)]));
assert!(close(&[path.subpaths[1].start], &[vertex(1, 6)]));
assert!(close(&ends(&path.subpaths[1]), &[vertex(3, 6), vertex(5, 6), vertex(1, 6)]));
}
#[test]
fn a_plain_polygon_turns_one_vertex_for_each_side() {
let path = star(4, 1, 0, 1);
assert_eq!(path.subpaths.len(), 1);
assert!(close(&ends(&path.subpaths[0]), &[1, 2, 3, 0].map(|k| vertex(k, 4))));
}
}
-230
View File
@@ -1,230 +0,0 @@
//! What a version 3 object holds as arguments where later versions name records: its transforms
//! (argument 100, R33), its fill (argument 20, R34) and its outline (argument 10, R35).
use crate::bytes::Rd;
use crate::layout::Profile;
use crate::model::{Cap, Color, Join, Matrix, Outline};
use crate::records::{self, angle, coord};
use crate::riff::push;
use crate::{Limits, Warning};
/// Transform entry types (R33): a matrix, and an envelope.
const MATRIX: u16 = 0x8c;
const ENVELOPE: u16 = 0x14;
/// The bytes of one transform entry (R33).
const ENTRY: usize = 10;
/// The bytes an outline keeps for its dashes, one byte each (R35).
const DASH_AREA: usize = 10;
/// The transforms of one object or group.
#[derive(Clone, Copy, Debug, PartialEq)]
pub(crate) struct Placement {
/// The matrices composed in file order, in points.
pub(crate) matrix: Matrix,
/// An envelope bends the shape. The reader doesn't apply envelopes.
pub(crate) envelope: bool,
}
/// The transforms argument (R33): a u16, the entry count, then 10-byte entries of a type and, at
/// byte 6, where the entry's data starts in the argument. The count is held to the entries the
/// argument holds and to the arguments a record may have. Entries of other types are passed over.
pub(crate) fn transforms(b: &[u8], p: &Profile, limits: &Limits, warn: &mut Vec<Warning>) -> Option<Placement> {
let mut r = Rd::new(b);
r.skip(2)?;
let stored = usize::from(r.u16()?);
let count = stored.min(r.left() / ENTRY).min(limits.arguments);
if count < stored {
push(warn, Warning::Damaged);
}
let mut out = Placement { matrix: Matrix::IDENTITY, envelope: false };
for _ in 0..count {
let mut e = Rd::new(r.bytes(ENTRY)?);
let kind = e.u16()?;
e.skip(4)?;
let at = usize::from(e.u16()?);
match kind {
MATRIX => out.matrix = records::fixed_matrix(&mut Rd::at(b, at), p.unit())?.after(&out.matrix),
ENVELOPE => out.envelope = true,
_ => {}
}
}
Some(out)
}
/// The fill argument (R34): a type byte, 0 for none and 1 for a uniform fill with its color. Fills
/// of other types read as none with a warning. The outer `None` is an argument that can't be read.
pub(crate) fn fill(b: &[u8], p: &Profile, warn: &mut Vec<Warning>) -> Option<Option<Color>> {
let mut r = Rd::new(b);
match r.u8()? {
0 => Some(None),
1 => Some(Some(records::color(&mut r, p, warn)?)),
_ => {
push(warn, Warning::UnsupportedFills);
Some(None)
}
}
}
/// The outline argument (R35): a flags byte whose bit 0 is set when the object is outlined, the
/// width, the stretch, the nib angle, the color, 7 bytes, the dash count and 10 bytes that hold the
/// dashes, the join and the caps (u16 each), then the two arrowhead ids. An argument that ends
/// after its color gives a solid line with butt caps and miter joins. The outer `None` is an
/// argument that can't be read.
pub(crate) fn outline(b: &[u8], p: &Profile, warn: &mut Vec<Warning>) -> Option<Option<Outline>> {
let mut r = Rd::new(b);
if r.u8()? & 1 == 0 {
return Some(None);
}
let width = coord(&mut r, p)?.abs();
let _stretch = r.u16()?;
let _nib = angle(&mut r, p)?;
let color = records::color(&mut r, p, warn)?;
let mut out = Outline { width, color, cap: Cap::Butt, join: Join::Miter, dashes: Vec::new(), behind_fill: false, scale_with: false };
let Some(stored) = r.skip(7).and_then(|()| r.u8()).map(usize::from) else { return Some(Some(out)) };
let Some(area) = r.bytes(DASH_AREA) else { return Some(Some(out)) };
if stored > DASH_AREA {
push(warn, Warning::Damaged);
}
let dashes: Vec<f64> = area.iter().take(stored).map(|d| f64::from(*d)).collect();
if dashes.iter().any(|d| *d > 0.0) {
out.dashes = dashes;
}
out.join = match r.u16() {
Some(1) => Join::Round,
Some(2) => Join::Bevel,
_ => Join::Miter,
};
out.cap = match r.u16() {
Some(1) => Cap::Round,
Some(2) => Cap::Square,
_ => Cap::Butt,
};
if matches!((r.u32(), r.u32()), (Some(s), Some(e)) if s != 0 || e != 0) {
push(warn, Warning::Arrowheads);
}
Some(Some(out))
}
#[cfg(test)]
mod tests {
use super::*;
fn p3() -> Profile {
crate::layout::for_version(300).unwrap()
}
/// A transforms argument of `entries` (type, data offset), then `data` from byte 4 + 10 for
/// each entry.
fn arg(count: u16, entries: &[(u16, u16)], data: &[i32]) -> Vec<u8> {
let mut b = vec![0, 0];
b.extend(count.to_le_bytes());
for (kind, at) in entries {
b.extend(kind.to_le_bytes());
b.extend([0; 4]);
b.extend(at.to_le_bytes());
b.extend([0; 2]);
}
b.extend(data.iter().flat_map(|v| v.to_le_bytes()));
b
}
#[test]
fn matrices_compose_in_file_order_and_other_entries_are_passed_over() {
// Scale by 2, then move 1 inch right: entry types 0x8c, an unknown one and 0x8c.
let scale = [131072, 0, 0, 0, 131072, 0];
let shift = [65536, 0, 1000, 0, 65536, 0];
let b = arg(3, &[(MATRIX, 34), (0x99, 0), (MATRIX, 58)], &[scale, shift].concat());
let mut w = vec![];
let t = transforms(&b, &p3(), &Limits::default(), &mut w).unwrap();
assert_eq!((t.matrix, t.envelope), (Matrix([2.0, 0.0, 0.0, 2.0, 72.0, 0.0]), false));
assert!(w.is_empty());
let b = arg(2, &[(MATRIX, 24), (ENVELOPE, 0)], &scale);
assert!(transforms(&b, &p3(), &Limits::default(), &mut vec![]).unwrap().envelope);
}
#[test]
fn hostile_transform_arguments_do_not_read_past_their_bytes() {
let scale = [131072, 0, 0, 0, 131072, 0];
// A count of 65,535 over one entry reads that entry, with the damage warning.
let b = arg(u16::MAX, &[(MATRIX, 14)], &scale);
let mut w = vec![];
assert_eq!(transforms(&b, &p3(), &Limits::default(), &mut w).unwrap().matrix.0[0], 2.0);
assert_eq!(w, vec![Warning::Damaged]);
// A data offset past the argument, and one that leaves less than a matrix.
for at in [5000, 14 + 4] {
assert!(transforms(&arg(1, &[(MATRIX, at)], &scale), &p3(), &Limits::default(), &mut vec![]).is_none(), "{at}");
}
// More entries than a record may have arguments.
let many: Vec<(u16, u16)> = vec![(0x99, 0); 100];
let limits = Limits { arguments: 8, ..Limits::default() };
let mut w = vec![];
assert!(transforms(&arg(100, &many, &[]), &p3(), &limits, &mut w).is_some());
assert_eq!(w, vec![Warning::Damaged]);
for len in 0..4 {
assert!(transforms(&b[..len], &p3(), &Limits::default(), &mut vec![]).is_none());
}
}
/// An outline argument: flags, width in 1/1000 inch, black, `dashes`, join, caps, arrowheads.
fn outline_arg(flags: u8, count: u8, dashes: &[u8], join: u16, cap: u16, heads: [u32; 2]) -> Vec<u8> {
let mut b = vec![flags];
b.extend(28i16.to_le_bytes());
b.extend([100, 0, 0, 0]);
b.extend([1, 0, 0, 0, 100]);
b.extend([0; 7]);
b.push(count);
let mut area = dashes.to_vec();
area.resize(DASH_AREA, 0);
b.extend(area);
b.extend(join.to_le_bytes());
b.extend(cap.to_le_bytes());
b.extend(heads.iter().flat_map(|h| h.to_le_bytes()));
b
}
#[test]
fn an_outline_reads_its_width_color_dashes_join_and_caps() {
let mut w = vec![];
let o = outline(&outline_arg(1, 2, &[3, 1], 1, 2, [0, 0]), &p3(), &mut w).unwrap().unwrap();
assert!((o.width - 2.016).abs() < 1e-9, "{}", o.width);
assert_eq!((o.color, o.join, o.cap, o.dashes), (Color::Cmyk([0.0, 0.0, 0.0, 1.0]), Join::Round, Cap::Square, vec![3.0, 1.0]));
assert!(w.is_empty());
// Bit 0 clear: no outline, whatever follows.
assert_eq!(outline(&outline_arg(0, 2, &[3, 1], 1, 2, [7, 0]), &p3(), &mut w), Some(None));
assert_eq!(outline(&[0], &p3(), &mut w), Some(None));
assert!(w.is_empty());
outline(&outline_arg(1, 0, &[], 0, 0, [0, 9]), &p3(), &mut w).unwrap().unwrap();
assert_eq!(w, vec![Warning::Arrowheads]);
}
#[test]
fn a_dash_count_past_the_dash_bytes_is_held_to_them() {
let mut w = vec![];
let o = outline(&outline_arg(1, 255, &[2; 10], 0, 0, [0, 0]), &p3(), &mut w).unwrap().unwrap();
assert_eq!(o.dashes.len(), DASH_AREA);
assert_eq!(w, vec![Warning::Damaged]);
// An argument that ends inside the dashes keeps a solid line; one cut before the color is
// unreadable.
let full = outline_arg(1, 255, &[2; 10], 0, 0, [0, 0]);
assert_eq!(outline(&full[..25], &p3(), &mut vec![]).unwrap().unwrap().dashes, Vec::<f64>::new());
assert_eq!(outline(&full[..12], &p3(), &mut vec![]).unwrap().unwrap().cap, Cap::Butt);
for len in 0..12 {
assert!(outline(&full[..len], &p3(), &mut vec![]).is_none(), "{len}");
}
}
#[test]
fn fills_read_none_uniform_and_other_types() {
let mut w = vec![];
assert_eq!(fill(&[0], &p3(), &mut w), Some(None));
assert_eq!(fill(&[1, 1, 100, 0, 0, 0], &p3(), &mut w), Some(Some(Color::Cmyk([1.0, 0.0, 0.0, 0.0]))));
assert!(w.is_empty());
for kind in [2, 4, 6, 7, 10] {
let mut w = vec![];
assert_eq!(fill(&[kind, 0, 0], &p3(), &mut w), Some(None));
assert_eq!(w, vec![Warning::UnsupportedFills], "{kind}");
}
assert_eq!(fill(&[], &p3(), &mut w), None);
assert_eq!(fill(&[1, 1, 100], &p3(), &mut w), None);
}
}
-181
View File
@@ -1,181 +0,0 @@
//! Where the fields of each record lie, by version: one table, resolved once per file. Each field
//! names the `PROVENANCE.md` row it rests on.
/// The layouts of one range of versions.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) struct Profile {
/// Coordinates are i16 in 1/1000 inch, record headers, counts and angles 16-bit (R5, R6, R7).
pub(crate) short: bool,
/// Bytes before the page size in `mcfg` (R10).
pub(crate) mcfg_skip: usize,
/// Bytes before a `trfd` entry's type (R8).
pub(crate) trfd_head: usize,
/// Bytes between a matrix entry's type and its six numbers (R8).
pub(crate) matrix_skip: usize,
/// Fill and outline records start with tagged records (R11, R12).
pub(crate) tagged: bool,
/// Outline: bytes after the join, after the stretch, after the nib angle and after the color
/// (R12).
pub(crate) outl_after_join: usize,
pub(crate) outl_after_stretch: usize,
pub(crate) outl_after_angle: usize,
pub(crate) outl_after_color: usize,
/// Where the start marker id lies after the first dash (R13); `None` where no source says.
pub(crate) marker_after_dash: Option<usize>,
/// Rectangles carry four corner radii, not one (R15).
pub(crate) four_radii: bool,
/// Rectangles are f64 sizes with radii as shares of half the shorter side (R29).
pub(crate) f64_rect: bool,
/// The master page flags its guides and desktop layers the way of versions 7 to 13 (R19).
pub(crate) old_master_flags: bool,
/// Object type 0x25 is a path (R30).
pub(crate) paths: bool,
/// Names are UTF-16LE, not Windows-1252 (R9).
pub(crate) utf16_names: bool,
/// An object holds its transform, fill and outline as arguments; there are no `trfd`, `fill`
/// or `outl` records (R33, R34, R35).
pub(crate) inline_styles: bool,
/// Object types count from 0: rectangle 0, ellipse 1, curve 2, text 3, bitmap 4 (R32).
pub(crate) types_from_zero: bool,
/// How a color is laid out (R14, R36).
pub(crate) color: ColorLayout,
/// A matrix is six i32 with its factors in 16.16 fixed point, not six f64 (R37).
pub(crate) fixed_matrix: bool,
/// `mcfg` holds 2 bytes and the page's two corners, not its width and height (R38).
pub(crate) mcfg_corners: bool,
}
/// The layouts of a color.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum ColorLayout {
/// A model byte and four value bytes (R36).
Bytes5,
/// A model u16, four u16 values and 2 bytes (R36).
Words12,
/// A model u16, a palette u16, 4 bytes and four value bytes (R14).
Record12,
}
const fn profile(from: u16) -> Profile {
let short = from < 600;
Profile {
short,
inline_styles: from < 400,
types_from_zero: from < 400,
color: if from < 400 {
ColorLayout::Bytes5
} else if from < 500 {
ColorLayout::Words12
} else {
ColorLayout::Record12
},
fixed_matrix: from < 500,
mcfg_corners: from < 400,
mcfg_skip: if from >= 1300 {
12
} else if from >= 900 {
4
} else if from >= 600 && from < 700 {
28
} else {
0
},
trfd_head: if from >= 1300 { 8 } else { 0 },
matrix_skip: if short { 0 } else { 6 },
tagged: from >= 1300,
outl_after_join: if from >= 600 && from < 1300 { 2 } else { 0 },
outl_after_stretch: if short { 0 } else { 2 },
outl_after_angle: if from >= 1300 {
46
} else if !short {
52
} else {
0
},
outl_after_color: if short { 10 } else { 16 },
marker_after_dash: if from >= 1300 {
Some(20)
} else if from >= 600 {
Some(22)
} else {
None
},
four_radii: from >= 900,
f64_rect: from >= 1500,
old_master_flags: from < 1400,
paths: from >= 1000,
utf16_names: from >= 1200,
}
}
/// The newest version read: 27, as the `vrsn` chunk names it (R1, R2).
pub(crate) const NEWEST: u16 = 2799;
/// The first version of each range, with its layouts. Ranges start where a field moves.
const PROFILES: &[(u16, Profile)] = &[
(300, profile(300)),
(400, profile(400)),
(500, profile(500)),
(600, profile(600)),
(700, profile(700)),
(800, profile(800)),
(900, profile(900)),
(1000, profile(1000)),
(1100, profile(1100)),
(1200, profile(1200)),
(1300, profile(1300)),
(1400, profile(1400)),
(1500, profile(1500)),
(1600, profile(1600)),
];
/// The oldest version of a RIFF file read: 3 (R31). Versions 1 and 2 are not RIFF files (`wl.rs`).
pub(crate) const OLDEST_RIFF: u16 = 300;
/// The layouts of the RIFF file of `version` (hundreds; 801 is the 8.01 variant, 2430 is 24.3), or
/// `None` outside 3 to 27.
pub(crate) fn for_version(version: u16) -> Option<Profile> {
if !(OLDEST_RIFF..=NEWEST).contains(&version) {
return None;
}
PROFILES.iter().rev().find(|(from, _)| *from <= version).map(|(_, p)| *p)
}
impl Profile {
/// Points per coordinate unit.
pub(crate) fn unit(&self) -> f64 {
if self.short { 72.0 / 1000.0 } else { 72.0 / 254_000.0 }
}
/// Bytes of a coordinate, and of header fields and counts.
pub(crate) fn word(&self) -> usize {
if self.short { 2 } else { 4 }
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn every_version_from_3_to_27_has_one_profile() {
assert!(for_version(299).is_none() && for_version(2800).is_none());
assert!(for_version(300).is_some_and(|p| p.short && p.inline_styles && p.types_from_zero && p.mcfg_corners && p.fixed_matrix));
assert!(for_version(399).is_some_and(|p| p.color == ColorLayout::Bytes5));
assert!(for_version(400).is_some_and(|p| p.short && !p.inline_styles && !p.mcfg_corners && p.fixed_matrix));
assert!(for_version(499).is_some_and(|p| p.color == ColorLayout::Words12));
assert!(for_version(500).is_some_and(|p| !p.fixed_matrix && !p.types_from_zero && p.color == ColorLayout::Record12));
assert!(for_version(1300).is_some_and(|p| p.old_master_flags));
assert!(for_version(1400).is_some_and(|p| p.tagged && !p.f64_rect && !p.old_master_flags));
assert!(for_version(1500).is_some_and(|p| p.tagged && p.f64_rect && p.mcfg_skip == 12 && p.paths));
assert!(for_version(2430).is_some_and(|p| p.f64_rect && p.paths && p.utf16_names));
assert!(for_version(500).is_some_and(|p| p.short && p.mcfg_skip == 0 && p.marker_after_dash.is_none()));
assert!(for_version(600).is_some_and(|p| !p.short && p.mcfg_skip == 28 && p.marker_after_dash == Some(22)));
assert!(for_version(801).is_some_and(|p| p.mcfg_skip == 0 && p.marker_after_dash == Some(22)));
assert!(for_version(999).is_some_and(|p| !p.paths && p.marker_after_dash == Some(22)));
assert!(for_version(1000).is_some_and(|p| p.mcfg_skip == 4 && p.four_radii && !p.utf16_names && p.paths));
assert!(for_version(1300).is_some_and(|p| p.tagged && p.trfd_head == 8 && p.outl_after_angle == 46));
// The table is in order, so the search finds each range's own row.
assert!(PROFILES.windows(2).all(|w| w[0].0 < w[1].0));
}
}
-110
View File
@@ -1,110 +0,0 @@
//! Reader for `.cdr` drawings of versions 1 to 27 (`.cdr`, and `.cdt` templates): the `WL` files
//! of versions 1 and 2, the RIFF chunk tree of versions 3 on with its compressed lists, the ZIP
//! packages of versions 14 on with their data streams, then pages, layers, guidelines, groups,
//! curves, rectangles, ellipses, arcs and polygons with uniform fills and outlines. It also reads
//! `.cmx` exchange files with 32-bit coordinates ([`read_cmx`]): their pages, layers, groups and
//! curves with uniform fills and outlines.
//!
//! Every record layout the reader relies on is listed in `PROVENANCE.md` with its public source
//! and status; code cites the row ids (R1 ...). Reading is bounded by [`Limits`], never recurses and does not
//! panic. Nothing here writes `.cdr` or `.cmx` files.
#![forbid(unsafe_code)]
#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
use std::fmt;
mod build;
mod bytes;
mod cmx;
mod geometry;
mod inline;
mod layout;
mod limits;
pub mod model;
mod package;
mod records;
mod riff;
mod styles;
#[cfg(any(test, feature = "synth"))]
pub mod synth;
#[cfg(any(test, feature = "synth"))]
pub mod synth_cmx;
mod wl;
mod zip;
pub use limits::Limits;
pub use model::{Drawing, Warning};
/// Does `bytes` look like a `.cdr` drawing: a RIFF file, a ZIP package holding one, or a `WL` file
/// of version 1 or 2 whose header offsets fit the file?
pub fn is_cdr(bytes: &[u8]) -> bool {
riff::is_cdr_riff(bytes) || package::is_package(bytes) || wl::is_wl(bytes)
}
/// Does `bytes` start as a `.cmx` exchange file: a RIFF form (or its big-endian RIFX form) of type
/// `CMX1`?
pub fn is_cmx(bytes: &[u8]) -> bool {
cmx::is_cmx(bytes)
}
/// Why a file can't be read.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Error {
/// Not a `.cdr` drawing.
NotCdr,
/// Not a `.cmx` file.
NotCmx,
/// A drawing of a version this reader doesn't read (hundreds: 2800 is version 28).
Version(u16),
/// A container structure that doesn't parse.
Damaged(&'static str),
/// Past one of the [`Limits`].
Limit(&'static str),
/// A file this reader doesn't open: an encrypted, ZIP64 or split package, or a RIFF file that
/// names a version before 3; a big-endian `.cmx` file or one with 16-bit coordinates.
Unsupported(&'static str),
}
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Error::NotCdr => write!(f, "not a CDR drawing"),
Error::NotCmx => write!(f, "not a CMX file"),
Error::Version(v) => write!(f, "version {} drawings are not read", v / 100),
Error::Damaged(what) => write!(f, "damaged {what}"),
Error::Limit(what) => write!(f, "past the {what} limit"),
Error::Unsupported(what) => write!(f, "{what} are not read"),
}
}
}
impl std::error::Error for Error {}
/// Read a drawing within `limits`.
pub fn read(bytes: &[u8], limits: Limits) -> Result<Drawing, Error> {
if bytes.len() > limits.input {
return Err(Error::Limit("input size"));
}
let mut budget = limits::Budget::new(limits);
// Versions 1 and 2 are not RIFF files (R40).
if wl::is_wl(bytes) {
return wl::drawing(bytes, &mut budget);
}
let mut warnings = Vec::new();
// Versions 14 on save a ZIP package around the RIFF stream (R24, R25, R26).
let (stream, streams) = if zip::is_zip(bytes) { package::open(bytes, &mut budget)? } else { (std::borrow::Cow::Borrowed(bytes), None) };
let ix = riff::Index::build(&stream, streams, &mut budget, &mut warnings)?;
let mut drawing = build::drawing(&ix, &mut budget, &mut warnings)?;
ix.stream_warnings(&mut drawing.warnings);
Ok(drawing)
}
/// Read a `.cmx` exchange file within `limits`. Files in big-endian byte order and files with
/// 16-bit coordinates are refused with [`Error::Unsupported`]. Its [`Drawing::version`] is 0.
pub fn read_cmx(bytes: &[u8], limits: Limits) -> Result<Drawing, Error> {
if bytes.len() > limits.input {
return Err(Error::Limit("input size"));
}
let mut budget = limits::Budget::new(limits);
cmx::drawing(bytes, &mut budget)
}
-166
View File
@@ -1,166 +0,0 @@
//! What one read may take. The values are VectorCraft's own; wasm32 gets half the memory limits.
use crate::Error;
/// The most a read may take, checked before every allocation and descent.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Limits {
/// Bytes of input.
pub input: usize,
/// Bytes inflated from compressed lists and package members, all of one file together.
pub inflated: usize,
/// Bytes of one package member.
pub member: usize,
/// Members of a package.
pub members: usize,
/// Nested lists below the file's own. Deeper content is left out with a warning.
pub depth: usize,
/// Chunks in the index, nested ones included, and the entries and styles of the style table;
/// in a `.cmx` file, its chunks, table entries and page instructions.
pub chunks: usize,
/// Objects mapped (shapes, groups and guidelines).
pub objects: usize,
/// Points of all curves together.
pub coordinates: usize,
/// Arguments of one `loda` record.
pub arguments: usize,
/// Dashes of all outlines together, an outline's counted again for every shape that uses it.
/// Past them a shape's outline is solid, with a warning.
pub dashes: usize,
/// Chunks walked inside clipped groups, all containers together, a group's counted again for
/// every container that names it. Past them a container's group is left out, with a warning.
pub clipped_chunks: usize,
}
#[cfg(not(target_arch = "wasm32"))]
const MIB: usize = 1 << 20;
impl Default for Limits {
#[cfg(not(target_arch = "wasm32"))]
fn default() -> Self {
Limits {
input: 512 * MIB,
inflated: 1024 * MIB,
member: 512 * MIB,
members: 4096,
depth: 256,
chunks: 2_000_000,
objects: 1_000_000,
coordinates: 16_000_000,
arguments: 64,
dashes: 16_000_000,
clipped_chunks: 2_000_000,
}
}
#[cfg(target_arch = "wasm32")]
fn default() -> Self {
Limits {
input: 256 << 20,
inflated: 512 << 20,
member: 256 << 20,
members: 4096,
depth: 256,
chunks: 2_000_000,
objects: 1_000_000,
coordinates: 16_000_000,
arguments: 64,
dashes: 8_000_000,
clipped_chunks: 2_000_000,
}
}
}
/// The running counters of one read against its [`Limits`].
#[derive(Debug)]
pub(crate) struct Budget {
pub(crate) limits: Limits,
inflated: usize,
chunks: usize,
objects: usize,
coordinates: usize,
dashes: usize,
clipped_chunks: usize,
/// A request for coordinates was refused since [`Budget::coordinates_refused`] last asked.
refused: bool,
}
impl Budget {
pub(crate) fn new(limits: Limits) -> Self {
Budget { limits, inflated: 0, chunks: 0, objects: 0, coordinates: 0, dashes: 0, clipped_chunks: 0, refused: false }
}
/// Whether a request for coordinates was refused since the last call, which tells a shape
/// left out at the limit from one whose bytes don't parse.
pub(crate) fn coordinates_refused(&mut self) -> bool {
std::mem::take(&mut self.refused)
}
/// Bytes an inflate may still produce.
pub(crate) fn inflate_left(&self) -> usize {
self.limits.inflated.saturating_sub(self.inflated)
}
pub(crate) fn take_inflated(&mut self, n: usize) -> Result<(), Error> {
self.inflated = self.inflated.checked_add(n).filter(|&t| t <= self.limits.inflated).ok_or(Error::Limit("inflated size"))?;
Ok(())
}
pub(crate) fn take_chunk(&mut self) -> Result<(), Error> {
self.take_chunks(1)
}
/// `n` more chunks or style table entries.
pub(crate) fn take_chunks(&mut self, n: usize) -> Result<(), Error> {
self.chunks = self.chunks.saturating_add(n);
if self.chunks > self.limits.chunks { Err(Error::Limit("chunk count")) } else { Ok(()) }
}
/// One more object, or `false` when the drawing already holds as many as a read maps.
pub(crate) fn take_object(&mut self) -> bool {
if self.objects >= self.limits.objects {
return false;
}
self.objects += 1;
true
}
/// `n` more curve points, or `false` past the limit (nothing is taken then).
pub(crate) fn take_coordinates(&mut self, n: usize) -> bool {
match self.coordinates.checked_add(n).filter(|&t| t <= self.limits.coordinates) {
Some(t) => {
self.coordinates = t;
true
}
None => {
self.refused = true;
false
}
}
}
/// Dashes the read may still take.
pub(crate) fn dashes_left(&self) -> usize {
self.limits.dashes.saturating_sub(self.dashes)
}
/// `n` more dashes, or `false` past the limit (nothing is taken then).
pub(crate) fn take_dashes(&mut self, n: usize) -> bool {
match self.dashes.checked_add(n).filter(|&t| t <= self.limits.dashes) {
Some(t) => {
self.dashes = t;
true
}
None => false,
}
}
/// One more chunk walked inside a clipped group, or `false` past the limit.
pub(crate) fn take_clipped_chunk(&mut self) -> bool {
if self.clipped_chunks >= self.limits.clipped_chunks {
return false;
}
self.clipped_chunks += 1;
true
}
}
-255
View File
@@ -1,255 +0,0 @@
//! What a drawing reads as. Lengths are in points (1/72 inch), from the centre of the page, with y
//! pointing up, as the file stores them.
/// A point in points.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Pt {
pub x: f64,
pub y: f64,
}
/// An affine map `[a, b, c, d, e, f]`: x' = a x + c y + e, y' = b x + d y + f.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Matrix(pub [f64; 6]);
impl Matrix {
pub const IDENTITY: Matrix = Matrix([1.0, 0.0, 0.0, 1.0, 0.0, 0.0]);
/// `self` after `first`: the map that applies `first`, then `self`.
pub fn after(&self, first: &Matrix) -> Matrix {
let [a, b, c, d, e, f] = self.0;
let [p, q, r, s, t, u] = first.0;
Matrix([a * p + c * q, b * p + d * q, a * r + c * s, b * r + d * s, a * t + c * u + e, b * t + d * u + f])
}
pub fn apply(&self, p: Pt) -> Pt {
let [a, b, c, d, e, f] = self.0;
Pt { x: a * p.x + c * p.y + e, y: b * p.x + d * p.y + f }
}
}
/// One segment after the previous point.
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum Segment {
Line(Pt),
/// Two control points, then the end point.
Cubic(Pt, Pt, Pt),
}
#[derive(Clone, Debug, PartialEq)]
pub struct SubPath {
pub start: Pt,
pub segments: Vec<Segment>,
pub closed: bool,
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Path {
pub subpaths: Vec<SubPath>,
}
/// The shape of an object, in its own space ([`Shape::matrix`] places it).
#[derive(Clone, Debug, PartialEq)]
pub enum Geometry {
Path(Path),
/// A rectangle from the origin to (`w`, `h`) (either may be negative). `radii` round its
/// corners counterclockwise from the one at (`w`, 0): (`w`, 0), (`w`, `h`), (0, `h`), (0, 0).
Rect {
w: f64,
h: f64,
radii: [f64; 4],
},
/// A whole ellipse in the box from the origin to (`w`, `h`).
Ellipse {
w: f64,
h: f64,
},
}
#[derive(Clone, Debug, PartialEq)]
pub enum Color {
Rgb([f32; 3]),
Cmyk([f32; 4]),
/// Ink: 0 is white, 1 black.
Gray(f32),
/// Every ink at full strength.
Registration,
/// A color of a named library, printed on its own plate. `look` is its full-strength color
/// when the file stores one (an approximation in sRGB); `tint` is 0 to 1.
Spot {
name: String,
tint: f32,
look: Option<[f32; 3]>,
},
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Cap {
Butt,
Round,
Square,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Join {
Miter,
Round,
Bevel,
}
#[derive(Clone, Debug, PartialEq)]
pub struct Outline {
pub width: f64,
pub color: Color,
pub cap: Cap,
pub join: Join,
/// Dash and gap lengths, in outline widths; empty for a solid line.
pub dashes: Vec<f64>,
/// Drawn behind the fill, so that a filled shape shows only the outer half of it.
pub behind_fill: bool,
/// Scaled with the shape: the shape's matrix scales the width and dashes as it scales the
/// geometry.
pub scale_with: bool,
}
/// Whether a layer, group or shape is hidden or locked.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct Flags {
pub hidden: bool,
pub locked: bool,
}
/// How a shape's colors combine with the art below it.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum Blend {
#[default]
Normal,
Multiply,
Screen,
Overlay,
SoftLight,
HardLight,
ColorDodge,
ColorBurn,
Darken,
Lighten,
Difference,
Exclusion,
Hue,
Saturation,
Color,
Luminosity,
}
#[derive(Clone, Debug, PartialEq)]
pub struct Shape {
pub geometry: Geometry,
pub matrix: Matrix,
pub fill: Option<Color>,
pub outline: Option<Outline>,
/// The fill covers every area its subpaths wind around (nonzero); otherwise subpaths that
/// overlap leave holes (even-odd).
pub nonzero: bool,
/// 1 opaque, 0 clear.
pub opacity: f32,
pub blend: Blend,
pub flags: Flags,
}
impl Shape {
/// An opaque, shown shape filled even-odd.
pub fn new(geometry: Geometry, matrix: Matrix, fill: Option<Color>, outline: Option<Outline>) -> Shape {
Shape { geometry, matrix, fill, outline, nonzero: false, opacity: 1.0, blend: Blend::Normal, flags: Flags::default() }
}
}
#[derive(Clone, Debug, PartialEq)]
pub enum Object {
Shape(Box<Shape>),
Group {
objects: Vec<Object>,
flags: Flags,
},
/// A clipping container and the objects it clips: `objects` (front to back) show only
/// inside the container's shape, with its fill behind them and its outline over them.
Clip {
container: Box<Shape>,
objects: Vec<Object>,
},
}
/// A guideline through `at`, at `angle` degrees counterclockwise from horizontal.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Guideline {
pub at: Pt,
pub angle: f64,
/// The guideline, a group around it or its layer is hidden.
pub hidden: bool,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum LayerKind {
Drawing,
/// The objects left beside the pages.
Desktop,
Guides,
Grid,
}
#[derive(Clone, Debug, PartialEq)]
pub struct Layer {
pub name: String,
pub kind: LayerKind,
pub flags: Flags,
/// Front to back, as the file lists them.
pub objects: Vec<Object>,
pub guides: Vec<Guideline>,
}
#[derive(Clone, Debug, PartialEq)]
pub struct Page {
/// Width and height in points, when the page gives its own.
pub size: Option<(f64, f64)>,
/// Front to back, as the file lists them.
pub layers: Vec<Layer>,
}
/// What was left out or changed while reading. Each kind is listed once.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Warning {
/// Text, bitmaps, splines and other objects not read yet.
UnsupportedObjects,
/// Fountain, pattern, texture and PostScript fills.
UnsupportedFills,
/// Colors in models not read; shown black.
UnknownColors,
/// Library spot colors whose look the file doesn't store; shown black.
SpotLooks,
/// Outline arrowheads.
Arrowheads,
/// Envelopes, which are not applied: the shapes under them keep their outlines.
Envelopes,
/// Lenses, and object transparency that isn't read, which are not applied: the objects show
/// opaque.
Lenses,
/// Content nested deeper, or past the counts, that a read takes.
TooDeep,
/// Chunks or records that end early or don't parse.
Damaged,
}
#[derive(Clone, Debug, PartialEq)]
pub struct Drawing {
/// In hundreds, as a RIFF file stores it: 300 to 2799. A file of version 1 or 2 stores no
/// number: it gives 200 when its marker byte is the one of version 2, and 100 otherwise. A
/// `.cmx` file gives 0.
pub version: u16,
/// Page size from the document settings, in points.
pub page_size: Option<(f64, f64)>,
pub pages: Vec<Page>,
/// Layers every page shows, from the master page.
pub master: Vec<Layer>,
/// Guidelines every page shows, kept outside any layer.
pub guides: Vec<Guideline>,
pub warnings: Vec<Warning>,
}
-147
View File
@@ -1,147 +0,0 @@
//! The packages of versions 14 on (R25, R26): a ZIP archive holding the RIFF stream as
//! `content/riffData.cdr` (14 and 15), or as `content/root.dat` with its chunk bodies in the data
//! streams that `content/dataFileList.dat` names (16 on). A data stream is inflated only when a
//! chunk the reader reads, or a list it splits, points into it.
use std::borrow::Cow;
use std::cell::{Cell, OnceCell};
use crate::limits::{Budget, Limits};
use crate::riff::push;
use crate::zip::{self, Archive};
use crate::{Error, Warning};
const RIFF_DATA: &[u8] = b"content/riffData.cdr";
const ROOT: &[u8] = b"content/root.dat";
const DATA_FILE_LIST: &[u8] = b"content/dataFileList.dat";
const DATA_DIR: &[u8] = b"content/data/";
/// Is `bytes` a ZIP archive with a `.cdr` drawing's root stream?
pub(crate) fn is_package(bytes: &[u8]) -> bool {
zip::is_zip(bytes) && Archive::open(bytes, Limits::default().members).is_ok_and(|a| a.find(RIFF_DATA).or_else(|| a.find(ROOT)).is_some())
}
/// The RIFF stream of the package `bytes`, and its data streams when it has them (16 on).
pub(crate) fn open<'a>(bytes: &'a [u8], budget: &mut Budget) -> Result<(Cow<'a, [u8]>, Option<Streams<'a>>), Error> {
let zip = Archive::open(bytes, budget.limits.members)?;
if let Some(i) = zip.find(RIFF_DATA) {
return Ok((member(&zip, i, budget)?, None));
}
let root = zip.find(ROOT).ok_or(Error::NotCdr)?;
let root = member(&zip, root, budget)?;
let list = match zip.find(DATA_FILE_LIST) {
Some(i) => member(&zip, i, budget)?,
None => Cow::Borrowed(&[][..]),
};
// One name for each line; a line feed after the last name ends it.
let list = list.strip_suffix(b"\n").unwrap_or(&list);
let mut members = Vec::new();
if !list.is_empty() {
for line in list.split(|&b| b == b'\n') {
if members.len() == budget.limits.members {
return Err(Error::Limit("package member count"));
}
let name = line.strip_suffix(b"\r").unwrap_or(line);
let found = zip.find(&[DATA_DIR, name].concat());
// A data stream that is encrypted or packed some other way refuses the file, as the
// root stream does.
if let Some(i) = found {
zip.check(i)?;
}
members.push(found);
}
}
let loaded = (0..zip.count()).map(|_| OnceCell::new()).collect();
let streams = Streams { zip, members, loaded, member_limit: budget.limits.member, damaged: Cell::new(false) };
Ok((root, Some(streams)))
}
/// Member `i` within the member limit and, when deflated, what is left to inflate.
fn member<'a>(zip: &Archive<'a>, i: usize, budget: &mut Budget) -> Result<Cow<'a, [u8]>, Error> {
let m = zip.read(i, budget.limits.member, budget.inflate_left())?;
if let Cow::Owned(v) = &m {
budget.take_inflated(v.len())?;
}
Ok(m)
}
/// What reading one package member gave.
#[derive(Debug)]
enum Slot<'a> {
Read(Cow<'a, [u8]>),
Damaged,
PastLimit,
}
/// The data streams of a version 16+ package, in `dataFileList.dat` order (R26).
#[derive(Debug)]
pub(crate) struct Streams<'a> {
zip: Archive<'a>,
/// The member holding each stream; `None` when the archive lacks it.
members: Vec<Option<usize>>,
/// Each member's bytes once read, so that streams naming one member read it once.
loaded: Vec<OnceCell<Slot<'a>>>,
member_limit: usize,
/// A stream, or a chunk's bytes in one, could not be found.
damaged: Cell<bool>,
}
impl<'a> Streams<'a> {
/// The member holding stream `s`; `None` when there is no such stream.
pub(crate) fn member_of(&self, s: usize) -> Option<usize> {
*self.members.get(s)?
}
/// The size the archive gives stream `s`; `None` when there is no such stream.
pub(crate) fn size(&self, s: usize) -> Option<usize> {
Some(self.zip.size(self.member_of(s)?))
}
/// Stream `s`, its member read on first use within the member limit and, when deflated,
/// within `left` more inflated bytes (which it takes from).
pub(crate) fn get(&self, s: usize, left: &Cell<usize>) -> Option<&[u8]> {
let Some(i) = self.member_of(s) else {
self.damaged.set(true);
return None;
};
let slot = self.loaded.get(i)?.get_or_init(|| {
let read = self.zip.read(i, self.member_limit, left.get());
if !matches!(read, Err(Error::Limit(_))) {
left.set(left.get().saturating_sub(self.zip.inflate_cost(i)));
}
match read {
Ok(b) => Slot::Read(b),
Err(Error::Limit(_)) => Slot::PastLimit,
Err(_) => {
self.damaged.set(true);
Slot::Damaged
}
}
});
match slot {
Slot::Read(b) => Some(b.as_ref()),
Slot::Damaged | Slot::PastLimit => None,
}
}
/// Was stream `s` left out because it is past a limit? Chunks in it are then not damage.
pub(crate) fn past_limit(&self, s: usize) -> bool {
let slot = self.member_of(s).and_then(|i| self.loaded.get(i)).and_then(OnceCell::get);
matches!(slot, Some(Slot::PastLimit))
}
/// Mark a chunk whose stream bytes could not be found.
pub(crate) fn note_damage(&self) {
self.damaged.set(true);
}
/// The warnings for streams that were left out.
pub(crate) fn warnings(&self, warn: &mut Vec<Warning>) {
if self.damaged.get() {
push(warn, Warning::Damaged);
}
if self.loaded.iter().any(|s| matches!(s.get(), Some(Slot::PastLimit))) {
push(warn, Warning::TooDeep);
}
}
}
-655
View File
@@ -1,655 +0,0 @@
//! Hand-written decoders of the records a drawing's objects refer to: the `loda` argument table
//! (R6), transforms (R8), colors (R14), fills (R11) and outlines (R12, R13).
use crate::bytes::Rd;
use crate::layout::{ColorLayout, Profile};
use crate::model::{Blend, Cap, Color, Join, Matrix, Outline};
use crate::riff::push;
use crate::{Limits, Warning};
/// The tag of a record's current layout in tagged files (R11, R12).
const TAG_1300: u32 = 1300;
/// The most tagged records skipped before a fill's own (R11).
const MAX_SKIPPED: usize = 4;
/// The most records skipped before an outline's own (R12).
const MAX_OUTLINE_RECORDS: usize = 16;
/// The most UTF-16 units of a library color's name kept, and the most bytes or UTF-16 units of
/// a layer's.
const MAX_NAME: usize = 256;
/// A header field: u16 in short files, u32 otherwise.
fn word(r: &mut Rd, p: &Profile) -> Option<usize> {
if p.short { r.u16().map(usize::from) } else { r.u32().map(|v| v as usize) }
}
/// A coordinate in points.
pub(crate) fn coord(r: &mut Rd, p: &Profile) -> Option<f64> {
let raw = if p.short { f64::from(r.i16()?) } else { f64::from(r.i32()?) };
Some(raw * p.unit())
}
/// An angle in degrees: tenths in short files, millionths otherwise (R7).
pub(crate) fn angle(r: &mut Rd, p: &Profile) -> Option<f64> {
if p.short { Some(f64::from(r.i16()?) / 10.0) } else { Some(f64::from(r.i32()?) / 1_000_000.0) }
}
/// A `loda` record (R6): its object type and arguments as (type, bytes).
pub(crate) struct Loda<'a> {
pub(crate) kind: u32,
pub(crate) args: Vec<(u32, &'a [u8])>,
}
impl<'a> Loda<'a> {
pub(crate) fn arg(&self, kind: u32) -> Option<&'a [u8]> {
self.args.iter().find(|(k, _)| *k == kind).map(|(_, b)| *b)
}
}
pub(crate) fn loda<'a>(b: &'a [u8], p: &Profile, limits: &Limits, warn: &mut Vec<Warning>) -> Option<Loda<'a>> {
let mut r = Rd::new(b);
let (_len, count, offsets_at, types_at, kind) = (word(&mut r, p)?, word(&mut r, p)?, word(&mut r, p)?, word(&mut r, p)?, word(&mut r, p)?);
// The types table is indexed from the stored count, however many arguments are read.
let stored = count;
let count = if count > limits.arguments {
push(warn, Warning::Damaged);
limits.arguments
} else {
count
};
let mut offsets = Vec::with_capacity(count + 1);
let mut ro = Rd::at(b, offsets_at);
for _ in 0..=count {
offsets.push(word(&mut ro, p)?);
}
let mut args = Vec::with_capacity(count);
for i in 0..count {
// The types table runs the other way: offset i pairs with type stored - 1 - i.
let kind = word(&mut Rd::at(b, types_at.checked_add((stored - 1 - i).checked_mul(p.word())?)?), p)? as u32;
let (start, end) = (*offsets.get(i)?, *offsets.get(i + 1)?);
match b.get(start..end) {
Some(body) => args.push((kind, body)),
None => push(warn, Warning::Damaged),
}
}
Some(Loda { kind: kind as u32, args })
}
/// The matrices of a `trfd` record composed in file order, in points (R8). Each entry ends where
/// the next offset points, and the last at the offset after it (R51); an entry too short for its
/// matrix makes the record unreadable.
pub(crate) fn trfd(b: &[u8], p: &Profile) -> Option<Matrix> {
let mut r = Rd::new(b);
let (_len, count, offsets_at) = (word(&mut r, p)?, word(&mut r, p)?, word(&mut r, p)?);
let mut m = Matrix::IDENTITY;
let k = p.unit();
// Each entry takes at least its offset's bytes, which bounds the count by the record's size.
for i in 0..count.min(b.len() / p.word()) {
let slot = offsets_at.checked_add(i.checked_mul(p.word())?)?;
let start = word(&mut Rd::at(b, slot), p)?;
// A table that stops before the last entry's end offset leaves that entry the rest of the
// record.
let end = word(&mut Rd::at(b, slot.checked_add(p.word())?), p).unwrap_or(b.len());
let mut e = Rd::at(b.get(start..end)?, p.trfd_head);
if e.u16()? != 8 {
continue;
}
e.skip(p.matrix_skip)?;
let next = if p.fixed_matrix {
fixed_matrix(&mut e, k)?
} else {
let (a, c, tx, bb, d, ty) = (e.f64()?, e.f64()?, e.f64()?, e.f64()?, e.f64()?, e.f64()?);
Matrix([a, bb, c, d, tx * k, ty * k])
};
m = next.after(&m);
}
Some(m)
}
/// A number in 16.16 fixed point.
pub(crate) fn fixed(r: &mut Rd) -> Option<f64> {
Some(f64::from(r.i32()?) / 65536.0)
}
/// A matrix of versions 3 and 4 (R37): six i32 `a c tx b d ty`, the factors in 16.16 fixed point
/// and `tx` and `ty` in coordinate units of `k` points.
pub(crate) fn fixed_matrix(r: &mut Rd, k: f64) -> Option<Matrix> {
let (a, c, tx) = (fixed(r)?, fixed(r)?, f64::from(r.i32()?));
let (b, d, ty) = (fixed(r)?, fixed(r)?, f64::from(r.i32()?));
Some(Matrix([a, b, c, d, tx * k, ty * k]))
}
/// A color in the layout of the file's version (R14, R36). Unknown models read as black with a
/// warning.
pub(crate) fn color(r: &mut Rd, p: &Profile, warn: &mut Vec<Warning>) -> Option<Color> {
match p.color {
ColorLayout::Record12 => {
let model = r.u16()?;
let palette = r.u16()?;
r.skip(4)?;
let v: [u8; 4] = r.bytes(4)?.try_into().ok()?;
Some(model_color(model, palette, v, warn))
}
ColorLayout::Words12 => {
let model = r.u16()?;
let w = [r.u16()?, r.u16()?, r.u16()?, r.u16()?];
r.skip(2)?;
// The models take 8-bit values, as in the other layouts; a larger value reads as 255.
Some(early_color(model, w.map(|x| u8::try_from(x).unwrap_or(u8::MAX)), w[0], w[1], warn))
}
ColorLayout::Bytes5 => Some(color5(r.bytes(5)?.try_into().ok()?, warn)),
}
}
/// A 5-byte color (R36): a model byte and four value bytes.
pub(crate) fn color5(b: [u8; 5], warn: &mut Vec<Warning>) -> Color {
let [model, v @ ..] = b;
early_color(u16::from(model), v, u16::from_le_bytes([v[0], v[1]]), u16::from_le_bytes([v[2], v[3]]), warn)
}
/// A color of versions 1 to 4 (R36). Model 1 is CMYK in percent. Model 0 is a numbered ink and
/// its tint in percent: 0 is black, 1 is white, and other numbers are inks of a library the file
/// doesn't store. Other models read as in later versions.
fn early_color(model: u16, v: [u8; 4], index: u16, tint: u16, warn: &mut Vec<Warning>) -> Color {
let pct = |x: f32| (x / 100.0).clamp(0.0, 1.0);
match (model, index) {
(1, _) => Color::Cmyk(v.map(|x| pct(f32::from(x)))),
(0, 0) => Color::Gray(pct(f32::from(tint))),
(0, 1) => Color::Gray(0.0),
(0, number) => {
push(warn, Warning::SpotLooks);
Color::Spot { name: format!("Spot 0:{number}"), tint: pct(f32::from(tint)), look: None }
}
_ => model_color(model, 0, v, warn),
}
}
/// The color of `model` with the four value bytes `v`, from version 5 (R14).
fn model_color(model: u16, palette: u16, v: [u8; 4], warn: &mut Vec<Warning>) -> Color {
let (v0, v1, v2, v3) = (f32::from(v[0]), f32::from(v[1]), f32::from(v[2]), f32::from(v[3]));
let pct = |x: f32| (x / 100.0).clamp(0.0, 1.0);
let byte = |x: f32| x / 255.0;
match model {
2 => Color::Cmyk([pct(v0), pct(v1), pct(v2), pct(v3)]),
3 | 17 => Color::Cmyk([byte(v0), byte(v1), byte(v2), byte(v3)]),
4 => Color::Cmyk([byte(v0), byte(v1), byte(v2), 0.0]),
5 | 21 => Color::Rgb([byte(v2), byte(v1), byte(v0)]),
9 => Color::Gray(1.0 - byte(v0)),
20 => Color::Registration,
1 | 14 | 25 => {
let number = u16::from_le_bytes([v[0], v[1]]);
let tint = pct(f32::from(u16::from_le_bytes([v[2], v[3]])));
push(warn, Warning::SpotLooks);
// Each library numbers its own colors: the name holds the palette and the number.
Color::Spot { name: format!("Spot {palette}:{number}"), tint, look: None }
}
_ => {
push(warn, Warning::UnknownColors);
Color::Rgb([0.0; 3])
}
}
}
/// A UTF-16 name stored as a character count and its code units. Every shape that uses the color
/// gets its own copy of the name: a name longer than [`MAX_NAME`] units keeps its first ones and a
/// hash of the whole name, with a warning, so two long names that start alike stay apart.
fn counted_utf16(r: &mut Rd, warn: &mut Vec<Warning>) -> Option<String> {
let n = r.u32()? as usize;
let b = r.bytes(n.checked_mul(2)?)?;
// Trailing NULs are padding.
let all = b.as_chunks::<2>().0;
let all = all.get(..all.iter().rposition(|c| *c != [0, 0]).map_or(0, |i| i + 1)).unwrap_or_default();
let units = all.iter().map(|c| u16::from_le_bytes(*c));
if all.len() <= MAX_NAME {
let units: Vec<u16> = units.collect();
return Some(String::from_utf16_lossy(&units));
}
push(warn, Warning::TooDeep);
// FNV-1a over the code units.
let hash = units.clone().fold(0xcbf2_9ce4_8422_2325_u64, |h, u| (h ^ u64::from(u)).wrapping_mul(0x0100_0000_01b3));
let kept: Vec<u16> = units.take(MAX_NAME).collect();
Some(format!("{} {hash:016x}", String::from_utf16_lossy(&kept)))
}
/// The color of the property list of a tagged uniform fill (R11) or outline (R12): its color
/// record, named by the library name it carries.
pub(crate) fn property_color(b: &[u8], p: &Profile, warn: &mut Vec<Warning>) -> Option<Color> {
let mut r = Rd::new(b);
let (mut found, mut name) = (None, None);
while r.left() >= 5 {
let kind = r.u8()?;
let len = r.u32()? as usize;
if kind == 0 {
break;
}
let body = r.bytes(len)?;
let mut br = Rd::new(body);
match kind {
1 => found = color(&mut br, p, warn),
8 => name = br.skip(16).and_then(|_| counted_utf16(&mut br, warn)),
3 => name = name.or_else(|| counted_utf16(&mut br, warn)),
_ => {}
}
}
match (found?, name.filter(|n| !n.is_empty())) {
// A library color with its name: the record's sRGB has the tint applied already.
(Color::Rgb(rgb), Some(name)) => {
let tint = b_tint(b).unwrap_or(1.0);
Some(Color::Spot { name, tint, look: Some(untinted(rgb, tint)) })
}
(c, _) => Some(c),
}
}
/// The tint byte of the first color property of a property list (model 21 keeps it last).
fn b_tint(b: &[u8]) -> Option<f32> {
let mut r = Rd::new(b);
while r.left() >= 5 {
let kind = r.u8()?;
let len = r.u32()? as usize;
let body = r.bytes(len)?;
if kind == 1 {
let mut c = Rd::new(body);
return (c.u16()? == 21).then(|| f32::from(*body.get(11).unwrap_or(&100)) / 100.0).map(|t| t.clamp(0.0, 1.0));
}
}
None
}
/// The full-strength color behind sRGB `rgb` shown at `tint` (a tint mixes toward white).
fn untinted(rgb: [f32; 3], tint: f32) -> [f32; 3] {
if tint <= 0.0 {
return rgb;
}
rgb.map(|v| (1.0 - (1.0 - v) / tint).clamp(0.0, 1.0))
}
/// A fill record: its id, and its color (`None`: no fill). Fills of other kinds read as none with
/// a warning (R11).
pub(crate) fn fill(b: &[u8], p: &Profile, warn: &mut Vec<Warning>) -> Option<(u32, Option<Color>)> {
let mut r = Rd::new(b);
let id = r.u32()?;
let body = if p.tagged { tagged_body(&mut r)? } else { r.bytes(r.left())? };
let mut r = Rd::new(body);
let kind = r.u16()?;
let color = match kind {
0 => None,
1 if p.tagged => {
if r.u32()? != TAG_1300 {
push(warn, Warning::Damaged);
return Some((id, None));
}
// A uniform fill whose color can't be read is damage, not a fill of none.
let len = r.u32()? as usize;
Some(property_color(r.bytes(len.min(r.left()))?, p, warn)?)
}
1 => {
r.skip(2)?;
Some(color(&mut r, p, warn)?)
}
_ => {
push(warn, Warning::UnsupportedFills);
None
}
};
Some((id, color))
}
/// The body of the record tagged 1300 that follows tagged records of later layouts (R11).
fn tagged_body<'a>(r: &mut Rd<'a>) -> Option<&'a [u8]> {
for _ in 0..=MAX_SKIPPED {
let (tag, len) = (r.u32()?, r.u32()? as usize);
let body = r.bytes(len.min(r.left()))?;
if tag == TAG_1300 {
return Some(body);
}
}
None
}
/// An outline record: its id and the outline (`None`: no outline) (R12, R13).
pub(crate) fn outline(b: &[u8], p: &Profile, warn: &mut Vec<Warning>) -> Option<(u32, Option<Outline>)> {
let mut r = Rd::new(b);
let id = r.u32()?;
// A library color named in a record of type 2, with the warnings its read gave.
let mut named = None;
if p.tagged {
let mut found = false;
for _ in 0..MAX_OUTLINE_RECORDS {
let (rec, len) = (r.u32()?, r.u32()? as usize);
if rec == 1 {
found = true;
break;
}
let body = r.bytes(len)?;
// Type 2 holds the outline's color as a property list, as a uniform fill does (R12).
// Only a library color with its name is taken from it; any other color comes from
// the fixed field below.
if rec == 2 {
let mut w = Vec::new();
if let Some(c @ Color::Spot { look: Some(_), .. }) = property_color(body, p, &mut w) {
named = Some((c, w));
}
}
}
if !found {
return None;
}
}
let (line_type, cap, join) = (r.u16()?, r.u16()?, r.u16()?);
r.skip(p.outl_after_join)?;
let width = coord(&mut r, p)?.abs();
let _stretch = r.u16()?;
r.skip(p.outl_after_stretch)?;
let _nib = angle(&mut r, p)?;
r.skip(p.outl_after_angle)?;
let color = match named {
Some((named, w)) => {
color(&mut r, p, &mut Vec::new())?;
for x in w {
push(warn, x);
}
named
}
None => color(&mut r, p, warn)?,
};
r.skip(p.outl_after_color)?;
let count = usize::from(r.u16()?);
let first_dash = r.pos();
let fits = r.left() / 2;
if count > fits {
push(warn, Warning::Damaged);
}
// At most 65,535; the read's dash limit is applied where shapes use them.
let dashes: Vec<f64> = (0..count.min(fits)).filter_map(|_| r.u16().map(f64::from)).collect();
if let Some(after) = p.marker_after_dash {
let mut m = Rd::at(b, first_dash + after);
if matches!((m.u32(), m.u32()), (Some(s), Some(e)) if s != 0 || e != 0) {
push(warn, Warning::Arrowheads);
}
}
// Bit 0 of the line type: no outline (R13).
if line_type & 1 != 0 {
return Some((id, None));
}
let cap = match cap {
1 => Cap::Round,
2 => Cap::Square,
_ => Cap::Butt,
};
let join = match join {
1 => Join::Round,
2 => Join::Bevel,
_ => Join::Miter,
};
// Bit 2 of the line type marks the outline dashed; without it the dashes stored are not drawn
// (R48).
let dashes = if line_type & 4 != 0 && dashes.iter().any(|d| *d > 0.0) { dashes } else { Vec::new() };
// Bit 4 of the line type: behind the fill (R49).
let behind_fill = line_type & 0x10 != 0;
// Bit 5 of the line type: scaled with the shape (R50).
let scale_with = line_type & 0x20 != 0;
Some((id, Some(Outline { width, color, cap, join, dashes, behind_fill, scale_with })))
}
/// The opacity and blend of argument 8000 from version 13 (R47): records of a u32 version, a u32
/// length and a body. A body of version 1300 that is [`UNIFORM_LEN`] bytes long is a uniform
/// transparency: an f64 at byte 61 and the merge mode at byte 77. VectorCraft reads the f64 as the
/// transparency in percent, 0 opaque and 100 clear. `None` for any other argument, such as a lens,
/// and for a value out of range or a merge mode without a VectorCraft blend mode.
pub(crate) fn transparency(b: &[u8]) -> Option<(f32, Blend)> {
let mut r = Rd::new(b);
while r.left() >= 8 {
let (since, len) = (r.u32()?, r.u32()? as usize);
let body = r.bytes(len)?;
if since != TAG_1300 {
continue;
}
if body.len() != UNIFORM_LEN {
return None;
}
let value = Rd::at(body, 61).f64()?;
if !(0.0..=100.0).contains(&value) {
return None;
}
return Some(((1.0 - value / 100.0) as f32, blend(*body.get(77)?)?));
}
None
}
/// The length of a uniform transparency's record body (R47).
const UNIFORM_LEN: usize = 117;
/// The blend mode of a transparency's merge mode byte (R47); `None` for the modes VectorCraft has
/// no blend mode for.
fn blend(mode: u8) -> Option<Blend> {
Some(match mode {
0 => Blend::Normal,
9 => Blend::Multiply,
11 => Blend::Lighten,
12 => Blend::Darken,
14 => Blend::Color,
15 => Blend::Hue,
16 => Blend::Saturation,
17 => Blend::Luminosity,
24 => Blend::Difference,
28 => Blend::Screen,
29 => Blend::Overlay,
30 => Blend::SoftLight,
31 => Blend::HardLight,
33 => Blend::ColorDodge,
34 => Blend::ColorBurn,
36 => Blend::Exclusion,
_ => return None,
})
}
/// A name argument (R9): Windows-1252 up to a NUL before version 12, UTF-16LE from it. A name
/// longer than [`MAX_NAME`] bytes or UTF-16 units keeps its first ones (without half of a
/// surrogate pair) and a hash of the whole name, with a warning, as a library color's name does.
pub(crate) fn name(b: &[u8], p: &Profile, warn: &mut Vec<Warning>) -> String {
if p.utf16_names {
let units = b.as_chunks::<2>().0.iter().map(|c| u16::from_le_bytes(*c)).take_while(|u| *u != 0);
let (mut kept, hash) = capped(units, warn);
if hash.is_some() && kept.last().is_some_and(|u| (0xD800..0xDC00).contains(u)) {
kept.pop();
}
with_hash(String::from_utf16_lossy(&kept), hash)
} else {
let bytes = b.iter().copied().take_while(|c| *c != 0);
let (kept, hash) = capped(bytes, warn);
with_hash(kept.into_iter().map(windows_1252).collect(), hash)
}
}
/// The first [`MAX_NAME`] of `units`, and when there are more, an FNV-1a hash of them all, with a
/// warning.
fn capped<T: Copy + Into<u64>>(units: impl Iterator<Item = T> + Clone, warn: &mut Vec<Warning>) -> (Vec<T>, Option<u64>) {
if units.clone().nth(MAX_NAME).is_none() {
return (units.collect(), None);
}
push(warn, Warning::TooDeep);
let hash = units.clone().fold(0xcbf2_9ce4_8422_2325_u64, |h, u| (h ^ u.into()).wrapping_mul(0x0100_0000_01b3));
(units.take(MAX_NAME).collect(), Some(hash))
}
/// `name`, followed by `hash` in hexadecimal when there is one.
fn with_hash(name: String, hash: Option<u64>) -> String {
match hash {
Some(h) => format!("{name} {h:016x}"),
None => name,
}
}
/// The characters Windows-1252 puts at 0x80 to 0x9F (U+FFFD where it has none); the other bytes
/// are Latin-1.
const CP1252_HIGH: [char; 32] = [
'€', '\u{FFFD}', '‚', 'ƒ', '„', '…', '†', '‡', 'ˆ', '‰', 'Š', '‹', 'Œ', '\u{FFFD}', 'Ž', '\u{FFFD}', '\u{FFFD}', '‘', '’', '“', '”', '•', '–',
'—', '˜', '™', 'š', '›', 'œ', '\u{FFFD}', 'ž', 'Ÿ',
];
fn windows_1252(c: u8) -> char {
match c {
0x80..=0x9F => CP1252_HIGH.get(usize::from(c - 0x80)).copied().unwrap_or('\u{FFFD}'),
_ => char::from(c),
}
}
#[cfg(test)]
mod tests {
use super::*;
/// An outline that names an arrowhead says so with a warning, in each version whose arrowhead
/// ids have a known place: 22 bytes after the first dash in versions 6 to 12, 20 from 13.
#[test]
fn arrowheads_are_named_from_version_6() {
let pen = crate::synth::Pen { line_type: 0, width: 1.0, cap: 0, join: 0 };
let color = [2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 100];
for (version, place) in [
(500, None),
(600, Some(22)),
(700, Some(22)),
(800, Some(22)),
(900, Some(22)),
(1000, Some(22)),
(1100, Some(22)),
(1200, Some(22)),
(1300, Some(20)),
(1700, Some(20)),
] {
let p = crate::layout::for_version(version).unwrap();
let plain = crate::synth::V(version).outline(7, pen, &color, &[]);
// The record ends with 32 bytes after its dashes, and this one has none.
let first_dash = plain.len() - 32;
let mut w = vec![];
assert!(outline(&plain, &p, &mut w).is_some_and(|(id, o)| id == 7 && o.is_some()), "{version}");
assert!(w.is_empty(), "{version}: {w:?}");
let Some(place) = place else { continue };
let mut arrow = plain.clone();
arrow[first_dash + place..first_dash + place + 4].copy_from_slice(&9u32.to_le_bytes());
let mut w = vec![];
assert!(outline(&arrow, &p, &mut w).is_some(), "{version}");
assert_eq!(w, vec![Warning::Arrowheads], "{version}");
}
}
#[test]
fn single_byte_names_read_as_windows_1252() {
let p = crate::layout::for_version(1100).unwrap();
assert_eq!(name(b"Caf\xe9 \x80\x96\0junk", &p, &mut vec![]), "Café €–");
let p = crate::layout::for_version(1200).unwrap();
assert_eq!(name(&[0x41, 0, 0x42, 0, 0, 0, 0x43, 0], &p, &mut vec![]), "AB");
}
/// A layer name longer than [`MAX_NAME`] bytes or UTF-16 units keeps its first ones and a hash
/// of the whole name, with a warning, in both encodings. A cut never keeps half of a surrogate
/// pair.
#[test]
fn long_layer_names_are_cut_with_a_hash() {
for version in [1100, 1200] {
let p = crate::layout::for_version(version).unwrap();
let bytes =
|s: &str| if p.utf16_names { s.encode_utf16().flat_map(u16::to_le_bytes).collect::<Vec<u8>>() } else { s.as_bytes().to_vec() };
let mut w = vec![];
let a = name(&bytes(&"N".repeat(100_000)), &p, &mut w);
let b = name(&bytes(&format!("{}M", "N".repeat(99_999))), &p, &mut vec![]);
assert_ne!(a, b, "{version}");
assert!(a.starts_with(&"N".repeat(MAX_NAME)) && a.chars().count() == MAX_NAME + 17, "{version}: {}", a.len());
assert_eq!(w, vec![Warning::TooDeep], "{version}");
let mut w = vec![];
assert_eq!(name(&bytes(&"N".repeat(MAX_NAME)), &p, &mut w), "N".repeat(MAX_NAME), "{version}");
assert!(w.is_empty(), "{version}");
}
let p = crate::layout::for_version(1200).unwrap();
let emoji: Vec<u8> = format!("N{}", "\u{1F600}".repeat(200)).encode_utf16().flat_map(u16::to_le_bytes).collect();
let cut = name(&emoji, &p, &mut vec![]);
assert!(!cut.contains('\u{FFFD}'), "{cut}");
assert_eq!(cut.chars().filter(|c| *c == '\u{1F600}').count(), (MAX_NAME - 1) / 2);
}
#[test]
fn colors_read_in_their_models() {
let p = crate::layout::for_version(500).unwrap();
let rec = |model: u16, v: [u8; 4]| {
let mut b = model.to_le_bytes().to_vec();
b.extend([0; 6]);
b.extend(v);
let mut w = vec![];
(color(&mut Rd::new(&b), &p, &mut w), w)
};
assert_eq!(rec(2, [100, 50, 0, 10]).0, Some(Color::Cmyk([1.0, 0.5, 0.0, 0.1])));
assert_eq!(rec(5, [255, 0, 0, 0]).0, Some(Color::Rgb([0.0, 0.0, 1.0])));
assert_eq!(rec(9, [255, 0, 0, 0]).0, Some(Color::Gray(0.0)));
assert_eq!(rec(25, [7, 0, 40, 0]).0, Some(Color::Spot { name: "Spot 0:7".into(), tint: 0.4, look: None }));
// The same number in another library is another color.
let mut other = 25u16.to_le_bytes().to_vec();
other.extend(3u16.to_le_bytes());
other.extend([0; 4]);
other.extend([7, 0, 40, 0]);
assert_eq!(color(&mut Rd::new(&other), &p, &mut vec![]), Some(Color::Spot { name: "Spot 3:7".into(), tint: 0.4, look: None }));
let (c, w) = rec(6, [1, 2, 3, 4]);
assert_eq!((c, w), (Some(Color::Rgb([0.0; 3])), vec![Warning::UnknownColors]));
}
#[test]
fn colors_of_versions_3_and_4_read_models_0_and_1() {
let read = |version: u16, model: u8, v: [u16; 4]| {
let p = crate::layout::for_version(version).unwrap();
let b: Vec<u8> = if version < 400 {
std::iter::once(model).chain(v.map(|x| x as u8)).collect()
} else {
u16::from(model).to_le_bytes().into_iter().chain(v.iter().flat_map(|x| x.to_le_bytes())).chain([0, 0]).collect()
};
let mut r = Rd::new(&b);
let mut w = vec![];
let c = color(&mut r, &p, &mut w);
assert_eq!(r.left(), 0, "{version}");
(c, w)
};
for version in [300, 400] {
// Model 1 is CMYK in percent, not a library color as from version 5.
assert_eq!(read(version, 1, [0, 100, 50, 10]).0, Some(Color::Cmyk([0.0, 1.0, 0.5, 0.1])), "{version}");
assert_eq!(read(version, 2, [0, 100, 50, 10]).0, Some(Color::Cmyk([0.0, 1.0, 0.5, 0.1])), "{version}");
}
// Model 0: an ink number and a tint. Version 3 stores each as a u16 in its four bytes.
assert_eq!(read(300, 0, [0, 0, 60, 0]).0, Some(Color::Gray(0.6)));
assert_eq!(read(300, 0, [1, 0, 60, 0]).0, Some(Color::Gray(0.0)));
assert_eq!(read(300, 0, [44, 1, 60, 0]), (Some(Color::Spot { name: "Spot 0:300".into(), tint: 0.6, look: None }), vec![Warning::SpotLooks]));
assert_eq!(read(400, 0, [0, 60, 0, 0]).0, Some(Color::Gray(0.6)));
assert_eq!(read(400, 0, [1, 60, 0, 0]).0, Some(Color::Gray(0.0)));
assert_eq!(read(400, 0, [300, 60, 0, 0]), (Some(Color::Spot { name: "Spot 0:300".into(), tint: 0.6, look: None }), vec![Warning::SpotLooks]));
}
#[test]
fn a_fixed_point_matrix_reads_its_factors_and_offsets() {
let raw: Vec<u8> = [65536i32, -32768, 1000, 131072, 16384, -500].iter().flat_map(|v| v.to_le_bytes()).collect();
let m = fixed_matrix(&mut Rd::new(&raw), 0.5).unwrap();
assert_eq!(m, Matrix([1.0, 2.0, -0.5, 0.25, 500.0, -250.0]));
assert!(fixed_matrix(&mut Rd::new(&raw[..23]), 0.5).is_none());
}
#[test]
fn long_names_that_start_alike_stay_apart() {
let read = |name: &str| {
let mut b = (name.encode_utf16().count() as u32).to_le_bytes().to_vec();
b.extend(name.encode_utf16().flat_map(u16::to_le_bytes));
let mut w = vec![];
(counted_utf16(&mut Rd::new(&b), &mut w).unwrap(), w)
};
let (a, w) = read(&"N".repeat(300));
let (b, _) = read(&format!("{}M", "N".repeat(299)));
assert_ne!(a, b);
assert!(a.starts_with(&"N".repeat(MAX_NAME)) && a.chars().count() == MAX_NAME + 17, "{a}");
assert_eq!(w, vec![Warning::TooDeep]);
assert_eq!(read("Sky Blue"), ("Sky Blue".to_string(), vec![]));
// Padding doesn't count toward the length or the name.
let (padded, w) = read(&format!("{}\0\0", "N".repeat(MAX_NAME - 1)));
assert_eq!((padded, w), ("N".repeat(MAX_NAME - 1), vec![]));
}
#[test]
fn a_tint_mixes_toward_white_and_comes_off_again() {
let shown = [0.6, 0.8, 1.0];
let base = untinted(shown, 0.5);
assert!((base[0] - 0.2).abs() < 1e-6 && (base[1] - 0.6).abs() < 1e-6 && base[2] == 1.0);
}
}
-465
View File
@@ -1,465 +0,0 @@
//! The chunk index: one flat table of every chunk, a list's children contiguous, built without
//! recursion. Payloads are not copied: an entry names a range of the RIFF stream, of the bytes
//! inflated from `LIST cmpr`, or of a package's data stream (layouts R1 to R4, R27).
use std::cell::Cell;
use std::collections::BTreeMap;
use std::io::Read as _;
use crate::bytes::{Rd, u32_at};
use crate::layout;
use crate::limits::Budget;
use crate::package::Streams;
use crate::{Error, Warning};
pub(crate) const LIST: [u8; 4] = *b"LIST";
const CMPR: [u8; 4] = *b"cmpr";
const CPNG: [u8; 4] = *b"CPng";
/// What follows `CPng` before the zlib stream (R3).
const CPNG_HEAD: [u8; 4] = [1, 0, 4, 0];
/// The size of a redirect record, and the stream number of one that holds its body (R27).
const REDIRECT: usize = 16;
const INLINE: u32 = u32::MAX;
/// One chunk: 28 bytes. `start` and `len` give the payload (after a list's form type) in its
/// source: 0 is the RIFF stream followed by the inflated bytes, `s + 1` is data stream `s`.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) struct Chunk {
pub(crate) id: [u8; 4],
/// A list's form type; zeros for other chunks.
pub(crate) form: [u8; 4],
src: u32,
start: u32,
len: u32,
first: u32,
count: u32,
}
impl Chunk {
pub(crate) fn is_list(&self, form: &[u8; 4]) -> bool {
self.id == LIST && &self.form == form
}
}
/// Every chunk of a file, and the bytes they point into.
pub(crate) struct Index<'a> {
input: &'a [u8],
inflated: Vec<u8>,
chunks: Vec<Chunk>,
/// The version the form type names: hundreds, as `vrsn` stores it (0 when the `vrsn` chunk
/// decides).
pub(crate) form_version: u16,
/// A version 16+ package's data streams; chunks of 16 bytes are redirect records then.
streams: Option<Streams<'a>>,
/// Bytes that inflating may still produce.
left: Cell<usize>,
/// The bytes redirected lists have taken: (package member, start) to end.
lists: Cell<BTreeMap<(usize, usize), usize>>,
/// The bytes other redirected chunks have taken, the same way.
leaves: Cell<BTreeMap<(usize, usize), usize>>,
/// Bytes that redirects to bytes another chunk already took may still read.
shared_left: Cell<usize>,
/// The first `vrsn` chunk among the file's own chunks, once seen, and the version it names
/// (`None` when it can't be read) (R2).
vrsn: Option<Option<u16>>,
}
/// A list still to be split into its children.
struct Pending {
entry: usize,
src: u32,
/// Its children's bytes.
start: usize,
end: usize,
/// The size pool of a compressed list's stream (`start..end` in source 0).
pool: Option<(usize, usize)>,
depth: usize,
}
/// What reading one chunk header gives.
enum Read {
Chunk(Chunk),
/// A redirect record whose body can't be found: the chunk is left out, its list read on.
Lost,
/// A redirect record into a data stream past a limit: the chunk is left out without the
/// damage warning.
PastLimit,
/// A redirect record to bytes another chunk took, past the shared-bytes limit: the chunk is
/// left out with the limit warning.
SharedPastLimit,
}
/// The version the RIFF form type names (R1): `CDR5`..`CDR9`, `CDRA` (10) to `CDRH` (17) with `I`
/// unused, then `J` (18) on; `CDR ` is version 3. Some files use a lower-case `cdr`, which names
/// the same versions except that `cdr8` is the 8.01 variant. Templates of version 21 have the form
/// type `CDTQ`; for `CDT` the `vrsn` chunk names the version, so this gives 0 (R28).
pub(crate) fn form_version(form: [u8; 4]) -> Option<u16> {
let [a, b, c, v] = form;
match (&[a, b, c], v) {
(b"cdr", b'8') => Some(801),
(b"CDR" | b"cdr", b' ') => Some(300),
(b"CDR" | b"cdr", b'1'..=b'9') => Some(100 * u16::from(v - b'0')),
(b"CDR" | b"cdr", b'A'..=b'H') => Some(100 * u16::from(v - b'A' + 10)),
(b"CDR" | b"cdr", b'J'..=b'W') => Some(100 * u16::from(v - b'J' + 18)),
(b"CDT", b'A'..=b'Z') => Some(0),
_ => None,
}
}
/// Does `bytes` start like a RIFF `.cdr` drawing (not the `CDRX` exchange variant)?
pub(crate) fn is_cdr_riff(bytes: &[u8]) -> bool {
bytes.get(..4) == Some(b"RIFF") && bytes.get(8..12).and_then(|f| f.try_into().ok()).and_then(form_version).is_some()
}
impl<'a> Index<'a> {
pub(crate) fn build(input: &'a [u8], streams: Option<Streams<'a>>, budget: &mut Budget, warn: &mut Vec<Warning>) -> Result<Self, Error> {
if input.len() > budget.limits.input {
return Err(Error::Limit("input size"));
}
let mut r = Rd::new(input);
if r.fourcc() != Some(*b"RIFF") {
return Err(Error::NotCdr);
}
let declared = r.u32().ok_or(Error::NotCdr)? as usize;
let form = r.fourcc().ok_or(Error::NotCdr)?;
let version = form_version(form).ok_or(Error::NotCdr)?;
// A file cut short keeps what it holds: its last chunk is truncated with a warning. A
// length that ends inside the form type is damage too, and the chunks after it are read.
let end = match declared.checked_add(8) {
Some(e) if (12..=input.len()).contains(&e) => e,
_ => {
push(warn, Warning::Damaged);
input.len()
}
};
let left = Cell::new(budget.inflate_left());
let mut ix = Index {
input,
inflated: Vec::new(),
chunks: Vec::new(),
form_version: version,
streams,
left,
lists: Cell::default(),
leaves: Cell::default(),
shared_left: Cell::new(budget.limits.member),
vrsn: None,
};
ix.chunks.push(Chunk { id: *b"RIFF", form, src: 0, start: 12, len: 0, first: 0, count: 0 });
let mut queue = vec![Pending { entry: 0, src: 0, start: 12, end, pool: None, depth: 0 }];
while let Some(p) = queue.pop() {
ix.split(p, &mut queue, budget, warn)?;
}
Ok(ix)
}
/// The bytes `start..end` of source `src`, or `None` when the range crosses its end. A data
/// stream is read on first use.
fn span(&self, src: u32, start: usize, end: usize) -> Option<&[u8]> {
if src > 0 {
let s = self.streams.as_ref()?;
return s.get(src as usize - 1, &self.left)?.get(start..end);
}
let n = self.input.len();
if end <= n {
self.input.get(start..end)
} else if start >= n {
self.inflated.get(start - n..end - n)
} else {
None
}
}
pub(crate) fn data(&self, c: &Chunk) -> &[u8] {
let start = c.start as usize;
match self.span(c.src, start, start + c.len as usize) {
Some(b) => b,
None => {
if let Some(s) = &self.streams
&& !self.past_limit(c.src)
{
s.note_damage();
}
&[]
}
}
}
/// Was source `src` a data stream left out because it is past a limit? Its chunks are then
/// left out with that warning alone.
fn past_limit(&self, src: u32) -> bool {
src > 0 && self.streams.as_ref().is_some_and(|s| s.past_limit(src as usize - 1))
}
pub(crate) fn children(&self, c: &Chunk) -> &[Chunk] {
let first = c.first as usize;
self.chunks.get(first..first + c.count as usize).unwrap_or_default()
}
pub(crate) fn root(&self) -> Option<&Chunk> {
self.chunks.first()
}
/// The version: the `vrsn` chunk's when it names one from 3 to 27, else the form type's (R1,
/// R2). A template's form type names no version, so its `vrsn` chunk decides whatever it names
/// (R28). Letters count differently from the version 24 update on (R1), so when both name a
/// version after 27 the `vrsn` chunk's is the one refused. The `cdr8` form type alone makes a
/// file the 8.01 variant, whatever its `vrsn` chunk names (R1).
pub(crate) fn version(&self) -> u16 {
match self.vrsn.flatten() {
_ if self.form_version == 801 => 801,
Some(v) if (layout::OLDEST_RIFF..=layout::NEWEST).contains(&v) => v,
Some(v) if self.form_version == 0 => v,
Some(v) if v > layout::NEWEST && self.form_version > layout::NEWEST => v,
_ => self.form_version,
}
}
/// The warnings for data streams that were left out.
pub(crate) fn stream_warnings(&self, warn: &mut Vec<Warning>) {
if let Some(s) = &self.streams {
s.warnings(warn);
}
}
/// Split list `p` into its children, appended to the table together; their lists are queued.
fn split(&mut self, p: Pending, queue: &mut Vec<Pending>, budget: &mut Budget, warn: &mut Vec<Warning>) -> Result<(), Error> {
let first = self.chunks.len();
let mut at = p.start;
let mut lists = Vec::new();
while at < p.end {
let Some((read, next, cut)) = self.read_chunk(p.src, at, p.end, p.pool) else {
push(warn, Warning::Damaged);
break;
};
if cut {
push(warn, Warning::Damaged);
}
at = next;
// A redirect record whose body can't be found counts as well, so that lists redirected
// to again and again can't repeat such records past the limit.
budget.take_chunk()?;
let chunk = match read {
Read::Chunk(chunk) => chunk,
Read::Lost => {
push(warn, Warning::Damaged);
continue;
}
Read::PastLimit => continue,
Read::SharedPastLimit => {
push(warn, Warning::TooDeep);
continue;
}
};
if p.entry == 0 && chunk.id == *b"vrsn" && self.vrsn.is_none() {
let at = chunk.start as usize;
self.vrsn = Some(self.span(chunk.src, at, at + chunk.len as usize).and_then(|b| Rd::new(b).u16()));
}
if chunk.id == LIST {
lists.push(self.chunks.len());
}
self.chunks.push(chunk);
}
let count = (self.chunks.len() - first) as u32;
if let Some(parent) = self.chunks.get_mut(p.entry) {
parent.first = first as u32;
parent.count = count;
}
for i in lists {
let Some(c) = self.chunks.get(i).copied() else { continue };
// From version 7 a `LIST stlt` holds the style tables, not chunks (R4); its body is read
// whole (R45). Before version 7 it holds chunks. The file's own chunks, its `vrsn`
// among them, are all read before this.
if c.form == *b"stlt" && self.version() >= 700 {
continue;
}
if p.depth + 1 > budget.limits.depth {
push(warn, Warning::TooDeep);
continue;
}
let (start, end) = (c.start as usize, c.start as usize + c.len as usize);
if c.form == CMPR && p.pool.is_none() {
match self.inflate_cmpr(c.src, start, end) {
Ok((s, e, pool)) => queue.push(Pending { entry: i, src: 0, start: s, end: e, pool: Some(pool), depth: p.depth + 1 }),
Err(Error::Limit(what)) => return Err(Error::Limit(what)),
Err(_) => push(warn, Warning::Damaged),
}
} else {
queue.push(Pending { entry: i, src: c.src, start, end, pool: p.pool, depth: p.depth + 1 });
}
}
Ok(())
}
/// The chunk at `at` (before `end`) of source `src`, and where the next one starts. In a
/// compressed stream the size field is an index into the size pool (R3); in a version 16+
/// package a chunk of 16 bytes outside one is a redirect record (R27). The flag is set for a
/// list cut short at `end`.
fn read_chunk(&self, src: u32, at: usize, end: usize, pool: Option<(usize, usize)>) -> Option<(Read, usize, bool)> {
let head = self.span(src, at, at.checked_add(8)?.min(end))?;
let id: [u8; 4] = head.get(..4)?.try_into().ok()?;
let raw = u32_at(head, 4)? as usize;
let size = match pool {
None => raw,
Some((ps, pe)) => {
let off = raw.checked_mul(4)?.checked_add(ps)?;
(off.checked_add(4)? <= pe).then_some(())?;
u32_at(self.span(0, off, off + 4)?, 0)? as usize
}
};
let body = at + 8;
// A list cut short by the end of its parent keeps the bytes it has, so the children
// before the cut are read; the caller warns that it is damaged. Other chunks are lost.
let (size, cut) = match body.checked_add(size) {
Some(e) if e <= end => (size, false),
_ if id == LIST => (end.checked_sub(body)?, true),
_ => return None,
};
let next = (body + size + (size & 1)).min(end);
if cut {
return Some((self.chunk(id, src, body, size).map_or(Read::Lost, Read::Chunk), next, true));
}
if self.streams.is_some() && pool.is_none() && size == REDIRECT {
let read = match self.redirect(id, src, body) {
Some(read) => read,
None if self.redirect_past_limit(src, body) => Read::PastLimit,
None => Read::Lost,
};
return Some((read, next, false));
}
Some((Read::Chunk(self.chunk(id, src, body, size)?), next, false))
}
/// Chunk `id` whose body is `len` bytes at `body` of source `src`; a list's body starts with
/// its form type.
fn chunk(&self, id: [u8; 4], src: u32, body: usize, len: usize) -> Option<Chunk> {
let (form, start) = if id == LIST {
let f: [u8; 4] = self.span(src, body, body.checked_add(4).filter(|_| len >= 4)?)?.try_into().ok()?;
(f, body + 4)
} else {
([0; 4], body)
};
let len = len - (start - body);
Some(Chunk { id, form, src, start: u32::try_from(start).ok()?, len: u32::try_from(len).ok()?, first: 0, count: 0 })
}
/// The chunk the redirect record at `body` of `src` stands for (R27): stream, length, offset
/// and a reserved u32. Stream `0xFFFFFFFF` holds at most 8 bytes in the record itself, after
/// the length. The body is not read again as a redirect record. `None` when the body can't
/// be found.
///
/// A redirected list whose bytes overlap those of an earlier redirected list, in any stream of
/// the same package member, is left out, so that no list is split twice. Other chunks may
/// share bytes: each one after the first to read them takes their length from the
/// shared-bytes limit (the member limit), so that many redirects to one body can't decode it
/// without end.
fn redirect(&self, id: [u8; 4], src: u32, body: usize) -> Option<Read> {
let mut r = Rd::new(self.span(src, body, body + REDIRECT)?);
let stream = r.u32()?;
let len = r.u32()? as usize;
if stream == INLINE {
return (len <= 8).then(|| self.chunk(id, src, body + 8, len).map(Read::Chunk))?;
}
let off = r.u32()? as usize;
let streams = self.streams.as_ref()?;
let size = streams.size(stream as usize)?;
let end = off.checked_add(len).filter(|&e| e <= size)?;
let member = streams.member_of(stream as usize)?;
if id == LIST {
if !claim(&self.lists, member, off, end) {
return None;
}
} else if !claim(&self.leaves, member, off, end) {
let left = self.shared_left.get();
if len > left {
return Some(Read::SharedPastLimit);
}
self.shared_left.set(left - len);
}
// Only a list's form type is read now; other bodies are read when the mapping asks.
self.chunk(id, stream.checked_add(1)?, off, len).map(Read::Chunk)
}
/// Does the redirect record at `body` of `src` point into a data stream past a limit?
fn redirect_past_limit(&self, src: u32, body: usize) -> bool {
let stream = self.span(src, body, body + 4).and_then(|b| u32_at(b, 0));
stream.is_some_and(|s| s != INLINE && self.past_limit(s.saturating_add(1)))
}
/// Inflate the two blocks of a `LIST cmpr` body at `start..end` of `src` (R3) → the chunk
/// stream and the size pool, as ranges of source 0.
fn inflate_cmpr(&mut self, src: u32, start: usize, end: usize) -> Result<(usize, usize, (usize, usize)), Error> {
let body = self.span(src, start, end).ok_or(Error::Damaged("compressed list"))?;
let mut r = Rd::new(body);
let c1 = r.u32().ok_or(Error::Damaged("compressed list"))? as usize;
r.skip(4).ok_or(Error::Damaged("compressed list"))?;
let c2 = r.u32().ok_or(Error::Damaged("compressed list"))? as usize;
let block = |at: usize, len: usize| -> Result<&[u8], Error> {
let b = body.get(at..at.checked_add(len).ok_or(Error::Damaged("compressed list"))?).ok_or(Error::Damaged("compressed list"))?;
let mut h = Rd::new(b);
if h.fourcc() != Some(CPNG) || h.fourcc() != Some(CPNG_HEAD) {
return Err(Error::Damaged("compressed block"));
}
Ok(b.get(8..).unwrap_or_default())
};
let second_at = c1.checked_add(16).ok_or(Error::Damaged("compressed list"))?;
let (first, second) = (block(16, c1)?.to_vec(), block(second_at, c2)?.to_vec());
let base = self.input.len();
let stream = self.inflate(&first)?;
let pool = self.inflate(&second)?;
Ok((base + stream.0, base + stream.1, (base + pool.0, base + pool.1)))
}
/// Inflate zlib `data` onto the end of the inflated bytes, within what is left → its range
/// there.
fn inflate(&mut self, data: &[u8]) -> Result<(usize, usize), Error> {
let at = self.inflated.len();
let left = self.left.get();
let reader = flate2::read::ZlibDecoder::new(data);
// One byte past what is left tells a stream that is too long from one that just fits.
let got = match reader.take((left as u64).saturating_add(1)).read_to_end(&mut self.inflated) {
Ok(n) => n,
Err(_) => {
// What a stream inflated before it failed counts toward the limit too, so that
// streams that fail late can't inflate past it again and again.
let produced = self.inflated.len().saturating_sub(at);
self.left.set(left.saturating_sub(produced));
self.inflated.truncate(at);
return Err(Error::Damaged("compressed block"));
}
};
if got > left {
self.inflated.truncate(at);
return Err(Error::Limit("inflated size"));
}
self.left.set(left - got);
if self.input.len().saturating_add(self.inflated.len()) > u32::MAX as usize {
return Err(Error::Limit("inflated size"));
}
Ok((at, at + got))
}
}
/// Take bytes `start..end` of package member `member` in `claimed`, or `false` when an earlier
/// redirect there took any of them. Empty ranges take nothing.
fn claim(claimed: &Cell<BTreeMap<(usize, usize), usize>>, member: usize, start: usize, end: usize) -> bool {
if start == end {
return true;
}
let mut taken = claimed.take();
let before = taken.range(..=(member, start)).next_back().is_some_and(|(&(m, _), &e)| m == member && e > start);
let after = taken.range((member, start)..).next().is_some_and(|(&(m, s), _)| m == member && s < end);
let free = !before && !after;
if free {
taken.insert((member, start), end);
}
claimed.set(taken);
free
}
/// Add `w` to the warnings once.
pub(crate) fn push(warn: &mut Vec<Warning>, w: Warning) {
if !warn.contains(&w) {
warn.push(w);
}
}
-258
View File
@@ -1,258 +0,0 @@
//! The style table in a `LIST stlt` of versions 7 to 15 (R45): the fill and outline records that a
//! style gives the objects that name it and have no fill or outline argument of their own.
use std::collections::{HashMap, HashSet};
use crate::Error;
use crate::bytes::{Rd, u32_at};
use crate::limits::Budget;
/// One style: its parent, and the fill and outline table entries it names (0: none).
#[derive(Clone, Copy)]
struct Style {
parent: u32,
fill: u32,
outline: u32,
}
/// The styles of a drawing: for each style id, the fill and outline records it gives, its
/// parents' included.
#[derive(Default)]
pub(crate) struct Styles {
fills: HashMap<u32, u32>,
outlines: HashMap<u32, u32>,
}
impl Styles {
/// The style table in body `b` of a `LIST stlt` of `version` (R45), or `None` when it doesn't
/// parse to its end. Its fill and outline entries and its styles count toward the chunks a
/// read takes.
pub(crate) fn read(b: &[u8], version: u16, budget: &mut Budget) -> Result<Option<Styles>, Error> {
let mut limit = None;
let styles = parse(b, version, &mut |n| match budget.take_chunks(n) {
Ok(()) => true,
Err(e) => {
limit = Some(e);
false
}
});
match limit {
Some(e) => Err(e),
None => Ok(styles),
}
}
/// The fill record that style `id` gives.
pub(crate) fn fill(&self, id: u32) -> Option<u32> {
self.fills.get(&id).copied()
}
/// The outline record that style `id` gives.
pub(crate) fn outline(&self, id: u32) -> Option<u32> {
self.outlines.get(&id).copied()
}
}
/// The style table in `b`. `take` is asked for each count of entries or styles before they are
/// read; a `false` stops the read.
fn parse(b: &[u8], version: u16, take: &mut dyn FnMut(usize) -> bool) -> Option<Styles> {
let mut r = Rd::new(b);
let count = r.u32()? as usize;
if count == 0 {
return (r.left() == 0).then(Styles::default);
}
// Fill entries carry 48 more bytes from version 13.
let fills = table(&mut r, if version >= 1300 { 60 } else { 12 }, take)?;
let outlines = table(&mut r, 12, take)?;
// The text style tables: fonts, alignments, spacings, two tables of fixed records, bullets,
// indents, hyphenation and drop caps, and from version 8.01 one more.
skip_table(&mut r, if version >= 1000 { 60 } else { 44 })?;
skip_table(&mut r, 12)?;
skip_table(&mut r, 52)?;
skip_table(&mut r, 152)?;
skip_table(&mut r, 784)?;
let bullets = r.u32()?;
for _ in 0..bullets {
bullet(&mut r, version)?;
}
skip_table(&mut r, 28)?;
skip_table(&mut r, if version >= 1300 { 36 } else { 32 })?;
skip_table(&mut r, 28)?;
if version >= 801 {
skip_table(&mut r, 12)?;
}
// Each style is at least 32 bytes.
if count > r.left() / 32 || !take(count) {
return None;
}
let mut styles = HashMap::new();
for _ in 0..count {
let (id, s) = style(&mut r, version)?;
styles.entry(id).or_insert(s);
}
if r.left() != 0 {
return None;
}
let mut work = 0;
Some(Styles { fills: resolve(&styles, &fills, |s| s.fill, &mut work), outlines: resolve(&styles, &outlines, |s| s.outline, &mut work) })
}
/// For each style, the record of `table` that its own entry names, or the nearest parent's where
/// its entry is 0. Each style is resolved once, and each path forgets only the styles on it, so a
/// chain of any length takes time in proportion to the styles; a chain that comes back to a style
/// on it, or reaches a style that isn't there, gives no record. `work` counts the styles visited
/// and forgotten.
fn resolve(styles: &HashMap<u32, Style>, table: &HashMap<u32, u32>, entry: impl Fn(&Style) -> u32, work: &mut usize) -> HashMap<u32, u32> {
// `None`: resolved to no record.
let mut done: HashMap<u32, Option<u32>> = HashMap::new();
let mut path = Vec::new();
let mut on_path = HashSet::new();
for &start in styles.keys() {
let mut id = start;
let found = loop {
*work += 1;
if let Some(&known) = done.get(&id) {
break known;
}
let Some(s) = styles.get(&id) else { break None };
// Back at a style on this path: a cycle.
if !on_path.insert(id) {
break None;
}
path.push(id);
match entry(s) {
0 => id = s.parent,
e => break table.get(&e).copied(),
}
};
for id in path.drain(..) {
*work += 1;
on_path.remove(&id);
done.insert(id, found);
}
}
done.into_iter().filter_map(|(id, r)| Some((id, r?))).collect()
}
/// A table of a u32 count and entries of `size` bytes, each a table id, 4 bytes and a record id.
fn table(r: &mut Rd, size: usize, take: &mut dyn FnMut(usize) -> bool) -> Option<HashMap<u32, u32>> {
let n = r.u32()? as usize;
if n > r.left() / size || !take(n) {
return None;
}
let mut out = HashMap::new();
for _ in 0..n {
let e = r.bytes(size)?;
out.entry(u32_at(e, 0)?).or_insert(u32_at(e, 8)?);
}
Some(out)
}
/// A table of a u32 count and entries of `size` bytes, passed over.
fn skip_table(r: &mut Rd, size: usize) -> Option<()> {
let n = r.u32()? as usize;
r.skip(n.checked_mul(size)?)
}
/// A bullet record, passed over: its length depends on a u32 inside it.
fn bullet(r: &mut Rd, version: u16) -> Option<()> {
r.skip(40)?;
if version >= 1300 {
if version >= 1400 {
r.skip(4)?;
}
let more = r.u32()?;
return r.skip(if more != 0 { 68 } else { 12 });
}
r.skip(if version >= 1000 { 28 } else { 20 })?;
let more = r.u32()?;
if more != 0 {
r.skip(8)?;
}
r.skip(8)
}
/// A style record: its kind (u32), id, parent, 8 bytes, a name length and the name (bytes before
/// version 12, UTF-16 units from it), the fill and outline entries, then the entries of text
/// styles (kinds 2 and 3).
fn style(r: &mut Rd, version: u16) -> Option<(u32, Style)> {
let kind = r.u32()?;
let (id, parent) = (r.u32()?, r.u32()?);
r.skip(8)?;
let len = r.u32()? as usize;
r.skip(len.checked_mul(if version >= 1200 { 2 } else { 1 })?)?;
let (fill, outline) = (r.u32()?, r.u32()?);
if kind > 1 {
r.skip(if version >= 801 { 20 } else { 16 })?;
}
if kind > 2 {
r.skip(20)?;
}
Some((id, Style { parent, fill, outline }))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::Limits;
use crate::synth::{self, V};
fn read(b: &[u8], version: u16) -> Option<Styles> {
Styles::read(b, version, &mut Budget::new(Limits::default())).unwrap()
}
#[test]
fn styles_that_name_each_other_as_parents_end() {
let looped = [synth::Style { id: 0x10, parent: 0x11, fill: 0, outline: 0 }, synth::Style { id: 0x11, parent: 0x10, fill: 0, outline: 0 }];
let s = read(&synth::stlt_body(V(700), &[(0x100, 1)], &[], &looped, false), 700).unwrap();
assert_eq!((s.fill(0x10), s.outline(0x11), s.fill(0x12)), (None, None, None));
}
#[test]
fn a_long_chain_of_parents_reaches_the_style_that_names_an_entry() {
let mut chain = vec![synth::Style { id: 1, parent: 0, fill: 0x100, outline: 0 }];
chain.extend((2..=500).map(|id| synth::Style { id, parent: id - 1, fill: 0, outline: 0 }));
let s = read(&synth::stlt_body(V(1100), &[(0x100, 7)], &[], &chain, false), 1100).unwrap();
assert_eq!((s.fill(500), s.fill(250), s.outline(500)), (Some(7), Some(7), None));
}
/// A loop of 2,000 styles, which every walk into it follows around, leaves the walks of 20,000
/// other styles no more work than the styles they visit.
#[test]
fn one_long_walk_does_not_slow_the_walks_after_it() {
let mut styles: HashMap<u32, Style> = (1..=2000).map(|id| (id, Style { parent: id % 2000 + 1, fill: 0, outline: 0 })).collect();
styles.extend((10_001..=30_000).map(|id| (id, Style { parent: 0, fill: 0x100, outline: 0 })));
let table = HashMap::from([(0x100, 7)]);
let mut work = 0;
let fills = resolve(&styles, &table, |s| s.fill, &mut work);
assert_eq!((fills.get(&1), fills.get(&10_001), fills.len()), (None, Some(&7), 20_000));
assert!(work <= 4 * styles.len(), "{work}");
}
#[test]
fn an_entry_missing_from_its_table_names_no_record() {
let styles = [synth::Style { id: 0x10, parent: 0, fill: 0x101, outline: 0x200 }];
let s = read(&synth::stlt_body(V(1300), &[(0x100, 1)], &[(0x200, 2)], &styles, false), 1300).unwrap();
assert_eq!((s.fill(0x10), s.outline(0x10)), (None, Some(2)));
}
#[test]
fn counts_past_the_body_do_not_parse() {
let mut b = synth::stlt_body(V(900), &[], &[], &[], false);
b[..4].copy_from_slice(&u32::MAX.to_le_bytes());
assert!(read(&b, 900).is_none());
let empty = 0u32.to_le_bytes();
assert!(read(&empty, 900).is_some());
assert!(read(&[], 900).is_none());
}
#[test]
fn entries_and_styles_count_toward_the_chunk_limit() {
let styles: Vec<_> = (1..=10).map(|id| synth::Style { id, parent: 0, fill: 0x100, outline: 0 }).collect();
let b = synth::stlt_body(V(1000), &[(0x100, 1)], &[], &styles, false);
let mut budget = Budget::new(Limits { chunks: 10, ..Limits::default() });
assert_eq!(Styles::read(&b, 1000, &mut budget).err(), Some(Error::Limit("chunk count")));
let mut budget = Budget::new(Limits { chunks: 11, ..Limits::default() });
assert!(Styles::read(&b, 1000, &mut budget).is_ok_and(|s| s.is_some()));
}
}
File diff suppressed because it is too large Load Diff
-287
View File
@@ -1,287 +0,0 @@
//! Synthetic `.cmx` files for tests and fuzz seeds, built from the layouts in `PROVENANCE.md` (R53
//! to R63). Not a `.cmx` writer: nothing checks that other programs open these files.
/// A chunk: its id, a u32 size, the body and a pad byte after an odd body (R53).
pub fn chunk(id: &[u8; 4], body: &[u8]) -> Vec<u8> {
let mut out = id.to_vec();
out.extend((body.len() as u32).to_le_bytes());
out.extend(body);
if body.len() % 2 == 1 {
out.push(0);
}
out
}
/// A `LIST` chunk of form `form`.
pub fn list(form: &[u8; 4], children: &[Vec<u8>]) -> Vec<u8> {
let mut body = form.to_vec();
body.extend(children.concat());
chunk(b"LIST", &body)
}
/// The RIFF form `CMX1` around `children`.
pub fn riff(children: &[Vec<u8>]) -> Vec<u8> {
let mut body = b"CMX1".to_vec();
body.extend(children.concat());
chunk(b"RIFF", &body)
}
/// The header (R54): `coord` is the coordinate size digit (`b'4'` or `b'2'`) and `meters` the size
/// of a coordinate unit. The header string and the system name, which the reader doesn't read,
/// are left as zeros.
pub fn cont(coord: u8, meters: f64) -> Vec<u8> {
let mut c = vec![0u8; 180];
c[48] = b'2';
c[52] = coord;
c[54] = b'2';
c[64..72].copy_from_slice(&meters.to_le_bytes());
chunk(b"cont", &c)
}
/// A field: its tag, a u16 length counting the 3 header bytes, then `data` (R55).
pub fn field(tag: u8, data: &[u8]) -> Vec<u8> {
let mut f = vec![tag];
f.extend(((data.len() + 3) as u16).to_le_bytes());
f.extend(data);
f
}
/// A field list: the fields, then 0xff (R55).
pub fn fields(fields: &[Vec<u8>]) -> Vec<u8> {
let mut l = fields.concat();
l.push(0xff);
l
}
/// A table chunk: a u16 count, then the entries (field lists) (R55).
pub fn table(id: &[u8; 4], entries: &[Vec<u8>]) -> Vec<u8> {
let mut d = (entries.len() as u16).to_le_bytes().to_vec();
d.extend(entries.concat());
chunk(id, &d)
}
/// A color entry in the older form: the model and palette bytes in field 1, the values in field 2
/// (R56).
pub fn color(model: u8, values: &[u8]) -> Vec<u8> {
fields(&[field(1, &[model, 5]), field(2, values)])
}
/// A color entry with a property list in field 10 whose color record (part 1) holds `model` and
/// the four value bytes `v` (R56).
pub fn color_record(model: u16, v: [u8; 4]) -> Vec<u8> {
color_record_named(model, v, None)
}
/// A color entry as [`color_record`], with a name part (part 3: a u32 count and UTF-16 units)
/// after the color when `name` is given (R56).
pub fn color_record_named(model: u16, v: [u8; 4], name: Option<&str>) -> Vec<u8> {
let mut part = vec![1u8];
part.extend(12u32.to_le_bytes());
part.extend(model.to_le_bytes());
part.extend(5u16.to_le_bytes());
part.extend([0; 4]);
part.extend(v);
if let Some(name) = name {
let units: Vec<u16> = name.encode_utf16().collect();
part.push(3);
part.extend((4 + 2 * units.len() as u32).to_le_bytes());
part.extend((units.len() as u32).to_le_bytes());
part.extend(units.iter().flat_map(|u| u.to_le_bytes()));
}
let mut rec = (part.len() as u32).to_le_bytes().to_vec();
rec.extend(part);
fields(&[field(10, &rec)])
}
/// A pen entry (R57): the width in coordinate units, an aspect of 100 and no angle, with the
/// identity matrix.
pub fn pen(width: u32) -> Vec<u8> {
let mut d = width.to_le_bytes().to_vec();
d.extend(100u16.to_le_bytes());
d.extend(0i32.to_le_bytes());
d.extend(1u16.to_le_bytes());
fields(&[field(1, &d)])
}
/// A line type entry (R57): its flags and the caps (low 4 bits) and join (high 4 bits).
pub fn line_type(flags: u8, caps_join: u8) -> Vec<u8> {
fields(&[field(1, &[flags, caps_join])])
}
/// A dash pattern entry (R57): the lengths in outline widths.
pub fn dashes(lengths: &[u16]) -> Vec<u8> {
let mut d = (lengths.len() as u16).to_le_bytes().to_vec();
d.extend(lengths.iter().flat_map(|l| l.to_le_bytes()));
fields(&[field(1, &d)])
}
/// An outline entry (R58): 1-based indexes of the line type, screen, color, arrowhead pair, pen and
/// dash pattern.
pub fn outline(parts: [u16; 6]) -> Vec<u8> {
fields(&[field(1, &parts.iter().flat_map(|p| p.to_le_bytes()).collect::<Vec<u8>>())])
}
/// The arrowhead pairs chunk (R59): a u16 count, then start and end (u16 each).
pub fn arrowheads(pairs: &[(u16, u16)]) -> Vec<u8> {
let mut d = (pairs.len() as u16).to_le_bytes().to_vec();
for (s, e) in pairs {
d.extend(s.to_le_bytes());
d.extend(e.to_le_bytes());
}
chunk(b"rota", &d)
}
/// An instruction in the short form: a u16 size counting the whole instruction, the code, the
/// body (R60).
pub fn instr(code: i16, body: &[u8]) -> Vec<u8> {
let mut i = ((body.len() + 4) as u16).to_le_bytes().to_vec();
i.extend(code.to_le_bytes());
i.extend(body);
i
}
/// An instruction in the long form: 0xFFFF, a u32 size counting the whole instruction, the code,
/// the body (R60).
pub fn long_instr(code: i16, body: &[u8]) -> Vec<u8> {
let mut i = 0xFFFFu16.to_le_bytes().to_vec();
i.extend(((body.len() + 8) as u32).to_le_bytes());
i.extend(code.to_le_bytes());
i.extend(body);
i
}
/// Begin a page (R61), with its width and height in coordinate units in field 4 when given.
pub fn begin_page(size: Option<(u32, u32)>) -> Vec<u8> {
let mut f = vec![field(1, &[1, 0, 0, 0, 0, 0])];
if let Some((w, h)) = size {
let mut d = w.to_le_bytes().to_vec();
d.extend(h.to_le_bytes());
f.push(field(4, &d));
}
instr(9, &fields(&f))
}
/// Begin a page (R61) without a size of its own, with the drawing's left, top, right and bottom
/// edges in field 1.
pub fn begin_page_in_bounds(left: i32, top: i32, right: i32, bottom: i32) -> Vec<u8> {
let mut d = vec![1, 0, 0, 0, 0, 0];
for v in [left, top, right, bottom] {
d.extend(v.to_le_bytes());
}
instr(9, &fields(&[field(1, &d)]))
}
/// Begin a layer (R62) named in 8-bit characters in field 1 from byte 12, and in UTF-16 in
/// field 4 when `wide` is given.
pub fn begin_layer(name: &str, wide: Option<&str>) -> Vec<u8> {
let mut d = vec![1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0];
d.extend((name.len() as u16).to_le_bytes());
d.extend(name.bytes());
let mut f = vec![field(1, &d)];
if let Some(w) = wide {
let units: Vec<u16> = w.encode_utf16().collect();
let mut d = (units.len() as u32).to_le_bytes().to_vec();
d.extend(units.iter().flat_map(|u| u.to_le_bytes()));
f.push(field(4, &d));
}
instr(11, &fields(&f))
}
pub fn end_layer() -> Vec<u8> {
instr(12, &[])
}
pub fn end_page() -> Vec<u8> {
instr(10, &[])
}
pub fn begin_group() -> Vec<u8> {
instr(13, &fields(&[field(1, &[0; 26])]))
}
pub fn end_group() -> Vec<u8> {
instr(14, &[])
}
/// Rendering attributes (R63): a uniform fill of color `fill` and the outline `outline` (1-based
/// indexes; `None` leaves the part out of the mask), and `lens` sets the lens bit.
pub fn attrs(fill: Option<u16>, outline: Option<u16>, lens: bool) -> Vec<u8> {
let mask = u8::from(fill.is_some()) | (u8::from(outline.is_some()) << 1) | (u8::from(lens) << 2);
let mut a = vec![mask];
if let Some(c) = fill {
let mut v = 1u16.to_le_bytes().to_vec();
let mut uniform = c.to_le_bytes().to_vec();
uniform.extend(0u16.to_le_bytes());
v.extend(fields(&[field(1, &uniform)]));
a.extend(fields(&[field(1, &v)]));
}
if let Some(o) = outline {
a.extend(fields(&[field(1, &o.to_le_bytes())]));
}
a
}
/// Rendering attributes with a fill of type `kind` and no settings of its own.
pub fn attrs_fill_type(kind: u16) -> Vec<u8> {
let mut a = vec![1u8];
a.extend(fields(&[field(1, &kind.to_le_bytes())]));
a
}
/// A curve (R62): `attrs`, then a u16 count, the points (i32 x, y) and their type bytes.
pub fn curve(attrs: &[u8], points: &[(i32, i32)], types: &[u8]) -> Vec<u8> {
let mut g = (points.len() as u16).to_le_bytes().to_vec();
for (x, y) in points {
g.extend(x.to_le_bytes());
g.extend(y.to_le_bytes());
}
g.extend(types);
instr(67, &fields(&[field(1, attrs), field(2, &g), field(3, &[0; 16])]))
}
/// A closed square of side `side` with its lower left corner at (`x`, `y`).
pub fn square(attrs: &[u8], x: i32, y: i32, side: i32) -> Vec<u8> {
curve(attrs, &[(x, y), (x + side, y), (x + side, y + side), (x, y + side), (x, y)], &[0x0c, 0x44, 0x44, 0x44, 0x48])
}
/// A `page` chunk of `instructions`.
pub fn page(instructions: &[Vec<u8>]) -> Vec<u8> {
chunk(b"page", &instructions.concat())
}
/// The tables of [`sample`]: colors red (RGB), black (CMYK in percent) and blue (a color record,
/// blue, green, red); pens of 0.5 mm and 1 mm; line types solid with round caps and joins, none,
/// and dashed behind the fill; one dash pattern; three outlines; one empty arrowhead pair.
pub fn tables() -> Vec<Vec<u8>> {
vec![
table(b"rclr", &[color(5, &[255, 0, 0]), color(2, &[0, 0, 0, 100]), color_record(5, [255, 0, 0, 0])]),
table(b"rpen", &[pen(5_000), pen(10_000)]),
table(b"rott", &[line_type(2, 0x11), line_type(1, 0), line_type(2 | 4 | 8, 0x02)]),
table(b"rdot", &[dashes(&[3, 1])]),
table(b"rotl", &[outline([1, 1, 2, 1, 1, 1]), outline([2, 1, 2, 1, 1, 1]), outline([3, 1, 3, 1, 2, 1])]),
arrowheads(&[(0, 0)]),
]
}
/// One page of 210 x 297 mm with two layers: "Art" holds a red square outlined in black, then a
/// group of a square with no outline and a blue one with the dashed outline; "Top" holds a black
/// square drawn last. Units are 0.1 µm.
pub fn sample() -> Vec<u8> {
let p = page(&[
begin_page(Some((2_100_000, 2_970_000))),
begin_layer("Art", None),
square(&attrs(Some(1), Some(1), false), -500_000, -500_000, 1_000_000),
begin_group(),
square(&attrs(Some(2), Some(2), false), 0, 0, 100_000),
square(&attrs(Some(3), Some(3), false), 200_000, 0, 100_000),
end_group(),
end_layer(),
begin_layer("Top", Some("Top")),
square(&attrs(Some(2), None, false), 0, 0, 10_000),
end_layer(),
end_page(),
]);
let mut children = vec![cont(b'4', 1e-7), p];
children.extend(tables());
riff(&children)
}
-358
View File
@@ -1,358 +0,0 @@
//! Drawings of versions 1 and 2: the file before RIFF, which starts with `WL` (R40 to R44). A
//! header of offsets, the settings with the page's box, then one flat list of records: 28 bytes
//! for a group or a layer, and a longer record for each drawn object, which holds its matrix, fill,
//! outline and shape. The reader maps the rectangles, ellipses and curves onto one page with one
//! layer and keeps no groups.
use crate::bytes::{Rd, u32_at};
use crate::geometry;
use crate::layout::{self, Profile};
use crate::limits::Budget;
use crate::model::{Cap, Drawing, Flags, Geometry, Join, Layer, LayerKind, Matrix, Object, Outline, Page, Shape};
use crate::records::{self, coord, fixed};
use crate::riff::push;
use crate::{Error, Warning};
/// The header: the signature, a marker byte, a zero and five u32 offsets (R40).
const HEADER: usize = 28;
/// The marker bytes read after `WL` (R40): `e` for version 1, `l` and `m` for version 2.
const MARKERS: [u8; 3] = *b"elm";
/// Where the page's box lies after the start of the settings (R41).
const PAGE_BOX: usize = 2;
/// The bytes of a group or layer record (R42).
const GROUP: usize = 28;
/// The u32 that starts every record (R42).
const RECORD_START: u32 = 24;
/// The flag bit, in byte 26, of a drawn object (R42).
const DRAWN: u8 = 0x40;
/// The bytes after a drawn object's body size (R42).
const AFTER_BODY: usize = 32;
/// Where a drawn object's fields lie (R43, R44).
const POINT: usize = 32;
const KIND: usize = 60;
const OUTLINED: usize = 67;
const OUTLINE_WIDTH: usize = 68;
const OUTLINE_COLOR: usize = 74;
/// Where a drawn object's fill and shape lie, which differs between the markers (R43, R44).
#[derive(Clone, Copy)]
struct Fields {
fill_kind: usize,
shape: usize,
}
impl Fields {
fn of(marker: u8) -> Self {
if marker == b'e' { Fields { fill_kind: 94, shape: 114 } } else { Fields { fill_kind: 105, shape: 136 } }
}
/// The least a drawn object takes: its fixed fields and the 4 bytes of a shape's size.
fn least(self) -> usize {
self.shape + 4
}
}
/// Object types (R43).
const RECTANGLE: u8 = 0;
const ELLIPSE: u8 = 1;
const CURVE: u8 = 2;
const TEXT: u8 = 3;
/// Where the settings start, and where the records start and end, when `b` has a `WL` header
/// whose offsets fit the file.
fn header(b: &[u8]) -> Option<(usize, usize, usize)> {
if b.get(..2)? != b"WL" || !MARKERS.contains(b.get(2)?) || *b.get(3)? != 0 {
return None;
}
let (settings, start, end) = (u32_at(b, 4)? as usize, u32_at(b, 8)? as usize, u32_at(b, 12)? as usize);
(settings >= HEADER && settings <= start && start <= end && end <= b.len()).then_some((settings, start, end))
}
/// Does `b` start like a drawing of version 1 or 2? The two letters alone are not enough: the
/// marker byte, the zero after it and the record offsets must fit too.
pub(crate) fn is_wl(b: &[u8]) -> bool {
header(b).is_some()
}
pub(crate) fn drawing(b: &[u8], budget: &mut Budget) -> Result<Drawing, Error> {
let (settings, start, end) = header(b).ok_or(Error::NotCdr)?;
let marker = b.get(2).copied().ok_or(Error::NotCdr)?;
let fields = Fields::of(marker);
// Lengths are i16 in 1/1000 inch, as in version 3 (R5).
let p = layout::for_version(layout::OLDEST_RIFF).ok_or(Error::NotCdr)?;
let mut warn = Vec::new();
let mut objects = Vec::new();
let mut at = start;
// Every step takes at least a group record's bytes, so the file's size bounds the steps.
while end - at >= GROUP {
budget.take_chunk()?;
// A record that doesn't start as records do is past one whose length isn't known.
if u32_at(b, at) != Some(RECORD_START) {
break;
}
if b.get(at + 26).is_none_or(|flags| flags & DRAWN == 0) {
at += GROUP;
continue;
}
// A drawn object of another type than rectangle, ellipse, curve and text doesn't say its
// length in the same way, so the records after it can't be found.
if b.get(at + KIND).is_none_or(|kind| *kind > TEXT) {
push(&mut warn, Warning::UnsupportedObjects);
at = end;
break;
}
let len = Rd::at(b, at + 28).u16().map_or(0, |body| usize::from(body) + AFTER_BODY);
let Some(rec) = b.get(at..at + len).filter(|_| len >= fields.least() && at + len <= end) else {
push(&mut warn, Warning::Damaged);
at = end;
break;
};
at += len;
if !budget.take_object() {
push(&mut warn, Warning::TooDeep);
at = end;
break;
}
objects.extend(object(rec, fields, &p, budget, &mut warn));
}
if at != end {
push(&mut warn, Warning::Damaged);
}
let version = if marker == b'e' { 100 } else { 200 };
let layer = Layer { name: String::new(), kind: LayerKind::Drawing, flags: Flags::default(), objects, guides: Vec::new() };
let pages = vec![Page { size: None, layers: vec![layer] }];
Ok(Drawing { version, page_size: page_box(b, settings, &p), pages, master: Vec::new(), guides: Vec::new(), warnings: warn })
}
/// The page's size from its box (R41): left, top, right and bottom around the page's centre.
fn page_box(b: &[u8], settings: usize, p: &Profile) -> Option<(f64, f64)> {
let mut r = Rd::at(b, settings + PAGE_BOX);
let (left, top, right, bottom) = (coord(&mut r, p)?, coord(&mut r, p)?, coord(&mut r, p)?, coord(&mut r, p)?);
let (w, h) = ((right - left).abs(), (top - bottom).abs());
(w > 0.0 && h > 0.0).then_some((w, h))
}
/// One drawn object's record (R43, R44): a shape, or `None` with a warning for text, for an object
/// of another type and for a shape that can't be read.
fn object(rec: &[u8], fields: Fields, p: &Profile, budget: &mut Budget, warn: &mut Vec<Warning>) -> Option<Object> {
// A curve left out at the coordinate limit is not damage.
budget.coordinates_refused();
let read = shape(rec, fields, p, budget, warn);
if read.is_none() && !budget.coordinates_refused() {
push(warn, Warning::Damaged);
}
read?.map(|s| Object::Shape(Box::new(s)))
}
/// The shape of a record. The outer `None` is a record that can't be read; the inner one an object
/// the reader leaves out, with its warning.
fn shape(rec: &[u8], fields: Fields, p: &Profile, budget: &mut Budget, warn: &mut Vec<Warning>) -> Option<Option<Shape>> {
let k = p.unit();
let mut r = Rd::at(rec, POINT);
let (x, y) = (f64::from(r.i16()?), f64::from(r.i16()?));
// x' = a x + b y + tx + x of the point, y' = c x + d y + ty + y of the point.
let (a, b, tx, c, d, ty) = (fixed(&mut r)?, fixed(&mut r)?, fixed(&mut r)?, fixed(&mut r)?, fixed(&mut r)?, fixed(&mut r)?);
let matrix = Matrix([a, c, b, d, (tx + x) * k, (ty + y) * k]);
let body = rec.get(fields.shape..)?;
let geometry = match *rec.get(KIND)? {
RECTANGLE => rect(body, p)?,
ELLIPSE => {
let mut s = Rd::new(body);
let (w, h) = (coord(&mut s, p)?, coord(&mut s, p)?);
// Two angles follow. No source confirms how they make an arc, so an ellipse whose
// angles differ is left out; one whose angles are missing is damage.
let (from, to) = (s.i16()?, s.i16()?);
if from != to {
push(warn, Warning::UnsupportedObjects);
return Some(None);
}
Geometry::Ellipse { w, h }
}
CURVE => Geometry::Path(geometry::point_list(body, p, budget, warn)?),
_ => {
push(warn, Warning::UnsupportedObjects);
return Some(None);
}
};
let color_at = |at: usize, warn: &mut Vec<Warning>| Some(records::color5(rec.get(at..at + 5)?.try_into().ok()?, warn));
let fill = match *rec.get(fields.fill_kind)? {
0 => None,
1 => Some(color_at(fields.fill_kind + 1, warn)?),
_ => {
push(warn, Warning::UnsupportedFills);
None
}
};
let outline = if *rec.get(OUTLINED)? != 0 {
let width = f64::from(Rd::at(rec, OUTLINE_WIDTH).u16()?) * k;
Some(Outline {
width,
color: color_at(OUTLINE_COLOR, warn)?,
cap: Cap::Butt,
join: Join::Miter,
dashes: Vec::new(),
behind_fill: false,
scale_with: false,
})
} else {
None
};
Some(Some(Shape::new(geometry, matrix, fill, outline)))
}
/// A rectangle (R44): its width and height, then a corner radius, which is kept when it is at most
/// half the shorter side.
fn rect(body: &[u8], p: &Profile) -> Option<Geometry> {
let mut r = Rd::new(body);
let (w, h) = (coord(&mut r, p)?, coord(&mut r, p)?);
let radius = coord(&mut r, p).filter(|v| *v > 0.0 && *v <= w.abs().min(h.abs()) / 2.0).unwrap_or(0.0);
Some(Geometry::Rect { w, h, radii: [radius; 4] })
}
#[cfg(test)]
mod tests {
use super::*;
use crate::Limits;
use crate::model::Color;
use crate::synth::{self, WlShape};
fn read(b: &[u8]) -> Result<Drawing, Error> {
drawing(b, &mut Budget::new(Limits::default()))
}
#[test]
fn the_header_is_taken_only_when_its_offsets_fit() {
let file = synth::wl_file(b'e', (612.0, 792.0), &[synth::wl_group()]);
assert!(is_wl(&file));
// The two letters, a marker and a zero are not enough.
assert!(!is_wl(b"WLe\0"));
assert!(!is_wl(b"WLe\0 and then some text that is long enough to hold offsets"));
let with = |at: usize, v: u32| {
let mut f = file.clone();
f[at..at + 4].copy_from_slice(&v.to_le_bytes());
f
};
// Records that start inside the header, start after their end, or end past the file.
assert!(!is_wl(&with(8, 27)));
assert!(!is_wl(&with(8, file.len() as u32)));
assert!(!is_wl(&with(12, file.len() as u32 + 1)));
// Settings that start inside the header or after the records.
assert!(!is_wl(&with(4, 27)));
assert!(!is_wl(&with(4, 65)));
let mut other = file.clone();
other[2] = b'x';
assert!(!is_wl(&other));
// No sample shows the marker `d`, so it is not taken.
other[2] = b'd';
assert!(!is_wl(&other));
for marker in *b"lm" {
assert!(is_wl(&synth::wl_file(marker, (612.0, 792.0), &[synth::wl_group()])));
}
other[2] = b'e';
other[3] = 1;
assert!(!is_wl(&other));
}
#[test]
fn a_version_2_file_keeps_its_page_box_fill_and_shape_where_that_version_puts_them() {
let (red, black) = ([1, 0, 100, 100, 0], [1, 0, 0, 0, 100]);
let rect = synth::wl_object(WlShape::Rect { w: 72.0, h: 36.0, radius: 9.0 }, [1.0, 0.0, 0.0, 1.0, 0.0, 0.0], Some(red), Some((2.0, black)));
for marker in *b"elm" {
let file = synth::wl_file(marker, (720.0, 504.0), std::slice::from_ref(&rect));
// Version 2 files start their settings after a picture, not after the header.
assert_eq!(u32_at(&file, 4) == Some(28), marker == b'e');
let d = read(&file).unwrap();
let near = |a: f64, b: f64| (a - b).abs() < 0.02;
assert_eq!((d.version, d.warnings.clone()), (if marker == b'e' { 100 } else { 200 }, vec![]));
assert!(d.page_size.is_some_and(|(w, h)| near(w, 720.0) && near(h, 504.0)), "{:?}", d.page_size);
let Object::Shape(s) = &d.pages[0].layers[0].objects[0] else { panic!("group") };
assert!(
matches!(s.geometry, Geometry::Rect { w, h, radii } if near(w, 72.0) && near(h, 36.0) && near(radii[0], 9.0)),
"{}",
marker as char
);
assert_eq!(s.fill, Some(Color::Cmyk([0.0, 1.0, 1.0, 0.0])), "{}", marker as char);
assert!(s.outline.as_ref().is_some_and(|o| near(o.width, 2.0) && o.color == Color::Cmyk([0.0, 0.0, 0.0, 1.0])), "{}", marker as char);
}
}
#[test]
fn a_drawn_object_is_marked_by_its_flag_bit() {
let rect = synth::wl_object(WlShape::Rect { w: 72.0, h: 36.0, radius: 0.0 }, [1.0, 0.0, 0.0, 1.0, 0.0, 0.0], None, None);
let mut file = synth::wl_file(b'l', (612.0, 792.0), &[rect]);
// Files with the marker `l` set another flag bit beside it.
file[64 + 26] = 0xc0;
let d = read(&file).unwrap();
assert_eq!((d.pages[0].layers[0].objects.len(), d.warnings), (1, vec![]));
}
#[test]
fn the_walk_stops_where_records_can_no_longer_be_found() {
let unit = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0];
let rect = || synth::wl_object(WlShape::Rect { w: 72.0, h: 36.0, radius: 0.0 }, unit, None, None);
// An object of another type doesn't give its length in the same way.
let mut other = rect();
other[KIND] = 0xff;
let d = read(&synth::wl_file(b'm', (612.0, 792.0), &[rect(), other, rect()])).unwrap();
assert_eq!((d.pages[0].layers[0].objects.len(), d.warnings), (1, vec![Warning::UnsupportedObjects]));
// A record that doesn't start as records do.
let mut lost = rect();
lost[0] = 0x84;
let d = read(&synth::wl_file(b'e', (612.0, 792.0), &[rect(), lost, rect()])).unwrap();
assert_eq!((d.pages[0].layers[0].objects.len(), d.warnings), (1, vec![Warning::Damaged]));
}
#[test]
fn a_rectangle_keeps_a_radius_of_at_most_half_its_shorter_side() {
let p = layout::for_version(300).unwrap();
let body = |radius: i16| [1000i16, 500, radius].iter().flat_map(|v| v.to_le_bytes()).collect::<Vec<u8>>();
let radius_of = |b: &[u8]| match rect(b, &p) {
Some(Geometry::Rect { w, h, radii }) if (w - 72.0).abs() < 1e-9 && (h - 36.0).abs() < 1e-9 => radii[0],
other => panic!("{other:?}"),
};
assert!((radius_of(&body(200)) - 14.4).abs() < 1e-9);
for radius in [300, -5, 0] {
assert_eq!(radius_of(&body(radius)), 0.0, "{radius}");
}
// A record that ends after the size has square corners.
assert_eq!(radius_of(&body(200)[..4]), 0.0);
assert_eq!(rect(&body(200)[..3], &p), None);
}
#[test]
fn a_record_shorter_than_its_fields_ends_the_walk_as_damage() {
let rect = synth::wl_object(WlShape::Rect { w: 72.0, h: 36.0, radius: 0.0 }, [1.0, 0.0, 0.0, 1.0, 0.0, 0.0], Some([1, 0, 0, 0, 100]), None);
let mut short = rect.clone();
// A body size that leaves less than the fixed fields.
short[28..30].copy_from_slice(&((Fields::of(b'e').least() - AFTER_BODY - 1) as u16).to_le_bytes());
let d = read(&synth::wl_file(b'e', (612.0, 792.0), &[rect.clone(), short, rect])).unwrap();
assert_eq!(d.pages[0].layers[0].objects.len(), 1);
assert_eq!(d.warnings, vec![Warning::Damaged]);
}
#[test]
fn an_ellipse_without_its_angles_is_damage() {
let ellipse =
synth::wl_object(WlShape::Ellipse { w: 72.0, h: 36.0, angles: (0, 0) }, [1.0, 0.0, 0.0, 1.0, 0.0, 0.0], Some([1, 0, 0, 0, 100]), None);
let mut cut = ellipse.clone();
// A body size that ends the record after the ellipse's width and height.
cut[28..30].copy_from_slice(&((Fields::of(b'e').least() - AFTER_BODY) as u16).to_le_bytes());
cut.truncate(Fields::of(b'e').least());
let d = read(&synth::wl_file(b'e', (612.0, 792.0), &[ellipse, cut])).unwrap();
assert_eq!(d.pages[0].layers[0].objects.len(), 1);
assert_eq!(d.warnings, vec![Warning::Damaged]);
}
#[test]
fn fill_types_other_than_uniform_and_unknown_inks_are_named() {
let mut textured =
synth::wl_object(WlShape::Rect { w: 72.0, h: 36.0, radius: 0.0 }, [1.0, 0.0, 0.0, 1.0, 0.0, 0.0], Some([0, 9, 0, 50, 0]), None);
let d = read(&synth::wl_file(b'm', (612.0, 792.0), std::slice::from_ref(&textured))).unwrap();
let Object::Shape(s) = &d.pages[0].layers[0].objects[0] else { panic!("group") };
assert_eq!(s.fill, Some(Color::Spot { name: "Spot 0:9".into(), tint: 0.5, look: None }));
assert_eq!((d.version, d.warnings), (200, vec![Warning::SpotLooks]));
textured[Fields::of(b'e').fill_kind] = 5;
let d = read(&synth::wl_file(b'm', (612.0, 792.0), &[textured])).unwrap();
let Object::Shape(s) = &d.pages[0].layers[0].objects[0] else { panic!("group") };
assert_eq!((s.fill.clone(), d.warnings), (None, vec![Warning::UnsupportedFills]));
}
}
-308
View File
@@ -1,308 +0,0 @@
//! The ZIP archives of `.cdr` drawings from version 14 on (R24): the central directory, then stored
//! and deflated members read on request. Archives that span disks, ZIP64 archives and encrypted
//! members are refused; so are directories whose members overlap or repeat a name.
use std::borrow::Cow;
use std::io::Read as _;
use crate::Error;
use crate::bytes::Rd;
/// End of central directory record: signature and fixed length.
const END: u32 = 0x0605_4b50;
const END_LEN: usize = 22;
/// The longest archive comment, which the end record may be followed by.
const MAX_COMMENT: usize = 0xFFFF;
/// ZIP64 end of central directory locator, 20 bytes before the end record when present.
const ZIP64_LOCATOR: u32 = 0x0706_4b50;
/// Central directory header: signature and fixed length.
const CENTRAL: u32 = 0x0201_4b50;
const CENTRAL_LEN: usize = 46;
/// Local file header: signature and fixed length.
const LOCAL: u32 = 0x0403_4b50;
const LOCAL_LEN: usize = 30;
/// General purpose flag bit 0: the member is encrypted.
const ENCRYPTED: u16 = 1;
const STORED: u16 = 0;
const DEFLATED: u16 = 8;
/// What members packed by another method are refused as.
const OTHER_METHODS: &str = "package compression methods other than storing and deflate";
/// One member, as the central directory and its local header give it.
#[derive(Clone, Copy, Debug)]
struct Entry<'a> {
name: &'a [u8],
flags: u16,
method: u16,
crc: u32,
packed: usize,
size: usize,
/// Where its local header starts and where its packed bytes start.
header: usize,
data: usize,
}
/// An archive's directory over its bytes.
#[derive(Debug)]
pub(crate) struct Archive<'a> {
bytes: &'a [u8],
entries: Vec<Entry<'a>>,
/// The entries in name order, for lookups.
by_name: Vec<usize>,
}
/// Does `bytes` start with a local file header?
pub(crate) fn is_zip(bytes: &[u8]) -> bool {
bytes.starts_with(b"PK\x03\x04")
}
impl<'a> Archive<'a> {
/// The directory of `bytes`, holding at most `max_entries` members.
pub(crate) fn open(bytes: &'a [u8], max_entries: usize) -> Result<Self, Error> {
let end = find_end(bytes).ok_or(Error::Damaged("package directory"))?;
if end >= 20 && Rd::at(bytes, end - 20).u32() == Some(ZIP64_LOCATOR) {
return Err(Error::Unsupported("ZIP64 packages"));
}
let mut r = Rd::at(bytes, end + 4);
let dir = || Error::Damaged("package directory");
let (disk, dir_disk) = (r.u16().ok_or_else(dir)?, r.u16().ok_or_else(dir)?);
let (on_disk, total) = (r.u16().ok_or_else(dir)?, r.u16().ok_or_else(dir)?);
let (dir_len, dir_at) = (r.u32().ok_or_else(dir)?, r.u32().ok_or_else(dir)?);
if total == u16::MAX || dir_len == u32::MAX || dir_at == u32::MAX {
return Err(Error::Unsupported("ZIP64 packages"));
}
if disk != 0 || dir_disk != 0 || on_disk != total {
return Err(Error::Unsupported("packages split across files"));
}
let total = usize::from(total);
if total > max_entries {
return Err(Error::Limit("package member count"));
}
let (dir_at, dir_len) = (dir_at as usize, dir_len as usize);
let dir_end = dir_at.checked_add(dir_len).filter(|&e| e <= end).ok_or_else(dir)?;
let mut r = Rd::at(bytes, dir_at);
let mut entries = Vec::with_capacity(total);
for _ in 0..total {
let e = central_entry(bytes, &mut r, dir_end)?;
entries.push(e);
}
// Each member's bytes end before the next member's header and before the directory.
let mut order: Vec<&Entry> = entries.iter().collect();
order.sort_unstable_by_key(|e| e.header);
for (i, e) in order.iter().enumerate() {
let stop = order.get(i + 1).map_or(dir_at, |n| n.header);
if e.data.checked_add(e.packed).is_none_or(|x| x > stop) {
return Err(Error::Damaged("package members overlap"));
}
}
let mut by_name: Vec<usize> = (0..entries.len()).collect();
by_name.sort_unstable_by_key(|&i| entries.get(i).map(|e| e.name));
let name = |i: &usize| entries.get(*i).map(|e| e.name);
if by_name.windows(2).any(|w| name(&w[0]) == name(&w[1])) {
return Err(Error::Damaged("package member named twice"));
}
Ok(Archive { bytes, entries, by_name })
}
/// The member named `name`.
pub(crate) fn find(&self, name: &[u8]) -> Option<usize> {
let at = self.by_name.binary_search_by(|&i| self.entries.get(i).map(|e| e.name).cmp(&Some(name))).ok()?;
self.by_name.get(at).copied()
}
/// The size member `i`'s directory entry gives.
pub(crate) fn size(&self, i: usize) -> usize {
self.entries.get(i).map_or(0, |e| e.size)
}
/// How many members the archive holds.
pub(crate) fn count(&self) -> usize {
self.entries.len()
}
/// The bytes reading member `i` may inflate: its stated size when it is deflated, else 0.
pub(crate) fn inflate_cost(&self, i: usize) -> usize {
self.entries.get(i).filter(|e| e.method == DEFLATED).map_or(0, |e| e.size)
}
/// An error when member `i` is encrypted or packed by a method other than storing or deflate.
pub(crate) fn check(&self, i: usize) -> Result<(), Error> {
let e = self.entries.get(i).ok_or(Error::Damaged("package member"))?;
if e.flags & ENCRYPTED != 0 {
return Err(Error::Unsupported("encrypted packages"));
}
if e.method != STORED && e.method != DEFLATED {
return Err(Error::Unsupported(OTHER_METHODS));
}
Ok(())
}
/// Member `i`'s bytes when they come to at most `limit`, and a deflated member's when they
/// also come to at most `inflate_left`. A stored member is borrowed; a deflated one inflates to
/// at most its stated size plus one byte, so a member that inflates past what it states stops
/// there. The length and CRC-32 must match the directory's.
pub(crate) fn read(&self, i: usize, limit: usize, inflate_left: usize) -> Result<Cow<'a, [u8]>, Error> {
self.check(i)?;
let e = self.entries.get(i).ok_or(Error::Damaged("package member"))?;
if e.size > limit {
return Err(Error::Limit("package member size"));
}
if e.method == DEFLATED && e.size > inflate_left {
return Err(Error::Limit("inflated size"));
}
let packed = self.bytes.get(e.data..e.data + e.packed).ok_or(Error::Damaged("package member"))?;
let out: Cow<'a, [u8]> = match e.method {
STORED if e.packed == e.size => Cow::Borrowed(packed),
STORED => return Err(Error::Damaged("package member")),
DEFLATED => {
let mut out = Vec::new();
let got = flate2::read::DeflateDecoder::new(packed)
.take(e.size as u64 + 1)
.read_to_end(&mut out)
.map_err(|_| Error::Damaged("package member"))?;
if got != e.size {
return Err(Error::Damaged("package member"));
}
Cow::Owned(out)
}
_ => return Err(Error::Unsupported(OTHER_METHODS)),
};
if crc32fast::hash(&out) != e.crc {
return Err(Error::Damaged("package member"));
}
Ok(out)
}
}
/// Where the end of central directory record starts: searched back from the end over at most the
/// longest comment, among the records whose comment reaches exactly to the end the first that
/// names members in a directory before it, else the first. A comment or a member may hold bytes
/// that look like an empty archive's end record.
fn find_end(bytes: &[u8]) -> Option<usize> {
let last = bytes.len().checked_sub(END_LEN)?;
let first = last.saturating_sub(MAX_COMMENT);
let mut found = None;
for at in (first..=last).rev() {
let mut r = Rd::at(bytes, at);
if r.u32() != Some(END) || r.skip(6).is_none() {
continue;
}
let (total, dir_len, dir_at, comment) = (r.u16(), r.u32(), r.u32(), r.u16());
if !comment.is_some_and(|c| at + END_LEN + usize::from(c) == bytes.len()) {
continue;
}
let names_members = total.is_some_and(|t| t > 0)
&& dir_len.zip(dir_at).is_some_and(|(len, dir)| {
(dir as usize).checked_add(len as usize).is_some_and(|e| e <= at) && Rd::at(bytes, dir as usize).u32() == Some(CENTRAL)
});
if names_members {
return Some(at);
}
found = found.or(Some(at));
}
found
}
/// The central directory entry at `r` (before `dir_end`) and its local header.
fn central_entry<'a>(bytes: &'a [u8], r: &mut Rd<'a>, dir_end: usize) -> Result<Entry<'a>, Error> {
let dir = || Error::Damaged("package directory");
if r.pos().checked_add(CENTRAL_LEN).is_none_or(|e| e > dir_end) || r.u32() != Some(CENTRAL) {
return Err(dir());
}
r.skip(4).ok_or_else(dir)?;
let flags = r.u16().ok_or_else(dir)?;
let method = r.u16().ok_or_else(dir)?;
r.skip(4).ok_or_else(dir)?;
let crc = r.u32().ok_or_else(dir)?;
let (packed, size) = (r.u32().ok_or_else(dir)?, r.u32().ok_or_else(dir)?);
let name_len = usize::from(r.u16().ok_or_else(dir)?);
let extra_len = usize::from(r.u16().ok_or_else(dir)?);
let comment_len = usize::from(r.u16().ok_or_else(dir)?);
let disk = r.u16().ok_or_else(dir)?;
r.skip(6).ok_or_else(dir)?;
let header = r.u32().ok_or_else(dir)?;
if packed == u32::MAX || size == u32::MAX || header == u32::MAX {
return Err(Error::Unsupported("ZIP64 packages"));
}
if disk != 0 {
return Err(Error::Unsupported("packages split across files"));
}
let name = r.bytes(name_len).ok_or_else(dir)?;
r.skip(extra_len).and_then(|()| r.skip(comment_len)).ok_or_else(dir)?;
if r.pos() > dir_end {
return Err(dir());
}
// The local header repeats the name; its own extra field may differ in length.
let header = header as usize;
let mut l = Rd::at(bytes, header);
let local = || Error::Damaged("package member header");
if l.u32() != Some(LOCAL) {
return Err(local());
}
// The signature, 22 bytes, then the name and extra field lengths.
l.skip(LOCAL_LEN - 8).ok_or_else(local)?;
let (local_name, local_extra) = (usize::from(l.u16().ok_or_else(local)?), usize::from(l.u16().ok_or_else(local)?));
if l.bytes(local_name) != Some(name) {
return Err(local());
}
l.skip(local_extra).ok_or_else(local)?;
Ok(Entry { name, flags, method, crc, packed: packed as usize, size: size as usize, header, data: l.pos() })
}
#[cfg(test)]
mod tests {
use super::*;
use crate::synth::{Member, zip};
fn stored(name: &str, data: &[u8]) -> Member {
Member { name: name.into(), data: data.to_vec(), deflate: false }
}
#[test]
fn stored_and_deflated_members_read_back() {
let bytes = zip(&[stored("a", b"hello"), Member { name: "b".into(), data: vec![7; 5000], deflate: true }], b"");
let a = Archive::open(&bytes, 10).unwrap();
assert!(matches!(a.read(a.find(b"a").unwrap(), 100, 100).unwrap(), Cow::Borrowed(b"hello")));
assert_eq!(a.read(a.find(b"b").unwrap(), 5000, 5000).unwrap().as_ref(), &[7; 5000][..]);
assert_eq!(a.read(a.find(b"b").unwrap(), 4999, 5000), Err(Error::Limit("package member size")));
assert_eq!(a.find(b"c"), None);
// What is left to inflate holds back deflated members only.
assert_eq!(a.read(a.find(b"b").unwrap(), 5000, 4999), Err(Error::Limit("inflated size")));
assert!(a.read(a.find(b"a").unwrap(), 100, 0).is_ok());
}
#[test]
fn the_end_record_is_found_behind_a_comment() {
let bytes = zip(&[stored("a", b"x")], &[b'c'; 300]);
assert!(Archive::open(&bytes, 10).is_ok());
// A comment longer than the record says leaves no end record to find.
let mut cut = bytes.clone();
cut.push(0);
assert_eq!(Archive::open(&cut, 10).unwrap_err(), Error::Damaged("package directory"));
// A comment that ends in bytes like an empty archive's end record: the record that names
// members in a directory is the archive's.
let mut fake = END.to_le_bytes().to_vec();
fake.resize(END_LEN, 0);
let bytes = zip(&[stored("a", b"x")], &fake);
let a = Archive::open(&bytes, 10).unwrap();
assert_eq!(a.count(), 1);
}
#[test]
fn a_member_whose_crc_or_length_is_wrong_is_damage() {
let bytes = zip(&[Member { name: "a".into(), data: vec![1; 64], deflate: true }], b"");
let a = Archive::open(&bytes, 10).unwrap();
// The directory's CRC-32 sits 16 bytes into its entry.
let dir_at = bytes.windows(4).position(|w| w == CENTRAL.to_le_bytes()).unwrap();
let mut bad = bytes.clone();
bad[dir_at + 16] ^= 1;
let b = Archive::open(&bad, 10).unwrap();
assert_eq!(b.read(0, 1000, 1000).unwrap_err(), Error::Damaged("package member"));
// A stated size one short: the inflate runs past it.
let mut short = bytes.clone();
short[dir_at + 24] -= 1;
let s = Archive::open(&short, 10).unwrap();
assert_eq!(s.read(0, 1000, 1000).unwrap_err(), Error::Damaged("package member"));
assert!(a.read(0, 1000, 1000).is_ok());
}
}
-65
View File
@@ -1,65 +0,0 @@
//! Read time of a large synthetic drawing. Run with
//! `cargo test --release -p vectorcraft-cdr --test it bench -- --ignored --nocapture`.
use vectorcraft_cdr::synth::{self, V, chunk, list};
use vectorcraft_cdr::{Limits, read};
/// A version 13 drawing of `n` curves of 22 points each, filled and outlined, compressed when
/// `compress`.
fn many_curves(n: usize, compress: bool) -> Vec<u8> {
let v = V(1300);
let red = synth::color(5, [0, 0, 255, 0]);
let black = synth::color(2, [0, 0, 0, 100]);
let styles = list(
b"doc ",
vec![
synth::mcfg(v, 612.0, 792.0),
list(b"filt", vec![chunk(b"fild", v.fill(1, &red))]),
list(b"otlt", vec![chunk(b"outl", v.outline(2, synth::Pen { line_type: 0, width: 1.0, cap: 0, join: 0 }, &black, &[]))]),
],
);
let objects: Vec<_> = (0..n)
.map(|i| {
let o = (i % 500) as f64;
// A move, then curves of two control points and an end point each.
let kind = |k: i32| {
if k == 0 {
0x08
} else if k % 3 == 0 {
0x80
} else {
0xC0
}
};
let pts: Vec<(f64, f64, u8)> = (0..22).map(|k| (o + f64::from(k), o + f64::from(k % 5), kind(k))).collect();
let args = vec![(20, 1u32.to_le_bytes().to_vec()), (10, 2u32.to_le_bytes().to_vec()), (30, v.points(&pts))];
synth::object(v, 3, &args, Some([1.0, 0.0, 0.0, 1.0, o, -o]))
})
.collect();
let page = synth::page(false, vec![synth::layer(v, [0, 0, 0, 0x98], "Art", objects)]);
let body = vec![styles, page];
let mut kids = vec![chunk(b"vrsn", 1300u16.to_le_bytes().to_vec())];
if compress {
kids.push(synth::cmpr(&body));
} else {
kids.extend(body);
}
synth::riff(1300, &kids)
}
#[test]
#[ignore = "manual timing probe; wall-clock performance depends on machine load"]
fn read_a_large_drawing() {
for compress in [false, true] {
let file = many_curves(50_000, compress);
let mut times = Vec::new();
for _ in 0..5 {
let t = std::time::Instant::now();
let d = read(&file, Limits::default()).unwrap();
times.push(t.elapsed().as_secs_f64() * 1000.0);
assert_eq!(d.pages.len(), 1);
}
times.sort_by(f64::total_cmp);
println!("compress={compress} bytes={} median_ms={:.1} min_ms={:.1}", file.len(), times[2], times[0]);
}
}
-568
View File
@@ -1,568 +0,0 @@
//! Reading synthetic `.cmx` files built from the layouts in `PROVENANCE.md` (R53 to R63), and
//! hostile ones.
use proptest::prelude::*;
use vectorcraft_cdr::model::{Cap, Color, Geometry, Join, Object, Shape};
use vectorcraft_cdr::synth_cmx::*;
use vectorcraft_cdr::{Error, Limits, Warning, is_cdr, is_cmx, read_cmx};
fn shape(o: &Object) -> &Shape {
match o {
Object::Shape(s) => s,
other => panic!("not a shape: {other:?}"),
}
}
/// The (x, y) bounds of a shape's path.
fn bounds(s: &Shape) -> (f64, f64, f64, f64) {
let Geometry::Path(p) = &s.geometry else { panic!("not a path") };
let mut b = (f64::MAX, f64::MAX, f64::MIN, f64::MIN);
for sp in &p.subpaths {
for pt in std::iter::once(sp.start).chain(sp.segments.iter().map(|s| match s {
vectorcraft_cdr::model::Segment::Line(p) | vectorcraft_cdr::model::Segment::Cubic(_, _, p) => *p,
})) {
b = (b.0.min(pt.x), b.1.min(pt.y), b.2.max(pt.x), b.3.max(pt.y));
}
}
b
}
fn near(a: f64, b: f64) -> bool {
(a - b).abs() < 1e-6
}
/// The file with `children` after a 32-bit header and the sample tables.
fn file(pages: &[Vec<u8>]) -> Vec<u8> {
let mut children = vec![cont(b'4', 1e-7)];
children.extend(pages.iter().cloned());
children.extend(tables());
riff(&children)
}
#[test]
fn a_cmx_file_is_told_from_a_cdr_drawing() {
let f = sample();
assert!(is_cmx(&f) && !is_cdr(&f));
let mut rifx = f.clone();
rifx[..4].copy_from_slice(b"RIFX");
assert!(is_cmx(&rifx));
assert!(!is_cmx(b"RIFF\0\0\0\0CDR9"));
assert_eq!(read_cmx(b"RIFF\0\0\0\0CDR9", Limits::default()), Err(Error::NotCmx));
}
#[test]
fn pages_layers_groups_and_curves() {
let d = read_cmx(&sample(), Limits::default()).unwrap();
assert_eq!(d.version, 0);
assert!(d.warnings.is_empty(), "{:?}", d.warnings);
assert_eq!(d.pages.len(), 1);
let page = &d.pages[0];
// 2,100,000 units of 0.1 µm are 210 mm.
let (w, h) = page.size.unwrap();
assert!(near(w, 210.0 / 25.4 * 72.0) && near(h, 297.0 / 25.4 * 72.0), "{w} {h}");
// The layer drawn last is in front: the model lists layers front to back.
let names: Vec<&str> = page.layers.iter().map(|l| l.name.as_str()).collect();
assert_eq!(names, ["Top", "Art"]);
let art = &page.layers[1].objects;
assert_eq!(art.len(), 2);
// The group, drawn after the red square, is in front of it.
let Object::Group { objects: kids, .. } = &art[0] else { panic!("{:?}", art[0]) };
assert_eq!(kids.len(), 2);
let red = shape(&art[1]);
assert_eq!(red.fill, Some(Color::Rgb([1.0, 0.0, 0.0])));
// 1,000,000 units are 100 mm; the square's corner is 50 mm left of and below the center.
let mm = 72.0 / 25.4;
let b = bounds(red);
assert!(near(b.0, -50.0 * mm) && near(b.1, -50.0 * mm) && near(b.2, 50.0 * mm) && near(b.3, 50.0 * mm), "{b:?}");
let Geometry::Path(p) = &red.geometry else { panic!() };
assert!(p.subpaths.len() == 1 && p.subpaths[0].closed && p.subpaths[0].segments.len() == 4);
let o = red.outline.as_ref().unwrap();
assert!(near(o.width, 0.5 * mm));
assert_eq!((o.color.clone(), o.cap, o.join), (Color::Cmyk([0.0, 0.0, 0.0, 1.0]), Cap::Round, Join::Round));
assert!(o.dashes.is_empty() && !o.behind_fill && !o.scale_with);
// Line type 1 draws no outline.
let blue = shape(&kids[0]);
let black = shape(&kids[1]);
assert!(black.outline.is_none());
assert_eq!(black.fill, Some(Color::Cmyk([0.0, 0.0, 0.0, 1.0])));
// The color record's values are blue, green and red.
assert_eq!(blue.fill, Some(Color::Rgb([0.0, 0.0, 1.0])));
let o = blue.outline.as_ref().unwrap();
assert!(near(o.width, 1.0 * mm));
assert_eq!((o.dashes.clone(), o.behind_fill, o.cap, o.join), (vec![3.0, 1.0], true, Cap::Square, Join::Miter));
assert_eq!(page.layers[0].name, "Top");
}
#[test]
fn layer_names_and_layers_without_objects() {
let p = page(&[
begin_page(None),
begin_layer("Ebene 1", Some("Слой 1")),
square(&attrs(Some(1), None, false), 0, 0, 1000),
end_layer(),
begin_layer("Gitter", None),
end_layer(),
begin_layer("Caf\u{e9}", None),
square(&attrs(Some(1), None, false), 0, 0, 1000),
end_layer(),
end_page(),
]);
let d = read_cmx(&file(&[p]), Limits::default()).unwrap();
let page = &d.pages[0];
assert_eq!(page.size, None);
// The empty layer is left out, and the UTF-16 name wins over the 8-bit one.
let names: Vec<&str> = page.layers.iter().map(|l| l.name.as_str()).collect();
assert_eq!(names, ["Caf\u{c3}\u{a9}", "Слой 1"]);
}
#[test]
fn objects_before_any_layer_get_one() {
let p = page(&[begin_page(None), square(&attrs(Some(1), None, false), 0, 0, 1000)]);
let d = read_cmx(&file(&[p]), Limits::default()).unwrap();
assert_eq!(d.pages[0].layers.len(), 1);
// The layer is left unnamed, as a `.cdr` drawing's is; the importer names it by its place.
assert_eq!(d.pages[0].layers[0].name, "");
}
#[test]
fn a_page_without_a_size_takes_the_drawings_bounds() {
// A square of 100 mm whose bounds lie off the file's origin, above and to the right.
let p = page(&[
begin_page_in_bounds(1_000_000, 3_000_000, 2_000_000, 2_000_000),
begin_layer("L", None),
square(&attrs(Some(1), None, false), 1_000_000, 2_000_000, 1_000_000),
end_layer(),
end_page(),
]);
let d = read_cmx(&file(&[p]), Limits::default()).unwrap();
let page = &d.pages[0];
let side = 100.0 / 25.4 * 72.0;
let (w, h) = page.size.unwrap();
assert!(near(w, side) && near(h, side), "{w} x {h}");
// The page is centered on the bounds, so the square fills it.
let (x0, y0, x1, y1) = bounds(shape(&page.layers[0].objects[0]));
assert!(near(x0, -side / 2.0) && near(x1, side / 2.0) && near(y0, -side / 2.0) && near(y1, side / 2.0), "{x0} {y0} {x1} {y1}");
}
#[test]
fn curves_and_open_groups() {
let c =
curve(&attrs(None, Some(1), false), &[(0, 0), (100, 0), (100, 100), (0, 100), (200, 200), (300, 200)], &[0x00, 0xc0, 0xc0, 0x84, 0x00, 0x44]);
// A group the layer leaves open closes with it.
let p = page(&[begin_page(None), begin_layer("L", None), begin_group(), c, end_layer()]);
let d = read_cmx(&file(&[p]), Limits::default()).unwrap();
let objects = &d.pages[0].layers[0].objects;
let Object::Group { objects: kids, .. } = &objects[0] else { panic!("{objects:?}") };
let s = shape(&kids[0]);
assert!(s.fill.is_none());
let Geometry::Path(p) = &s.geometry else { panic!() };
assert_eq!(p.subpaths.len(), 2);
assert!(matches!(p.subpaths[0].segments[..], [vectorcraft_cdr::model::Segment::Cubic(..)]));
assert!(!p.subpaths[1].closed);
}
#[test]
fn a_curve_without_its_points_is_reported() {
let p = page(&[begin_page(None), begin_layer("L", None), instr(67, &fields(&[field(1, &attrs(Some(1), None, false))])), end_layer()]);
let d = read_cmx(&file(&[p]), Limits::default()).unwrap();
assert!(d.warnings.contains(&Warning::Damaged), "{:?}", d.warnings);
}
#[test]
fn a_layer_name_too_short_to_read_in_utf_16_reads_in_8_bit() {
let mut d = vec![1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0];
d.extend(b"Art");
let layer = instr(11, &fields(&[field(1, &d), field(4, &[3, 0])]));
let p = page(&[begin_page(None), layer, square(&attrs(Some(1), None, false), 0, 0, 1000), end_layer()]);
let d = read_cmx(&file(&[p]), Limits::default()).unwrap();
assert_eq!(d.pages[0].layers[0].name, "Art");
}
#[test]
fn what_is_not_read_is_reported() {
let other = |code: i16| instr(code, &fields(&[field(1, &[0; 8])]));
let p = page(&[
begin_page(None),
begin_layer("L", None),
other(66),
other(68),
other(20),
other(88),
square(&attrs_fill_type(2), 0, 0, 1000),
square(&attrs(Some(1), None, true), 0, 0, 1000),
end_layer(),
]);
let d = read_cmx(&file(&[p]), Limits::default()).unwrap();
for w in [Warning::UnsupportedObjects, Warning::UnsupportedFills, Warning::Lenses] {
assert!(d.warnings.contains(&w), "{w:?}: {:?}", d.warnings);
}
// A fill of another type leaves the curve unfilled; the curve is still read.
let objects = &d.pages[0].layers[0].objects;
assert_eq!(objects.len(), 2);
assert!(shape(&objects[1]).fill.is_none());
}
#[test]
fn colors_of_other_models_and_missing_entries() {
let mut children = vec![cont(b'4', 1e-7)];
children.push(page(&[
begin_page(None),
begin_layer("L", None),
square(&attrs(Some(1), None, false), 0, 0, 1000),
square(&attrs(Some(9), None, false), 0, 0, 1000),
square(&attrs(Some(2), None, false), 0, 0, 1000),
]));
children.push(table(b"rclr", &[color(7, &[1, 2, 3, 4]), color(3, &[255, 0, 0, 255])]));
let d = read_cmx(&riff(&children), Limits::default()).unwrap();
assert!(d.warnings.contains(&Warning::UnknownColors) && d.warnings.contains(&Warning::Damaged), "{:?}", d.warnings);
let objects = &d.pages[0].layers[0].objects;
assert_eq!(shape(&objects[0]).fill, Some(Color::Cmyk([1.0, 0.0, 0.0, 1.0])));
assert_eq!(shape(&objects[1]).fill, Some(Color::Rgb([0.0; 3])));
}
#[test]
fn gray_cmy_and_rgb_colors_of_the_older_fields() {
let mut children = vec![cont(b'4', 1e-7)];
children.push(page(&[
begin_page(None),
begin_layer("L", None),
square(&attrs(Some(1), None, false), 0, 0, 1000),
square(&attrs(Some(2), None, false), 0, 0, 1000),
square(&attrs(Some(3), None, false), 0, 0, 1000),
]));
children.push(table(b"rclr", &[color(9, &[51]), color(4, &[255, 0, 51]), color(5, &[255, 0, 0])]));
let d = read_cmx(&riff(&children), Limits::default()).unwrap();
assert!(d.warnings.is_empty(), "{:?}", d.warnings);
let objects = &d.pages[0].layers[0].objects;
// The model holds objects front to back: the RGB square, the CMY one, then the gray one.
assert_eq!(shape(&objects[0]).fill, Some(Color::Rgb([1.0, 0.0, 0.0])));
match (shape(&objects[1]).fill.clone(), shape(&objects[2]).fill.clone()) {
(Some(Color::Cmyk([c, m, y, k])), Some(Color::Gray(g))) => {
assert!((c - 1.0).abs() < 1e-6 && m == 0.0 && (y - 0.2).abs() < 1e-6 && k == 0.0, "{c} {m} {y} {k}");
assert!((g - 0.8).abs() < 1e-6, "{g}");
}
other => panic!("{other:?}"),
}
}
#[test]
fn outline_arrowheads_are_reported() {
let mut children = vec![cont(b'4', 1e-7)];
children.push(page(&[begin_page(None), begin_layer("L", None), square(&attrs(None, Some(1), false), 0, 0, 1000)]));
children.extend(tables().into_iter().filter(|t| !t.starts_with(b"rota")));
children.push(arrowheads(&[(0, 2)]));
let d = read_cmx(&riff(&children), Limits::default()).unwrap();
assert_eq!(d.warnings, vec![Warning::Arrowheads]);
}
#[test]
fn a_long_instruction_and_a_jump_over_image_bytes() {
// The jump's target counts from the start of the file: header, `cont`, then the page body.
let before = riff(&[cont(b'4', 1e-7), page(&[])]).len() - 8;
let head = [begin_page(None), begin_layer("L", None)].concat();
let jump_len = 4 + 1 + 3 + 4;
let image = vec![0xEEu8; 37];
let target = (before + 8 + head.len() + jump_len + image.len()) as u32;
let jump = instr(111, &fields(&[field(1, &target.to_le_bytes())]));
assert_eq!(jump.len(), jump_len);
let body = [
head,
jump,
image,
long_instr(67, &curve(&attrs(Some(1), None, false), &[(0, 0), (10, 0), (10, 10)], &[0x0c, 0x44, 0x48])[4..]),
end_layer(),
]
.concat();
let mut children = vec![cont(b'4', 1e-7), chunk(b"page", &body)];
children.extend(tables());
let d = read_cmx(&riff(&children), Limits::default()).unwrap();
// The images jumped over are not read, and the warning says so.
assert_eq!(d.warnings, [Warning::UnsupportedObjects]);
assert_eq!(d.pages[0].layers[0].objects.len(), 1);
}
#[test]
fn bytes_after_a_chunk_that_runs_short_are_passed_over() {
let stray = vec![0x10, 0x00, 0x16, 0x00, 0x01, 0x0b, 0x00, 0x01, 0, 0, 0, 0, 0, 0, 0, 0xff];
let mut children = vec![cont(b'4', 1e-7), stray, list(b"pgls", &[page(&[begin_page(None), square(&attrs(Some(1), None, false), 0, 0, 1000)])])];
children.extend(tables());
let d = read_cmx(&riff(&children), Limits::default()).unwrap();
assert!(d.warnings.is_empty(), "{:?}", d.warnings);
assert_eq!(d.pages[0].layers[0].objects.len(), 1);
}
#[test]
fn other_byte_orders_and_coordinate_sizes_are_refused() {
let mut f = sample();
f[..4].copy_from_slice(b"RIFX");
assert_eq!(read_cmx(&f, Limits::default()), Err(Error::Unsupported("big-endian CMX files")));
let mut children = vec![cont(b'2', 1e-3)];
children.extend(tables());
assert_eq!(read_cmx(&riff(&children), Limits::default()), Err(Error::Unsupported("CMX files with 16-bit coordinates")));
assert_eq!(read_cmx(&riff(&tables()), Limits::default()), Err(Error::Damaged("CMX header")));
assert_eq!(read_cmx(&riff(&[cont(b'9', 1e-7)]), Limits::default()), Err(Error::Damaged("CMX header")));
}
#[test]
fn a_header_without_a_usable_unit_reads_0_1_micrometers() {
for meters in [0.0, -1.0, f64::NAN, 2.0] {
let mut children = vec![cont(b'4', meters), page(&[begin_page(Some((2_100_000, 2_970_000)))])];
children.extend(tables());
let d = read_cmx(&riff(&children), Limits::default()).unwrap();
let (w, _) = d.pages[0].size.unwrap();
assert!(near(w, 210.0 / 25.4 * 72.0), "{meters}: {w}");
}
}
#[test]
fn groups_past_the_depth_limit_are_left_out() {
let mut ins = vec![begin_page(None), begin_layer("L", None)];
for _ in 0..6 {
ins.push(begin_group());
}
ins.push(square(&attrs(Some(1), None, false), 0, 0, 1000));
for _ in 0..6 {
ins.push(end_group());
}
ins.push(square(&attrs(Some(1), None, false), 0, 0, 1000));
let d = read_cmx(&file(&[page(&ins)]), Limits { depth: 3, ..Limits::default() }).unwrap();
assert!(d.warnings.contains(&Warning::TooDeep));
// The square after the groups is still read, beside the three groups kept.
let objects = &d.pages[0].layers[0].objects;
assert_eq!(objects.len(), 2);
let mut depth = 0;
let mut o = &objects[1];
while let Object::Group { objects: kids, .. } = o {
depth += 1;
match kids.first() {
Some(k) => o = k,
None => break,
}
}
assert_eq!(depth, 3);
}
#[test]
fn counts_past_the_limits_are_bounded() {
let ins: Vec<Vec<u8>> = std::iter::once(begin_page(None)).chain((0..50).map(|_| square(&attrs(Some(1), None, false), 0, 0, 1000))).collect();
let f = file(&[page(&ins)]);
let d = read_cmx(&f, Limits { objects: 10, ..Limits::default() }).unwrap();
assert_eq!(d.pages[0].layers[0].objects.len(), 10);
assert!(d.warnings.contains(&Warning::TooDeep));
let d = read_cmx(&f, Limits { coordinates: 12, ..Limits::default() }).unwrap();
assert_eq!(d.pages[0].layers[0].objects.len(), 2);
assert_eq!(read_cmx(&f, Limits { chunks: 20, ..Limits::default() }), Err(Error::Limit("chunk count")));
assert_eq!(read_cmx(&f, Limits { input: 10, ..Limits::default() }), Err(Error::Limit("input size")));
let dashed = |n: u16| {
let mut children = vec![cont(b'4', 1e-7)];
children.push(page(&[begin_page(None), square(&attrs(None, Some(3), false), 0, 0, 1000), square(&attrs(None, Some(3), false), 0, 0, 1000)]));
children.extend(tables());
read_cmx(&riff(&children), Limits { dashes: usize::from(n), ..Limits::default() }).unwrap()
};
let d = dashed(3);
let o: Vec<usize> = d.pages[0].layers[0].objects.iter().map(|o| shape(o).outline.as_ref().unwrap().dashes.len()).collect();
assert_eq!(o, [0, 2]);
assert!(d.warnings.contains(&Warning::TooDeep));
}
#[test]
fn a_curve_cut_short_keeps_the_points_it_holds() {
let mut c = curve(&attrs(Some(1), None, false), &[(0, 0), (10, 0), (10, 10)], &[0x0c, 0x44, 0x48]);
// Claim 9 points where 3 are stored: the field's own length still covers only 3.
let at = c.windows(2).position(|w| w == [3, 0]).unwrap();
c[at] = 9;
let p = page(&[begin_page(None), c]);
let d = read_cmx(&file(&[p]), Limits::default()).unwrap();
assert!(d.warnings.contains(&Warning::Damaged));
assert_eq!(d.pages[0].layers[0].objects.len(), 1);
}
#[test]
fn a_curve_that_lost_type_bytes_keeps_its_first_points() {
// Three whole points and only two of their type bytes.
let mut g = 3u16.to_le_bytes().to_vec();
for (x, y) in [(0i32, 0i32), (1_000_000, 0), (1_000_000, 1_000_000)] {
g.extend(x.to_le_bytes());
g.extend(y.to_le_bytes());
}
g.extend([0x0c, 0x44]);
let c = instr(67, &fields(&[field(1, &attrs(None, Some(1), false)), field(2, &g)]));
let d = read_cmx(&file(&[page(&[begin_page(None), c])]), Limits::default()).unwrap();
assert!(d.warnings.contains(&Warning::Damaged), "{:?}", d.warnings);
let Geometry::Path(p) = &shape(&d.pages[0].layers[0].objects[0]).geometry else { panic!() };
let side = 100.0 / 25.4 * 72.0;
assert!(near(p.subpaths[0].start.x, 0.0) && near(p.subpaths[0].start.y, 0.0));
match p.subpaths[0].segments[..] {
[vectorcraft_cdr::model::Segment::Line(e)] => assert!(near(e.x, side) && near(e.y, 0.0), "{e:?}"),
ref other => panic!("{other:?}"),
}
}
#[test]
fn a_file_cut_short_of_its_declared_size_is_reported() {
let mut f = file(&[]);
let declared = (f.len() as u32 - 8 + 100).to_le_bytes();
f[4..8].copy_from_slice(&declared);
let d = read_cmx(&f, Limits::default()).unwrap();
assert!(d.warnings.contains(&Warning::Damaged), "{:?}", d.warnings);
}
#[test]
fn a_page_that_ends_inside_an_instruction_is_reported() {
let p = page(&[begin_page(None), begin_layer("L", None), square(&attrs(Some(1), None, false), 0, 0, 1000), end_layer(), vec![1, 0]]);
let d = read_cmx(&file(&[p]), Limits::default()).unwrap();
assert!(d.warnings.contains(&Warning::Damaged), "{:?}", d.warnings);
assert_eq!(d.pages[0].layers[0].objects.len(), 1);
}
#[test]
fn a_chunk_64_bytes_past_stray_bytes_is_found() {
let p = page(&[begin_page(None), begin_layer("L", None), square(&attrs(Some(1), None, false), 0, 0, 1000), end_layer()]);
let mut children = vec![cont(b'4', 1e-7), [vec![1u8; 64], p].concat()];
children.extend(tables());
let d = read_cmx(&riff(&children), Limits::default()).unwrap();
assert_eq!(d.pages.len(), 1);
assert_eq!(d.pages[0].layers[0].objects.len(), 1);
}
#[test]
fn stray_letters_with_a_length_past_the_file_are_passed_over() {
let mut stray = b"abcd".to_vec();
stray.extend(0xFFFF_FF00u32.to_le_bytes());
let p = page(&[begin_page(None), begin_layer("L", None), square(&attrs(Some(1), None, false), 0, 0, 1000), end_layer()]);
let mut children = vec![cont(b'4', 1e-7), [stray, p].concat()];
children.extend(tables());
let d = read_cmx(&riff(&children), Limits::default()).unwrap();
assert_eq!(d.pages.len(), 1);
assert_eq!(d.pages[0].layers[0].objects.len(), 1);
}
#[test]
fn a_dash_pattern_of_zero_lengths_draws_a_solid_line() {
let mut children = vec![cont(b'4', 1e-7)];
children.push(page(&[begin_page(None), begin_layer("L", None), square(&attrs(None, Some(1), false), 0, 0, 1000)]));
children.extend(tables().into_iter().filter(|t| !t.starts_with(b"rdot") && !t.starts_with(b"rotl")));
children.push(table(b"rdot", &[dashes(&[0, 0])]));
children.push(table(b"rotl", &[outline([3, 1, 2, 1, 1, 1])]));
let d = read_cmx(&riff(&children), Limits::default()).unwrap();
assert!(d.warnings.is_empty(), "{:?}", d.warnings);
let o = shape(&d.pages[0].layers[0].objects[0]).outline.clone().unwrap();
assert!(o.dashes.is_empty(), "{:?}", o.dashes);
}
#[test]
fn a_curve_field_that_lost_points_is_left_out() {
// Three points claimed, two whole points stored and the third cut inside its y: the type
// bytes can't be found, so no node types are read from coordinates.
let mut g = 3u16.to_le_bytes().to_vec();
for (x, y) in [(0i32, 0i32), (1_000_000, 0)] {
g.extend(x.to_le_bytes());
g.extend(y.to_le_bytes());
}
g.extend(1_000_000i32.to_le_bytes());
g.extend([0x40, 0x42]);
let c = instr(67, &fields(&[field(1, &attrs(Some(1), None, false)), field(2, &g)]));
let d = read_cmx(&file(&[page(&[begin_page(None), begin_layer("L", None), c])]), Limits::default()).unwrap();
assert!(d.warnings.contains(&Warning::Damaged), "{:?}", d.warnings);
assert!(d.pages[0].layers.is_empty(), "{:?}", d.pages[0].layers);
}
#[test]
fn a_chunk_whose_id_has_a_digit_is_found_after_stray_bytes() {
// Stray bytes, a chunk the reader passes over whose id ends in a digit, then the page.
let p = page(&[begin_page(None), begin_layer("L", None), square(&attrs(Some(1), None, false), 0, 0, 1000), end_layer()]);
let mut b = vec![1u8; 6];
b.extend(chunk(b"inf1", &[0; 70]));
b.extend(p);
let mut children = vec![cont(b'4', 1e-7), b];
children.extend(tables());
let d = read_cmx(&riff(&children), Limits::default()).unwrap();
assert!(d.warnings.is_empty(), "{:?}", d.warnings);
assert_eq!(d.pages.len(), 1);
assert_eq!(d.pages[0].layers[0].objects.len(), 1);
}
#[test]
fn padding_and_ids_with_impossible_lengths_are_not_taken_for_chunks() {
// After stray bytes, four spaces with a small length, or letters with a length past the list,
// come before the page: neither is taken for a chunk, so the page is found.
for filler in [b" \x08\x00\x00\x00".to_vec(), b"junk\x40\x42\x0f\x00".to_vec()] {
let p = page(&[begin_page(None), begin_layer("L", None), square(&attrs(Some(1), None, false), 0, 0, 1000), end_layer()]);
let mut b = vec![1u8; 2];
b.extend(filler);
b.extend(p);
let mut children = vec![cont(b'4', 1e-7), b];
children.extend(tables());
let d = read_cmx(&riff(&children), Limits::default()).unwrap();
assert!(d.warnings.is_empty(), "{:?}", d.warnings);
assert_eq!(d.pages.len(), 1);
assert_eq!(d.pages[0].layers[0].objects.len(), 1);
}
}
#[test]
fn after_stray_bytes_a_chunk_the_reader_passes_over_keeps_what_it_holds() {
// Stray bytes, then a chunk the reader passes over whose body starts with the letters of a
// page chunk, then the page: only the page is read.
let p = page(&[begin_page(None), begin_layer("L", None), square(&attrs(Some(1), None, false), 0, 0, 1000), end_layer()]);
let mut inner = b"page".to_vec();
inner.extend(4u32.to_le_bytes());
inner.extend([0; 10]);
let mut b = vec![1u8; 2];
b.extend(chunk(b"inf1", &inner));
b.extend(p);
let mut children = vec![cont(b'4', 1e-7), b];
children.extend(tables());
let d = read_cmx(&riff(&children), Limits::default()).unwrap();
assert!(d.warnings.is_empty(), "{:?}", d.warnings);
assert_eq!(d.pages.len(), 1);
assert_eq!(d.pages[0].layers[0].objects.len(), 1);
}
#[test]
fn a_canvas_or_a_container_is_reported() {
for bit in [8u8, 16] {
let mut a = attrs(Some(1), None, false);
a[0] |= bit;
let p = page(&[begin_page(None), begin_layer("L", None), square(&a, 0, 0, 1000), end_layer()]);
let d = read_cmx(&file(&[p]), Limits::default()).unwrap();
assert_eq!(d.warnings, vec![Warning::UnsupportedObjects], "{bit}");
assert!(shape(&d.pages[0].layers[0].objects[0]).fill.is_some());
}
}
#[test]
fn a_library_color_with_its_name_reads_as_a_spot_color() {
let mut children = vec![cont(b'4', 1e-7)];
children.push(page(&[begin_page(None), begin_layer("L", None), square(&attrs(Some(1), None, false), 0, 0, 1000)]));
children.push(table(b"rclr", &[color_record_named(5, [0, 0, 255, 0], Some("Brick 12"))]));
let d = read_cmx(&riff(&children), Limits::default()).unwrap();
match shape(&d.pages[0].layers[0].objects[0]).fill.clone() {
Some(Color::Spot { name, tint, look }) => {
assert_eq!((name.as_str(), tint), ("Brick 12", 1.0));
assert!(look.is_some());
}
other => panic!("{other:?}"),
}
}
proptest! {
#![proptest_config(ProptestConfig { cases: 256, ..ProptestConfig::default() })]
#[test]
fn never_panics_on_garbage(bytes in prop::collection::vec(any::<u8>(), 0..2048)) {
let mut b = b"RIFF\0\0\0\0CMX1".to_vec();
b.extend(bytes);
let _ = read_cmx(&b, Limits::default());
}
#[test]
fn never_panics_on_mutated_samples(edits in prop::collection::vec((any::<usize>(), any::<u8>()), 1..24)) {
let mut b = sample();
let n = b.len();
for (at, v) in edits {
b[at % n] = v;
}
let _ = read_cmx(&b, Limits::default());
}
}
-8
View File
@@ -1,8 +0,0 @@
//! Integration tests: one test binary for the crate, one module per area.
// Unwrapping and panicking on failure is fine here, unlike in shipped code (AGENTS.md › Robustness).
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
mod bench;
mod cmx;
mod provenance;
mod read;
-43
View File
@@ -1,43 +0,0 @@
//! Every layout id the code cites (`R1` ...) has a row in `PROVENANCE.md`.
use std::collections::BTreeSet;
/// The ids `R<n>` in `text`.
fn ids(text: &str) -> BTreeSet<u32> {
let b = text.as_bytes();
let mut out = BTreeSet::new();
for (i, c) in b.iter().enumerate() {
let starts = *c == b'R' && (i == 0 || !b[i - 1].is_ascii_alphanumeric());
if !starts {
continue;
}
let digits: String = b[i + 1..].iter().take_while(|d| d.is_ascii_digit()).map(|d| *d as char).collect();
let ends = b.get(i + 1 + digits.len()).is_none_or(|d| !d.is_ascii_alphanumeric());
if !digits.is_empty() && ends {
out.insert(digits.parse().unwrap());
}
}
out
}
#[test]
fn every_cited_layout_has_a_row() {
let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR"));
let table = std::fs::read_to_string(dir.join("PROVENANCE.md")).unwrap();
let rows: BTreeSet<u32> = table.lines().filter_map(|l| l.strip_prefix("| R")).filter_map(|l| l.split(' ').next()?.parse().ok()).collect();
let mut cited = BTreeSet::new();
for entry in std::fs::read_dir(dir.join("src")).unwrap() {
let path = entry.unwrap().path();
if path.extension().is_some_and(|e| e == "rs") {
cited.extend(ids(&std::fs::read_to_string(&path).unwrap()));
}
}
assert!(!cited.is_empty());
let missing: Vec<_> = cited.difference(&rows).collect();
assert!(missing.is_empty(), "cited without a PROVENANCE.md row: {missing:?}");
}
#[test]
fn ids_are_found_only_as_whole_words() {
assert_eq!(ids("(R1, R12) RIFF R3x xR4 R"), BTreeSet::from([1, 12]));
}
File diff suppressed because it is too large Load Diff
+2 -2
View File
@@ -41,7 +41,7 @@ vectorcraft-eps = { workspace = true }
vectorcraft-metafile = { workspace = true }
vectorcraft-plugins = { workspace = true }
vectorcraft-affinity = { workspace = true }
vectorcraft-cdr = { workspace = true }
craft-cdr = { workspace = true }
vectorcraft-scriptcheck = { workspace = true }
vectorcraft-js = { workspace = true }
# The commands' parameter schemas (schemas.rs).
@@ -96,7 +96,7 @@ craft-jxl = { workspace = true }
hayro-ccitt = { workspace = true }
craft-stream-codecs = { workspace = true }
vectorcraft-affinity = { workspace = true, features = ["synth"] }
vectorcraft-cdr = { workspace = true, features = ["synth"] }
craft-cdr = { workspace = true, features = ["synth"] }
crc32fast = { workspace = true }
vectorcraft-testkit = { workspace = true }
proptest = { workspace = true }
+8 -8
View File
@@ -1,7 +1,7 @@
//! `.cdr` drawings of versions 1 to 27 (`.cdr`, and `.cdt` templates): the pages, layers,
//! guidelines, groups, curves, rectangles, ellipses, arcs and polygons with uniform fills and
//! outlines, their hidden and locked states, fill rules and uniform transparency that
//! `vectorcraft-cdr` reads, mapped to editable VectorCraft art. Pages become
//! `craft-cdr` reads, mapped to editable VectorCraft art. Pages become
//! artboards side by side; layers of the same name on different pages become one layer where the
//! pages stack them in the same order. What the
//! reader leaves out is listed in the warnings, one line for each kind ([`note`]). `.cmx` exchange
@@ -10,9 +10,9 @@
use std::collections::HashMap;
use std::sync::Arc;
use craft_cdr::model::{self as cd, LayerKind};
use craft_cdr::{Limits, Warning};
use kurbo::{Affine, Rect};
use vectorcraft_cdr::model::{self as cd, LayerKind};
use vectorcraft_cdr::{Limits, Warning};
use vectorcraft_doc::{Artboard, ColorMode, Document, Guide, LayerColor, Node, NodeKind};
use super::load::err;
@@ -92,12 +92,12 @@ const MAX_LAYERS: usize = 10_000;
/// Is `bytes` a `.cdr` drawing this importer reads?
pub(super) fn is_cdr(bytes: &[u8]) -> bool {
vectorcraft_cdr::is_cdr(bytes)
craft_cdr::is_cdr(bytes)
}
pub(super) fn import(bytes: &[u8]) -> Result<(Document, Vec<String>)> {
let d = vectorcraft_cdr::read(bytes, Limits::default()).map_err(|e| match e {
vectorcraft_cdr::Error::Version(v) => {
let d = craft_cdr::read(bytes, Limits::default()).map_err(|e| match e {
craft_cdr::Error::Version(v) => {
let version = v / 100;
err(format!("CDR {version} drawings can't be opened: VectorCraft reads versions 1 to 27"))
}
@@ -108,13 +108,13 @@ pub(super) fn import(bytes: &[u8]) -> Result<(Document, Vec<String>)> {
/// Is `bytes` a `.cmx` file, of any byte order or coordinate size?
pub(super) fn is_cmx(bytes: &[u8]) -> bool {
vectorcraft_cdr::is_cmx(bytes)
craft_cdr::is_cmx(bytes)
}
/// A `.cmx` file with 32-bit coordinates: its pages, layers, groups and curves with uniform fills
/// and outlines, mapped as a `.cdr` drawing's are.
pub(super) fn import_cmx(bytes: &[u8]) -> Result<(Document, Vec<String>)> {
let d = vectorcraft_cdr::read_cmx(bytes, Limits::default()).map_err(|why| err(format!("this CMX file can't be read ({why})")))?;
let d = craft_cdr::read_cmx(bytes, Limits::default()).map_err(|why| err(format!("this CMX file can't be read ({why})")))?;
Ok(build(&d, cmx_note, CMX_PAGES_CUT))
}
+2 -2
View File
@@ -4,9 +4,9 @@
use std::collections::HashMap;
use std::sync::Arc;
use craft_cdr::Warning;
use craft_cdr::model::{self as cd, Geometry};
use kurbo::{Affine, BezPath, Point, Rect};
use vectorcraft_cdr::Warning;
use vectorcraft_cdr::model::{self as cd, Geometry};
use vectorcraft_color::swatch::REGISTRATION;
use vectorcraft_color::{BlendMode, Color, Paint, Swatch};
use vectorcraft_doc::appearance::{Appearance, AppearanceItem, Dash, FillLayer, LineCap, LineJoin, StrokeLayer};
+2 -2
View File
@@ -533,11 +533,11 @@ pub const FORMATS: &[Format] = &[
// jxl-oxide reads a JPEG XL file's first frame, which is stored as PNG. Exports don't write it.
reader("jxl", "JPEG XL", &["jxl"], "image/jxl", true),
// `.cdr` drawings of versions 1 to 27 (`WL` files, RIFF files from version 3, and the ZIP packages of 14 on), read by
// `vectorcraft-cdr`; a `.cdt` template opens as a new untitled document. Exports don't write
// `craft-cdr`; a `.cdt` template opens as a new untitled document. Exports don't write
// them.
reader("cdr", "CDR Drawing", &["cdr"], "application/vnd.corel-draw", false), // brand-ok: shared MIME type
reader("cdt", "CDR Template", &["cdt"], "application/vnd.corel-draw", false), // brand-ok: shared MIME type
// `.cmx` exchange files with 32-bit coordinates, read by `vectorcraft-cdr`; exports don't write
// `.cmx` exchange files with 32-bit coordinates, read by `craft-cdr`; exports don't write
// them.
reader("cmx", "CMX", &["cmx"], "image/x-cmx", false),
// QuickDraw pictures, read by `vectorcraft_metafile::import_pict` into paths, type and images.
+1 -1
View File
@@ -2,8 +2,8 @@
//! artboards, layers, guides, live shapes, solid paint and strokes.
use super::*;
use craft_cdr::synth::{self, V, chunk, list};
use serde_json::json;
use vectorcraft_cdr::synth::{self, V, chunk, list};
use vectorcraft_doc::{LiveShape, Node, NodeKind};
fn walk(nodes: &[std::sync::Arc<Node>], out: &mut Vec<Node>) {
+1 -1
View File
@@ -2,8 +2,8 @@
//! paths, solid paint and strokes, with their warnings and refusals.
use super::*;
use craft_cdr::synth_cmx::*;
use serde_json::json;
use vectorcraft_cdr::synth_cmx::*;
use vectorcraft_doc::{Node, NodeKind};
fn paths(nodes: &[std::sync::Arc<Node>], out: &mut Vec<Node>) {
+9 -9
View File
@@ -321,7 +321,7 @@ proptest! {
// The feature sample adds a style table, a clipping container and a lens to the shapes.
let compress = compress && version >= 700;
let mut bytes =
if features { vectorcraft_cdr::synth::feature_sample(version, compress) } else { vectorcraft_cdr::synth::sample(version, compress) };
if features { craft_cdr::synth::feature_sample(version, compress) } else { craft_cdr::synth::sample(version, compress) };
let n = bytes.len();
for (at, b) in edits { bytes[at % n] = b; }
bytes.truncate(cut);
@@ -344,11 +344,11 @@ proptest! {
// The members are edited before they are zipped, so that the edits reach the drawing
// rather than stop at the CRC-32; the archive may then be cut short.
let mut members = if version < 1600 {
vec![vectorcraft_cdr::synth::Member { name: "content/riffData.cdr".into(), data: vectorcraft_cdr::synth::sample(version, true), deflate: false }]
vec![craft_cdr::synth::Member { name: "content/riffData.cdr".into(), data: craft_cdr::synth::sample(version, true), deflate: false }]
} else {
let mut body = vec![vectorcraft_cdr::synth::chunk(b"vrsn", version.to_le_bytes().to_vec())];
body.extend(vectorcraft_cdr::synth::sample_content(version));
vectorcraft_cdr::synth::package16_members(version, &body, false, &[])
let mut body = vec![craft_cdr::synth::chunk(b"vrsn", version.to_le_bytes().to_vec())];
body.extend(craft_cdr::synth::sample_content(version));
craft_cdr::synth::package16_members(version, &body, false, &[])
};
for (m, at, b) in edits {
let k = m % members.len();
@@ -358,7 +358,7 @@ proptest! {
data[at % n] = b;
}
}
let mut bytes = vectorcraft_cdr::synth::zip(&members, b"");
let mut bytes = craft_cdr::synth::zip(&members, b"");
if let Some(cut) = cut {
bytes.truncate(cut);
}
@@ -395,7 +395,7 @@ proptest! {
cut in prop::option::of(0usize..1024),
edits in prop::collection::vec((0usize..8192, any::<u8>()), 0..24),
) {
let mut bytes = vectorcraft_cdr::synth::wl_sample(marker);
let mut bytes = craft_cdr::synth::wl_sample(marker);
let n = bytes.len();
for (at, b) in edits { bytes[at % n] = b; }
if let Some(cut) = cut {
@@ -444,7 +444,7 @@ proptest! {
cut in prop::option::of(12usize..4096),
edits in prop::collection::vec((0usize..8192, any::<u8>()), 0..24),
) {
let mut bytes = vectorcraft_cdr::synth_cmx::sample();
let mut bytes = craft_cdr::synth_cmx::sample();
let n = bytes.len();
for (at, b) in edits { bytes[at % n] = b; }
if let Some(cut) = cut {
@@ -464,7 +464,7 @@ proptest! {
fn cmx_garbage_opens_and_places_without_panicking(tail in prop::collection::vec(any::<u8>(), 0..2048)) {
// A 32-bit header, so the garbage is walked as chunks, tables and instructions.
let mut bytes = b"RIFF".to_vec();
let cont = vectorcraft_cdr::synth_cmx::cont(b'4', 1e-7);
let cont = craft_cdr::synth_cmx::cont(b'4', 1e-7);
bytes.extend(((4 + cont.len() + tail.len()) as u32).to_le_bytes());
bytes.extend(b"CMX1");
bytes.extend(cont);
+1 -1
View File
@@ -19,7 +19,7 @@ nothing below L6 depends on a UI toolkit (egui, eframe, winit, rfd). Table: `xta
| Layer | Crates | Role |
|---|---|---|
| L0 | `geom`, `color`; `affinity`, `cdr` (standalone, no workspace deps) | curves and transforms (on `kurbo`), colour models, ICC and conversions; the Affinity and `.cdr`/`.cmx` readers |
| L0 | `geom`, `color`; `affinity` (standalone, no workspace deps) | curves and transforms (on `kurbo`), colour models, ICC and conversions; the Affinity reader (CDR/CMX moved to `craft-cdr`) |
| L1 | `doc` | the document model: artboards, layers, objects, appearance, text, symbols; pure data + serde, structural sharing |
| L2 | `pathops`, `brush`, `trace`, `text`, `effects`, `plugins`, `three-d` | booleans/Shape Builder/offset/outline; brushes; Image Trace; fonts, shaping (HarfRust, skrifa), bidi and layout; live effects and the pixel-filter pipeline; sandboxed WebAssembly plug-ins (wasmi); 3D surfaces of revolution, projection and shading (`three-d`, on `geom` only) |
| L3 | `render`, `svg`, `pdf`, `format`, `eps`, `cad`, `metafile` | document to pixels (`vello_cpu`, multithreaded); SVG, PDF, native JSON, EPS/PostScript (with its own interpreter), DXF, EMF/WMF readers and writers |
+2 -2
View File
@@ -335,8 +335,8 @@ Gradient meshes in the editing data keep each point's own color where a patch's
| PICT | open, place (legacy) | yes (versions 1 and 2: shapes, lines, regions, text, bitmaps, pixel maps and QuickTime JPEG images; placed as one group clipped to the picture's frame) | no | `.pct`, `.pic` and `.pict`; a version 2 picture also opens by its content; a two-color pattern fills with its average color; inverted shapes, transfer modes other than a copy and QuickTime images in other formats come back as warnings; a picture cut short keeps what came before it; tests in `crates/metafile/src/tests/pict.rs`, `crates/engine/src/cmd/fileio/tests_pict.rs` and `crates/engine/tests/import_fuzz.rs` |
| Pixar PXR | open, place (legacy) | yes (any set of the R, G, B and A channels in 8 or 12 bits, dumped or run-length encoded, in tiles; R alone is gray; alpha matted to black or unassociated) | no | recognized by its magic number; 12-bit samples are clamped to 0.0 to 1.0; null tiles are transparent with A and black without; the offsets aren't read, and the image takes the default resolution; a file cut short, with header values or packets the format doesn't define, or past the pixel allowance is refused with a message; tested on synthetic files only; tests in `crates/engine/src/cmd/fileio/tests_pxrread.rs` and `crates/engine/tests/import_fuzz.rs` |
| FreeHand `.fh*` | open (legacy) | no | no | |
| `.cdr` drawings | open | yes (versions 1 to 27, the `WL` files of versions 1 and 2 and the ZIP packages of versions 14 on included: pages, layers, guidelines, groups, clipping containers, curves, paths, rectangles, ellipses, arcs, polygons, uniform fills and outlines, from the object's style where it has none of its own; hidden and locked layers, groups and objects; the winding flag as the nonzero fill rule; uniform transparency of version 13 on as opacity and blend mode; text, bitmaps, blends, contours, brush strokes, fountain, pattern, texture and PostScript fills and arrowheads are left out with a warning, and lenses, other transparency and merge modes without a blend mode are not applied, with a warning; versions 1 and 2 open as one page and one layer without groups, arcs or pies; version 3 envelopes are not applied, so the objects and groups under one keep their outlines and matrices, with a warning; encrypted, ZIP64 and split packages are refused) | no | `.cdt` templates open as new untitled documents; File › Place reads both; after an open with a warning, an export or Save As to the drawing's own path needs `acknowledgeLoss: true`; record layouts and their sources in `crates/cdr/PROVENANCE.md`; synthetic test files only; tests in `crates/cdr/tests/it/read.rs`, `crates/engine/src/cmd/fileio/tests_cdr.rs` and `crates/engine/tests/import_fuzz.rs` |
| `.cmx` exchange files | | yes (files with 32-bit coordinates: pages, layers, groups, curves, uniform fills and outlines with their width, color, caps, joins and dashes; text, images, rectangles, ellipses, clipping paths, other fills and arrowheads are left out with a warning, and lenses are not applied, with a warning; big-endian files and files with 16-bit coordinates are refused) | no | File › Place reads them too; after an open with a warning, an export or Save As to the file's own path needs `acknowledgeLoss: true`; layouts and their sources in `crates/cdr/PROVENANCE.md` (R53 to R63); synthetic test files only; tests in `crates/cdr/tests/it/cmx.rs`, `crates/engine/src/cmd/fileio/tests_cmx.rs` and `crates/engine/tests/import_fuzz.rs` |
| `.cdr` drawings | open | yes (versions 1 to 27, the `WL` files of versions 1 and 2 and the ZIP packages of versions 14 on included: pages, layers, guidelines, groups, clipping containers, curves, paths, rectangles, ellipses, arcs, polygons, uniform fills and outlines, from the object's style where it has none of its own; hidden and locked layers, groups and objects; the winding flag as the nonzero fill rule; uniform transparency of version 13 on as opacity and blend mode; text, bitmaps, blends, contours, brush strokes, fountain, pattern, texture and PostScript fills and arrowheads are left out with a warning, and lenses, other transparency and merge modes without a blend mode are not applied, with a warning; versions 1 and 2 open as one page and one layer without groups, arcs or pies; version 3 envelopes are not applied, so the objects and groups under one keep their outlines and matrices, with a warning; encrypted, ZIP64 and split packages are refused) | no | `.cdt` templates open as new untitled documents; File › Place reads both; after an open with a warning, an export or Save As to the drawing's own path needs `acknowledgeLoss: true`; record layouts and their sources in `craft-cdr` (`storytold/craft-libs@9b28b56bc7`, `crates/cdr/PROVENANCE.md`); synthetic test files only; tests in `craft-cdr` `crates/cdr/tests/it/read.rs`, `crates/engine/src/cmd/fileio/tests_cdr.rs` and `crates/engine/tests/import_fuzz.rs` |
| `.cmx` exchange files | | yes (files with 32-bit coordinates: pages, layers, groups, curves, uniform fills and outlines with their width, color, caps, joins and dashes; text, images, rectangles, ellipses, clipping paths, other fills and arrowheads are left out with a warning, and lenses are not applied, with a warning; big-endian files and files with 16-bit coordinates are refused) | no | File › Place reads them too; after an open with a warning, an export or Save As to the file's own path needs `acknowledgeLoss: true`; layouts and their sources in `craft-cdr` (`storytold/craft-libs@9b28b56bc7`, `crates/cdr/PROVENANCE.md`, R53 to R63); synthetic test files only; tests in `craft-cdr` `crates/cdr/tests/it/cmx.rs`, `crates/engine/src/cmd/fileio/tests_cmx.rs` and `crates/engine/tests/import_fuzz.rs` |
| Text `.txt` | place, export | place (Text Import Options) | yes | place reads Unicode and ANSI, and Shift JIS, GB2312, Chinese Big 5, Cyrillic, GB18030, Greek, Turkish, Baltic and Central European through the WHATWG Encoding Standard's decoders (VectorCraft's own mapping); `tests/textimport.rs`, `place/text.rs`; fuzzed (`text_import_fuzz.rs`) |
| RTF `.rtf` | place | place (area type with fonts, size, bold, italic, underline, strikethrough, caps, superscript and subscript, color, alignment, indents and paragraph spacing) | no | `tests/textimport.rs`, `place/rtf.rs`; fuzzed (`text_import_fuzz.rs`); `\'hh` bytes read as Windows-1252 or Mac Roman only |
| Word `.docx` | place | place (area type with the document's styles and its fonts, size, bold, italic, underline, strikethrough, caps, superscript and subscript, color, alignment, indents and paragraph spacing) | no | `tests/textimport.rs`, `place/docx.rs`; fuzzed (`text_import_fuzz.rs`); list numbers, pictures and text boxes are left out |
+2 -2
View File
@@ -2354,8 +2354,8 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
- DXF export writes a path of straight segments and circular arcs (a slot, a D shape, a rounded rectangle, a pie) as one polyline whose vertices carry a bulge (group 42) for each arc: an LWPOLYLINE in R14 and later, a POLYLINE with VERTEX entities in R12 and R13, closed when the path is closed, and it reads back as the same outline (#1299, `crates/cad/src/tests.rs`). Such a path was written as one SPLINE (a flattened polyline in R12); a path with any other curve still is. A shallow curve becomes an ARC or a bulge only when it lies on the circle within 5e-4 of its own extent as well as of the radius, and the drawing extents (`$EXTMIN`, `$EXTMAX`) reach the furthest points of every ARC and bulge.
- DXF export with Use Artboards applies live effects and places symbols' art once for all the artboards' drawings instead of once for each drawing; each drawing's bytes, linked images, warnings and notes are the same as before (`drawings_apply_the_live_effects_once_and_match_drawings_written_alone`, `each_artboard_s_drawing_is_the_drawing_of_that_artboard_alone`).
- Affinity documents in (AF.1–AF.4): `.af` (Affinity 3) and `.afdesign`/`.afphoto`/`.afpub` (Affinity 1 and 2, container versions 8–12) open and place as editable art: layers and sublayers, groups (pass-through or isolated), artboards (with their names and backgrounds) and Publisher pages side by side, curves with live corners, parametric shapes (rectangles with corner radii, ellipses, polygons, stars, pies, triangles, trapezoids), compound shapes, solid/linear/elliptical gradient fills and strokes (weight, dashes, alignment, scale-with-object), clipping by nesting, vector and pixel masks, artistic and frame text with fonts, sizes, tracking, leading and alignment, placed images (their original JPEG/PNG) and pixel layers (8/16-bit RGB, CMYK), opacity, visibility, locking and blend modes, at the document's resolution in points. Effects, adjustments, brushes and pressure profiles, transparency gradients, master pages, symbol instances (imported as their cached picture), special shapes (cloud, heart, cog…, imported as ellipses) and Affinity-only blend modes are named in the import warning. A file whose native data can't be read opens as its embedded preview with the reason, and that preview can't be placed. Save never writes back over the Affinity file and there is no Affinity export. AF.5 (from DesignCraft's import, storytold/designcraft#291) adds master pages (on a locked layer behind the pages that show them), tables (area type per cell and a line per edge), each paragraph's alignment, indents, spacing and leading, horizontal text scale, outlined text, frame text sized by its text scale, drop shadows and outer glows as live effects (inner shadows as inner glows), outline effects as strokes, colour and gradient overlays baked into the paint, embedded Affinity documents as editable content (their artboards don't become artboards), pixel layers over 64 MP at a reduced resolution and HEIC photos from their stored pixels; automatic leading (size plus the font's line gap) fitted on thumbnails; underlines and strikethrough; strokes whose style is None (every shape stores one) left out, which also brings 6 public files closer to their thumbnails; line breaks inside a paragraph; table cell text centred as Affinity centres it, also where it is taller than its cell; CMYK pixel layers converted through the document's embedded CMYK profile (relative colorimetric with black-point compensation, as each layer's colour settings name), or kept as CMYK images when there is none; outline effects on stroked shapes around their stroke; artistic text whose paragraphs align differently aligned within its longest line, a frame's first baseline at cap height, and frames whose last lines' descenders hang out made tall enough to show them (all measured on a local document's own PDF export: baselines match to 0.1 pt); a local 56-artboard document's mean thumbnail difference went from 16.2 to 11.4, and its pages' mean difference from the owner's PDF export from 12.9 to 9.3. AF.4 adds Affinity 3 artboard recognition and actual-outline clipping, source-backed JPEG/PNG raster tiles, Unicode text-run recovery, stored fallback/exact installed fonts, OpenType feature flags and compound-geometry limits. 51 public CC0/MIT/Apache-2.0 files (33 current `.af`), pinned and sha256-verified (`cargo xtask corpus --affinity`), test native retention and every-board native/SVG/PDF/PSD output for current files; selected files compare their saved thumbnails. No Affinity reopen or independent paired PSD oracle was available; [source audit and complex-font gaps](affinity-validation.md); [scope, provenance and limits](../crates/affinity/README.md).
- `.cdr` drawings of versions 1 to 27 open and place, and `.cdt` templates open as new untitled documents. `vectorcraft-cdr` reads the `WL` files of versions 1 and 2 (one page and one layer of rectangles, whole ellipses and curves with uniform fills and outlines), the RIFF chunk tree of versions 3 on and its compressed lists, and the ZIP packages of versions 14 on with the data streams of versions 16 on, and the importer maps pages to artboards side by side, layers by name, the master page's guidelines to guides on every page, groups, clipping containers (as clipping groups), curves and paths, rectangles (live, with each corner's radius), ellipses (live), arcs and polygons, uniform fills in CMYK, CMY, RGB, gray and registration, and outlines with their width (0.25 pt for a width of 0), caps, joins and dashes (behind the fill, or scaled with the object's matrix, where the file says so), an object without a fill or outline of its own taking its style's, hidden and locked layers, groups and objects, the winding flag as the nonzero fill rule, and a uniform transparency of version 13 and later as the object's opacity and blend mode. A library color stored with its name and values (version 13 and later, in a fill or an outline) becomes a spot swatch with its tint; one stored only by its number opens as a black spot color named by its palette and number, with a warning. Text, bitmaps, blends, contours, brush strokes, fountain, pattern, texture and PostScript fills, arrowheads, lenses, other transparency and the envelopes of version 3 are left out with a warning, and encrypted, ZIP64 and split packages are refused with a message. Every record layout has a source in `crates/cdr/PROVENANCE.md`. Reading is bounded by limits on input size, inflated size, package members, nesting, chunks, objects, coordinates and dashes, where an outline's dashes count for every shape that uses it (`crates/cdr/tests/it/read.rs`, `crates/engine/src/cmd/fileio/tests_cdr.rs`, `crates/engine/tests/import_fuzz.rs`).
- `.cmx` exchange files with 32-bit coordinates open and place: `vectorcraft-cdr` reads their color, pen, line type, dash and outline tables and each page's instructions, and the importer maps pages, layers (a layer that holds nothing is left out), groups and curves, with uniform fills and outlines, as it maps a `.cdr` drawing's. Text, images, rectangles, ellipses, clipping paths, other fills, arrowheads and lenses are named in the warnings, and big-endian files and files with 16-bit coordinates are refused with a message (`crates/cdr/tests/it/cmx.rs`, `crates/engine/src/cmd/fileio/tests_cmx.rs`, `crates/engine/tests/import_fuzz.rs`).
- `.cdr` drawings of versions 1 to 27 open and place, and `.cdt` templates open as new untitled documents. `craft-cdr` reads the `WL` files of versions 1 and 2 (one page and one layer of rectangles, whole ellipses and curves with uniform fills and outlines), the RIFF chunk tree of versions 3 on and its compressed lists, and the ZIP packages of versions 14 on with the data streams of versions 16 on, and the importer maps pages to artboards side by side, layers by name, the master page's guidelines to guides on every page, groups, clipping containers (as clipping groups), curves and paths, rectangles (live, with each corner's radius), ellipses (live), arcs and polygons, uniform fills in CMYK, CMY, RGB, gray and registration, and outlines with their width (0.25 pt for a width of 0), caps, joins and dashes (behind the fill, or scaled with the object's matrix, where the file says so), an object without a fill or outline of its own taking its style's, hidden and locked layers, groups and objects, the winding flag as the nonzero fill rule, and a uniform transparency of version 13 and later as the object's opacity and blend mode. A library color stored with its name and values (version 13 and later, in a fill or an outline) becomes a spot swatch with its tint; one stored only by its number opens as a black spot color named by its palette and number, with a warning. Text, bitmaps, blends, contours, brush strokes, fountain, pattern, texture and PostScript fills, arrowheads, lenses, other transparency and the envelopes of version 3 are left out with a warning, and encrypted, ZIP64 and split packages are refused with a message. Every record layout has a source in `craft-cdr` (`storytold/craft-libs@9b28b56bc7`, `crates/cdr/PROVENANCE.md`). Reading is bounded by limits on input size, inflated size, package members, nesting, chunks, objects, coordinates and dashes, where an outline's dashes count for every shape that uses it (`craft-cdr` `crates/cdr/tests/it/read.rs`, `crates/engine/src/cmd/fileio/tests_cdr.rs`, `crates/engine/tests/import_fuzz.rs`).
- `.cmx` exchange files with 32-bit coordinates open and place: `craft-cdr` reads their color, pen, line type, dash and outline tables and each page's instructions, and the importer maps pages, layers (a layer that holds nothing is left out), groups and curves, with uniform fills and outlines, as it maps a `.cdr` drawing's. Text, images, rectangles, ellipses, clipping paths, other fills, arrowheads and lenses are named in the warnings, and big-endian files and files with 16-bit coordinates are refused with a message (`craft-cdr` `storytold/craft-libs@9b28b56bc7` `crates/cdr/tests/it/cmx.rs`, `crates/engine/src/cmd/fileio/tests_cmx.rs`, `crates/engine/tests/import_fuzz.rs`).
- Placed documents: File › Place of a `.vectorcraft` file links to it by default (`file.place`'s `link`): one locked object showing an artboard of the document (or its art's bounds), read the way placing it without Link reads it, its symbols, patterns and images kept apart from the document's; without Link (or from bytes, not a file) it is an editable copy as before. It stays vectors in every output (SVG, PDF, EPS, EMF, DXF), and so do placed documents inside it, read from their own files up to 8 levels deep (documents that place each other stop there). On screen they draw from bitmaps cached per file and zoom step, shared by every copy and made in the background (a placeholder until ready), so a sheet of them redraws in about a millisecond; exports and prints draw them exactly. Like linked images, a save keeps only a preview of each (JPEG when opaque) unless Include Linked Files; output, and zooming past the preview, read the file again, falling back to the preview with a warning when it is gone or changed. Saves for older versions write them as plain art. Links check, update, relink, Update Links on open, Link Info (the artboard's size), Placement Options, Break Link (also Embed, Object › Expand: the editable copy placing without Link gives, its resources joining the document), Edit Original (the document in a new tab) and the Links panel cover them; saving a document updates the open documents that place it. The native format (v4) keeps data of 8 KB or more after the JSON instead of base64 in it.
- Placed documents' bitmaps on screen: when a bitmap made in the background is ready, the desktop app renders the canvas again only where the objects that show its file are, when the frame shown was rendered on the UI thread and that part is at most half the canvas. Bitmaps drawn or made since a frame began are kept for that frame past the 512 MiB budget, up to 2 GiB, so a view showing more than the budget does not make them again in every frame. A bitmap that would take them past 2 GiB is not kept, and its file draws exactly at that zoom. A bitmap that can't be made (the file can't be read and there is no preview) shows the light placeholder and is not asked for again. Each ready bitmap used to render the whole canvas again, and bitmaps past the budget and bitmaps that could not be made were asked for again in every frame (`crates/render/src/tests/placed_document.rs`).
- Linked PDF and `.ai` pages: File › Place with Link (the default) places a page of a PDF, `.ai` or `.ait` file read as PDF pages as a placed document, as it links an image, the page and its box (`crop`) kept with the link: Links check, update and relink it, Break Link and Object › Expand give the group placing it without Link gives, every output draws the page's vectors, and Package copies the file. Without Link, or with a password or `textAs: "outlines"`, the page is embedded. An EPS file, a PostScript file or a PostScript `.ai` placed from a file with Link is a placed document the same way, showing the art placing it without Link gives (clipped to its bounding box, or its art's bounds with `crop: "bounding"`); Links lists it as `EPS` or `PostScript`, and a save, Package, Break Link and Object › Expand treat it as they treat a placed PDF page. Package also copies the files that the native document of an EPS file written by VectorCraft links, beside the EPS file's copy, which finds them there by name. Placing one keeps the file linked rather than embedding it, as [the help page](https://helpx.adobe.com/illustrator/desktop/add-and-import-files/import-other-file-types/eps-and-dcs-file-import-in-illustrator.html) describes; a DCS file stays a linked image (`crates/engine/src/tests/placed_document.rs`, `crates/engine/src/tests/package.rs`).
-1
View File
@@ -65,7 +65,6 @@ pub const TABLE: &[(&str, Class)] = &[
("scriptcheck", Class::Standalone),
("js", Class::Standalone),
("apischema", Class::Standalone),
("cdr", Class::Standalone),
];
/// Explicit orderings *within* a layer (earlier may be used by later).