Mirrors/pdfcraft
1
0 Fork 0
mirror of https://github.com/storytold/pdfcraft.git synced 2026-11-12 01:11:19 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'upstream/main' into pk-6125m

Browse Source
This commit is contained in:
FredApps committed 2026-11-04 18:50:24 +01:00
2 parents 6cb3dbe8cc 7d17aea92c
commit 8d7eb74ff7
74 files changed
+12936 -405
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

ATTRIBUTION.md
+2 -1
View File
@@ -4,7 +4,7 @@
Every asset PdfCraft includes, bundles or uses to build its published material, with its author, source and licence. The policy is in [AGENTS.md](AGENTS.md) §1. The machine-readable list, with the SHA-256 of every asset, is [ATTRIBUTION.toml](ATTRIBUTION.toml). Licence texts are kept beside the assets and summarised in [NOTICE](NOTICE).
## In this repository (255)
## In this repository (256)
| Asset | Title | Author | Licence | Source | Used for |
|---|---|---|---|---|---|
@@ -203,6 +203,7 @@ Every asset PdfCraft includes, bundles or uses to build its published material,
| `vendor/hayro-interpret/assets/FoxitSymbol.pfb` | FoxitSymbol (standard-14 substitute font) | Foxit Software Inc. / PDFium Authors | BSD-3-Clause | https://pdfium.googlesource.com/pdfium (via hayro-interpret 0.7.0 assets/) | Renders non-embedded standard-14 fonts (vendored hayro-interpret) |
| `vendor/hayro-interpret/assets/CGATS001Compat-v2-micro.icc` | CGATS001Compat v2 micro ICC profile | Clinton Ingram (saucecontrol/Compact-ICC-Profiles) | CC0-1.0 | https://github.com/saucecontrol/Compact-ICC-Profiles | Default CMYK colour conversion (vendored hayro-interpret) |
| `crates/fonts/src/std14_metrics.rs` | Standard-14 font advance widths and encodings (as Rust tables) | Adobe (Core14 AFM metrics, PDF specification encodings); tables generated by the PdfCraft contributors | MIT OR Apache-2.0 | ISO 32000-2 Annex D and the Adobe Core14 AFM metrics. Generated by joining the published WinAnsi, Symbol and ZapfDingbats encodings (code to glyph name) with the per-glyph advance widths, then spot-checked against the specification by hand in the tests of crates/fonts/src/std14.rs. Data only: the code that reads these tables lives in std14.rs, so that ordinary edits do not churn this file's hash. | Advance widths for the fourteen standard fonts, which a PDF may name without embedding. Non-visual data, not a typeface: the item AGENTS.md 1.1 permits, held first-party so generated appearance streams and the renderer agree. |
| `crates/prc/src/acof/table.rs` | PRC Double prefix-code table (as a Rust table) | Kristof Ralovich (prc-rs); the code table itself is defined by the PRC format (ISO 14739-1, working draft clause 11.17.2) | MIT | Rows taken from prc-rs src/double.rs at commit 287b671bb5b31b05efb5ec1b98f7c359b9e4dd7d (https://github.com/ralovich/prc-rs), mechanically reformatted into (code length, code, entry) tuples; checked to be a complete prefix code by the tests in crates/prc/src/acof.rs. Data only: the code that reads the table lives in acof.rs. The MIT notice is kept in the file header. | Decodes every PRC Double (coordinates, transforms, colours) in 3D annotations' PRC streams. Non-visual data. |
| `vendor/hayro-cmap/assets/cmaps.brotli` | Adobe CMap resources (predefined CJK CMaps) | Adobe | BSD-3-Clause | https://github.com/adobe-type-tools/cmap-resources (via hayro-cmap 0.1.0 assets/) | Character-code mapping tables required to read CJK PDFs. Non-visual data, allowed by AGENTS.md §1.1 |
| `docs/brand/artcraft-logo-white.png` | ArtCraft brand: artcraft-logo-white | ArtCraft Team | LicenseRef-Storyteller-Trademark | ArtCraft Team brand assets (provided by the project owner, 2026-10-01; identical copies in storytold/photocraft) | ArtCraft branding next to the community links (About dialog, Help menu, home screen) and in docs. ArtCraft Team trademark, not open source; may be used only unmodified within PdfCraft; forks and modified versions must remove it. |
| `docs/brand/artcraft-logo-white.svg` | ArtCraft brand: artcraft-logo-white | ArtCraft Team | LicenseRef-Storyteller-Trademark | ArtCraft Team brand assets (provided by the project owner, 2026-10-01; identical copies in storytold/photocraft) | ArtCraft branding next to the community links (About dialog, Help menu, home screen) and in docs. ArtCraft Team trademark, not open source; may be used only unmodified within PdfCraft; forks and modified versions must remove it. |
ATTRIBUTION.toml
+11
View File
@@ -2156,6 +2156,17 @@ adobe_data = true
usage = "Advance widths for the fourteen standard fonts, which a PDF may name without embedding. Non-visual data, not a typeface: the item AGENTS.md 1.1 permits, held first-party so generated appearance streams and the renderer agree."
sha256 = "f225e0b044875b8fa6375b6b5ad935f0d99fcc1ad03ecf9f0baae2cedbfca4d2"
[[asset]]
path = "crates/prc/src/acof/table.rs"
title = "PRC Double prefix-code table (as a Rust table)"
author = "Kristof Ralovich (prc-rs); the code table itself is defined by the PRC format (ISO 14739-1, working draft clause 11.17.2)"
source = "Rows taken from prc-rs src/double.rs at commit 287b671bb5b31b05efb5ec1b98f7c359b9e4dd7d (https://github.com/ralovich/prc-rs), mechanically reformatted into (code length, code, entry) tuples; checked to be a complete prefix code by the tests in crates/prc/src/acof.rs. Data only: the code that reads the table lives in acof.rs. The MIT notice is kept in the file header."
licence = "MIT"
licence_file = "licenses/prc-rs-LICENSE.txt"
kind = "data"
usage = "Decodes every PRC Double (coordinates, transforms, colours) in 3D annotations' PRC streams. Non-visual data."
sha256 = "8e705c5cde6a3ef778e8aca69759e38845b228b3f7f12949e587b19855d2114c"
[[bundled]]
crate = "epaint_default_fonts"
version = "0.37.0"
Cargo.lock
Generated
+9
View File
@@ -4551,6 +4551,15 @@ dependencies = [
"zbus",
]
[[package]]
name = "pdfcraft-prc"
version = "0.18.1"
dependencies = [
"flate2",
"proptest",
"thiserror 2.0.21",
]
[[package]]
name = "pdfcraft-preflight"
version = "0.18.1"
LICENSES.toml
+7
View File
@@ -88,6 +88,13 @@ destination = "licenses/egui-emoji-icon-font-mit-license.txt"
sha256 = "b9d2c1d909aa149996fd4c91dcb92b2362a04431640c1d200959da94caf8cde1"
origin = "https://raw.githubusercontent.com/emilk/egui/0.36.2/crates/epaint_default_fonts/fonts/emoji-icon-font-mit-license.txt"
[[document]]
source = "licenses/prc-rs-LICENSE.txt"
licences = ["MIT"]
destination = "licenses/prc-rs-LICENSE.txt"
sha256 = "ddb846513d92153d8fa16b18ed3e7c86953a582f0d2f49f02b29f1bd569dac58"
origin = "https://raw.githubusercontent.com/ralovich/prc-rs/287b671bb5b31b05efb5ec1b98f7c359b9e4dd7d/LICENSE"
[[document]]
source = "vendor/hayro-interpret/LICENSE-APACHE"
licences = ["Apache-2.0"]
ROADMAP.md
+2
View File
@@ -223,6 +223,8 @@ Ranked; detail and the full milestone table in [docs/roadmap.md](docs/roadmap.md
## Progress log
- **2026-11-03 (M11, shared JBIG2 dictionary):** With Monochrome Images set to JBIG2, Optimize has up to 16 JBIG2 images share one symbol dictionary (`/JBIG2Globals`), the letters found on more than one page stored once, when that is smaller (`pdfcraft_filters::encode_jbig2_shared`). Eight pages of 10 pt text rendered at 300 dpi take 41% less in Helvetica and 42% in Times than coded alone, 10% in Courier; groups of 16 save 45%, of 32 only 47%. Only images redaction can store again without the dictionary share one (image masks and DeviceGray named directly, at most 64 Mi pixels), and redacting one stores the rest of its group so, which the group bounds to 15.
- **2026-11-03 (M5, #5850 review):** Resolve indirect IT when recognizing typewriter contents and Fill & Sign marks. Comment listing and property lookup retain their existing direct-Subtype behavior. A real double-click Edit composer preserves the typewriter’s text as written; ordinary comment edits keep trimming. Regressions cover direct Subtype with indirect intent, save/reopen, raw posted contents and same-index comments on different pages. The existing live-movement test now commits its setup with an outside click rather than Enter. Estimates unchanged.
- **2026-11-03 (M5, #5850):** Fill & Sign Enter inserts a line break in a growing editor; clicking outside commits and Escape cancels. Nonempty text keeps leading, internal and trailing line breaks. The headless fill_sign_add path sizes its typewriter box for the same wrapped lines so saved appearances show every row. Production-order keyboard and engine save/reopen/render regressions exercise the UI and headless callers. Estimates unchanged.
crates/automation/src/tools.rs
+1 -1
View File
@@ -1503,7 +1503,7 @@ pub fn tools() -> Vec<ToolDef> {
.with(schema(json!({ "doc": doc() }), &["doc"])),
t("doc_open_revision", "Open a revision", "Open saved revision `revision` (1 = the oldest) of a document as a new, unsaved document, to see the file as it was then.")
.with(schema(json!({ "doc": doc(), "revision": { "type": "integer", "minimum": 1 } }), &["doc", "revision"])),
t("doc_optimize", "Optimize PDF", "Write an optimized copy to `path` (Acrobat's PDF Optimizer). preset: standard (default; Reduce File Size's choices) or mobile (images to 96 ppi above 144, JPEG high quality); the options below change it. compatibility: retain (default; keeps the document's version, or 1.5 when object streams are written), 1.4, 1.5, 1.6, 1.7 or 2.0. merge_fragments (default true) first puts a page picture drawn as many stacked image strips (as some PDF printers write it) back together into one image, so it can be resampled (merged_images, fragments_merged). color / gray: { downsample, ppi, above_ppi, compression: jpeg|zip|retain, quality 1–100 } (defaults: downsample to 150 ppi above 225, JPEG 60). mono: { downsample, ppi, above_ppi, compression: ccitt_g4|jbig2|retain } for black-and-white images and image masks (default: averaged down to 300 ppi above 450 ppi, counted in images_resampled; stored losslessly as CCITT Group 4 or JBIG2 (or 1-bit Flate, once resampled or packed from more bits) when that is smaller, Group 3 fax images, JBIG2 images, black-and-white RGB and indexed images using only palette entries 0 and 1 among them, counted in images_recompressed; retain resamples only, a CCITT image staying CCITT, a JBIG2 image JBIG2 and any other becoming Flate). Images past what one run may decode stay as they are, counted in images_refused; streams it only stores with Flate past that stay LZW, uncounted. Images are measured where pages draw them and replaced only when smaller. discard_*: thumbnails (default true), alternate_images (true), tags, print_settings; flate_unencoded (true); object_streams (default true; always off for 1.4); lzw_to_flate (true) decodes LZW streams and stores them with Flate instead, leaving any it cannot decode unchanged (lzw_streams counts the streams converted); remove_invalid_links and remove_unreferenced_dests (true); images and forms the pages list but never draw are always dropped (unused_xobjects). discard: Remove Hidden Information categories (metadata, attachments, comments, form-fields, hidden-text, hidden-layers, bookmarks, links-actions-scripts, private-data). Signed documents are refused. The open document is unchanged.")
t("doc_optimize", "Optimize PDF", "Write an optimized copy to `path` (Acrobat's PDF Optimizer). preset: standard (default; Reduce File Size's choices) or mobile (images to 96 ppi above 144, JPEG high quality); the options below change it. compatibility: retain (default; keeps the document's version, or 1.5 when object streams are written), 1.4, 1.5, 1.6, 1.7 or 2.0. merge_fragments (default true) first puts a page picture drawn as many stacked image strips (as some PDF printers write it) back together into one image, so it can be resampled (merged_images, fragments_merged). color / gray: { downsample, ppi, above_ppi, compression: jpeg|zip|retain, quality 1–100 } (defaults: downsample to 150 ppi above 225, JPEG 60). mono: { downsample, ppi, above_ppi, compression: ccitt_g4|jbig2|retain } for black-and-white images and image masks (default: averaged down to 300 ppi above 450 ppi, counted in images_resampled; stored losslessly as CCITT Group 4 or JBIG2 (or 1-bit Flate, once resampled or packed from more bits) when that is smaller, up to 16 JBIG2 images sharing one symbol dictionary (/JBIG2Globals) where that is smaller still (image masks and DeviceGray images named directly, of at most 64 Mi pixels, which redaction can store again without it), Group 3 fax images, JBIG2 images, black-and-white RGB and indexed images using only palette entries 0 and 1 among them, counted in images_recompressed; retain resamples only, a CCITT image staying CCITT, a JBIG2 image JBIG2 and any other becoming Flate). Images past what one run may decode stay as they are, counted in images_refused; streams it only stores with Flate past that stay LZW, uncounted. Images are measured where pages draw them and replaced only when smaller. discard_*: thumbnails (default true), alternate_images (true), tags, print_settings; flate_unencoded (true); object_streams (default true; always off for 1.4); lzw_to_flate (true) decodes LZW streams and stores them with Flate instead, leaving any it cannot decode unchanged (lzw_streams counts the streams converted); remove_invalid_links and remove_unreferenced_dests (true); images and forms the pages list but never draw are always dropped (unused_xobjects). discard: Remove Hidden Information categories (metadata, attachments, comments, form-fields, hidden-text, hidden-layers, bookmarks, links-actions-scripts, private-data). Signed documents are refused. The open document is unchanged.")
.cmd("optimize.advanced")
.with(schema(
json!({
crates/cos/src/budget.rs
+6
View File
@@ -25,6 +25,12 @@ pub const MAX_PAGE_DECODED: usize = 256 << 20;
/// Form XObjects one page's content walk may enter, each entry counted again.
pub const MAX_PAGE_FORMS: usize = 50_000;
/// The most pixels an image redaction decodes, to clear the ones under a mark or to store again
/// without the `/JBIG2Globals` it shares with a redacted image (`pdfcraft_redact`). Optimize has
/// JBIG2 images share a dictionary only within it (`pdfcraft_optimize`), so that redaction can
/// store each of them again: one it couldn't would refuse the redaction.
pub const MAX_REDACTED_IMAGE_PIXELS: u64 = 64 << 20;
/// The steps a sample of a JPEG costs: a few bytes can hold a page of one grey, and decoding,
/// resampling and storing it took about 20 to 45 ns a sample.
const JPEG_WORK: u64 = 2;
crates/cos/src/document.rs
+5
View File
@@ -19,6 +19,7 @@ mod reader;
mod state;
mod xref;
pub(crate) use objects::Held;
#[cfg(test)]
pub(crate) use reader::find;
#[cfg(test)]
@@ -62,6 +63,10 @@ pub struct Document {
security: Option<Arc<pdfcraft_crypt::SecurityHandler>>,
/// Object number of the `/Encrypt` dictionary (never encrypted itself).
encrypt_num: Option<u32>,
/// What that dictionary and `/ID` refer to, which the key comes from, and so is as stored.
encrypt_members: Arc<HashSet<u32>>,
/// Object numbers a scan of the file didn't find: the file doesn't change, so it never will.
unfound: Arc<Mutex<HashSet<u32>>>,
/// Encryption was added, changed or removed since opening: only a full save can apply it.
encryption_changed: bool,
/// Set by edits that must not leave earlier revisions in the file (redaction).
crates/cos/src/document/objects.rs
+32 -8
View File
@@ -156,12 +156,16 @@ impl Document {
self.try_get(r.num).unwrap_or_else(|_| Arc::new(Object::Null))
}
/// Follow a reference if `o` is one; otherwise return `o` itself.
/// Follow a reference if `o` is one; otherwise return `o` itself. An object can be nothing but
/// a reference to another, which is followed too, up to [`MAX_REFERENCE_HOPS`] of them.
pub fn resolve(&self, o: &Object) -> Arc<Object> {
match o {
Object::Ref(r) => self.get(*r),
other => Arc::new(other.clone()),
let Object::Ref(r) = o else { return Arc::new(o.clone()) };
let mut held = self.get(*r);
for _ in 0..MAX_REFERENCE_HOPS {
let Object::Ref(r) = &*held else { break };
held = self.get(*r);
}
held
}
/// `s` with the `/DecodeParms` its filters use made direct, so [`Stream::decoded`] reads them:
@@ -218,7 +222,7 @@ impl Document {
}
/// `o`, or the object it refers to, without copying either.
fn held<'o>(&self, o: &'o Object) -> Held<'o> {
pub(crate) fn held<'o>(&self, o: &'o Object) -> Held<'o> {
match o {
Object::Ref(_) => Held::Resolved(self.resolve(o)),
o => Held::Direct(o),
@@ -395,6 +399,7 @@ impl Document {
// cycles such as `6 0 obj << /Length 6 0 R >>`. Bound the nesting on every path.
let _guard =
LoadGuard::enter(num).ok_or_else(|| CosError::Syntax { offset: 0, detail: format!("reference cycle while loading object {num}") })?;
let _scope = crate::security::FollowScope::enter();
let obj = self.load(num, 0)?;
let obj = Arc::new(obj);
// The editing cache is bounded like the scan reader's: re-parsing a file-backed view
@@ -562,7 +567,11 @@ impl Document {
let Object::Stream(s) = &*loaded else { return Err(CosError::MissingObject(num)) };
let n = s.dict.int(b"N").unwrap_or(0).clamp(0, 1_000_000) as usize;
let first = usize::try_from(s.dict.int(b"First").unwrap_or(0).max(0)).ok();
let data = s.decoded_within(self.stream_limit)?;
// Its parameters can be given by reference, and can sit in another object stream. A scan of
// the file's object streams comes here without a read around it.
let _scope = crate::security::FollowScope::enter();
let readable = crate::security::following(Cow::Borrowed(s), || self.with_direct_parms(s));
let data = readable.decoded_within(self.stream_limit)?;
let mut lx = Lexer::new(&data, 0);
let mut index = Vec::with_capacity(n);
for _ in 0..n {
@@ -577,8 +586,14 @@ impl Document {
Ok(stm)
}
/// Last-resort lookup: scan the file for `num G obj`.
/// Last-resort lookup: scan the file for `num G obj`. What isn't there is remembered: each miss
/// reads the whole file, and a file can refer to such an object from everywhere.
fn scan_for(&self, num: u32) -> Option<(ObjRef, Object)> {
if self.unfound.lock().is_ok_and(|unfound| unfound.contains(&num)) {
return None;
}
#[cfg(test)]
super::tests::FILE_SCANS.with(|scans| scans.set(scans.get() + 1));
let needle = format!("{num} ");
let data = &self.data;
let mut found = None;
@@ -594,6 +609,11 @@ impl Document {
found = Some((id, o)); // keep the last (newest) definition
}
}
if found.is_none()
&& let Ok(mut unfound) = self.unfound.lock()
{
unfound.insert(num);
}
found
}
@@ -786,9 +806,13 @@ const DECODE_PARMS_KEYS: [&[u8]; 13] = [
b"ColorTransform",
];
/// How many references in a row [`Document::resolve`] follows: enough for any file, and it ends a
/// cycle of them.
const MAX_REFERENCE_HOPS: usize = 32;
/// An object read in place, or the object a reference names as the document holds it: either way
/// nothing is copied ([`Document::held`]).
enum Held<'o> {
pub(crate) enum Held<'o> {
Direct(&'o Object),
Resolved(Arc<Object>),
}
crates/cos/src/document/open.rs
+53 -7
View File
@@ -1,7 +1,11 @@
use super::reader::find;
use super::state::Credentials;
use super::xref::XrefIndex;
use super::{Arc, BTreeMap, CosError, Dict, Document, ObjRef, Object};
use super::{Arc, BTreeMap, CosError, Dict, Document, HashSet, ObjRef, Object};
/// More objects than `/Encrypt` and `/ID` refer to in any file, so that one which refers to the page
/// tree, say, doesn't have a whole document read to open it.
const MAX_ENCRYPT_MEMBERS: usize = 64;
impl Document {
/// A new document with an empty page tree (for split / extract / combine). It has no
@@ -27,6 +31,8 @@ impl Document {
version: "1.7".into(),
security: None,
encrypt_num: None,
encrypt_members: Arc::default(),
unfound: Arc::default(),
encryption_changed: false,
full_save: false,
out_security: None,
@@ -111,6 +117,8 @@ impl Document {
version,
security: None,
encrypt_num: None,
encrypt_members: Arc::default(),
unfound: Arc::default(),
encryption_changed: false,
full_save: false,
out_security: None,
@@ -185,6 +193,8 @@ impl Document {
};
let params = crate::security::encrypt_dict(self, &dict);
let id0 = self.first_id();
// Read here, while nothing is decrypted yet.
let members = self.encryption_members(enc);
let handler = match credentials {
Credentials::Password(password) => Arc::new(pdfcraft_crypt::SecurityHandler::open(params, &id0, *password).map_err(|e| match e {
pdfcraft_crypt::CryptError::WrongPassword if password.is_none() => CosError::NeedsPassword,
@@ -197,6 +207,7 @@ impl Document {
};
self.security = Some(handler);
self.encrypt_num = num;
self.encrypt_members = Arc::new(members);
// Objects read while locating the catalog were read before decryption was possible.
self.cache = Arc::default();
self.objstms = Arc::default();
@@ -205,10 +216,42 @@ impl Document {
/// The first file identifier, part of the encryption key (empty when there is none).
fn first_id(&self) -> Vec<u8> {
match self.trailer.get(b"ID") {
Some(Object::Array(a)) => a.first().and_then(|s| s.as_string()).map(|s| s.bytes.clone()).unwrap_or_default(),
_ => Vec::new(),
let id = self.trailer.get(b"ID").map(|id| self.resolve(id));
let first = id.as_deref().and_then(Object::as_array).and_then(|a| a.first()).map(|s| self.resolve(s));
first.as_deref().and_then(Object::as_string).map(|s| s.bytes.clone()).unwrap_or_default()
}
/// The objects `/Encrypt`, given as `enc`, and `/ID` refer to, the ones they refer to, and so
/// on, up to [`MAX_ENCRYPT_MEMBERS`]. Their strings aren't encrypted (ISO 32000-2 §7.6.2): the
/// key is made from them, so they have to read as stored, and stay so. A number with no object
/// behind it, and a stream, which those dictionaries never hold, isn't one: an object added
/// under that number later, or a page's content a hostile `/Encrypt` names, is encrypted.
fn encryption_members(&self, enc: &Object) -> HashSet<u32> {
let mut pending = Vec::new();
crate::writer::collect_refs(enc, &mut |r| pending.push(r));
if let Some(id) = self.trailer.get(b"ID") {
crate::writer::collect_refs(id, &mut |r| pending.push(r));
}
let mut members = HashSet::new();
while let Some(r) = pending.pop() {
if members.len() >= MAX_ENCRYPT_MEMBERS || members.contains(&r.num) {
continue;
}
let held = self.get(r);
if matches!(&*held, Object::Null | Object::Stream(_)) {
continue;
}
members.insert(r.num);
crate::writer::collect_refs(&held, &mut |x| pending.push(x));
}
members
}
/// Whether object `num` is written as it is held, being one of [`Document::encryption_members`],
/// unedited, and the save writing the same `/Encrypt`. What was edited or added is encrypted
/// whatever its number.
pub(crate) fn stored_as_is(&self, num: u32) -> bool {
!self.encryption_changed && !self.is_edited(num) && self.encrypt_members.contains(&num)
}
/// Lift the restrictions of a document opened with its user password by entering the
@@ -270,8 +313,9 @@ impl Document {
/// always a full rewrite. Returns the handler (authenticated as owner).
pub fn set_encryption(&mut self, params: &pdfcraft_crypt::NewEncryption) -> Result<(), CosError> {
// The file identifier is part of the key; make sure it exists and keep it.
let id0 = match self.trailer.get(b"ID") {
Some(Object::Array(a)) if a.len() == 2 => a[0].as_string().map(|s| s.bytes.clone()).unwrap_or_default(),
let id = self.trailer.get(b"ID").map(|id| self.resolve(id));
let id0 = match id.as_deref() {
Some(Object::Array(a)) if a.len() == 2 => self.first_id(),
_ => {
let id = pdfcraft_crypt::file_id(&params.seed);
let s = Object::String(crate::PdfString { bytes: id.clone(), hex: true });
@@ -338,7 +382,9 @@ impl Document {
/// Decrypt a freshly parsed indirect object if the document is encrypted.
pub(super) fn decrypted(&self, id: ObjRef, o: Object) -> Object {
match &self.security {
Some(h) if Some(id.num) != self.encrypt_num => crate::security::transform(h, &o, id.num, id.generation, crate::security::Pass::Decrypt),
Some(h) if Some(id.num) != self.encrypt_num && !self.encrypt_members.contains(&id.num) => {
crate::security::transform(self, h, &o, id.num, id.generation, crate::security::Pass::Decrypt)
}
_ => o,
}
}
crates/cos/src/document/tests.rs
+142
View File
@@ -1,5 +1,147 @@
use super::*;
std::thread_local! {
/// How many times `Document::scan_for` read the file on this thread.
pub(super) static FILE_SCANS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
}
/// A scan that doesn't find an object isn't made again: each reads the whole file, and a file can
/// refer to such an object from every object it has.
#[test]
fn what_a_scan_of_the_file_did_not_find_is_remembered() {
let body = b"%PDF-1.7\n1 0 obj << /Type /Catalog /Pages 2 0 R >> endobj\n2 0 obj << /Type /Pages /Kids [] /Count 0 >> endobj\n";
let mut out = body.to_vec();
let xref = out.len();
out.extend_from_slice(b"xref\n0 4\n0000000000 65535 f \n");
out.extend_from_slice(format!("{:010} 00000 n \n", 9).as_bytes());
out.extend_from_slice(format!("{:010} 00000 n \n", body.iter().position(|b| *b == b'\n').unwrap() + 49).as_bytes());
out.extend_from_slice(b"0000000001 00000 n \n");
out.extend_from_slice(format!("trailer << /Size 4 /Root 1 0 R >>\nstartxref\n{xref}\n%%EOF\n").as_bytes());
let doc = Document::open(Arc::new(out)).unwrap();
FILE_SCANS.with(|scans| scans.set(0));
for _ in 0..5 {
assert!(doc.try_get(3).is_err());
}
assert_eq!(FILE_SCANS.with(std::cell::Cell::get), 1);
let clone = doc.clone();
assert!(clone.try_get(3).is_err());
assert_eq!(FILE_SCANS.with(std::cell::Cell::get), 1, "a clone has the same file");
}
/// An object can be nothing but a reference to another. A chain of them is followed, and one that
/// goes round ends in what isn't a dictionary or a name, without hanging.
#[test]
fn references_to_references_are_followed() {
let mut doc = Document::new_empty();
let name = doc.add(Object::name("Target"));
let one = doc.add(Object::Ref(name));
let two = doc.add(Object::Ref(one));
assert_eq!(doc.resolve(&Object::Ref(two)).as_name(), Some(b"Target".as_slice()));
let a = doc.add(Object::Null);
let b = doc.add(Object::Ref(a));
doc.set(a, Object::Ref(b));
assert_eq!(doc.resolve(&Object::Ref(a)).as_name(), None);
}
/// An object stream's `/DecodeParms` can be given by reference: without them a predictor isn't
/// undone, so its members were lost.
#[test]
fn an_object_stream_with_parameters_by_reference_is_read() {
let members = b"3 0 << /Hidden (yes) >>";
// PNG Sub, one row.
let mut rows = vec![1u8];
let mut before = 0u8;
for b in members {
rows.push(b.wrapping_sub(before));
before = *b;
}
let coded = pdfcraft_filters::encode_flate(&rows);
let mut out = b"%PDF-1.5\n".to_vec();
let mut offs = [0usize; 7];
let mut obj = |out: &mut Vec<u8>, n: usize, body: &[u8]| {
offs[n] = out.len();
out.extend_from_slice(format!("{n} 0 obj\n").as_bytes());
out.extend_from_slice(body);
out.extend_from_slice(b"\nendobj\n");
};
obj(&mut out, 1, b"<< /Type /Catalog /Pages 2 0 R >>");
obj(&mut out, 2, b"<< /Type /Pages /Kids [] /Count 0 /Extra 3 0 R >>");
let mut stm = format!("<< /Type /ObjStm /N 1 /First 4 /Filter /FlateDecode /DecodeParms 6 0 R /Length {} >>\nstream\n", coded.len()).into_bytes();
stm.extend_from_slice(&coded);
stm.extend_from_slice(b"\nendstream");
obj(&mut out, 4, &stm);
let data = [2u8, 0, 4, 0];
let mut xs = format!("<< /Type /XRef /Size 7 /W [1 2 1] /Index [3 1] /Length {} >>\nstream\n", data.len()).into_bytes();
xs.extend_from_slice(&data);
xs.extend_from_slice(b"\nendstream");
obj(&mut out, 5, &xs);
obj(&mut out, 6, format!("<< /Predictor 11 /Columns {} >>", members.len()).as_bytes());
let table = out.len();
out.extend_from_slice(b"xref\n0 7\n0000000000 65535 f \n");
for (n, off) in offs.iter().enumerate().skip(1) {
let line = if n == 3 { "0000000000 65535 f \n".to_string() } else { format!("{off:010} 00000 n \n") };
out.extend_from_slice(line.as_bytes());
}
out.extend_from_slice(format!("trailer << /Size 7 /Root 1 0 R /XRefStm {} >>\nstartxref\n{table}\n%%EOF\n", offs[5]).as_bytes());
let doc = Document::open(Arc::new(out)).unwrap();
let hidden = doc.get(ObjRef::new(3, 0));
assert_eq!(hidden.as_dict().and_then(|d| d.get(b"Hidden")).and_then(Object::as_string).map(|s| s.bytes.clone()), Some(b"yes".to_vec()));
}
/// Each entry of an `/Encrypt` dictionary, and of a crypt filter in it, reads the same by reference.
/// Read as absent, `/StmF` or `/CFM` was `/Identity`, so a whole file's streams stayed ciphertext.
#[test]
fn encrypt_dictionary_entries_read_the_same_by_reference() {
let string = |s: &str| Object::String(crate::PdfString::text(s));
let mut filter = Dict::new();
filter.set(b"CFM".to_vec(), Object::name("AESV2"));
filter.set(b"Length".to_vec(), Object::Int(5));
let cf = |filter: Dict| {
let mut cf = Dict::new();
cf.set(b"StdCF".to_vec(), Object::Dict(filter));
cf.set(b"Other".to_vec(), Object::Dict(Dict::new()));
Object::Dict(cf)
};
let mut d = Dict::new();
let entries = [
("Filter", Object::name("Standard")),
("V", Object::Int(4)),
("R", Object::Int(4)),
("Length", Object::Int(128)),
("P", Object::Int(-44)),
("O", string("owner")),
("U", string("user")),
("EncryptMetadata", Object::Bool(false)),
("CF", cf(filter.clone())),
("StmF", Object::name("StdCF")),
("StrF", Object::name("Other")),
("EFF", Object::name("StdCF")),
];
for (key, value) in &entries {
d.set(key.as_bytes().to_vec(), value.clone());
}
let mut doc = Document::new_empty();
let direct = crate::security::encrypt_dict(&doc, &d);
assert_eq!((direct.stm_f.as_slice(), direct.str_f.as_slice(), direct.ef_f.as_slice()), (&b"StdCF"[..], &b"Other"[..], &b"StdCF"[..]));
assert_eq!(direct.length_bits, 40, "the filter's own length, in bytes");
assert!(!direct.encrypt_metadata);
assert_eq!(direct.crypt_filters.iter().filter(|(_, m)| *m == pdfcraft_crypt::Method::Aes128).count(), 1);
for (key, value) in &entries {
let mut one = d.clone();
let r = doc.add(value.clone());
one.set(key.as_bytes().to_vec(), Object::Ref(r));
assert_eq!(crate::security::encrypt_dict(&doc, &one), direct, "/{key}");
}
for key in ["CFM", "Length"] {
let mut by_reference = filter.clone();
let r = doc.add(filter.get(key.as_bytes()).unwrap().clone());
by_reference.set(key.as_bytes().to_vec(), Object::Ref(r));
let mut one = d.clone();
one.set(b"CF".to_vec(), cf(by_reference));
assert_eq!(crate::security::encrypt_dict(&doc, &one), direct, "/{key} in the filter");
}
}
/// /DecodeParms given by reference, whole, as array entries or as the numbers inside, are read
/// once made direct: here a Flate predictor, which the stream alone doesn't see. Only the entries the filters use are
/// resolved, and nothing is for a chain longer than a decoder takes.
crates/cos/src/lib.rs
+1 -1
View File
@@ -22,7 +22,7 @@ mod parser;
mod security;
mod writer;
pub use budget::{DecodeBudget, ImageBudget, MAX_PAGE_DECODED, MAX_PAGE_FORMS};
pub use budget::{DecodeBudget, ImageBudget, MAX_PAGE_DECODED, MAX_PAGE_FORMS, MAX_REDACTED_IMAGE_PIXELS};
pub use bytes::Bytes;
pub use document::{Document, ReadState, Revision, SourceIdentity, XrefEntry};
pub use object::{Dict, MAX_DECODED, MAX_JBIG2_GLOBALS, Name, ObjRef, Object, PdfString, Stream};
crates/cos/src/security.rs
+214 -80
View File
@@ -7,10 +7,69 @@
//! false. Streams naming a crypt filter (`/Crypt` in `/Filter`) use that filter; embedded files
//! use `/EFF`.
use pdfcraft_crypt::{EncryptDict, Method, SecurityHandler, StreamKind};
use std::cell::Cell;
use pdfcraft_crypt::{EncryptDict, Method, SecurityHandler, StreamKind};
use pdfcraft_filters::MAX_CHAIN;
use crate::document::Held;
use crate::{Dict, Document, Object, PdfString, Stream};
/// How many references one read or write of an object may follow, with all that it loads on the
/// way. How an object is treated can be given by reference, and what that loads can do the same: a
/// file could make one read a tree of them, each object read again once the cache has let it go.
/// An object takes a few of these, and two dozen if every part of it is given by reference; past
/// this they read as absent. The parameters of an object stream, read together, count as one.
const MAX_FOLLOWED: u32 = 32;
std::thread_local! {
/// How many [`FollowScope`]s this thread is inside.
static SCOPES: Cell<u32> = const { Cell::new(0) };
/// The references followed in the outermost of them.
static FOLLOWED: Cell<u32> = const { Cell::new(0) };
/// The references refused in the outermost of them, past [`MAX_FOLLOWED`].
static REFUSED: Cell<u32> = const { Cell::new(0) };
}
/// One read or write of an object, with everything it loads on the way: what [`MAX_FOLLOWED`] counts.
pub(crate) struct FollowScope;
impl FollowScope {
pub(crate) fn enter() -> Self {
if SCOPES.replace(SCOPES.get().saturating_add(1)) == 0 {
FOLLOWED.set(0);
REFUSED.set(0);
}
FollowScope
}
}
impl Drop for FollowScope {
fn drop(&mut self) {
SCOPES.set(SCOPES.get().saturating_sub(1));
}
}
/// What `f` gives, counted against [`MAX_FOLLOWED`], or `spent` past it. Called inside a
/// [`FollowScope`], which is what starts the count again.
pub(crate) fn following<T>(spent: T, f: impl FnOnce() -> T) -> T {
if FOLLOWED.get() >= MAX_FOLLOWED {
REFUSED.set(REFUSED.get().saturating_add(1));
return spent;
}
FOLLOWED.set(FOLLOWED.get() + 1);
f()
}
/// `o`, or the object it refers to, for what decides how a stream or dictionary is treated. Past
/// [`MAX_FOLLOWED`] a reference reads as absent.
fn followed<'o>(doc: &Document, o: &'o Object) -> Held<'o> {
match o {
Object::Ref(_) => following(Held::Direct(&Object::Null), || doc.held(o)),
o => Held::Direct(o),
}
}
fn bytes_of(doc: &Document, d: &Dict, key: &[u8]) -> Vec<u8> {
d.get(key).map(|v| doc.resolve(v)).and_then(|v| v.as_string().map(|s| s.bytes.clone())).unwrap_or_default()
}
@@ -18,12 +77,12 @@ fn bytes_of(doc: &Document, d: &Dict, key: &[u8]) -> Vec<u8> {
/// Read the handler parameters from an `/Encrypt` dictionary.
pub(crate) fn encrypt_dict(doc: &Document, d: &Dict) -> EncryptDict {
let int = |k: &[u8], default: i64| d.get(k).map(|v| doc.resolve(v)).and_then(|v| v.as_int()).unwrap_or(default);
let name = |k: &[u8]| d.get(k).and_then(|v| v.as_name()).map(|n| n.to_vec()).unwrap_or_else(|| b"Identity".to_vec());
let name = |d: &Dict, k: &[u8]| d.get(k).and_then(|v| doc.resolve(v).as_name().map(<[u8]>::to_vec));
let mut crypt_filters = Vec::new();
if let Some(cf) = d.get(b"CF").map(|c| doc.resolve(c)).and_then(|c| c.as_dict().cloned()) {
for (k, v) in cf.iter() {
let Some(f) = doc.resolve(v).as_dict().cloned() else { continue };
let method = match f.name(b"CFM") {
let method = match name(&f, b"CFM").as_deref() {
Some(b"V2") => Method::Rc4,
Some(b"AESV2") => Method::Aes128,
Some(b"AESV3") => Method::Aes256,
@@ -40,7 +99,8 @@ pub(crate) fn encrypt_dict(doc: &Document, d: &Dict) -> EncryptDict {
.get(b"CF")
.map(|c| doc.resolve(c))
.and_then(|c| c.as_dict().and_then(|c| c.get(b"StdCF").map(|f| doc.resolve(f))))
.and_then(|f| f.as_dict().and_then(|f| f.int(b"Length")))
.and_then(|f| f.as_dict().and_then(|f| f.get(b"Length").map(|n| doc.resolve(n))))
.and_then(|n| n.as_int())
.filter(|n| *n > 0);
let length_bits = match (v, cf_len) {
(5.., _) => 256,
@@ -50,7 +110,7 @@ pub(crate) fn encrypt_dict(doc: &Document, d: &Dict) -> EncryptDict {
_ => int(b"Length", 40),
};
EncryptDict {
filter: d.name(b"Filter").map(|n| n.to_vec()).unwrap_or_default(),
filter: name(d, b"Filter").unwrap_or_default(),
v,
r: int(b"R", 0),
length_bits,
@@ -60,28 +120,46 @@ pub(crate) fn encrypt_dict(doc: &Document, d: &Dict) -> EncryptDict {
ue: bytes_of(doc, d, b"UE"),
perms: bytes_of(doc, d, b"Perms"),
p: int(b"P", -1) as i32,
encrypt_metadata: !matches!(d.get(b"EncryptMetadata"), Some(Object::Bool(false))),
encrypt_metadata: !matches!(d.get(b"EncryptMetadata").map(|v| doc.resolve(v)).as_deref(), Some(Object::Bool(false))),
crypt_filters,
stm_f: name(b"StmF"),
str_f: name(b"StrF"),
ef_f: d.get(b"EFF").and_then(|v| v.as_name()).map(|n| n.to_vec()).unwrap_or_default(),
stm_f: name(d, b"StmF").unwrap_or_else(|| b"Identity".to_vec()),
str_f: name(d, b"StrF").unwrap_or_else(|| b"Identity".to_vec()),
ef_f: name(d, b"EFF").unwrap_or_default(),
}
}
/// The crypt filter a stream names in its `/Filter` chain (`/Crypt` + `/DecodeParms /Name`).
fn named_crypt_filter(dict: &Dict) -> Option<Vec<u8>> {
let names: Vec<&[u8]> = match dict.get(b"Filter") {
Some(Object::Name(n)) => vec![n],
Some(Object::Array(a)) => a.iter().filter_map(Object::as_name).collect(),
/// Whether `f`, an entry of a `/Filter` chain or its only filter, is `/Crypt`.
fn is_crypt(doc: &Document, f: &Object) -> bool {
followed(doc, f).as_name() == Some(b"Crypt")
}
/// The crypt filter a stream names in its `/Filter` chain (`/Crypt` + `/DecodeParms /Name`), each
/// given directly or by reference, in an array or not. A chain longer than any decoder takes names
/// none: nothing can read that stream anyway, and every stream of a file can share one long array.
/// A `/Name` that reads as absent means `/Identity`, unless a reference on the way to it was refused
/// (see [`MAX_FOLLOWED`]): that says nothing about the stream, so it names none, and the document's
/// own filter is used.
fn named_crypt_filter(doc: &Document, dict: &Dict) -> Option<Vec<u8>> {
let refused = REFUSED.get();
let filter = followed(doc, dict.get(b"Filter")?);
let i = match &*filter {
Object::Array(a) if a.len() <= MAX_CHAIN + 1 => a.iter().position(|f| is_crypt(doc, f))?,
f if is_crypt(doc, f) => 0,
_ => return None,
};
let i = names.iter().position(|n| *n == b"Crypt")?;
let parms = match dict.get(b"DecodeParms") {
Some(Object::Dict(d)) if i == 0 => Some(d.clone()),
Some(Object::Array(a)) => a.get(i).and_then(|p| p.as_dict().cloned()),
let parms = dict.get(b"DecodeParms").map(|p| followed(doc, p));
let entry = match parms.as_deref() {
Some(Object::Array(a)) => a.get(i).map(|p| followed(doc, p)),
Some(p) if i == 0 => Some(Held::Direct(p)),
_ => None,
};
Some(parms.and_then(|p| p.name(b"Name").map(|n| n.to_vec())).unwrap_or_else(|| b"Identity".to_vec()))
let name = entry.as_deref().and_then(Object::as_dict).and_then(|p| p.get(b"Name")).map(|n| followed(doc, n));
match name.as_deref().and_then(Object::as_name) {
Some(name) => Some(name.to_vec()),
// /Identity here would read ciphertext as data, and write the stream in the clear.
None if REFUSED.get() > refused => None,
None => Some(b"Identity".to_vec()),
}
}
/// A signature dictionary (field signature, document timestamp or usage-rights signature),
@@ -91,42 +169,67 @@ fn named_crypt_filter(dict: &Dict) -> Option<Vec<u8>> {
/// `/Contents` alongside an array `/ByteRange` (`/Type` is optional). A signature dictionary
/// has no `/Subtype`; a dictionary with one (an annotation, whose `/Contents` is the comment
/// text) or with another `/Type` is never exempt, whatever else it carries.
fn is_signature_dict(d: &Dict) -> bool {
if d.get(b"Subtype").is_some() {
/// With `doc` its entries are read through references; a dictionary nested in another object
/// has none (see [`transform`]).
fn is_signature_dict(doc: Option<&Document>, d: &Dict) -> bool {
// All this decides is what happens to such a /Contents.
if !matches!(d.get(b"Contents"), Some(Object::String(_))) {
return false;
}
match d.get(b"Type") {
Some(_) => matches!(d.name(b"Type"), Some(b"Sig" | b"DocTimeStamp")),
None => matches!(d.get(b"Contents"), Some(Object::String(_))) && matches!(d.get(b"ByteRange"), Some(Object::Array(_))),
// A null entry, or one that refers to nothing, is an absent one (ISO 32000-2 §7.3.7, §7.3.10).
let entry = |key: &[u8]| {
let value = d.get(key)?;
let held = doc.map_or(Held::Direct(value), |doc| followed(doc, value));
(!matches!(*held, Object::Null)).then_some(held)
};
if entry(b"Subtype").is_some() {
return false;
}
match entry(b"Type") {
Some(t) => matches!(t.as_name(), Some(b"Sig" | b"DocTimeStamp")),
None => matches!(entry(b"ByteRange").as_deref(), Some(Object::Array(_))),
}
}
/// Remove the `/Crypt` entry from a stream's filter chain, with its decode parameters.
fn drop_crypt_filter(dict: &mut Dict) {
let i = match dict.get(b"Filter") {
Some(Object::Array(a)) => a.iter().position(|n| n.as_name() == Some(b"Crypt")),
Some(Object::Name(n)) if n.as_slice() == b"Crypt" => Some(0),
_ => None,
/// Longer than any filter's name. A name can be of any length, and a chain every stream shares can
/// hold a long one.
const MAX_FILTER_NAME: usize = 127;
/// The dictionary of `source` without the `/Crypt` entries of its filter chain and their decode
/// parameters. The two come out direct when given by reference, which every stream of a file can
/// share, so of what was shared only small values are copied: filter names, and the parameters
/// decoders read ([`Document::with_direct_parms`]). The chain is short, as [`named_crypt_filter`]
/// found a filter in it.
fn drop_crypt_filter(doc: &Document, source: &Stream) -> Dict {
let entry = |f: &Object| match f {
f if is_crypt(doc, f) => Object::name("Crypt"),
Object::Name(n) if n.len() <= MAX_FILTER_NAME => f.clone(),
Object::Ref(_) => f.clone(),
_ => Object::Null,
};
let Some(i) = i else { return };
let mut filters = match dict.get(b"Filter") {
Some(Object::Array(a)) => a.clone(),
_ => Vec::new(),
let filter = source.dict.get(b"Filter").map(|f| followed(doc, f));
let chain: Vec<Object> = match filter.as_deref() {
Some(Object::Array(a)) => a.iter().map(entry).collect(),
Some(f) => vec![entry(f)],
None => Vec::new(),
};
if i < filters.len() {
filters.remove(i);
}
let crypt: Vec<bool> = chain.iter().map(|f| f.as_name() == Some(b"Crypt")).collect();
let mut chained = Stream::from_raw(source.dict.clone(), Vec::new());
chained.dict.set(b"Filter".to_vec(), Object::Array(chain.clone()));
// A lone parameter dictionary belongs to the first filter (as `named_crypt_filter` reads it).
match dict.get(b"DecodeParms").cloned() {
Some(Object::Array(mut parms)) if i < parms.len() => {
parms.remove(i);
dict.set(b"DecodeParms".to_vec(), Object::Array(parms));
}
Some(Object::Dict(_)) if i == 0 => {
let parms = match doc.with_direct_parms(&chained).dict.get(b"DecodeParms") {
Some(Object::Array(p)) => Some(Object::Array(p.iter().zip(&crypt).filter(|(_, c)| !**c).map(|(p, _)| p.clone()).collect())),
Some(Object::Dict(_)) if crypt.first() == Some(&true) => None,
_ => source.dict.get(b"DecodeParms").cloned(),
};
let mut dict = source.dict.clone();
match parms {
Some(p) => dict.set(b"DecodeParms".to_vec(), p),
None => {
dict.remove(b"DecodeParms");
}
_ => {}
}
let filters: Vec<Object> = chain.into_iter().zip(&crypt).filter(|(_, c)| !**c).map(|(f, _)| f).collect();
if filters.is_empty() {
dict.remove(b"Filter");
if matches!(dict.get(b"DecodeParms"), Some(Object::Array(p)) if p.is_empty()) {
@@ -135,6 +238,7 @@ fn drop_crypt_filter(dict: &mut Dict) {
} else {
dict.set(b"Filter".to_vec(), Object::Array(filters));
}
dict
}
/// What [`transform`] does to an object.
@@ -152,51 +256,81 @@ pub(crate) enum Pass {
/// Decrypt or encrypt every string and stream in an indirect object, except a signature
/// dictionary's `/Contents` (see [`is_signature_dict`]).
pub(crate) fn transform(h: &SecurityHandler, o: &Object, num: u32, generation: u16, pass: Pass) -> Object {
///
/// `o` is as `doc` holds it: what a stream's dictionary gives by reference is read from `doc`, so
/// its references have to be the document's, not a save's renumbered ones.
pub(crate) fn transform(doc: &Document, h: &SecurityHandler, o: &Object, num: u32, generation: u16, pass: Pass) -> Object {
let _scope = FollowScope::enter();
let decrypt = pass == Pass::Decrypt;
let strings = |s: &PdfString| {
let bytes = if decrypt { h.decrypt_string(num, generation, &s.bytes) } else { h.encrypt_string(num, generation, &s.bytes) };
PdfString { bytes, hex: s.hex || !decrypt }
};
walk(o, &strings, h, num, generation, pass)
// References are followed here only, for the object itself, never for what is nested in it.
// `walk` goes deep, and a load from down there adds that depth again for each object loaded,
// which overflowed the stack on a 10 KB file. A stream can't be nested, and a dictionary that
// is reads as it says directly.
match o {
Object::Stream(s) => stream(doc, s, &strings, h, num, generation, pass),
Object::Dict(d) if is_signature_dict(Some(doc), d) => signature_dict(d, &strings),
o => walk(o, &strings),
}
}
fn walk(o: &Object, strings: &dyn Fn(&PdfString) -> PdfString, h: &SecurityHandler, num: u32, generation: u16, pass: Pass) -> Object {
let decrypt = pass == Pass::Decrypt;
/// `d`, a signature dictionary, with the strings of everything but its `/Contents` transformed.
fn signature_dict(d: &Dict, strings: &dyn Fn(&PdfString) -> PdfString) -> Object {
Object::Dict(
d.iter()
.map(|(k, v)| match (k.as_slice(), v) {
(b"Contents", Object::String(_)) => (k.clone(), v.clone()),
_ => (k.clone(), walk(v, strings)),
})
.collect(),
)
}
fn walk(o: &Object, strings: &dyn Fn(&PdfString) -> PdfString) -> Object {
match o {
Object::String(s) => Object::String(strings(s)),
Object::Array(a) => Object::Array(a.iter().map(|x| walk(x, strings, h, num, generation, pass)).collect()),
Object::Dict(d) if is_signature_dict(d) => Object::Dict(
d.iter()
.map(|(k, v)| match (k.as_slice(), v) {
(b"Contents", Object::String(_)) => (k.clone(), v.clone()),
_ => (k.clone(), walk(v, strings, h, num, generation, pass)),
})
.collect(),
),
Object::Dict(d) => Object::Dict(d.iter().map(|(k, v)| (k.clone(), walk(v, strings, h, num, generation, pass))).collect()),
Object::Stream(s) => {
let mut dict: Dict = s.dict.iter().map(|(k, v)| (k.clone(), walk(v, strings, h, num, generation, pass))).collect();
let ty = s.dict.name(b"Type");
// Cross-reference streams are never encrypted (§7.5.8), but only reading may trust the
// label: a stream a producer calls /XRef stays plaintext if writing believes it, and the
// writer builds its own cross-reference streams outside this transform.
if (decrypt && ty == Some(b"XRef")) || (ty == Some(b"Metadata") && !h.encrypts_metadata()) {
return Object::Stream(Stream { dict, raw: s.raw.clone() });
}
let mut named = named_crypt_filter(&s.dict);
if pass == Pass::EncryptReplacing && named.as_deref().is_some_and(|n| !h.dict().crypt_filters.iter().any(|(f, _)| f == n)) {
drop_crypt_filter(&mut dict);
named = None;
}
let kind = match (&named, ty) {
(Some(n), _) => StreamKind::Named(n),
(None, Some(b"EmbeddedFile")) => StreamKind::EmbeddedFile,
_ => StreamKind::Normal,
};
let raw = if decrypt { h.decrypt_stream(num, generation, &s.raw, kind) } else { h.encrypt_stream(num, generation, &s.raw, kind) };
Object::Stream(Stream { dict, raw: raw.into() })
}
Object::Array(a) => Object::Array(a.iter().map(|x| walk(x, strings)).collect()),
Object::Dict(d) if is_signature_dict(None, d) => signature_dict(d, strings),
Object::Dict(d) => Object::Dict(d.iter().map(|(k, v)| (k.clone(), walk(v, strings))).collect()),
other => other.clone(),
}
}
fn stream(
doc: &Document,
s: &Stream,
strings: &dyn Fn(&PdfString) -> PdfString,
h: &SecurityHandler,
num: u32,
generation: u16,
pass: Pass,
) -> Object {
let decrypt = pass == Pass::Decrypt;
let walked = |d: &Dict| -> Dict { d.iter().map(|(k, v)| (k.clone(), walk(v, strings))).collect() };
let ty = s.dict.get(b"Type").map(|t| followed(doc, t));
let ty = ty.as_deref().and_then(Object::as_name);
// Cross-reference streams are never encrypted (§7.5.8), but only reading may trust the
// label: a stream a producer calls /XRef stays plaintext if writing believes it, and the
// writer builds its own cross-reference streams outside this transform.
if (decrypt && ty == Some(b"XRef")) || (ty == Some(b"Metadata") && !h.encrypts_metadata()) {
return Object::Stream(Stream { dict: walked(&s.dict), raw: s.raw.clone() });
}
let mut named = named_crypt_filter(doc, &s.dict);
// Before the walk, which then encrypts what is in the dictionary this leaves.
let foreign = pass == Pass::EncryptReplacing && named.as_deref().is_some_and(|n| !h.dict().crypt_filters.iter().any(|(f, _)| f == n));
let dropped = foreign.then(|| drop_crypt_filter(doc, s));
if dropped.is_some() {
named = None;
}
let dict = walked(dropped.as_ref().unwrap_or(&s.dict));
let kind = match (&named, ty) {
(Some(n), _) => StreamKind::Named(n),
(None, Some(b"EmbeddedFile")) => StreamKind::EmbeddedFile,
_ => StreamKind::Normal,
};
let raw = if decrypt { h.decrypt_stream(num, generation, &s.raw, kind) } else { h.encrypt_stream(num, generation, &s.raw, kind) };
Object::Stream(Stream { dict, raw: raw.into() })
}
crates/cos/src/writer.rs
+43 -9
View File
@@ -133,11 +133,12 @@ fn write_stream(s: &Stream, out: &mut Vec<u8>) {
/// The object as written: encrypted with its (output) number when the document is encrypted,
/// except the `/Encrypt` dictionary itself (`source_num` is its number in the source document).
/// `o` has the document's numbers in its references ([`crate::security::transform`]).
fn prepared<'a>(doc: &Document, source_num: u32, num: u32, generation: u16, o: &'a Object) -> Cow<'a, Object> {
match doc.output_security() {
(Some(h), encrypt_num) if Some(source_num) != encrypt_num => {
(Some(h), encrypt_num) if Some(source_num) != encrypt_num && !doc.stored_as_is(source_num) => {
let pass = if doc.encryption_changed() { crate::security::Pass::EncryptReplacing } else { crate::security::Pass::Encrypt };
Cow::Owned(crate::security::transform(h, o, num, generation, pass))
Cow::Owned(crate::security::transform(doc, h, o, num, generation, pass))
}
_ => Cow::Borrowed(o),
}
@@ -287,6 +288,10 @@ pub fn write_full(doc: &Document, opts: &SaveOptions) -> Result<Vec<u8>, CosErro
queue.push_back(r);
}
}
// A direct /Encrypt can refer to objects, /CF or /StmF, say.
if let Some(encrypt @ Object::Dict(_)) = trailer_in.get(b"Encrypt") {
visit_refs(encrypt, &mut queue);
}
// Unknown trailer entries are document data. Objects they alone reference must be written
// too, or a full rewrite would keep the key and drop its value.
for (key, value) in trailer_in.iter() {
@@ -315,7 +320,10 @@ pub fn write_full(doc: &Document, opts: &SaveOptions) -> Result<Vec<u8>, CosErro
// The /Encrypt dictionary and everything it references (e.g. indirect /CF crypt-filter
// dictionaries) are needed before anything can be decrypted: never inside object streams.
let mut encryption_objects: std::collections::HashSet<ObjRef> = std::collections::HashSet::new();
let mut pending: Vec<ObjRef> = trailer_in.reference(b"Encrypt").into_iter().collect();
let mut pending: Vec<ObjRef> = Vec::new();
if let Some(encrypt) = trailer_in.get(b"Encrypt") {
collect_refs(encrypt, &mut |r| pending.push(r));
}
while let Some(r) = pending.pop() {
if encryption_objects.insert(r) {
collect_refs(&reader.get(r), &mut |x| pending.push(x));
@@ -336,9 +344,10 @@ pub fn write_full(doc: &Document, opts: &SaveOptions) -> Result<Vec<u8>, CosErro
if in_stream {
packed.push((num, *r));
} else {
let o = renumber(&*reread(&mut reader, *r, *is_stream)?, &map);
let o = reread(&mut reader, *r, *is_stream)?;
let o = renumber(&prepared(&reader.document, r.num, num, 0, &o), &map);
rows.insert(num, Row::InFile(out.len() as u64, 0));
write_indirect(num, 0, &prepared(&reader.document, r.num, num, 0, &o), &mut out);
write_indirect(num, 0, &o, &mut out);
}
}
// Object streams take the numbers after the last object. Their contents are not encrypted
@@ -368,11 +377,11 @@ pub fn write_full(doc: &Document, opts: &SaveOptions) -> Result<Vec<u8>, CosErro
trailer.set(key.to_vec(), Object::Ref(ObjRef::new(*r, 0)));
}
}
if let Some(Object::Dict(d)) = trailer_in.get(b"Encrypt") {
trailer.set(b"Encrypt".to_vec(), Object::Dict(d.clone()));
if let Some(encrypt @ Object::Dict(_)) = trailer_in.get(b"Encrypt") {
trailer.set(b"Encrypt".to_vec(), renumber(encrypt, &map));
}
if let Some(id) = trailer_in.get(b"ID") {
trailer.set(b"ID".to_vec(), id.clone());
trailer.set(b"ID".to_vec(), direct_id(&reader.document, id));
}
for (key, value) in trailer_in.iter() {
if !trailer_key_rewritten(key) {
@@ -442,6 +451,22 @@ impl ObjectStreamBatch {
}
}
/// `/ID` for the trailer, direct, as it has to be with `/Encrypt`: nothing else in the file holds
/// what it refers to now. Given by reference it is two entries at most, however many references a
/// file gave, so that one large string isn't copied for each. An entry that isn't a string stays in
/// its place as an empty one, which is how the key read it.
fn direct_id(doc: &Document, id: &Object) -> Object {
if matches!(id, Object::Array(a) if !a.iter().any(|s| matches!(s, Object::Ref(_)))) {
return id.clone();
}
let entry = |s: &Object| match &*doc.resolve(s) {
s @ Object::String(_) => s.clone(),
_ => Object::String(crate::PdfString { bytes: Vec::new(), hex: true }),
};
let held = doc.resolve(id);
Object::Array(held.as_array().into_iter().flatten().take(2).map(entry).collect())
}
/// Trailer keys a full rewrite generates itself. Everything else is copied, with references
/// renumbered, so a save does not drop metadata the reader accepted.
fn trailer_key_rewritten(key: &[u8]) -> bool {
@@ -486,7 +511,7 @@ pub(crate) fn unlinked_additions(doc: &Document) -> HashSet<u32> {
pending.into_keys().collect()
}
fn collect_refs(o: &Object, f: &mut impl FnMut(ObjRef)) {
pub(crate) fn collect_refs(o: &Object, f: &mut impl FnMut(ObjRef)) {
match o {
Object::Ref(r) => f(*r),
Object::Array(a) => a.iter().for_each(|x| collect_refs(x, f)),
@@ -663,6 +688,15 @@ fn civil_from_days(days: i64) -> (i64, u32, u32) {
#[cfg(test)]
mod tests {
/// `/ID` by reference comes out direct, each entry where it was: the key is made from the first.
#[test]
fn a_file_identifier_keeps_its_entries_in_their_places() {
let doc = Document::new_empty();
let string = |bytes: &[u8]| Object::String(crate::PdfString { bytes: bytes.to_vec(), hex: true });
let nowhere = Object::Ref(ObjRef::new(9_999, 0));
assert_eq!(super::direct_id(&doc, &Object::Array(vec![nowhere, string(b"ab")])), Object::Array(vec![string(b""), string(b"ab")]));
}
use proptest::prelude::*;
use super::*;
crates/cos/tests/it/encryption.rs
+823
View File
@@ -494,3 +494,826 @@ fn a_stream_labelled_xref_is_encrypted_when_saved() {
let bytes = write_full(&doc, &SaveOptions { object_streams: false, ..SaveOptions::default() }).unwrap();
assert!(!bytes.windows(SECRET.len()).any(|w| w == SECRET.as_bytes()), "the labelled stream was written in the clear");
}
/// The content stream's reference.
fn contents_of(doc: &Document) -> ObjRef {
let catalog = doc.get(doc.root().unwrap()).as_dict().cloned().unwrap();
let pages = doc.get(catalog.reference(b"Pages").unwrap()).as_dict().cloned().unwrap();
let page = doc.resolve(&pages.get(b"Kids").unwrap().as_array().unwrap()[0]).as_dict().cloned().unwrap();
page.reference(b"Contents").unwrap()
}
/// The content stream's data as loaded, whatever its filters say.
fn raw_content(doc: &Document) -> String {
match &*doc.get(contents_of(doc)) {
Object::Stream(s) => String::from_utf8_lossy(&s.raw).trim().to_string(),
_ => panic!("no content stream"),
}
}
/// Gives the content stream the `/Filter` and `/DecodeParms` of `selector`.
fn select(doc: &mut Document, (filter, parms): (Object, Object)) {
let contents = contents_of(doc);
let Object::Stream(mut s) = doc.get(contents).as_ref().clone() else { panic!("no content stream") };
s.dict.set(b"Filter".to_vec(), filter);
s.dict.set(b"DecodeParms".to_vec(), parms);
doc.set(contents, Object::Stream(s));
}
/// `/Crypt` naming `name`, in the `form`th spelling: all direct, then each part by reference.
/// `None` past the last.
fn selector(doc: &mut Document, form: usize, name: &str) -> Option<(Object, Object)> {
let crypt = Object::name("Crypt");
let parms = |n: Object| {
let mut d = pdfcraft_cos::Dict::new();
d.set(b"Name".to_vec(), n);
Object::Dict(d)
};
let named = parms(Object::name(name));
Some(match form {
0 => (crypt, named),
1 => (crypt, Object::Ref(doc.add(named))),
2 => (Object::Array(vec![crypt]), Object::Array(vec![Object::Ref(doc.add(named))])),
3 => (Object::Array(vec![crypt]), Object::Ref(doc.add(Object::Array(vec![named])))),
4 => (crypt, parms(Object::Ref(doc.add(Object::name(name))))),
5 => (Object::Ref(doc.add(crypt)), named),
6 => (Object::Ref(doc.add(Object::Array(vec![crypt]))), Object::Array(vec![named])),
7 => (Object::Array(vec![Object::Ref(doc.add(crypt))]), Object::Array(vec![named])),
// Behind a filter given by reference: places in the two arrays pair up all the same.
8 => (Object::Array(vec![Object::Ref(doc.add(Object::name("ASCIIHexDecode"))), crypt]), Object::Array(vec![Object::Null, named])),
// The two entries in different forms, which is how a lone filter is usually spelled.
9 => (Object::Array(vec![crypt]), named),
10 => (crypt, Object::Array(vec![named])),
// The filter twice, which names the first's.
11 => (Object::Array(vec![crypt.clone(), crypt]), Object::Array(vec![named.clone(), named])),
// A reference to a reference.
12 => {
let name = doc.add(Object::name(name));
let hop = doc.add(Object::Ref(name));
(crypt, parms(Object::Ref(hop)))
}
_ => return None,
})
}
fn holds(bytes: &[u8], text: &str) -> bool {
String::from_utf8_lossy(bytes).contains(text)
}
/// An object `/Encrypt` names is written as stored only while it is as stored. A file whose
/// `/Encrypt` names its `/Info` reads that dictionary as stored; once the title is edited, both
/// saves encrypt it rather than writing the new title in the clear.
#[test]
fn an_edited_object_that_encrypt_names_is_encrypted() {
let mut doc = Document::open(Arc::new(fixture())).unwrap();
doc.set_encryption(&NewEncryption {
algorithm: Algorithm::Aes128,
user_password: "",
owner_password: "owner",
permissions: -1,
encrypt_metadata: true,
seed: [9; 32],
})
.unwrap();
let info = doc.trailer().reference(b"Info").unwrap();
let mut dict = doc.get(doc.trailer().reference(b"Encrypt").unwrap()).as_dict().cloned().unwrap();
dict.set(b"Junk".to_vec(), Object::Ref(info));
doc.trailer_mut().set(b"Encrypt".to_vec(), Object::Dict(dict));
let bytes = write_full(&doc, &SaveOptions::default()).unwrap();
let mut doc = Document::open(Arc::new(bytes)).unwrap();
let info = doc.trailer().reference(b"Info").unwrap();
doc.update_dict(info, |d| d.set(b"Title".to_vec(), PdfString::text("Merger plan"))).unwrap();
for (save, saved) in [("incremental", write_incremental(&doc, &SaveOptions::default())), ("full", write_full(&doc, &SaveOptions::default()))] {
assert!(!holds(&saved.unwrap(), "Merger plan"), "{save}: the edited title was written in the clear");
}
}
/// A stream can select its crypt filter by reference at every step: the chain, an entry of it, the
/// parameters, an entry of those, the name (ISO 32000-2 §7.3.10, §7.4.10). Read as absent, the
/// filter was `/Identity`, so such a stream was saved in the clear and, in a file from elsewhere,
/// its ciphertext read as data. A full save renumbers: what it follows has the document's numbers.
#[test]
fn a_crypt_filter_selected_by_reference_is_used() {
for alg in [Algorithm::Aes128, Algorithm::Aes256] {
for form in 0.. {
let mut doc = Document::open(Arc::new(protect(alg, "", "owner", -1))).unwrap();
let Some(selected) = selector(&mut doc, form, "StdCF") else { break };
select(&mut doc, selected);
let saved = write_incremental(&doc, &SaveOptions::default()).unwrap();
assert!(!holds(&saved, "Secret page"), "{alg:?} form {form}: saved encrypted");
let back = Document::open(Arc::new(saved)).unwrap();
assert_eq!(raw_content(&back), SECRET, "{alg:?} form {form}: read back");
let full = write_full(&back, &SaveOptions::default()).unwrap();
assert!(!holds(&full, "Secret page"), "{alg:?} form {form}: renumbered, encrypted");
assert_eq!(raw_content(&Document::open(Arc::new(full)).unwrap()), SECRET, "{alg:?} form {form}: renumbered");
}
}
}
/// A reference to a stream that takes `follows` references to read cold, this one included: its
/// nine filters are all read, the last leading to the next stream.
fn spends(doc: &mut Document, follows: usize) -> Object {
let left = follows - 1;
let mut filters: Vec<Object> = (0..left.min(8)).map(|i| Object::Ref(doc.add(Object::Int(i as i64)))).collect();
if left > 8 {
filters.push(spends(doc, left - 8));
}
let mut dict = pdfcraft_cos::Dict::new();
dict.set(b"Filter".to_vec(), Object::Array(filters));
Object::Ref(doc.add(Object::Stream(pdfcraft_cos::Stream::from_raw(dict, Vec::new()))))
}
/// Gives the content stream a `/Type` that takes `follows` references to read, ahead of its filter.
fn spend_first(doc: &mut Document, follows: usize) {
let spent = spends(doc, follows);
let contents = contents_of(doc);
let Object::Stream(mut s) = doc.get(contents).as_ref().clone() else { panic!("no content stream") };
s.dict.set(b"Type".to_vec(), spent);
doc.set(contents, Object::Stream(s));
}
/// Past what one read may follow a reference reads as absent, and a crypt filter with no `/Name` is
/// `/Identity`. Together those would read this stream's ciphertext as data, so what can't be told
/// is the document's own filter, as a `/Filter` that can't be read is.
#[test]
fn a_crypt_filter_past_what_a_read_may_follow_is_the_documents_own() {
let mut doc = Document::open(Arc::new(protect(Algorithm::Aes128, "", "owner", -1))).unwrap();
let selected = selector(&mut doc, 1, "StdCF").unwrap();
select(&mut doc, selected);
spend_first(&mut doc, 40);
let saved = write_incremental(&doc, &SaveOptions::default()).unwrap();
assert!(!holds(&saved, "Secret page"), "saved encrypted");
let back = Document::open(Arc::new(saved)).unwrap();
assert_eq!(raw_content(&back), SECRET);
let full = write_full(&back, &SaveOptions::default()).unwrap();
assert!(!holds(&full, "Secret page"), "renumbered, encrypted");
assert_eq!(raw_content(&Document::open(Arc::new(full)).unwrap()), SECRET, "renumbered");
}
/// A read that takes all it may follow has refused nothing: a crypt filter with no `/Name` after it
/// is still `/Identity`, and the stream is in the clear.
#[test]
fn a_crypt_filter_with_no_name_after_all_a_read_may_follow_is_identity() {
let mut doc = Document::open(Arc::new(protect(Algorithm::Aes128, "", "owner", -1))).unwrap();
select(&mut doc, (Object::name("Crypt"), Object::Dict(pdfcraft_cos::Dict::new())));
spend_first(&mut doc, 32);
let saved = write_incremental(&doc, &SaveOptions::default()).unwrap();
assert!(holds(&saved, "Secret page"), "written as the stream asks");
assert_eq!(raw_content(&Document::open(Arc::new(saved)).unwrap()), SECRET);
}
/// `/Identity` selected by reference keeps a stream in the clear in a document that encrypts the
/// rest, in every spelling, on both saves.
#[test]
fn an_identity_crypt_filter_selected_by_reference_leaves_a_stream_alone() {
for form in 0.. {
let mut doc = Document::open(Arc::new(protect(Algorithm::Aes128, "", "owner", -1))).unwrap();
let Some(selected) = selector(&mut doc, form, "Identity") else { break };
select(&mut doc, selected);
let saved = write_incremental(&doc, &SaveOptions::default()).unwrap();
assert!(holds(&saved, "Secret page"), "form {form}: written as the stream asks");
let back = Document::open(Arc::new(saved)).unwrap();
assert_eq!(raw_content(&back), SECRET, "form {form}");
let full = write_full(&back, &SaveOptions::default()).unwrap();
assert!(holds(&full, "Secret page"), "form {form}: renumbered");
assert_eq!(raw_content(&Document::open(Arc::new(full)).unwrap()), SECRET, "form {form}: renumbered");
}
}
/// New protection drops a crypt filter it doesn't define, whichever way the stream selected it. The
/// chain comes out direct. Parameters in the stream's own dictionary stay, encrypted with it; of an
/// array in an object of its own, which every stream can share, only what decoders read is copied.
#[test]
fn protecting_drops_a_crypt_filter_selected_by_reference() {
let protected = |doc: &mut Document| {
doc.set_encryption(&NewEncryption {
algorithm: Algorithm::Aes256,
user_password: "",
owner_password: "owner",
permissions: -1,
encrypt_metadata: true,
seed: [7; 32],
})
.unwrap();
write_full(doc, &SaveOptions::default()).unwrap()
};
for form in 0.. {
let mut doc = Document::open(Arc::new(fixture())).unwrap();
let Some(selected) = selector(&mut doc, form, "MyCF") else { break };
select(&mut doc, selected);
let bytes = protected(&mut doc);
assert!(!holds(&bytes, "Secret page"), "form {form}: encrypted");
assert!(!holds(&bytes, "MyCF"), "form {form}: no selector left in the stream");
let back = Document::open(Arc::new(bytes.clone())).unwrap();
assert_eq!(raw_content(&back), SECRET, "form {form}");
let contents = back.get(contents_of(&back));
let filter = contents.as_dict().unwrap().get(b"Filter");
match form {
8 => assert!(
matches!(filter, Some(Object::Array(a)) if matches!(a.as_slice(), [Object::Ref(_)])),
"form 8: the other filter stays: {filter:?}"
),
_ => assert_eq!(filter, None, "form {form}"),
}
assert!(hayro_syntax::Pdf::new(bytes).is_ok(), "form {form}");
}
for shared in [false, true] {
let mut doc = Document::open(Arc::new(fixture())).unwrap();
let mut named = pdfcraft_cos::Dict::new();
named.set(b"Name".to_vec(), Object::name("MyCF"));
let mut other = pdfcraft_cos::Dict::new();
other.set(b"Note".to_vec(), Object::String(PdfString::text("Private note")));
other.set(b"Predictor".to_vec(), Object::Int(1));
let parms = Object::Array(vec![Object::Dict(named), Object::Dict(other)]);
let parms = if shared { Object::Ref(doc.add(parms)) } else { parms };
select(&mut doc, (Object::Array(vec![Object::name("Crypt"), Object::name("ASCIIHexDecode")]), parms));
let bytes = protected(&mut doc);
assert!(!holds(&bytes, "Private note"), "shared: {shared}");
let back = Document::open(Arc::new(bytes)).unwrap();
let contents = back.get(contents_of(&back));
let kept = contents.as_dict().unwrap().get(b"DecodeParms").unwrap().as_array().unwrap();
assert_eq!(kept.len(), 1, "one filter left, one entry");
let kept = kept[0].as_dict().unwrap();
assert_eq!(kept.get(b"Predictor"), Some(&Object::Int(1)), "shared: {shared}");
assert_eq!(kept.get(b"Note").is_some(), !shared, "shared: {shared}");
}
}
/// Every stream of a file can share one large object as its `/DecodeParms` or `/Filter`, which
/// costs nothing until new protection drops a crypt filter from each. Copied whole, a 1 MB file
/// came out at 1 GB.
#[test]
fn protecting_copies_no_large_object_into_every_stream() {
let pad = Object::Array(vec![Object::Int(1); 100_000]);
let mut doc = Document::open(Arc::new(fixture())).unwrap();
let mut large = pdfcraft_cos::Dict::new();
large.set(b"Pad".to_vec(), pad.clone());
let parms = doc.add(Object::Array(vec![Object::Null, Object::Dict(large)]));
let filter = doc.add(Object::Array(vec![Object::name("Crypt"), Object::Name(vec![b'A'; 100_000]), pad]));
let mut streams = Vec::new();
for _ in 0..200 {
let mut by_parms = pdfcraft_cos::Dict::new();
by_parms.set(b"Filter".to_vec(), Object::Array(vec![Object::name("Crypt"), Object::name("ASCIIHexDecode")]));
by_parms.set(b"DecodeParms".to_vec(), Object::Ref(parms));
streams.push(Object::Ref(doc.add(Object::Stream(pdfcraft_cos::Stream::from_raw(by_parms, b"41>".to_vec())))));
let mut by_filter = pdfcraft_cos::Dict::new();
by_filter.set(b"Filter".to_vec(), Object::Ref(filter));
streams.push(Object::Ref(doc.add(Object::Stream(pdfcraft_cos::Stream::from_raw(by_filter, b"41>".to_vec())))));
}
doc.update_dict(doc.root().unwrap(), |c| c.set(b"Test".to_vec(), Object::Array(streams))).unwrap();
doc.set_encryption(&NewEncryption {
algorithm: Algorithm::Aes256,
user_password: "",
owner_password: "owner",
permissions: -1,
encrypt_metadata: true,
seed: [7; 32],
})
.unwrap();
let bytes = write_full(&doc, &SaveOptions { object_streams: false, ..SaveOptions::default() }).unwrap();
assert!(bytes.len() < 1 << 20, "{} bytes", bytes.len());
}
/// A file can name one large string thousands of times in `/ID`, which holds two. An encrypted file
/// keeps its `/ID`, so each copy would be in the file a save writes.
#[test]
fn a_file_identifier_of_many_references_is_two_strings() {
let mut doc = Document::open(Arc::new(fixture())).unwrap();
doc.set_encryption(&NewEncryption {
algorithm: Algorithm::Aes128,
user_password: "",
owner_password: "owner",
permissions: -1,
encrypt_metadata: true,
seed: [9; 32],
})
.unwrap();
let large = doc.add(Object::String(PdfString { bytes: vec![0xAB; 100_000], hex: true }));
doc.trailer_mut().set(b"ID".to_vec(), Object::Array(vec![Object::Ref(large); 500]));
let bytes = write_full(&doc, &SaveOptions { object_streams: false, ..SaveOptions::default() }).unwrap();
assert!(bytes.len() < 1 << 20, "{} bytes", bytes.len());
}
/// What a file can do with those references: point a stream's selector at the stream itself, or at
/// nothing. They read as absent, so a stream with `/Crypt` is `/Identity` (ISO 32000-2 §7.4.10),
/// and one that names no filter follows the document's. Loading ends either way.
#[test]
fn a_crypt_filter_reference_to_itself_or_nothing_reads_as_absent() {
let named = |n: Object| {
let mut d = pdfcraft_cos::Dict::new();
d.set(b"Name".to_vec(), n);
Object::Dict(d)
};
for (what, encrypted) in [
("/Filter to itself", true),
("/Filter nowhere", true),
("/DecodeParms to itself", false),
("/DecodeParms nowhere", false),
("/Name to itself", false),
("/Name nowhere", false),
] {
let mut doc = Document::open(Arc::new(protect(Algorithm::Aes128, "", "owner", -1))).unwrap();
let me = Object::Ref(contents_of(&doc));
let nowhere = Object::Ref(ObjRef::new(9_999, 0));
let crypt = Object::name("Crypt");
select(
&mut doc,
match what {
"/Filter to itself" => (me, Object::Null),
"/Filter nowhere" => (nowhere, Object::Null),
"/DecodeParms to itself" => (crypt, me),
"/DecodeParms nowhere" => (crypt, nowhere),
"/Name to itself" => (crypt, named(me)),
_ => (crypt, named(nowhere)),
},
);
let saved = write_incremental(&doc, &SaveOptions::default()).unwrap();
assert_eq!(!holds(&saved, "Secret page"), encrypted, "{what}");
assert_eq!(raw_content(&Document::open(Arc::new(saved)).unwrap()), SECRET, "{what}");
}
}
/// A lone parameter dictionary belongs to the first filter, so `/Crypt` behind another filter has
/// none of its own and is `/Identity` (ISO 32000-2 §7.4.1), whatever that dictionary says.
#[test]
fn a_lone_parameter_dictionary_is_the_first_filters() {
let mut doc = Document::open(Arc::new(protect(Algorithm::Aes128, "", "owner", -1))).unwrap();
let mut parms = pdfcraft_cos::Dict::new();
parms.set(b"Name".to_vec(), Object::name("StdCF"));
let first = Object::Array(vec![Object::name("Crypt"), Object::name("ASCIIHexDecode")]);
let second = Object::Array(vec![Object::name("ASCIIHexDecode"), Object::name("Crypt")]);
select(&mut doc, (first, Object::Dict(parms.clone())));
assert!(!holds(&write_incremental(&doc, &SaveOptions::default()).unwrap(), "Secret page"), "first: it names StdCF");
select(&mut doc, (second, Object::Dict(parms)));
assert!(holds(&write_incremental(&doc, &SaveOptions::default()).unwrap(), "Secret page"), "second: it names nothing");
}
/// A lone parameter dictionary is the first filter's, so dropping a `/Crypt` behind that filter
/// leaves it, and dropping one in front of it takes it away.
#[test]
fn protecting_keeps_the_parameters_of_the_filter_before_a_crypt_filter() {
let protected = |filters: Vec<Object>| {
let mut doc = Document::open(Arc::new(fixture())).unwrap();
let mut parms = pdfcraft_cos::Dict::new();
parms.set(b"Name".to_vec(), Object::name("MyCF"));
select(&mut doc, (Object::Array(filters), Object::Dict(parms)));
doc.set_encryption(&NewEncryption {
algorithm: Algorithm::Aes256,
user_password: "",
owner_password: "owner",
permissions: -1,
encrypt_metadata: true,
seed: [7; 32],
})
.unwrap();
let back = Document::open(Arc::new(write_full(&doc, &SaveOptions::default()).unwrap())).unwrap();
back.get(contents_of(&back)).as_dict().unwrap().contains(b"DecodeParms")
};
let (hex, crypt) = (Object::name("ASCIIHexDecode"), Object::name("Crypt"));
assert!(protected(vec![hex.clone(), crypt.clone()]), "the first filter's, which stays");
assert!(!protected(vec![crypt, hex]), "/Crypt's, which goes");
}
/// Dropping `/Crypt` takes its entry out of `/DecodeParms`, and an array too short to have one is
/// left as it is, given directly or by reference.
#[test]
fn protecting_leaves_a_parameter_array_too_short_for_the_crypt_filter() {
for by_reference in [false, true] {
let mut doc = Document::open(Arc::new(fixture())).unwrap();
let short = Object::Array(vec![Object::Null]);
let parms = if by_reference { Object::Ref(doc.add(short)) } else { short };
select(&mut doc, (Object::Array(vec![Object::name("ASCIIHexDecode"), Object::name("Crypt")]), parms));
doc.set_encryption(&NewEncryption {
algorithm: Algorithm::Aes256,
user_password: "",
owner_password: "owner",
permissions: -1,
encrypt_metadata: true,
seed: [7; 32],
})
.unwrap();
let bytes = write_full(&doc, &SaveOptions::default()).unwrap();
assert!(!holds(&bytes, "Secret page"), "by reference: {by_reference}");
let back = Document::open(Arc::new(bytes)).unwrap();
assert_eq!(raw_content(&back), SECRET, "by reference: {by_reference}");
let contents = back.get(contents_of(&back));
let filter = contents.as_dict().unwrap().get(b"Filter").unwrap().as_array().unwrap();
assert_eq!(filter.len(), 1, "only /Crypt goes");
assert_eq!(filter[0].as_name(), Some(b"ASCIIHexDecode".as_slice()), "the other filter stays as it was");
}
}
/// A chain of up to [`pdfcraft_filters::MAX_CHAIN`] filters and `/Crypt` is read; a longer one
/// names no crypt filter, so its entries aren't followed for every stream sharing it.
#[test]
fn a_chain_longer_than_any_decoder_takes_names_no_crypt_filter() {
let chain = |others: usize| {
let mut doc = Document::open(Arc::new(protect(Algorithm::Aes128, "", "owner", -1))).unwrap();
let mut filters = vec![Object::name("ASCIIHexDecode"); others];
filters.push(Object::name("Crypt"));
let array = doc.add(Object::Array(filters));
select(&mut doc, (Object::Ref(array), Object::Null));
holds(&write_incremental(&doc, &SaveOptions::default()).unwrap(), "Secret page")
};
assert!(chain(pdfcraft_filters::MAX_CHAIN), "the longest chain read: /Identity, in the clear");
assert!(!chain(pdfcraft_filters::MAX_CHAIN + 1), "one more: the document's filter");
}
/// A stream's `/Type` by reference picks its handling like one given directly: metadata left
/// readable under `/EncryptMetadata false`, an embedded file under `/EFF`.
#[test]
fn a_stream_type_given_by_reference_picks_its_crypt_filter() {
let mut doc = Document::open(Arc::new(fixture())).unwrap();
let catalog = doc.get(doc.root().unwrap()).as_dict().cloned().unwrap();
let meta = catalog.reference(b"Metadata").unwrap();
let ty = doc.add(Object::name("Metadata"));
let Object::Stream(mut s) = doc.get(meta).as_ref().clone() else { panic!("no metadata stream") };
s.dict.set(b"Type".to_vec(), Object::Ref(ty));
doc.set(meta, Object::Stream(s));
doc.set_encryption(&NewEncryption {
algorithm: Algorithm::Aes256,
user_password: "",
owner_password: "o",
permissions: -1,
encrypt_metadata: false,
seed: [5; 32],
})
.unwrap();
let bytes = write_full(&doc, &SaveOptions::default()).unwrap();
assert!(holds(&bytes, "<x:xmpmeta>meta</x:xmpmeta>"), "search engines can read XMP");
let mut doc = Document::open(Arc::new(protect(Algorithm::Aes128, "", "owner", -1))).unwrap();
let encrypt = doc.trailer().reference(b"Encrypt").unwrap();
doc.update_dict(encrypt, |e| e.set(b"EFF".to_vec(), Object::name("Identity"))).unwrap();
let mut doc = Document::open(Arc::new(write_incremental(&doc, &SaveOptions::default()).unwrap())).unwrap();
let contents = contents_of(&doc);
let ty = doc.add(Object::name("EmbeddedFile"));
let Object::Stream(mut s) = doc.get(contents).as_ref().clone() else { panic!("no content stream") };
s.dict.set(b"Type".to_vec(), Object::Ref(ty));
doc.set(contents, Object::Stream(s));
assert!(holds(&write_incremental(&doc, &SaveOptions::default()).unwrap(), "Secret page"), "/EFF /Identity leaves it alone");
}
/// What makes a dictionary a signature's can be given by reference, and what is null or refers to
/// nothing is absent: `/Contents` stays as written in each of these.
#[test]
fn a_signature_dictionary_is_known_in_every_form() {
let mut doc = Document::open(Arc::new(fixture())).unwrap();
let ty = doc.add(Object::name("Sig"));
let range = Object::Array([0, 10, 20, 30].into_iter().map(Object::Int).collect());
let by_reference = doc.add(range.clone());
let nowhere = Object::Ref(ObjRef::new(9_999, 0));
let forms: [(Vec<(&str, Object)>, &str); 5] = [
(vec![("Type", Object::Ref(ty))], "DEAD"),
(vec![("ByteRange", Object::Ref(by_reference))], "BEEF"),
(vec![("Type", Object::Null), ("ByteRange", range.clone())], "CAFE"),
(vec![("Type", nowhere.clone()), ("ByteRange", range.clone())], "F00D"),
(vec![("Subtype", nowhere), ("ByteRange", range)], "D00D"),
];
let mut signatures = Vec::new();
for (entries, contents) in forms {
let mut sig = pdfcraft_cos::Dict::new();
for (key, value) in entries {
sig.set(key.as_bytes().to_vec(), value);
}
let bytes = (0..contents.len()).step_by(2).map(|i| u8::from_str_radix(&contents[i..i + 2], 16).unwrap()).collect();
sig.set(b"Contents".to_vec(), Object::String(PdfString { bytes, hex: true }));
signatures.push(Object::Ref(doc.add(Object::Dict(sig))));
}
// Nested in another object, it follows nothing, but known directly it is one all the same.
let mut nested = pdfcraft_cos::Dict::new();
nested.set(b"Type".to_vec(), Object::name("Sig"));
nested.set(b"Contents".to_vec(), Object::String(PdfString { bytes: vec![0xAB, 0xBA], hex: true }));
let mut field = pdfcraft_cos::Dict::new();
field.set(b"V".to_vec(), Object::Dict(nested));
signatures.push(Object::Ref(doc.add(Object::Dict(field))));
// Neither of what makes one: a string /Contents alone is anybody's, so it's encrypted.
let mut other = pdfcraft_cos::Dict::new();
other.set(b"Contents".to_vec(), Object::String(PdfString { bytes: vec![0xAB, 0xCD], hex: true }));
signatures.push(Object::Ref(doc.add(Object::Dict(other))));
doc.update_dict(doc.root().unwrap(), |c| c.set(b"Test".to_vec(), Object::Array(signatures))).unwrap();
doc.set_encryption(&NewEncryption {
algorithm: Algorithm::Aes256,
user_password: "",
owner_password: "owner",
permissions: -1,
encrypt_metadata: true,
seed: [3; 32],
})
.unwrap();
let bytes = write_full(&doc, &SaveOptions { object_streams: false, ..SaveOptions::default() }).unwrap();
for contents in ["DEAD", "BEEF", "CAFE", "F00D", "D00D", "ABBA"] {
assert!(holds(&bytes, &format!("<{contents}>")), "{contents}: written as is");
}
assert!(!holds(&bytes, "<ABCD>"), "without a /ByteRange it is no signature");
}
/// What a test needs to write an update of a classic file protected with AES-128.
struct Classic {
bytes: Vec<u8>,
root: ObjRef,
pages: ObjRef,
info: ObjRef,
encrypt: ObjRef,
id: Vec<u8>,
dict: pdfcraft_cos::Dict,
}
fn classic_file() -> Classic {
let mut doc = Document::open(Arc::new(fixture())).unwrap();
doc.set_encryption(&NewEncryption {
algorithm: Algorithm::Aes128,
user_password: "",
owner_password: "owner",
permissions: -1,
encrypt_metadata: true,
seed: [9; 32],
})
.unwrap();
let bytes = write_full(&doc, &SaveOptions { object_streams: false, ..SaveOptions::default() }).unwrap();
let doc = Document::open(Arc::new(bytes.clone())).unwrap();
let encrypt = doc.trailer().reference(b"Encrypt").unwrap();
let id = doc.trailer().get(b"ID").unwrap().as_array().unwrap()[0].as_string().unwrap().bytes.clone();
let dict = doc.get(encrypt).as_dict().cloned().unwrap();
let pages = doc.get(doc.root().unwrap()).as_dict().unwrap().reference(b"Pages").unwrap();
Classic { root: doc.root().unwrap(), pages, info: doc.trailer().reference(b"Info").unwrap(), bytes, encrypt, id, dict }
}
fn hex(bytes: &[u8]) -> String {
bytes.iter().map(|b| format!("{b:02X}")).collect()
}
/// `bytes` with an update appended: `objects`, and a trailer of `trailer` entries, in which `@n`
/// stands for the offset of object `n`. An object with nothing in it gets an entry of the
/// cross-reference table that points at nothing.
fn updated(bytes: &[u8], objects: &[(u32, Vec<u8>)], trailer: &str) -> Vec<u8> {
let at = bytes.windows(9).rposition(|w| w == b"startxref").unwrap();
let prev: usize = String::from_utf8_lossy(&bytes[at + 9..]).split_whitespace().next().unwrap().parse().unwrap();
let mut out = bytes.to_vec();
let mut table = String::from("xref\n");
let mut trailer = trailer.to_string();
for (num, body) in objects {
if body.is_empty() {
table.push_str(&format!("{num} 1\n0000000010 00000 n \n"));
continue;
}
trailer = trailer.replace(&format!("@{num}"), &out.len().to_string());
table.push_str(&format!("{num} 1\n{:010} 00000 n \n", out.len()));
out.extend_from_slice(format!("{num} 0 obj\n").as_bytes());
out.extend_from_slice(body);
out.extend_from_slice(b"\nendobj\n");
}
let xref = out.len();
out.extend_from_slice(table.as_bytes());
out.extend_from_slice(format!("trailer\n<< {trailer} /Size 2000 /Prev {prev} >>\nstartxref\n{xref}\n%%EOF\n").as_bytes());
out
}
/// The `/Encrypt` dictionary of `file`, with `/O`, `/StmF` and `/StrF` as given.
fn encrypt_with(file: &Classic, o: &str, filter: &str) -> Vec<u8> {
let string = |key: &[u8]| hex(&file.dict.get(key).unwrap().as_string().unwrap().bytes);
format!(
"<< /Filter /Standard /V 4 /R 4 /Length 128 /P {} /O {o} /U <{}> /CF << /StdCF << /CFM /AESV2 /Length 16 /AuthEvent /DocOpen >> >> /StmF /{filter} /StrF /{filter} >>",
file.dict.int(b"P").unwrap(),
string(b"U")
)
.into_bytes()
}
/// An object stream can have its parameters by reference, and a stream's crypt filter can be
/// selected by a member of it: legal together, though each is rare. What reads the stream first
/// goes through the object stream, and members must come out of it as they do read directly. They
/// didn't, while a read made for a selector wasn't allowed to follow its own: the object stream was
/// kept undecoded, its members lost for good, and a full save wrote nulls without saying so.
#[test]
fn an_object_stream_reached_from_a_selector_keeps_its_members() {
let file = classic_file();
let parms = "[<< /Name /Identity >> null]";
let header = format!("902 0 903 {} ", parms.len() + 1);
let members = format!("{header}{parms} << /Keep (yes) >>");
let (mut rows, mut before) = (vec![1u8], 0u8);
for b in members.bytes() {
rows.push(b.wrapping_sub(before));
before = b;
}
let coded = pdfcraft_cos::Stream::flate(pdfcraft_cos::Dict::new(), &rows).raw;
let mut object_stream =
format!("<< /Type /ObjStm /N 2 /First {} /Filter /FlateDecode /DecodeParms 911 0 R /Length {} >>\nstream\n", header.len(), coded.len())
.into_bytes();
object_stream.extend_from_slice(&coded);
object_stream.extend_from_slice(b"\nendstream");
let data = [2u8, 0x03, 0x8E, 0, 2, 0x03, 0x8E, 1];
let mut xref = format!("<< /Type /XRef /Size 2000 /W [1 2 1] /Index [902 2] /Length {} >>\nstream\n", data.len()).into_bytes();
xref.extend_from_slice(&data);
xref.extend_from_slice(b"\nendstream");
let string = |key: &[u8]| format!("<{}>", hex(&file.dict.get(key).unwrap().as_string().unwrap().bytes));
let objects = [
(file.root.num, format!("<< /Type /Catalog /Pages {} 0 R /A 900 0 R /B 903 0 R >>", file.pages.num).into_bytes()),
(file.encrypt.num, encrypt_with(&file, &string(b"O"), "Identity")),
(900, b"<< /Filter [/Crypt /ASCIIHexDecode] /DecodeParms 902 0 R /Length 1 >>\nstream\n>\nendstream".to_vec()),
(910, object_stream),
(911, format!("<< /Predictor 11 /Columns {} >>", members.len()).into_bytes()),
(912, xref),
];
let trailer = format!("/Root {} 0 R /Encrypt {} 0 R /ID [<{id}> <{id}>] /XRefStm @912", file.root.num, file.encrypt.num, id = hex(&file.id));
let bytes = updated(&file.bytes, &objects, &trailer);
let keep =
|doc: &Document, r: &Object| doc.resolve(r).as_dict().and_then(|d| d.get(b"Keep")).and_then(Object::as_string).map(|s| s.bytes.clone());
let member = Object::Ref(ObjRef::new(903, 0));
let doc = Document::open(Arc::new(bytes.clone())).unwrap();
assert_eq!(keep(&doc, &member).as_deref(), Some(b"yes".as_slice()), "read first");
let doc = Document::open(Arc::new(bytes.clone())).unwrap();
let _ = doc.get(ObjRef::new(900, 0));
assert_eq!(keep(&doc, &member).as_deref(), Some(b"yes".as_slice()), "read after the stream selecting from it");
let saved = write_full(&Document::open(Arc::new(bytes)).unwrap(), &SaveOptions::default()).unwrap();
let back = Document::open(Arc::new(saved)).unwrap();
let catalog = back.get(back.root().unwrap());
assert_eq!(keep(&back, catalog.as_dict().unwrap().get(b"B").unwrap()).as_deref(), Some(b"yes".as_slice()), "after a full save");
}
/// `walk` goes as deep as an object nests, so following a reference from down there adds that depth
/// again for each object it loads: this file, under 10 KB, overflowed a 2 MiB stack and took the
/// process with it. Only the object itself follows references, and it does so in very little stack.
#[test]
fn nested_dictionaries_load_nothing_on_a_small_stack() {
let file = classic_file();
let first = 960u32;
let objects: Vec<(u32, Vec<u8>)> = (first..first + 40)
.map(|num| {
let open = "[".repeat(120);
let close = "]".repeat(120);
(num, format!("{open}<< /Contents () /Type {} 0 R >>{close}", num + 1).into_bytes())
})
.collect();
let trailer = format!("/Root {} 0 R /Encrypt {} 0 R /ID [<{id}> <{id}>]", file.root.num, file.encrypt.num, id = hex(&file.id));
let bytes = updated(&file.bytes, &objects, &trailer);
let reading = std::thread::Builder::new().stack_size(1 << 20).spawn(move || {
let doc = Document::open(Arc::new(bytes)).unwrap();
doc.get(ObjRef::new(first, 0)).as_array().is_some()
});
assert_eq!(reading.unwrap().join().ok(), Some(true));
}
/// The object itself can follow references, a ladder of them as long as loading may nest, and that
/// fits a small stack too.
#[test]
fn a_ladder_of_signature_checks_fits_a_small_stack() {
let file = classic_file();
let first = 960u32;
let objects: Vec<(u32, Vec<u8>)> =
(first..first + 40).map(|num| (num, format!("<< /Contents () /Type {} 0 R >>", num + 1).into_bytes())).collect();
let trailer = format!("/Root {} 0 R /Encrypt {} 0 R /ID [<{id}> <{id}>]", file.root.num, file.encrypt.num, id = hex(&file.id));
let bytes = updated(&file.bytes, &objects, &trailer);
let reading = std::thread::Builder::new().stack_size(1 << 20).spawn(move || {
let doc = Document::open(Arc::new(bytes)).unwrap();
doc.get(ObjRef::new(first, 0)).as_dict().is_some()
});
assert_eq!(reading.unwrap().join().ok(), Some(true));
}
/// The strings of `/Encrypt` are never encrypted (ISO 32000-2 §7.6.2), and can be objects of their
/// own. Read as ordinary strings they were decrypted, and a full save encrypted them again under
/// another number, so the file it wrote no longer opened with its own password.
#[test]
fn encrypt_strings_given_by_reference_stay_as_stored() {
let file = classic_file();
let string = |key: &[u8]| hex(&file.dict.get(key).unwrap().as_string().unwrap().bytes);
let replaced = format!(
"<< /Filter /Standard /V 4 /R 4 /Length 128 /P {} /O 900 0 R /U 901 0 R /CF << /StdCF << /CFM /AESV2 /Length 16 /AuthEvent /DocOpen >> >> /StmF /StdCF /StrF /StdCF >>",
file.dict.int(b"P").unwrap()
);
let objects = [
(file.encrypt.num, replaced.into_bytes()),
(900, format!("<{}>", string(b"O")).into_bytes()),
(901, format!("<{}>", string(b"U")).into_bytes()),
];
let trailer =
format!("/Root {} 0 R /Info {} 0 R /Encrypt {} 0 R /ID [<{id}> <{id}>]", file.root.num, file.info.num, file.encrypt.num, id = hex(&file.id));
let source = Document::open(Arc::new(updated(&file.bytes, &objects, &trailer))).unwrap();
assert_eq!(content(&source), SECRET, "the file reads");
assert_eq!(title(&source).as_deref(), Some("Quarterly numbers"));
for object_streams in [false, true] {
let saved = write_full(&source, &SaveOptions { object_streams, ..SaveOptions::default() }).unwrap();
let back = Document::open(Arc::new(saved)).unwrap();
assert_eq!(content(&back), SECRET, "object streams: {object_streams}");
assert_eq!(title(&back).as_deref(), Some("Quarterly numbers"), "object streams: {object_streams}");
}
}
/// A save keeps what a file is protected with: its `/Encrypt`, which holds the handler and the
/// permissions, its `/ID`, and so its file key, under every algorithm and by either kind of save.
#[test]
fn a_save_keeps_the_handler_the_key_and_the_permissions() {
for alg in ALL {
let doc = Document::open_with_password(Arc::new(protect(alg, "user", "owner", -1 ^ 0b1_0000)), Some("user")).unwrap();
let held = |d: &Document| {
let encrypt = d.resolve(d.trailer().get(b"Encrypt").unwrap()).as_dict().unwrap().clone();
(encrypt, d.trailer().get(b"ID").cloned(), d.security().unwrap().file_key().to_vec(), format!("{:?}", d.permissions()))
};
let before = held(&doc);
let mut edited = doc.clone();
let _ = edited.add(Object::Int(1));
for (save, saved) in [
("incremental", write_incremental(&edited, &SaveOptions::default()).unwrap()),
("full", write_full(&doc, &SaveOptions::default()).unwrap()),
] {
let back = Document::open_with_password(Arc::new(saved), Some("user")).unwrap();
assert!(held(&back) == before, "{alg:?}: a {save} save");
assert_eq!(content(&back), SECRET, "{alg:?}: a {save} save");
}
}
}
/// `/ID` has to be direct in an encrypted file, but one that isn't has its key made from the same
/// bytes. A full save writes it direct, and an incremental one leaves it as it was.
#[test]
fn a_file_identifier_given_by_reference_is_read() {
let file = classic_file();
let id = hex(&file.id);
let reference = |entries: &str, objects: &[(u32, Vec<u8>)]| {
let trailer = format!("/Root {} 0 R /Encrypt {} 0 R /ID {entries}", file.root.num, file.encrypt.num);
updated(&file.bytes, objects, &trailer)
};
let whole = reference("900 0 R", &[(900, format!("[<{id}> <{id}>]").into_bytes())]);
let entries = reference("[900 0 R 901 0 R]", &[(900, format!("<{id}>").into_bytes()), (901, format!("<{id}>").into_bytes())]);
for file in [whole, entries] {
let source = Document::open(Arc::new(file)).unwrap();
assert_eq!(content(&source), SECRET);
let back = Document::open(Arc::new(write_full(&source, &SaveOptions::default()).unwrap())).unwrap();
assert_eq!(content(&back), SECRET);
assert!(matches!(back.trailer().get(b"ID"), Some(Object::Array(_))), "written direct");
let mut edited = source.clone();
let _ = edited.add(Object::Int(1));
let back = Document::open(Arc::new(write_incremental(&edited, &SaveOptions::default()).unwrap())).unwrap();
assert_eq!(content(&back), SECRET, "an incremental save");
assert_eq!(back.trailer().get(b"ID"), edited.trailer().get(b"ID"), "and leaves it as it was");
}
}
/// A direct `/Encrypt` can refer to objects. A full save dropped those it found only there, and kept
/// its references as they were under the old numbers, so nothing in the file read afterwards.
#[test]
fn a_direct_encrypt_dictionary_keeps_what_it_refers_to() {
for object_streams in [false, true] {
let mut doc = Document::open(Arc::new(fixture())).unwrap();
doc.set_encryption(&NewEncryption {
algorithm: Algorithm::Aes128,
user_password: "",
owner_password: "owner",
permissions: -1,
encrypt_metadata: true,
seed: [9; 32],
})
.unwrap();
let mut dict = doc.get(doc.trailer().reference(b"Encrypt").unwrap()).as_dict().cloned().unwrap();
let filter = doc.add(Object::name("StdCF"));
let filters = doc.add(dict.get(b"CF").unwrap().clone());
dict.set(b"StmF".to_vec(), Object::Ref(filter));
dict.set(b"CF".to_vec(), Object::Ref(filters));
doc.trailer_mut().set(b"Encrypt".to_vec(), Object::Dict(dict));
let options = SaveOptions { object_streams, ..SaveOptions::default() };
let saved = write_full(&doc, &options).unwrap();
let back = Document::open(Arc::new(saved)).unwrap();
assert_eq!(content(&back), SECRET, "object streams: {object_streams}");
let again = write_full(&back, &options).unwrap();
assert_eq!(content(&Document::open(Arc::new(again)).unwrap()), SECRET, "object streams: {object_streams}, saved again");
}
}
/// How a stream is treated can be given by reference, and what that loads can be a stream too. A
/// file can make a ladder of those, where each rung reads the rung below, then two trees wider than
/// the object cache, which push that rung out of it, then the rung below again. Each rung would
/// take twice what the one below does, if one read could follow any number of references.
#[test]
fn selectors_that_lead_to_selectors_load_at_once() {
let mut doc = Document::open(Arc::new(protect(Algorithm::Aes128, "", "owner", -1))).unwrap();
let stream_of = |doc: &mut Document, filters: Vec<Object>| {
let mut dict = pdfcraft_cos::Dict::new();
dict.set(b"Filter".to_vec(), Object::Array(filters));
doc.add(Object::Stream(pdfcraft_cos::Stream::from_raw(dict, Vec::new())))
};
let tree = |doc: &mut Document| {
let mut level: Vec<ObjRef> = (0..6_561).map(|i| doc.add(Object::Int(i))).collect();
while level.len() > 1 {
let chunks: Vec<Vec<Object>> = level.chunks(9).map(|c| c.iter().map(|r| Object::Ref(*r)).collect()).collect();
level = chunks.into_iter().map(|c| stream_of(doc, c)).collect();
}
Object::Ref(level[0])
};
let (first, second) = (tree(&mut doc), tree(&mut doc));
let mut top = doc.add(Object::Int(0));
// Twelve rungs of two, and the trees' five levels, stay inside the 32 that loading may nest.
for _ in 0..12 {
let (a, b) = (stream_of(&mut doc, vec![Object::Ref(top)]), stream_of(&mut doc, vec![Object::Ref(top)]));
top = stream_of(&mut doc, vec![Object::Ref(a), first.clone(), second.clone(), Object::Ref(b)]);
}
let saved = write_incremental(&doc, &SaveOptions::default()).unwrap();
let (done, finished) = std::sync::mpsc::channel();
std::thread::spawn(move || {
let doc = Document::open(Arc::new(saved)).unwrap();
let _ = done.send(doc.get(top).as_dict().is_some());
});
// With the budget it takes milliseconds, and without it longer than anyone would wait, so a
// margin this wide can't fail on a busy machine.
assert_eq!(finished.recv_timeout(std::time::Duration::from_secs(120)), Ok(true), "loading must not fan out");
}
crates/engine/src/tests.rs
+101
View File
@@ -10252,6 +10252,107 @@ fn image_transform_engine_refuses_singular_matrices_without_mutation() {
}
}
/// Optimize has JBIG2 images share a symbol dictionary only where redaction can store each again
/// without it. Of four pages of the same scan, the two in DeviceGray and the image mask share one;
/// the one in a DeviceN of one colourant, which redaction doesn't store again, is coded alone.
/// Redacting the first page then stores the second and the mask again without the dictionary,
/// which leaves the file.
#[test]
fn redacting_an_optimized_jbig2_page_stores_the_rest_of_its_group_again() {
use pdfcraft_cos::{Dict, Document, ObjRef, Object, SaveOptions, Stream, write_full};
let (w, h) = (600usize, 480usize);
// Lines of 26 letters, each 32 rows of a run from a stem down its left side, of 2 to 24 pixels,
// the same to the pixel wherever it is, picked and spaced at random.
let mut seed = 0x2545_F491_4F6C_DD1Du64;
let mut next = move || {
seed ^= seed << 13;
seed ^= seed >> 7;
seed ^= seed << 17;
seed as usize
};
let letters: Vec<Vec<usize>> = (0..26).map(|_| (0..16).map(|_| 1 + next() % 12).collect()).collect();
let stride = w.div_ceil(8);
let mut bits = vec![0xFFu8; stride * h];
for top in (8..h - 40).step_by(44) {
let mut x = 8 + next() % 8;
while x + 32 < w {
let letter = &letters[next() % 26];
for (row, run) in letter.iter().enumerate() {
for (px, py) in (x..x + 2 * run).flat_map(|px| [(px, top + 2 * row), (px, top + 2 * row + 1)]) {
bits[py * stride + px / 8] &= !(0x80 >> (px % 8));
}
}
x += 2 * letter.iter().max().unwrap_or(&1) + 4 + next() % 5;
}
}
let mut doc = Document::new_empty();
let pages = doc.root().and_then(|r| doc.get(r).as_dict().and_then(|d| d.reference(b"Pages"))).unwrap();
let device_n = Object::Array(vec![Object::name("DeviceN"), Object::Array(vec![Object::name("Black")]), Object::name("DeviceGray"), {
let mut tint = Dict::new();
tint.set(b"FunctionType".to_vec(), Object::Int(2));
tint.set(b"Domain".to_vec(), Object::Array(vec![Object::Int(0), Object::Int(1)]));
tint.set(b"N".to_vec(), Object::Int(1));
Object::Dict(tint)
}]);
let mut images: Vec<ObjRef> = Vec::new();
let grey = || ("ColorSpace", Object::name("DeviceGray"));
for (k, (key, value)) in [grey(), grey(), ("ColorSpace", device_n), ("ImageMask", Object::Bool(true))].into_iter().enumerate() {
let mut d = Dict::new();
d.set(b"Type".to_vec(), Object::name("XObject"));
d.set(b"Subtype".to_vec(), Object::name("Image"));
d.set(b"Width".to_vec(), Object::Int(w as i64));
d.set(b"Height".to_vec(), Object::Int(h as i64));
d.set(b"BitsPerComponent".to_vec(), Object::Int(1));
d.set(key.as_bytes().to_vec(), value);
let image = doc.add(Object::Stream(Stream::flate(d, &bits)));
images.push(image);
let content = doc.add(Object::Stream(Stream::from_raw(Dict::new(), b"q 144 0 0 115.2 36 600 cm /Im Do Q".to_vec())));
let mut xobjects = Dict::new();
xobjects.set(b"Im".to_vec(), Object::Ref(image));
let mut resources = Dict::new();
resources.set(b"XObject".to_vec(), Object::Dict(xobjects));
let mut page = Dict::new();
page.set(b"Type".to_vec(), Object::name("Page"));
page.set(b"Parent".to_vec(), Object::Ref(pages));
page.set(b"MediaBox".to_vec(), Object::Array(vec![0.into(), 0.into(), 612.into(), 792.into()]));
page.set(b"Resources".to_vec(), Object::Dict(resources));
page.set(b"Contents".to_vec(), Object::Ref(content));
if k == 0 {
let mut mark = Dict::new();
mark.set(b"Type".to_vec(), Object::name("Annot"));
mark.set(b"Subtype".to_vec(), Object::name("Redact"));
mark.set(b"Rect".to_vec(), Object::Array(vec![40.into(), 610.into(), 100.into(), 650.into()]));
let mark = doc.add(Object::Dict(mark));
page.set(b"Annots".to_vec(), Object::Array(vec![Object::Ref(mark)]));
}
let page = doc.add(Object::Dict(page));
doc.update_dict(pages, |d| {
let mut kids = d.get(b"Kids").and_then(|k| k.as_array().cloned()).unwrap_or_default();
kids.push(Object::Ref(page));
d.set(b"Count".to_vec(), Object::Int(kids.len() as i64));
d.set(b"Kids".to_vec(), Object::Array(kids));
})
.unwrap();
}
let mono = pdfcraft_optimize::MonoSettings {
compression: pdfcraft_optimize::MonoCompression::Jbig2,
downsample: false,
..pdfcraft_optimize::MonoSettings::REDUCE
};
pdfcraft_optimize::optimize(&mut doc, &pdfcraft_optimize::Settings { mono, ..Default::default() }).unwrap();
let globals = |doc: &Document, image: ObjRef| match &*doc.get(image) {
Object::Stream(s) => s.dict.get(b"DecodeParms").and_then(Object::as_dict).and_then(|d| d.reference(b"JBIG2Globals")),
_ => None,
};
let shared = globals(&doc, images[0]);
assert!(shared.is_some() && globals(&doc, images[1]) == shared && globals(&doc, images[3]) == shared, "DeviceGray and the mask share");
assert_eq!(globals(&doc, images[2]), None, "the DeviceN page is coded alone");
pdfcraft_redact::apply(&mut doc, None).unwrap();
let saved = Document::open(Arc::new(write_full(&doc, &SaveOptions::default()).unwrap())).unwrap();
let named = saved.scan_objects().filter(|(_, o)| matches!(&**o, Object::Stream(s) if saved.jbig2_globals_ref(s).is_some())).count();
assert_eq!(named, 0, "no image names the dictionary, which left with them");
}
#[test]
fn fill_sign_multiline_text_survives_engine_save_reopen_and_render() {
let (mut session, id) = rotated_blank(0);
crates/filters/README.md
+3 -2
View File
@@ -31,6 +31,7 @@ decode_ccitt_within(data, &params, max_rows, work: &mut u64) -> Result<Vec<u8>,
decode_jbig2_within(data, globals, columns, rows, max, work: &mut u64) -> Result<Vec<u8>, FilterError> // JBIG2 as JBIG2Decode gives it; a page of columns × rows, within max and MAX_JBIG2_PIXELS; reading and decoding it spend from work, in the decoder's steps
encode_jbig2_generic(data, columns, rows) -> Result<Vec<u8>, FilterError> // 1-bit rows as lossless JBIG2 for JBIG2Decode; columns and rows <= MAX_JBIG2_COLUMNS (65,535) and MAX_JBIG2_PIXELS (2^28) samples, what the decoder takes
encode_jbig2(data, columns, rows) -> Result<Vec<u8>, FilterError> // 1-bit rows as lossless JBIG2 for JBIG2Decode, symbol coded when that is smaller; the same limits
encode_jbig2_shared(&[(data, columns, rows)]) -> Result<Option<SharedJbig2>, FilterError> // images symbol coded sharing one dictionary: the /JBIG2Globals data, and each image's stream or None; the same limits
```
- `chain` is applied first to last, as in a `/Filter` array.
@@ -51,7 +52,7 @@ encode_jbig2(data, columns, rows) -> Result<Vec<u8>, FilterError> // 1-bit row
| ASCII85Decode | `<~` prefix, `z`, white space, `~>` (or bare `~`, or none) EOD, final partial group; `z` inside a group, a 1-char final group, overflow or bad characters → Corrupt | `z` for zero groups, newline every 75 characters, `~>` |
| RunLengthDecode | 0–127 literal, 129–255 repeat, 128 EOD (optional); truncated run → Corrupt | runs of ≥2 repeat, literals up to 128, 128 |
| CCITTFaxDecode | not in a chain (`Unsupported`); `decode_ccitt_within` decodes Group 3 and Group 4 on its own, as rows of 1-bit samples each on a new byte, black 0 unless `black_is_1`, at most `max_rows` rows (fewer with `/Rows`), the rows before any damage, up to 1,048,576 samples a row; Group 3 rows on bytes are read by their end-of-line codes when the data starts with one and on bytes otherwise, whatever `end_of_line` says, so data with codes but none before the first row (not as T.4 sends them) is read on bytes, as the renderer draws it, and at `k` 0 may come out as other rows (`pdfcraft_cos::ImageBudget::decode` calls it for a fax image, after the filters before it) | `encode_g4`: Group 4 (`/K -1`) with an end-of-block mark, 0 bits coded black so `/BlackIs1 false` decodes the same bits; rows packed MSB first, each on a new byte, padding bits and trailing bytes ignored; up to 32,767 samples a row (the encoder counts positions in 16 bits); no rows or columns, or too wide → Unsupported, too few bytes → Corrupt |
| JBIG2Decode | not in a chain (`Unsupported`); `decode_jbig2_within` decodes it on its own with `hayro-jbig2`, given what its `/JBIG2Globals` decode to, as rows of 1-bit samples each on a new byte, black 0; the page has to be `columns` × `rows` (PdfCraft's renderer draws the whole page into the image), within `max` bytes as such rows and 2^28 pixels (`MAX_JBIG2_PIXELS`, the most the decoder takes), checked before it is decoded; regions inside it are bounded by the decoder alone (a region may claim more pixels than its page); damaged data, or globals that don't decode, are `Corrupt` (`pdfcraft_cos::ImageBudget::decode` calls it for a JBIG2 image, after the filters before it) | `encode_jbig2_generic`: the embedded organisation (D.3) with a page information segment and an immediate lossless generic region (7.4.6), no `/JBIG2Globals`; template 0 with its nominal AT pixels and typical prediction (6.2.5), coded with the MQ arithmetic coder (Annex E, Table E.1) and ended by its 0xFF 0xAC marker. A 0 sample is coded as a JBIG2 1 (black), since `JBIG2Decode` gives black as 0, so the stream decodes to the same bits; rows packed MSB first, each on a new byte, padding bits and trailing bytes ignored; up to 65,535 samples on a side and 2^28 in all, where `hayro-jbig2` stops; no rows or columns, or too large → Unsupported, too few bytes → Corrupt. `encode_jbig2`: the smaller of that and symbol coding (`jbig2/symbols.rs`): each distinct mark (8-connected black pixels, at most 256 a side) stored once in a symbol dictionary (7.4.2; arithmetic coded, each bitmap a template 0 generic region without typical prediction, the bitmaps sharing their contexts) and placed by immediate lossless text regions referring to it (7.4.3; bottom-left reference corner, strips of 1, 2, 4 or 8 rows, whichever is smallest), each of at most 10,000 instances over a band of rows, as the decoder PdfCraft renders with (`hayro-jbig2`) takes no more in one region, with larger marks, and in a second plan marks that occur once, in a generic region over their box. Only exact copies share a symbol (no refinement), so the stream decodes to the same bits; fewer than two symbols, more than 2^20 black runs, 65,536 distinct marks or 16 MiB of their pixels, and the generic coding is used; a plan of more than 32,767 symbols (that decoder refuses more) isn't made |
| JBIG2Decode | not in a chain (`Unsupported`); `decode_jbig2_within` decodes it on its own with `hayro-jbig2`, given what its `/JBIG2Globals` decode to, as rows of 1-bit samples each on a new byte, black 0; the page has to be `columns` × `rows` (PdfCraft's renderer draws the whole page into the image), within `max` bytes as such rows and 2^28 pixels (`MAX_JBIG2_PIXELS`, the most the decoder takes), checked before it is decoded; regions inside it are bounded by the decoder alone (a region may claim more pixels than its page); damaged data, or globals that don't decode, are `Corrupt` (`pdfcraft_cos::ImageBudget::decode` calls it for a JBIG2 image, after the filters before it) | `encode_jbig2_generic`: the embedded organisation (D.3) with a page information segment and an immediate lossless generic region (7.4.6), no `/JBIG2Globals`; template 0 with its nominal AT pixels and typical prediction (6.2.5), coded with the MQ arithmetic coder (Annex E, Table E.1) and ended by its 0xFF 0xAC marker. A 0 sample is coded as a JBIG2 1 (black), since `JBIG2Decode` gives black as 0, so the stream decodes to the same bits; rows packed MSB first, each on a new byte, padding bits and trailing bytes ignored; up to 65,535 samples on a side and 2^28 in all, where `hayro-jbig2` stops; no rows or columns, or too large → Unsupported, too few bytes → Corrupt. `encode_jbig2`: the smaller of that and symbol coding (`jbig2/symbols.rs`): each distinct mark (8-connected black pixels, at most 256 a side) stored once in a symbol dictionary (7.4.2; arithmetic coded, each bitmap a template 0 generic region without typical prediction, the bitmaps sharing their contexts) and placed by immediate lossless text regions referring to it (7.4.3; bottom-left reference corner, strips of 1, 2, 4 or 8 rows, whichever is smallest), each of at most 10,000 instances over a band of rows, as the decoder PdfCraft renders with (`hayro-jbig2`) takes no more in one region, with larger marks, and in a second plan marks that occur once, in a generic region over their box. Only exact copies share a symbol (no refinement), so the stream decodes to the same bits; fewer than two symbols, more than 2^20 black runs, 65,536 distinct marks or 16 MiB of their pixels, and the generic coding is used; a plan of more than 32,767 symbols (that decoder refuses more) isn't made. `encode_jbig2_shared`: the marks found in more than one image of a group (at most 16,383, those in the most images first, within the same limits on distinct marks and their pixels as one image's) go once in a symbol dictionary segment associated with no page, number 0, which is the `/JBIG2Globals` data (7.2.6, D.3); each image's stream numbers its segments from 1 (a segment refers only to lower numbers, 7.2.5) and its text regions refer to that dictionary first, then to one of its own for the marks only it repeats, so the shared symbols' IDs come first (Table 31's SBSYMS); the rest is coded as `encode_jbig2`'s symbol coding codes it, the smaller of its two plans. An image that places none of the shared marks gets no stream, to be stored alone; whether the rest save more than the globals take is the caller's to weigh |
## Tests
@@ -62,7 +63,7 @@ encode_jbig2(data, columns, rows) -> Result<Vec<u8>, FilterError> // 1-bit row
- `mq.rs`: the arithmetic coder reproduces Annex H.2's 30 bytes from its 256 decisions.
- `jbig2.rs`: output decoded by `hayro-jbig2` (dev-dependency, an independent decoder) matches the input bits: a text-like page (smaller than Group 4), edges, padding, all-white and all-black regions (typical rows), and property tests over bitmaps of noise and of runs; any input returns rather than panics.
- `jbig2/decode.rs`: `decode_jbig2_within` gives back the rows of both codings, padding bits 0; refuses a page of another width or height, past `max` or past `MAX_JBIG2_PIXELS` before decoding it (2^28 pixels take about 34 MB, a bit each), globals that aren't JBIG2 and damaged data, and returns rather than panics on every prefix of a stream.
- `jbig2/symbols.rs`: the integer coders against Annex A's example and Table A.1; symbol-coded output decoded by `hayro-jbig2` matches the input bits for every plan and strip size: text whose letters repeat (under half the generic coding's size, the dictionary retained and referred to), large and lone marks left to a generic region, marks on the edges, touching at corners and inside each other's boxes, and property tests over glyphs scattered over each other and the edges with stray pixels (never larger than the generic coding); one shape, a blank page and noise are coded generically; marks joined at a corner, either way, are one mark, and 256 pixels a side is a symbol while 257 wide or tall is left out; black padding bits are ignored; coordinates past 4,435 use Annex A's 32-bit range and PREV stays below 512; past 2^20 runs, 65,536 distinct marks or 2^24 symbol pixels the image is coded generically, and at each cap it is still looked at; a plan codes at most 32,767 symbols, which decode, and past that the second plan still codes the repeated ones; more than 10,000 marks are placed by several text regions, numbered in turn, the dictionary retained for each but the last; any input returns rather than panics.
- `jbig2/symbols.rs`: the integer coders against Annex A's example and Table A.1; symbol-coded output decoded by `hayro-jbig2` matches the input bits for every plan and strip size: text whose letters repeat (under half the generic coding's size, the dictionary retained and referred to), large and lone marks left to a generic region, marks on the edges, touching at corners and inside each other's boxes, and property tests over glyphs scattered over each other and the edges with stray pixels (never larger than the generic coding); one shape, a blank page and noise are coded generically; marks joined at a corner, either way, are one mark, and 256 pixels a side is a symbol while 257 wide or tall is left out; black padding bits are ignored; coordinates past 4,435 use Annex A's 32-bit range and PREV stays below 512; past 2^20 runs, 65,536 distinct marks or 2^24 symbol pixels the image is coded generically, and at each cap it is still looked at; a plan codes at most 32,767 symbols, which decode, and past that the second plan still codes the repeated ones; more than 10,000 marks are placed by several text regions, numbered in turn, the dictionary retained for each but the last; pages in one font share one dictionary, segment 0 of no page, retained, which each page's text regions refer to first, taking less together than alone, a page's own repeated marks in a dictionary referred to after it, a page sharing nothing left alone, images with fewer than two marks in common sharing nothing, and past 16,383 shared marks those in the most images kept, with a property test over groups of scattered pages; any input returns rather than panics.
- `fuzz/`: a detached cargo-fuzz crate (`cargo +nightly fuzz run decode`, run from `crates/filters/`).
## Status
crates/filters/src/jbig2.rs
+75 -18
View File
@@ -1,8 +1,9 @@
//! JBIG2 encoding (ITU-T T.88 | ISO/IEC 14492), for `JBIG2Decode` (ISO 32000-2 §7.4.7), lossless:
//! a generic region, template 0 with its nominal adaptive pixels, typical prediction on, MQ
//! arithmetic coding ([`crate::mq`]); or the image's marks as symbols ([`symbols`]). Written from
//! the standard's 6.2.5 (coding a generic region), 7.2 (segment headers), 7.4.1, 7.4.6 and 7.4.8
//! (the segments) and D.3 (the embedded organisation PDF uses). Decoding is in [`decode`].
//! arithmetic coding ([`crate::mq`]); or the image's marks as symbols ([`symbols`]), which a group
//! of images may share through `/JBIG2Globals`. Written from the standard's 6.2.5 (coding a generic
//! region), 7.2 (segment headers), 7.4.1, 7.4.6 and 7.4.8 (the segments) and D.3 (the embedded
//! organisation PDF uses). Decoding is in [`decode`].
mod decode;
mod symbols;
@@ -56,9 +57,7 @@ const PAD: usize = 4;
/// Errors: as [`encode_jbig2_generic`].
pub fn encode_jbig2(data: &[u8], columns: u32, rows: u32) -> Result<Vec<u8>, FilterError> {
let generic = encode_jbig2_generic(data, columns, rows)?;
// `encode_jbig2_generic` checked that the rows are there.
let stride = (columns as usize).div_ceil(8);
let samples = usize::try_from(rows).ok().and_then(|r| r.checked_mul(stride)).and_then(|n| data.get(..n));
let samples = rows_to_encode(data, columns, rows).ok();
Ok(match samples.and_then(|s| symbols::encode(s, columns, rows)) {
Some(coded) if coded.len() < generic.len() => coded,
_ => generic,
@@ -78,16 +77,9 @@ pub fn encode_jbig2(data: &[u8], columns: u32, rows: u32) -> Result<Vec<u8>, Fil
/// [`MAX_JBIG2_PIXELS`], what the decoder takes ([`FilterError::Unsupported`]); fewer bytes than the
/// rows need ([`FilterError::Corrupt`]).
pub fn encode_jbig2_generic(data: &[u8], columns: u32, rows: u32) -> Result<Vec<u8>, FilterError> {
let too_large = columns > MAX_JBIG2_COLUMNS || rows > MAX_JBIG2_COLUMNS || u64::from(columns) * u64::from(rows) > MAX_JBIG2_PIXELS;
if columns == 0 || rows == 0 || too_large {
return Err(FilterError::Unsupported(format!("JBIG2 encoding of {columns} × {rows} samples")));
}
let samples = rows_to_encode(data, columns, rows)?;
let width = columns as usize;
let stride = width.div_ceil(8);
let samples = usize::try_from(rows).ok().and_then(|r| r.checked_mul(stride)).and_then(|n| data.get(..n)).ok_or_else(|| FilterError::Corrupt {
filter: "JBIG2Decode",
detail: format!("{} bytes for {rows} rows of {columns} samples", data.len()),
})?;
let mut contexts: Vec<Context> = vec![0; 1 << 16];
let mut mq = MqEncoder::new();
let height = samples.len() / stride;
@@ -105,6 +97,48 @@ pub fn encode_jbig2_generic(data: &[u8], columns: u32, rows: u32) -> Result<Vec<
Ok(out)
}
/// The samples of `rows` rows of `columns` 1-bit samples in `data`, when the encoders here take
/// that size; the errors are [`encode_jbig2_generic`]'s.
fn rows_to_encode(data: &[u8], columns: u32, rows: u32) -> Result<&[u8], FilterError> {
let too_large = columns > MAX_JBIG2_COLUMNS || rows > MAX_JBIG2_COLUMNS || u64::from(columns) * u64::from(rows) > MAX_JBIG2_PIXELS;
if columns == 0 || rows == 0 || too_large {
return Err(FilterError::Unsupported(format!("JBIG2 encoding of {columns} × {rows} samples")));
}
let stride = (columns as usize).div_ceil(8);
usize::try_from(rows)
.ok()
.and_then(|r| r.checked_mul(stride))
.and_then(|n| data.get(..n))
.ok_or_else(|| FilterError::Corrupt { filter: "JBIG2Decode", detail: format!("{} bytes for {rows} rows of {columns} samples", data.len()) })
}
/// A group of images coded by [`encode_jbig2_shared`]: the data of the `/JBIG2Globals` stream
/// they share, and each image's own stream, in the order given, or `None` for one that shares
/// nothing with the others.
#[derive(Debug)]
pub struct SharedJbig2 {
pub globals: Vec<u8>,
pub images: Vec<Option<Vec<u8>>>,
}
/// Images, each `rows` rows of `columns` 1-bit PDF samples, as lossless JBIG2 sharing one symbol
/// dictionary: the marks found in more than one of them are stored once, in a symbol dictionary
/// segment not associated with a page, which is the `/JBIG2Globals` stream's data, and each image's
/// stream, in the embedded organisation, places them from there, with its other marks coded as
/// [`encode_jbig2`]'s symbol coding codes them (see [`symbols`]). With the globals, each decodes to
/// its own bits. An image that holds none of those marks, or that symbol coding doesn't take, has
/// no stream here; it is stored alone. `None` when the images share fewer than two marks.
///
/// What each image's stream saves is left for the caller to weigh against what the globals take,
/// which the images that use them share.
///
/// Errors: as [`encode_jbig2_generic`], for the first image it would refuse.
pub fn encode_jbig2_shared(images: &[(&[u8], u32, u32)]) -> Result<Option<SharedJbig2>, FilterError> {
let images =
images.iter().map(|(data, columns, rows)| Ok((rows_to_encode(data, *columns, *rows)?, *columns, *rows))).collect::<Result<Vec<_>, _>>()?;
Ok(symbols::encode_shared(&images).map(|(globals, images)| SharedJbig2 { globals, images }))
}
/// A page information segment's data (7.4.8): the page's size, resolution unknown, eventually
/// lossless, default pixel 0 (white), OR combination, not striped.
fn page_information(columns: u32, rows: u32) -> Vec<u8> {
@@ -145,12 +179,18 @@ fn at_pixels(out: &mut Vec<u8>) {
}
}
/// A segment (7.2): its header (number, type, the segments it refers to, page 1, data length),
/// then its data. `retained`: a later segment refers to this one. `refers_to` holds each
/// A segment (7.2) of page 1: its header (number, type, the segments it refers to, the page, data
/// length), then its data. `retained`: a later segment refers to this one. `refers_to` holds each
/// referred-to segment's number and whether a segment after this one refers to it too (its
/// retain bit, 7.2.4). Segment numbers here stay below 256, so each referred-to one takes a byte
/// (7.2.5); a segment refers to at most four, so their count and retain bits take one byte too.
fn segment(out: &mut Vec<u8>, number: u32, kind: u8, refers_to: &[(u8, bool)], retained: bool, data: &[u8]) {
segment_of(out, 1, number, kind, refers_to, retained, data);
}
/// [`segment`], of page `page`: 0 for a segment associated with no page (7.2.6), such as the
/// global ones `/JBIG2Globals` holds, which a page's segments may refer to.
fn segment_of(out: &mut Vec<u8>, page: u8, number: u32, kind: u8, refers_to: &[(u8, bool)], retained: bool, data: &[u8]) {
out.extend_from_slice(&number.to_be_bytes());
out.push(kind);
// At most four, so the count fits its three bits.
@@ -158,7 +198,7 @@ fn segment(out: &mut Vec<u8>, number: u32, kind: u8, refers_to: &[(u8, bool)], r
let kept = refers_to.iter().enumerate().fold(0u8, |bits, (k, (_, kept))| bits | u8::from(*kept) << (k + 1));
out.push((refers_to.len() as u8) << 5 | kept | u8::from(retained));
out.extend(refers_to.iter().map(|(n, _)| *n));
out.push(1);
out.push(page);
// A segment's data never comes near 4 GiB here: an image is at most 2^28 samples.
out.extend_from_slice(&u32::try_from(data.len()).unwrap_or(u32::MAX).to_be_bytes());
out.extend_from_slice(data);
@@ -216,6 +256,11 @@ mod tests {
/// The rows an independent decoder (`hayro-jbig2`) reads from `data`, as PDF samples: true
/// for white (a JBIG2 0).
pub(super) fn decode(data: &[u8]) -> Vec<Vec<bool>> {
decode_with(data, None)
}
/// [`decode`], with `/JBIG2Globals`.
pub(super) fn decode_with(data: &[u8], globals: Option<&[u8]>) -> Vec<Vec<bool>> {
struct Rows(Vec<Vec<bool>>, Vec<bool>, usize);
impl hayro_jbig2::Decoder for Rows {
fn push_pixel(&mut self, black: bool) {
@@ -230,7 +275,7 @@ mod tests {
self.0.push(row);
}
}
let image = hayro_jbig2::Image::new_embedded(data, None).unwrap();
let image = hayro_jbig2::Image::new_embedded(data, globals).unwrap();
let mut rows = Rows(Vec::new(), Vec::new(), image.width() as usize);
image.decode(&mut rows).unwrap();
rows.0
@@ -353,6 +398,18 @@ mod tests {
/// The encoder stops where the decoder does, on each side and in total: past that it would
/// write a stream nothing here can read. 16,384 squared is exactly the bound on samples.
/// `encode_jbig2_shared` refuses what `encode_jbig2_generic` refuses: an image taller than
/// the decoder takes is `Unsupported`, one at the bound isn't refused. (Its one tall mark is
/// too large to be a symbol, so nothing is shared: `Ok(None)`.)
#[test]
fn shared_coding_takes_only_what_the_decoder_takes() {
let past = vec![0x7F; MAX_JBIG2_COLUMNS as usize + 1];
let tall = (&past[..], 1, MAX_JBIG2_COLUMNS + 1);
assert!(matches!(encode_jbig2_shared(&[tall, tall]), Err(FilterError::Unsupported(_))), "too tall");
let at = (&past[..MAX_JBIG2_COLUMNS as usize], 1, MAX_JBIG2_COLUMNS);
assert!(matches!(encode_jbig2_shared(&[at, at]), Ok(None)), "at the bound");
}
#[test]
fn it_encodes_only_what_the_decoder_takes() {
let unsupported = |columns, rows| matches!(encode_jbig2_generic(&[], columns, rows), Err(FilterError::Unsupported(_)));
crates/filters/src/jbig2/decode.rs
+188
View File
@@ -144,6 +144,143 @@ mod tests {
assert_eq!(decode_jbig2(&symbols, None, w, h, usize::MAX).unwrap(), marks);
}
/// A region's location is unsigned (ISO/IEC 14492 5.4.4), so one past `i32::MAX` is off the
/// page. The decoder took it for a signed one: a region at 0xFFFFFFFC came back onto the page
/// four pixels left of it, and a refinement anywhere past `i32::MAX` was refused, and the page
/// with it. Each stream is a page of 16 × 12 covered by a generic region, then a region of 8 × 6
/// of one kind past `i32::MAX`, coded by the standard's procedures, and decodes to that page
/// alone; moved onto the page, the region draws. Vendored hayro-jbig2 patch 14.
#[test]
fn a_region_located_past_i32_max_is_off_the_page() {
const PAGE: &str = "0000000030000100000013000000100000000c00000000000000004200000000000126000100000035000000100000000c0000000000000000040003fffdff02fefefed906aa2cb6ee4ccb4bc975d02669ca7a9c14c20c638f5a5e1bffac";
let cases = [
// At 0xFFFFFFFC, 1.
("generic", "00000002260001000000220000000800000006fffffffc00000001000003fffdff02fefefe17c876ae6f77ffac"),
// At 1, 0xFFFFFFFE, with its symbol dictionary.
(
"text",
"000000020000010000001e000003fffdff02fefefe00000001000000014fdda14149cec477ed5fffac00000003062002010000001b000000080000000600000001fffffffe00001000000001a943ffac",
),
// At 0xFFFFFFFC, 1, with its pattern dictionary.
(
"halftone",
"000000021000010000000a000101000000011fffac00000003162002010000002e0000000800000006fffffffc0000000100000000000800000006000000000000000001000000d09301774485ffac",
),
// At 0xFFFFFFFC, 1, reading the page there (7.4.7.4): 0s.
("refinement of the page", "000000022a00010000001e0000000800000006fffffffc000000010400ffffffff0bd98f188428ffac"),
// Of an intermediate region at the same place (7.4.7.5), 1, 0xFFFFFFFE.
(
"refinement of a region",
"0000000224000100000023000000080000000600000001fffffffe000003fffdff02fefefe3d81322da16b7fffac000000032a2002010000001e000000080000000600000001fffffffe0000ffffffffe29946b82229ffac",
),
// Of an intermediate refinement of an intermediate region, all at 0xFFFFFFFC, 1.
(
"refinement of a refinement",
"00000002240001000000230000000800000006fffffffc00000001000003fffdff02fefefecdfd921ec8c47fffac00000003282002010000001e0000000800000006fffffffc000000010000ffffffff903cdb447a47ffac000000042a2003010000001e0000000800000006fffffffc000000010000ffffffffdcd6078cab86ffac",
),
];
let hex = |text: &str| (0..text.len() / 2).map(|i| u8::from_str_radix(&text[i * 2..i * 2 + 2], 16).unwrap()).collect::<Vec<u8>>();
let decode = |segments: &str| decode_jbig2(&[hex(PAGE), hex(segments)].concat(), None, 16, 12, usize::MAX).unwrap();
let page = decode("");
assert!(page.iter().any(|&byte| byte != 0xFF), "the page has ink");
for (kind, segments) in cases {
assert_eq!(decode(segments), page, "{kind}");
// Moved onto the page, to 4, 1 or 1, 2, the same regions draw: they decode, and are
// left out for where they are.
let (off, on) = [("fffffffc00000001", "0000000400000001"), ("00000001fffffffe", "0000000100000002")]
.into_iter()
.find(|(off, _)| segments.contains(off))
.unwrap();
assert_ne!(decode(&segments.replace(off, on)), page, "{kind} on the page");
}
// A refinement at 2, 0 of an intermediate region at 0x80000000, 0. A refinement of a
// region refines it where it is, "GRREFERENCEDX 0, GRREFERENCEDY 0" (Table 35), and the two
// should be at one place (7.4.7.5). Where they aren't, it decodes as it does where they are.
const ELSEWHERE: &str = "000000022400010000002300000008000000068000000000000000000003fffdff02fefefe1bca3149568cdfffac000000032a2002010000001e000000080000000600000002000000000000ffffffff784a909cc761ffac";
let refined = decode(ELSEWHERE);
assert_eq!(refined, decode(&ELSEWHERE.replace("8000000000000000", "0000000200000000")), "the region at 2, 0 too");
assert_ne!(refined, page, "drawn");
}
/// A refinement of the page refines "the current contents of the page buffer, restricted to the
/// area of the page buffer specified by this segment's region segment information field"
/// (ISO/IEC 14492 7.4.7.4), at an offset of 0 (Table 35), and reads 0 outside that area
/// (6.3.5.2). The decoder read the page around the area too, and refused a refinement wider or
/// taller than the page. A refinement of another region refines that region, not the page. And
/// a reference 32 or more left of a refinement (GRREFERENCEDX below −31, as a symbol refined
/// with an RDX below −31 has, Table 18) is read from where each row starts in it: each row's
/// first context read 0 for the reference column it starts at, and from 33 left for the one
/// before it too. Each stream is coded by the standard's procedures and decodes to its
/// picture, `#` for black. Vendored hayro-jbig2 patch 16.
#[test]
fn a_refinement_refines_the_page_in_its_area_and_any_reference_where_it_is() {
let cases: [(&str, &str, &[&str]); 5] = [
(
"a 48 × 6 page a generic region has inked, refined at 33: ink on both sides of the area, template 0",
"000000003000010000001300000030000000060000000000000000420000000000012600010000004100000030000000060000000000000000040003fffdff02fefefe331433558a5c5056cf412003ec9a38164df39bd4463b9331502c4fb1c267ab77b665aa5962ffac000000022a0001000000210000000c0000000600000021000000000400ffffffff9a6c35bbeee221f687ffac",
&[
".#..##.######..#.#..#####.##..#........##.##..##",
".#..####.####.#...###.##.##.#.#.....#.#.####.###",
"##.#......#..#....#..#.###.#..#.#####.###.######",
"......#....###.#.##..#.##........#.#.#...#####..",
"#.##..###.#.#.##.....#...#.#..#.##.#..#...#...#.",
".###...#..#..#..##..#.#..#####.#.##.......###.##",
],
),
(
"a 24 × 8 inked page refined at 5, 1, template 1",
"000000003000010000001300000018000000080000000000000000420000000000012600010000003500000018000000080000000000000000040003fffdff02fefefeb1e133cb8bcbb8510e81d219bb880dfb40a311dc5c298819efffac000000022a00010000001b0000000a0000000500000005000000010401e55c0078dcd30fffac",
&[
"#.##.##...##....##.##..#",
"#.##.##...#.####..##..#.",
"##..##.##...#...###..#.#",
".....#.#.##.#...###....#",
"..#.#...#.#...#.#...##.#",
"....######...#.####....#",
"..######..##.#.#..##.#..",
"...#..##.####.#..##...#.",
],
),
(
"a 16 × 5 inked page refined by a region 4 wider than it, template 0",
"000000003000010000001300000010000000050000000000000000420000000000012600010000002600000010000000050000000000000000040003fffdff02fefefe22e5e253a429cbf2c701ffac000000022a000100000023000000140000000500000000000000000400ffffffff3afa516532bbe3d481926fffac",
&[".#.#.#.#..#.#.#.", "##.####..###...#", "..####.#..####.#", ".###.#.....#..#.", "#.###..#########"],
),
(
"an intermediate region at 4, 1 on an inked 20 × 8 page, refined there (OR): the region, not the page, template 0",
"000000003000010000001300000014000000080000000000000000420000000000012600010000003000000014000000080000000000000000040003fffdff02fefefeb91e434e1726ca89ed06c2bffb0fe5fa7fccc80fffac00000002240001000000230000000a000000050000000400000001000003fffdff02fefefece7a9826ba81bfffac000000032a2002010000001e0000000a0000000500000004000000010000ffffffffd046ee6f6190ffac",
&[
"#.#.#....#.#...#....",
"##..#.#.#.##.....##.",
"##.#.#.#.#.###.##...",
"###.##.####..###.#.#",
"...#.###..###.#.#..#",
"#...#######.#...####",
"..##.##...#..##..#.#",
"#...##...#.##....#..",
],
),
(
"a symbol refined in a symbol dictionary from a 40 × 6 one, RDX −33: 33 left, template 1",
"0000000030000100000013000000070000000600000000000000004200000000000100000100000036000003fffdff02fefefe00000001000000014f913296209e2187f37bddb8589c8beb7d70109de7124ebe47d04914ef7e655c3c4cffac00000002002001010000001f100203fffdff02fefefe00000001000000014fe451a27bddf49f7ef7e7ffac00000003062002010000001b0000000700000006000000000000000004001000000001a943ffac",
&[".####.#", ".##..##", "......#", "...#..#", "#.#.###", "....##."],
),
];
let hex = |text: &str| (0..text.len() / 2).map(|i| u8::from_str_radix(&text[i * 2..i * 2 + 2], 16).unwrap()).collect::<Vec<u8>>();
for (form, stream, picture) in cases {
let (w, h) = (picture[0].len(), picture.len());
// As the filter gives it: black as 0, each row padded to a byte with 0s.
let mut rows = vec![0u8; w.div_ceil(8) * h];
for (y, row) in picture.iter().enumerate() {
for (x, _) in row.bytes().enumerate().filter(|(_, c)| *c == b'.') {
rows[y * w.div_ceil(8) + x / 8] |= 0x80 >> (x % 8);
}
}
assert_eq!(decode_jbig2(&hex(stream), None, w as u32, h as u32, usize::MAX).unwrap(), rows, "{form}");
}
}
/// What a page costs is the same however much a run has left. Given exactly that it decodes,
/// and less stops it: spending all that's left, and what comes after isn't read. A page that
/// fails still spends what it took.
@@ -183,6 +320,57 @@ mod tests {
assert_eq!(u64::MAX - work, 4 * 14);
}
/// A refinement whose reference is offset right of it (GRREFERENCEDX above 0, as a refined text
/// instance has from a wider bitmap, ISO/IEC 14492 Table 12, and a refined symbol from an RDX
/// above 0, Table 18) reads the reference from its first column. Left of the reference the
/// decoder emptied what it had read of it, and at its first column didn't read it again, so its
/// first 32 columns read as 0: such a refinement decoded to other pixels than were coded, or
/// failed. Each stream is a refinement coded by the standard's procedures on a page of its own
/// size, and decodes to its picture, `#` for black. Vendored hayro-jbig2 patch 15.
#[test]
fn a_refinement_reads_a_reference_right_of_it_from_its_first_column() {
let cases: [(&str, &str, &[&str]); 4] = [
(
"a text instance of an 8 × 6 symbol refined 6 wider: 3 right, template 0",
"00000000300001000000130000000e000000060000000000000000420000000000010000010000001d000003fffdff02fefefe00000001000000014fdd3dba48bdddde35ffac00000002062001010000002c0000000e000000060000000000000000040012ffffffff00000001a96b4a6b78b7fc094fadde1b3e881fffac",
&[".#.#.#....#...", "##.###....##.#", ".###...###..#.", "#.......#...#.", "#.####.#...#..", "#.##...###.#.."],
),
(
"refined 2 wider and 2 taller, RDX and RDY 1: 2 right, 2 down, template 1",
"00000000300001000000130000000a000000080000000000000000420000000000010000010000001d000003fffdff02fefefe00000001000000014fdd9c52d3ea827a43ffac0000000206200101000000280000000a00000008000000000000000004801200000001a96c00cdac6dd5f6f848ce872411cfffac",
&["####.##...", "####..####", "####..##..", "...##...#.", "#......#..", "..#.....#.", "##....####", ".#........"],
),
(
"a symbol refined in a symbol dictionary, RDX 5, RDY −1, template 0 with its AT pixels moved",
"00000000300001000000130000000c000000060000000000000000420000000000010000010000001e000003fffdff02fefefe00000001000000014fdda13efc4029efc95fffac000000020020010100000027000203fffdff02fefefefeff010100000001000000014fc98c352dd84a906f120ffb49793fffac00000003062002010000001b0000000c00000006000000000000000004001000000001a943ffac",
&["#.#.##.#.###", "..#.#.....##", "##..#...#...", "..##....##..", "##.#.##.####", ".#..#####..#"],
),
(
"a text instance of a 40 × 5 symbol refined 2 wider, RDX 1: 2 right, across a word, template 0",
"00000000300001000000130000002a0000000500000000000000004200000000000100000100000031000003fffdff02fefefe00000001000000015240f590d953ae3f4069dede672090d4d61b377906d3f41aafa4f77107ffac00000002062001010000003c0000002a000000050000000000000000040012ffffffff00000001a96c0b9386d4b140486bdc3673dbd031490e468c7f7813d19068ab04a79cbfffac",
&[
"##.#.#..##.##.#####.#....#.#.#..#..######.",
".#.#..###....#..##.#..#.####.#..#.###...##",
".#.#......#....#####....#...###...#####...",
"#...##.##.......#...###.###...##..##.###.#",
"..#..###..###..#...#.......##.#........##.",
],
),
];
let hex = |text: &str| (0..text.len() / 2).map(|i| u8::from_str_radix(&text[i * 2..i * 2 + 2], 16).unwrap()).collect::<Vec<u8>>();
for (form, stream, picture) in cases {
let (w, h) = (picture[0].len(), picture.len());
// As the filter gives it: black as 0, each row padded to a byte with 0s.
let mut rows = vec![0u8; w.div_ceil(8) * h];
for (y, row) in picture.iter().enumerate() {
for (x, _) in row.bytes().enumerate().filter(|(_, c)| *c == b'.') {
rows[y * w.div_ceil(8) + x / 8] |= 0x80 >> (x % 8);
}
}
assert_eq!(decode_jbig2(&hex(stream), None, w as u32, h as u32, usize::MAX).unwrap(), rows, "{form}");
}
}
/// The page has to be the image's size, and is bounded before it is decoded, being decoded
/// whole: within `max` as rows of one bit, and within [`MAX_JBIG2_PIXELS`]. Globals are given
/// to the decoder: ones it skips decode, ones that aren't JBIG2 are an error, as is damaged
crates/filters/src/jbig2/symbols.rs
+346 -37
View File
@@ -11,7 +11,7 @@ use std::collections::HashMap;
use std::hash::{DefaultHasher, Hash, Hasher};
use std::ops::Range;
use super::{at_pixels, code_generic, generic_region, page_information, region_information, segment};
use super::{at_pixels, code_generic, generic_region, page_information, region_information, segment, segment_of};
use crate::mq::{Context, MqEncoder};
/// The longest side of a mark stored as a symbol. A larger one is left to the generic region.
@@ -37,10 +37,14 @@ const MAX_CODED_SYMBOLS: usize = (1 << 15) - 1;
/// placed by several regions, each over a band of rows, all referring to the one dictionary.
const MAX_REGION_INSTANCES: usize = 10_000;
// Segment numbers stay at most 256, so a referred-to one takes a byte (7.2.5): the page, the
// dictionary, a text region for each MAX_REGION_INSTANCES of at most MAX_RUNS marks, and the
// generic region.
const _: () = assert!(MAX_RUNS.div_ceil(MAX_REGION_INSTANCES) + 3 <= 256);
/// The most symbols a group's shared dictionary holds ([`encode_shared`]): half of what a page may
/// place, so each page keeps room for its own.
const MAX_SHARED_SYMBOLS: usize = MAX_CODED_SYMBOLS / 2;
// Segment numbers stay at most 256, so a referred-to one takes a byte (7.2.5): the shared
// dictionary, the page, its own dictionary, a text region for each MAX_REGION_INSTANCES of at most
// MAX_RUNS marks, and the generic region.
const _: () = assert!(MAX_RUNS.div_ceil(MAX_REGION_INSTANCES) + 4 <= 256);
/// The integer coders' ranges (Table A.1): how many 1 bits pick the range, how many bits give the
/// offset into it, and its first value. The last range has no 0 after its prefix.
@@ -97,13 +101,107 @@ struct Instance {
height: u32,
}
/// A group of images coded by [`encode_shared`]: the globals' data, and each image's stream.
type SharedCoding = (Vec<u8>, Vec<Option<Vec<u8>>>);
/// The symbols of a group's shared dictionary, as one image's [`plan`] places them: the ID each of
/// the image's symbols has there, if it is there, and how many symbols that dictionary exports.
struct Shared {
ids: Vec<Option<u32>>,
count: u32,
}
/// `rows` rows of `columns` 1-bit PDF samples (black 0), symbol coded: the smaller of two plans,
/// every mark of at most [`MAX_SYMBOL_SIDE`] a side as a symbol, or only those with a copy.
/// `None` when neither plan has from two to [`MAX_CODED_SYMBOLS`] symbols, or the image is too
/// large or too busy to look at.
pub(super) fn encode(samples: &[u8], columns: u32, rows: u32) -> Option<Vec<u8>> {
let page = page(samples, columns)?;
[1, 2].into_iter().filter_map(|copies| plan(&page, columns, rows, copies, None)).min_by_key(Vec::len)
[1, 2].into_iter().filter_map(|copies| plan(&page, columns, rows, copies, None, None)).min_by_key(Vec::len)
}
/// Images, each as [`encode`] takes one, symbol coded sharing one dictionary: the globals' data, a
/// symbol dictionary segment associated with no page (number 0) holding the distinct marks found
/// in more than one image, and each image's stream placing them from there, the smaller of
/// [`encode`]'s two plans for its other marks. The group's marks are held within the limits one
/// image's are ([`MAX_SYMBOLS`], [`MAX_SYMBOL_PIXELS`]): past them, later marks aren't shared. Past
/// [`MAX_SHARED_SYMBOLS`] shared marks, those in the most images are kept.
///
/// An image too large or too busy to look at, or that places none of the shared marks, gets `None`;
/// `None` overall when fewer than two marks are shared.
pub(super) fn encode_shared(images: &[(&[u8], u32, u32)]) -> Option<SharedCoding> {
// The group's distinct marks, each with how many images hold it (as its uses), looked at an
// image at a time.
let mut table: Vec<Symbol> = Vec::new();
let mut by_hash: HashMap<u64, Vec<u32>> = HashMap::new();
let mut held = 0usize;
for (samples, columns, _) in images {
let Some(page) = page(samples, *columns) else { continue };
// An image's symbols are distinct, so each counts an image once.
for symbol in page.symbols {
match find(&table, &by_hash, &symbol) {
Some(t) => {
if let Some(s) = table.get_mut(t as usize) {
s.uses = s.uses.saturating_add(1);
}
}
None => {
let Some(more) = held.checked_add(symbol.pixels.len()).filter(|h| *h <= MAX_SYMBOL_PIXELS && table.len() < MAX_SYMBOLS) else {
continue;
};
held = more;
let t = u32::try_from(table.len()).ok()?;
by_hash.entry(fingerprint(&symbol)).or_default().push(t);
table.push(Symbol { uses: 1, ..symbol });
}
}
}
}
let uses = |t: &u32| table.get(*t as usize).map_or(0, |s| s.uses);
let mut shared: Vec<u32> = (0..u32::try_from(table.len()).ok()?).filter(|t| uses(t) >= 2).collect();
if shared.len() < 2 {
return None;
}
shared.sort_by_key(|t| std::cmp::Reverse(uses(t)));
shared.truncate(MAX_SHARED_SYMBOLS);
// The dictionary's order, as `plan` keeps it.
shared.sort_by_key(|t| table.get(*t as usize).map(|s| (s.height, s.width)));
let mut global = vec![None; table.len()];
for (k, t) in shared.iter().enumerate() {
if let Some(slot) = global.get_mut(*t as usize) {
*slot = u32::try_from(k).ok();
}
}
let symbols: Vec<&Symbol> = shared.iter().filter_map(|t| table.get(*t as usize)).collect();
let mut globals = Vec::new();
segment_of(&mut globals, 0, 0, 0, &[], true, &symbol_dictionary(&symbols)?);
let count = u32::try_from(symbols.len()).ok()?;
let streams = images
.iter()
.map(|(samples, columns, rows)| {
let page = page(samples, *columns)?;
let ids = page.symbols.iter().map(|s| find(&table, &by_hash, s).and_then(|t| global.get(t as usize).copied().flatten())).collect();
let shared = Shared { ids, count };
[1, 2].into_iter().filter_map(|copies| plan(&page, *columns, *rows, copies, None, Some(&shared))).min_by_key(Vec::len)
})
.collect();
Some((globals, streams))
}
/// What sorts a symbol's bitmap ([`symbols`] and [`encode_shared`] look exact copies up by it).
fn fingerprint(s: &Symbol) -> u64 {
let mut hasher = DefaultHasher::new();
(s.width, s.height, &s.pixels).hash(&mut hasher);
hasher.finish()
}
/// The index in `table` of the symbol with `s`'s bitmap, looked up by its [`fingerprint`].
fn find(table: &[Symbol], by_hash: &HashMap<u64, Vec<u32>>, s: &Symbol) -> Option<u32> {
by_hash
.get(&fingerprint(s))?
.iter()
.copied()
.find(|t| table.get(*t as usize).is_some_and(|t| (t.width, t.height) == (s.width, s.height) && t.pixels == s.pixels))
}
/// The image's marks and symbols; `None` past the limits above.
@@ -267,23 +365,18 @@ fn symbols(page: &mut Page) -> Option<()> {
page.large.push(m);
continue;
}
let pixels = pixels(mark, &page.runs, &page.order);
let mut hasher = DefaultHasher::new();
(width, height, &pixels).hash(&mut hasher);
let same = by_hash.entry(hasher.finish()).or_default();
let symbol = Symbol { width, height, pixels: pixels(mark, &page.runs, &page.order), uses: 0 };
let symbols = &mut page.symbols;
let known =
same.iter().copied().find(|s| symbols.get(*s as usize).is_some_and(|s| (s.width, s.height) == (width, height) && s.pixels == pixels));
let id = match known {
let id = match find(symbols, &by_hash, &symbol) {
Some(id) => id,
None => {
kept = kept.checked_add(pixels.len())?;
kept = kept.checked_add(symbol.pixels.len())?;
if kept > MAX_SYMBOL_PIXELS || symbols.len() == MAX_SYMBOLS {
return None;
}
let id = u32::try_from(symbols.len()).ok()?;
symbols.push(Symbol { width, height, pixels, uses: 0 });
same.push(id);
by_hash.entry(fingerprint(&symbol)).or_default().push(id);
symbols.push(symbol);
id
}
};
@@ -300,18 +393,28 @@ fn symbols(page: &mut Page) -> Option<()> {
/// the other marks in a generic region. `None` with fewer than two such symbols (their IDs would
/// take no bits at all, SBSYMCODELEN 0, a corner of the standard left alone here) or more than
/// [`MAX_CODED_SYMBOLS`].
fn plan(page: &Page, columns: u32, rows: u32, copies: u32, log_strips: Option<u32>) -> Option<Vec<u8>> {
///
/// With `shared`, the symbols a group's dictionary holds are placed from there, whatever their uses
/// here, and the page's own dictionary holds only the others (none, when it has none), as
/// [`encode_shared`] writes them; `None` too for a page that places none of the shared ones.
fn plan(page: &Page, columns: u32, rows: u32, copies: u32, log_strips: Option<u32>, shared: Option<&Shared>) -> Option<Vec<u8>> {
let symbol = |s: u32| page.symbols.get(s as usize);
let global = |s: u32| shared.and_then(|g| g.ids.get(s as usize).copied().flatten());
let globals = shared.map_or(0, |g| g.count);
// The dictionary's order (6.5.5): height classes from the shortest, each narrowest first.
let mut kept: Vec<u32> = (0..page.symbols.len() as u32).filter(|s| symbol(*s).is_some_and(|s| s.uses >= copies)).collect();
if kept.len() < 2 || kept.len() > MAX_CODED_SYMBOLS {
let mut kept: Vec<u32> =
(0..page.symbols.len() as u32).filter(|s| global(*s).is_none() && symbol(*s).is_some_and(|s| s.uses >= copies)).collect();
let count = usize::try_from(globals).ok()?.checked_add(kept.len())?;
if !(2..=MAX_CODED_SYMBOLS).contains(&count) {
return None;
}
kept.sort_by_key(|s| symbol(*s).map(|s| (s.height, s.width)));
let mut id = vec![None; page.symbols.len()];
// The shared symbols' IDs come first, as their dictionary is referred to first (Table 31's
// SBSYMS).
let mut id: Vec<Option<u32>> = (0..page.symbols.len() as u32).map(global).collect();
for (k, s) in kept.iter().enumerate() {
if let Some(slot) = id.get_mut(*s as usize) {
*slot = u32::try_from(k).ok();
*slot = u32::try_from(k).ok().and_then(|k| k.checked_add(globals));
}
}
let mut instances = Vec::new();
@@ -324,9 +427,12 @@ fn plan(page: &Page, columns: u32, rows: u32, copies: u32, log_strips: Option<u3
_ => left.push(*m),
}
}
if shared.is_some() && !instances.iter().any(|i| i.id < globals) {
return None;
}
let kept: Vec<&Symbol> = kept.iter().filter_map(|s| symbol(*s)).collect();
let dictionary = symbol_dictionary(&kept)?;
let count = u32::try_from(kept.len()).ok()?;
let dictionary = if kept.is_empty() { None } else { Some(symbol_dictionary(&kept)?) };
let count = u32::try_from(count).ok()?;
// Bands of at most MAX_REGION_INSTANCES, from the top.
instances.sort_by_key(|i| (i.t, i.s));
let mut regions = Vec::new();
@@ -339,12 +445,21 @@ fn plan(page: &Page, columns: u32, rows: u32, copies: u32, log_strips: Option<u3
});
}
let mut out = Vec::new();
segment(&mut out, 0, 48, &[], false, &page_information(columns, rows));
segment(&mut out, 1, 0, &[], true, &dictionary);
let mut number = 2;
// The shared dictionary is segment 0, in the globals, and a segment refers only to lower
// numbers (7.2.5): the page's own follow it.
let mut number = u32::from(shared.is_some());
segment(&mut out, number, 48, &[], false, &page_information(columns, rows));
number += 1;
let mut dictionaries: Vec<u8> = shared.map(|_| 0).into_iter().collect();
if let Some(dictionary) = &dictionary {
segment(&mut out, number, 0, &[], true, dictionary);
dictionaries.push(u8::try_from(number).ok()?);
number += 1;
}
for (k, text) in regions.iter().enumerate() {
// The dictionary stays retained for the next region, until the last (7.2.4).
segment(&mut out, number, 7, &[(1, k + 1 < regions.len())], false, text);
// The dictionaries stay retained for the next region, until the last (7.2.4).
let refers_to: Vec<(u8, bool)> = dictionaries.iter().map(|n| (*n, k + 1 < regions.len())).collect();
segment(&mut out, number, 7, &refers_to, false, text);
number += 1;
}
if !left.is_empty() {
@@ -538,8 +653,9 @@ fn encode_id(mq: &mut MqEncoder, contexts: &mut [Context], length: u32, id: u32)
#[cfg(test)]
mod tests {
use super::*;
use crate::jbig2::tests::{decode, samples, unpack};
use crate::jbig2::{encode_jbig2, encode_jbig2_generic};
use crate::FilterError;
use crate::jbig2::tests::{decode, decode_with, samples, unpack};
use crate::jbig2::{encode_jbig2, encode_jbig2_generic, encode_jbig2_shared};
type Bitmap = Vec<Vec<u8>>;
@@ -664,7 +780,7 @@ mod tests {
let mut plans = 0;
for copies in [1, 2] {
for log_strips in 0..4 {
if let Some(coded) = plan(&page, columns, rows, copies, Some(log_strips)) {
if let Some(coded) = plan(&page, columns, rows, copies, Some(log_strips), None) {
assert_eq!(decode(&coded), unpack(&data, columns, rows), "{copies} copies, strips of {}", 1 << log_strips);
plans += 1;
}
@@ -733,7 +849,7 @@ mod tests {
let page = page(&data, c).unwrap();
assert!(page.marks.iter().all(|m| m.x1 as usize <= columns), "{columns} columns");
for copies in [1, 2] {
if let Some(coded) = plan(&page, c, r, copies, None) {
if let Some(coded) = plan(&page, c, r, copies, None, None) {
assert_eq!(decode(&coded), unpack(&data, c, r), "{columns} columns");
}
}
@@ -820,17 +936,17 @@ mod tests {
};
let (data, columns, rows) = codes(MAX_CODED_SYMBOLS, 0);
let at_cap = page(&data, columns).unwrap();
assert_eq!(decode(&plan(&at_cap, columns, rows, 1, None).unwrap()), unpack(&data, columns, rows));
assert_eq!(decode(&plan(&at_cap, columns, rows, 1, None, None).unwrap()), unpack(&data, columns, rows));
// One more distinct mark, each once: neither plan is made.
let (data, columns, rows) = codes(MAX_CODED_SYMBOLS + 1, 0);
let past = page(&data, columns).unwrap();
assert!(plan(&past, columns, rows, 1, None).is_none() && plan(&past, columns, rows, 2, None).is_none());
assert!(plan(&past, columns, rows, 1, None, None).is_none() && plan(&past, columns, rows, 2, None, None).is_none());
assert_eq!(encode_jbig2(&data, columns, rows).unwrap(), encode_jbig2_generic(&data, columns, rows).unwrap());
// With two of them repeated, the second plan codes those two.
let (data, columns, rows) = codes(MAX_CODED_SYMBOLS + 1, 200);
let past = page(&data, columns).unwrap();
assert!(plan(&past, columns, rows, 1, None).is_none());
assert_eq!(decode(&plan(&past, columns, rows, 2, None).unwrap()), unpack(&data, columns, rows));
assert!(plan(&past, columns, rows, 1, None, None).is_none());
assert_eq!(decode(&plan(&past, columns, rows, 2, None, None).unwrap()), unpack(&data, columns, rows));
// Above a page of text whose letters repeat, that second plan is the one `encode_jbig2`
// keeps: the first, of every mark, would code too many symbols.
let mut picture: Bitmap = vec![vec![0u8; 256 * 18]; 512];
@@ -869,7 +985,7 @@ mod tests {
let (data, columns, rows) = squares(256);
let at_cap = page(&data, columns).unwrap();
assert_eq!(at_cap.symbols.len(), 256);
assert_eq!(decode(&plan(&at_cap, columns, rows, 1, None).unwrap()), unpack(&data, columns, rows));
assert_eq!(decode(&plan(&at_cap, columns, rows, 1, None, None).unwrap()), unpack(&data, columns, rows));
let (data, columns, _) = squares(257);
assert!(page(&data, columns).is_none());
}
@@ -984,7 +1100,199 @@ mod tests {
}
}
/// Each segment's page association (7.2.6): the byte after the numbers it refers to.
fn associations(data: &[u8]) -> Vec<u8> {
let (mut pages, mut at) = (Vec::new(), 0);
while at < data.len() {
let refers = usize::from(data[at + 5] >> 5);
pages.push(data[at + 6 + refers]);
let length_at = at + 6 + refers + 1;
at = length_at + 4 + u32::from_be_bytes(data[length_at..length_at + 4].try_into().unwrap()) as usize;
}
pages
}
/// `pictures`, `columns` × `rows` each, coded sharing a dictionary; each image's stream, which
/// has to be there, decodes with the globals to its picture.
fn shared_round_trip(pictures: &[Bitmap]) -> (Vec<u8>, Vec<Vec<u8>>) {
let (columns, rows) = (pictures[0][0].len() as u32, pictures[0].len() as u32);
let data: Vec<Vec<u8>> = pictures.iter().map(|p| samples(p)).collect();
let images: Vec<(&[u8], u32, u32)> = data.iter().map(|d| (&d[..], columns, rows)).collect();
let shared = encode_jbig2_shared(&images).unwrap().unwrap();
let (globals, coded) = (shared.globals, shared.images);
let coded: Vec<Vec<u8>> = coded.into_iter().map(Option::unwrap).collect();
for (d, c) in data.iter().zip(&coded) {
assert_eq!(decode_with(c, Some(&globals)), unpack(d, columns, rows));
}
(globals, coded)
}
/// `font` with a stem 20 pixels tall down each glyph's left side: a font sharing no glyph with
/// any [`glyphs`] gives, whose glyphs are at most 18 pixels tall.
fn stemmed(font: &[Bitmap]) -> Vec<Bitmap> {
font.iter()
.map(|g| {
(0..g.len().max(20)).map(|y| std::iter::once(1).chain(g.get(y).cloned().unwrap_or_else(|| vec![0; g[0].len()])).collect()).collect()
})
.collect()
}
/// Mark `k` of a set of distinct ones: a stroke 33 pixels long with a pixel above every other
/// column for each 1 bit of `k`, below 2^17.
fn comb(k: usize) -> Bitmap {
let mut g = vec![vec![0u8; 33]; 2];
g[1].fill(1);
for bit in 0..17 {
g[0][2 * bit] = u8::from(k >> bit & 1 == 1);
}
g
}
/// The combs `ks`, 120 a row, the rows four pixels apart.
fn combs(ks: impl ExactSizeIterator<Item = usize>) -> Bitmap {
let mut page = vec![vec![0u8; 120 * 36]; ks.len().div_ceil(120) * 4];
for (i, k) in ks.enumerate() {
draw(&mut page, &comb(k), (i % 120 * 36) as i64, (i / 120 * 4) as i64);
}
page
}
/// The symbols a symbol dictionary segment exports (SDNUMEXSYMS, 7.4.2.1.4), in a stream
/// that is that segment alone: after its header, flags and adaptive pixels.
fn exported(globals: &[u8]) -> usize {
u32::from_be_bytes(globals[21..25].try_into().unwrap()) as usize
}
/// Pages in one font share its letters: one symbol dictionary, segment 0, associated with no
/// page and retained (7.2.4, 7.2.6), which each page's text region refers to first, its own
/// segments numbered after it (7.2.5). Together they take less than they take alone.
#[test]
fn pages_in_one_font_share_one_dictionary() {
let font = glyphs(40, 7);
let pictures: Vec<Bitmap> = (0..4).map(|seed| text(1200, 300, &font, 20 + seed)).collect();
let (globals, coded) = shared_round_trip(&pictures);
assert_eq!(segments(&globals), [(0, 0, true, vec![])]);
assert_eq!(associations(&globals), [0]);
let (mut shared, mut alone) = (globals.len(), 0);
for (picture, c) in pictures.iter().zip(&coded) {
let segments = segments(c);
assert_eq!(segments.first().map(|s| s.0), Some(1), "the page's own segments follow");
assert!(segments.iter().filter(|s| s.1 == 7).all(|s| s.3.first() == Some(&(0, false))), "{segments:?}");
assert!(associations(c).iter().all(|page| *page == 1));
shared += c.len();
alone += encode_jbig2(&samples(picture), 1200, 300).unwrap().len();
}
assert!(shared < alone, "shared {shared} bytes, alone {alone}");
}
/// Two pages alike place every mark from the shared dictionary and have none of their own; a
/// page with letters of its own as well keeps them in its own dictionary, referred to after the
/// shared one (its symbols' IDs follow), and the page with nothing shared has no stream.
#[test]
fn what_a_page_has_alone_stays_its_own() {
let (font, other) = (glyphs(30, 7), stemmed(&glyphs(20, 99)));
let same = text(900, 240, &font, 3);
let mut more = text(900, 240, &font, 4);
more.extend(text(900, 120, &other, 5));
let (globals, coded) = shared_round_trip(&[same.clone(), same.clone()]);
assert!(!globals.is_empty());
assert!(coded.iter().all(|c| segment_types(c) == [48, 7]), "{:?}", coded.iter().map(|c| segment_types(c)).collect::<Vec<_>>());
let with_more = |p: &Bitmap| p.iter().cloned().chain(std::iter::repeat_n(vec![0u8; 900], 120)).collect::<Bitmap>();
let (_, coded) = shared_round_trip(&[with_more(&same), more]);
assert_eq!(segment_types(&coded[1])[..3], [48, 0, 7]);
assert_eq!(segments(&coded[1])[2].3, [(0, false), (2, false)]);
let alone = text(900, 360, &other, 6);
let data: Vec<Vec<u8>> = [&same, &same, &alone].iter().map(|p| samples(p)).collect();
let images: Vec<(&[u8], u32, u32)> = vec![(&data[0], 900, 240), (&data[1], 900, 240), (&data[2], 900, 360)];
let (_, coded) = encode_shared(&images).unwrap();
assert!(coded[0].is_some() && coded[1].is_some() && coded[2].is_none());
}
/// Images that share fewer than two marks share nothing; two are enough.
#[test]
fn images_with_nothing_in_common_share_nothing() {
let font = glyphs(30, 7);
let (a, b) = (samples(&text(600, 200, &font, 1)), samples(&text(600, 200, &stemmed(&font), 1)));
assert!(encode_shared(&[(&a, 600, 200), (&b, 600, 200)]).is_none());
assert!(encode_shared(&[(&a, 600, 200)]).is_none(), "one image");
assert!(encode_shared(&[]).is_none());
// The two commonest letters of the first page, below the last line of the second.
let mut two = text(600, 200, &stemmed(&font), 1);
draw(&mut two, &font[0], 10, 180);
draw(&mut two, &font[1], 100, 180);
let two = samples(&two);
let (globals, coded) = encode_shared(&[(&a, 600, 200), (&two, 600, 200)]).unwrap();
assert_eq!(exported(&globals), 2);
assert_eq!(decode_with(coded[1].as_ref().unwrap(), Some(&globals)), unpack(&two, 600, 200));
}
/// The images of a group are checked as `encode_jbig2_generic` checks one, and an image it
/// would refuse refuses the group.
#[test]
fn a_group_with_an_image_the_encoder_refuses_is_refused() {
let page = samples(&text(600, 200, &glyphs(30, 7), 1));
assert!(matches!(encode_jbig2_shared(&[(&page, 600, 200), (&page[..10], 600, 200)]), Err(FilterError::Corrupt { .. })));
assert!(matches!(encode_jbig2_shared(&[(&page, 600, 200), (&page, 0, 200)]), Err(FilterError::Unsupported(_))));
assert!(encode_jbig2_shared(&[(&page, 600, 200), (&page, 600, 200)]).unwrap().is_some());
}
/// A group holds its distinct marks within what one image's are held to: past 65,536 a mark
/// first seen later isn't held, so isn't shared, while those held count every image they're
/// in. Ten marks of the first image are in two images after it, with 464 first seen there.
#[test]
fn past_the_marks_a_group_holds_later_ones_arent_shared() {
let (a, b) = (samples(&combs(0..40_000)), samples(&combs(40_000..65_536)));
let late = combs((0..10).chain(65_536..66_000).collect::<Vec<_>>().into_iter());
let (rows, late) = (late.len() as u32, samples(&late));
let (columns, a_rows, b_rows) = (120 * 36, 40_000u32.div_ceil(120) * 4, 25_536u32.div_ceil(120) * 4);
let images = [(&a[..], columns, a_rows), (&b[..], columns, b_rows), (&late[..], columns, rows), (&late[..], columns, rows)];
let (globals, coded) = encode_shared(&images).unwrap();
assert_eq!(exported(&globals), 10);
for c in &coded[2..] {
assert_eq!(decode_with(c.as_ref().unwrap(), Some(&globals)), unpack(&late, columns, rows));
}
}
/// Past what one dictionary shares, it keeps the marks the most images hold: 20,000 shared,
/// the first 10,000 in all three images and the rest in two. The third image then places all
/// its marks from it, and the other two code the rest themselves (in a dictionary of their own
/// or a generic region, whichever is smaller).
#[test]
fn past_the_shared_limit_the_most_widely_held_marks_are_shared() {
let (both, first) = (combs(0..20_000), combs(0..10_000));
let rows = both.len();
let first: Bitmap = first.iter().cloned().chain(std::iter::repeat_n(vec![0u8; 120 * 36], rows - first.len())).collect();
let (globals, coded) = shared_round_trip(&[both.clone(), both, first]);
assert_eq!(exported(&globals), MAX_SHARED_SYMBOLS);
assert_eq!(segment_types(&coded[2]), [48, 7]);
assert!(segment_types(&coded[0]).iter().any(|t| *t == 0 || *t == 39), "{:?}", segment_types(&coded[0]));
}
proptest::proptest! {
/// Glyphs scattered over pages of one font: whatever is shared, every page with a stream
/// decodes with the globals to its picture.
#[test]
fn shared_groups_round_trip(
columns in 1usize..200,
rows in 1usize..100,
shapes in 2usize..8,
n in 0usize..60,
pages in 2usize..5,
seed in proptest::num::u64::ANY,
) {
let font = glyphs(shapes, seed);
let data: Vec<Vec<u8>> = (0..pages).map(|p| samples(&scatter(columns, rows, &font, seed ^ p as u64, n))).collect();
let (c, r) = (columns as u32, rows as u32);
let images: Vec<(&[u8], u32, u32)> = data.iter().map(|d| (&d[..], c, r)).collect();
if let Some((globals, coded)) = encode_shared(&images) {
for (d, coded) in data.iter().zip(coded) {
if let Some(coded) = coded {
proptest::prop_assert_eq!(decode_with(&coded, Some(&globals)), unpack(d, c, r));
}
}
}
}
/// Glyphs anywhere, over the edges and each other, with stray pixels: every plan decodes to
/// the picture, and `encode_jbig2` is never larger than the generic coding.
#[test]
@@ -1015,6 +1323,7 @@ mod tests {
fn any_input_returns(data in proptest::collection::vec(0u8..=255, 0..600), columns in 0u32..5000, rows in 0u32..80) {
let _ = encode_jbig2(&data, columns, rows);
let _ = encode(&data, columns, rows);
let _ = encode_shared(&[(&data, columns, rows), (&data, columns, rows.saturating_sub(1))]);
}
}
}
crates/filters/src/lib.rs
+3 -2
View File
@@ -27,7 +27,8 @@
//! ```
//!
//! 1-bit samples can be encoded as CCITT Group 4 ([`encode_g4`]) or lossless JBIG2
//! ([`encode_jbig2`]).
//! ([`encode_jbig2`]), a group of images sharing their marks through `/JBIG2Globals`
//! ([`encode_jbig2_shared`]).
//!
//! Every decoder is bounded by a caller-supplied `max_output` (decompression-bomb
//! defence) and never panics on malformed input.
@@ -47,7 +48,7 @@ mod runlength;
use std::borrow::Cow;
pub use ccitt::{CcittParams, MAX_CCITT_COLUMNS, MAX_G4_COLUMNS, decode_ccitt_within, encode_g4};
pub use jbig2::{MAX_JBIG2_COLUMNS, MAX_JBIG2_PIXELS, decode_jbig2_within, encode_jbig2, encode_jbig2_generic};
pub use jbig2::{MAX_JBIG2_COLUMNS, MAX_JBIG2_PIXELS, SharedJbig2, decode_jbig2_within, encode_jbig2, encode_jbig2_generic, encode_jbig2_shared};
/// A PDF stream filter, identified by its `/Filter` name.
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
crates/forms/README.md
+4 -1
View File
@@ -50,7 +50,10 @@ let cells: Vec<table::Cell> = grid.cells_for(names)?; // "Table1_1", "Table
keeps it: `/V` is stored as typed, the appearance draws `?` for those characters, the widget is
marked with the first one (`pdfcraft_fonts::UNDRAWN_MARK`, cleared once all of it can be drawn)
and the form sets `/NeedAppearances`, so other viewers draw the field from its value with fonts
that have them. Not in a document that declares PDF/A, which forbids that flag (`declares_pdfa`).
that have them. Not in a document that declares PDF/A, which forbids that flag (`declares_pdfa`:
the bytes `pdfaid:part` in XMP metadata each filter stage of which decodes within 8 MiB, the cap
preflight's Standards panel reads it with; preflight reads the identifier by its namespace, so a
packet that gives that namespace another prefix declares PDF/A there and not here).
`undrawn_fields` lists the marked fields; the engine reports each edit that draws one, and
flattening refuses to make that `?` permanent.
- Displaying a form that leaves its appearances to the viewer (`/NeedAppearances`, or a text or
crates/forms/src/appearances.rs
+13 -2
View File
@@ -212,13 +212,24 @@ impl FieldAppearanceCache {
}
}
/// Whether the document's XMP metadata declares PDF/A conformance (`pdfaid:part`).
/// The most each filter stage of the XMP metadata stream may decode for its PDF/A declaration to
/// be read, the cap preflight's Standards panel reads it with: past it, metadata declares nothing
/// there either.
pub(crate) const MAX_XMP_BYTES: usize = 8 << 20;
/// Whether the document's XMP metadata declares PDF/A conformance (the bytes `pdfaid:part`).
/// Metadata a filter stage of which decodes past [`MAX_XMP_BYTES`] doesn't.
pub fn declares_pdfa(doc: &Document) -> bool {
let Some(root) = doc.root() else { return false };
let Some(m) = doc.get(root).as_dict().and_then(|c| c.get(b"Metadata").cloned()) else { return false };
let m = doc.resolve(&m);
match &*m {
Object::Stream(s) => s.decoded().is_ok_and(|b| b.windows(11).any(|w| w == b"pdfaid:part")),
// Not a `DecodeBudget`, which counts every stage against one allowance: preflight bounds
// each stage, and the two must agree on metadata stored through a chain of filters.
// `/DecodeParms` is read only when direct, as preflight and organize read metadata too:
// PDF/A asks for it unfiltered, so only a file that breaks that reaches parameters here,
// and the readers go to `with_direct_parms` together or they disagree.
Object::Stream(s) => s.decoded_within(MAX_XMP_BYTES).is_ok_and(|b| b.windows(11).any(|w| w == b"pdfaid:part")),
_ => false,
}
}
crates/forms/src/author/edit.rs
+15 -2
View File
@@ -583,10 +583,15 @@ fn apply_late_widget_props(
}
/// Name field `old` `new` in each field's Calculate script that reads it
/// ([`crate::af::rename_in_calculation`]).
/// ([`crate::af::rename_in_calculation`]). Script streams share one budget, as a reading of the
/// form's scripts does, however many fields name the same stream; past it, a script is left as
/// it is, like one that won't decode. A Calculate action several fields share by reference is
/// read and rewritten once, in place, so they all read the new name.
fn rename_in_calculations(doc: &mut Document, all: &[Field], old: &str, new: &str) -> Result<(), FormError> {
let aa_of =
|doc: &Document, r: ObjRef| doc.get(r).as_dict().and_then(|d| d.get(b"AA").map(|a| doc.resolve(a))).and_then(|a| a.as_dict().cloned());
let mut scripts = crate::script_budget();
let mut shared = std::collections::HashSet::new();
for f in all {
// The script is the field's, or its only widget's when the field has none, as
// `actions_of` reads it.
@@ -595,12 +600,16 @@ fn rename_in_calculations(doc: &mut Document, all: &[Field], old: &str, new: &st
_ => None,
};
let Some((owner, mut aa)) = aa_of(doc, f.obj).map(|aa| (f.obj, aa)).or_else(only_widget) else { continue };
let by_ref = aa.get(b"C").and_then(Object::as_ref);
if by_ref.is_some_and(|r| !shared.insert(r)) {
continue;
}
let Some(mut action) = aa.get(b"C").and_then(|a| doc.resolve(a).as_dict().cloned()) else { continue };
let js = match action.get(b"JS").map(|js| doc.resolve(js)).as_deref() {
Some(Object::String(s)) => s.to_text(),
// A stream that isn't UTF-8 reads with replacement characters, which must not be
// written back in place of what it holds.
Some(Object::Stream(s)) => match s.decoded().ok().and_then(|b| String::from_utf8(b).ok()) {
Some(Object::Stream(s)) => match scripts.decode(s).ok().and_then(|b| String::from_utf8(b).ok()) {
Some(js) => js,
None => continue,
},
@@ -608,6 +617,10 @@ fn rename_in_calculations(doc: &mut Document, all: &[Field], old: &str, new: &st
};
let Some(js) = crate::af::rename_in_calculation(&js, old, new) else { continue };
action.set(b"JS".to_vec(), PdfString::text(&js));
if let Some(r) = by_ref {
doc.update_dict(r, |d| *d = action)?;
continue;
}
aa.set(b"C".to_vec(), Object::Dict(action));
doc.update_dict(owner, |d| d.set(b"AA".to_vec(), Object::Dict(aa)))?;
}
crates/forms/src/detect.rs
+80 -6
View File
@@ -6,7 +6,7 @@
//! the shapes from a page's content, [`raster::shapes`] from a picture of the page (a scan).
use pdfcraft_content::{Matrix, Pieces};
use pdfcraft_cos::{Document, Object};
use pdfcraft_cos::{DecodeBudget, Document, Object};
pub mod raster;
@@ -49,6 +49,60 @@ pub struct Candidate {
/// points along its sides (#2942: a cell drawn with a midpoint on each vertical side).
const MAX_RECT_POINTS: usize = 16;
/// Graphics states saved (`q`) and kept at once while detecting; deeper saves are counted, not kept.
const MAX_SAVES: usize = 256;
/// The graphics states a page saves (`q`) as detection follows its matrix: at most [`MAX_SAVES`]
/// kept, deeper ones counted so each `Q` still closes its own. Of those not kept: the matrix when
/// the first was made, which closing the last restores; the shallowest a `cm` changed the matrix
/// in; and whether a `Q` has closed that one, so the matrix isn't known until the last closes.
struct Saves {
kept: Vec<Matrix>,
lost: usize,
lost_base: Matrix,
moved_at: usize,
unknown: bool,
}
impl Default for Saves {
fn default() -> Self {
Saves { kept: Vec::new(), lost: 0, lost_base: Matrix::IDENTITY, moved_at: usize::MAX, unknown: false }
}
}
impl Saves {
fn save(&mut self, ctm: Matrix) {
if self.kept.len() < MAX_SAVES && self.lost == 0 {
self.kept.push(ctm);
} else {
if self.lost == 0 {
self.lost_base = ctm;
}
self.lost = self.lost.saturating_add(1);
}
}
fn restore(&mut self, ctm: &mut Matrix) {
if self.lost == 0 {
*ctm = self.kept.pop().unwrap_or(*ctm);
return;
}
self.lost -= 1;
if self.lost == 0 {
(*ctm, self.moved_at, self.unknown) = (self.lost_base, usize::MAX, false);
} else if self.lost < self.moved_at {
self.unknown = true;
}
}
/// A `cm` changed the matrix at the current depth.
fn moved(&mut self) {
if self.lost > 0 {
self.moved_at = self.moved_at.min(self.lost);
}
}
}
/// The rectangles and horizontal segments a page draws (stroked or filled), in user space.
#[derive(Default)]
struct DetectionPath {
@@ -125,7 +179,15 @@ impl DetectionPath {
}
}
/// The shapes page `page`'s content draws, its streams decoded within one page's allowance
/// ([`DecodeBudget::page`]), however often `/Contents` lists the same stream.
pub fn page_shapes(doc: &Document, page: usize) -> Shapes {
shapes_within(doc, page, &mut DecodeBudget::page())
}
/// [`page_shapes`], decoding against `budget`: a stream `/Contents` lists again is charged again,
/// and one past what is left reads as empty.
pub(crate) fn shapes_within(doc: &Document, page: usize, budget: &mut DecodeBudget) -> Shapes {
let mut out = Shapes::default();
let Some(p) = pdfcraft_model::pages(doc).into_iter().nth(page) else { return out };
let list: Vec<Object> = match p.dict.get(b"Contents").map(|c| doc.resolve(c)) {
@@ -139,24 +201,36 @@ pub fn page_shapes(doc: &Document, page: usize) -> Shapes {
let mut pieces = Vec::new();
for o in list {
if let Object::Stream(s) = &*doc.resolve(&o) {
pieces.push(s.decoded().unwrap_or_default());
pieces.push(budget.decode(s).unwrap_or_default());
}
}
let mut ctm = Matrix::IDENTITY;
let mut stack = Vec::new();
let mut saves = Saves::default();
let mut path_boxes: Vec<[f64; 4]> = Vec::new();
let mut subpaths: Vec<DetectionPath> = Vec::new();
let mut path = DetectionPath::default();
let mut cur: Option<[f64; 2]> = None;
for op in Pieces::join(&pieces).parse().ops {
let joined = Pieces::join(&pieces);
drop(pieces);
// An operator at a time: dense content (`n n n …`) parsed whole holds about 80 bytes for each
// byte it decoded.
for op in pdfcraft_content::ops(joined.data()) {
match op.op.as_slice() {
b"q" => stack.push(ctm),
b"Q" => ctm = stack.pop().unwrap_or(ctm),
b"q" => saves.save(ctm),
b"Q" => saves.restore(&mut ctm),
b"cm" => {
if let Some(m) = op.nums::<6>() {
ctm = Matrix(m).then(&ctm);
saves.moved();
}
}
// Painted where the matrix isn't known: dropped, as `n` drops a path.
b"S" | b"s" | b"f" | b"F" | b"f*" | b"B" | b"B*" | b"b" | b"b*" if saves.unknown => {
path_boxes.clear();
subpaths.clear();
path = DetectionPath::default();
cur = None;
}
b"re" => {
path.finish(&mut subpaths);
if let Some([x, y, w, h]) = op.nums::<4>() {
crates/forms/src/read.rs
+19 -7
View File
@@ -192,11 +192,17 @@ fn actions_of(doc: &Document, d: &Dict, widgets: &[ObjRef], scripts: &mut Decode
out
}
fn values_of(doc: &Document, o: Option<&Object>) -> Vec<String> {
/// Text streams of field values (`/V`, `/DV`) one reading of the form may decode in all, however
/// many fields name the same stream.
pub(crate) const MAX_VALUE_BYTES: usize = 64 << 20;
/// A field's value or default value (`/V`, `/DV`). A text stream is decoded against `budget`, and
/// reads as no value once it is spent, as one that won't decode does.
fn values_of(doc: &Document, o: Option<&Object>, budget: &mut DecodeBudget) -> Vec<String> {
let Some(o) = o else { return Vec::new() };
match &*doc.resolve(o) {
Object::Array(a) => a.iter().filter_map(|x| text_of(&doc.resolve(x))).collect(),
Object::Stream(s) => s.decoded().ok().map(|b| PdfString::literal(b).to_text()).into_iter().collect(),
Object::Stream(s) => budget.decode(s).ok().map(|b| PdfString::literal(b).to_text()).into_iter().collect(),
other => text_of(other).filter(|s| s != "Off" && !s.is_empty()).into_iter().collect(),
}
}
@@ -345,7 +351,12 @@ pub(crate) fn enumerate(doc: &Document) -> (Vec<Field>, usize) {
None => Inherited::default(),
};
let mut out = Vec::new();
let mut seen = Seen { fields: std::collections::HashSet::new(), widgets: std::collections::HashSet::new(), scripts: script_budget() };
let mut seen = Seen {
fields: std::collections::HashSet::new(),
widgets: std::collections::HashSet::new(),
scripts: script_budget(),
values: DecodeBudget::new(MAX_VALUE_BYTES, 0),
};
if let Some(af) = &af {
for f in af.get(b"Fields").map(|o| doc.resolve(o)).and_then(|o| o.as_array().cloned()).unwrap_or_default() {
if let Some(r) = f.as_ref() {
@@ -416,13 +427,14 @@ fn unlisted_root(doc: &Document, r: ObjRef, seen: &std::collections::HashSet<Obj
}
}
/// What one reading of the form's fields has used: the field and widget dictionaries read, and
/// the script budget their actions share.
/// What one reading of the form's fields has used: the field and widget dictionaries read, the
/// script budget their actions share, and the budget their value streams share.
struct Seen {
fields: std::collections::HashSet<ObjRef>,
/// A widget belongs to the first field that lists it, however often it is listed.
widgets: std::collections::HashSet<ObjRef>,
scripts: DecodeBudget,
values: DecodeBudget,
}
/// Read the field at `r` and the fields under it into `out`, with what they inherit from
@@ -549,8 +561,8 @@ fn walk(
name: inh.name.clone(),
obj: r,
kind,
value: values_of(doc, inh.v.as_ref()),
default: values_of(doc, inh.dv.as_ref()),
value: values_of(doc, inh.v.as_ref(), &mut seen.values),
default: values_of(doc, inh.dv.as_ref(), &mut seen.values),
flags: ff,
max_len: inh.max_len,
options,
crates/forms/src/tests.rs
+143
View File
@@ -3575,6 +3575,149 @@ fn repeated_script_references_share_one_decode_budget() {
assert!(calculate > 0 && calculate <= limit, "{calculate} bytes of field scripts");
}
/// An unfiltered stream of `body`, as an object of [`document`].
fn raw_stream(body: &str) -> String {
format!("<< /Length {} >>\nstream\n{body}\nendstream", body.len())
}
/// 300 fields whose value is one 1 MiB text stream: a reading of the form decodes their values
/// within one budget, not 300 MiB.
#[test]
fn repeated_value_streams_share_one_decode_budget() {
let fields_list: String = (0..300).map(|i| format!("{} 0 R ", i + 3)).collect();
let mut objs = vec![format!("<< /Type /Catalog /AcroForm << /Fields [{fields_list}] >> >>"), raw_stream(&"x".repeat(1 << 20))];
objs.extend((0..300).map(|i| format!("<< /FT /Tx /T (f{i}) /V 2 0 R /DV 2 0 R >>")));
let all = fields(&document(&objs));
assert_eq!(all.len(), 300);
let read: usize = all.iter().flat_map(|f| f.value.iter().chain(&f.default)).map(String::len).sum();
assert!(read > 0 && read <= crate::read::MAX_VALUE_BYTES, "{read} bytes of values");
assert_eq!(all[0].value, ["x".repeat(1 << 20)], "the first field still reads its value");
}
/// Clear form leaves a field as it is when its default is a stream the value budget didn't reach:
/// 70 fields typed in, whose default is one 1 MiB text stream, keep a value, the first ones
/// their default and the rest what was typed, none of them emptied.
#[test]
fn clear_form_keeps_a_field_whose_default_was_not_read() {
let n = 70;
let fields_list: String = (0..n).map(|i| format!("{} 0 R ", i + 3)).collect();
let mut objs = vec![format!("<< /Type /Catalog /AcroForm << /Fields [{fields_list}] >> >>"), raw_stream(&"d".repeat(1 << 20))];
objs.extend((0..n).map(|i| format!("<< /FT /Tx /T (f{i}) /V (typed) /DV 2 0 R >>")));
let mut doc = document(&objs);
reset(&mut doc, None).unwrap();
let values: Vec<String> = (0..n)
.map(|i| {
let field = doc.get(ObjRef::new(i as u32 + 3, 0));
field.as_dict().and_then(|d| d.get(b"V")).and_then(|v| v.as_string().map(PdfString::to_text)).unwrap_or_default()
})
.collect();
assert!(values.iter().all(|v| !v.is_empty()), "no field is emptied");
assert_eq!(values[0], "d".repeat(1 << 20), "the first field goes back to its default");
assert_eq!(values[n - 1], "typed", "the last field, whose default wasn't read, keeps its value");
// A value the reading didn't decode, with no default, is cleared: it isn't known to be empty.
let mut objs = vec![format!("<< /Type /Catalog /AcroForm << /Fields [{fields_list}] >> >>"), raw_stream(&"v".repeat(1 << 20))];
objs.extend((0..n).map(|i| format!("<< /FT /Tx /T (f{i}) /V 2 0 R >>")));
let mut doc = document(&objs);
reset(&mut doc, None).unwrap();
let last = doc.get(ObjRef::new(n as u32 + 2, 0));
assert!(last.as_dict().and_then(|d| d.get(b"V")).is_none_or(|v| !matches!(v, Object::Ref(_))), "the last field's unread value is cleared");
}
/// Renaming a field that 300 calculations read through one shared Calculate action, whose script
/// is a 256 KiB stream, decodes and rewrites that action once, in place: every calculation reads
/// the new name, and nothing is decoded or written 300 times.
#[test]
fn a_rename_rewrites_a_shared_calculation_once() {
let n = 300;
let refs = |from: usize| -> String { (from..from + n).map(|i| format!("{i} 0 R ")).collect() };
let js = format!("AFSimple_Calculate(\"SUM\", new Array (\"a\"));{}", " ".repeat(256 << 10));
let mut objs = vec![
"<< /Type /Catalog /Pages 2 0 R /AcroForm 4 0 R >>".into(),
"<< /Type /Pages /Kids [3 0 R] /Count 1 /MediaBox [0 0 600 800] >>".into(),
format!("<< /Type /Page /Parent 2 0 R /Annots [5 0 R {}] >>", refs(8)),
format!("<< /Fields [5 0 R {}] /DA (/Helv 0 Tf 0 g) >>", refs(8)),
"<< /Type /Annot /Subtype /Widget /FT /Tx /T (a) /Rect [50 700 250 720] /P 3 0 R >>".into(),
"<< /S /JavaScript /JS 7 0 R >>".into(),
raw_stream(&js),
];
objs.extend((0..n).map(|i| format!("<< /Type /Annot /Subtype /Widget /FT /Tx /T (c{i}) /Rect [50 10 250 30] /P 3 0 R /AA << /C 6 0 R >> >>")));
let mut doc = document(&objs);
set_props(&mut doc, "a", &FieldProps { name: Some("qty".into()), ..FieldProps::default() }).unwrap();
let action = ObjRef::new(6, 0);
let renamed = (8..8 + n).all(|i| {
let field = doc.get(ObjRef::new(i as u32, 0));
field.as_dict().and_then(|d| d.get(b"AA")).and_then(|aa| aa.as_dict()?.get(b"C")?.as_ref()) == Some(action)
});
assert!(renamed, "every calculation still names the one shared action");
let js = doc.get(action).as_dict().and_then(|d| d.get(b"JS")?.as_string().map(PdfString::to_text)).unwrap_or_default();
assert!(js.contains("\"qty\"") && !js.contains("\"a\""), "the shared action reads the new name");
assert!(js.len() <= MAX_SCRIPT_BYTES, "{} bytes written once", js.len());
}
/// A page whose `/Contents` lists one 1 MiB stream ten times is read within the budget given:
/// pieces past it read as empty, so their rectangles aren't found.
#[test]
fn page_shapes_decode_a_repeated_content_stream_within_the_budget() {
let piece = format!("%{}\n10 10 20 20 re S\n", "x".repeat(1 << 20));
let doc = document(&[
"<< /Type /Catalog /Pages 2 0 R >>".into(),
"<< /Type /Pages /Kids [3 0 R] /Count 1 /MediaBox [0 0 600 800] >>".into(),
format!("<< /Type /Page /Parent 2 0 R /Contents [{}] >>", "4 0 R ".repeat(10)),
raw_stream(&piece),
]);
assert_eq!(crate::detect::page_shapes(&doc, 0).boxes.len(), 10, "one page's allowance reads them all");
let mut budget = DecodeBudget::new(4 << 20, 0);
let boxes = crate::detect::shapes_within(&doc, 0, &mut budget).boxes.len();
assert!((1..=4).contains(&boxes), "{boxes} rectangles read within 4 MiB");
assert_eq!(budget.remaining(), 0, "the budget is spent");
}
/// Field detection keeps at most 256 saved graphics states, and each `Q` still restores its own
/// `q` past that: a scale set 300 saves deep is gone once they are all restored.
#[test]
fn page_shapes_restore_saves_past_the_cap() {
let content = format!("{} 2 0 0 2 0 0 cm {} 10 10 20 20 re S", "q ".repeat(300), "Q ".repeat(300));
let doc = document(&[
"<< /Type /Catalog /Pages 2 0 R >>".into(),
"<< /Type /Pages /Kids [3 0 R] /Count 1 /MediaBox [0 0 600 800] >>".into(),
"<< /Type /Page /Parent 2 0 R /Contents 4 0 R >>".into(),
raw_stream(&content),
]);
assert_eq!(crate::detect::page_shapes(&doc, 0).boxes, [[10.0, 10.0, 30.0, 30.0]]);
// A scale set past the cap and closed by its own `Q` leaves a matrix that can't be known until
// the last lost save closes: what is drawn in between isn't reported at the scaled place.
let content = format!("{} q 2 0 0 2 0 0 cm Q 10 10 20 20 re S {} 40 40 10 10 re S", "q ".repeat(257), "Q ".repeat(257));
let doc = document(&[
"<< /Type /Catalog /Pages 2 0 R >>".into(),
"<< /Type /Pages /Kids [3 0 R] /Count 1 /MediaBox [0 0 600 800] >>".into(),
"<< /Type /Page /Parent 2 0 R /Contents 4 0 R >>".into(),
raw_stream(&content),
]);
assert_eq!(crate::detect::page_shapes(&doc, 0).boxes, [[40.0, 40.0, 50.0, 50.0]]);
}
/// The PDF/A declaration is read from metadata each filter stage of which decodes within
/// [`crate::appearances::MAX_XMP_BYTES`], as preflight decodes it: a field drawn with characters its
/// font lacks decodes no more than that a stage.
#[test]
fn a_pdfa_declaration_is_read_from_metadata_within_its_cap() {
let declared = |xmp: String| declares_pdfa(&document(&["<< /Type /Catalog /Metadata 2 0 R >>".into(), raw_stream(&xmp)]));
let pdfa = |padding: usize| format!("<x:xmpmeta><pdfaid:part>2</pdfaid:part>{}</x:xmpmeta>", " ".repeat(padding));
assert!(declared(pdfa(1 << 20)));
assert!(!declared(pdfa(crate::appearances::MAX_XMP_BYTES)), "metadata past the cap declares nothing");
assert!(!declared("<x:xmpmeta><dc:title>pdfaid</dc:title></x:xmpmeta>".into()), "metadata without pdfaid:part declares nothing");
// 3.5 MiB stored as hex, then Flate: its stages decode 7 and 3.5 MiB, each within the cap.
let xmp = pdfa(7 << 19);
let hex: Vec<u8> = xmp.bytes().flat_map(|b| [b"0123456789ABCDEF"[usize::from(b >> 4)], b"0123456789ABCDEF"[usize::from(b & 15)]]).collect();
let mut stream = pdfcraft_cos::Stream::flate(pdfcraft_cos::Dict::new(), &hex);
stream.dict.set(b"Filter".to_vec(), Object::Array(vec![Object::name("FlateDecode"), Object::name("ASCIIHexDecode")]));
let mut doc = Document::new_empty();
let metadata = doc.add(Object::Stream(stream));
let catalog = doc.add(Object::Dict([(b"Metadata".to_vec(), Object::Ref(metadata))].into_iter().collect()));
doc.trailer_mut().set(b"Root".to_vec(), Object::Ref(catalog));
assert!(declares_pdfa(&doc), "metadata through a chain of filters declares PDF/A, as preflight decodes it");
}
/// A widget listed many times, by one field's `/Kids` or by a `/Kids` array several fields share,
/// is read once: the first field to list it owns it.
#[test]
crates/forms/src/values.rs
+24 -2
View File
@@ -470,7 +470,9 @@ fn redraw(doc: &mut Document, f: &Field, values: &[String], scripts: &mut dyn Sc
/// document that declares PDF/A, which forbids it: there the widget's mark
/// (`pdfcraft_fonts::UNDRAWN_MARK`) is all, and the edit's report says the `?` shows everywhere.
pub(crate) fn ask_viewers_to_redraw(doc: &mut Document) -> Result<(), FormError> {
if declares_pdfa(doc) || need_appearances(doc) {
// The form's own flag first: once it is set, the metadata needn't be decoded again for each
// field drawn after.
if need_appearances(doc) || declares_pdfa(doc) {
return Ok(());
}
let Some(root) = doc.root() else { return Ok(()) };
@@ -625,6 +627,22 @@ pub fn clear_password_values(doc: &mut Document) -> Result<usize, FormError> {
Ok(targets.len())
}
/// Whether `field`'s `key` (`/V` or `/DV`, its own or inherited) is a stream with data, which
/// [`fields`] reads as empty once its value budget is spent.
fn unread_stream(doc: &Document, field: ObjRef, key: &[u8]) -> bool {
let mut node = Some(field);
for _ in 0..64 {
let Some(r) = node else { break };
let obj = doc.get(r);
let Some(d) = obj.as_dict() else { break };
if let Some(value) = d.get(key) {
return matches!(&*doc.resolve(value), Object::Stream(s) if !s.raw.is_empty());
}
node = d.reference(b"Parent");
}
false
}
/// Acrobat's Clear form: every field (or the named ones) back to its default value.
pub fn reset(doc: &mut Document, names: Option<&[String]>) -> Result<usize, FormError> {
let all = fields(doc);
@@ -638,7 +656,11 @@ pub fn reset(doc: &mut Document, names: Option<&[String]>) -> Result<usize, Form
}
let mut changed = 0;
for f in all.iter().filter(|f| names.is_none_or(|n| n.contains(&f.name))) {
if f.value == f.default {
// A default the reading didn't decode (its budget spent) is unknown, not empty: clearing
// the field to nothing would lose the value it should go back to. A value it didn't decode
// isn't known to be the default, so it is reset.
let unread = |key: &[u8], read: &[String]| read.is_empty() && unread_stream(doc, f.obj, key);
if unread(b"DV", &f.default) || (f.value == f.default && !unread(b"V", &f.value)) {
continue;
}
let v = match f.kind {
crates/optimize/README.md
+10 -2
View File
@@ -89,7 +89,15 @@ let report = optimize_with_progress(&mut doc, &settings, &mut |stage| keep_going
alone when JBIG2 is asked for, is stored again as the compression asks when that is smaller (as JBIG2 symbols where
its own coding is a generic region, say); a symbol-coded scan, averaged, loses its exact
repeats and often comes out larger, and then stays as it is. A JBIG2 image stored again refers to no
`/JBIG2Globals`, and one whose page isn't its size (PdfCraft's
`/JBIG2Globals` of its own. With JBIG2 asked for, the images stored as JBIG2, up to 16 at a
time, then share one symbol dictionary in a new `/JBIG2Globals` stream, holding the marks found
in more than one of them: those that come out smaller that way, when together they save more
than it takes. Only images that redaction can store again without it share one: image masks
and DeviceGray images named directly, of at most 64 Mi pixels (redaction's limit,
`pdfcraft_cos::MAX_REDACTED_IMAGE_PIXELS`); others are coded alone.
Redacting one of them stores the others of its group again without it, so the group keeps that
to 15 images, and each image's decode reads the dictionary of 16 at most. A
JBIG2 image whose page isn't its size (PdfCraft's
renderer draws the whole page into the image) is left alone. With Retain, a resampled image
keeps its kind of compression (CCITT, JBIG2, or Flate) and nothing else changes; an image of
more bits is then left to the grey or colour settings. Every change is kept only when it is
@@ -103,7 +111,7 @@ let report = optimize_with_progress(&mut doc, &settings, &mut |stage| keep_going
is past the 80 million pixels above).
- Lossless JBIG2 uses bounded generic-region encoding or exact-copy symbol dictionaries when
smaller. No lossy symbol substitution is used. Export, redaction and this step read JBIG2
smaller, a dictionary shared by up to 16 images when that is smaller still. No lossy symbol substitution is used. Export, redaction and this step read JBIG2
images, with bounded shared globals. All of a run's images share one allowance of decoding
(`pdfcraft_cos::ImageBudget`), filters, decoders and pixels alike, JPEG samples and merged
pictures too: about
crates/optimize/src/images.rs
+182 -6
View File
@@ -1117,12 +1117,23 @@ fn downsample_bits_checked(data: &[u8], w: u32, h: u32, nw: u32, nh: u32, dark_i
/// to be resampled, and so is JBIG2 alone when Group 4 is asked for; Group 3, Group 4 inside
/// another filter, and JBIG2 otherwise are stored again like any other. With `Retain`, a resampled image keeps its kind of compression (CCITT, JBIG2, or
/// Flate), and nothing else changes: an image of more bits stays as it is, for the grey or
/// colour settings. A JBIG2 image stored again refers to no `/JBIG2Globals`.
/// colour settings. A JBIG2 image stored again refers to no `/JBIG2Globals`; with `Jbig2`, [`share`]
/// may then have a group of them share one.
///
/// The samples keep their meaning, so the colour space, decode array and `/Mask` stay, but for
/// black-and-white RGB, which becomes grey with one decode pair, and an indexed image's default
/// decode array, which goes as the default at one bit.
fn mono(doc: &Document, s: &Stream, ppi: f64, defaults: bool, settings: &MonoSettings, budget: &mut ImageBudget) -> Option<(Stream, bool)> {
///
/// Stored as JBIG2 with `Jbig2`, it comes with the 1-bit samples it was coded from, for [`share`]
/// to code again with the run's other JBIG2 images.
fn mono(
doc: &Document,
s: &Stream,
ppi: f64,
defaults: bool,
settings: &MonoSettings,
budget: &mut ImageBudget,
) -> Option<(Stream, bool, Option<Vec<u8>>)> {
let d = &s.dict;
let downsample = settings.downsample && ppi.is_finite() && ppi > settings.above_ppi && settings.target_ppi > 0.0 && !d.contains(b"SMask");
let retain = settings.compression == MonoCompression::Retain;
@@ -1206,7 +1217,106 @@ fn mono(doc: &Document, s: &Stream, ppi: f64, defaults: bool, settings: &MonoSet
let flate = ((resampled || packed_from_more) && !(retain && (ccitt || jbig2))).then(|| Stream::flate(dict, &data));
// Smaller as stored, counting the dictionary: a tiny image can lose by Group 4's parameters.
let best = [g4, jbig, flate].into_iter().flatten().filter_map(|c| Some((crate::stored_len(&c)?, c))).min_by_key(|(len, _)| *len)?;
(best.0 < crate::stored_len(s)?).then_some((best.1, resampled))
let shareable = settings.compression == MonoCompression::Jbig2 && best.1.dict.name(b"Filter") == Some(b"JBIG2Decode");
(best.0 < crate::stored_len(s)?).then(|| (best.1, resampled, shareable.then_some(data)))
}
/// The most images that share one symbol dictionary ([`share`]). Redaction stores again every
/// image that shares a redacted one's dictionary, and each image's decode reads all of it, so a
/// group keeps both to that many; most of what sharing saves comes with the first few images.
const SHARED_IMAGES: usize = 16;
/// The most bytes of 1-bit samples a group holds: a group is coded before it would pass them
/// ([`hold_in`]). An image that shares has at most [`SHARED_PIXELS`], and as its rows are whole
/// bytes, at most that many bytes, which is this: one always fits a group with nothing in it.
const SHARED_BYTES: usize = 64 << 20;
/// What the globals cost as an object of their own besides their dictionary and data: `N 0 obj`,
/// `stream`, `endstream` and `endobj`, a cross-reference entry, and an encrypted file's IV and
/// padding. A group is shared only when it saves more than that as well.
const NEW_OBJECT: usize = 96;
/// Adds `image` to `group`, coding the group (`share`, which empties it) first when the image's
/// samples would take it past `cap` bytes, and after when it has [`SHARED_IMAGES`].
fn hold_in(group: &mut Vec<Held>, image: Held, cap: usize, mut share: impl FnMut(&mut Vec<Held>)) {
if group.iter().map(|h| h.bits.len()).fold(image.bits.len(), usize::saturating_add) > cap {
share(group);
}
group.push(image);
if group.len() == SHARED_IMAGES {
share(group);
}
}
/// The most pixels an image sharing a dictionary has: redaction's own limit on the images it
/// stores again (see [`shares`]).
const SHARED_PIXELS: u64 = pdfcraft_cos::MAX_REDACTED_IMAGE_PIXELS;
/// Whether an image stored as JBIG2 (its dictionary `d`) may share a dictionary: only one that
/// redaction can store again without it, an image mask or a DeviceGray image, named directly, of
/// at most [`SHARED_PIXELS`]. Redacting one image of a group stores the others so, as the
/// dictionary can hold the shapes of marks under the area, and refuses the redaction for one it
/// can't; an image of another colour space, though redaction may take it, is coded alone.
fn shares(d: &Dict) -> bool {
let side = |key: &[u8]| d.int(key).and_then(|v| u64::try_from(v).ok());
let within = side(b"Width").zip(side(b"Height")).is_some_and(|(w, h)| w.saturating_mul(h) <= SHARED_PIXELS);
within && (matches!(d.get(b"ImageMask"), Some(Object::Bool(true))) || d.name(b"ColorSpace") == Some(b"DeviceGray"))
}
/// An image the run stored as JBIG2, held to be stored again sharing a dictionary ([`share`]): its
/// 1-bit samples, `width` × `height`.
struct Held {
image: ObjRef,
bits: Vec<u8>,
width: u32,
height: u32,
}
/// Stores the images of `group`, each JBIG2 already, again sharing one symbol dictionary in a
/// `/JBIG2Globals` stream ([`pdfcraft_filters::encode_jbig2_shared`]): those that come out smaller
/// that way, if together they save more than the globals take. The others stay as they are, and
/// so do all of them when that saves nothing. `report` counts the bytes as they end up, the globals
/// included.
fn share(doc: &mut Document, group: &mut Vec<Held>, report: &mut Report) {
let held = std::mem::take(group);
if held.len() < 2 {
return;
}
let images: Vec<(&[u8], u32, u32)> = held.iter().map(|h| (&h.bits[..], h.width, h.height)).collect();
let Ok(Some(shared)) = pdfcraft_filters::encode_jbig2_shared(&images) else { return };
let with_globals = |s: &Stream, coded: Vec<u8>, globals: ObjRef| {
let mut dict = s.dict.clone();
let mut parms = Dict::new();
parms.set(b"JBIG2Globals".to_vec(), Object::Ref(globals));
dict.set(b"DecodeParms".to_vec(), Object::Dict(parms));
Stream::from_raw(dict, coded)
};
// Weighed naming the globals with the longest reference there is: the real one is no longer.
let longest = ObjRef { num: u32::MAX, generation: u16::MAX };
let (mut chosen, mut saved) = (Vec::new(), 0usize);
for (h, coded) in held.iter().zip(shared.images) {
let Some(coded) = coded else { continue };
let object = doc.get(h.image);
let Object::Stream(alone) = &*object else { continue };
let shorter = crate::stored_len(alone).zip(crate::stored_len(&with_globals(alone, coded.clone(), longest))).filter(|(a, b)| b < a);
if let Some((before, after)) = shorter {
saved = saved.saturating_add(before - after);
chosen.push((h.image, coded));
}
}
let globals = Stream::from_raw(Dict::new(), shared.globals);
if chosen.is_empty() || crate::stored_len(&globals).is_none_or(|takes| saved <= takes.saturating_add(NEW_OBJECT)) {
return;
}
report.image_bytes_after = report.image_bytes_after.saturating_add(globals.raw.len());
let globals = doc.add(Object::Stream(globals));
for (image, coded) in chosen {
let object = doc.get(image);
let Object::Stream(alone) = &*object else { continue };
report.image_bytes_after = report.image_bytes_after.saturating_sub(alone.raw.len()).saturating_add(coded.len());
let new = with_globals(alone, coded, globals);
doc.set(image, Object::Stream(new));
}
}
/// One pass over the document's images, within `budget`. An image past it stays as it is, and is
@@ -1239,6 +1349,13 @@ pub(crate) fn run(
refs.sort_by_key(|(r, _)| r.num);
let total = refs.len();
let mut jbig2 = false;
let mut group: Vec<Held> = Vec::new();
// Holds a JBIG2 image for `share`, which codes the group once it is full.
let mut hold = |doc: &mut Document, image: ObjRef, size: (Option<i64>, Option<i64>), bits: Option<Vec<u8>>, report: &mut Report| {
let side = |v: Option<i64>| v.and_then(|v| u32::try_from(v).ok());
let (Some(bits), Some(width), Some(height)) = (bits, side(size.0), side(size.1)) else { return };
hold_in(&mut group, Held { image, bits, width, height }, SHARED_BYTES, |group| share(doc, group, report));
};
for (done, (r, ppi)) in refs.into_iter().enumerate() {
if !progress(Stage::Images { done, total }) {
return Err(OptimizeError::Cancelled);
@@ -1254,7 +1371,7 @@ pub(crate) fn run(
Some(m) if packed_from_more => (Some(m), None),
m => (None, m),
};
if let Some((new, resampled)) = mono {
if let Some((new, resampled, bits)) = mono {
report.image_bytes_before += s.raw.len();
report.image_bytes_after += new.raw.len();
if resampled {
@@ -1263,7 +1380,10 @@ pub(crate) fn run(
report.images_recompressed += 1;
}
jbig2 |= new.dict.name(b"Filter") == Some(b"JBIG2Decode");
let size = (new.dict.int(b"Width"), new.dict.int(b"Height"));
let bits = bits.filter(|_| shares(&new.dict));
doc.set(r, Object::Stream(new));
hold(doc, r, size, bits, report);
continue;
}
let n = s.dict.get(b"ColorSpace").and_then(|cs| components(doc, cs));
@@ -1278,10 +1398,10 @@ pub(crate) fn run(
}),
};
let total = |new: &Stream, smask: Option<&(ObjRef, Stream)>| Some(crate::stored_len(new)?.saturating_add(smask_len(smask).unwrap_or(0)));
let packed_wins = packed.as_ref().is_some_and(|(p, _)| {
let packed_wins = packed.as_ref().is_some_and(|(p, _, _)| {
processed.as_ref().is_none_or(|(new, smask)| total(p, None).zip(total(new, smask.as_ref())).is_some_and(|(a, b)| a <= b))
});
if let Some((new, resampled)) = packed.filter(|_| packed_wins) {
if let Some((new, resampled, bits)) = packed.filter(|_| packed_wins) {
jbig2 |= new.dict.name(b"Filter") == Some(b"JBIG2Decode");
report.image_bytes_before += s.raw.len();
report.image_bytes_after += new.raw.len();
@@ -1290,7 +1410,10 @@ pub(crate) fn run(
} else {
report.images_recompressed += 1;
}
let size = (new.dict.int(b"Width"), new.dict.int(b"Height"));
let bits = bits.filter(|_| shares(&new.dict));
doc.set(r, Object::Stream(new));
hold(doc, r, size, bits, report);
continue;
}
let Some((new, smask)) = processed else {
@@ -1311,6 +1434,7 @@ pub(crate) fn run(
doc.set(mr, Object::Stream(m));
}
}
share(doc, &mut group, report);
if !progress(Stage::Images { done: total, total }) {
return Err(OptimizeError::Cancelled);
}
@@ -1338,6 +1462,58 @@ fn at_least_pdf_1_4(doc: &mut Document) -> Result<(), OptimizeError> {
mod dimension_tests {
use super::*;
/// A group is coded before an image's samples would take it past its limit, and once it has
/// [`SHARED_IMAGES`]: with room for 10 bytes, images of 4 go two to a group, never three, and
/// with room for 8, two of 4 fill one exactly; one of exactly the limit joins a group with
/// nothing in it.
#[test]
fn a_group_is_coded_before_its_samples_would_pass_the_limit() {
let held = |bytes: usize| Held { image: ObjRef { num: 1, generation: 0 }, bits: vec![0; bytes], width: 8, height: 8 };
let mut coded: Vec<Vec<usize>> = Vec::new();
let mut group = Vec::new();
let mut code = |g: &mut Vec<Held>| coded.push(std::mem::take(g).iter().map(|h| h.bits.len()).collect());
for _ in 0..5 {
hold_in(&mut group, held(4), 10, &mut code);
}
hold_in(&mut group, held(10), 10, &mut code);
assert_eq!(coded, [vec![4, 4], vec![4, 4], vec![4]]);
assert_eq!(group.iter().map(|h| h.bits.len()).collect::<Vec<_>>(), [10]);
// Exactly the limit is within it: with room for 8, two images of 4 stay together.
let (mut count, mut group) = (0, Vec::new());
let mut code = |g: &mut Vec<Held>| count += std::mem::take(g).len();
hold_in(&mut group, held(4), 8, &mut code);
hold_in(&mut group, held(4), 8, &mut code);
assert_eq!((count, group.len()), (0, 2));
let (mut count, mut group) = (0, Vec::new());
for _ in 0..SHARED_IMAGES {
hold_in(&mut group, held(1), usize::MAX, |g| count += std::mem::take(g).len());
}
assert_eq!((count, group.len()), (SHARED_IMAGES, 0), "coded on the 16th");
}
/// Only what redaction can store again without the dictionary shares one: an image mask, or
/// DeviceGray named directly, of at most 2^26 pixels.
#[test]
fn only_what_redaction_can_store_again_shares_a_dictionary() {
let dict = |entries: Vec<(&str, Object)>| {
let mut d = Dict::new();
for (k, v) in entries {
d.set(k.as_bytes().to_vec(), v);
}
d
};
let sized = |w: i64, h: i64, cs: Object| dict(vec![("Width", Object::Int(w)), ("Height", Object::Int(h)), ("ColorSpace", cs)]);
assert!(shares(&sized(8192, 8192, Object::name("DeviceGray"))));
assert!(!shares(&sized(8192, 8193, Object::name("DeviceGray"))), "a row past 2^26 pixels");
assert!(shares(&dict(vec![("Width", Object::Int(8)), ("Height", Object::Int(8)), ("ImageMask", Object::Bool(true))])));
let device_n =
Object::Array(vec![Object::name("DeviceN"), Object::Array(vec![Object::name("Black")]), Object::name("DeviceGray"), Object::Null]);
assert!(!shares(&sized(8, 8, device_n)));
assert!(!shares(&sized(8, 8, Object::name("CalGray"))));
assert!(!shares(&sized(8, 8, Object::Ref(ObjRef { num: 3, generation: 0 }))), "a colour space by reference");
assert!(!shares(&dict(vec![("ColorSpace", Object::name("DeviceGray"))])), "no size");
}
#[test]
fn pixel_reader_rejects_hostile_dimensions_before_decoding() {
for (width, height, channels) in [(-1, 1, 1), (0, 1, 1), (i64::from(u32::MAX) + 101, 1, 1), (80_000_001, 1, 1), (2, 2, usize::MAX)] {
crates/optimize/tests/optimize.rs
+200 -2
View File
@@ -1951,8 +1951,17 @@ fn black_and_white_images_become_jbig2() {
assert!(r.image_bytes_after < as_g4.image_bytes_after, "JBIG2 {} bytes, Group 4 {}", r.image_bytes_after, as_g4.image_bytes_after);
let images: Vec<Stream> = image_refs(&jbig2).into_iter().map(|i| stream(&jbig2, i)).collect();
assert_eq!(images.len(), 3);
// The same text three times: the grey image and the mask share one symbol dictionary, and the
// indexed image, which only those share, is coded alone.
let globals_of = |s: &Stream| s.dict.get(b"DecodeParms").and_then(Object::as_dict).map(|d| (d.len(), d.reference(b"JBIG2Globals")));
let is_indexed = |s: &Stream| s.dict.get(b"ColorSpace").and_then(Object::as_array).is_some();
let shared: Vec<_> = images.iter().filter(|s| !is_indexed(s)).map(globals_of).collect();
assert!(shared.len() == 2 && shared[0].is_some_and(|(n, g)| n == 1 && g.is_some()) && shared[0] == shared[1], "{shared:?}");
for s in &images {
assert_eq!((s.dict.name(b"Filter"), s.dict.contains(b"DecodeParms")), (Some(&b"JBIG2Decode"[..]), false));
assert_eq!(s.dict.name(b"Filter"), Some(&b"JBIG2Decode"[..]));
if is_indexed(s) {
assert!(!s.dict.contains(b"DecodeParms"));
}
}
assert!(images.iter().any(|s| s.dict.get(b"Decode") == Some(&decode)), "the decode array stays");
let indexed_kept =
@@ -1999,6 +2008,11 @@ fn a_catalog_version_given_by_reference_is_read() {
/// `#` a 3 × 3 block, three columns apart with a wider gap between words, every copy of a letter
/// the same to the pixel.
fn rendered_text(w: u32, h: u32) -> Vec<u8> {
rendered_text_from(w, h, 0x2545_F491_4F6C_DD1D)
}
/// [`rendered_text`], its letters picked from `seed`, which isn't 0.
fn rendered_text_from(w: u32, h: u32, mut seed: u64) -> Vec<u8> {
const LETTERS: [&[&str]; 5] = [
&["##", "##", "##", "##", "##", "##", "##", "##", "##", "##"],
&["......", ".####.", "##..##", "##..##", "##..##", "##..##", ".####."],
@@ -2008,7 +2022,6 @@ fn rendered_text(w: u32, h: u32) -> Vec<u8> {
];
let stride = (w as usize).div_ceil(8);
let mut data = vec![0xFF; stride * h as usize];
let mut seed = 0x2545_F491_4F6C_DD1Du64;
let mut next = move || {
seed ^= seed << 13;
seed ^= seed >> 7;
@@ -2053,9 +2066,194 @@ fn rendered_text_becomes_jbig2_symbols() {
assert_eq!(s.dict.name(b"Filter"), Some(&b"JBIG2Decode"[..]));
let generic = pdfcraft_filters::encode_jbig2_generic(&text, w, h).unwrap();
assert!(s.raw.len() * 2 < generic.len(), "symbols {} bytes, generic {}", s.raw.len(), generic.len());
assert!(!s.dict.contains(b"DecodeParms"), "alone, it shares no dictionary");
assert!(render(&doc) == before, "the page looks the same");
}
/// Page `index` of `doc`, saved and opened again, rendered at scale 1.
fn render_page(doc: &Document, index: usize) -> Vec<u8> {
let bytes = write_full(doc, &SaveOptions::default()).unwrap();
let mut r = pdfcraft_render::PageRenderer::new(Arc::new(bytes), pdfcraft_render::RenderConfig::default());
let out = r.render(pdfcraft_render::RenderRequest { page: index, scale: 1.0, ..Default::default() });
assert!(out.error.is_none(), "{:?}", out.error);
out.rgba.to_vec()
}
/// Text in a font of 26 letters, about 10 pt at 300 dpi: each letter 32 rows of a run from a stem
/// down its left side, of 2 to 24 pixels, every copy the same to the pixel; lines 44 rows apart,
/// the letters picked from `seed`, which isn't 0.
fn font_text(w: u32, h: u32, mut seed: u64) -> Vec<u8> {
let mut font_seed = 0x2545_F491_4F6C_DD1Du64;
let next = |seed: &mut u64| {
*seed ^= *seed << 13;
*seed ^= *seed >> 7;
*seed ^= *seed << 17;
*seed
};
let letters: Vec<Vec<usize>> = (0..26).map(|_| (0..16).map(|_| 1 + (next(&mut font_seed) % 12) as usize).collect()).collect();
let stride = (w as usize).div_ceil(8);
let mut data = vec![0xFF; stride * h as usize];
for top in (8..(h as usize).saturating_sub(40)).step_by(44) {
let mut x = 8;
while x + 32 < w as usize {
let letter = &letters[(next(&mut seed) % 26) as usize];
for (row, run) in letter.iter().enumerate() {
for y in [top + 2 * row, top + 2 * row + 1] {
for px in x..x + 2 * run {
data[y * stride + px / 8] &= !(0x80 >> (px % 8));
}
}
}
x += 2 * letter.iter().max().unwrap() + 4 + if next(&mut seed) % 6 == 0 { 14 } else { 0 };
}
}
data
}
/// The `/JBIG2Globals` an image names in its `/DecodeParms`.
fn globals_of(doc: &Document, image: ObjRef) -> Option<ObjRef> {
stream(doc, image).dict.get(b"DecodeParms")?.as_dict()?.reference(b"JBIG2Globals")
}
/// Pages of text in one font, each letter the same to the pixel on every page, stored as JBIG2
/// share one symbol dictionary (`/JBIG2Globals`): together they take less than each page coded
/// alone, and every page looks the same, the last one, whose crosses no other page has, placing
/// them from a dictionary of its own beside the shared one. The report counts the bytes they
/// take, the globals once.
#[test]
fn jbig2_pages_share_one_symbol_dictionary() {
let mut doc = Document::new_empty();
let (w, h) = (600u32, 480u32);
let stride = (w as usize).div_ceil(8);
let pages: Vec<Vec<u8>> = (1..=4u64)
.map(|k| {
let mut text = font_text(w, h, k.wrapping_mul(0x9E37_79B9_7F4A_7C15));
if k == 4 {
// Crosses down the right margin, three pixels a stroke.
for top in (40..440).step_by(40) {
for (dx, dy) in (0..9).map(|i| (i, 4)).chain((0..9).map(|i| (4, i))) {
let (x, y) = (580 + dx, top + dy);
text[y * stride + x / 8] &= !(0x80 >> (x % 8));
}
}
}
text
})
.collect();
let images: Vec<ObjRef> = pages
.iter()
.map(|text| {
let im = mono_image(&mut doc, w, h, text, None, &[("BitsPerComponent", 1.into()), ("ColorSpace", Object::name("DeviceGray"))]);
page(&mut doc, &[("Im", im)], "q 600 0 0 480 6 300 cm /Im Do Q");
im
})
.collect();
let before: Vec<Vec<u8>> = (0..pages.len()).map(|p| render_page(&doc, p)).collect();
let alone: usize = pages.iter().map(|text| pdfcraft_filters::encode_jbig2(text, w, h).unwrap().len()).sum();
let settings = Settings { mono: MonoSettings { compression: MonoCompression::Jbig2, ..MonoSettings::REDUCE }, ..Settings::default() };
let report = optimize(&mut doc, &settings).unwrap();
let globals = globals_of(&doc, images[0]).expect("the first page names the globals");
assert!(images.iter().all(|im| globals_of(&doc, *im) == Some(globals)), "every page names the same globals");
let shared = stream(&doc, globals).raw.len() + images.iter().map(|im| stream(&doc, *im).raw.len()).sum::<usize>();
assert!(shared * 4 < alone * 3, "shared {shared} bytes, alone {alone}");
assert_eq!(report.image_bytes_after, shared);
for (p, before) in before.iter().enumerate() {
assert!(render_page(&doc, p) == *before, "page {p} looks the same");
let s = stream(&doc, images[p]);
assert_eq!(decoded_image(&doc, &s).unwrap(), pages[p], "page {p} decodes to its samples");
}
// Optimized again, each page would come out larger alone than it is beside the globals: the
// sharing stays.
let streams: Vec<Stream> = images.iter().map(|im| stream(&doc, *im)).collect();
let again = optimize(&mut doc, &settings).unwrap();
assert_eq!((again.images_recompressed, again.images_resampled), (0, 0));
assert!(images.iter().zip(&streams).all(|(im, s)| stream(&doc, *im) == *s));
}
/// Images share a dictionary only where that saves more than it takes: two pages of five small
/// letters save less than their globals would take, and stay as they are coded alone.
#[test]
fn a_dictionary_that_saves_less_than_it_takes_isnt_shared() {
let mut doc = Document::new_empty();
let (w, h) = (600u32, 480u32);
let images: Vec<ObjRef> = (1..=2u64)
.map(|k| {
let text = rendered_text_from(w, h, k.wrapping_mul(0x9E37_79B9_7F4A_7C15));
let im = mono_image(&mut doc, w, h, &text, None, &[("BitsPerComponent", 1.into()), ("ColorSpace", Object::name("DeviceGray"))]);
page(&mut doc, &[("Im", im)], "q 600 0 0 480 6 300 cm /Im Do Q");
im
})
.collect();
let settings = Settings { mono: MonoSettings { compression: MonoCompression::Jbig2, ..MonoSettings::REDUCE }, ..Settings::default() };
let report = optimize(&mut doc, &settings).unwrap();
assert_eq!(report.images_recompressed, 2);
for im in &images {
let s = stream(&doc, *im);
assert_eq!((s.dict.name(b"Filter"), s.dict.contains(b"DecodeParms")), (Some(&b"JBIG2Decode"[..]), false));
}
// Optimized again, they code to what they are, no smaller: they stay.
let streams: Vec<Stream> = images.iter().map(|im| stream(&doc, *im)).collect();
assert_eq!(optimize(&mut doc, &settings).unwrap().images_recompressed, 0);
assert!(images.iter().zip(&streams).all(|(im, s)| stream(&doc, *im) == *s));
}
/// Only JBIG2 asked for shares: under Retain, JBIG2 pages drawn at 600 ppi are averaged and stored
/// as JBIG2 again, each alone, as Retain changes nothing but their resolution.
#[test]
fn retained_jbig2_shares_nothing() {
let mut doc = Document::new_empty();
let (w, h) = (1200u32, 960u32);
let images: Vec<ObjRef> = (1..=4u64)
.map(|k| {
let text = font_text(w, h, k.wrapping_mul(0x9E37_79B9_7F4A_7C15));
let mut d = Dict::new();
for (key, value) in [("Type", Object::name("XObject")), ("Subtype", Object::name("Image")), ("ColorSpace", Object::name("DeviceGray"))] {
d.set(key.as_bytes().to_vec(), value);
}
for (key, value) in [("Width", i64::from(w)), ("Height", i64::from(h)), ("BitsPerComponent", 1)] {
d.set(key.as_bytes().to_vec(), Object::Int(value));
}
d.set(b"Filter".to_vec(), Object::name("JBIG2Decode"));
let im = doc.add(Object::Stream(Stream::from_raw(d, pdfcraft_filters::encode_jbig2(&text, w, h).unwrap())));
// 1200 samples over 144 pt: 600 ppi.
page(&mut doc, &[("Im", im)], "q 144 0 0 115.2 6 300 cm /Im Do Q");
im
})
.collect();
let settings = Settings { mono: MonoSettings { compression: MonoCompression::Retain, ..MonoSettings::REDUCE }, ..Settings::default() };
assert_eq!(optimize(&mut doc, &settings).unwrap().images_resampled, 4);
for im in images {
let s = stream(&doc, im);
assert_eq!((s.dict.name(b"Filter"), s.dict.contains(b"DecodeParms")), (Some(&b"JBIG2Decode"[..]), false));
}
}
/// Sixteen images at most share one dictionary, and two are enough: of eighteen, the first
/// sixteen share one and the other two another.
#[test]
fn sixteen_images_at_most_share_a_dictionary() {
let mut doc = Document::new_empty();
let (w, h) = (600u32, 480u32);
let texts: Vec<Vec<u8>> = (1..=18u64).map(|k| font_text(w, h, k.wrapping_mul(0x9E37_79B9_7F4A_7C15))).collect();
let images: Vec<ObjRef> = texts
.iter()
.map(|text| {
let im = mono_image(&mut doc, w, h, text, None, &[("BitsPerComponent", 1.into()), ("ColorSpace", Object::name("DeviceGray"))]);
page(&mut doc, &[("Im", im)], "q 600 0 0 480 6 300 cm /Im Do Q");
im
})
.collect();
let settings = Settings { mono: MonoSettings { compression: MonoCompression::Jbig2, ..MonoSettings::REDUCE }, ..Settings::default() };
optimize(&mut doc, &settings).unwrap();
let globals: Vec<Option<ObjRef>> = images.iter().map(|im| globals_of(&doc, *im)).collect();
assert!(globals.iter().all(Option::is_some), "{globals:?}");
assert!(globals[..16].iter().all(|g| *g == globals[0]) && globals[16..].iter().all(|g| *g == globals[16]), "{globals:?}");
assert_ne!(globals[0], globals[16]);
for (k, (im, text)) in images.iter().zip(&texts).enumerate() {
assert!(decoded_image(&doc, &stream(&doc, *im)).unwrap() == *text, "image {k} decodes to its samples");
}
}
/// A JBIG2 scan goes through Monochrome Images like any black-and-white image. Above 450 ppi it
/// is averaged as its Flate copy is, to the same samples, and stored as each compression asks:
/// Group 4 or JBIG2, or Flate when that is smaller, or under Retain JBIG2 again; alone or behind another
crates/prc/Cargo.toml
+18
View File
@@ -0,0 +1,18 @@
[package]
name = "pdfcraft-prc"
description = "PRC 3D model reader (ISO 14739-1): container, bit-level primitives, schema"
version.workspace = true
edition.workspace = true
license.workspace = true
rust-version.workspace = true
repository.workspace = true
[lints]
workspace = true
[dependencies]
flate2.workspace = true
thiserror.workspace = true
[dev-dependencies]
proptest.workspace = true
crates/prc/README.md
+43
View File
@@ -0,0 +1,43 @@
# pdfcraft-prc
A reader for PRC (ISO 14739-1), the 3D model format a PDF `/3D` stream of `/Subtype /PRC` carries (ISO 32000-2 §13.6.3).
- **Layer:** L0, standalone. No dependency on any other PdfCraft crate.
- **Licence:** MIT OR Apache-2.0. Inflation through `flate2` with the pure-Rust `miniz_oxide` backend.
- `#![forbid(unsafe_code)]`. Never panics on input: inflated bytes, decoded elements, schema steps and walk depth are capped, and damage returns `PrcError`.
## API
```rust
PrcFile::parse(data) -> Result<PrcFile, PrcError> // header, file structures, model file
PrcFile::parse_with_limit(data, max_inflated) -> Result<PrcFile, PrcError>
FileStructure::section(SectionKind) -> &[u8] // inflated globals / tree / tessellation / geometry / extra geometry
FileStructure::schema() -> Result<Schema, PrcError> // the globals section's leading schema
FileStructure::tessellations() -> Result<Vec<Tessellation>, PrcError> // meshes, wires, markups, compressed meshes
PrcFile::placements() / placements_with(StyleAlpha, EntityOverrides) -> Result<Vec<Placement>, PrcError>
PrcFile::model_tree() -> Result<Vec<ModelNode>, PrcError> // the assembly tree as a model-tree panel lists it
Placement::triangle_colours(&TriangleMesh) -> Option<Vec<Option<Rgba>>>
TriangleMesh::transformed(&Matrix) -> TriangleMesh
Schema::read(&mut BitReader) / Schema::skip_added_fields(entity_type, &mut BitReader)
BitReader: bit, bits, character, unsigned_integer, integer, integer_vbn, double_vbn, nbits_then_unsigned, string, float_as_bytes, double
```
- `MAX_INFLATED_BYTES` (512 MiB) bounds every section together; `TooLarge` reports the limit hit.
- `MAX_DECODED_ELEMENTS` (2^24) bounds the array elements one pass decodes (a tree walk, or one `tessellations` call), since a single bit can decode to a 4-8 byte element; `TooManyElements` reports it.
- Schema programs (how a newer producer describes fields it added) run under a nesting ceiling (64) and `MAX_SCHEMA_STEPS` (2^22), shared like `MAX_DECODED_ELEMENTS` by every program one pass runs.
- `Unsupported` names constructs the reader cannot step over (schema pointer fields, `Value_CurveIs3D`).
- `Tessellation::Mesh` is a `TriangleMesh`: positions, triangles, one triangle range per face, the stored normals and
texture coordinates with each triangle's corner indices into them, and per-triangle line-attribute styles.
`Wire` is polylines; `Markup` is read past.
- `Tessellation::Compressed` is read to its end so later entities decode; its triangles are not rebuilt yet.
- A face may carry at most 8 texture-coordinate sets; more is `Malformed`. Optimised vertex colours are `Unsupported`.
- The product tree: each drawable tessellation placed by its occurrence path's locations and the item's coordinate
systems (a 4x4 `Matrix`), coloured by the style inheritance rules, with occurrences' entity references applied
(`EntityOverrides`: subtree, everywhere or ignored) and style transparency combined with material alpha by `StyleAlpha`.
A prototype's part is coloured by its own file structure's styles. Each `ModelNode` lists its name, where the name
came from, its visibility and the range of placements it drew.
- Occurrence and prototype cycles are `Malformed`; the walk is capped at depth 64, 2^20 visits and `MAX_PLACEMENTS`.
- A tree's markups (PMI), views, scene lights and clipping planes are read past, not modelled; so are textures.
- Not yet in the crate: rebuilding compressed meshes, textures.
- The `Double` code table's rows come from [prc-rs](https://github.com/ralovich/prc-rs) (MIT); its notice is in `src/acof/table.rs`.
A few reading choices also follow prc-rs; each is marked `// prc-rs:` in the source.
crates/prc/src/acof.rs
+93
View File
@@ -0,0 +1,93 @@
//! The prefix-code table behind the PRC `Double` [WD 11.17.2].
//!
//! The table has 2077 rows: 29 frequent doubles and one row per IEEE binary64 exponent
//! (0..=2047). Each row is a code of 1 to 22 bits and the value it decodes to.
//! The rows come from prc-rs under its MIT licence (see [`table`]).
use std::collections::HashMap;
use std::sync::OnceLock;
mod table;
/// Rows a complete table has.
const ROWS: usize = 2077;
/// The longest code, in bits.
pub(crate) const MAX_CODE_BITS: u32 = 22;
/// What a code decodes to.
#[derive(Debug, Clone, Copy, PartialEq)]
pub(crate) enum Entry {
/// A frequent value, returned with the sign bit applied.
Double(f64),
/// The upper 32 bits of a binary64 (exponent set, mantissa zero); the mantissa follows
/// in the stream.
Exponent(u32),
}
/// One row: code length, code, and what it decodes to.
type Row = (u32, u32, Entry);
fn key(nbits: u32, code: u32) -> u32 {
(nbits << 24) | code
}
/// The rows keyed by `(nbits, code)`, or `None` when the table is incomplete or not prefix
/// free (then no `Double` decodes, rather than some decoding wrongly).
fn build(rows: &[Row]) -> Option<HashMap<u32, Entry>> {
let mut map = HashMap::with_capacity(rows.len());
for &(nbits, code, entry) in rows {
if nbits == 0 || nbits > MAX_CODE_BITS || code >> nbits != 0 || map.insert(key(nbits, code), entry).is_some() {
return None;
}
}
let prefix_free = map.keys().all(|&k| {
let (n, c) = (k >> 24, k & 0xff_ffff);
(1..n).all(|m| !map.contains_key(&key(m, c >> (n - m))))
});
(map.len() == ROWS && prefix_free).then_some(map)
}
fn table() -> Option<&'static HashMap<u32, Entry>> {
static MAP: OnceLock<Option<HashMap<u32, Entry>>> = OnceLock::new();
MAP.get_or_init(|| build(table::TABLE)).as_ref()
}
/// The entry for an `nbits`-long code, if one exists.
pub(crate) fn lookup(nbits: u32, code: u32) -> Option<Entry> {
table()?.get(&key(nbits, code)).copied()
}
/// The `(nbits, code)` of IEEE exponent `e`'s row, the test writer's half of [`lookup`].
#[cfg(test)]
pub(crate) fn exponent_code(e: u32) -> Option<(u32, u32)> {
table()?.iter().find(|(_, v)| matches!(v, Entry::Exponent(hi) if (hi >> 20) & 0x7ff == e)).map(|(&k, _)| (k >> 24, k & 0xff_ffff))
}
#[cfg(test)]
#[allow(clippy::unwrap_used)]
mod tests {
use super::*;
#[test]
fn an_incomplete_or_ambiguous_table_decodes_nothing() {
assert!(build(&[(2, 0b01, Entry::Double(0.0))]).is_none(), "one row is not the table");
let rows: Vec<Row> = (0..ROWS as u32).map(|i| (22, i, Entry::Exponent(i))).collect();
assert!(build(&rows).is_some(), "2077 distinct 22-bit codes are prefix free");
let mut ambiguous = rows.clone();
ambiguous[0] = (1, 0, Entry::Double(1.0)); // a prefix of every code starting 0
assert!(build(&ambiguous).is_none());
let mut too_long = rows;
too_long[0] = (2, 0b111, Entry::Double(1.0)); // a code wider than its length
assert!(build(&too_long).is_none());
}
#[test]
fn the_table_is_complete() {
let t = table().unwrap();
assert_eq!(t.len(), ROWS);
assert_eq!(t.values().filter(|e| matches!(e, Entry::Double(_))).count(), 29);
assert!((0..2048).all(|e| exponent_code(e).is_some()));
assert_eq!(lookup(2, 0b01), Some(Entry::Double(0.0)));
}
}
crates/prc/src/acof/table.rs
+2113
View File
File diff suppressed because it is too large. Load diff
crates/prc/src/arrays.rs
+420
View File
@@ -0,0 +1,420 @@
//! The array primitives of compressed tessellation [WD 11.6-11.9] and the Huffman payload
//! they may carry [WD 12.2].
//!
//! The WD gives only the Huffman writer. The reader decodes what producers write: each
//! leaf's code length is read in the width the payload's 8-bit field states (the WD writes a
//! fixed 8 bits), stored codes carry a leading root bit, and the payload is read LSB-first
//! although the stream around it is MSB-first.
use std::collections::HashMap;
use crate::PrcError;
use crate::bits::BitReader;
/// Longest Huffman code [WD 12.2].
const MAX_CODE_BITS: u32 = 32;
/// Widest Huffman symbol a caller asks for: the arrays hold 2- to 16-bit values.
const MAX_SYMBOL_BITS: u32 = 16;
fn malformed(what: &str) -> PrcError {
PrcError::Malformed(what.to_owned())
}
/// An LSB-first cursor over a Huffman payload.
struct Lsb<'a> {
data: &'a [u8],
pos: usize,
end: usize,
}
impl Lsb<'_> {
fn bit(&mut self) -> Result<u32, PrcError> {
if self.pos >= self.end {
return Err(PrcError::Truncated("a Huffman payload"));
}
let byte = self.data.get(self.pos / 8).ok_or(PrcError::Truncated("a Huffman payload"))?;
let b = u32::from((byte >> (self.pos % 8)) & 1);
self.pos += 1;
Ok(b)
}
/// `n` ≤ 32 bits, the first read being the least significant.
fn bits(&mut self, n: u32) -> Result<u32, PrcError> {
let mut v = 0u32;
for i in 0..n.min(32) {
v |= self.bit()? << i;
}
Ok(v)
}
fn remaining(&self) -> usize {
self.end.saturating_sub(self.pos)
}
}
/// The low `n` (1..=16) bits of `v` as a symbol, two's complement when `signed`.
fn symbol(v: u32, n: u32, signed: bool) -> i32 {
let v = i64::from(v);
let wide = if signed && n > 0 && v & (1 << (n - 1)) != 0 { v - (1i64 << n) } else { v };
// n <= 16, so `wide` is within ±2^16.
i32::try_from(wide).unwrap_or(0)
}
/// The Huffman container of a compressed Character/Short array [WD 11.6, 11.7, 12.2]:
/// symbols are `nbits` wide, sign-extended when `signed`.
fn huffman(r: &mut BitReader<'_>, nbits: u32, signed: bool) -> Result<Vec<i32>, PrcError> {
if nbits == 0 || nbits > MAX_SYMBOL_BITS {
return Err(malformed("Huffman symbol width"));
}
let words = r.unsigned_integer()? as usize;
if words == 0 {
return Ok(Vec::new());
}
if words.saturating_mul(32) > r.remaining() {
return Err(PrcError::Truncated("a Huffman payload"));
}
// words * 32 bits remain, so words * 4 bytes cannot overflow.
let blob = (0..words * 4).map(|_| r.character()).collect::<Result<Vec<u8>, _>>()?;
let last = r.unsigned_integer()?;
if last > 32 {
return Err(malformed("Huffman last-word bit count above 32"));
}
let end = (words - 1) * 32 + last as usize;
let mut b = Lsb { data: &blob, pos: 0, end };
let codes = huffman_leaves(&mut b, nbits, signed)?;
if codes.is_empty() {
return Ok(Vec::new());
}
let count = b.bits(32)? as usize;
// Every element is at least one bit.
if count > b.remaining() {
return Err(PrcError::Truncated("a Huffman element count"));
}
r.take_elements(count)?;
let mut out = Vec::with_capacity(count.min(1024));
for _ in 0..count {
out.push(huffman_symbol(&mut b, &codes)?);
}
Ok(out)
}
/// The leaf table: `(code length, stored code)` to symbol.
fn huffman_leaves(b: &mut Lsb<'_>, nbits: u32, signed: bool) -> Result<HashMap<(u32, u32), i32>, PrcError> {
let leaves = b.bits(nbits + 1)?;
if leaves == 0 {
return Ok(HashMap::new());
}
// prc-rs: the code-length width is read from the payload, not fixed at 8 bits.
let len_width = b.bits(8)?;
if len_width == 0 || len_width > MAX_CODE_BITS {
return Err(malformed("Huffman code-length width"));
}
// Every leaf is at least nbits + 2 bits, so the payload bounds the table.
if (leaves as usize).saturating_mul((nbits + 2) as usize) > b.remaining() {
return Err(PrcError::Truncated("a Huffman payload"));
}
let mut codes = HashMap::new();
for _ in 0..leaves {
let s = symbol(b.bits(nbits)?, nbits, signed);
let len = b.bits(len_width)?;
if len == 0 || len > MAX_CODE_BITS {
return Err(malformed("Huffman code length"));
}
let code = b.bits(len)?;
if codes.insert((len, code), s).is_some() {
return Err(malformed("duplicate Huffman code"));
}
}
// A leaf whose code begins another's would end that code early, leaving its unread bits
// in front of the next element.
let shadowed = codes.keys().any(|&(len, code)| (1..len).any(|l| codes.contains_key(&(l, code >> (len - l)))));
if shadowed {
return Err(malformed("a Huffman code that is a prefix of another"));
}
Ok(codes)
}
/// One element: code bits, most significant first, until a leaf matches.
fn huffman_symbol(b: &mut Lsb<'_>, codes: &HashMap<(u32, u32), i32>) -> Result<i32, PrcError> {
// prc-rs: the stored code's first bit read is its most significant (the root bit).
let (mut code, mut len) = (0u32, 0u32);
while len < MAX_CODE_BITS {
code = (code << 1) | b.bit()?;
len += 1;
if let Some(&s) = codes.get(&(len, code)) {
return Ok(s);
}
}
Err(malformed("a Huffman code matching no leaf"))
}
/// A `CharacterArray(nbits)` [WD 11.6]. `compressed` is `None` when the flag is written,
/// else the caller's implicit value. Uncompressed elements are whole bytes, sign-extended
/// from 8 bits when `signed`.
pub(crate) fn character_array(r: &mut BitReader<'_>, nbits: u32, compressed: Option<bool>, signed: bool) -> Result<Vec<i32>, PrcError> {
let compressed = match compressed {
Some(c) => c,
None => r.bit()?,
};
if compressed {
return huffman(r, nbits, signed);
}
let n = r.unsigned_integer()? as usize;
if n.saturating_mul(8) > r.remaining() {
return Err(PrcError::Truncated("a character array"));
}
r.take_elements(n)?;
(0..n)
.map(|_| {
let c = r.character()?;
Ok(if signed { i32::from(c.cast_signed()) } else { i32::from(c) })
})
.collect()
}
/// A `ShortArray(nbits)` [WD 11.7]: uncompressed elements are a low then a high byte, read
/// unsigned.
pub(crate) fn short_array(r: &mut BitReader<'_>, nbits: u32) -> Result<Vec<i32>, PrcError> {
if r.bit()? {
return huffman(r, nbits, false);
}
let n = r.unsigned_integer()? as usize;
if n.saturating_mul(16) > r.remaining() {
return Err(PrcError::Truncated("a short array"));
}
r.take_elements(n)?;
(0..n)
.map(|_| {
let lo = r.character()?;
let hi = r.character()?;
Ok(i32::from(u16::from_le_bytes([lo, hi])))
})
.collect()
}
/// A `CompressedIntegerArray` [WD 11.8]: a CharacterArray(6) of widths, then one
/// `IntegerWithVariableBitNumber` per width.
pub(crate) fn compressed_integer_array(r: &mut BitReader<'_>) -> Result<Vec<i64>, PrcError> {
let widths = character_array(r, 6, None, false)?;
widths
.into_iter()
.map(|w| {
let w = u32::try_from(w).map_err(|_| malformed("integer width"))?;
r.integer_vbn(w)
})
.collect()
}
/// A `CompressedIndiceArray` [WD 11.9], read as producers write it: the stored signed 6-bit
/// values are width differences summed into each element's width, and each element is a
/// delta from the previous (the WD's own reading desyncs from the third element). Indices
/// are never negative.
pub(crate) fn compressed_indice_array(r: &mut BitReader<'_>, compressed: Option<bool>) -> Result<Vec<u32>, PrcError> {
let diffs = character_array(r, 6, compressed, true)?;
let mut out = Vec::with_capacity(diffs.len());
let (mut width, mut prev) = (0i64, 0i64);
for d in diffs {
// prc-rs: widths are running sums of the stored differences, values running deltas.
width = width.checked_add(i64::from(d)).ok_or_else(|| malformed("indice width"))?;
let w = u32::try_from(width).map_err(|_| malformed("indice width"))?;
let v = prev.checked_add(r.integer_vbn(w)?).ok_or_else(|| malformed("indice delta"))?;
out.push(u32::try_from(v).map_err(|_| malformed("an index outside 0..2^32"))?);
prev = v;
}
Ok(out)
}
/// An `UncompressedBoolArray` of `n` raw bits (no length prefix).
pub(crate) fn bool_array(r: &mut BitReader<'_>, n: usize) -> Result<Vec<bool>, PrcError> {
if n > r.remaining() {
return Err(PrcError::Truncated("a boolean array"));
}
r.take_elements(n)?;
(0..n).map(|_| r.bit()).collect()
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used)]
use super::*;
use crate::testw::W;
fn read<T>(w: &W, f: impl FnOnce(&mut BitReader<'_>) -> Result<T, PrcError>) -> T {
let bytes = w.bytes();
let mut r = BitReader::new(&bytes);
let v = f(&mut r).unwrap();
assert_eq!(r.position(), w.len(), "bits consumed");
v
}
#[test]
fn huffman_decodes_the_wd_example_with_root_bits() {
// WD 12.2's input {1,3,5,7,7,9,5,3,3}; codes carry the root bit.
let leaves = [(3, 0b100, 3), (7, 0b101, 3), (5, 0b110, 3), (1, 0b1110, 4), (9, 0b1111, 4)];
let values = [1, 3, 5, 7, 7, 9, 5, 3, 3];
let mut w = W::default();
w.bit(true).huffman(4, 3, &leaves, &values);
assert_eq!(read(&w, |r| character_array(r, 4, None, false)), values);
}
#[test]
fn huffman_symbols_sign_extend_only_when_signed() {
let leaves = [(0b111110, 0b10, 2), (1, 0b11, 2)];
let mut w = W::default();
w.huffman(6, 2, &leaves, &[62, 1, 62]);
assert_eq!(read(&w, |r| huffman(r, 6, true)), [-2, 1, -2]);
assert_eq!(read(&w, |r| huffman(r, 6, false)), [62, 1, 62]);
}
#[test]
fn huffman_rejects_codes_that_match_no_leaf_and_empty_payloads_are_empty() {
let mut bad = W::default();
bad.huffman_raw(2, 2, &[(1, 0b10, 2)], &[(0b11, 2)]);
let bytes = bad.bytes();
assert!(matches!(huffman(&mut BitReader::new(&bytes), 2, false), Err(PrcError::Malformed(_) | PrcError::Truncated(_))));
let mut empty = W::default();
empty.uint(0);
assert!(read(&empty, |r| huffman(r, 2, false)).is_empty());
}
#[test]
fn a_huffman_element_count_past_the_payload_is_truncated_not_allocated() {
// One leaf, then an element count of 2^32 - 1 with no elements behind it.
let mut w = W::default();
w.huffman_count(2, 2, &[(1, 0b10, 2)], u32::MAX);
let bytes = w.bytes();
assert!(matches!(huffman(&mut BitReader::new(&bytes), 2, false), Err(PrcError::Truncated("a Huffman element count"))));
}
#[test]
fn a_huffman_code_that_begins_another_is_malformed() {
// `10` would end every `100` one bit early.
let mut w = W::default();
w.huffman(2, 2, &[(1, 0b10, 2), (2, 0b100, 3)], &[2, 1]);
let bytes = w.bytes();
let r = huffman(&mut BitReader::new(&bytes), 2, false);
assert!(malformed_by(r, "a Huffman code that is a prefix of another"));
}
#[test]
fn huffman_widths_out_of_range_are_errors() {
// Well-formed payloads at each width, which only the width check refuses.
for nbits in [0, 17] {
let mut w = W::default();
w.huffman(nbits, 2, &[(1, 0b10, 2)], &[1]);
let bytes = w.bytes();
assert!(matches!(huffman(&mut BitReader::new(&bytes), nbits, false), Err(PrcError::Malformed(_))), "{nbits}");
}
}
#[test]
fn uncompressed_arrays() {
let mut w = W::default();
w.bit(false).uint(2).put(0xfe, 8).put(3, 8);
assert_eq!(read(&w, |r| character_array(r, 6, None, true)), [-2, 3]);
let mut s = W::default();
s.bit(false).uint(1).put(0x34, 8).put(0x12, 8);
assert_eq!(read(&s, |r| short_array(r, 16)), [0x1234]);
}
#[test]
fn integer_array_reads_one_width_per_value() {
let mut w = W::default();
w.bit(false).uint(3).put(3, 8).put(0, 8).put(4, 8);
w.bit(true).put(3, 2); // -3 in 3 bits
w.bit(false).put(5, 3); // 5 in 4 bits
assert_eq!(read(&w, compressed_integer_array), [-3, 0, 5]);
}
#[test]
fn indice_array_sums_widths_and_deltas() {
// Values 5, 6, 4: widths 4, 2, 3 stored as diffs 4, -2, +1.
let mut w = W::default();
w.bit(false).uint(3).put(4, 8).put(0xfe, 8).put(1, 8);
w.bit(false).put(5, 3); // 5
w.bit(false).put(1, 1); // +1
w.bit(true).put(2, 2); // -2
assert_eq!(read(&w, |r| compressed_indice_array(r, None)), [5, 6, 4]);
// The implicit-flag form reads no flag bit.
let mut i = W::default();
i.uint(1).put(2, 8).bit(false).put(1, 1);
assert_eq!(read(&i, |r| compressed_indice_array(r, Some(false))), [1]);
// A negative running index is damage.
let mut n = W::default();
n.bit(false).uint(1).put(2, 8).bit(true).put(1, 1);
let bytes = n.bytes();
assert!(compressed_indice_array(&mut BitReader::new(&bytes), None).is_err());
}
#[test]
fn a_bool_array_longer_than_the_data_is_truncated() {
assert!(matches!(bool_array(&mut BitReader::new(&[0]), 9), Err(PrcError::Truncated(_))));
assert_eq!(bool_array(&mut BitReader::new(&[0x80]), 2).unwrap(), [true, false]);
}
#[test]
fn decoded_elements_are_charged_against_one_allowance() {
// One bit can decode to a 4-byte element, so the byte cap alone does not bound memory.
let leaves = [(0b111110, 0b10, 2), (1, 0b11, 2)];
let mut w = W::default();
w.huffman(6, 2, &leaves, &[62, 1, 62]);
let bytes = w.bytes();
let mut r = BitReader::with_elements(&bytes, 2);
assert!(matches!(huffman(&mut r, 6, false), Err(PrcError::TooManyElements { .. })));
let mut r = BitReader::with_elements(&bytes, 4);
assert_eq!(huffman(&mut r, 6, false).unwrap(), [62, 1, 62]);
assert_eq!(r.elements_left(), 1);
assert!(matches!(bool_array(&mut BitReader::with_elements(&[0], 1), 2), Err(PrcError::TooManyElements { .. })));
}
/// Uncompressed character and short arrays are charged against the allowance too, and a
/// character count past the data is refused by name before anything is read.
#[test]
fn uncompressed_arrays_are_charged_and_their_counts_checked() {
let mut w = W::default();
w.uint(3).put(0, 8).put(1, 8).put(2, 8);
let chars = w.bytes();
let read = |n| character_array(&mut BitReader::with_elements(&chars, n), 8, Some(false), false);
assert!(matches!(read(2), Err(PrcError::TooManyElements { .. })));
assert_eq!(read(3).unwrap(), [0, 1, 2]);
let mut w = W::default();
w.bit(false).uint(2).put(1, 8).put(0, 8).put(2, 8).put(0, 8);
let shorts = w.bytes();
assert!(matches!(short_array(&mut BitReader::with_elements(&shorts, 1), 8), Err(PrcError::TooManyElements { .. })));
assert_eq!(short_array(&mut BitReader::with_elements(&shorts, 2), 8).unwrap(), [1, 2]);
let mut w = W::default();
w.uint(1000).put(7, 8);
let short_of_data = w.bytes();
let res = character_array(&mut BitReader::new(&short_of_data), 8, Some(false), false);
assert!(matches!(res, Err(PrcError::Truncated("a character array"))), "{res:?}");
}
fn malformed_by(res: Result<Vec<i32>, PrcError>, what: &str) -> bool {
matches!(res, Err(PrcError::Malformed(m)) if m == what)
}
#[test]
fn a_zero_code_length_width_or_length_is_refused_by_name() {
let mut w = W::default();
w.huffman_raw(2, 0, &[(1, 0, 0)], &[]);
let bytes = w.bytes();
assert!(malformed_by(huffman(&mut BitReader::new(&bytes), 2, false), "Huffman code-length width"));
let mut w = W::default();
w.huffman_raw(2, 2, &[(1, 0, 0)], &[]);
let bytes = w.bytes();
assert!(malformed_by(huffman(&mut BitReader::new(&bytes), 2, false), "Huffman code length"));
}
#[test]
fn a_boolean_array_past_the_data_is_refused_before_it_is_read() {
let mut w = W::default();
w.put(0b1011, 4);
let bytes = w.bytes();
let mut r = BitReader::new(&bytes);
let n = r.remaining() + 1;
assert_eq!(bool_array(&mut r, n), Err(PrcError::Truncated("a boolean array")));
assert_eq!(r.position(), 0, "nothing read");
}
}
crates/prc/src/bits.rs
+491
View File
@@ -0,0 +1,491 @@
//! The bit-level reader for PRC compressed sections [WD 10.3, 11.1-11.17].
//!
//! Values are consumed MSB-first from each inflated byte and straddle byte boundaries freely
//! [WD 10.3.1, 11.3]. Multi-byte integers are groups of eight bits, low group first. Two sign
//! conventions coexist: `Integer` is two's complement, the `*WithVariableBitNumber` types are
//! sign-magnitude.
use crate::PrcError;
use crate::acof::{self, Entry};
/// The most array elements the readers of one PRC stream decode together (2^24): at most 8
/// bytes each, so 128 MiB.
pub const MAX_DECODED_ELEMENTS: usize = 1 << 24;
/// The most schema-program steps (tokens executed, loop iterations included) the readers of
/// one PRC stream run together.
pub const MAX_SCHEMA_STEPS: u64 = 1 << 22;
/// What the readers of one stream may still spend, carried from each reader to the next.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct Budget {
/// Array elements still to decode.
pub(crate) elements: usize,
/// Schema-program steps still to run.
pub(crate) steps: u64,
}
impl Budget {
/// A whole stream's allowance.
pub(crate) const FULL: Self = Self { elements: MAX_DECODED_ELEMENTS, steps: MAX_SCHEMA_STEPS };
}
/// A cursor over one inflated section.
#[derive(Debug, Clone)]
pub struct BitReader<'a> {
data: &'a [u8],
pos: usize,
budget: Budget,
}
impl<'a> BitReader<'a> {
/// A reader positioned at the first bit of `data`, allowed [`MAX_DECODED_ELEMENTS`] and
/// [`MAX_SCHEMA_STEPS`].
pub fn new(data: &'a [u8]) -> Self {
Self::with_budget(data, Budget::FULL)
}
/// A reader of `data` allowed `budget`: what an earlier reader of the same stream left.
pub(crate) fn with_budget(data: &'a [u8], budget: Budget) -> Self {
Self { data, pos: 0, budget }
}
/// A reader of `data` allowed `elements` array elements and a full step allowance.
#[cfg(test)]
pub(crate) fn with_elements(data: &'a [u8], elements: usize) -> Self {
Self::with_budget(data, Budget { elements, ..Budget::FULL })
}
/// This reader, at its position, allowed `budget` instead: what readers of the same
/// stream left since it stopped.
pub(crate) fn with_remaining(mut self, budget: Budget) -> Self {
self.budget = budget;
self
}
/// What this reader may still spend.
pub(crate) fn budget(&self) -> Budget {
self.budget
}
/// Array elements this reader may still decode.
#[cfg(test)]
pub(crate) fn elements_left(&self) -> usize {
self.budget.elements
}
/// Charge `n` decoded array elements against the allowance.
///
/// # Errors
/// [`PrcError::TooManyElements`] when fewer than `n` are left.
pub(crate) fn take_elements(&mut self, n: usize) -> Result<(), PrcError> {
self.budget.elements = self.budget.elements.checked_sub(n).ok_or(PrcError::TooManyElements { limit: MAX_DECODED_ELEMENTS })?;
Ok(())
}
/// Charge one schema-program step; false when none is left.
pub(crate) fn take_step(&mut self) -> bool {
match self.budget.steps.checked_sub(1) {
Some(left) => {
self.budget.steps = left;
true
}
None => false,
}
}
/// Bits consumed so far.
pub fn position(&self) -> usize {
self.pos
}
/// Bits left before the end of the data.
pub fn remaining(&self) -> usize {
self.data.len().saturating_mul(8).saturating_sub(self.pos)
}
/// Step over `n` bits of opaque data (`UserData` [WD 8.6]).
///
/// # Errors
/// [`PrcError::Truncated`] when fewer than `n` bits remain; the cursor does not move.
pub fn skip_bits(&mut self, n: usize) -> Result<(), PrcError> {
if n > self.remaining() {
return Err(PrcError::Truncated("user data"));
}
self.pos = self.pos.saturating_add(n);
Ok(())
}
/// One bit; a PRC `Boolean` [WD 10.3.3].
///
/// # Errors
/// [`PrcError::Truncated`] at the end of the data.
pub fn bit(&mut self) -> Result<bool, PrcError> {
let byte = self.data.get(self.pos / 8).ok_or(PrcError::Truncated("a bit"))?;
let b = (byte >> (7 - (self.pos % 8))) & 1 == 1;
// `pos / 8` indexed the data, so `pos + 1` is at most `8 * len`.
self.pos = self.pos.saturating_add(1);
Ok(b)
}
/// `n` bits (at most 32), MSB-first; `UnsignedIntegerWithVariableBitNumber` [WD 11.13].
///
/// # Errors
/// [`PrcError::Truncated`] at the end of the data; [`PrcError::Malformed`] for `n > 32`.
pub fn bits(&mut self, n: u32) -> Result<u32, PrcError> {
if n > 32 {
return Err(PrcError::Malformed(format!("{n}-bit field")));
}
if self.remaining() < n as usize {
return Err(PrcError::Truncated("a bit field"));
}
let mut v: u64 = 0;
for _ in 0..n {
v = (v << 1) | u64::from(self.bit()?);
}
// n <= 32, so v fits.
Ok(u32::try_from(v).unwrap_or(u32::MAX))
}
fn byte(&mut self) -> Result<u8, PrcError> {
Ok(u8::try_from(self.bits(8)?).unwrap_or(u8::MAX))
}
/// A `Character`: one byte [WD 10.3.4].
///
/// # Errors
/// [`PrcError::Truncated`].
pub fn character(&mut self) -> Result<u8, PrcError> {
self.byte()
}
/// An `UnsignedInteger` [WD 11.10]: while a 1 bit precedes it, one more eight-bit group,
/// low group first.
///
/// # Errors
/// [`PrcError::Truncated`]; [`PrcError::Malformed`] past four groups.
pub fn unsigned_integer(&mut self) -> Result<u32, PrcError> {
let mut v: u32 = 0;
let mut shift = 0;
while self.bit()? {
if shift >= 32 {
return Err(PrcError::Malformed("UnsignedInteger over 32 bits".into()));
}
v |= u32::from(self.byte()?) << shift;
shift += 8;
}
Ok(v)
}
/// An `Integer` [WD 11.11]: a 0 bit is zero; otherwise eight-bit groups, low group first,
/// each followed by a continue bit, sign-extended from the last group's top bit.
///
/// # Errors
/// [`PrcError::Truncated`]; [`PrcError::Malformed`] past four groups.
pub fn integer(&mut self) -> Result<i32, PrcError> {
if !self.bit()? {
return Ok(0);
}
let mut v: u32 = 0;
let mut shift = 0;
loop {
if shift >= 32 {
return Err(PrcError::Malformed("Integer over 32 bits".into()));
}
let group = self.byte()?;
v |= u32::from(group) << shift;
shift += 8;
if !self.bit()? {
if group & 0x80 != 0 && shift < 32 {
v |= u32::MAX << shift;
}
return Ok(v.cast_signed());
}
}
}
/// An `IntegerWithVariableBitNumber(n)` [WD 11.12]: a negative flag (1 = negative; the WD
/// prose says the opposite, its sample code and real files agree on this), then the
/// magnitude in `n - 1` bits.
///
/// # Errors
/// [`PrcError::Truncated`]; [`PrcError::Malformed`] for `n > 33`.
pub fn integer_vbn(&mut self, n: u32) -> Result<i64, PrcError> {
let Some(magnitude_bits) = n.checked_sub(1) else {
return Ok(0);
};
let negative = self.bit()?;
let m = i64::from(self.bits(magnitude_bits)?);
Ok(if negative { -m } else { m })
}
/// A `DoubleWithVariableBitNumber(tolerance, n)` [WD 11.14]: a sign-magnitude quantum
/// count times `tolerance`.
///
/// # Errors
/// As [`Self::integer_vbn`].
pub fn double_vbn(&mut self, tolerance: f64, n: u32) -> Result<f64, PrcError> {
Ok(self.integer_vbn(n)? as f64 * tolerance)
}
/// `NumberOfBitsThenUnsignedInteger` [WD 11.15]: a 5-bit width, then the value in that
/// many bits.
///
/// # Errors
/// [`PrcError::Truncated`].
pub fn nbits_then_unsigned(&mut self) -> Result<u32, PrcError> {
let n = self.bits(5)?;
self.bits(n)
}
/// A `String` [WD 10.3.7, 11.4]: `None` for the null string, else UTF-8 (invalid
/// sequences replaced).
///
/// # Errors
/// [`PrcError::Truncated`] when the byte count runs past the data.
pub fn string(&mut self) -> Result<Option<String>, PrcError> {
if !self.bit()? {
return Ok(None);
}
let len = self.unsigned_integer()? as usize;
if len.saturating_mul(8) > self.remaining() {
return Err(PrcError::Truncated("a String"));
}
let bytes = (0..len).map(|_| self.byte()).collect::<Result<Vec<u8>, _>>()?;
Ok(Some(String::from_utf8_lossy(&bytes).into_owned()))
}
/// `FloatAsBytes` [WD 11.5]: an IEEE binary32, least-significant byte first.
///
/// # Errors
/// [`PrcError::Truncated`].
pub fn float_as_bytes(&mut self) -> Result<f32, PrcError> {
let b = [self.byte()?, self.byte()?, self.byte()?, self.byte()?];
Ok(f32::from_le_bytes(b))
}
/// A `Double` [WD 11.17]: a prefix code from the Double table, then a sign bit and, for
/// an exponent code, a byte-wise mantissa with back-references.
///
/// The two-bit zero code has no sign bit. Back-reference offsets 1 to 5 are all accepted,
/// distance 1 included (PDF Association pdf-issues #769).
///
/// # Errors
/// [`PrcError::UnknownDoubleCode`], [`PrcError::Truncated`], or [`PrcError::Malformed`]
/// for a back-reference outside the value.
pub fn double(&mut self) -> Result<f64, PrcError> {
// prc-rs: the decoding steps (code lookup, sign, exponent, byte-wise mantissa with
// back-references) follow prc-rs's.
let mut code = 0u32;
let mut entry = None;
for n in 1..=acof::MAX_CODE_BITS {
code = (code << 1) | u32::from(self.bit()?);
if let Some(e) = acof::lookup(n, code) {
if n == 2 && code == 0b01 {
return Ok(0.0);
}
entry = Some(e);
break;
}
}
let entry = entry.ok_or(PrcError::UnknownDoubleCode)?;
let negative = self.bit()?;
let upper = match entry {
Entry::Double(v) => return Ok(if negative { -v } else { v }),
Entry::Exponent(upper) => upper,
};
let mut b = (u64::from(upper) << 32).to_le_bytes();
if self.bit()? {
self.mantissa(&mut b)?;
}
let sign = if negative { 1u64 << 63 } else { 0 };
Ok(f64::from_bits(u64::from_le_bytes(b) | sign))
}
/// Mantissa bits 51..0 into `b` (little-endian byte order): a nibble, then bytes 5 down
/// to 0, each a literal or a back-reference to a byte already set.
fn mantissa(&mut self, b: &mut [u8; 8]) -> Result<(), PrcError> {
let nibble = u8::try_from(self.bits(4)?).unwrap_or(0);
let [.., b6, _] = b;
*b6 |= nibble;
let at = |b: &[u8; 8], i: usize| b.get(i).copied().ok_or_else(|| PrcError::Malformed("Double back-reference past the value".into()));
for cbi in (0..=5usize).rev() {
let prev = at(b, cbi + 1)?;
let value = if self.bit()? {
self.byte()?
} else {
match self.bits(3)? {
// Fill this byte and every lower one with the previous byte.
0 => {
b.iter_mut().take(cbi + 1).for_each(|x| *x = prev);
return Ok(());
}
// As 0, but the lowest byte is a literal.
6 => {
b.iter_mut().take(cbi + 1).skip(1).for_each(|x| *x = prev);
let low = self.byte()?;
let [b0, ..] = b;
*b0 = low;
return Ok(());
}
off @ 1..=5 => at(b, cbi + off as usize)?,
_ => return Err(PrcError::Malformed("Double mantissa offset 7".into())),
}
};
if let Some(x) = b.get_mut(cbi) {
*x = value;
}
}
Ok(())
}
}
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used)]
mod tests {
use super::*;
use crate::testw::W;
/// The code for IEEE exponent `e`.
fn exponent_code(e: u32) -> (u32, u32) {
acof::exponent_code(e).expect("the table has a row per exponent")
}
fn read_double(w: &W) -> f64 {
BitReader::new(&w.bytes()).double().unwrap()
}
#[test]
fn zero_is_the_two_bit_code_with_no_sign() {
let mut w = W::default();
w.put(0b01, 2).put(0b1111_1111, 8);
let bytes = w.bytes();
let mut r = BitReader::new(&bytes);
assert_eq!(r.double().unwrap(), 0.0);
assert_eq!(r.position(), 2);
}
#[test]
fn exponent_with_literal_mantissa() {
let v = -1234.5678f64;
let le = v.to_bits().to_le_bytes();
let e = u32::try_from((v.to_bits() >> 52) & 0x7ff).unwrap();
let (n, c) = exponent_code(e);
let mut w = W::default();
w.put(u64::from(c), n).put(1, 1).put(1, 1).put(u64::from(le[6] & 0x0f), 4);
for byte in le[..6].iter().rev() {
w.put(1, 1).put(u64::from(*byte), 8);
}
assert_eq!(read_double(&w), v);
}
#[test]
fn exponent_without_mantissa_is_a_power_of_two() {
let (n, c) = exponent_code(1023 + 3);
let mut w = W::default();
w.put(u64::from(c), n).put(0, 1).put(0, 1);
assert_eq!(read_double(&w), 8.0);
}
#[test]
fn fill_back_reference_and_literal_low_byte() {
// Mantissa bytes 6..0 = 0x05, 0xAA, 0xAA (offset 1), 0xAA (offset 2), fill 0xAA to byte 1, byte 0 = 0x11.
let (n, c) = exponent_code(1023);
let mut w = W::default();
w.put(u64::from(c), n).put(0, 1).put(1, 1).put(0x5, 4);
w.put(1, 1).put(0xAA, 8);
w.put(0, 1).put(1, 3);
w.put(0, 1).put(2, 3);
w.put(0, 1).put(6, 3).put(0x11, 8);
assert_eq!(read_double(&w), f64::from_le_bytes([0x11, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xF5, 0x3F]));
// Byte 5 literal, then fill 4..0.
let mut w = W::default();
w.put(u64::from(c), n).put(0, 1).put(1, 1).put(0x5, 4);
w.put(1, 1).put(0x77, 8).put(0, 1).put(0, 3);
assert_eq!(read_double(&w), f64::from_le_bytes([0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0xF5, 0x3F]));
}
#[test]
fn a_back_reference_past_the_value_is_refused() {
let (n, c) = exponent_code(1023);
let mut w = W::default();
w.put(u64::from(c), n).put(0, 1).put(1, 1).put(0, 4);
w.put(0, 1).put(5, 3).put(0, 16); // byte 5 + offset 5 = byte 10
assert!(matches!(BitReader::new(&w.bytes()).double(), Err(PrcError::Malformed(_))));
}
#[test]
fn a_truncated_double_is_an_error_not_a_panic() {
// No code is 8 bits or shorter and a prefix of 0x17, so one byte ends inside a code.
assert!(matches!(BitReader::new(&[0x17]).double(), Err(PrcError::Truncated(_))));
assert!(matches!(BitReader::new(&[]).double(), Err(PrcError::Truncated(_))));
}
#[test]
fn integers_and_strings() {
let mut w = W::default();
// UnsignedInteger 300 = groups 0x2C, 0x01.
w.put(1, 1).put(0x2C, 8).put(1, 1).put(0x01, 8).put(0, 1);
// Integer -2 = group 0xFE, stop.
w.put(1, 1).put(0xFE, 8).put(0, 1);
// Integer 200 = 0xC8 then 0x00 (top bit clear), stop.
w.put(1, 1).put(0xC8, 8).put(1, 1).put(0x00, 8).put(0, 1);
// IntegerWithVariableBitNumber(4) = -5.
w.put(1, 1).put(5, 3);
// String "hé".
w.put(1, 1).put(1, 1).put(3, 8).put(0, 1).put(0x68, 8).put(0xC3, 8).put(0xA9, 8);
// Null string.
w.put(0, 1);
let bytes = w.bytes();
let mut r = BitReader::new(&bytes);
assert_eq!(r.unsigned_integer().unwrap(), 300);
assert_eq!(r.integer().unwrap(), -2);
assert_eq!(r.integer().unwrap(), 200);
assert_eq!(r.integer_vbn(4).unwrap(), -5);
assert_eq!(r.string().unwrap().as_deref(), Some("hé"));
assert_eq!(r.string().unwrap(), None);
}
#[test]
fn the_writer_round_trips_through_the_reader() {
let mut w = W::default();
w.uint(0).uint(u32::MAX).int(-129).int(i32::MIN).int(i32::MAX).string(Some("glass")).string(None);
let bytes = w.bytes();
let mut r = BitReader::new(&bytes);
assert_eq!(r.unsigned_integer().unwrap(), 0);
assert_eq!(r.unsigned_integer().unwrap(), u32::MAX);
assert_eq!(r.integer().unwrap(), -129);
assert_eq!(r.integer().unwrap(), i32::MIN);
assert_eq!(r.integer().unwrap(), i32::MAX);
assert_eq!(r.string().unwrap().as_deref(), Some("glass"));
assert_eq!(r.string().unwrap(), None);
}
#[test]
fn oversized_groups_and_widths_are_malformed() {
// Five UnsignedInteger groups.
let mut w = W::default();
(0..5).for_each(|_| {
w.put(1, 1).put(0xFF, 8);
});
w.put(0, 1);
assert!(matches!(BitReader::new(&w.bytes()).unsigned_integer(), Err(PrcError::Malformed(_))));
assert!(matches!(BitReader::new(&[0; 8]).bits(33), Err(PrcError::Malformed(_))));
assert!(matches!(BitReader::new(&[0; 8]).integer_vbn(34), Err(PrcError::Malformed(_))));
assert_eq!(BitReader::new(&[]).integer_vbn(0), Ok(0));
}
#[test]
fn truncation_is_an_error_not_a_panic() {
let mut r = BitReader::new(&[0xFF]);
assert!(r.unsigned_integer().is_err());
let mut r = BitReader::new(&[0xC0, 0x40]);
assert!(matches!(r.string(), Err(PrcError::Truncated(_))));
let mut r = BitReader::new(&[0xAB]);
assert!(matches!(r.skip_bits(9), Err(PrcError::Truncated(_))));
assert_eq!(r.position(), 0, "a refused skip does not move the cursor");
r.skip_bits(8).unwrap();
assert_eq!(r.remaining(), 0);
}
}
crates/prc/src/container.rs
+340
View File
@@ -0,0 +1,340 @@
//! The PRC container: file header, file-structure descriptions, section extents and
//! inflation [WD 6.1-6.2, 10.2].
//!
//! Section extents are not stored: each section runs to the next one's start offset, and the
//! last one to the model file's start. Inflation stops at the zlib stream's end, so padding
//! between sections is tolerated.
use std::io::Read;
use crate::PrcError;
use crate::bits::BitReader;
use crate::schema::Schema;
/// The PRC version this reader implements.
pub const PRC_READER_VERSION: u32 = 8137;
/// The most file structures [`PrcFile::parse`] accepts.
pub const MAX_FILE_STRUCTURES: usize = 65_536;
/// Ceiling on the total inflated size of every section in one PRC stream, together with the
/// picture and uncompressed blocks it copies.
pub const MAX_INFLATED_BYTES: usize = 512 * 1024 * 1024;
/// Sections per file structure [WD 6.1.2]: its header, then the five in [`SectionKind`]
/// order.
const SECTIONS: usize = 6;
/// A 128-bit PRC identifier [WD 10.2.4]: four little-endian `u32`s.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub struct UniqueId(pub [u32; 4]);
/// The compressed sections of one file structure, in file order [WD 6.1.2, 6.2.1].
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum SectionKind {
/// Starts with the file structure's schema, then its globals entity.
Globals,
/// The product-structure tree.
Tree,
/// Tessellated (mesh) data.
Tessellation,
/// Exact (B-rep) geometry.
Geometry,
/// Supplementary geometry.
ExtraGeometry,
}
impl SectionKind {
/// Every kind, in file order.
pub const ALL: [SectionKind; 5] =
[SectionKind::Globals, SectionKind::Tree, SectionKind::Tessellation, SectionKind::Geometry, SectionKind::ExtraGeometry];
/// The section's name, as used in errors.
pub fn name(self) -> &'static str {
match self {
SectionKind::Globals => "globals",
SectionKind::Tree => "tree",
SectionKind::Tessellation => "tessellation",
SectionKind::Geometry => "geometry",
SectionKind::ExtraGeometry => "extra geometry",
}
}
fn index(self) -> usize {
match self {
SectionKind::Globals => 0,
SectionKind::Tree => 1,
SectionKind::Tessellation => 2,
SectionKind::Geometry => 3,
SectionKind::ExtraGeometry => 4,
}
}
}
/// The uncompressed file header [WD 6.1.1].
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct PrcHeader {
/// The oldest reader version the producer says can read the file.
pub min_version_for_read: u32,
/// The producer's PRC version.
pub authoring_version: u32,
/// The file's identifier.
pub file_id: UniqueId,
/// The producing application's identifier (all zero = unregistered).
pub application_id: UniqueId,
}
/// One file structure: its uncompressed header fields and its five inflated sections
/// [WD 6.2].
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct FileStructure {
/// The identifier; equals the file header's description of it.
pub id: UniqueId,
/// Per-structure reader version floor; may differ from the file's.
pub min_version_for_read: u32,
/// Per-structure producer version.
pub authoring_version: u32,
/// Picture payloads (JPEG, PNG, ...) carried uncompressed in the header, referenced by
/// index from picture entities [WD 6.2.2].
pub pictures: Vec<Vec<u8>>,
sections: [Vec<u8>; 5],
}
impl FileStructure {
/// The inflated bytes of one section.
pub fn section(&self, kind: SectionKind) -> &[u8] {
self.sections.get(kind.index()).map_or(&[], Vec::as_slice)
}
/// The globals section's leading schema: the fields producers newer than this reader
/// added to each entity type [WD 6.3].
///
/// # Errors
/// As [`Schema::read`].
pub fn schema(&self) -> Result<Schema, PrcError> {
Schema::read(&mut BitReader::new(self.section(SectionKind::Globals)))
}
}
/// A parsed PRC stream: header, file structures and model-file section.
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct PrcFile {
/// The file header.
pub header: PrcHeader,
/// File structures in physical order (referenced before referencing).
pub file_structures: Vec<FileStructure>,
/// The inflated model-file section: its schema, then the model file entity.
pub model_file: Vec<u8>,
/// The `UncompressedFiles` blocks after the file header [WD 6.1.1], which picture
/// entities may also reference.
pub uncompressed_files: Vec<Vec<u8>>,
}
/// A little-endian byte cursor over the uncompressed parts of the stream.
struct Bytes<'a> {
data: &'a [u8],
pos: usize,
}
impl<'a> Bytes<'a> {
fn take(&mut self, n: usize, what: &'static str) -> Result<&'a [u8], PrcError> {
let end = self.pos.checked_add(n).ok_or(PrcError::Truncated(what))?;
let s = self.data.get(self.pos..end).ok_or(PrcError::Truncated(what))?;
self.pos = end;
Ok(s)
}
fn u32(&mut self, what: &'static str) -> Result<u32, PrcError> {
let s = self.take(4, what)?;
let b: [u8; 4] = s.try_into().map_err(|_| PrcError::Truncated(what))?;
Ok(u32::from_le_bytes(b))
}
fn id(&mut self, what: &'static str) -> Result<UniqueId, PrcError> {
Ok(UniqueId([self.u32(what)?, self.u32(what)?, self.u32(what)?, self.u32(what)?]))
}
fn magic(&mut self) -> Result<(), PrcError> {
match self.take(3, "magic") {
Ok(b"PRC") => Ok(()),
_ => Err(PrcError::NotPrc),
}
}
/// `UncompressedBlock`s: a count, then size-prefixed blocks [WD 10.2.2-3], each charged to
/// `budget` before it is copied.
fn blocks(&mut self, what: &'static str, budget: &mut Budget) -> Result<Vec<Vec<u8>>, PrcError> {
let n = offset(self.u32(what)?);
// Each block needs at least its 4-byte size, so `n` is bounded by the data left.
if n > self.data.len().saturating_sub(self.pos) / 4 {
return Err(PrcError::Truncated(what));
}
(0..n)
.map(|_| {
let len = offset(self.u32(what)?);
let block = self.take(len, what)?;
budget.charge(block.len())?;
Ok(block.to_vec())
})
.collect()
}
}
/// A stored `u32` offset or count as a `usize` (saturating on a 16-bit target, where no data
/// that large could exist).
pub(crate) fn offset(v: u32) -> usize {
usize::try_from(v).unwrap_or(usize::MAX)
}
/// One file structure description of the file header [WD 6.2]: its id and the offsets of
/// its sections.
fn file_structure_description(r: &mut Bytes) -> Result<(UniqueId, Vec<usize>), PrcError> {
let id = r.id("file structure description")?;
if r.u32("file structure description")? != 0 {
return Err(PrcError::Malformed("file structure reserved field is not 0".into()));
}
let count = offset(r.u32("file structure description")?);
if count < SECTIONS {
return Err(PrcError::Malformed(format!("{count} sections in a file structure")));
}
let mut offs = Vec::with_capacity(SECTIONS);
// Offsets past the six this reader uses are read and dropped; each read is bounded by
// the data, so a huge `count` ends in `Truncated`.
for i in 0..count {
let o = r.u32("section offset")?;
if i < SECTIONS {
offs.push(offset(o));
}
}
Ok((id, offs))
}
/// Where one file structure's parts lie: its section offsets and the end of its last section.
struct Extent<'a> {
offs: &'a [usize],
last: usize,
}
impl Extent<'_> {
fn bound(&self, i: usize) -> usize {
self.offs.get(i).copied().unwrap_or(self.last)
}
}
/// The file structure `id` lying at `extent`: its header and its inflated sections, charged
/// to `budget`.
fn file_structure(data: &[u8], id: UniqueId, extent: &Extent, budget: &mut Budget) -> Result<FileStructure, PrcError> {
if extent.offs.windows(2).any(|w| w.first() > w.get(1)) || extent.bound(SECTIONS - 1) > extent.last {
return Err(PrcError::Malformed("file structure section offsets are not ascending".into()));
}
let header = data.get(..extent.bound(1)).ok_or(PrcError::Truncated("file structure header"))?;
let mut h = Bytes { data: header, pos: extent.bound(0) };
h.magic()?;
let min_version_for_read = h.u32("file structure header")?;
let authoring_version = h.u32("file structure header")?;
if h.id("file structure header")? != id {
return Err(PrcError::Malformed("file structure id differs from its description".into()));
}
let _application = h.id("file structure header")?;
// Headers may overlap, so each structure's copy of its pictures is charged.
let pictures = h.blocks("file structure pictures", budget)?;
let mut sections: [Vec<u8>; 5] = Default::default();
for (i, (slot, kind)) in sections.iter_mut().zip(SectionKind::ALL).enumerate() {
let end = if i + 2 < SECTIONS { extent.bound(i + 2) } else { extent.last };
*slot = budget.inflate(data, (extent.bound(i + 1), end), kind.name())?;
}
Ok(FileStructure { id, min_version_for_read, authoring_version, pictures, sections })
}
/// What is left of the inflation ceiling, and the ceiling itself for the error.
struct Budget {
left: usize,
limit: usize,
}
impl Budget {
/// The zlib stream in `data[range]`, its size charged to the budget.
fn inflate(&mut self, data: &[u8], range: (usize, usize), section: &'static str) -> Result<Vec<u8>, PrcError> {
let (start, end) = range;
if start == end {
return Ok(Vec::new());
}
let src = data.get(start..end).ok_or_else(|| PrcError::Malformed(format!("{section} section {start}..{end} is outside the data")))?;
let mut out = Vec::new();
// One byte past the budget is enough to know it was exceeded.
let cap = u64::try_from(self.left).unwrap_or(u64::MAX).saturating_add(1);
flate2::read::ZlibDecoder::new(src).take(cap).read_to_end(&mut out).map_err(|e| PrcError::Inflate { section, reason: e.to_string() })?;
self.charge(out.len())?;
Ok(out)
}
/// Spend `n` bytes of the ceiling.
fn charge(&mut self, n: usize) -> Result<(), PrcError> {
self.left = self.left.checked_sub(n).ok_or(PrcError::TooLarge { limit: self.limit })?;
Ok(())
}
}
impl PrcFile {
/// Parse a PRC stream (the decoded data of a `/3D` stream with `/Subtype /PRC`).
///
/// Newer `min_version_for_read` values are not refused: the fields read here are
/// unchanged across published versions, and the caller sees the versions in
/// [`PrcHeader`].
///
/// # Errors
/// [`PrcError::NotPrc`] without the magic; [`PrcError::Truncated`] or
/// [`PrcError::Malformed`] for a damaged header or offset table; [`PrcError::Inflate`]
/// for a section that is not zlib; [`PrcError::TooLarge`] past [`MAX_INFLATED_BYTES`]
/// in total, inflated sections and copied blocks together.
///
/// # Examples
/// ```
/// use pdfcraft_prc::{PrcError, PrcFile};
/// assert_eq!(PrcFile::parse(b"%PDF"), Err(PrcError::NotPrc));
/// ```
pub fn parse(data: &[u8]) -> Result<Self, PrcError> {
Self::parse_with_limit(data, MAX_INFLATED_BYTES)
}
/// [`Self::parse`] with a caller-chosen ceiling on the total inflated size, for callers
/// with less memory to spend than [`MAX_INFLATED_BYTES`].
///
/// # Errors
/// As [`Self::parse`]; [`PrcError::TooLarge`] carries `limit`.
pub fn parse_with_limit(data: &[u8], limit: usize) -> Result<Self, PrcError> {
let mut r = Bytes { data, pos: 0 };
r.magic()?;
let header = PrcHeader {
min_version_for_read: r.u32("file header")?,
authoring_version: r.u32("file header")?,
file_id: r.id("file header")?,
application_id: r.id("file header")?,
};
let n_fs = offset(r.u32("file structure count")?);
if n_fs == 0 || n_fs > MAX_FILE_STRUCTURES {
return Err(PrcError::Malformed(format!("{n_fs} file structures")));
}
let descriptions = (0..n_fs).map(|_| file_structure_description(&mut r)).collect::<Result<Vec<_>, _>>()?;
let mf_start = offset(r.u32("model file offsets")?);
let mf_end = offset(r.u32("model file offsets")?);
let mut budget = Budget { left: limit, limit };
let uncompressed_files = r.blocks("uncompressed files", &mut budget)?;
if mf_end < mf_start {
return Err(PrcError::Malformed("model file ends before it starts".into()));
}
if mf_end > data.len() {
return Err(PrcError::Malformed(format!("model file ends at {mf_end}, past the {}-byte stream", data.len())));
}
// prc-rs: the last section runs to the model file's start.
let last = mf_start.min(data.len());
let file_structures =
descriptions.iter().map(|(id, offs)| file_structure(data, *id, &Extent { offs, last }, &mut budget)).collect::<Result<Vec<_>, _>>()?;
let model_file = budget.inflate(data, (mf_start, mf_end), "model file")?;
Ok(PrcFile { header, file_structures, model_file, uncompressed_files })
}
}
crates/prc/src/entity.rs
+127
View File
@@ -0,0 +1,127 @@
//! What every section reader shares: the cursor, the schema, the authoring version, and the
//! base fields every PRC entity starts with [WD 7.2.3, 7.4.3, 8.6].
use crate::PrcError;
use crate::bits::BitReader;
use crate::schema::Schema;
use crate::tree::Graphics;
const ATTRIBUTE: u32 = 201;
/// A [`PrcError::Malformed`] naming `what`.
pub(crate) fn malformed(what: String) -> PrcError {
PrcError::Malformed(what)
}
/// A section reader.
pub(crate) struct Ctx<'a, 's> {
pub(crate) r: BitReader<'a>,
pub(crate) schema: &'s Schema,
/// The file structure's authoring version; gates version-added fields.
pub(crate) version: u32,
/// The current name: what a `same_name` entity reuses; every entity's own name replaces
/// it [WD 7.2.3.4]. Each section starts with none.
pub(crate) name: Option<String>,
/// The PRC unique id of the last `ContentPRCRefBase` read [WD 7.2.3.2].
pub(crate) uid: u32,
/// The current graphics: what a `same_graphics` entity reuses [WD 7.2.4].
pub(crate) graphics: Graphics,
}
impl<'a, 's> Ctx<'a, 's> {
pub(crate) fn new(r: BitReader<'a>, schema: &'s Schema, version: u32) -> Self {
Ctx { r, schema, version, name: None, uid: 0, graphics: Graphics::default() }
}
/// Reads an entity type code; any value but `want` is malformed.
pub(crate) fn expect_type(&mut self, want: u32) -> Result<(), PrcError> {
let t = self.r.unsigned_integer()?;
if t != want {
return Err(malformed(format!("entity type {t} where {want} belongs")));
}
Ok(())
}
/// A count that must fit in the remaining data at `min_bits` per item, which bounds any
/// allocation sized by it.
pub(crate) fn count(&mut self, min_bits: usize, what: &'static str) -> Result<usize, PrcError> {
let n = self.r.unsigned_integer()? as usize;
if n.saturating_mul(min_bits) > self.r.remaining() {
return Err(PrcError::Truncated(what));
}
self.r.take_elements(n)?;
Ok(n)
}
/// A counted array of `UnsignedInteger`s.
pub(crate) fn uints(&mut self, what: &'static str) -> Result<Vec<u32>, PrcError> {
let n = self.count(1, what)?;
(0..n).map(|_| self.r.unsigned_integer()).collect()
}
/// A counted array of `Double`s.
pub(crate) fn doubles(&mut self, what: &'static str) -> Result<Vec<f64>, PrcError> {
let n = self.count(2, what)?;
(0..n).map(|_| self.r.double()).collect()
}
/// `AttributeEntry` [WD 7.4.3]: a predefined title code or a string.
fn attribute_entry(&mut self) -> Result<(), PrcError> {
if self.r.bit()? {
self.r.unsigned_integer()?;
} else {
self.r.string()?;
}
Ok(())
}
/// One attribute value [WD 7.4.3], read past.
fn attribute_value(&mut self) -> Result<(), PrcError> {
match self.r.unsigned_integer()? {
0 => {}
1 | 3 => {
self.r.integer()?;
}
2 => {
self.r.double()?;
}
4 => {
self.r.string()?;
}
// prc-rs: a 64-bit integer is its high part, then its low part.
5 => {
self.r.integer()?;
self.r.unsigned_integer()?;
}
k => return Err(malformed(format!("attribute value kind {k}"))),
}
Ok(())
}
/// `ContentPRCBase` [WD 7.2.3]: attributes, then the name; returns the entity's name,
/// which is also the current name afterwards.
pub(crate) fn content_prc_base(&mut self) -> Result<Option<String>, PrcError> {
let n = self.count(1, "attributes")?;
for _ in 0..n {
self.expect_type(ATTRIBUTE)?;
self.attribute_entry()?;
let pairs = self.count(2, "attribute pairs")?;
for _ in 0..pairs {
self.attribute_entry()?;
self.attribute_value()?;
}
self.schema.skip_added_fields(ATTRIBUTE, &mut self.r)?;
}
// `same_name` TRUE reuses the current name [WD 7.2.3.4].
if !self.r.bit()? {
self.name = self.r.string()?;
}
Ok(self.name.clone())
}
/// `UserData` [WD 8.6]: a bit count, then that many opaque bits.
pub(crate) fn user_data(&mut self) -> Result<(), PrcError> {
let n = self.r.unsigned_integer()? as usize;
self.r.skip_bits(n)
}
}
crates/prc/src/error.rs
+46
View File
@@ -0,0 +1,46 @@
//! The crate's error type.
/// Why a PRC stream could not be read.
#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
#[non_exhaustive]
pub enum PrcError {
/// The data does not start with the `PRC` magic [WD 6.1.1].
#[error("not a PRC stream: missing the \"PRC\" magic")]
NotPrc,
/// A value ran past the end of its byte or bit stream.
#[error("PRC data truncated while reading {0}")]
Truncated(&'static str),
/// A structural field holds a value the format forbids.
#[error("malformed PRC: {0}")]
Malformed(String),
/// No `Double` code of up to 22 bits matched [WD 11.17].
#[error("PRC Double: no code matches the next 22 bits")]
UnknownDoubleCode,
/// A section is not a valid zlib stream.
#[error("PRC {section} section does not inflate: {reason}")]
Inflate {
/// The section's name.
section: &'static str,
/// The decoder's message.
reason: String,
},
/// The inflated sections and copied blocks together exceed the ceiling
/// ([`crate::MAX_INFLATED_BYTES`] or the caller's limit).
#[error("PRC sections inflate past the {limit}-byte ceiling")]
TooLarge {
/// The ceiling that was hit.
limit: usize,
},
/// The arrays read from one stream hold more elements than [`crate::MAX_DECODED_ELEMENTS`].
/// One bit can decode to a 4- or 8-byte element, so the inflation ceiling alone does not
/// bound the memory the arrays take.
#[error("PRC arrays decode past the {limit}-element ceiling")]
TooManyElements {
/// The ceiling that was hit.
limit: usize,
},
/// A construct this reader does not decode; the part of the file holding it cannot be
/// read past.
#[error("PRC {0} is not supported")]
Unsupported(&'static str),
}
crates/prc/src/geometry.rs
+276
View File
@@ -0,0 +1,276 @@
//! Model-space vectors and matrices, and their application to meshes.
use crate::TriangleMesh;
/// A point or direction in model space.
#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub(crate) struct Vec3(pub(crate) [f64; 3]);
impl Vec3 {
/// The right-handed cross product `self × b`.
pub(crate) fn cross(self, b: Vec3) -> Vec3 {
let ([ax, ay, az], [bx, by, bz]) = (self.0, b.0);
Vec3([ay * bz - az * by, az * bx - ax * bz, ax * by - ay * bx])
}
}
/// A 4×4 matrix, `m.0[row][col]`, acting on column vectors.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Matrix(pub [[f64; 4]; 4]);
impl Default for Matrix {
fn default() -> Self {
Matrix::IDENTITY
}
}
impl Matrix {
/// The identity matrix.
pub const IDENTITY: Matrix = Matrix([[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]]);
/// The entry at `row`, `col`; 0 outside the matrix.
#[must_use]
pub fn at(&self, row: usize, col: usize) -> f64 {
self.0.get(row).and_then(|r| r.get(col)).copied().unwrap_or(0.0)
}
/// `self × b`: `b` applied first.
#[must_use]
pub fn multiply(&self, b: &Matrix) -> Matrix {
let mut m = [[0.0; 4]; 4];
for (i, row) in m.iter_mut().enumerate() {
for (j, cell) in row.iter_mut().enumerate() {
*cell = (0..4).map(|k| self.at(i, k) * b.at(k, j)).sum();
}
}
Matrix(m)
}
/// `self × (p, 1)`, divided by the homogeneous coordinate when it is neither 0 nor 1.
#[must_use]
pub fn transform_point(&self, p: [f64; 3]) -> [f64; 3] {
let [x, y, z] = p;
let row = |i: usize| self.at(i, 0) * x + self.at(i, 1) * y + self.at(i, 2) * z + self.at(i, 3);
let w = row(3);
let s = if w == 0.0 || w == 1.0 { 1.0 } else { 1.0 / w };
[row(0) * s, row(1) * s, row(2) * s]
}
/// The determinant of the upper-left 3×3 block.
fn det3(&self) -> f64 {
let a = |i, j| self.at(i, j);
a(0, 0) * (a(1, 1) * a(2, 2) - a(1, 2) * a(2, 1)) - a(0, 1) * (a(1, 0) * a(2, 2) - a(1, 2) * a(2, 0))
+ a(0, 2) * (a(1, 0) * a(2, 1) - a(1, 1) * a(2, 0))
}
/// The determinant of the whole matrix, by expansion along the last row.
fn det4(&self) -> f64 {
(0..4)
.map(|j| {
let cols: Vec<usize> = (0..4).filter(|&c| c != j).collect();
let a = |i: usize, k: usize| cols.get(k).map_or(0.0, |&c| self.at(i, c));
let minor = a(0, 0) * (a(1, 1) * a(2, 2) - a(1, 2) * a(2, 1)) - a(0, 1) * (a(1, 0) * a(2, 2) - a(1, 2) * a(2, 0))
+ a(0, 2) * (a(1, 0) * a(2, 1) - a(1, 1) * a(2, 0));
let sign = if (3 + j) % 2 == 0 { 1.0 } else { -1.0 };
sign * self.at(3, j) * minor
})
.sum()
}
/// Whether mapping points through this matrix turns them inside out. Where the point is
/// divided by `w`, the Jacobian's sign is the sign of the 4×4 determinant; a last row of
/// zeros (no division) falls back to the 3×3 block. Each row is first divided by its
/// largest entry, which keeps both signs while the products stay in range.
fn mirrors(&self) -> bool {
let scaled = Matrix(self.0.map(|row| {
let big = row.iter().fold(0.0_f64, |m, c| m.max(c.abs()));
if big.is_finite() && big > 0.0 { row.map(|c| c / big) } else { row }
}));
let det = scaled.det4();
if det == 0.0 { scaled.det3() < 0.0 } else { det < 0.0 }
}
/// Cofactor `(i, j)` of the upper-left 3×3 block (`i`, `j` < 3).
fn cofactor(&self, i: usize, j: usize) -> f64 {
let (r0, r1) = ((i + 1) % 3, (i + 2) % 3);
let (c0, c1) = ((j + 1) % 3, (j + 2) % 3);
self.at(r0, c0) * self.at(r1, c1) - self.at(r0, c1) * self.at(r1, c0)
}
}
impl TriangleMesh {
/// This mesh with every position mapped through `m` and every stored normal through its
/// inverse transpose (renormalised); a mirroring `m` (negative 4×4 determinant, which a
/// negative `w` can cause too) reverses each triangle so the outside stays
/// counter-clockwise. A projective `m` (a last row other than
/// `[0, 0, 0, w]`) bends the surface per point, so the stored normals are dropped.
///
/// ```
/// use pdfcraft_prc::{Matrix, TriangleMesh};
/// let mut mirror = Matrix::IDENTITY;
/// mirror.0[0][0] = -1.0;
/// let mut mesh = TriangleMesh::default();
/// mesh.positions = vec![[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]];
/// mesh.triangles = vec![[0, 1, 2]];
/// let placed = mesh.transformed(&mirror);
/// assert_eq!(placed.positions, [[-1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]]);
/// assert_eq!(placed.triangles, [[0, 2, 1]]);
/// ```
#[must_use]
pub fn transformed(&self, m: &Matrix) -> Self {
let mut out = self.clone();
for p in &mut out.positions {
*p = m.transform_point(*p);
}
// The cofactor matrix is det times the inverse transpose, so its sign is corrected
// and the result renormalised.
let mirrors = m.mirrors();
let sign = if mirrors { -1.0 } else { 1.0 };
if m.at(3, 0) != 0.0 || m.at(3, 1) != 0.0 || m.at(3, 2) != 0.0 {
out.normals.clear();
out.triangle_normals.clear();
}
for n in &mut out.normals {
let [x, y, z] = *n;
let v = [0, 1, 2].map(|i| sign * (m.cofactor(i, 0) * x + m.cofactor(i, 1) * y + m.cofactor(i, 2) * z));
let len = v.iter().map(|c| c * c).sum::<f64>().sqrt();
*n = if len > 0.0 && len.is_finite() { v.map(|c| c / len) } else { v };
}
if mirrors {
for t in &mut out.triangles {
t.swap(1, 2);
}
for t in &mut out.triangle_normals {
t.swap(1, 2);
}
for t in out.triangle_uvs.iter_mut().flatten().flatten() {
t.swap(1, 2);
}
}
out
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn cross_follows_the_right_hand_rule() {
assert_eq!(Vec3([1.0, 0.0, 0.0]).cross(Vec3([0.0, 1.0, 0.0])), Vec3([0.0, 0.0, 1.0]));
assert_eq!(Vec3([0.0, 1.0, 0.0]).cross(Vec3([1.0, 0.0, 0.0])), Vec3([0.0, 0.0, -1.0]));
}
#[test]
fn multiply_applies_the_right_operand_first() {
let mut t = Matrix::IDENTITY;
t.0[0][3] = 5.0;
let mut s = Matrix::IDENTITY;
s.0[0][0] = 2.0;
assert_eq!(t.multiply(&s).transform_point([1.0, 0.0, 0.0]), [7.0, 0.0, 0.0]);
assert_eq!(s.multiply(&t).transform_point([1.0, 0.0, 0.0]), [12.0, 0.0, 0.0]);
}
#[test]
fn a_projective_point_is_divided_by_w() {
let mut m = Matrix::IDENTITY;
m.0[3][3] = 2.0;
assert_eq!(m.transform_point([2.0, 4.0, 6.0]), [1.0, 2.0, 3.0]);
m.0[3][3] = 0.0;
assert_eq!(m.transform_point([2.0, 4.0, 6.0]), [2.0, 4.0, 6.0]);
}
#[test]
fn normals_take_the_inverse_transpose_and_mirror_with_their_triangle() {
// A shear in x by y turns the plane x = 0 into x = y; its x normal tilts to stay perpendicular.
let mut shear = Matrix::IDENTITY;
shear.0[0][1] = 1.0;
let mesh = TriangleMesh {
positions: vec![[0.0; 3], [1.0, 0.0, 0.0], [0.0, 0.0, 1.0]],
triangles: vec![[0, 1, 2]],
normals: vec![[1.0, 0.0, 0.0]],
triangle_normals: vec![[0, 0, 0]],
..TriangleMesh::default()
};
let n = shear.transformed_normal(&mesh);
let s = std::f64::consts::FRAC_1_SQRT_2;
assert!((n[0] - s).abs() < 1e-12 && (n[1] + s).abs() < 1e-12 && n[2] == 0.0, "{n:?}");
let mut mirror = Matrix::IDENTITY;
mirror.0[2][2] = -1.0;
let placed = mesh.transformed(&mirror);
assert_eq!(placed.triangles, [[0, 2, 1]]);
assert_eq!(placed.triangle_normals, [[0, 0, 0]]);
assert_eq!(placed.normals, [[1.0, 0.0, 0.0]]);
}
#[test]
fn a_projective_transform_drops_the_stored_normals() {
let mesh = TriangleMesh {
positions: vec![[0.0; 3], [1.0, 0.0, 0.0], [0.0, 0.0, 1.0]],
triangles: vec![[0, 1, 2]],
normals: vec![[1.0, 0.0, 1.0]],
triangle_normals: vec![[0, 0, 0]],
..TriangleMesh::default()
};
let mut projective = Matrix::IDENTITY;
projective.0[3][0] = 1.0;
let placed = mesh.transformed(&projective);
assert!(placed.normals.is_empty() && placed.triangle_normals.is_empty());
// A uniform w keeps them.
let mut uniform = Matrix::IDENTITY;
uniform.0[3][3] = 2.0;
assert_eq!(mesh.transformed(&uniform).triangle_normals, [[0, 0, 0]]);
}
/// A negative `w` turns the mapped triangles inside out though the 3×3 block does not
/// mirror, so the winding is reversed by the sign of the whole determinant.
#[test]
fn a_negative_w_reverses_the_winding() {
let mesh = TriangleMesh {
positions: vec![[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]],
triangles: vec![[0, 1, 2]],
normals: vec![[1.0, 0.0, 0.0]],
triangle_normals: vec![[0, 0, 0]],
..TriangleMesh::default()
};
let mut negated = Matrix::IDENTITY;
negated.0[3][3] = -1.0;
let placed = mesh.transformed(&negated);
assert_eq!(placed.positions, [[-1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, -1.0]]);
assert_eq!(placed.triangles, [[0, 2, 1]]);
assert_eq!(placed.normals, [[-1.0, 0.0, 0.0]]);
// A projective w that is negative over the mesh: w = z - 3.
let mut projective = Matrix::IDENTITY;
projective.0[3][2] = 1.0;
projective.0[3][3] = -3.0;
assert_eq!(mesh.transformed(&projective).triangles, [[0, 2, 1]]);
// A positive w, uniform or projective, keeps the winding.
let mut positive = Matrix::IDENTITY;
positive.0[3][2] = 1.0;
positive.0[3][3] = 3.0;
assert_eq!(mesh.transformed(&positive).triangles, [[0, 1, 2]]);
}
#[test]
fn a_mirror_whose_determinant_underflows_still_reverses_the_winding() {
let mesh = TriangleMesh {
positions: vec![[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]],
triangles: vec![[0, 1, 2]],
..TriangleMesh::default()
};
let diagonal = |x: f64| {
let mut m = Matrix::IDENTITY;
(m.0[0][0], m.0[1][1], m.0[2][2]) = (x, 1e-200, 1e-200);
m
};
assert_eq!(mesh.transformed(&diagonal(-1e200)).triangles, [[0, 2, 1]]);
assert_eq!(mesh.transformed(&diagonal(1e200)).triangles, [[0, 1, 2]]);
}
impl Matrix {
fn transformed_normal(&self, mesh: &TriangleMesh) -> [f64; 3] {
mesh.transformed(self).normals.first().copied().unwrap_or_default()
}
}
}
crates/prc/src/lib.rs
+37
View File
@@ -0,0 +1,37 @@
//! A reader for PRC, the 3D model format a PDF `/3D` stream of `/Subtype /PRC` carries
//! (ISO 32000-2 §13.6.3, ISO 14739-1).
//!
//! Layer L0, standalone: this crate depends on no other PdfCraft crate. It reads the
//! uncompressed container, inflates each section, and decodes the bit-level primitives and
//! the schema a newer producer uses to describe fields this reader does not know; it decodes
//! tessellations and walks the product tree into placed, coloured meshes
//! ([`PrcFile::placements`], [`PrcFile::model_tree`]).
//!
//! Clause numbers in `[WD x.y]` refer to the PRC working draft, ISO/TC 171/SC 2 N570.
//!
//! Every read is bounded: inflation by [`MAX_INFLATED_BYTES`] (or a caller's limit), decoded
//! array elements by [`MAX_DECODED_ELEMENTS`] and schema-program steps by [`MAX_SCHEMA_STEPS`]
//! per reading pass, schema programs by a depth ceiling. Damaged data is an error, never a panic.
#![forbid(unsafe_code)]
#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
mod acof;
mod arrays;
mod bits;
mod container;
mod entity;
mod error;
mod geometry;
mod schema;
mod tess;
#[cfg(test)]
mod testw;
mod tree;
pub use bits::{BitReader, MAX_DECODED_ELEMENTS, MAX_SCHEMA_STEPS};
pub use container::{FileStructure, MAX_FILE_STRUCTURES, MAX_INFLATED_BYTES, PRC_READER_VERSION, PrcFile, PrcHeader, SectionKind, UniqueId};
pub use error::PrcError;
pub use geometry::Matrix;
pub use schema::Schema;
pub use tess::{Tessellation, TriangleMesh, TriangleStyle};
pub use tree::{EntityOverrides, MAX_PLACEMENTS, ModelNode, NameSource, Placement, Rgba, StyleAlpha};
crates/prc/src/schema.rs
+565
View File
@@ -0,0 +1,565 @@
//! `FileStructureSchema` and its token interpreter [WD 6.3, 9].
//!
//! A producer newer than the reader describes, per entity type, the fields it appended; the
//! reader runs that program after the fields it knows, to step over the rest [WD 9.1]. Token
//! values follow the WD 9.2 table as corrected by PDF Association pdf-issues #407
//! (`Block_Start` = 19; 39 and 40 swallow one token).
//!
//! Choices the sources leave open, made here:
//! - `SimpleFor` reads its count as an `UnsignedInteger` [WD 9.3.17 pseudocode; pdf-issues
//! #575]: that read also decodes an `Integer`-written non-negative count, while a signed
//! read does not decode an unsigned one whose top group is 0x80 or higher.
//! - `Block_Version V` runs its block only when `V` is newer than
//! [`crate::PRC_READER_VERSION`]: an older block holds fields this reader already reads
//! natively [WD 9.3.20].
//! - `Extent_1D` and `Extent_2D` read 2 and 4 `Double`s: `Interval` and `Domain`
//! [WD 8.2.2, 8.2.4].
//! - Expression values are `i64`; a `Double` read as an operand truncates (NaN reads as 0).
//! - Variables are not block-scoped: a program that reuses an index after its block ends
//! reads the stale value instead of an error.
//! - Pointer tokens (12-14) and `Value_CurveIs3D` (28) need the exact-geometry reader and are
//! refused with [`PrcError::Unsupported`].
use std::collections::HashMap;
use crate::PrcError;
use crate::bits::BitReader;
/// Nesting depth of blocks, loops, expressions and `Father_Type` calls.
const MAX_DEPTH: u32 = 64;
/// The per-entity-type programs at the start of a globals or model-file
/// bitstream [WD 6.3.1].
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Schema {
programs: HashMap<u32, Vec<u32>>,
}
impl Schema {
/// Read a schema: `UnsignedInteger` count, then per entry the entity
/// type, a token count and the tokens [WD 6.3.2].
///
/// # Errors
/// [`PrcError::Truncated`] when a count runs past the data;
/// [`PrcError::Malformed`] for an entity type listed twice; [`PrcError::TooManyElements`]
/// past the reader's allowance, one element per entry and per token.
pub fn read(r: &mut BitReader<'_>) -> Result<Self, PrcError> {
let n = r.unsigned_integer()? as usize;
// Every entry takes at least two bits.
if n > r.remaining() / 2 {
return Err(PrcError::Truncated("the schema"));
}
let mut programs = HashMap::new();
for _ in 0..n {
// The entry itself costs one element, so empty programs are not free.
r.take_elements(1)?;
let entity_type = r.unsigned_integer()?;
let len = r.unsigned_integer()? as usize;
if len > r.remaining() {
return Err(PrcError::Truncated("a schema program"));
}
r.take_elements(len)?;
let tokens = (0..len).map(|_| r.unsigned_integer()).collect::<Result<Vec<_>, _>>()?;
if programs.insert(entity_type, tokens).is_some() {
return Err(PrcError::Malformed(format!("schema lists entity type {entity_type} twice")));
}
}
Ok(Self { programs })
}
/// True when no entity type has added fields (the common case: the file
/// was written at the version this reader implements).
pub fn is_empty(&self) -> bool {
self.programs.is_empty()
}
/// The entity types the schema describes, unordered.
pub fn entity_types(&self) -> impl Iterator<Item = u32> + '_ {
self.programs.keys().copied()
}
/// Consume the fields a newer producer appended to `entity_type`, if the
/// schema describes it; a no-op otherwise. Each step is charged to `r`, so every
/// program run on one stream shares [`crate::MAX_SCHEMA_STEPS`].
///
/// # Errors
/// [`PrcError::Unsupported`] for a token that needs exact geometry;
/// [`PrcError::Malformed`] for an ill-formed program, one past the depth ceiling, or
/// one that runs out of the stream's steps; any read error from `r`.
pub fn skip_added_fields(&self, entity_type: u32, r: &mut BitReader<'_>) -> Result<(), PrcError> {
let Some(program) = self.programs.get(&entity_type) else {
return Ok(());
};
let mut exec = Exec { schema: self, r, vars: HashMap::new(), loop_counter: 0 };
exec.program(program, 0)
}
}
struct Exec<'s, 'r, 'd> {
schema: &'s Schema,
r: &'r mut BitReader<'d>,
vars: HashMap<u32, i64>,
loop_counter: i64,
}
fn malformed(what: &str) -> PrcError {
PrcError::Malformed(format!("schema program: {what}"))
}
/// The token at `*pos`, advancing past it.
fn next(prog: &[u32], pos: &mut usize) -> Result<u32, PrcError> {
let t = prog.get(*pos).copied().ok_or_else(|| malformed("ends mid-statement"))?;
*pos += 1;
Ok(t)
}
impl Exec<'_, '_, '_> {
fn tick(&mut self, depth: u32) -> Result<(), PrcError> {
if !self.r.take_step() {
return Err(malformed("step ceiling reached"));
}
if depth > MAX_DEPTH {
return Err(malformed("nesting ceiling reached"));
}
Ok(())
}
fn program(&mut self, prog: &[u32], depth: u32) -> Result<(), PrcError> {
let mut pos = 0;
while pos < prog.len() {
self.stmt(prog, &mut pos, true, depth)?;
}
Ok(())
}
/// One data read for tokens 0-5 and 7-11, returning its value as an
/// operand.
fn read(&mut self, token: u32) -> Result<i64, PrcError> {
let doubles = match token {
0 => return Ok(i64::from(self.r.bit()?)),
1 => return Ok(self.r.double()? as i64),
2 => return Ok(i64::from(self.r.character()?)),
3 => return Ok(i64::from(self.r.unsigned_integer()?)),
4 => return Ok(i64::from(self.r.integer()?)),
5 => {
self.r.string()?;
return Ok(0);
}
7 => 2,
8 => 3,
9 => 2,
10 => 4,
11 => 6,
_ => return Err(malformed("not a data token")),
};
for _ in 0..doubles {
self.r.double()?;
}
Ok(0)
}
/// Statements until `Block_End`, which is consumed.
fn block(&mut self, prog: &[u32], pos: &mut usize, run: bool, depth: u32) -> Result<(), PrcError> {
loop {
if prog.get(*pos) == Some(&21) {
*pos += 1;
return Ok(());
}
self.stmt(prog, pos, run, depth + 1)?;
}
}
/// Run `body` (one statement at `*pos`) `count` times; `*pos` ends past it.
fn repeat(&mut self, prog: &[u32], pos: &mut usize, count: i64, run: bool, depth: u32) -> Result<(), PrcError> {
let start = *pos;
self.stmt(prog, pos, false, depth + 1)?;
if run {
let saved = self.loop_counter;
for i in 0..count.max(0) {
self.tick(depth)?;
self.loop_counter = i;
let mut p = start;
self.stmt(prog, &mut p, true, depth + 1)?;
}
self.loop_counter = saved;
}
Ok(())
}
/// One statement; with `run` false, only step over its tokens.
fn stmt(&mut self, prog: &[u32], pos: &mut usize, run: bool, depth: u32) -> Result<(), PrcError> {
self.tick(depth)?;
match next(prog, pos)? {
t @ (0..=5 | 7..=11) => {
if run {
self.read(t)?;
}
}
6 => self.parent_program(prog, pos, run, depth)?,
12 => {
next(prog, pos)?;
if run {
return Err(PrcError::Unsupported("a schema pointer field"));
}
}
13 | 14 => {
if run {
return Err(PrcError::Unsupported("a schema pointer field"));
}
}
15 => {
let count = self.expr(prog, pos, run, depth + 1)?;
self.repeat(prog, pos, count, run, depth)?;
}
16 => {
// prc-rs: reads SimpleFor's count as an Integer; this reader deliberately reads an
// UnsignedInteger (module doc).
let count = if run { i64::from(self.r.unsigned_integer()?) } else { 0 };
self.repeat(prog, pos, count, run, depth)?;
}
17 => self.conditional(prog, pos, run, depth)?,
19 => self.block(prog, pos, run, depth)?,
20 => {
let version = next(prog, pos)?;
let newer = version > crate::PRC_READER_VERSION;
self.block(prog, pos, run && newer, depth)?;
}
22 => {
let v = next(prog, pos)?;
if run {
self.vars.insert(v, 0);
}
}
23 | 24 => {
let v = next(prog, pos)?;
let value = self.expr(prog, pos, run, depth + 1)?;
if run {
self.vars.insert(v, value);
}
}
39 | 40 => {
next(prog, pos)?;
}
t => return Err(malformed(&format!("token {t} where a statement belongs"))),
}
Ok(())
}
/// Token 6: run the named type's own program, the fields it inherits.
fn parent_program(&mut self, prog: &[u32], pos: &mut usize, run: bool, depth: u32) -> Result<(), PrcError> {
let parent = next(prog, pos)?;
if run && let Some(p) = self.schema.programs.get(&parent) {
self.tick(depth + 1)?;
let mut q = 0;
while q < p.len() {
self.stmt(p, &mut q, true, depth + 1)?;
}
}
Ok(())
}
/// Token 17: `if` with an optional token-18 `else`.
fn conditional(&mut self, prog: &[u32], pos: &mut usize, run: bool, depth: u32) -> Result<(), PrcError> {
let cond = self.expr(prog, pos, run, depth + 1)? != 0;
self.stmt(prog, pos, run && cond, depth + 1)?;
if prog.get(*pos) == Some(&18) {
*pos += 1;
self.stmt(prog, pos, run && !cond, depth + 1)?;
}
Ok(())
}
/// One expression; with `run` false its value is 0 and nothing is read.
fn expr(&mut self, prog: &[u32], pos: &mut usize, run: bool, depth: u32) -> Result<i64, PrcError> {
self.tick(depth)?;
let t = next(prog, pos)?;
match t {
0..=4 => {
if run {
self.read(t)
} else {
Ok(0)
}
}
25 => {
let v = next(prog, pos)?;
if !run {
return Ok(0);
}
self.vars.get(&v).copied().ok_or_else(|| malformed(&format!("variable {v} read before it is set")))
}
26 => Ok(i64::from(next(prog, pos)?)),
27 => Ok(self.loop_counter),
28 => {
if run {
Err(PrcError::Unsupported("Value_CurveIs3D"))
} else {
Ok(0)
}
}
29..=38 => {
let a = self.expr(prog, pos, run, depth + 1)?;
let b = self.expr(prog, pos, run, depth + 1)?;
if !run {
return Ok(0);
}
let overflow = || malformed("a schema expression overflows");
Ok(match t {
29 => a.checked_mul(b).ok_or_else(overflow)?,
30 => a.checked_div(b).ok_or_else(|| malformed("division by zero"))?,
31 => a.checked_add(b).ok_or_else(overflow)?,
32 => a.checked_sub(b).ok_or_else(overflow)?,
33 => i64::from(a < b),
34 => i64::from(a <= b),
35 => i64::from(a > b),
36 => i64::from(a >= b),
37 => i64::from(a == b),
_ => i64::from(a != b),
})
}
t => Err(malformed(&format!("token {t} where a value belongs"))),
}
}
}
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::indexing_slicing)]
mod tests {
use super::*;
use crate::testw::W;
fn schema(entries: &[(u32, &[u32])]) -> W {
let mut w = W::default();
w.uint(entries.len() as u32);
for (t, toks) in entries {
w.uint(*t).uint(toks.len() as u32);
for k in *toks {
w.uint(*k);
}
}
w
}
/// Each schema entry and its program's tokens are charged against the reader's element
/// allowance.
#[test]
fn program_tokens_are_charged_against_the_allowance() {
let bytes = schema(&[(172, &[1, 2, 3])]).bytes();
assert!(matches!(Schema::read(&mut BitReader::with_elements(&bytes, 3)), Err(PrcError::TooManyElements { .. })));
assert!(Schema::read(&mut BitReader::with_elements(&bytes, 4)).is_ok());
let empty = schema(&[(172, &[]), (173, &[]), (174, &[])]).bytes();
assert!(matches!(Schema::read(&mut BitReader::with_elements(&empty, 2)), Err(PrcError::TooManyElements { .. })));
assert!(Schema::read(&mut BitReader::with_elements(&empty, 3)).is_ok());
}
fn run(entries: &[(u32, &[u32])], data: &W) -> (Result<(), PrcError>, usize) {
let mut w = schema(entries);
w.append(data);
let bytes = w.bytes();
let mut r = BitReader::new(&bytes);
let s = Schema::read(&mut r).unwrap();
let start = r.position();
let res = s.skip_added_fields(172, &mut r);
(res, r.position() - start)
}
#[test]
fn integer_string_and_boolean_tokens_consume_their_fields() {
let mut d = W::default();
d.bit(true).uint(300).int(-7).string(Some("ab")).put(0x41, 8);
let want = d.len();
d.uint(99); // not part of the added fields
let (res, used) = run(&[(172, &[0, 3, 4, 5, 2])], &d);
res.unwrap();
assert_eq!(used, want);
}
#[test]
fn data_tokens_consume_their_fields() {
let mut d = W::default();
d.bit(true).double(1.5).uint(300).int(-7).string(Some("ab")).double(2.0).double(3.0);
let want = d.len();
d.uint(99); // not part of the added fields
let (res, used) = run(&[(172, &[0, 1, 3, 4, 5, 7])], &d);
res.unwrap();
assert_eq!(used, want);
}
#[test]
fn vector_extent_and_box_tokens_read_their_doubles() {
// Vec3, Extent1D, Extent2D, BBox: 3 + 2 + 4 + 6 Doubles.
let mut d = W::default();
for i in 0..15 {
d.double(f64::from(i) + 0.5);
}
let want = d.len();
d.uint(99);
let (res, used) = run(&[(172, &[8, 9, 10, 11])], &d);
res.unwrap();
assert_eq!(used, want);
}
#[test]
fn arithmetic_and_comparison_operators() {
// For (5 - 3) { UInt }, then If (2 < 2) { Bool } Else { Char }.
let mut d = W::default();
d.uint(7).uint(8).put(0x41, 8);
let want = d.len();
d.uint(99);
let prog = [15, 32, 26, 5, 26, 3, 3, 17, 33, 26, 2, 26, 2, 0, 18, 2];
let (res, used) = run(&[(172, &prog)], &d);
res.unwrap();
assert_eq!(used, want);
}
#[test]
fn an_absent_type_is_a_no_op() {
let mut w = schema(&[(300, &[3])]);
w.uint(5);
let bytes = w.bytes();
let mut r = BitReader::new(&bytes);
let s = Schema::read(&mut r).unwrap();
let at = r.position();
s.skip_added_fields(172, &mut r).unwrap();
assert_eq!(r.position(), at);
assert!(!s.is_empty());
}
#[test]
fn simple_for_reads_its_count_then_repeats_the_body() {
let mut d = W::default();
d.int(3).uint(1).uint(2).uint(3);
let want = d.len();
d.uint(77);
let (res, used) = run(&[(172, &[16, 3])], &d);
res.unwrap();
assert_eq!(used, want);
// A block body.
let mut d = W::default();
d.int(2).bit(true).uint(9).bit(false).uint(8);
let want = d.len();
let (res, used) = run(&[(172, &[16, 19, 0, 3, 21])], &d);
res.unwrap();
assert_eq!(used, want);
// A count whose top byte is 0x80 or higher, written either way.
for signed in [false, true] {
let mut d = W::default();
if signed {
d.int(200);
} else {
d.uint(200);
}
(0..200).for_each(|_| {
d.bit(true);
});
let want = d.len();
d.uint(77);
let (res, used) = run(&[(172, &[16, 0])], &d);
res.unwrap();
assert_eq!(used, want, "signed={signed}");
}
}
#[test]
fn if_else_and_variables_choose_the_branch_by_file_data() {
// DeclareAndSet v0 = <UInt from file>; if v0 > 1 { UInt } else { Character }.
let prog: &[u32] = &[24, 0, 3, 17, 35, 25, 0, 26, 1, 3, 18, 2];
let mut d = W::default();
d.uint(5).uint(4250);
let want = d.len();
let (res, used) = run(&[(172, prog)], &d);
res.unwrap();
assert_eq!(used, want);
let mut d = W::default();
d.uint(0).put(0xAB, 8);
let want = d.len();
let (res, used) = run(&[(172, prog)], &d);
res.unwrap();
assert_eq!(used, want);
}
#[test]
fn for_counts_by_expression_and_exposes_the_counter() {
// For (2 * 2) { if counter == 2 { UInt } } => one UInt read.
let prog: &[u32] = &[15, 29, 26, 2, 26, 2, 17, 37, 27, 26, 2, 3];
let mut d = W::default();
d.uint(1234);
let want = d.len();
let (res, used) = run(&[(172, prog)], &d);
res.unwrap();
assert_eq!(used, want);
}
#[test]
fn an_expression_that_overflows_is_malformed() {
// For ((2^31 * 2^31) * 4) { UInt }: 2^64 would wrap to 0 and read nothing.
let prog: &[u32] = &[15, 29, 29, 26, 1 << 31, 26, 1 << 31, 26, 4, 3];
let (res, _) = run(&[(172, prog)], &W::default());
assert!(matches!(res, Err(PrcError::Malformed(m)) if m.contains("overflows")));
}
#[test]
fn version_blocks_run_only_when_newer_than_the_reader() {
let mut d = W::default();
d.uint(42);
let want = d.len();
let (res, used) = run(&[(172, &[20, 8137, 3, 21, 20, 9000, 3, 21])], &d);
res.unwrap();
assert_eq!(used, want);
}
#[test]
fn father_type_runs_the_parent_program_and_obsolete_tokens_swallow_one() {
let mut d = W::default();
d.uint(1).uint(2);
let want = d.len();
let (res, used) = run(&[(172, &[39, 3, 6, 50, 40, 8]), (50, &[3, 3])], &d);
res.unwrap();
assert_eq!(used, want);
}
#[test]
fn hostile_programs_are_refused_not_run_forever() {
let d = W::default();
// For (1000000 * 1000000) { empty block }.
let prog: &[u32] = &[15, 29, 26, 1_000_000, 26, 1_000_000, 19, 21];
assert!(matches!(run(&[(172, prog)], &d).0, Err(PrcError::Malformed(_))));
// Father_Type recursing into itself.
assert!(matches!(run(&[(172, &[6, 172])], &d).0, Err(PrcError::Malformed(_))));
// A pointer field.
assert!(matches!(run(&[(172, &[13])], &d).0, Err(PrcError::Unsupported(_))));
// A stray Block_End, an unterminated block, a division by zero.
assert!(matches!(run(&[(172, &[21])], &d).0, Err(PrcError::Malformed(_))));
assert!(matches!(run(&[(172, &[19, 0])], &d).0, Err(PrcError::Malformed(_))));
assert!(matches!(run(&[(172, &[23, 0, 30, 26, 1, 26, 0])], &d).0, Err(PrcError::Malformed(_))));
}
/// Every program run on one reader draws on one step allowance.
#[test]
fn programs_on_one_stream_share_the_step_allowance() {
// For (2^19) { empty block }: about 2^20 steps, so the 2^22 allowance fits three runs.
let bytes = schema(&[(172, &[15, 26, 1 << 19, 19, 21])]).bytes();
let mut r = BitReader::new(&bytes);
let s = Schema::read(&mut r).unwrap();
let runs = (0..5).take_while(|_| s.skip_added_fields(172, &mut r).is_ok()).count();
assert_eq!(runs, 3);
assert!(matches!(s.skip_added_fields(172, &mut r), Err(PrcError::Malformed(m)) if m.contains("step ceiling")));
}
#[test]
fn a_duplicated_entity_type_is_malformed() {
let bytes = schema(&[(172, &[3]), (172, &[3])]).bytes();
assert!(matches!(Schema::read(&mut BitReader::new(&bytes)), Err(PrcError::Malformed(_))));
}
#[test]
fn an_entry_count_past_the_data_is_refused_before_any_entry_is_read() {
let mut w = W::default();
w.uint(1_000).uint(172).uint(0);
let bytes = w.bytes();
assert_eq!(Schema::read(&mut BitReader::new(&bytes)).unwrap_err(), PrcError::Truncated("the schema"));
}
}
crates/prc/src/tess.rs
+440
View File
@@ -0,0 +1,440 @@
//! The tessellation section: `FileStructureTessellation` (305) and its entities, `TESS_3D`
//! (172) with its `TESS_Face`s (174), `TESS_3D_Wire` (175), `TESS_Markup` (176) and
//! `TESS_3D_Compressed` (173) [WD 7.3.7, 7.8].
//!
//! `TESS_3D_Compressed` is read field by field to its end [WD 7.8.9.7] so the entities after
//! it decode; its triangles are not rebuilt.
//!
//! The schema runs after the fields of each concrete type read here (201, 172, 173, 174, 175,
//! 176, 305), not for the abstract levels (`PRCBase`, `TESS`).
mod triangulate;
use crate::arrays;
use crate::bits::{BitReader, Budget};
use crate::entity::{Ctx, malformed};
use crate::{FileStructure, PrcError, SectionKind};
use triangulate::{Corners, Face, triangle_elements};
const FILE_STRUCTURE_TESSELLATION: u32 = 305;
const TESS_3D: u32 = 172;
const TESS_3D_COMPRESSED: u32 = 173;
const TESS_FACE: u32 = 174;
const TESS_3D_WIRE: u32 = 175;
const TESS_MARKUP: u32 = 176;
/// prc-rs: `origin` exists in a compressed tessellation from this version (pdf-issues #705).
const ORIGIN_FROM: u32 = 7031;
/// prc-rs: `has_loops` exists from this file-structure authoring version.
const HAS_LOOPS_FROM: u32 = 7039;
/// prc-rs: `must_recalculate_normals` exists from this version.
const RECALCULATE_FROM: u32 = 7047;
/// A wire header's count bits; the top four are flags [WD 7.8.7.5].
const WIRE_COUNT_MASK: u32 = 0x0FFF_FFFF;
const WIRE_IS_CLOSING: u32 = 0x1000_0000;
const WIRE_IS_CONTINUOUS: u32 = 0x2000_0000;
/// Normal angles wider than this are not a `ShortArray` [WD 7.8.9.7].
const MAX_ANGLE_BITS: u32 = 16;
/// One entry of the tessellation array; a representation item's `index_tessellation` selects
/// one by position.
#[derive(Debug, Clone, PartialEq)]
#[non_exhaustive]
pub enum Tessellation {
/// A `TESS_3D` triangle mesh.
Mesh(TriangleMesh),
/// A `TESS_3D_Wire`: polylines.
Wire(Vec<Vec<[f64; 3]>>),
/// A `TESS_Markup` (PMI drawing), read past but not decoded.
Markup,
/// A `TESS_3D_Compressed` mesh, read past but not rebuilt.
#[non_exhaustive]
Compressed {
/// The entity's triangle count.
triangles: usize,
},
}
/// A `TESS_3D` decoded to indexed triangles, in the entity's own frame (the representation
/// item's placement is not applied).
#[derive(Debug, Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct TriangleMesh {
/// The coordinate array as points.
pub positions: Vec<[f64; 3]>,
/// Counter-clockwise triangles seen from the outside, as indices into
/// [`Self::positions`] [WD 7.8.5.2].
pub triangles: Vec<[u32; 3]>,
/// `triangles` split by `TESS_Face`: face `i` is `triangles[faces[i].clone()]`.
pub faces: Vec<std::ops::Range<usize>>,
/// The producer asks the reader to compute normals (none are stored).
pub normals_recalculated: bool,
/// The stored vertex normals [WD 7.8.5.1], as written (not renormalised); empty when the
/// mesh stores none or any of its normal indices is unusable.
pub normals: Vec<[f64; 3]>,
/// Per triangle, the index into [`Self::normals`] of each corner's normal, in the corner
/// order of [`Self::triangles`]; empty exactly when [`Self::normals`] is.
pub triangle_normals: Vec<[u32; 3]>,
/// Per triangle, the style its face's line attributes give it [WD 7.8.6]; empty when no
/// face carries any.
pub triangle_styles: Vec<TriangleStyle>,
/// The stored texture coordinates as (u, v) pairs [WD 7.8.5.1]; empty when the mesh
/// stores none.
pub uvs: Vec<[f64; 2]>,
/// Per texture-coordinate set, per triangle, the index into [`Self::uvs`] of each
/// corner's coordinate, in the corner order of [`Self::triangles`]; each set is as long
/// as [`Self::triangles`], `None` for a triangle whose face stores no coordinate for the
/// set. Empty when [`Self::uvs`] is.
pub triangle_uvs: Vec<Vec<Option<[u32; 3]>>>,
}
/// The graphics a face's `line_attributes` give one triangle [WD 7.8.6].
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
#[non_exhaustive]
pub struct TriangleStyle {
/// An index into the globals' style array plus one; 0 keeps the owner's graphics.
pub style: u32,
/// The face's behaviour bits [WD 5.4].
pub behaviour: u16,
}
impl FileStructure {
/// The tessellation section's entities, in the order a representation item's
/// `index_tessellation` counts them [WD 7.3.7].
///
/// # Errors
/// As [`crate::Schema::read`] for the globals' schema; [`PrcError::Truncated`] or
/// [`PrcError::Malformed`] for a damaged section; [`PrcError::Unsupported`] for
/// optimised vertex colours.
pub fn tessellations(&self) -> Result<Vec<Tessellation>, PrcError> {
self.tessellations_within(Budget::FULL)
}
/// As [`Self::tessellations`], the globals' schema and the section sharing `budget`.
pub(crate) fn tessellations_within(&self, budget: Budget) -> Result<Vec<Tessellation>, PrcError> {
let mut globals = BitReader::with_budget(self.section(SectionKind::Globals), budget);
let schema = crate::Schema::read(&mut globals)?;
let r = BitReader::with_budget(self.section(SectionKind::Tessellation), globals.budget());
Ctx::new(r, &schema, self.authoring_version).file_structure_tessellation()
}
}
impl Ctx<'_, '_> {
/// `FileStructureTessellation` (305) [WD 7.3.7].
pub(crate) fn file_structure_tessellation(&mut self) -> Result<Vec<Tessellation>, PrcError> {
self.expect_type(FILE_STRUCTURE_TESSELLATION)?;
self.content_prc_base()?;
let n = self.count(1, "tessellations")?;
let mut out = Vec::with_capacity(n.min(1024));
for _ in 0..n {
out.push(match self.r.unsigned_integer()? {
TESS_3D => Tessellation::Mesh(self.tess_3d()?),
TESS_3D_WIRE => Tessellation::Wire(self.wire()?),
TESS_MARKUP => {
self.markup()?;
Tessellation::Markup
}
TESS_3D_COMPRESSED => Tessellation::Compressed { triangles: self.tess_3d_compressed()? },
t => return Err(malformed(format!("entity type {t} in the tessellation array"))),
});
}
self.schema.skip_added_fields(FILE_STRUCTURE_TESSELLATION, &mut self.r)?;
self.user_data()?;
Ok(out)
}
/// `ContentBaseTessData` [WD 7.8.4]: `is_calculated`, then coordinates.
fn base_tess_data(&mut self) -> Result<Vec<f64>, PrcError> {
self.r.bit()?;
self.doubles("tessellation coordinates")
}
/// `VertexColors` [WD 7.8.7.2] for `count` points, read past.
fn vertex_colors(&mut self, count: usize, in_wire: bool) -> Result<(), PrcError> {
let rgba = self.r.bit()?;
// prc-rs: `is_segment_color` exists only inside a wire.
let per_segment = in_wire && self.r.bit()?;
if self.r.bit()? {
return Err(PrcError::Unsupported("optimised vertex colours"));
}
let count = if per_segment { count / 2 } else { count };
let bytes = if rgba { 4 } else { 3 };
// The first colour is `8 * bytes` bits; every later one is at least its reuse bit.
if count > 0 && (count - 1).saturating_add(8 * bytes) > self.r.remaining() {
return Err(PrcError::Truncated("vertex colours"));
}
for i in 0..count {
if i == 0 || !self.r.bit()? {
for _ in 0..bytes {
self.r.character()?;
}
}
}
Ok(())
}
/// `TESS_3D` (172) after its type code [WD 7.8.5].
fn tess_3d(&mut self) -> Result<TriangleMesh, PrcError> {
let coords = self.base_tess_data()?;
let _has_faces = self.r.bit()?;
if self.version >= HAS_LOOPS_FROM {
let _has_loops = self.r.bit()?;
}
let recalc = self.version >= RECALCULATE_FROM && self.r.bit()?;
if recalc {
let _flags = self.r.character()?;
let _crease_angle = self.r.double()?;
}
let normal_coords = self.doubles("normal coordinates")?;
let _wire_indices = self.uints("wire indices")?;
let indices = self.uints("triangulated indices")?;
let n_faces = self.count(1, "faces")?;
let mut faces = Vec::with_capacity(n_faces.min(1024));
for _ in 0..n_faces {
self.expect_type(TESS_FACE)?;
faces.push(self.face()?);
}
let texture = self.doubles("texture coordinates")?;
self.schema.skip_added_fields(TESS_3D, &mut self.r)?;
let mut mesh = TriangleMesh { positions: points(&coords)?, normals_recalculated: recalc, ..TriangleMesh::default() };
let styled = faces.iter().any(|f| !f.styles.is_empty());
let mut corners = Corners::default();
// Every triangle carries a corner triple for each texture set any face uses.
let sets = faces.iter().map(Face::texture_sets).max().unwrap_or(0);
let per_triangle = triangle_elements(!recalc, sets, styled);
for f in &faces {
// Faces may reuse one index range, so each face's triangles, with what they
// carry, are charged before they are made.
self.r.take_elements(f.triangle_count()?.saturating_mul(per_triangle))?;
let start = mesh.triangles.len();
let entities = f.triangulate(&indices, !recalc, mesh.positions.len(), &mut mesh.triangles, &mut corners)?;
mesh.faces.push(start..mesh.triangles.len());
if styled {
f.styles_into(&entities, &mut mesh.triangle_styles);
}
}
(mesh.normals, mesh.triangle_normals) = stored_normals(&normal_coords, &corners.normals, mesh.triangles.len());
(mesh.uvs, mesh.triangle_uvs) = stored_uvs(&texture, corners.textures);
Ok(mesh)
}
/// `TESS_Face` (174) after its type code [WD 7.8.6].
fn face(&mut self) -> Result<Face, PrcError> {
let styles = self.uints("face line attributes")?;
let _start_of_wire = self.r.unsigned_integer()?;
let _sizes_wire = self.uints("face wire sizes")?;
let flags = self.r.unsigned_integer()?;
let start = self.r.unsigned_integer()? as usize;
let data = self.uints("triangulated data")?;
let textures = self.r.unsigned_integer()? as usize;
let mut face = Face { flags, start, data, textures, styles, behaviour: 0 };
if self.r.bit()? {
let n = face.point_count()?;
self.vertex_colors(n, false)?;
}
if !face.styles.is_empty() {
let bits = self.r.unsigned_integer()?;
face.behaviour = u16::try_from(bits).map_err(|_| malformed(format!("face behaviour {bits} is wider than 16 bits")))?;
}
self.schema.skip_added_fields(TESS_FACE, &mut self.r)?;
Ok(face)
}
/// `TESS_3D_Wire` (175) after its type code [WD 7.8.7].
fn wire(&mut self) -> Result<Vec<Vec<[f64; 3]>>, PrcError> {
let pts = points(&self.base_tess_data()?)?;
let words = self.uints("wire indices")?;
let mut wires: Vec<Vec<[f64; 3]>> = Vec::new();
let mut colours = 0usize;
if words.is_empty() {
colours = pts.len();
if !pts.is_empty() {
wires.push(pts.clone());
}
}
let mut it = words.iter().copied();
while let Some(header) = it.next() {
let n = (header & WIRE_COUNT_MASK) as usize;
let mut wire = Vec::with_capacity(n.min(words.len()));
for _ in 0..n {
let idx = it.next().ok_or_else(|| malformed("wire runs past its indices".into()))?;
wire.push(point_at(&pts, idx)?);
}
colours = colours.saturating_add(n);
if header & WIRE_IS_CLOSING != 0 {
colours = colours.saturating_add(1);
if let Some(&first) = wire.first() {
wire.push(first);
}
}
match wires.last_mut() {
Some(prev) if header & WIRE_IS_CONTINUOUS != 0 => prev.extend(wire),
_ => wires.push(wire),
}
}
if self.r.bit()? {
self.vertex_colors(colours, true)?;
}
self.schema.skip_added_fields(TESS_3D_WIRE, &mut self.r)?;
Ok(wires)
}
/// `TESS_Markup` (176) after its type code [WD 7.8.8], read past.
fn markup(&mut self) -> Result<(), PrcError> {
self.base_tess_data()?;
self.uints("markup codes")?;
let n = self.count(1, "markup strings")?;
for _ in 0..n {
self.r.string()?;
}
self.r.string()?;
self.r.character()?;
self.schema.skip_added_fields(TESS_MARKUP, &mut self.r)
}
/// `TESS_3D_Compressed` (173) after its type code [WD 7.8.9.7], read past; returns its
/// triangle count. prc-rs: the field order and version gates follow its schema.
///
/// Sizes the WD leaves unstated: the face count is the largest face index + 1,
/// `normal_is_reversed` is one bit per triangle, and the point-reference array's
/// compressed flag is implicit (more than three references).
fn tess_3d_compressed(&mut self) -> Result<usize, PrcError> {
let r = &mut self.r;
r.bit()?; // is_calculated
r.bit()?; // has_faces
r.double()?; // tolerance
if self.version >= ORIGIN_FROM {
for _ in 0..3 {
r.float_as_bytes()?;
}
}
arrays::compressed_integer_array(r)?; // point_array
let edge_status = arrays::character_array(r, 2, None, false)?;
let face_of = arrays::compressed_indice_array(r, None)?;
let t = face_of.len();
if edge_status.len() != t && edge_status.len() != t.saturating_mul(3) {
return Err(malformed(format!("{} edge statuses for {t} triangles", edge_status.len())));
}
let faces = face_of.iter().max().map_or(0, |&m| (m as usize).saturating_add(1));
let n = r.unsigned_integer()? as usize;
let references = arrays::bool_array(r, n)?.iter().filter(|&&b| b).count();
let refs = arrays::compressed_indice_array(r, Some(references > 3))?;
if refs.len() != references {
return Err(malformed(format!("{} point references for {references} flagged points", refs.len())));
}
self.compressed_normals(t, faces)?;
let r = &mut self.r;
if r.bit()? {
arrays::bool_array(r, faces)?; // is_point_color_on_face
arrays::character_array(r, 8, None, false)?; // point_color_array
}
if r.bit()? {
arrays::bool_array(r, faces)?; // is_multiple_line_attribute_on_face
}
arrays::short_array(r, 16)?; // line_attributes
if !r.bit()? {
self.compressed_texture_parameter()?;
if !self.r.bit()? {
arrays::bool_array(&mut self.r, faces)?; // face_has_texture
}
}
if self.r.bit()? {
arrays::character_array(&mut self.r, 8, None, false)?; // behaviours
}
self.schema.skip_added_fields(TESS_3D_COMPRESSED, &mut self.r)?;
Ok(t)
}
/// A compressed tessellation's normals, from `must_recalculate_normals` on, read past.
fn compressed_normals(&mut self, triangles: usize, faces: usize) -> Result<(), PrcError> {
let r = &mut self.r;
if r.bit()? {
arrays::bool_array(r, triangles)?; // normal_is_reversed
r.double()?; // crease_angle
r.character()?; // normal_recalculation_flags
return Ok(());
}
let angle_bits = u32::from(r.character()?);
if angle_bits > MAX_ANGLE_BITS {
return Err(malformed(format!("{angle_bits}-bit normal angles")));
}
let n = r.unsigned_integer()? as usize;
arrays::bool_array(r, n)?; // is_binary_normal
arrays::short_array(r, angle_bits)?; // normal angles
arrays::bool_array(r, faces)?; // is_face_planar
Ok(())
}
/// `CompressedTextureParameter` [WD 7.8.9.8-7.8.9.9; pdf-issues #729, #749], read past.
fn compressed_texture_parameter(&mut self) -> Result<(), PrcError> {
let words = self.count(32, "texture data")?;
// count() bounded words * 32 by the remaining bits.
self.r.skip_bits(words.saturating_mul(32))?;
self.r.unsigned_integer()?; // last_integer_used_bit_number
let n = self.count(5, "texture references")?;
for _ in 0..n {
self.r.nbits_then_unsigned()?;
}
self.r.double()?; // tolerance
let n = self.count(32, "texture parameters")?;
for _ in 0..n {
self.r.float_as_bytes()?;
}
Ok(())
}
}
/// The normal array and each triangle's corner normals, or both empty when any slot fails to
/// name a normal: a mesh shades from its stored normals wholly or not at all.
fn stored_normals(coords: &[f64], slots: &[[u32; 3]], triangles: usize) -> (Vec<[f64; 3]>, Vec<[u32; 3]>) {
// Like a slot naming no normal, a partial last normal drops the stored normals.
let Ok(normals) = points(coords) else {
return (Vec::new(), Vec::new());
};
let named = |k: u32| k.is_multiple_of(3) && (k as usize / 3) < normals.len();
if normals.is_empty() || slots.len() != triangles || !slots.iter().flatten().all(|&k| named(k)) {
return (Vec::new(), Vec::new());
}
let corners = slots.iter().map(|t| t.map(|k| k / 3)).collect();
(normals, corners)
}
/// Per texture-coordinate set, each triangle's corner pair indices.
type UvSets = Vec<Vec<Option<[u32; 3]>>>;
/// The texture coordinates as (u, v) pairs, and per set the corner slots turned into pair
/// indices (a slot is a `Double` offset, so even); a triangle with a slot naming no pair is
/// `None`.
fn stored_uvs(coords: &[f64], sets: UvSets) -> (Vec<[f64; 2]>, UvSets) {
let uvs: Vec<[f64; 2]> = coords.as_chunks::<2>().0.to_vec();
if uvs.is_empty() {
return (Vec::new(), Vec::new());
}
let pair = |k: u32| (k.is_multiple_of(2) && (k as usize / 2) < uvs.len()).then_some(k / 2);
let sets =
sets.into_iter().map(|set| set.into_iter().map(|tri| tri.and_then(|[a, b, c]| Some([pair(a)?, pair(b)?, pair(c)?]))).collect()).collect();
(uvs, sets)
}
/// `coords` as points; an array that does not divide into whole points is malformed.
fn points(coords: &[f64]) -> Result<Vec<[f64; 3]>, PrcError> {
let (whole, rest) = coords.as_chunks::<3>();
if !rest.is_empty() {
return Err(malformed(format!("{} coordinates are not whole points", coords.len())));
}
Ok(whole.to_vec())
}
/// The point a `Double`-offset index names [WD 7.8.5.2: multiples of 3].
fn point_at(pts: &[[f64; 3]], idx: u32) -> Result<[f64; 3], PrcError> {
if !idx.is_multiple_of(3) {
return Err(malformed(format!("point index {idx} is not a multiple of 3")));
}
pts.get(idx as usize / 3).copied().ok_or_else(|| malformed(format!("point index {idx} past the coordinates")))
}
#[cfg(test)]
pub(crate) mod tests;
crates/prc/src/tess/tests.rs
+738
View File
@@ -0,0 +1,738 @@
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use super::triangulate::MAX_TEXTURE_SETS;
use super::*;
use crate::Schema;
use crate::testw::W;
const SQUARE: [f64; 12] = [0., 0., 0., 1., 0., 0., 1., 1., 0., 0., 1., 0.];
const ATTRIBUTE: u32 = 201;
const NORMAL_SINGLE: u32 = 0x4000_0000;
/// A 305 section holding `body` (already-written entities, `n` of them).
fn section(n: u32, body: &W) -> W {
let mut w = W::default();
w.uint(305).uint(0).bit(true).uint(n).append(body).uint(0);
w
}
fn uints(w: &mut W, v: &[u32]) {
w.uint(u32::try_from(v.len()).unwrap());
for &x in v {
w.uint(x);
}
}
fn square(w: &mut W, entity: u32) {
coordinates(w, entity, &SQUARE);
}
fn coordinates(w: &mut W, entity: u32, coords: &[f64]) {
w.uint(entity).bit(false).uint(u32::try_from(coords.len()).unwrap());
for &c in coords {
w.double(c);
}
}
#[derive(Default)]
struct Mesh<'a> {
recalc: bool,
indices: &'a [u32],
faces: &'a [(u32, u32, &'a [u32])],
textures: u32,
uvs: &'a [f64],
/// The coordinates; [`SQUARE`] when `None`.
coords: Option<&'a [f64]>,
}
/// A TESS_3D over [`SQUARE`] at authoring version `v`.
fn tess_3d(w: &mut W, v: u32, m: &Mesh<'_>) {
coordinates(w, 172, m.coords.unwrap_or(&SQUARE));
w.bit(true);
if v >= 7039 {
w.bit(false);
}
if v >= 7047 {
w.bit(m.recalc);
if m.recalc {
w.put(0, 8).double(0.5);
}
}
if m.recalc {
w.uint(0);
} else {
// Two normals: slot 0 is +z, slot 3 is -z.
w.uint(6);
for c in [0., 0., 1., 0., 0., -1.] {
w.double(c);
}
}
w.uint(0);
uints(w, m.indices);
w.uint(u32::try_from(m.faces.len()).unwrap());
for &(flags, start, data) in m.faces {
w.uint(174).uint(0).uint(0).uint(0).uint(flags).uint(start);
uints(w, data);
w.uint(m.textures).bit(false);
}
w.uint(u32::try_from(m.uvs.len()).unwrap());
for &c in m.uvs {
w.double(c);
}
}
fn decode(w: &W, schema: &Schema, version: u32) -> Result<Vec<Tessellation>, PrcError> {
let bytes = w.bytes();
Ctx::new(BitReader::new(&bytes), schema, version).file_structure_tessellation()
}
fn mesh(t: &Tessellation) -> &TriangleMesh {
match t {
Tessellation::Mesh(m) => m,
other => panic!("not a mesh: {other:?}"),
}
}
fn one(indices: &[u32], faces: &[(u32, u32, &[u32])], textures: u32) -> TriangleMesh {
let mut b = W::default();
tess_3d(&mut b, 8137, &Mesh { indices, faces, textures, ..Mesh::default() });
mesh(&decode(&section(1, &b), &Schema::default(), 8137).unwrap()[0]).clone()
}
#[test]
fn triangle_and_fan_with_normals() {
// One triangle (n,p x3), then a fan of 4 vertices (n,p each).
let m = one(&[3, 0, 0, 3, 3, 6, 0, 0, 3, 3, 0, 6, 3, 9], &[(0x2 | 0x4, 0, &[1, 1, 4])], 0);
assert_eq!(m.positions.len(), 4);
assert_eq!(m.positions[2], [1., 1., 0.]);
assert_eq!(m.triangles, [[0, 1, 2], [0, 1, 2], [0, 2, 3]]);
assert_eq!(m.faces, vec![0..3]);
assert!(!m.normals_recalculated);
assert_eq!(m.normals, [[0., 0., 1.], [0., 0., -1.]]);
// Each corner keeps the normal stored beside its point.
assert_eq!(m.triangle_normals, [[1, 0, 1], [0, 1, 0], [0, 0, 1]]);
}
#[test]
fn strip_normals_follow_the_alternating_winding() {
let m = one(&[3, 0, 0, 3, 3, 6, 0, 9], &[(0x8, 0, &[1, 4])], 0);
assert_eq!(m.triangles, [[0, 1, 2], [2, 1, 3]]);
assert_eq!(m.triangle_normals, [[1, 0, 1], [1, 0, 0]]);
}
#[test]
fn a_normal_index_past_the_array_drops_every_normal_but_no_triangle() {
let m = one(&[0, 0, 6, 3, 0, 6], &[(0x2, 0, &[1])], 0);
assert_eq!(m.triangles, [[0, 1, 2]]);
assert!(m.normals.is_empty());
assert!(m.triangle_normals.is_empty());
}
#[test]
fn recalculated_normals_drop_the_normal_slots_and_strips_alternate() {
let mut b = W::default();
tess_3d(&mut b, 8137, &Mesh { recalc: true, indices: &[0, 3, 6, 9], faces: &[(0x8, 0, &[1, 4])], ..Mesh::default() });
let t = decode(&section(1, &b), &Schema::default(), 8137).unwrap();
let m = mesh(&t[0]);
assert!(m.normals_recalculated);
assert_eq!(m.triangles, [[0, 1, 2], [2, 1, 3]]);
assert!(m.normals.is_empty() && m.triangle_normals.is_empty());
}
#[test]
fn version_gates_the_loop_and_recalculation_flags() {
for v in [7038, 7039, 7046, 7047, 8137] {
let mut b = W::default();
tess_3d(&mut b, v, &Mesh { indices: &[0, 0, 0, 3, 0, 6], faces: &[(0x2, 0, &[1])], ..Mesh::default() });
// A trailing wire: a misread flag desyncs it.
wire(&mut b, false);
let t = decode(&section(2, &b), &Schema::default(), v).unwrap();
assert_eq!(mesh(&t[0]).triangles, [[0, 1, 2]], "version {v}");
assert!(matches!(t[1], Tessellation::Wire(_)), "version {v}");
}
}
#[test]
fn one_normal_blocks_and_textures() {
// 0x20: n,p,p,p. 0x40 with NORMAL_Single: n then p per vertex.
// 0x2000 with one texture set: n,t,p,t,p,t,p.
let idx = [
0, 0, 3, 6, // 0x20
3, 0, 6, 9, // 0x40 single, 3 vertices
0, 0, 9, 2, 0, 4, 3, // 0x2000
];
let m = one(&idx, &[(0x20 | 0x40 | 0x2000, 0, &[1, 1, 3 | NORMAL_SINGLE, 1])], 1);
assert_eq!(m.triangles, [[0, 1, 2], [0, 2, 3], [3, 0, 1]]);
// A one-normal entity gives every corner its single normal.
assert_eq!(m.triangle_normals, [[0, 0, 0], [1, 1, 1], [0, 0, 0]]);
}
#[test]
fn one_normal_fan_without_single_keeps_a_normal_per_vertex() {
let m = one(&[0, 0, 0, 3, 0, 6, 0, 9], &[(0x40, 0, &[1, 4])], 0);
assert_eq!(m.triangles, [[0, 1, 2], [0, 2, 3]]);
}
#[test]
fn textured_fan_and_strip_carry_texture_slots_per_vertex() {
// 0x400 then 0x800, two texture sets: n,t,t,p per vertex.
let mut idx = Vec::new();
for p in [0, 3, 6, 0, 3, 6, 9] {
idx.extend([0, 0, 2, p]);
}
let m = one(&idx, &[(0x400 | 0x800, 0, &[1, 3, 1, 4])], 2);
assert_eq!(m.triangles, [[0, 1, 2], [0, 1, 2], [2, 1, 3]]);
}
/// The unit square as two textured triangles (one set; per vertex a normal, a texture slot,
/// a point), its corners at the picture's corners.
fn textured_square() -> W {
let mut body = W::default();
let indices = [0, 0, 0, 0, 2, 3, 0, 4, 6, 0, 0, 0, 0, 4, 6, 0, 6, 9];
tess_3d(
&mut body,
8137,
&Mesh { indices: &indices, faces: &[(0x200, 0, &[2])], textures: 1, uvs: &[0., 0., 1., 0., 1., 1., 0., 1.], ..Mesh::default() },
);
section(1, &body)
}
#[test]
fn a_textured_mesh_keeps_each_corners_coordinates() {
let t = decode(&textured_square(), &Schema::default(), 8137).unwrap();
let m = mesh(&t[0]);
assert_eq!(m.triangles, [[0, 1, 2], [0, 2, 3]]);
assert_eq!(m.uvs, [[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [0.0, 1.0]]);
assert_eq!(m.triangle_uvs, [vec![Some([0, 1, 2]), Some([0, 2, 3])]]);
// An odd slot names no pair: that triangle has no coordinates.
let mut b = W::default();
tess_3d(
&mut b,
8137,
&Mesh { indices: &[0, 1, 0, 0, 2, 3, 0, 4, 6], faces: &[(0x200, 0, &[1])], textures: 1, uvs: &[0.0; 6], ..Mesh::default() },
);
let t = decode(&section(1, &b), &Schema::default(), 8137).unwrap();
let m = mesh(&t[0]);
assert_eq!(m.triangles, [[0, 1, 2]]);
assert_eq!(m.triangle_uvs, [vec![None]]);
}
#[test]
fn too_many_texture_sets_are_refused_before_anything_is_allocated() {
// An empty fan on a face claiming 2^32 - 1 texture sets: no slot bounds the count.
let mut b = W::default();
tess_3d(&mut b, 8137, &Mesh { indices: &[0], faces: &[(0x400, 0, &[1, 0])], textures: u32::MAX, ..Mesh::default() });
assert!(
matches!(decode(&section(1, &b), &Schema::default(), 8137), Err(PrcError::Malformed(m)) if m == format!("{} texture-coordinate sets on a face", u32::MAX))
);
let sets = u32::try_from(MAX_TEXTURE_SETS).unwrap();
let mut ok = W::default();
tess_3d(&mut ok, 8137, &Mesh { indices: &[0], faces: &[(0x400, 0, &[1, 0])], textures: sets, ..Mesh::default() });
assert!(decode(&section(1, &ok), &Schema::default(), 8137).is_ok());
}
/// A tessellation section holding one TESS_3D: [`SQUARE`] as two faces of one triangle each.
pub(crate) fn two_face_square() -> W {
let mut b = W::default();
tess_3d(&mut b, 8137, &Mesh { indices: &[0, 0, 0, 3, 0, 6, 0, 0, 0, 6, 0, 9], faces: &[(0x2, 0, &[1]), (0x2, 6, &[1])], ..Mesh::default() });
section(1, &b)
}
#[test]
fn two_faces_partition_the_triangles() {
let m = one(&[0, 0, 0, 3, 0, 6, 0, 0, 0, 6, 0, 9], &[(0x2, 0, &[1]), (0x2, 6, &[1])], 0);
assert_eq!(m.triangles, [[0, 1, 2], [0, 2, 3]]);
assert_eq!(m.faces, [0..1, 1..2]);
}
/// A wire over [`SQUARE`]: an open two-point wire continued by a closing two-point wire,
/// then optionally per-segment RGB colours.
fn wire(w: &mut W, colours: bool) {
square(w, 175);
uints(w, &[2, 0, 3, WIRE_IS_CONTINUOUS | WIRE_IS_CLOSING | 2, 6, 9]);
w.bit(colours);
if colours {
// 5 points (4 + the implicit closing one) -> 2 segment colours.
w.bit(false).bit(true).bit(false).put(0xff0000, 24);
w.bit(true);
}
}
#[test]
fn wires_close_and_continue_and_colours_are_counted() {
for colours in [false, true] {
let mut b = W::default();
wire(&mut b, colours);
// A second entity: a wrong colour count would desync it.
wire(&mut b, false);
let t = decode(&section(2, &b), &Schema::default(), 8137).unwrap();
for e in &t {
let Tessellation::Wire(w) = e else { panic!("not a wire") };
assert_eq!(w, &[vec![[0., 0., 0.], [1., 0., 0.], [1., 1., 0.], [0., 1., 0.], [1., 1., 0.]]]);
}
}
}
#[test]
fn a_closing_wire_colours_its_implicit_point() {
// Per-point RGB: 4 indexed points + 1 implicit = 5 colours.
let mut b = W::default();
square(&mut b, 175);
uints(&mut b, &[2, 0, 3, WIRE_IS_CONTINUOUS | WIRE_IS_CLOSING | 2, 6, 9]);
b.bit(true).bit(false).bit(false).bit(false).put(1, 24);
for _ in 1..5 {
b.bit(true);
}
wire(&mut b, false);
let t = decode(&section(2, &b), &Schema::default(), 8137).unwrap();
assert!(matches!(t[1], Tessellation::Wire(_)));
assert_eq!(t[0], t[1]);
}
#[test]
fn a_wire_index_must_name_a_point() {
let mut b = W::default();
square(&mut b, 175);
uints(&mut b, &[2, 0, 12]);
b.bit(false);
assert!(matches!(decode(&section(1, &b), &Schema::default(), 8137), Err(PrcError::Malformed(_))));
}
#[test]
fn a_wire_without_indices_is_the_coordinate_polyline() {
let mut b = W::default();
square(&mut b, 175);
b.uint(0).bit(true);
// 4 implicit points -> 4 RGB colours, all "same" after the first.
b.bit(false).bit(false).bit(false).put(1, 24);
for _ in 1..4 {
b.bit(true);
}
wire(&mut b, false);
let t = decode(&section(2, &b), &Schema::default(), 8137).unwrap();
let Tessellation::Wire(w) = &t[0] else { panic!("not a wire") };
assert_eq!(w.len(), 1);
assert_eq!(w[0].len(), 4);
assert!(matches!(t[1], Tessellation::Wire(_)));
}
/// Reused colours cost one bit each, so a long run of them may end the section.
#[test]
fn reused_vertex_colours_may_be_the_last_data() {
let n = 40;
let mut b = W::default();
b.uint(175).bit(false).uint(3 * n);
for i in 0..3 * n {
b.double(f64::from(i));
}
// No indices: the polyline of all `n` points, one RGB colour then `n - 1` reuses.
b.uint(0).bit(true).bit(false).bit(false).bit(false).put(1, 24);
for _ in 1..n {
b.bit(true);
}
let t = decode(&section(1, &b), &Schema::default(), 8137).unwrap();
let Tessellation::Wire(w) = &t[0] else { panic!("not a wire") };
assert_eq!(w[0].len(), n as usize);
}
/// A square as one triangle plus one 4-vertex fan (two entities, three triangles), the face
/// carrying `attrs` and, when it has any, behaviour 0x30; then `colours` per-point colours
/// and a trailing wire.
fn styled_face(attrs: &[u32], colours: usize) -> Vec<Tessellation> {
decode(&styled_face_section(attrs, colours, 0x30), &Schema::default(), 8137).unwrap()
}
/// [`styled_face`]'s section, the face's behaviour `behaviour`.
fn styled_face_section(attrs: &[u32], colours: usize, behaviour: u32) -> W {
let mut b = W::default();
square(&mut b, 172);
b.bit(true).bit(false).bit(false).uint(0).uint(0);
uints(&mut b, &[0, 0, 0, 3, 0, 6, 0, 0, 0, 3, 0, 6, 0, 9]);
b.uint(1).uint(174);
uints(&mut b, attrs);
b.uint(0).uint(0).uint(0x2 | 0x4).uint(0);
uints(&mut b, &[1, 1, 4]);
b.uint(0).bit(colours > 0);
if colours > 0 {
b.bit(false).bit(false).put(0x10_2030, 24);
for _ in 1..colours {
b.bit(true);
}
}
if !attrs.is_empty() {
b.uint(behaviour);
}
b.uint(0);
wire(&mut b, false);
section(2, &b)
}
#[test]
fn face_vertex_colours_count_points_not_data() {
// A triangle plus a fan of 4 vertices = 7 points -> 7 colours.
let t = styled_face(&[], 7);
assert_eq!(mesh(&t[0]).triangles.len(), 3);
assert!(matches!(t[1], Tessellation::Wire(_)));
}
fn styles(attrs: &[u32]) -> Vec<(u32, u16)> {
let t = styled_face(attrs, 0);
assert!(matches!(t[1], Tessellation::Wire(_)));
mesh(&t[0]).triangle_styles.iter().map(|g| (g.style, g.behaviour)).collect()
}
#[test]
fn face_line_attributes_style_its_triangles() {
assert!(styles(&[]).is_empty());
assert_eq!(styles(&[5]), [(5, 0x30); 3]);
// One per entity: the triangle, then both triangles of the fan.
assert_eq!(styles(&[4, 7]), [(4, 0x30), (7, 0x30), (7, 0x30)]);
// An entity styled 0 inherits, as do entities past the list.
assert_eq!(styles(&[4, 0, 9]), [(4, 0x30), (0, 0x30), (0, 0x30)]);
}
#[test]
fn markup_is_read_past() {
let mut b = W::default();
b.uint(176).bit(false).uint(3);
for c in [1., 2., 3.] {
b.double(c);
}
uints(&mut b, &[6, 0]);
b.uint(1).string(Some("R1")).string(Some("label")).put(7, 8);
wire(&mut b, false);
let t = decode(&section(2, &b), &Schema::default(), 8137).unwrap();
assert_eq!(t[0], Tessellation::Markup);
assert!(matches!(t[1], Tessellation::Wire(_)));
}
#[test]
fn schema_fields_are_skipped_after_each_entity() {
// A newer producer added one UnsignedInteger to TESS_3D and one to TESS_Face.
let mut s = W::default();
s.uint(2).uint(172).uint(1).uint(3).uint(174).uint(1).uint(3);
let sb = s.bytes();
let schema = Schema::read(&mut BitReader::new(&sb)).unwrap();
let mut b = W::default();
square(&mut b, 172);
b.bit(true).bit(false).bit(false).uint(0).uint(0);
uints(&mut b, &[0, 0, 0, 3, 0, 6]);
b.uint(1).uint(174).uint(0).uint(0).uint(0).uint(0x2).uint(0);
uints(&mut b, &[1]);
b.uint(0).bit(false).uint(99); // the face's added field
b.uint(0).uint(77); // texture count, then TESS_3D's added field
wire(&mut b, false);
let t = decode(&section(2, &b), &schema, 8137).unwrap();
assert_eq!(mesh(&t[0]).triangles, [[0, 1, 2]]);
assert!(matches!(t[1], Tessellation::Wire(_)));
// Without the schema the same bytes do not decode to the same thing.
assert_ne!(decode(&section(2, &b), &Schema::default(), 8137).ok(), Some(t));
}
#[test]
fn attributes_names_and_user_data_are_read_past() {
let mut w = W::default();
w.uint(305).uint(1).uint(ATTRIBUTE);
w.bit(true).uint(2); // predefined title
w.uint(2);
w.bit(false).string(Some("k")).uint(4).string(Some("v"));
w.bit(true).uint(1).uint(5).int(-1).uint(9);
w.uint(42); // the attribute's schema-added field
w.bit(false).string(Some("tess")).uint(1);
wire(&mut w, false);
w.uint(5).put(0b10110, 5);
let mut sw = W::default();
sw.uint(1).uint(ATTRIBUTE).uint(1).uint(3);
let sb = sw.bytes();
let schema = Schema::read(&mut BitReader::new(&sb)).unwrap();
let bytes = w.bytes();
let mut ctx = Ctx::new(BitReader::new(&bytes), &schema, 8137);
let t = ctx.file_structure_tessellation().unwrap();
assert!(matches!(t[..], [Tessellation::Wire(_)]));
assert_eq!(ctx.name.as_deref(), Some("tess"));
assert_eq!(ctx.r.position(), w.len());
}
/// A one-triangle TESS_3D_Compressed. `full` takes every optional branch: stored normals,
/// colours, line attributes, texture, behaviours. Otherwise `three_t` picks the 3T edge form.
fn compressed(w: &mut W, v: u32, full: bool, three_t: bool) {
compressed_with_angles(w, v, full, three_t, 10);
}
/// [`compressed`] whose `full` form stores `angle_bits`-bit normal angles.
fn compressed_with_angles(w: &mut W, v: u32, full: bool, three_t: bool, angle_bits: u8) {
w.uint(173).bit(false).bit(true).double(0.001);
if v >= 7031 {
w.put(0, 32).put(0, 32).put(0, 32);
}
// point_array: nine 2-bit values.
w.bit(false).uint(9);
for _ in 0..9 {
w.put(2, 8);
}
for _ in 0..9 {
w.bit(false).bit(true);
}
// edge_status_array: the 3T form (Huffman) or the T form.
if full {
w.bit(true).huffman(2, 2, &[(0, 0b10, 2)], &[0, 0, 0]);
} else if three_t {
w.bit(false).uint(3).put(0, 8).put(0, 8).put(0, 8);
} else {
w.bit(false).uint(1).put(0, 8);
}
// triangle_face_array [0]. `full`: four references, so the flagless reference array is
// Huffman; else none.
w.bit(false).uint(1).put(1, 8).bit(false);
if full {
w.uint(4).put(0b1111, 4);
w.huffman(6, 2, &[(1, 0b10, 2), (0, 0b11, 2)], &[1, 0, 0, 0]);
w.put(0, 4);
} else {
w.uint(3).put(0, 3).uint(0);
}
if full {
w.bit(false).put(u64::from(angle_bits), 8).uint(3).put(0b101, 3);
w.bit(true).huffman(10, 2, &[(5, 0b10, 2)], &[5, 5]);
w.bit(true); // is_face_planar
w.bit(true).bit(true).bit(false).uint(5);
for c in [1, 255, 0, 0, 128] {
w.put(c, 8);
}
w.bit(true).bit(false);
} else {
w.bit(true).bit(false).double(0.5).put(0, 8);
w.bit(false).bit(false);
}
w.bit(false).uint(1).put(1, 8).put(0, 8); // line_attribute_array
if full {
w.bit(false).uint(1).put(0, 32).uint(32);
w.uint(1).put(1, 5).bit(true).double(0.5).uint(2);
w.put(0, 32).put(0, 32).bit(false).bit(true);
w.bit(true).bit(false).uint(1).put(1, 8);
} else {
w.bit(true).bit(false);
}
}
#[test]
fn a_compressed_mesh_is_read_to_its_end() {
for (full, three_t) in [(false, false), (false, true), (true, true)] {
for v in [7030, 7031, 8137] {
let mut b = W::default();
compressed(&mut b, v, full, three_t);
let indices = [0, 0, 0, 3, 0, 6, 0, 0, 0, 3, 0, 6, 0, 9];
tess_3d(&mut b, v, &Mesh { indices: &indices, faces: &[(0x2 | 0x4, 0, &[1, 1, 4])], ..Mesh::default() });
let w = section(2, &b);
let bytes = w.bytes();
let schema = Schema::default();
let mut ctx = Ctx::new(BitReader::new(&bytes), &schema, v);
let t = ctx.file_structure_tessellation().unwrap();
assert!(matches!(t[..], [Tessellation::Compressed { triangles: 1, .. }, Tessellation::Mesh(_)]), "full={full} v={v}: {t:?}");
assert_eq!(ctx.r.position(), w.len(), "full={full} v={v}");
}
}
}
#[test]
fn refusals_and_damage_are_errors() {
// Edge statuses neither T nor 3T long.
let mut c = W::default();
c.uint(173).bit(false).bit(true).double(0.001);
c.put(0, 32).put(0, 32).put(0, 32);
c.bit(false).uint(0).bit(false).uint(2).put(0, 16);
c.bit(false).uint(1).put(1, 8).bit(false);
assert!(matches!(decode(&section(1, &c), &Schema::default(), 8137), Err(PrcError::Malformed(_))));
// Optimised vertex colours.
let mut o = W::default();
square(&mut o, 175);
o.uint(0).bit(true).bit(false).bit(false).bit(true);
assert!(matches!(decode(&section(1, &o), &Schema::default(), 8137), Err(PrcError::Unsupported(_))));
// A point index that is not a multiple of 3, and one past the end.
for bad in [4, 12] {
let mut b = W::default();
tess_3d(&mut b, 8137, &Mesh { indices: &[0, 0, 0, bad, 0, 6], faces: &[(0x2, 0, &[1])], ..Mesh::default() });
assert!(matches!(decode(&section(1, &b), &Schema::default(), 8137), Err(PrcError::Malformed(_))));
}
// A fan whose count claims a billion points.
let mut b = W::default();
tess_3d(&mut b, 8137, &Mesh { indices: &[0, 0], faces: &[(0x4, 0, &[1, 0x3FFF_FFFF])], ..Mesh::default() });
assert!(decode(&section(1, &b), &Schema::default(), 8137).is_err());
// A tessellation count far past the data.
let mut w = W::default();
w.uint(305).uint(0).bit(true).uint(u32::MAX);
assert!(matches!(decode(&w, &Schema::default(), 8137), Err(PrcError::Truncated(_))));
// A wrong entity type where the section's own belongs.
let mut w = W::default();
w.uint(306);
assert!(matches!(decode(&w, &Schema::default(), 8137), Err(PrcError::Malformed(_))));
}
#[test]
fn every_truncation_of_a_section_is_an_error_not_a_panic() {
let mut b = W::default();
compressed(&mut b, 8137, true, true);
wire(&mut b, true);
let bytes = section(2, &b).bytes();
for end in 0..bytes.len() {
let cut = bytes.get(..end).unwrap();
// The zero padding of the last byte may still decode; anything shorter must not.
let _ = Ctx::new(BitReader::new(cut), &Schema::default(), 8137).file_structure_tessellation();
}
let cut = bytes.get(..bytes.len() / 2).unwrap();
assert!(Ctx::new(BitReader::new(cut), &Schema::default(), 8137).file_structure_tessellation().is_err());
}
/// A one-file-structure PRC stream whose tessellation section is `tess`, with an empty
/// globals section schema.
fn prc_file(tess: &[u8]) -> Vec<u8> {
let mut globals = W::default();
globals.uint(0);
prc_file_with(&globals.bytes(), tess)
}
/// As [`prc_file`] with the globals section `globals`.
fn prc_file_with(globals: &[u8], tess: &[u8]) -> Vec<u8> {
use std::io::Write as _;
const HEADER_LEN: usize = 107;
let zlib = |data: &[u8]| {
let mut e = flate2::write::ZlibEncoder::new(Vec::new(), flate2::Compression::default());
e.write_all(data).unwrap();
e.finish().unwrap()
};
let u32s = |out: &mut Vec<u8>, vs: &[u32]| vs.iter().for_each(|v| out.extend_from_slice(&v.to_le_bytes()));
let sections: [&[u8]; 5] = [globals, b"", tess, b"", b""];
let mut body = b"PRC".to_vec();
u32s(&mut body, &[8137, 8137, 5, 6, 7, 8, 0, 0, 0, 0, 0]);
let mut offs = vec![HEADER_LEN];
for s in sections {
offs.push(HEADER_LEN + body.len());
body.extend(zlib(s));
}
let mf_start = HEADER_LEN + body.len();
body.extend(zlib(b""));
let mf_end = HEADER_LEN + body.len();
let mut out = b"PRC".to_vec();
u32s(&mut out, &[8137, 8137, 1, 2, 3, 4, 0, 0, 0, 0, 1]);
u32s(&mut out, &[5, 6, 7, 8, 0, 6]);
u32s(&mut out, &offs.iter().map(|&o| u32::try_from(o).unwrap()).collect::<Vec<_>>());
u32s(&mut out, &[u32::try_from(mf_start).unwrap(), u32::try_from(mf_end).unwrap(), 0]);
out.extend(body);
out
}
#[test]
fn a_prc_file_yields_its_tessellations() {
let f = crate::PrcFile::parse(&prc_file(&textured_square().bytes())).unwrap();
let t = f.file_structures[0].tessellations().unwrap();
assert_eq!(mesh(&t[0]).triangles, [[0, 1, 2], [0, 2, 3]]);
}
#[test]
fn normal_angles_wider_than_16_bits_are_refused_by_name() {
let mut b = W::default();
compressed_with_angles(&mut b, 8137, true, true, 17);
assert!(matches!(decode(&section(1, &b), &Schema::default(), 8137), Err(PrcError::Malformed(m)) if m == "17-bit normal angles"));
}
/// An entity's counted array is charged against the reader's element allowance.
#[test]
fn counted_entity_arrays_are_charged_against_the_allowance() {
let mut w = W::default();
w.uint(3).uint(1).uint(2).uint(3);
let bytes = w.bytes();
let schema = Schema::default();
let read = |n| Ctx::new(BitReader::with_elements(&bytes, n), &schema, 8137).uints("indices");
assert!(matches!(read(2), Err(PrcError::TooManyElements { .. })));
assert_eq!(read(3).unwrap(), [1, 2, 3]);
}
#[test]
fn a_face_behaviour_wider_than_16_bits_is_malformed() {
let r = decode(&styled_face_section(&[1], 0, 0x1_0030), &Schema::default(), 8137);
assert!(matches!(r, Err(PrcError::Malformed(m)) if m == "face behaviour 65584 is wider than 16 bits"));
}
#[test]
fn coordinates_that_are_not_whole_points_are_malformed() {
let mut partial = SQUARE.to_vec();
partial.push(7.0);
let mut b = W::default();
let faces: &[(u32, u32, &[u32])] = &[(0x2, 0, &[1])];
tess_3d(&mut b, 8137, &Mesh { indices: &[0, 0, 0, 3, 0, 6], faces, coords: Some(&partial), ..Mesh::default() });
let r = decode(&section(1, &b), &Schema::default(), 8137);
assert!(matches!(r, Err(PrcError::Malformed(m)) if m == "13 coordinates are not whole points"));
// A partial last normal drops the stored normals, as a slot naming none does.
assert_eq!(stored_normals(&[0.0, 0.0, 1.0, 0.0], &[[0, 0, 0]], 1), (Vec::new(), Vec::new()));
}
/// Elements a tessellation section spends from a full allowance.
fn spent(section: &W) -> usize {
let bytes = section.bytes();
let schema = Schema::default();
let mut ctx = Ctx::new(BitReader::new(&bytes), &schema, 8137);
ctx.file_structure_tessellation().unwrap();
crate::MAX_DECODED_ELEMENTS - ctx.r.elements_left()
}
#[test]
fn faces_reusing_one_index_range_are_charged_for_each_triangle_they_make() {
const INDICES: [u32; 12] = [0, 0, 0, 3, 0, 6, 0, 0, 0, 6, 0, 9];
let square = |faces: &[(u32, u32, &[u32])]| {
let mut b = W::default();
tess_3d(&mut b, 8137, &Mesh { indices: &INDICES, faces, ..Mesh::default() });
spent(&section(1, &b))
};
let one = square(&[(0x2, 0, &[2])]);
let three = square(&[(0x2, 0, &[2]), (0x2, 0, &[2]), (0x2, 0, &[2])]);
// Per extra face: its count entry, its one data element and its two triangles, each
// 12 bytes of corners and 12 of normal slots.
assert_eq!(three - one, 2 * (2 + 2 * 4));
}
#[test]
fn reused_textured_faces_are_charged_for_every_corner_array() {
// The textured square, then one untextured triangle's normal and point slots.
const INDICES: [u32; 24] = [0, 0, 0, 0, 2, 3, 0, 4, 6, 0, 0, 0, 0, 4, 6, 0, 6, 9, 0, 0, 0, 3, 0, 6];
let square = |faces: &[(u32, u32, &[u32])], sets: u32| {
let mut b = W::default();
tess_3d(&mut b, 8137, &Mesh { indices: &INDICES, faces, textures: sets, uvs: &[0.0; 8], ..Mesh::default() });
spent(&section(1, &b))
};
let face: (u32, u32, &[u32]) = (0x200, 0, &[2]);
let untextured: (u32, u32, &[u32]) = (0x2, 18, &[1]);
let one = square(&[face], 1);
let three = square(&[face, face, face], 1);
// Per extra face: its count, its data element and two triangles of corners, normal slots
// and one texture set, 16 bytes a corner triple.
assert_eq!(three - one, 2 * (2 + 2 * 6));
// One textured face gives every triangle of the mesh a texture triple.
let mixed = square(&[face, untextured], 1);
assert_eq!(mixed - one, 2 + 6);
}
#[test]
fn a_face_is_charged_before_it_is_triangulated() {
// One face claiming a million triangles over a 12-entry index array.
const INDICES: [u32; 12] = [0, 0, 0, 3, 0, 6, 0, 0, 0, 6, 0, 9];
let mut b = W::default();
tess_3d(&mut b, 8137, &Mesh { indices: &INDICES, faces: &[(0x2, 0, &[1_000_000])], ..Mesh::default() });
let bytes = section(1, &b).bytes();
let schema = Schema::default();
let r = Ctx::new(BitReader::with_elements(&bytes, 1000), &schema, 8137).file_structure_tessellation();
assert!(matches!(r, Err(PrcError::TooManyElements { .. })), "{r:?}");
}
#[test]
fn the_globals_schema_and_the_tessellations_share_one_allowance() {
// A schema of one entry with three tokens: four elements.
let mut globals = W::default();
globals.uint(1).uint(999).uint(3).uint(0).uint(0).uint(0);
let tess = textured_square();
let f = crate::PrcFile::parse(&prc_file_with(&globals.bytes(), &tess.bytes())).unwrap();
let need = spent(&tess) + 4;
let within = |elements| f.file_structures[0].tessellations_within(crate::bits::Budget { elements, ..crate::bits::Budget::FULL });
assert!(within(need).is_ok());
assert!(matches!(within(need - 1), Err(PrcError::TooManyElements { .. })));
}
crates/prc/src/tess/triangulate.rs
+282
View File
@@ -0,0 +1,282 @@
//! A `TESS_Face`'s triangulated data turned into triangles [WD 7.8.5.5, 7.8.6].
use super::TriangleStyle;
use crate::PrcError;
use crate::entity::malformed;
/// A fan/strip count's point-count bits; bit 30 is `NORMAL_Single` [WD 7.8.6.2].
const COUNT_MASK: u32 = 0x3FFF_FFFF;
const NORMAL_SINGLE: u32 = 0x4000_0000;
/// Texture-coordinate sets a face may carry. Each set costs a slot per point and a corner
/// triple per triangle of the whole mesh, so the count is capped.
pub(super) const MAX_TEXTURE_SETS: usize = 8;
pub(super) struct Face {
pub(super) flags: u32,
pub(super) start: usize,
pub(super) data: Vec<u32>,
pub(super) textures: usize,
/// `line_attributes`, each a style index + 1: none = the owner's graphics, one = the
/// whole face's, more = one per triangulation entity [WD 7.8.6].
pub(super) styles: Vec<u32>,
/// The behaviour bits read when `styles` is not empty.
pub(super) behaviour: u16,
}
/// A `used_entities_flag` block's shape [WD 7.8.5.5].
#[derive(Clone, Copy)]
enum Shape {
Triangles,
Fan,
Strip,
}
/// One `used_entities_flag` block.
#[derive(Clone, Copy)]
struct Block {
bit: u32,
shape: Shape,
/// One normal per entity rather than per point.
one_normal: bool,
textured: bool,
}
const fn block(bit: u32, shape: Shape, one_normal: bool, textured: bool) -> Block {
Block { bit, shape, one_normal, textured }
}
/// The blocks in stream order, low bit first [WD 7.8.5.5].
const BLOCKS: [Block; 12] = [
block(0x0002, Shape::Triangles, false, false),
block(0x0004, Shape::Fan, false, false),
block(0x0008, Shape::Strip, false, false),
block(0x0020, Shape::Triangles, true, false),
block(0x0040, Shape::Fan, true, false),
block(0x0080, Shape::Strip, true, false),
block(0x0200, Shape::Triangles, false, true),
block(0x0400, Shape::Fan, false, true),
block(0x0800, Shape::Strip, false, true),
block(0x2000, Shape::Triangles, true, true),
block(0x4000, Shape::Fan, true, true),
block(0x8000, Shape::Strip, true, true),
];
/// One triangulation entity's index slots: per point its position, normal slot (when the
/// array stores normals) and texture slots.
#[derive(Default)]
struct Slots {
verts: Vec<u32>,
normals: Vec<u32>,
/// Per texture set, each point's slot.
textures: Vec<Vec<u32>>,
}
/// What a mesh's triangles carry besides positions, built in step with them: corner normal
/// slots and, per texture set, corner texture slots (`None` for a triangle whose face stores
/// fewer sets).
#[derive(Default)]
pub(super) struct Corners {
pub(super) normals: Vec<[u32; 3]>,
pub(super) textures: Vec<Vec<Option<[u32; 3]>>>,
}
impl Face {
/// Entity sizes per set block, from `TriangulatedData` [WD 7.8.6]. A triangle block is
/// one size word (its triangle count); fans and strips list a vertex count each.
fn entities(&self) -> Result<Vec<(Block, Vec<u32>)>, PrcError> {
let mut d = self.data.iter().copied();
let mut next = || d.next().ok_or_else(|| malformed("triangulated data ends early".into()));
let mut out = Vec::new();
for b in BLOCKS {
if self.flags & b.bit == 0 {
continue;
}
let sizes = match b.shape {
Shape::Triangles => vec![next()?],
Shape::Fan | Shape::Strip => {
let n = next()? as usize;
if n > self.data.len() {
return Err(malformed("triangulated data ends early".into()));
}
(0..n).map(|_| next()).collect::<Result<_, _>>()?
}
};
out.push((b, sizes));
}
Ok(out)
}
/// Points the face's index slots name: the vertex-colour count (pdf-issues #820).
pub(super) fn point_count(&self) -> Result<usize, PrcError> {
let mut n = 0usize;
for (b, sizes) in self.entities()? {
for s in sizes {
let s = (s & COUNT_MASK) as usize;
n = n.saturating_add(if matches!(b.shape, Shape::Triangles) { s.saturating_mul(3) } else { s });
}
}
Ok(n)
}
/// Triangles [`Self::triangulate`] makes: one per triangle-block count, two fewer than the
/// points of each fan and strip.
pub(super) fn triangle_count(&self) -> Result<usize, PrcError> {
let mut n = 0usize;
for (b, sizes) in self.entities()? {
for s in sizes {
let s = (s & COUNT_MASK) as usize;
n = n.saturating_add(if matches!(b.shape, Shape::Triangles) { s } else { s.saturating_sub(2) });
}
}
Ok(n)
}
/// Texture sets the face's triangles carry: its count when one of its blocks is textured,
/// at most [`MAX_TEXTURE_SETS`] (a face past it is refused when triangulated).
pub(super) fn texture_sets(&self) -> usize {
if BLOCKS.iter().any(|b| b.textured && self.flags & b.bit != 0) { self.textures.min(MAX_TEXTURE_SETS) } else { 0 }
}
/// Emit the face's triangles into `out`; `normals` = the index array stores normal slots,
/// in which case each triangle's corner normal slots go to `corners`, as do its corner
/// texture slots. Returns the triangles each triangulation entity emitted, in order: one
/// entity per triangle of a triangle block, per fan, per strip [WD 7.8.6].
pub(super) fn triangulate(
&self,
indices: &[u32],
normals: bool,
n_points: usize,
out: &mut Vec<[u32; 3]>,
corners: &mut Corners,
) -> Result<Vec<usize>, PrcError> {
if self.textures > MAX_TEXTURE_SETS {
return Err(malformed(format!("{} texture-coordinate sets on a face", self.textures)));
}
let mut entities = Vec::new();
let mut slots = indices.get(self.start..).unwrap_or(&[]).iter().copied();
for (b, sizes) in self.entities()? {
let t = if b.textured { self.textures } else { 0 };
for word in sizes {
let count = (word & COUNT_MASK) as usize;
// Points in this entity, and whether each carries its own normal slot.
let (points, per_point_normal) = match b.shape {
Shape::Triangles => (count.saturating_mul(3), !b.one_normal),
Shape::Fan | Shape::Strip => (count, !b.one_normal || word & NORMAL_SINGLE == 0),
};
if points.saturating_mul(t.saturating_add(1)) > indices.len() {
return Err(malformed("face runs past the triangulated index array".into()));
}
let s = read_slots(&mut slots, b.shape, points, t, normals.then_some(per_point_normal), n_points)?;
let made = emit(b.shape, &s, out, corners);
match b.shape {
Shape::Triangles => entities.extend(std::iter::repeat_n(1, made)),
Shape::Fan | Shape::Strip => entities.push(made),
}
}
}
Ok(entities)
}
/// Append one [`TriangleStyle`] per triangle of the face, whose entities emitted
/// `entities[i]` triangles each. Entities past the face's styles inherit (style 0).
pub(super) fn styles_into(&self, entities: &[usize], out: &mut Vec<TriangleStyle>) {
let whole = match self.styles.as_slice() {
[] => Some(0),
[one] => Some(*one),
_ => None,
};
for (i, &n) in entities.iter().enumerate() {
let style = whole.unwrap_or_else(|| self.styles.get(i).copied().unwrap_or(0));
out.extend(std::iter::repeat_n(TriangleStyle { style, behaviour: self.behaviour }, n));
}
}
}
/// The 8-byte elements of [`crate::MAX_DECODED_ELEMENTS`] one triangle holds: its corners
/// (12 bytes), its normal-slot corners when the index array stores them (12), a corner triple
/// per texture set (16 each) and its style when the mesh is styled (8).
pub(super) fn triangle_elements(normals: bool, sets: usize, styled: bool) -> usize {
let normals = if normals { 2 } else { 0 };
2usize.saturating_add(normals).saturating_add(sets.saturating_mul(2)).saturating_add(usize::from(styled))
}
/// One entity's `points` index slots. `normals` is `None` when the array stores no normal
/// slots, else whether every point has its own (rather than one per entity).
fn read_slots(
slots: &mut impl Iterator<Item = u32>,
shape: Shape,
points: usize,
texture_sets: usize,
normals: Option<bool>,
n_points: usize,
) -> Result<Slots, PrcError> {
let mut take = || slots.next().ok_or_else(|| malformed("face runs past the triangulated index array".into()));
// The caller bounded points * (texture_sets + 1) by the index array's length.
let mut s = Slots { textures: vec![Vec::with_capacity(points); texture_sets], ..Slots::default() };
let mut current = 0;
for k in 0..points {
let new_entity = match shape {
Shape::Triangles => k % 3 == 0,
Shape::Fan | Shape::Strip => k == 0,
};
if let Some(per_point) = normals {
if per_point || new_entity {
current = take()?;
}
s.normals.push(current);
}
for set in &mut s.textures {
set.push(take()?);
}
let p = take()?;
if !p.is_multiple_of(3) || p as usize / 3 >= n_points {
return Err(malformed(format!("point index {p} is not a point")));
}
s.verts.push(p / 3);
}
Ok(s)
}
/// Append the triangles of one entity's `slots` to `out` and `corners`, keeping every
/// texture set as long as `out`. Returns how many it made.
fn emit(shape: Shape, slots: &Slots, out: &mut Vec<[u32; 3]>, corners: &mut Corners) -> usize {
let before = out.len();
assemble(shape, &slots.verts, out);
assemble(shape, &slots.normals, &mut corners.normals);
let made = out.len().saturating_sub(before);
while corners.textures.len() < slots.textures.len() {
corners.textures.push(vec![None; before]);
}
for (k, set) in corners.textures.iter_mut().enumerate() {
match slots.textures.get(k) {
Some(own) => {
let mut tris = Vec::with_capacity(made);
assemble(shape, own, &mut tris);
set.extend(tris.into_iter().map(Some));
}
None => set.extend(std::iter::repeat_n(None, made)),
}
}
made
}
/// Append the triangles `shape` makes of `verts`.
fn assemble(shape: Shape, verts: &[u32], out: &mut Vec<[u32; 3]>) {
match shape {
Shape::Triangles => out.extend(verts.as_chunks::<3>().0.iter().copied()),
Shape::Fan => {
if let Some((&c, rim)) = verts.split_first() {
out.extend(rim.windows(2).filter_map(|w| match w {
[a, b] => Some([c, *a, *b]),
_ => None,
}));
}
}
Shape::Strip => out.extend(verts.windows(3).enumerate().filter_map(|(k, w)| match w {
[a, b, c] if k % 2 == 0 => Some([*a, *b, *c]),
[a, b, c] => Some([*b, *a, *c]),
_ => None,
})),
}
}
crates/prc/src/testw.rs
+166
View File
@@ -0,0 +1,166 @@
//! Test-only PRC bit writer: the inverse of [`crate::BitReader`].
#![allow(clippy::expect_used)]
use crate::acof;
/// An MSB-first bit sink for building test streams.
#[derive(Debug, Default, Clone)]
pub(crate) struct W {
bits: Vec<bool>,
}
impl W {
/// The low `n` bits of `v` (`n` ≤ 64), most significant first.
pub(crate) fn put(&mut self, v: u64, n: u32) -> &mut Self {
for i in (0..n).rev() {
self.bits.push((v >> i) & 1 == 1);
}
self
}
/// One bit; a PRC `Boolean`.
pub(crate) fn bit(&mut self, b: bool) -> &mut Self {
self.bits.push(b);
self
}
/// Bits written so far.
pub(crate) fn len(&self) -> usize {
self.bits.len()
}
/// Every bit of `other`, unaligned.
pub(crate) fn append(&mut self, other: &Self) -> &mut Self {
self.bits.extend_from_slice(&other.bits);
self
}
/// An `UnsignedInteger` [WD 11.10].
pub(crate) fn uint(&mut self, mut v: u32) -> &mut Self {
while v != 0 {
self.bit(true).put(u64::from(v & 0xff), 8);
v >>= 8;
}
self.bit(false)
}
/// An `Integer` [WD 11.11]: two's-complement groups, low first, each followed by a
/// continue bit.
pub(crate) fn int(&mut self, v: i32) -> &mut Self {
if v == 0 {
return self.bit(false);
}
self.bit(true);
let mut v = i64::from(v);
loop {
let group = v & 0xff;
self.put(group.cast_unsigned(), 8);
v >>= 8;
let done = (v == 0 && group & 0x80 == 0) || (v == -1 && group & 0x80 != 0);
self.bit(!done);
if done {
return self;
}
}
}
/// A `String` [WD 11.4]: presence bit, byte count, raw UTF-8 bytes.
pub(crate) fn string(&mut self, s: Option<&str>) -> &mut Self {
let Some(s) = s else {
return self.bit(false);
};
self.bit(true).uint(u32::try_from(s.len()).expect("a short test string"));
for b in s.bytes() {
self.put(u64::from(b), 8);
}
self
}
/// A finite `Double` [WD 11.17]: zero as the two-bit zero code; anything else as its
/// exponent row, the sign, then the mantissa as literal bytes.
pub(crate) fn double(&mut self, v: f64) -> &mut Self {
if v == 0.0 {
return self.put(0b01, 2);
}
let bits = v.to_bits();
let exponent = u32::try_from((bits >> 52) & 0x7ff).expect("11 bits");
let (n, c) = acof::exponent_code(exponent).expect("the Double table has a row per exponent");
let le = bits.to_le_bytes();
self.put(u64::from(c), n).bit(v < 0.0).bit(true).put(u64::from(le[6] & 0x0f), 4);
for b in le[..6].iter().rev() {
self.bit(true).put(u64::from(*b), 8);
}
self
}
/// A Huffman container [WD 12.2]: `leaves` are `(symbol, stored code, length)`, each value
/// is emitted as its leaf's code.
pub(crate) fn huffman(&mut self, nbits: u32, len_width: u32, leaves: &[(u32, u32, u32)], values: &[i32]) -> &mut Self {
let mask = (1u32 << nbits) - 1;
let codes: Vec<(u32, u32)> = values
.iter()
.map(|&v| {
let l = leaves.iter().find(|l| l.0 & mask == v.cast_unsigned() & mask).expect("a leaf per value");
(l.1, l.2)
})
.collect();
self.huffman_raw(nbits, len_width, leaves, &codes)
}
/// As [`Self::huffman`] with each element's `(code, length)` given.
pub(crate) fn huffman_raw(&mut self, nbits: u32, len_width: u32, leaves: &[(u32, u32, u32)], codes: &[(u32, u32)]) -> &mut Self {
let mut blob = Self::huffman_head(nbits, len_width, leaves);
lsb(&mut blob, u32::try_from(codes.len()).expect("a short test array"), 32);
for &(c, l) in codes {
for i in (0..l).rev() {
blob.push((c >> i) & 1 == 1);
}
}
self.huffman_words(blob)
}
/// A Huffman container whose element count is `count` with no elements written.
pub(crate) fn huffman_count(&mut self, nbits: u32, len_width: u32, leaves: &[(u32, u32, u32)], count: u32) -> &mut Self {
let mut blob = Self::huffman_head(nbits, len_width, leaves);
lsb(&mut blob, count, 32);
self.huffman_words(blob)
}
fn huffman_head(nbits: u32, len_width: u32, leaves: &[(u32, u32, u32)]) -> Vec<bool> {
let mut blob = Vec::new();
lsb(&mut blob, u32::try_from(leaves.len()).expect("a short test table"), nbits + 1);
lsb(&mut blob, len_width, 8);
for &(s, c, l) in leaves {
lsb(&mut blob, s, nbits);
lsb(&mut blob, l, len_width);
lsb(&mut blob, c, l);
}
blob
}
/// The payload as whole 32-bit words of LSB-first bytes, then the last word's used bits.
fn huffman_words(&mut self, mut blob: Vec<bool>) -> &mut Self {
let bits = blob.len();
let words = bits.div_ceil(32);
blob.resize(words * 32, false);
self.uint(u32::try_from(words).expect("a short test payload"));
for byte in blob.chunks(8) {
let b = byte.iter().enumerate().fold(0u64, |a, (i, &x)| a | (u64::from(x) << i));
self.put(b, 8);
}
self.uint(u32::try_from(bits - (words - 1) * 32).expect("at most 32"))
}
/// The bits packed MSB-first, the last byte zero-padded.
pub(crate) fn bytes(&self) -> Vec<u8> {
self.bits.chunks(8).map(|c| c.iter().enumerate().fold(0u8, |a, (i, &b)| a | (u8::from(b) << (7 - i)))).collect()
}
}
/// The low `n` bits of `v`, least significant first.
fn lsb(blob: &mut Vec<bool>, v: u32, n: u32) {
for i in 0..n {
blob.push((v >> i) & 1 == 1);
}
}
crates/prc/src/tree/markup.rs
+199
View File
@@ -0,0 +1,199 @@
//! What a tree carries beside its geometry, read past and not modelled: markup data (PMI)
//! and views [WD 7.3.10.4, 7.7], and a scene's lights and clipping planes [WD 7.5.15-7.5.18,
//! 7.11.13]. The tree section has no length to skip by, so each is read field by field.
use super::{
AMBIENT_LIGHT, ANNOTATION_ITEM, ANNOTATION_REFERENCE, ANNOTATION_SET, DIRECTIONAL_LIGHT, LIGHT_INTENSITY_FROM, MARKUP_LINKED_ITEM, MAX_DEPTH,
MKP_LEADER, MKP_MARKUP, MKP_VIEW, POINT_LIGHT, SPOT_LIGHT, SURF_PLANE, VIEW_FLAGS_FROM,
};
use crate::PrcError;
use crate::entity::{Ctx, malformed};
impl Ctx<'_, '_> {
/// `MarkupData` [WD 7.3.10.4]: linked items, leaders, markups, then annotation entities.
pub(super) fn markup_data(&mut self) -> Result<(), PrcError> {
let n = self.count(1, "markup linked items")?;
for _ in 0..n {
self.markup_linked_item()?;
}
let n = self.count(1, "leaders")?;
for _ in 0..n {
self.leader()?;
}
let n = self.count(1, "markups")?;
for _ in 0..n {
self.mkp_markup()?;
}
let n = self.count(1, "annotation entities")?;
for _ in 0..n {
self.annotation_entity(0)?;
}
Ok(())
}
/// A counted list of `MKP_View`s.
pub(super) fn views(&mut self) -> Result<(), PrcError> {
let n = self.count(1, "views")?;
for _ in 0..n {
self.view()?;
}
Ok(())
}
/// A counted list of `ReferenceOnPRCBase`s.
fn references(&mut self, what: &'static str) -> Result<(), PrcError> {
let n = self.count(1, what)?;
for _ in 0..n {
self.reference_on_prc_base()?;
}
Ok(())
}
/// `MISC_MarkupLinkedItem` (204) [WD 7.4.5].
// prc-rs: a `has_reference_data` flag and its reference data follow the content entity
// reference (pdf-issues #722).
fn markup_linked_item(&mut self) -> Result<(), PrcError> {
self.expect_type(MARKUP_LINKED_ITEM)?;
self.base_with_graphics()?;
self.r.unsigned_integer()?; // local coordinate system + 1
if self.r.bit()? {
self.reference_data()?;
}
if self.r.bit()? {
self.reference_data()?;
}
for _ in 0..4 {
self.r.bit()?; // show and delete, markup and leader
}
self.schema.skip_added_fields(MARKUP_LINKED_ITEM, &mut self.r)?;
self.user_data()
}
/// `MKP_Leader` (503) [WD 7.7.5; pdf-issues #698].
// prc-rs: the leader's field order.
fn leader(&mut self) -> Result<(), PrcError> {
self.expect_type(MKP_LEADER)?;
self.base_with_graphics()?;
for _ in 0..2 {
if self.r.bit()? {
self.reference_on_prc_base()?; // first, second linked item
}
}
self.r.unsigned_integer()?; // tessellation + 1
self.schema.skip_added_fields(MKP_LEADER, &mut self.r)?;
self.user_data()
}
/// `MKP_Markup` (502) [WD 7.7.4].
// prc-rs: the markup's field order.
fn mkp_markup(&mut self) -> Result<(), PrcError> {
self.expect_type(MKP_MARKUP)?;
self.base_with_graphics()?;
self.r.unsigned_integer()?; // type
self.r.unsigned_integer()?; // subtype
self.references("markup linked items")?;
self.references("markup leaders")?;
self.r.unsigned_integer()?; // tessellation + 1
self.schema.skip_added_fields(MKP_MARKUP, &mut self.r)?;
self.user_data()
}
/// An annotation item (504), set (505) or reference (506) [WD 7.7.6-7.7.8]; sets nest.
// prc-rs: the annotation entities' field orders.
fn annotation_entity(&mut self, depth: usize) -> Result<(), PrcError> {
if depth > MAX_DEPTH {
return Err(malformed("annotation sets nest too deep".into()));
}
let t = self.r.unsigned_integer()?;
if !matches!(t, ANNOTATION_ITEM | ANNOTATION_SET | ANNOTATION_REFERENCE) {
return Err(malformed(format!("entity type {t} as an annotation")));
}
self.base_with_graphics()?;
match t {
ANNOTATION_ITEM => self.reference_on_prc_base()?,
ANNOTATION_SET => {
let n = self.count(1, "annotation set")?;
for _ in 0..n {
self.annotation_entity(depth + 1)?;
}
}
_ => self.references("annotation reference")?,
}
self.schema.skip_added_fields(t, &mut self.r)?;
self.user_data()
}
/// `MKP_View` (501) [WD 7.7.3].
// prc-rs: the view's field order, and its flags, linked items and filters from version
// 8137.
fn view(&mut self) -> Result<(), PrcError> {
self.expect_type(MKP_VIEW)?;
self.base_with_graphics()?;
self.references("view annotations")?;
self.plane()?;
if self.r.bit()? {
self.scene_display_parameters()?;
}
if self.version >= VIEW_FLAGS_FROM {
for _ in 0..3 {
self.r.bit()?; // annotation view, default view, direction
}
self.references("view linked items")?;
let n = self.count(1, "view filters")?;
for _ in 0..n {
self.filter()?;
}
}
self.schema.skip_added_fields(MKP_VIEW, &mut self.r)?;
self.user_data()
}
/// `SURF_Plane` (86) [WD 7.11.13; pdf-issues #658]: `ContentSurface` [WD 7.11.3.2], a
/// `Transformation3D` with no presence flag, the `Domain` [WD 8.2.4] and the
/// parameterisation's four coefficients.
// prc-rs: the plane's field order.
pub(super) fn plane(&mut self) -> Result<(), PrcError> {
self.expect_type(SURF_PLANE)?;
if self.r.bit()? {
self.content_prc_base()?; // base geometry: attributes and name
self.r.unsigned_integer()?; // identifier
}
self.r.unsigned_integer()?; // extend type
self.transformation_3d()?;
for _ in 0..8 {
self.r.double()?; // domain (4), coefficients (4)
}
self.schema.skip_added_fields(SURF_PLANE, &mut self.r)
}
/// A light (731-734) [WD 7.5.15-7.5.18].
// prc-rs: the lights' field orders, and a directional light's intensity from version 8030
// (pdf-issues #745).
pub(super) fn light(&mut self) -> Result<(), PrcError> {
let t = self.r.unsigned_integer()?;
if !(AMBIENT_LIGHT..=SPOT_LIGHT).contains(&t) {
return Err(malformed(format!("entity type {t} as a light")));
}
self.content_prc_ref_base()?;
for _ in 0..3 {
self.r.unsigned_integer()?; // ambient, diffuse, specular colour + 1
}
if matches!(t, POINT_LIGHT | SPOT_LIGHT) {
self.vector3()?; // location
for _ in 0..3 {
self.r.double()?; // attenuation
}
}
if matches!(t, DIRECTIONAL_LIGHT | SPOT_LIGHT) {
self.vector3()?; // direction
}
if t == DIRECTIONAL_LIGHT && self.version >= LIGHT_INTENSITY_FROM {
self.r.double()?;
}
if t == SPOT_LIGHT {
self.r.double()?; // fall-off angle
self.r.double()?; // fall-off exponent
}
self.schema.skip_added_fields(t, &mut self.r)
}
}
crates/prc/src/tree/markup_tests.rs
+280
View File
@@ -0,0 +1,280 @@
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use super::tests::{Occ, PLAIN, S_RED, base, graphics, part_with, plate, ref_base, single};
use crate::PrcError;
use crate::bits::BitReader;
use crate::entity::Ctx;
use crate::testw::W;
use crate::{Schema, Tessellation};
/// Read after each entity, to show it was read to its last bit and no further.
const SENTINEL: u32 = 0x5A5A;
/// Runs `read` over `w` then the sentinel, at authoring version `version`.
fn read_at(w: &W, version: u32, read: impl FnOnce(&mut Ctx<'_, '_>) -> Result<(), PrcError>) -> Result<(), PrcError> {
let mut all = W::default();
all.append(w).uint(SENTINEL);
let bytes = all.bytes();
let schema = Schema::default();
let mut ctx = Ctx::new(BitReader::new(&bytes), &schema, version);
read(&mut ctx)?;
assert_eq!(ctx.r.unsigned_integer()?, SENTINEL, "read past the wrong number of bits");
Ok(())
}
fn read(w: &W, read: impl FnOnce(&mut Ctx<'_, '_>) -> Result<(), PrcError>) -> Result<(), PrcError> {
read_at(w, 8137, read)
}
/// Each truncation of `w` is an error, never a panic.
fn truncations_fail(w: &W, read: impl Fn(&mut Ctx<'_, '_>) -> Result<(), PrcError>) {
let bytes = w.bytes();
let schema = Schema::default();
for end in 0..bytes.len().saturating_sub(1) {
let mut ctx = Ctx::new(BitReader::new(&bytes[..end]), &schema, 8137);
assert!(read(&mut ctx).is_err(), "cut at {end}");
}
}
fn reference(w: &mut W, uid: u32) {
w.uint(205).uint(237).bit(true).uint(uid);
}
fn markup_data(linked: &[W], leaders: &[W], markups: &[W], annotations: &[W]) -> W {
let mut w = W::default();
for list in [linked, leaders, markups, annotations] {
w.uint(u32::try_from(list.len()).unwrap());
for e in list {
w.append(e);
}
}
w
}
fn linked_item() -> W {
let mut w = W::default();
w.uint(204);
graphics(&mut w, None, 1, PLAIN);
w.uint(0).bit(true);
reference(&mut w, 7);
w.bit(true).uint(206).uint(149).bit(true).bit(true).uint(1).uint(1).uint(1).uint(0);
w.bit(true).bit(false).bit(true).bit(false).uint(0);
w
}
fn leader() -> W {
let mut w = W::default();
w.uint(503);
graphics(&mut w, None, 2, PLAIN);
w.bit(true);
reference(&mut w, 3);
w.bit(false).uint(4).uint(0);
w
}
fn markup() -> W {
let mut w = W::default();
w.uint(502);
graphics(&mut w, Some("Note"), 3, PLAIN);
w.uint(1).uint(2).uint(1);
reference(&mut w, 7);
w.uint(2);
reference(&mut w, 2);
reference(&mut w, 2);
w.uint(3).uint(0);
w
}
fn annotation(t: u32, inner: impl FnOnce(&mut W)) -> W {
let mut w = W::default();
w.uint(t);
graphics(&mut w, None, 4, PLAIN);
inner(&mut w);
w.uint(0);
w
}
fn annotation_item() -> W {
annotation(504, |w| reference(w, 3))
}
fn annotation_set(members: &[W]) -> W {
annotation(505, |w| {
w.uint(u32::try_from(members.len()).unwrap());
for m in members {
w.append(m);
}
})
}
fn annotation_reference() -> W {
annotation(506, |w| {
w.uint(1);
reference(w, 3);
})
}
fn plane(w: &mut W) {
w.uint(86).bit(true);
base(w, Some("Front"));
w.uint(9).uint(0).put(0x01, 8);
for v in [1., 2., 3., 0., 0., 1., 1., 1., 1., 0., 0.] {
w.double(v);
}
}
fn light(t: u32) -> W {
let mut w = W::default();
w.uint(t);
ref_base(&mut w, None, 5);
w.uint(1).uint(2).uint(3);
let doubles = match t {
732 => 6,
733 => 4,
734 => 11,
_ => 0,
};
for _ in 0..doubles {
w.double(0.5);
}
w
}
/// A scene with `lights` and `planes` clipping planes; `is_absolute` is written from 8137.
fn scene(lights: &[W], planes: usize, version: u32) -> W {
let mut w = W::default();
w.uint(741);
ref_base(&mut w, None, 6);
w.bit(true).uint(u32::try_from(lights.len()).unwrap());
for l in lights {
w.append(l);
}
w.bit(false).bit(false).uint(u32::try_from(planes).unwrap());
for _ in 0..planes {
plane(&mut w);
}
w.uint(0).uint(0).uint(0);
if version >= 8137 {
w.bit(true);
}
w
}
fn filter(w: &mut W) {
w.uint(320);
ref_base(w, None, 8);
w.bit(true).bit(true).uint(0).bit(true).uint(0).uint(0);
}
fn view(version: u32) -> W {
let mut w = W::default();
w.uint(501);
graphics(&mut w, Some("Top"), 7, PLAIN);
w.uint(1);
reference(&mut w, 3);
plane(&mut w);
w.bit(true).append(&scene(&[light(731)], 1, version));
if version >= 8137 {
w.bit(true).bit(false).bit(true).uint(1);
reference(&mut w, 7);
w.uint(1);
filter(&mut w);
}
w.uint(0);
w
}
fn views(vs: &[W]) -> W {
let mut w = W::default();
w.uint(u32::try_from(vs.len()).unwrap());
for v in vs {
w.append(v);
}
w
}
#[test]
fn a_markup_linked_item_is_read_past() {
let w = markup_data(&[linked_item()], &[], &[], &[]);
read(&w, |c| c.markup_data()).unwrap();
truncations_fail(&w, |c| c.markup_data());
}
#[test]
fn a_leader_is_read_past() {
let w = markup_data(&[], &[leader()], &[], &[]);
read(&w, |c| c.markup_data()).unwrap();
truncations_fail(&w, |c| c.markup_data());
}
#[test]
fn a_markup_is_read_past() {
let w = markup_data(&[], &[], &[markup()], &[]);
read(&w, |c| c.markup_data()).unwrap();
truncations_fail(&w, |c| c.markup_data());
}
#[test]
fn annotation_items_sets_and_references_are_read_past() {
let set = annotation_set(&[annotation_item(), annotation_set(&[annotation_reference()])]);
let w = markup_data(&[], &[], &[], &[annotation_item(), set, annotation_reference()]);
read(&w, |c| c.markup_data()).unwrap();
truncations_fail(&w, |c| c.markup_data());
}
#[test]
fn annotation_sets_nested_past_the_ceiling_are_an_error() {
let mut e = annotation_item();
for _ in 0..=super::MAX_DEPTH {
e = annotation_set(&[e]);
}
let w = markup_data(&[], &[], &[], &[e]);
assert!(matches!(read(&w, |c| c.markup_data()), Err(PrcError::Malformed(_))));
}
#[test]
fn an_annotation_of_another_type_is_an_error() {
let w = markup_data(&[], &[], &[], &[annotation(502, |_| {})]);
assert!(matches!(read(&w, |c| c.markup_data()), Err(PrcError::Malformed(_))));
}
#[test]
fn a_view_is_read_past_with_its_flags_only_from_8137() {
let w = views(&[view(8137)]);
read(&w, |c| c.views()).unwrap();
truncations_fail(&w, |c| c.views());
read_at(&views(&[view(8030)]), 8030, |c| c.views()).unwrap();
}
#[test]
fn scene_lights_of_each_kind_are_read_past() {
let w = scene(&[light(731), light(732), light(733), light(734)], 0, 8137);
read(&w, |c| c.scene_display_parameters()).unwrap();
truncations_fail(&w, |c| c.scene_display_parameters());
let mut old = W::default();
old.uint(733);
ref_base(&mut old, None, 5);
old.uint(1).uint(2).uint(3).double(0.).double(0.).double(1.);
read_at(&old, 8020, |c| c.light()).unwrap();
}
#[test]
fn scene_clipping_planes_are_read_past() {
let w = scene(&[], 2, 8137);
read(&w, |c| c.scene_display_parameters()).unwrap();
truncations_fail(&w, |c| c.scene_display_parameters());
}
#[test]
fn a_tree_with_markups_and_views_still_places_its_parts() {
let mut tail = markup_data(&[linked_item()], &[leader()], &[markup()], &[annotation_set(&[annotation_item()])]);
tail.append(&views(&[view(8137)]));
let part = part_with(Some("Plate"), PLAIN, 1, |w| super::tests::poly_item(w, 7, 0, 1, (S_RED, super::SHOW)), &tail);
let occs = [Occ { name: Some("Asm"), sons: vec![1], markups: Some(tail.clone()), ..Occ::default() }, Occ { part: 1, ..Occ::default() }];
let f = single(&[part, plate(S_RED)], &occs);
let nodes = f.model_tree().unwrap();
assert_eq!(nodes.len(), 2);
let p = f.placements().unwrap();
assert_eq!(p.len(), 1);
assert!(matches!(f.file_structures[0].tessellations().unwrap().first(), Some(Tessellation::Mesh(_))));
}
crates/prc/src/tree/mod.rs
+329
View File
@@ -0,0 +1,329 @@
//! The product tree: the tree section (`FileStructureTree`, 304), the globals' styles and
//! coordinate systems (303) and the model file (301), walked into placed tessellations
//! [WD 7.3.3-7.3.11, 7.5, 7.6].
//!
//! Markups (PMI), views, scene lights and clipping planes are read past and not modelled.
// prc-rs: where the working draft leaves an entity's field order open, the order here is
// prc-rs's format description's; each such entity's reader carries its own marker.
use std::sync::Arc;
use crate::bits::{BitReader, Budget};
use crate::container::offset;
use crate::entity::{Ctx, malformed};
use crate::geometry::{Matrix, Vec3};
use crate::{PrcError, PrcFile, Schema, SectionKind, UniqueId};
mod markup;
mod node;
mod overrides;
mod read;
mod style;
mod walk;
pub use node::{ModelNode, NameSource};
pub use overrides::EntityOverrides;
use overrides::{Override, Target};
pub(crate) use style::Graphics;
use style::{Globals, Paint, resolve_style};
pub use style::{Rgba, StyleAlpha};
use walk::{At, Walk};
const BASE_WITH_GRAPHICS: u32 = 2;
const MODEL_FILE: u32 = 301;
const FILE_STRUCTURE: u32 = 302;
const FILE_STRUCTURE_GLOBALS: u32 = 303;
const FILE_STRUCTURE_TREE: u32 = 304;
const PRODUCT_OCCURRENCE: u32 = 310;
const PART_DEFINITION: u32 = 311;
const FILTER: u32 = 320;
const SURF_PLANE: u32 = 86;
const CARTESIAN_TRANSFORMATION: u32 = 202;
const ENTITY_REFERENCE: u32 = 203;
const MARKUP_LINKED_ITEM: u32 = 204;
const REFERENCE_ON_PRC_BASE: u32 = 205;
const REFERENCE_ON_TOPOLOGY: u32 = 206;
const GENERAL_TRANSFORMATION: u32 = 207;
const RI_BREP_MODEL: u32 = 232;
const RI_CURVE: u32 = 233;
const RI_DIRECTION: u32 = 234;
const RI_PLANE: u32 = 235;
const RI_POINT_SET: u32 = 236;
const RI_POLY_BREP_MODEL: u32 = 237;
const RI_POLY_WIRE: u32 = 238;
const RI_SET: u32 = 239;
const RI_COORDINATE_SYSTEM: u32 = 240;
const MKP_VIEW: u32 = 501;
const MKP_MARKUP: u32 = 502;
const MKP_LEADER: u32 = 503;
const ANNOTATION_ITEM: u32 = 504;
const ANNOTATION_SET: u32 = 505;
const ANNOTATION_REFERENCE: u32 = 506;
const STYLE: u32 = 701;
const MATERIAL: u32 = 702;
const PICTURE: u32 = 703;
const TEXTURE_APPLICATION: u32 = 711;
const TEXTURE_DEFINITION: u32 = 712;
const TEXTURE_TRANSFORMATION: u32 = 713;
const LINE_PATTERN: u32 = 721;
const AMBIENT_LIGHT: u32 = 731;
const POINT_LIGHT: u32 = 732;
const DIRECTIONAL_LIGHT: u32 = 733;
const SPOT_LIGHT: u32 = 734;
const SCENE_DISPLAY_PARAMETERS: u32 = 741;
const CAMERA: u32 = 742;
/// prc-rs: a scene's `is_absolute` exists from this authoring version.
const ABSOLUTE_SCENE_FROM: u32 = 8137;
/// prc-rs: a view's flags, linked items and filters exist from this authoring version.
const VIEW_FLAGS_FROM: u32 = 8137;
/// prc-rs: a directional light's intensity exists from this authoring version.
const LIGHT_INTENSITY_FROM: u32 = 8030;
/// `TextureDefinition` mapping type "operator" and function "blend", 0-based
/// (pdf-issues #485).
const TEXTURE_MAPPING_OPERATOR: i32 = 3;
const TEXTURE_FUNCTION_BLEND: i32 = 3;
/// Texture application mode: alpha test [WD 7.5.7].
const TEXTURE_ALPHA_TEST: u8 = 0x02;
/// Ceiling on `RI_Set` nesting, the occurrence walk's depth and a prototype chain's length.
const MAX_DEPTH: usize = 64;
/// Ceiling on occurrences visited in one walk: prototypes share subtrees, so a small file can
/// describe an exponential walk.
const MAX_VISITS: usize = 1 << 20;
/// Ceiling on placements one walk yields.
pub const MAX_PLACEMENTS: usize = 1 << 20;
/// `GraphicsContent` behaviour bits [WD 7.2.4.2].
const SHOW: u16 = 0x0001;
const SON_HERIT_COLOR: u16 = 0x0008;
const FATHER_HERIT_COLOR: u16 = 0x0010;
const REMOVED: u16 = 0x2000;
/// `product_behavior` SUPPRESSED [WD 7.3.10].
const SUPPRESSED: u8 = 0x01;
/// Per file structure, entry `b` is the paint of biased style `b`.
type Palettes = Arc<[Arc<[Option<Paint>]>]>;
/// A tessellation drawn at a place in the model: world = [`Self::matrix`] × the
/// tessellation's own coordinates.
#[derive(Debug, Clone, PartialEq)]
#[non_exhaustive]
pub struct Placement {
/// Index into [`PrcFile::file_structures`].
pub file_structure: usize,
/// Index into that file structure's [`tessellations`](crate::FileStructure::tessellations),
/// as the tree stores it: [`PrcFile::placements`] does not decode that section, so an
/// index past its end is the caller's to refuse.
pub tessellation: usize,
/// The occurrence path's locations, then the representation item's coordinate systems.
pub matrix: Matrix,
/// The colour of the style the tree resolves for this item; `None` when no style
/// reaches it or the style names no colour this reader resolves (a textured material
/// without a base). Faces with their own style are coloured by
/// [`Self::triangle_colours`].
pub colour: Option<Rgba>,
/// The graphics from the root to this item, outermost first.
chain: Vec<Graphics>,
palettes: Palettes,
/// An occurrence's entity reference replacing the item's style.
item_override: Option<Graphics>,
/// Per face index, sorted, an entity reference replacing that face's style.
face_overrides: Vec<(u32, Graphics)>,
}
/// The paint of the style `won` names, in its file structure's globals.
fn paint_of(palettes: &Palettes, won: Graphics) -> Option<Paint> {
palettes.get(won.fs)?.get(offset(won.style)).copied().flatten()
}
impl Placement {
/// Per triangle of `mesh` (this placement's tessellation), its colour as
/// [`Self::colour`] describes, with each face's own style taking part in the inheritance
/// [WD 7.2.4, 7.8.6]; `None` when no face of `mesh` carries a style or an override, so
/// every triangle is [`Self::colour`].
#[must_use]
pub fn triangle_colours(&self, mesh: &crate::TriangleMesh) -> Option<Vec<Option<Rgba>>> {
if mesh.triangle_styles.is_empty() && self.face_overrides.is_empty() {
return None;
}
let faces = overrides::triangle_faces(mesh);
let by_face = |k: usize| {
let f = faces.get(k)?;
let i = self.face_overrides.binary_search_by_key(f, |(i, _)| *i).ok()?;
self.face_overrides.get(i).map(|(_, g)| *g)
};
let colour = |won| paint_of(&self.palettes, won).map(|p| p.rgba);
if mesh.triangle_styles.is_empty() {
let whole = self.item_override.unwrap_or_else(|| resolve_style(&self.chain));
return Some((0..mesh.triangles.len()).map(|k| colour(by_face(k).unwrap_or(whole))).collect());
}
let mut chain = self.chain.clone();
chain.push(Graphics::default());
let looks = mesh.triangle_styles.iter().enumerate().map(|(k, s)| {
if let Some(won) = by_face(k).or(self.item_override) {
return colour(won);
}
if let Some(last) = chain.last_mut() {
*last = Graphics { style: s.style, bits: s.behaviour, fs: self.file_structure };
}
colour(resolve_style(&chain))
});
Some(looks.collect())
}
}
/// A representation item that can be drawn, flattened out of any `RI_Set`.
#[derive(Debug, Clone, PartialEq)]
struct Item {
/// `index_local_coordinate_system + 1` of each enclosing set and the item, outermost
/// first; 0 entries dropped.
local: Vec<u32>,
/// `index_tessellation + 1`; never 0 here.
tessellation: u32,
/// The part's graphics, each enclosing set's, then the item's own.
graphics: Vec<Graphics>,
/// The PRC unique id of each enclosing set, then the item's own.
uids: Vec<u32>,
/// A B-rep model's stored `(context, body)` ids [WD 7.6.2].
brep: Option<(u32, u32)>,
}
/// A `ProductOccurrence` (310) as far as placing and naming.
#[derive(Debug, Clone, PartialEq, Default)]
struct Product {
part: u32,
prototype: u32,
prototype_fs: Option<UniqueId>,
external: u32,
external_fs: Option<UniqueId>,
sons: Vec<u32>,
/// Its own graphics hide it (Show clear or Removed set).
hidden: bool,
suppressed: bool,
graphics: Graphics,
location: Option<Matrix>,
name: Option<String>,
/// Its entity references that name a target.
overrides: Vec<Override>,
}
/// One file structure's tree section.
#[derive(Debug, Clone, PartialEq, Default)]
struct Tree {
parts: Vec<Vec<Item>>,
/// Each part definition's name, parallel to `parts`.
part_names: Vec<Option<String>>,
products: Vec<Product>,
}
/// The model file's roots: file structure id and biased occurrence index.
#[derive(Debug, Clone, PartialEq)]
struct ModelFile {
roots: Vec<(UniqueId, u32)>,
}
impl PrcFile {
/// Where each drawable tessellation sits in the model: the product-occurrence tree walked
/// from the model file's roots, each occurrence's location composed onto its father's,
/// and each representation item's local coordinate systems applied last [WD 7.3.10.1,
/// 7.6.3.2], coloured with [`StyleAlpha::ZeroUnset`] and entity references applied by
/// [`EntityOverrides::Subtree`]. Suppressed occurrences and hidden entities are left
/// out; a tessellation several occurrences draw appears once per occurrence. Empty when
/// the file stores no tree ([`Self::stores_tree`]).
///
/// # Errors
/// [`PrcError::Unsupported`] when an item or an entity reference names a reference
/// coordinate system and the globals carry fonts or fill patterns; [`PrcError::Malformed`] for a tree index naming no entity,
/// a cycle of occurrences or prototypes, or a tree past [`MAX_PLACEMENTS`] or the depth
/// ceiling; read errors as [`crate::FileStructure::tessellations`].
pub fn placements(&self) -> Result<Vec<Placement>, PrcError> {
self.placements_with(StyleAlpha::default(), EntityOverrides::default())
}
/// [`Self::placements`], combining style transparency with material alpha by `rule` and
/// applying occurrences' entity references by `scope`.
///
/// # Errors
/// As [`Self::placements`].
pub fn placements_with(&self, rule: StyleAlpha, scope: EntityOverrides) -> Result<Vec<Placement>, PrcError> {
Ok(self.walk(rule, scope)?.0)
}
/// The assembly tree as a model-tree panel lists it: every product occurrence the model
/// file's roots reach, depth first, with its display name and stored visibility. Hidden
/// and suppressed subtrees are listed (with `drawn` false) though [`Self::placements`]
/// leaves them out; each node's `placements` range indexes that list, so attributes each
/// placed mesh to its part. Empty when the file stores no tree.
///
/// # Errors
/// As [`Self::placements`].
pub fn model_tree(&self) -> Result<Vec<ModelNode>, PrcError> {
Ok(self.walk(StyleAlpha::default(), EntityOverrides::default())?.1)
}
/// Whether the file stores a tree: its model file holds an entity. ISO 14739-1 requires
/// one, but a tessellation-only file still draws (unplaced), so its absence reads as an
/// empty tree, not an error.
#[must_use]
pub fn stores_tree(&self) -> bool {
self.model_file.iter().any(|&b| b != 0)
}
fn walk(&self, rule: StyleAlpha, scope: EntityOverrides) -> Result<(Vec<Placement>, Vec<ModelNode>), PrcError> {
self.walk_within(rule, scope, Budget::FULL)
}
/// [`Self::walk`] with `budget` shared by all its readers.
pub(crate) fn walk_within(&self, rule: StyleAlpha, scope: EntityOverrides, budget: Budget) -> Result<(Vec<Placement>, Vec<ModelNode>), PrcError> {
if !self.stores_tree() {
return Ok((Vec::new(), Vec::new()));
}
// One allowance for the whole walk, so many sections cannot each spend a full one.
let mut left = budget;
let mut trees = Vec::with_capacity(self.file_structures.len());
for fs in &self.file_structures {
// The globals open with the schema every reader of this structure uses: read it
// once, charged to the walk, and go on from there for the globals themselves.
let mut globals_reader = BitReader::with_budget(fs.section(SectionKind::Globals), left);
let schema = Schema::read(&mut globals_reader)?;
left = globals_reader.budget();
let mut ctx = Ctx::new(BitReader::with_budget(fs.section(SectionKind::Tree), left), &schema, fs.authoring_version);
let tree = ctx.file_structure_tree()?;
left = ctx.r.budget();
// The globals carry the coordinate systems and the colours; colours alone are not
// worth refusing the placements over.
let mut ctx = Ctx::new(globals_reader.with_remaining(left), &schema, fs.authoring_version);
let globals = ctx.globals();
left = ctx.r.budget();
let globals = match globals {
Ok(g) => g,
Err(e) if places_by_system(&tree) => return Err(e),
Err(_) => Globals::default(),
};
trees.push((fs.id, tree, globals));
}
let mut r = BitReader::with_budget(&self.model_file, left);
let schema = Schema::read(&mut r)?;
let model = Ctx::new(r, &schema, self.header.authoring_version).model_file()?;
let mut walk = Walk::new(trees.iter().map(|(id, t, g)| (*id, t, g)).collect(), rule, scope);
for (id, root) in model.roots {
let fs = trees.iter().position(|t| t.0 == id).ok_or_else(|| malformed("a root names an unknown file structure".into()))?;
if let Some(index) = root.checked_sub(1) {
walk.occurrence(fs, offset(index), &Matrix::IDENTITY, &[], At::ROOT)?;
}
}
Ok((walk.out, walk.nodes))
}
}
/// Whether an item of `tree`, or an entity reference one of its occurrences holds, names a
/// coordinate system: then the globals that store them must have been read.
fn places_by_system(tree: &Tree) -> bool {
tree.parts.iter().flatten().any(|i| !i.local.is_empty()) || tree.products.iter().flat_map(|p| &p.overrides).any(|o| o.local != 0)
}
#[cfg(test)]
mod markup_tests;
#[cfg(test)]
mod tests;
crates/prc/src/tree/node.rs
+68
View File
@@ -0,0 +1,68 @@
//! The assembly tree as a list: what a model-tree panel shows.
use std::ops::Range;
/// Where a [`ModelNode`]'s name came from. PRC does not say which name a
/// viewer should show; this reader takes the first present of these, in order.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum NameSource {
/// The occurrence's own name.
Occurrence,
/// The name of an occurrence in its prototype chain.
Prototype,
/// The name of the part definition it draws.
Part,
/// No name anywhere: [`ModelNode::name`] is `None`.
Unnamed,
}
/// One product occurrence of a PRC model's assembly tree, as
/// [`PrcFile::model_tree`](crate::PrcFile::model_tree) lists it: depth
/// first, a parent before its children, children in file order.
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct ModelNode {
/// The name to show, by [`Self::name_from`]; `None` when unnamed.
pub name: Option<String>,
/// Where [`Self::name`] came from.
pub name_from: NameSource,
/// Index of the parent node in the list; `None` for a root.
pub parent: Option<usize>,
/// 0 for a root.
pub depth: usize,
/// Index into [`crate::PrcFile::file_structures`] of the structure
/// holding this occurrence.
pub file_structure: usize,
/// The occurrence's 0-based index in that structure's tree.
pub occurrence: usize,
/// The occurrence's own graphics hide it (Show clear, or Removed)
/// [WD 7.2.4.2]: the visibility the file stores, which a viewer opens on.
pub hidden: bool,
/// The occurrence is suppressed (`product_behavior`) [WD 7.3.10].
pub suppressed: bool,
/// Whether anything of this node is drawn: false when it or an
/// ancestor is hidden or suppressed.
pub drawn: bool,
/// Whether the occurrence (or its prototype) carries a part definition,
/// i.e. geometry of its own rather than only children.
pub has_part: bool,
/// The placements this node and its descendants draw: indices into
/// [`PrcFile::placements`](crate::PrcFile::placements) (or
/// [`placements_with`](crate::PrcFile::placements_with), which yields the same order):
/// the meshes attributed to this occurrence's part and its descendants' parts. Empty when
/// nothing under it is drawn.
pub placements: Range<usize>,
}
impl ModelNode {
/// The label the node is listed under: its name, or `occurrence F:I`
/// (file structure, occurrence) when it has none.
#[must_use]
pub fn label(&self) -> String {
match &self.name {
Some(name) => name.clone(),
None => format!("occurrence {}:{}", self.file_structure, self.occurrence),
}
}
}
crates/prc/src/tree/overrides.rs
+128
View File
@@ -0,0 +1,128 @@
//! Product-occurrence entity references: the colour, visibility and placement an occurrence
//! imposes on an entity it reaches [WD 7.3.10.1, 7.4.4].
use super::{Graphics, Item, RI_BREP_MODEL, RI_COORDINATE_SYSTEM, UniqueId};
/// `PRC_TYPE_TOPO_Face` [WD 6.2].
const TOPO_FACE: u32 = 149;
/// Which entities an occurrence's entity references reach. ISO 14739-1 says a reference
/// overrides the referenced entity's properties, and not where.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
#[non_exhaustive]
pub enum EntityOverrides {
/// Only where the occurrence's own subtree places the target, so one instance of a
/// shared part can be coloured alone.
#[default]
Subtree,
/// Every placement of the target anywhere in the model.
Everywhere,
/// Read past them: every entity keeps its own and inherited graphics.
Ignore,
}
/// One `MISC_EntityReference` held by a product occurrence.
#[derive(Debug, Clone, PartialEq)]
pub(super) struct Override {
/// The reference's graphics; style 0 leaves the target's colour alone.
pub(super) graphics: Graphics,
/// The graphics hide the target (Show clear or Removed set).
pub(super) hidden: bool,
/// `index_local_coordinate_system + 1` replacing the target's; 0 none.
pub(super) local: u32,
pub(super) target: Target,
}
/// What an entity reference names.
#[derive(Debug, Clone, PartialEq)]
pub(super) enum Target {
/// `ReferenceOnPRCBase`: the entity of type `kind` whose PRC unique id is `uid` in
/// structure `fs` (`None`: the occurrence's own).
Entity { kind: u32, fs: Option<UniqueId>, uid: u32 },
/// `ReferenceOnTopology` into the B-rep stored as `(context, body)`: its topological
/// items of type `kind` at `indices` (0-based). With `fs` `None` it matches that B-rep in
/// any structure the subtree reaches: producers write "same structure" for an assembly's
/// reference into a part's own structure.
Topology { kind: u32, fs: Option<UniqueId>, brep: (u32, u32), indices: Vec<u32> },
}
impl Target {
/// The structure the reference names, if it names one.
pub(super) fn fs(&self) -> Option<UniqueId> {
match self {
Target::Entity { fs, .. } | Target::Topology { fs, .. } => *fs,
}
}
}
/// An entity reference in force: the structure of the occurrence holding it, the structure
/// it names (`None`: any), and the reference.
pub(super) type Active<'t> = (usize, Option<usize>, &'t Override);
/// The overrides that reach one representation item.
#[derive(Debug, Default)]
pub(super) struct Reached {
/// Graphics replacing the item's resolved style, in its owner's structure.
pub(super) item: Option<Graphics>,
pub(super) hidden: bool,
/// The owner's structure and its local coordinate system.
pub(super) local: Option<(usize, u32)>,
/// Per face index, sorted, graphics replacing that face's style.
pub(super) faces: Vec<(u32, Graphics)>,
}
impl Reached {
/// Applies `active` innermost first, so an outer occurrence's override wins over an
/// inner one's, as an assembly's appearance beats its sub-assembly's.
pub(super) fn collect(active: &[Active<'_>], fs: usize, item: &Item) -> Self {
let mut r = Reached::default();
// A map, not a list searched per index: one reference may name millions of faces.
let mut faces = std::collections::BTreeMap::new();
for &(owner, named, ov) in active.iter().rev() {
let in_fs = named.is_none_or(|n| n == fs);
let g = Graphics { fs: owner, ..ov.graphics };
match &ov.target {
Target::Entity { kind, uid, .. } => {
if !in_fs || !is_item(*kind) || !item.uids.contains(uid) {
continue;
}
if ov.graphics.style != 0 {
r.item = Some(g);
}
r.hidden = ov.hidden;
if ov.local != 0 {
r.local = Some((owner, ov.local));
}
}
Target::Topology { kind, brep, indices, .. } => {
if !in_fs || *kind != TOPO_FACE || item.brep != Some(*brep) || ov.graphics.style == 0 {
continue;
}
for &f in indices {
faces.insert(f, g);
}
}
}
}
r.faces = faces.into_iter().collect();
r
}
}
/// Representation-item types a `ReferenceOnPRCBase` can colour.
fn is_item(kind: u32) -> bool {
(RI_BREP_MODEL..=RI_COORDINATE_SYSTEM).contains(&kind)
}
/// Per triangle of `mesh`, the index of the `TESS_Face` it was read from (`u32::MAX` for
/// none).
pub(super) fn triangle_faces(mesh: &crate::TriangleMesh) -> Vec<u32> {
let mut out = vec![u32::MAX; mesh.triangles.len()];
for (i, range) in mesh.faces.iter().enumerate() {
let face = u32::try_from(i).unwrap_or(u32::MAX);
for f in out.get_mut(range.clone()).into_iter().flatten() {
*f = face;
}
}
out
}
crates/prc/src/tree/read.rs
+452
View File
@@ -0,0 +1,452 @@
//! The tree section's and the model file's entities: part definitions, representation items,
//! product occurrences and their transformations and entity references [WD 7.3, 7.4, 7.6].
use super::{
ABSOLUTE_SCENE_FROM, BASE_WITH_GRAPHICS, CAMERA, CARTESIAN_TRANSFORMATION, ENTITY_REFERENCE, FILE_STRUCTURE, FILE_STRUCTURE_TREE, FILTER,
GENERAL_TRANSFORMATION, Graphics, Item, MAX_DEPTH, MODEL_FILE, Matrix, ModelFile, Override, PART_DEFINITION, PRODUCT_OCCURRENCE, Product,
REFERENCE_ON_PRC_BASE, REFERENCE_ON_TOPOLOGY, REMOVED, RI_BREP_MODEL, RI_COORDINATE_SYSTEM, RI_CURVE, RI_DIRECTION, RI_PLANE, RI_POINT_SET,
RI_POLY_BREP_MODEL, RI_POLY_WIRE, RI_SET, SCENE_DISPLAY_PARAMETERS, SHOW, SUPPRESSED, Target, Tree, UniqueId, Vec3,
};
use crate::PrcError;
use crate::entity::{Ctx, malformed};
impl Ctx<'_, '_> {
pub(super) fn vector3(&mut self) -> Result<Vec3, PrcError> {
Ok(Vec3([self.r.double()?, self.r.double()?, self.r.double()?]))
}
pub(super) fn unique_id(&mut self) -> Result<UniqueId, PrcError> {
let mut id = [0; 4];
for v in &mut id {
*v = self.r.unsigned_integer()?;
}
Ok(UniqueId(id))
}
/// `ContentPRCRefBase` [WD 7.2.3.2; pdf-issues #697]: the base, then the CAD ids and the
/// PRC unique id, which becomes [`Ctx::uid`].
pub(super) fn content_prc_ref_base(&mut self) -> Result<(), PrcError> {
self.content_prc_base()?;
self.r.unsigned_integer()?; // CAD identifier
self.r.unsigned_integer()?; // CAD persistent identifier
self.uid = self.r.unsigned_integer()?;
Ok(())
}
/// `PRCBaseWithGraphics` [WD 7.2.4; pdf-issues #405]: whether the entity's own graphics
/// hide it (Show clear or Removed set), and its graphics. Reused graphics
/// (`same_graphics`) are the current graphics and never hide.
pub(super) fn base_with_graphics(&mut self) -> Result<(bool, Graphics), PrcError> {
self.content_prc_ref_base()?;
let hidden = if self.r.bit()? {
false
} else {
self.r.unsigned_integer()?; // layer + 1
let style = self.r.unsigned_integer()?;
let lo = u16::from(self.r.character()?);
let hi = u16::from(self.r.character()?);
let bits = lo | hi << 8;
self.graphics = Graphics { style, bits, fs: 0 };
bits & SHOW == 0 || bits & REMOVED != 0
};
// prc-rs: schema additions to the base itself follow the graphics.
self.schema.skip_added_fields(BASE_WITH_GRAPHICS, &mut self.r)?;
Ok((hidden, self.graphics))
}
/// `CartesianTransformation` (202) or `GeneralTransformation` (207), type code included
/// [WD 7.4.8, 7.4.9, 7.4.11; pdf-issues #430].
pub(super) fn transformation(&mut self) -> Result<Matrix, PrcError> {
let t = self.r.unsigned_integer()?;
let m = match t {
GENERAL_TRANSFORMATION => {
// Column-major [WD 7.4.9].
let mut m = Matrix::IDENTITY;
for col in 0..4 {
for row in &mut m.0 {
if let Some(c) = row.get_mut(col) {
*c = self.r.double()?;
}
}
}
m
}
CARTESIAN_TRANSFORMATION => self.transformation_3d()?,
t => return Err(malformed(format!("entity type {t} as a transformation"))),
};
self.schema.skip_added_fields(t, &mut self.r)?;
Ok(m)
}
/// The embedded `Transformation3D` [WD 7.4.11.1]: a behaviour byte, then each field its
/// bits name.
pub(super) fn transformation_3d(&mut self) -> Result<Matrix, PrcError> {
let b = self.r.character()?;
let mut m = Matrix::IDENTITY;
let set_col = |m: &mut Matrix, col: usize, v: Vec3| {
for (row, x) in m.0.iter_mut().zip(v.0) {
if let Some(c) = row.get_mut(col) {
*c = x;
}
}
};
if b & 0x01 != 0 {
let t = self.vector3()?;
set_col(&mut m, 3, t);
}
if b & 0x20 != 0 {
for col in 0..3 {
let v = self.vector3()?;
set_col(&mut m, col, v);
}
} else if b & 0x02 != 0 {
let x = self.vector3()?;
let y = self.vector3()?;
// Mirrored (0x04): the third axis is y × x.
let z = if b & 0x04 != 0 { y.cross(x) } else { x.cross(y) };
set_col(&mut m, 0, x);
set_col(&mut m, 1, y);
set_col(&mut m, 2, z);
}
let mut scale = [1.0; 3];
if b & 0x10 != 0 {
scale = self.vector3()?.0;
}
// prc-rs: with both scale bits set, both are read and multiply.
if b & 0x08 != 0 {
let s = self.r.double()?;
scale = scale.map(|v| v * s);
}
for row in m.0.iter_mut().take(3) {
for (c, s) in row.iter_mut().zip(scale) {
*c *= s;
}
}
if b & 0x40 != 0 {
let h = [self.r.double()?, self.r.double()?, self.r.double()?, self.r.double()?];
if let Some(r) = m.0.get_mut(3) {
*r = h;
}
}
Ok(m)
}
/// A polymorphic representation item [WD 7.6]; drawable ones are pushed onto `out` with
/// `local` (the enclosing sets' coordinate systems) prefixed.
// prc-rs: the item's own fields follow its local coordinate system and tessellation.
fn representation_item(&mut self, at: &Item, out: &mut Vec<Item>, depth: usize) -> Result<(), PrcError> {
if depth > MAX_DEPTH {
return Err(malformed("representation sets nest too deep".into()));
}
let t = self.r.unsigned_integer()?;
let (hidden, own) = self.base_with_graphics()?;
let mut item = at.clone();
item.uids.push(self.uid);
item.graphics.push(own);
let cs = self.r.unsigned_integer()?;
let tess = self.r.unsigned_integer()?;
if cs != 0 {
item.local.push(cs);
}
let (drawable, brep) = if t == RI_SET {
let n = self.count(1, "representation set")?;
let mut members = Vec::new();
for _ in 0..n {
self.representation_item(&item, &mut members, depth + 1)?;
}
if !hidden {
out.extend(members);
}
(false, None)
} else {
self.leaf_item_fields(t)?
};
self.schema.skip_added_fields(t, &mut self.r)?;
self.user_data()?;
if drawable && !hidden && tess != 0 {
out.push(Item { tessellation: tess, brep, ..item });
}
Ok(())
}
/// The type-specific fields of a representation item other than `RI_Set` [WD 7.6];
/// whether the item can be drawn, and a B-rep model's `(context, body)`.
fn leaf_item_fields(&mut self, t: u32) -> Result<(bool, Option<(u32, u32)>), PrcError> {
match t {
RI_BREP_MODEL => {
let brep = self.exact_tolerance()?;
self.r.bit()?; // is_closed
return Ok((true, brep));
}
RI_CURVE | RI_PLANE => {
self.exact_tolerance()?;
}
RI_DIRECTION => {
if self.r.bit()? {
self.vector3()?; // origin
}
self.vector3()?;
return Ok((false, None));
}
RI_POINT_SET => {
let n = self.count(6, "point set")?;
for _ in 0..n {
self.vector3()?;
}
}
RI_POLY_BREP_MODEL => {
self.r.bit()?; // is_closed
}
RI_POLY_WIRE => {}
RI_COORDINATE_SYSTEM => {
self.transformation()?;
return Ok((false, None));
}
t => return Err(malformed(format!("entity type {t} as a representation item"))),
}
Ok((true, None))
}
/// A B-rep, curve or plane item's optional exact-geometry `(context, body)` ids
/// [WD 7.6.2].
fn exact_tolerance(&mut self) -> Result<Option<(u32, u32)>, PrcError> {
if self.r.bit()? {
return Ok(Some((self.r.unsigned_integer()?, self.r.unsigned_integer()?)));
}
Ok(None)
}
/// `SceneDisplayParameters` (741) [WD 7.5.19]: read past, lights and clipping planes
/// included.
// prc-rs: the scene's field order, and `is_absolute` from version 8137.
pub(super) fn scene_display_parameters(&mut self) -> Result<(), PrcError> {
self.expect_type(SCENE_DISPLAY_PARAMETERS)?;
self.content_prc_ref_base()?;
self.r.bit()?; // is_active
let n = self.count(1, "scene lights")?;
for _ in 0..n {
self.light()?;
}
if self.r.bit()? {
self.camera()?;
}
if self.r.bit()? {
self.vector3()?; // rotation centre
}
let n = self.count(1, "scene clipping planes")?;
for _ in 0..n {
self.plane()?;
}
self.r.unsigned_integer()?; // background style + 1
self.r.unsigned_integer()?; // default style + 1
let n = self.count(2, "scene default styles")?;
for _ in 0..n {
self.r.unsigned_integer()?; // entity type
self.r.unsigned_integer()?; // style + 1
}
if self.version >= ABSOLUTE_SCENE_FROM {
self.r.bit()?; // is_absolute
}
self.schema.skip_added_fields(SCENE_DISPLAY_PARAMETERS, &mut self.r)
}
/// `Camera` (742) [WD 7.5.20]: read past.
// prc-rs: the camera's field order.
fn camera(&mut self) -> Result<(), PrcError> {
self.expect_type(CAMERA)?;
self.content_prc_ref_base()?;
self.r.bit()?; // is_orthographic
for _ in 0..3 {
self.vector3()?; // position, look, up
}
for _ in 0..6 {
self.r.double()?; // x, y, ratio, near, far, zoom
}
self.schema.skip_added_fields(CAMERA, &mut self.r)
}
/// `MISC_EntityReference` (203) [WD 7.4.4, 7.4.10]; `None` when it names no target.
// prc-rs: the local coordinate system precedes the optional reference data.
fn entity_reference(&mut self) -> Result<Option<Override>, PrcError> {
self.expect_type(ENTITY_REFERENCE)?;
let (hidden, graphics) = self.base_with_graphics()?;
let local = self.r.unsigned_integer()?;
let target = if self.r.bit()? { self.reference_data()? } else { None };
self.schema.skip_added_fields(ENTITY_REFERENCE, &mut self.r)?;
self.user_data()?;
Ok(target.map(|target| Override { graphics, hidden, local, target }))
}
/// `ReferenceData` [WD 7.4.10.2]: a `ReferenceOnPRCBase` (205) or a
/// `ReferenceOnTopology` (206), type code included; `None` when it names no target.
pub(super) fn reference_data(&mut self) -> Result<Option<Target>, PrcError> {
let t = self.r.unsigned_integer()?;
let target = match t {
REFERENCE_ON_PRC_BASE => Some(self.reference_on_prc_base_body()?),
REFERENCE_ON_TOPOLOGY => self.reference_on_topology()?,
t => return Err(malformed(format!("entity type {t} as reference data"))),
};
self.schema.skip_added_fields(t, &mut self.r)?;
Ok(target)
}
/// `ReferenceOnPRCBase` (205) [WD 7.4.6] after its type code.
fn reference_on_prc_base_body(&mut self) -> Result<Target, PrcError> {
let kind = self.r.unsigned_integer()?;
let fs = self.file_identifier()?;
let uid = self.r.unsigned_integer()?;
Ok(Target::Entity { kind, fs, uid })
}
/// `ReferenceOnPRCBase` (205) [WD 7.4.6], type code included: read past.
pub(super) fn reference_on_prc_base(&mut self) -> Result<(), PrcError> {
self.expect_type(REFERENCE_ON_PRC_BASE)?;
self.reference_on_prc_base_body()?;
self.schema.skip_added_fields(REFERENCE_ON_PRC_BASE, &mut self.r)
}
/// `ReferenceOnTopology` (206) after its type code; `None` without a body.
fn reference_on_topology(&mut self) -> Result<Option<Target>, PrcError> {
let kind = self.r.unsigned_integer()?;
if !self.r.bit()? {
return Ok(None);
}
let fs = self.file_identifier()?;
let brep = (self.r.unsigned_integer()?, self.r.unsigned_integer()?);
let indices = self.uints("topology reference indices")?;
Ok(Some(Target::Topology { kind, fs, brep, indices }))
}
/// `ASM_Filter` (320) [WD 7.3.12]: read past.
// prc-rs: the filter's field order.
pub(super) fn filter(&mut self) -> Result<(), PrcError> {
self.expect_type(FILTER)?;
self.content_prc_ref_base()?;
self.r.bit()?; // is_active
self.r.bit()?; // layers inclusive
self.uints("filter layers")?;
self.r.bit()?; // entities inclusive
let n = self.count(1, "filter entities")?;
for _ in 0..n {
self.entity_reference()?;
}
self.schema.skip_added_fields(FILTER, &mut self.r)?;
self.user_data()
}
/// `PartDefinition` (311): its drawable items and its name.
fn part_definition(&mut self) -> Result<(Vec<Item>, Option<String>), PrcError> {
self.expect_type(PART_DEFINITION)?;
let (hidden, own) = self.base_with_graphics()?;
let name = self.name.clone();
self.vector3()?; // bounding box
self.vector3()?;
let n = self.count(1, "representation items")?;
let mut items = Vec::new();
let at = Item { local: Vec::new(), tessellation: 0, graphics: vec![own], uids: Vec::new(), brep: None };
for _ in 0..n {
self.representation_item(&at, &mut items, 0)?;
}
self.markup_data()?;
self.views()?;
self.schema.skip_added_fields(PART_DEFINITION, &mut self.r)?;
self.user_data()?;
if hidden {
items.clear();
}
Ok((items, name))
}
/// `FileIdentifier` [WD 7.3.10.2.2]: `None` for the same structure.
fn file_identifier(&mut self) -> Result<Option<UniqueId>, PrcError> {
if self.r.bit()? { Ok(None) } else { self.unique_id().map(Some) }
}
/// `ProductOccurrence` (310) [WD 7.3.10].
fn product_occurrence(&mut self) -> Result<Product, PrcError> {
self.expect_type(PRODUCT_OCCURRENCE)?;
let (hidden, graphics) = self.base_with_graphics()?;
let mut p = Product { hidden, graphics, name: self.name.clone(), part: self.r.unsigned_integer()?, ..Product::default() };
p.prototype = self.r.unsigned_integer()?;
if p.prototype != 0 {
p.prototype_fs = self.file_identifier()?;
}
p.external = self.r.unsigned_integer()?;
if p.external != 0 {
p.external_fs = self.file_identifier()?;
}
p.sons = self.uints("son occurrences")?;
p.suppressed = self.r.character()? & SUPPRESSED != 0;
// ProductInformation [WD 7.3.10.3]: unit flag, unit, load status, information.
self.r.bit()?;
self.r.double()?;
self.r.character()?;
self.r.integer()?;
if self.r.bit()? {
p.location = Some(self.transformation()?);
}
let n = self.count(1, "entity references")?;
for _ in 0..n {
p.overrides.extend(self.entity_reference()?);
}
self.markup_data()?;
self.views()?;
if self.r.bit()? {
self.filter()?;
}
let n = self.count(1, "display filters")?;
for _ in 0..n {
self.filter()?;
}
let n = self.count(1, "scene display parameters")?;
for _ in 0..n {
self.scene_display_parameters()?;
}
self.schema.skip_added_fields(PRODUCT_OCCURRENCE, &mut self.r)?;
self.user_data()?;
Ok(p)
}
/// `FileStructureTree` (304) [WD 7.3.6], with its `FileStructure` (302) inside.
pub(super) fn file_structure_tree(&mut self) -> Result<Tree, PrcError> {
self.expect_type(FILE_STRUCTURE_TREE)?;
self.content_prc_base()?;
let n = self.count(1, "part definitions")?;
let mut tree = Tree::default();
for _ in 0..n {
let (items, name) = self.part_definition()?;
tree.parts.push(items);
tree.part_names.push(name);
}
let n = self.count(1, "product occurrences")?;
for _ in 0..n {
tree.products.push(self.product_occurrence()?);
}
self.expect_type(FILE_STRUCTURE)?;
self.content_prc_base()?;
self.r.unsigned_integer()?; // next_available_index
self.r.unsigned_integer()?; // product_occurrence_index + 1 (the structure's root)
self.schema.skip_added_fields(FILE_STRUCTURE, &mut self.r)?;
self.schema.skip_added_fields(FILE_STRUCTURE_TREE, &mut self.r)?;
self.user_data()?;
Ok(tree)
}
/// `ModelFile` (301) after its schema [WD 7.3.3; pdf-issues #724, #740]: `units_in_mm` is
/// always present.
pub(super) fn model_file(&mut self) -> Result<ModelFile, PrcError> {
self.expect_type(MODEL_FILE)?;
self.content_prc_base()?;
self.r.bit()?; // units_from_cad_file
self.r.double()?; // units_in_mm
let n = self.count(6, "root occurrences")?;
let mut roots = Vec::with_capacity(n);
for _ in 0..n {
let id = self.unique_id()?;
let index = self.r.unsigned_integer()?;
self.r.bit()?; // is_active
roots.push((id, index));
}
Ok(ModelFile { roots })
}
}
crates/prc/src/tree/style.rs
+348
View File
@@ -0,0 +1,348 @@
//! Graphics, styles, materials and the globals that hold them [WD 7.2.4, 7.3.5, 7.5].
use super::{
FATHER_HERIT_COLOR, FILE_STRUCTURE_GLOBALS, LINE_PATTERN, MATERIAL, Matrix, PICTURE, RI_COORDINATE_SYSTEM, SON_HERIT_COLOR, STYLE,
TEXTURE_ALPHA_TEST, TEXTURE_APPLICATION, TEXTURE_DEFINITION, TEXTURE_FUNCTION_BLEND, TEXTURE_MAPPING_OPERATOR, TEXTURE_TRANSFORMATION, Vec3,
};
use crate::PrcError;
use crate::container::offset;
use crate::entity::{Ctx, malformed};
/// One entity's `GraphicsContent` [WD 7.2.4]: `style` is `line_style_index + 1` (0 none),
/// `bits` the behaviour bits. `fs` is the file structure whose globals `style` indexes: the
/// one whose tree holds the entity. The walk sets it; a reader leaves it 0.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub(crate) struct Graphics {
pub(crate) style: u32,
pub(crate) bits: u16,
pub(crate) fs: usize,
}
/// A straight (not premultiplied) colour, each channel 0-1; `a` is the opacity.
#[derive(Debug, Clone, Copy, PartialEq, Default)]
#[non_exhaustive]
pub struct Rgba {
/// Red.
pub r: f64,
/// Green.
pub g: f64,
/// Blue.
pub b: f64,
/// Opacity: 0 transparent, 1 opaque.
pub a: f64,
}
/// How a style's `transparency` combines with its material's diffuse alpha. ISO 14739-1
/// defines both and not their combination, and gives a diffuse alpha of 0.0 no "unset"
/// meaning.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
#[non_exhaustive]
pub enum StyleAlpha {
/// As [`Self::StyleWins`], except that a material diffuse alpha of exactly 0.0 under a
/// style with no transparency reads as unset, so opaque. Producers write 0.0 on the
/// materials of models meant to be seen; read literally, every part is invisible.
#[default]
ZeroUnset,
/// The style's transparency, when it has one, is the opacity; the material alpha, read
/// literally (0.0 invisible), applies only to a style without one.
StyleWins,
/// The opacity is material alpha × style transparency.
Multiply,
}
/// A style's resolved colour, and whether its opacity comes from reading a zero material
/// alpha as unset.
#[derive(Debug, Clone, Copy, PartialEq)]
pub(crate) struct Paint {
pub(crate) rgba: Rgba,
pub(crate) alpha_unset: bool,
}
/// A `Style` (701) as far as colour: `index` is `colour_or_material + 1`.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct Style {
pub(crate) is_material: bool,
pub(crate) index: u32,
pub(crate) transparency: Option<u8>,
}
/// A `materials` entry as far as colour.
#[derive(Debug, Clone, Copy, PartialEq)]
pub(crate) enum Material {
/// `Material` (702): `diffuse + 1` (a colour index) and the diffuse alpha.
Plain { diffuse: u32, alpha: f64 },
/// `TextureApplication` (711) [WD 7.5.6]: `material_generic_index + 1`, the material
/// under the texture.
Textured { base: u32 },
}
/// What `FileStructureGlobals` contributes to placing and colouring.
#[derive(Debug, Clone, PartialEq, Default)]
pub(crate) struct Globals {
/// Entry `i` places an item with biased local coordinate system `i + 1`.
pub(crate) systems: Vec<Matrix>,
/// RGB, `a` 1.
pub(crate) colours: Vec<Rgba>,
pub(crate) materials: Vec<Material>,
pub(crate) styles: Vec<Style>,
}
/// The entry at biased index `biased` (`index + 1`); `None` for 0 or past the end.
pub(crate) fn biased<T>(list: &[T], biased: u32) -> Option<&T> {
list.get(offset(biased.checked_sub(1)?))
}
impl Globals {
/// The colour a style or material names by `biased` (`index + 1`). Stored indices count
/// the colour array's doubles, so `colours[i]` is stored as `3i + 1`; an index that is
/// not of that form names nothing.
fn colour(&self, biased: u32) -> Option<Rgba> {
let i = biased.checked_sub(1)?;
// pdf-issues #816: a colour index counts doubles, three per colour.
if i % 3 != 0 {
return None;
}
self.colours.get(offset(i / 3)).copied()
}
/// The colour of style `biased` (`line_style_index + 1`) under `rule`.
pub(crate) fn style_paint(&self, biased_style: u32, rule: StyleAlpha) -> Option<Paint> {
let style = biased(&self.styles, biased_style)?;
let (rgb, mut alpha) = if style.is_material {
let mut m = biased(&self.materials, style.index)?;
if let Material::Textured { base } = *m {
m = biased(&self.materials, base)?;
}
match *m {
Material::Plain { diffuse, alpha } => (self.colour(diffuse)?, alpha),
Material::Textured { .. } => return None,
}
} else {
(self.colour(style.index)?, 1.0)
};
let mut alpha_unset = false;
match style.transparency {
Some(t) => {
let t = f64::from(t) / 255.0;
alpha = match rule {
StyleAlpha::ZeroUnset | StyleAlpha::StyleWins => t,
StyleAlpha::Multiply => alpha * t,
};
}
None if rule == StyleAlpha::ZeroUnset && style.is_material && alpha == 0.0 => {
alpha = 1.0;
alpha_unset = true;
}
None => {}
}
// A NaN alpha (a stored double may be one) reads as opaque.
let a = if alpha.is_nan() { 1.0 } else { alpha.clamp(0.0, 1.0) };
Some(Paint { rgba: Rgba { a, ..rgb }, alpha_unset })
}
}
/// The style a chain of graphics resolves to, outermost first [WD 7.2.4.2]: a son's own
/// style is used unless an ancestor set `FatherHeritColor` (the oldest such wins), and a son
/// setting `SonHeritColor` overrides that. Entities with no style inherit. Returns the
/// winning entity's graphics, style 0 when none.
pub(crate) fn resolve_style(chain: &[Graphics]) -> Graphics {
let (mut won, mut forced) = (Graphics::default(), false);
for g in chain {
if g.style == 0 {
continue;
}
if !forced || g.bits & SON_HERIT_COLOR != 0 {
won = *g;
forced = g.bits & FATHER_HERIT_COLOR != 0;
}
}
won
}
impl Ctx<'_, '_> {
/// `FileStructureGlobals` (303) [WD 7.3.5]: colours, materials, styles and the reference
/// coordinate systems. Pictures, textures and line patterns are read past; fonts and fill
/// patterns are [`PrcError::Unsupported`].
// prc-rs: the globals' field order.
pub(crate) fn globals(&mut self) -> Result<Globals, PrcError> {
let mut g = Globals::default();
self.expect_type(FILE_STRUCTURE_GLOBALS)?;
self.content_prc_base()?;
let n = self.count(4, "referenced file structures")?;
for _ in 0..n {
self.unique_id()?;
}
self.r.double()?; // tessellation chord-height ratio
self.r.double()?; // tessellation angle
self.r.string()?; // default font family
if self.r.unsigned_integer()? != 0 {
return Err(PrcError::Unsupported("PRC global fonts"));
}
let n = self.count(6, "colours")?;
g.colours = (0..n).map(|_| self.vector3().map(|Vec3([r, g, b])| Rgba { r, g, b, a: 1.0 })).collect::<Result<_, _>>()?;
let n = self.count(1, "pictures")?;
for _ in 0..n {
self.picture()?;
}
let n = self.count(1, "texture definitions")?;
for _ in 0..n {
self.texture_definition()?;
}
let n = self.count(1, "materials")?;
g.materials = (0..n).map(|_| self.material()).collect::<Result<_, _>>()?;
let n = self.count(1, "line patterns")?;
for _ in 0..n {
self.line_pattern()?;
}
let n = self.count(1, "styles")?;
g.styles = (0..n).map(|_| self.style()).collect::<Result<_, _>>()?;
if self.r.unsigned_integer()? != 0 {
return Err(PrcError::Unsupported("PRC fill patterns"));
}
let n = self.count(1, "reference coordinate systems")?;
for _ in 0..n {
self.expect_type(RI_COORDINATE_SYSTEM)?;
self.base_with_graphics()?;
self.r.unsigned_integer()?; // local coordinate system + 1
self.r.unsigned_integer()?; // tessellation + 1
g.systems.push(self.transformation()?);
self.schema.skip_added_fields(RI_COORDINATE_SYSTEM, &mut self.r)?;
self.user_data()?;
}
self.schema.skip_added_fields(FILE_STRUCTURE_GLOBALS, &mut self.r)?;
self.user_data()?;
Ok(g)
}
/// `LinePattern` (721) [WD 7.5.2]: read past.
fn line_pattern(&mut self) -> Result<(), PrcError> {
self.expect_type(LINE_PATTERN)?;
self.content_prc_ref_base()?;
self.doubles("line pattern lengths")?;
self.r.double()?; // phase
self.r.bit()?; // is_real_length
self.schema.skip_added_fields(LINE_PATTERN, &mut self.r)
}
/// One `materials` entry, type-tagged: `Material` (702) or `TextureApplication` (711)
/// [WD 7.5.4, 7.5.6].
// prc-rs: a material entry is type-tagged, then a ref base, then its fields.
fn material(&mut self) -> Result<Material, PrcError> {
let t = self.r.unsigned_integer()?;
self.content_prc_ref_base()?;
let m = match t {
MATERIAL => {
self.r.unsigned_integer()?; // ambient + 1
let diffuse = self.r.unsigned_integer()?;
self.r.unsigned_integer()?; // emissive + 1
self.r.unsigned_integer()?; // specular + 1
self.r.double()?; // shininess
self.r.double()?; // ambient alpha
let alpha = self.r.double()?;
self.r.double()?; // emissive alpha
self.r.double()?; // specular alpha
Material::Plain { diffuse, alpha }
}
TEXTURE_APPLICATION => {
let base = self.r.unsigned_integer()?;
self.r.unsigned_integer()?; // texture definition + 1
self.r.unsigned_integer()?; // next texture + 1
self.r.unsigned_integer()?; // UV coordinates set + 1
Material::Textured { base }
}
t => return Err(malformed(format!("entity type {t} as a material"))),
};
self.schema.skip_added_fields(t, &mut self.r)?;
Ok(m)
}
/// `Style` (701) [WD 7.5.3].
// prc-rs: the transparency and the three rendering parameters each follow a presence bit.
fn style(&mut self) -> Result<Style, PrcError> {
self.expect_type(STYLE)?;
self.content_prc_ref_base()?;
self.r.double()?; // line width
self.r.bit()?; // is_vpicture
self.r.unsigned_integer()?; // line pattern + 1
let is_material = self.r.bit()?;
let index = self.r.unsigned_integer()?;
let transparency = if self.r.bit()? { Some(self.r.character()?) } else { None };
for _ in 0..3 {
if self.r.bit()? {
self.r.character()?;
}
}
self.schema.skip_added_fields(STYLE, &mut self.r)?;
Ok(Style { is_material, index, transparency })
}
/// `Picture` (703) [WD 7.5.5]: read past.
fn picture(&mut self) -> Result<(), PrcError> {
self.expect_type(PICTURE)?;
self.content_prc_base()?;
for _ in 0..4 {
self.r.unsigned_integer()?; // format, file + 1, width, height
}
self.schema.skip_added_fields(PICTURE, &mut self.r)
}
/// `TextureDefinition` (712) [WD 7.5.7; pdf-issues #485]: read past.
fn texture_definition(&mut self) -> Result<(), PrcError> {
self.expect_type(TEXTURE_DEFINITION)?;
self.content_prc_ref_base()?;
self.r.unsigned_integer()?; // picture + 1
let dimension = self.r.character()?;
if self.r.integer()? == TEXTURE_MAPPING_OPERATOR {
self.r.integer()?; // mapping operator
if self.r.bit()? {
self.transformation()?;
}
}
self.r.unsigned_integer()?; // channels
self.doubles("texture intensities")?;
let n = self.count(8, "texture components")?;
for _ in 0..n {
self.r.character()?;
}
if self.r.integer()? == TEXTURE_FUNCTION_BLEND {
for _ in 0..4 {
self.r.double()?; // blend colour
}
}
for _ in 0..2 {
// RGB, then alpha: a source blend, and a destination one when set.
if self.r.integer()? != 0 {
self.r.integer()?;
}
}
if self.r.character()? & TEXTURE_ALPHA_TEST != 0 {
self.r.integer()?; // alpha test function
self.r.double()?; // reference
}
for _ in 0..dimension.clamp(1, 3) {
self.r.integer()?; // wrapping mode
}
if self.r.bit()? {
self.texture_transformation()?;
}
self.schema.skip_added_fields(TEXTURE_DEFINITION, &mut self.r)
}
/// `TextureTransformation` (713) [WD 7.5.8, 7.4.11.1; pdf-issues #819]: read past.
fn texture_transformation(&mut self) -> Result<(), PrcError> {
self.expect_type(TEXTURE_TRANSFORMATION)?;
self.r.bit()?; // invert u
self.r.bit()?; // invert v
self.r.bit()?; // is 2D
let b = self.r.character()?;
// Translation; non-orthogonal axes, else one rotation vector; non-uniform, else
// uniform scale; homogeneous row.
let doubles = [(0x01, 2), (0x20, 4), (0x10, 2), (0x40, 3)].iter().filter(|(bit, _)| b & bit != 0).map(|(_, n)| n).sum::<usize>()
+ if b & 0x20 == 0 && b & 0x02 != 0 { 2 } else { 0 }
+ usize::from(b & 0x10 == 0 && b & 0x08 != 0);
for _ in 0..doubles {
self.r.double()?;
}
self.schema.skip_added_fields(TEXTURE_TRANSFORMATION, &mut self.r)
}
}
crates/prc/src/tree/tests.rs
+714
View File
@@ -0,0 +1,714 @@
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use super::style::{Material, Style};
use super::{
EntityOverrides, FATHER_HERIT_COLOR, FILE_STRUCTURE_TREE, Globals, Graphics, MAX_PLACEMENTS, NameSource, SHOW, SON_HERIT_COLOR, StyleAlpha,
resolve_style,
};
use crate::bits::{BitReader, Budget};
use crate::entity::Ctx;
use crate::tess::tests::two_face_square;
use crate::testw::W;
use crate::{PrcError, PrcFile, Rgba, Schema, Tessellation, TriangleMesh, UniqueId};
const RED: Rgba = Rgba { r: 1., g: 0., b: 0., a: 1. };
const GREEN: Rgba = Rgba { r: 0., g: 1., b: 0., a: 1. };
const BLUE: Rgba = Rgba { r: 0., g: 0., b: 1., a: 1. };
/// Visible graphics with no style.
pub(super) const PLAIN: (u32, u16) = (0, SHOW);
/// The biased style indices of [`palette`]: red, green, a blue material.
pub(super) const S_RED: u32 = 1;
const S_GREEN: u32 = 2;
const S_BLUE: u32 = 3;
const RI_POLY_BREP: u32 = 237;
fn fs_id(i: usize) -> UniqueId {
UniqueId([0x100 + u32::try_from(i).unwrap(), 1, 2, 3])
}
fn len(n: usize) -> u32 {
u32::try_from(n).unwrap()
}
/// `ContentPRCBase` with no attributes and its own name.
pub(super) fn base(w: &mut W, name: Option<&str>) {
w.uint(0).bit(false).string(name);
}
pub(super) fn ref_base(w: &mut W, name: Option<&str>, uid: u32) {
base(w, name);
w.uint(0).uint(0).uint(uid);
}
/// `PRCBaseWithGraphics` with its own `(style, behaviour)`.
pub(super) fn graphics(w: &mut W, name: Option<&str>, uid: u32, (style, bits): (u32, u16)) {
ref_base(w, name, uid);
w.bit(false).uint(0).uint(style).put(u64::from(bits & 0xff), 8).put(u64::from(bits >> 8), 8);
}
fn file_id(w: &mut W, fs: Option<usize>) {
match fs {
None => {
w.bit(true);
}
Some(i) => {
w.bit(false);
for v in fs_id(i).0 {
w.uint(v);
}
}
}
}
/// An `RI_PolyBrepModel` drawing biased tessellation `tess` under local system `cs`.
pub(super) fn poly_item(w: &mut W, uid: u32, cs: u32, tess: u32, g: (u32, u16)) {
w.uint(RI_POLY_BREP);
graphics(w, None, uid, g);
w.uint(cs).uint(tess).bit(false).uint(0);
}
/// An `RI_BrepModel` drawing tessellation 1, its exact body stored as `brep`.
fn brep_item(w: &mut W, uid: u32, g: (u32, u16), brep: (u32, u32)) {
w.uint(232);
graphics(w, None, uid, g);
w.uint(0).uint(1).bit(true).uint(brep.0).uint(brep.1).bit(false).uint(0);
}
/// A `PartDefinition` holding the `n` items `items` writes, and no markups or views.
fn part(name: Option<&str>, g: (u32, u16), n: usize, items: impl FnOnce(&mut W)) -> W {
let mut none = W::default();
for _ in 0..5 {
none.uint(0);
}
part_with(name, g, n, items, &none)
}
/// [`part`] with `markups` (its markup data and views) written after the items.
pub(super) fn part_with(name: Option<&str>, g: (u32, u16), n: usize, items: impl FnOnce(&mut W), markups: &W) -> W {
let mut w = W::default();
w.uint(311);
graphics(&mut w, name, 0, g);
for _ in 0..6 {
w.double(0.);
}
w.uint(len(n));
items(&mut w);
w.append(markups).uint(0); // user data
w
}
/// One poly-B-rep item (uid 7) drawing tessellation 1 in style `style`.
pub(super) fn plate(style: u32) -> W {
part(Some("Plate"), PLAIN, 1, |w| poly_item(w, 7, 0, 1, (style, SHOW)))
}
#[derive(Default)]
pub(super) struct Occ<'a> {
pub(super) name: Option<&'a str>,
pub(super) g: Option<(u32, u16)>,
pub(super) part: u32,
pub(super) prototype: u32,
pub(super) prototype_fs: Option<usize>,
pub(super) sons: Vec<u32>,
pub(super) suppressed: bool,
pub(super) location: Option<W>,
pub(super) refs: Vec<W>,
/// Its markup data and views; none when `None`.
pub(super) markups: Option<W>,
}
fn occ(w: &mut W, o: &Occ<'_>) {
w.uint(310);
graphics(w, o.name, 0, o.g.unwrap_or(PLAIN));
w.uint(o.part).uint(o.prototype);
if o.prototype != 0 {
file_id(w, o.prototype_fs);
}
w.uint(0).uint(len(o.sons.len()));
for &s in &o.sons {
w.uint(s);
}
w.put(u64::from(o.suppressed), 8);
w.bit(false).double(1.).put(0, 8).int(0);
match &o.location {
Some(t) => w.bit(true).append(t),
None => w.bit(false),
};
w.uint(len(o.refs.len()));
for r in &o.refs {
w.append(r);
}
match &o.markups {
Some(m) => {
w.append(m);
}
None => {
for _ in 0..5 {
w.uint(0);
}
}
}
w.bit(false).uint(0).uint(0).uint(0);
}
pub(super) fn tree(parts: &[W], occs: &[Occ<'_>]) -> W {
let mut w = W::default();
w.uint(304);
base(&mut w, None);
w.uint(len(parts.len()));
for p in parts {
w.append(p);
}
w.uint(len(occs.len()));
for o in occs {
occ(&mut w, o);
}
w.uint(302);
base(&mut w, None);
w.uint(0).uint(0).uint(0);
w
}
fn style(index: u32, is_material: bool, transparency: Option<u8>) -> W {
let mut w = W::default();
w.uint(701);
ref_base(&mut w, None, 0);
w.double(0.).bit(false).uint(0).bit(is_material).uint(index);
match transparency {
Some(t) => w.bit(true).put(u64::from(t), 8),
None => w.bit(false),
};
w.bit(false).bit(false).bit(false);
w
}
fn material(diffuse: u32, alpha: f64) -> W {
let mut w = W::default();
w.uint(702);
ref_base(&mut w, None, 0);
w.uint(0).uint(diffuse).uint(0).uint(0);
w.double(0.).double(1.).double(alpha).double(1.).double(1.);
w
}
/// A globals section (schema included) with `colours`, `materials`, `styles` and reference
/// coordinate systems `systems` (transformations).
fn globals(colours: &[Rgba], materials: &[W], styles: &[W], systems: &[W]) -> W {
let mut schema = W::default();
schema.uint(0);
globals_after(schema, colours, materials, styles, systems)
}
/// [`globals`] after the already-written `schema`.
fn globals_after(mut w: W, colours: &[Rgba], materials: &[W], styles: &[W], systems: &[W]) -> W {
w.uint(303);
base(&mut w, None);
w.uint(0).double(0.).double(0.).string(None).uint(0);
w.uint(len(colours.len()));
for c in colours {
w.double(c.r).double(c.g).double(c.b);
}
w.uint(0).uint(0).uint(len(materials.len()));
for m in materials {
w.append(m);
}
w.uint(0).uint(len(styles.len()));
for s in styles {
w.append(s);
}
w.uint(0).uint(len(systems.len()));
for t in systems {
w.uint(240);
graphics(&mut w, None, 0, PLAIN);
w.uint(0).uint(0).append(t).uint(0);
}
w.uint(0);
w
}
/// Red, green and blue colours, and styles [`S_RED`], [`S_GREEN`] and [`S_BLUE`] (a
/// material with diffuse alpha 0).
fn palette() -> W {
globals(&[RED, GREEN, BLUE], &[material(7, 0.)], &[style(1, false, None), style(4, false, None), style(1, true, None)], &[])
}
fn translate(t: [f64; 3]) -> W {
let mut w = W::default();
w.uint(202).put(0x01, 8).double(t[0]).double(t[1]).double(t[2]);
w
}
/// A translation by `t` after a uniform scale by `s`.
fn translate_scale(t: [f64; 3], s: f64) -> W {
let mut w = W::default();
w.uint(202).put(0x01 | 0x08, 8).double(t[0]).double(t[1]).double(t[2]).double(s);
w
}
/// An entity reference giving the item with PRC unique id `uid` the graphics `g`.
fn ref_entity(uid: u32, g: (u32, u16)) -> W {
ref_entity_at(uid, g, 0)
}
/// [`ref_entity`], also placing its target by biased coordinate system `local`.
fn ref_entity_at(uid: u32, g: (u32, u16), local: u32) -> W {
let mut w = W::default();
w.uint(203);
graphics(&mut w, None, 0, g);
w.uint(local).bit(true).uint(205).uint(RI_POLY_BREP).bit(true).uint(uid).uint(0);
w
}
/// An entity reference giving faces `faces` of B-rep `brep` the graphics `g`.
fn ref_faces(brep: (u32, u32), faces: &[u32], g: (u32, u16)) -> W {
let mut w = W::default();
w.uint(203);
graphics(&mut w, None, 0, g);
w.uint(0).bit(true).uint(206).uint(149).bit(true).bit(true).uint(brep.0).uint(brep.1).uint(len(faces.len()));
for &f in faces {
w.uint(f);
}
w.uint(0);
w
}
/// A model file (schema included) whose roots are `(file structure, biased occurrence)`.
fn model(roots: &[(usize, u32)]) -> W {
let mut w = W::default();
w.uint(0).uint(301);
base(&mut w, None);
w.bit(false).double(1.).uint(len(roots.len()));
for &(fs, index) in roots {
for v in fs_id(fs).0 {
w.uint(v);
}
w.uint(index).bit(true);
}
w
}
/// One file structure's globals, tree and tessellation sections.
struct Fs {
globals: W,
tree: W,
tess: W,
}
fn zlib(data: &[u8]) -> Vec<u8> {
use std::io::Write as _;
let mut e = flate2::write::ZlibEncoder::new(Vec::new(), flate2::Compression::default());
e.write_all(data).unwrap();
e.finish().unwrap()
}
fn u32s(out: &mut Vec<u8>, vs: &[u32]) {
vs.iter().for_each(|v| out.extend_from_slice(&v.to_le_bytes()));
}
/// A PRC stream of `structures` and `model`.
fn prc(structures: &[Fs], model: &W) -> Vec<u8> {
let header_len = 59 + 48 * structures.len();
let at = |body: &Vec<u8>| len(header_len + body.len());
let mut body = Vec::new();
let mut descriptions = Vec::new();
for (i, fs) in structures.iter().enumerate() {
let mut offs = vec![at(&body)];
body.extend(b"PRC");
u32s(&mut body, &[8137, 8137]);
u32s(&mut body, &fs_id(i).0);
u32s(&mut body, &[0, 0, 0, 0, 0]);
for s in [fs.globals.bytes(), fs.tree.bytes(), fs.tess.bytes(), Vec::new(), Vec::new()] {
offs.push(at(&body));
body.extend(zlib(&s));
}
descriptions.push((fs_id(i), offs));
}
let mf_start = at(&body);
body.extend(zlib(&model.bytes()));
let mf_end = at(&body);
let mut out = b"PRC".to_vec();
u32s(&mut out, &[8137, 8137, 1, 2, 3, 4, 0, 0, 0, 0, len(structures.len())]);
for (id, offs) in descriptions {
u32s(&mut out, &id.0);
u32s(&mut out, &[0, 6]);
u32s(&mut out, &offs);
}
u32s(&mut out, &[mf_start, mf_end, 0]);
out.extend(body);
assert_eq!(out.len(), usize::try_from(mf_end).unwrap());
out
}
/// One file structure with [`palette`], `parts` and `occs`, whose root is occurrence 0.
pub(super) fn single(parts: &[W], occs: &[Occ<'_>]) -> PrcFile {
PrcFile::parse(&prc(&[Fs { globals: palette(), tree: tree(parts, occs), tess: two_face_square() }], &model(&[(0, 1)]))).unwrap()
}
fn mesh(f: &PrcFile, fs: usize) -> TriangleMesh {
match f.file_structures[fs].tessellations().unwrap().into_iter().next() {
Some(Tessellation::Mesh(m)) => m,
other => panic!("not a mesh: {other:?}"),
}
}
fn colours(f: &PrcFile, scope: EntityOverrides) -> Vec<Option<Rgba>> {
f.placements_with(StyleAlpha::default(), scope).unwrap().iter().map(|p| p.colour).collect()
}
fn malformed(r: Result<impl std::fmt::Debug, PrcError>) -> String {
match r {
Err(PrcError::Malformed(m)) => m,
other => panic!("expected Malformed, got {other:?}"),
}
}
#[test]
fn a_parsed_assembly_places_names_and_colours_each_occurrence() {
let occs = [
Occ { name: Some("Asm"), sons: vec![1, 2], location: Some(translate([0., 0., 100.])), ..Occ::default() },
Occ { part: 1, location: Some(translate([10., 0., 0.])), ..Occ::default() },
Occ { name: Some("B"), part: 1, location: Some(translate([0., 5., 0.])), ..Occ::default() },
];
let f = single(&[plate(S_RED)], &occs);
assert!(f.stores_tree());
let p = f.placements().unwrap();
assert_eq!(p.len(), 2);
let m = mesh(&f, 0);
let moved: Vec<_> = p.iter().map(|p| (p.file_structure, p.tessellation, m.transformed(&p.matrix).positions[2])).collect();
assert_eq!(moved, [(0, 0, [11., 1., 100.]), (0, 0, [1., 6., 100.])]);
assert_eq!(p.iter().map(|p| p.colour).collect::<Vec<_>>(), [Some(RED); 2]);
// A material with diffuse alpha 0 and no style transparency reads as opaque.
assert_eq!(colours(&single(&[plate(S_BLUE)], &occs), EntityOverrides::default()), [Some(BLUE); 2]);
let nodes = f.model_tree().unwrap();
let summary: Vec<_> = nodes.iter().map(|n| (n.name.as_deref(), n.name_from, n.parent, n.depth, n.placements.clone())).collect();
assert_eq!(
summary,
[
(Some("Asm"), NameSource::Occurrence, None, 0, 0..2),
(Some("Plate"), NameSource::Part, Some(0), 1, 0..1),
(Some("B"), NameSource::Occurrence, Some(0), 1, 1..2),
]
);
}
#[test]
fn a_file_without_a_model_file_entity_has_no_tree() {
let fs = Fs { globals: palette(), tree: tree(&[], &[]), tess: two_face_square() };
let bytes = prc(&[fs], &W::default());
let f = PrcFile::parse(&bytes).unwrap();
assert!(!f.stores_tree());
assert!(f.placements().unwrap().is_empty());
}
#[test]
fn an_occurrence_that_contains_itself_is_an_error() {
let occs = [Occ { sons: vec![1], ..Occ::default() }, Occ { part: 1, sons: vec![0, 0], ..Occ::default() }];
assert!(malformed(single(&[plate(S_RED)], &occs).placements()).contains("contains itself"));
}
#[test]
fn a_prototype_cycle_is_an_error() {
let occs = [Occ { prototype: 2, ..Occ::default() }, Occ { prototype: 1, ..Occ::default() }];
assert!(malformed(single(&[], &occs).model_tree()).contains("own prototype"));
}
/// One element allowance covers the whole walk: an allowance that fits one file structure does
/// not fit two, and running short of it is reported as such.
#[test]
fn one_element_allowance_covers_the_whole_walk() {
// A part of 64 items, so each file structure's tree section, not its globals or the model
// file, decodes most of the elements.
let wide = || part(None, PLAIN, 64, |w| (0..64).for_each(|_| poly_item(w, 0, 0, 1, PLAIN)));
let fs = || Fs { globals: palette(), tree: tree(&[wide()], &[Occ { part: 1, ..Occ::default() }]), tess: two_face_square() };
let one = PrcFile::parse(&prc(&[fs()], &model(&[(0, 1)]))).unwrap();
let two = PrcFile::parse(&prc(&[fs(), fs()], &model(&[(0, 1), (1, 1)]))).unwrap();
let walk = |f: &PrcFile, n| f.walk_within(StyleAlpha::default(), EntityOverrides::default(), Budget { elements: n, ..Budget::FULL });
let short = |f: &PrcFile, n| matches!(walk(f, n), Err(PrcError::TooManyElements { .. }));
// One structure decodes about 70 elements, two about 140.
assert!(short(&one, 32));
assert_eq!(walk(&one, 100).map(|w| w.0.len()), Ok(64));
assert!(short(&two, 100), "each structure fits in 100, both do not");
assert_eq!(walk(&two, 200).map(|w| w.0.len()), Ok(128));
}
/// One schema-step allowance covers the whole walk: each structure's tree runs a 2,000-step
/// program, which a 3,000-step allowance fits once but not twice.
#[test]
fn one_step_allowance_covers_the_whole_walk() {
let fs = || {
let mut schema = W::default();
// For (1000) { empty block } on the file structure tree.
schema.uint(1).uint(FILE_STRUCTURE_TREE).uint(5);
for t in [15, 26, 1000, 19, 21] {
schema.uint(t);
}
let globals = globals_after(schema, &[RED], &[], &[], &[]);
Fs { globals, tree: tree(&[plate(S_RED)], &[Occ { part: 1, ..Occ::default() }]), tess: two_face_square() }
};
let one = PrcFile::parse(&prc(&[fs()], &model(&[(0, 1)]))).unwrap();
let two = PrcFile::parse(&prc(&[fs(), fs()], &model(&[(0, 1), (1, 1)]))).unwrap();
let walk = |f: &PrcFile| f.walk_within(StyleAlpha::default(), EntityOverrides::default(), Budget { steps: 3000, ..Budget::FULL });
assert_eq!(walk(&one).map(|w| w.0.len()), Ok(1));
assert!(matches!(walk(&two), Err(PrcError::Malformed(m)) if m.contains("step ceiling")));
assert_eq!(two.placements().map(|p| p.len()), Ok(2));
}
/// Each structure's schema is read once, charged to the walk's allowance: a schema too large
/// for what is left is an error, not decoded outside the allowance and then skipped.
#[test]
fn the_globals_schema_is_charged_to_the_walk() {
let mut schema = W::default();
// 200 empty entries cost 200 elements.
schema.uint(200);
for t in 0..200 {
schema.uint(50_000 + t).uint(0);
}
let fs = Fs {
globals: globals_after(schema, &[RED], &[], &[], &[]),
tree: tree(&[plate(S_RED)], &[Occ { part: 1, ..Occ::default() }]),
tess: two_face_square(),
};
let f = PrcFile::parse(&prc(&[fs], &model(&[(0, 1)]))).unwrap();
let walk = |n| f.walk_within(StyleAlpha::default(), EntityOverrides::default(), Budget { elements: n, ..Budget::FULL });
assert!(matches!(walk(100), Err(PrcError::TooManyElements { .. })));
assert_eq!(walk(1000).map(|w| w.0.len()), Ok(1));
}
/// Globals that cannot be read are reported, not replaced by empty ones, when an entity
/// reference names one of their coordinate systems.
#[test]
fn unreadable_globals_are_an_error_when_a_reference_names_a_coordinate_system() {
let file = |local| {
let mut fonts = W::default();
fonts.uint(0).uint(303);
base(&mut fonts, None);
fonts.uint(0).double(0.).double(0.).string(None).uint(1);
let occs = [Occ { part: 1, refs: vec![ref_entity_at(7, PLAIN, local)], ..Occ::default() }];
let fs = Fs { globals: fonts, tree: tree(&[plate(S_RED)], &occs), tess: two_face_square() };
PrcFile::parse(&prc(&[fs], &model(&[(0, 1)]))).unwrap()
};
assert_eq!(file(0).placements().map(|p| p.len()), Ok(1));
assert!(matches!(file(1).placements(), Err(PrcError::Unsupported("PRC global fonts"))));
}
#[test]
fn an_exponential_walk_is_cut_off() {
// Occurrence k has occurrence k + 1 twice as sons: 2^21 visits.
let occs: Vec<_> = (0..21).map(|k| Occ { sons: if k < 20 { vec![k + 1, k + 1] } else { Vec::new() }, ..Occ::default() }).collect();
assert!(malformed(single(&[], &occs).model_tree()).contains("too large"));
}
#[test]
fn placements_past_the_ceiling_are_an_error() {
// 1,025 placements of a part with 1,024 items.
let items = 1024;
let wide = part(None, PLAIN, items, |w| (0..items).for_each(|_| poly_item(w, 0, 0, 1, PLAIN)));
let occs = [Occ { sons: vec![1; 1025], ..Occ::default() }, Occ { part: 1, ..Occ::default() }];
assert!(1025 * items > MAX_PLACEMENTS);
assert!(malformed(single(&[wide], &occs).placements()).contains("placements"));
}
#[test]
fn hidden_and_suppressed_occurrences_are_listed_but_not_placed() {
let occs = [
Occ { sons: vec![1, 2, 3], ..Occ::default() },
Occ { part: 1, ..Occ::default() },
Occ { part: 1, suppressed: true, ..Occ::default() },
Occ { part: 1, sons: vec![1], g: Some((0, 0)), ..Occ::default() },
];
let f = single(&[plate(S_RED)], &occs);
assert_eq!(f.placements().unwrap().len(), 1);
let nodes = f.model_tree().unwrap();
let flags: Vec<_> = nodes.iter().map(|n| (n.occurrence, n.hidden, n.suppressed, n.drawn)).collect();
assert_eq!(flags, [(0, false, false, true), (1, false, false, true), (2, false, true, false), (3, true, false, false), (1, false, false, false)]);
}
#[test]
fn a_father_herit_colour_beats_the_part_and_a_son_herit_colour_beats_that() {
let forced = (S_GREEN, SHOW | FATHER_HERIT_COLOR);
let occs = [Occ { sons: vec![1], g: Some(forced), ..Occ::default() }, Occ { part: 1, ..Occ::default() }];
assert_eq!(colours(&single(&[plate(S_RED)], &occs), EntityOverrides::default()), [Some(GREEN)]);
let son = part(None, PLAIN, 1, |w| poly_item(w, 7, 0, 1, (S_RED, SHOW | SON_HERIT_COLOR)));
assert_eq!(colours(&single(&[son], &occs), EntityOverrides::default()), [Some(RED)]);
// Unforced, the son's own style wins over its father's.
let occs = [Occ { sons: vec![1], g: Some((S_GREEN, SHOW)), ..Occ::default() }, Occ { part: 1, ..Occ::default() }];
assert_eq!(colours(&single(&[plate(S_RED)], &occs), EntityOverrides::default()), [Some(RED)]);
}
#[test]
fn resolve_style_takes_the_oldest_forcing_ancestor() {
let g = |style, bits| Graphics { style, bits, fs: 0 };
let chain = [g(1, FATHER_HERIT_COLOR), g(2, FATHER_HERIT_COLOR), g(0, 0), g(3, 0)];
assert_eq!(resolve_style(&chain).style, 1);
assert_eq!(resolve_style(&[g(1, 0), g(0, 0)]).style, 1);
assert_eq!(resolve_style(&[]).style, 0);
}
#[test]
fn a_prototypes_part_is_coloured_by_its_own_structures_styles() {
// Structure 1 is a part library whose style 1 is green; structure 0's style 1 is red.
let library = Fs {
globals: globals(&[GREEN], &[], &[style(1, false, None)], &[]),
tree: tree(&[plate(1)], &[Occ { name: Some("Bolt"), part: 1, ..Occ::default() }]),
tess: two_face_square(),
};
let assembly = Fs {
globals: globals(&[RED], &[], &[style(1, false, None)], &[]),
tree: tree(&[], &[Occ { prototype: 1, prototype_fs: Some(1), location: Some(translate([1., 2., 3.])), ..Occ::default() }]),
tess: W::default(),
};
let f = PrcFile::parse(&prc(&[assembly, library], &model(&[(0, 1)]))).unwrap();
let p = f.placements().unwrap();
assert_eq!(p.iter().map(|p| (p.file_structure, p.colour, p.matrix.at(1, 3))).collect::<Vec<_>>(), [(1, Some(GREEN), 2.)]);
let n = f.model_tree().unwrap();
assert_eq!((n[0].name.as_deref(), n[0].name_from), (Some("Bolt"), NameSource::Prototype));
}
/// A root placing the red plate twice, the first occurrence carrying `refs`.
fn shared_plate(refs: Vec<W>) -> PrcFile {
let occs = [Occ { sons: vec![1, 2], ..Occ::default() }, Occ { part: 1, refs, ..Occ::default() }, Occ { part: 1, ..Occ::default() }];
single(&[plate(S_RED)], &occs)
}
#[test]
fn an_entity_reference_reaches_its_scope() {
let f = shared_plate(vec![ref_entity(7, (S_GREEN, SHOW))]);
assert_eq!(colours(&f, EntityOverrides::Subtree), [Some(GREEN), Some(RED)]);
assert_eq!(colours(&f, EntityOverrides::Everywhere), [Some(GREEN), Some(GREEN)]);
assert_eq!(colours(&f, EntityOverrides::Ignore), [Some(RED), Some(RED)]);
// A reference to another uid changes nothing; one without Show hides its target.
assert_eq!(colours(&shared_plate(vec![ref_entity(8, (S_GREEN, SHOW))]), EntityOverrides::Subtree), [Some(RED); 2]);
assert_eq!(colours(&shared_plate(vec![ref_entity(7, (0, 0))]), EntityOverrides::Subtree), [Some(RED)]);
}
#[test]
fn a_topology_reference_colours_its_faces() {
let brep = part(None, PLAIN, 1, |w| brep_item(w, 7, (S_RED, SHOW), (4, 9)));
let occs = [Occ { part: 1, refs: vec![ref_faces((4, 9), &[1], (S_GREEN, SHOW))], ..Occ::default() }];
let f = single(&[brep], &occs);
let p = f.placements().unwrap();
assert_eq!(p[0].colour, Some(RED));
assert_eq!(p[0].triangle_colours(&mesh(&f, 0)), Some(vec![Some(RED), Some(GREEN)]));
// Another body's faces are left alone.
let occs = [Occ { part: 1, refs: vec![ref_faces((4, 8), &[1], (S_GREEN, SHOW))], ..Occ::default() }];
let f = single(&[part(None, PLAIN, 1, |w| brep_item(w, 7, (S_RED, SHOW), (4, 9)))], &occs);
assert_eq!(f.placements().unwrap()[0].triangle_colours(&mesh(&f, 0)), None);
}
#[test]
fn an_items_coordinate_system_applies_after_the_occurrence_location() {
let fs = Fs {
globals: globals(&[RED], &[], &[], &[translate([0., 0., 7.])]),
tree: tree(
&[part(None, PLAIN, 1, |w| poly_item(w, 7, 1, 1, PLAIN))],
&[Occ { part: 1, location: Some(translate_scale([1., 0., 0.], 2.)), ..Occ::default() }],
),
tess: two_face_square(),
};
let f = PrcFile::parse(&prc(&[fs], &model(&[(0, 1)]))).unwrap();
let p = f.placements().unwrap();
assert_eq!((p[0].matrix.at(0, 3), p[0].matrix.at(2, 3), p[0].colour), (1., 14., None));
}
#[test]
fn a_colour_index_counts_doubles() {
// pdf-issues #816: colour i is stored as 3i + 1.
let g =
|index| Globals { colours: vec![RED, GREEN], styles: vec![Style { is_material: false, index, transparency: None }], ..Globals::default() };
let paint = |index| g(index).style_paint(1, StyleAlpha::default()).map(|p| p.rgba);
assert_eq!(paint(1), Some(RED));
assert_eq!(paint(4), Some(GREEN));
assert_eq!(paint(2), None);
assert_eq!(paint(7), None);
}
#[test]
fn style_alpha_rules_combine_transparency_with_material_alpha() {
let g = |alpha, transparency| Globals {
colours: vec![BLUE],
materials: vec![Material::Plain { diffuse: 1, alpha }],
styles: vec![Style { is_material: true, index: 1, transparency }],
..Globals::default()
};
let a = |alpha, t, rule| g(alpha, t).style_paint(1, rule).unwrap().rgba.a;
assert_eq!(a(0., None, StyleAlpha::ZeroUnset), 1.);
assert_eq!(a(0., None, StyleAlpha::StyleWins), 0.);
assert_eq!(a(0.5, Some(51), StyleAlpha::StyleWins), 0.2);
assert_eq!(a(0.5, Some(51), StyleAlpha::Multiply), 0.1);
assert_eq!(a(f64::NAN, None, StyleAlpha::Multiply), 1.);
// A textured material takes its base's colour.
let mut t = g(1., None);
t.materials.push(Material::Textured { base: 1 });
t.styles[0].index = 2;
assert_eq!(t.style_paint(1, StyleAlpha::default()).unwrap().rgba, BLUE);
}
fn transformation(behaviour: u8, fields: &[f64]) -> super::Matrix {
let mut w = W::default();
w.uint(202).put(u64::from(behaviour), 8);
for &d in fields {
w.double(d);
}
let bytes = w.bytes();
Ctx::new(BitReader::new(&bytes), &Schema::default(), 8137).transformation().unwrap()
}
#[test]
fn a_mirrored_rotation_takes_y_cross_x_and_both_scales_multiply() {
let x_y = [1., 0., 0., 0., 1., 0.];
assert_eq!(transformation(0x02, &x_y).at(2, 2), 1.);
assert_eq!(transformation(0x02 | 0x04, &x_y).at(2, 2), -1.);
let m = transformation(0x10 | 0x08, &[1., 2., 3., 2.]);
assert_eq!([m.at(0, 0), m.at(1, 1), m.at(2, 2)], [2., 4., 6.]);
let m = transformation(0x40, &[0., 0., 0.5, 2.]);
assert_eq!(m.0[3], [0., 0., 0.5, 2.]);
}
#[test]
fn every_truncation_of_a_tree_or_globals_is_an_error_not_a_panic() {
let occs = [
Occ { name: Some("Asm"), sons: vec![1], location: Some(translate([0., 0., 1.])), ..Occ::default() },
Occ { part: 1, refs: vec![ref_entity(7, (S_GREEN, SHOW)), ref_faces((1, 1), &[0], PLAIN)], ..Occ::default() },
];
let t = tree(&[plate(S_RED)], &occs).bytes();
let schema = Schema::default();
for end in 0..t.len().saturating_sub(1) {
assert!(Ctx::new(BitReader::new(&t[..end]), &schema, 8137).file_structure_tree().is_err(), "tree cut at {end}");
}
let g = palette().bytes();
for end in 1..g.len().saturating_sub(1) {
let mut r = BitReader::new(&g[..end]);
if Schema::read(&mut r).is_ok() {
assert!(Ctx::new(r, &schema, 8137).globals().is_err(), "globals cut at {end}");
}
}
}
#[test]
fn a_prototype_chain_past_the_ceiling_is_an_error() {
// Occurrence k (1-based) has occurrence k + 1 as its prototype; none has a part.
let n = u32::try_from(super::MAX_DEPTH).unwrap() + 3;
let occs: Vec<_> = (1..=n).map(|k| Occ { prototype: if k < n { k + 1 } else { 0 }, ..Occ::default() }).collect();
assert!(malformed(single(&[], &occs).model_tree()).contains("prototype chain too long"));
}
/// `depth` representation sets, each holding the next, around one poly-B-rep item.
fn nested_sets(w: &mut W, depth: usize) {
if depth == 0 {
return poly_item(w, 0, 0, 1, PLAIN);
}
w.uint(super::RI_SET);
graphics(w, None, 0, PLAIN);
w.uint(0).uint(0).uint(1);
nested_sets(w, depth - 1);
w.uint(0); // user data
}
#[test]
fn representation_sets_nested_past_the_ceiling_are_an_error() {
let deep = part(None, PLAIN, 1, |w| nested_sets(w, super::MAX_DEPTH + 1));
let occs = [Occ { part: 1, ..Occ::default() }];
assert!(malformed(single(&[deep], &occs).placements()).contains("representation sets nest too deep"));
let ok = part(None, PLAIN, 1, |w| nested_sets(w, super::MAX_DEPTH));
assert_eq!(single(&[ok], &occs).placements().unwrap().len(), 1);
}
crates/prc/src/tree/walk.rs
+262
View File
@@ -0,0 +1,262 @@
//! The occurrence walk that turns the trees into placements [WD 7.3.10.1, 7.6.3.2].
use super::overrides::{Active, Reached};
use super::{
EntityOverrides, Globals, Graphics, MAX_DEPTH, MAX_PLACEMENTS, MAX_VISITS, Matrix, ModelNode, NameSource, Override, Palettes, Placement, Product,
StyleAlpha, Target, Tree, UniqueId, paint_of, resolve_style, style,
};
use crate::PrcError;
use crate::container::offset;
use crate::entity::malformed;
/// Ceiling on face-override entries all placements of one walk carry together.
const MAX_FACE_OVERRIDES: usize = 1 << 24;
/// Where an occurrence sits: its depth, its parent node and whether its ancestors are drawn.
#[derive(Debug, Clone, Copy)]
pub(super) struct At {
depth: usize,
parent: Option<usize>,
drawn: bool,
}
impl At {
/// A root occurrence.
pub(super) const ROOT: At = At { depth: 0, parent: None, drawn: true };
}
/// An occurrence's part and sons as `(file structure, value)`, after the prototype fallback.
struct Resolved<'t> {
part: (usize, u32),
sons: (usize, &'t [u32]),
proto_name: Option<&'t str>,
/// The entity references in force: the occurrence's own, else its prototype chain's
/// first.
overrides: (usize, &'t [Override]),
}
/// The occurrence walk over every file structure's tree.
pub(super) struct Walk<'t> {
/// Per file structure: its id, tree and globals.
trees: Vec<(UniqueId, &'t Tree, &'t Globals)>,
pub(super) out: Vec<Placement>,
pub(super) nodes: Vec<ModelNode>,
visits: usize,
face_overrides: usize,
palettes: Palettes,
scope: EntityOverrides,
/// The entity references of the occurrences being walked, outermost first; under
/// [`EntityOverrides::Everywhere`], every occurrence's.
active: Vec<Active<'t>>,
/// The `(file structure, occurrence)` of each occurrence being walked, root first: an
/// occurrence met again on its own path is a cycle.
path: Vec<(usize, usize)>,
}
impl<'t> Walk<'t> {
/// A walk over `trees`, with no placements yet, colouring by `rule` and applying entity
/// references by `scope`.
pub(super) fn new(trees: Vec<(UniqueId, &'t Tree, &'t Globals)>, rule: StyleAlpha, scope: EntityOverrides) -> Self {
let palettes = trees
.iter()
.map(|(_, _, g)| (0..=g.styles.len()).map(|b| u32::try_from(b).ok().and_then(|b| g.style_paint(b, rule))).collect())
.collect();
let mut walk =
Walk { trees, out: Vec::new(), nodes: Vec::new(), visits: 0, face_overrides: 0, palettes, scope, active: Vec::new(), path: Vec::new() };
if scope == EntityOverrides::Everywhere {
let trees = walk.trees.clone();
for (fs, t) in trees.iter().enumerate() {
for p in &t.1.products {
walk.activate(fs, &p.overrides);
}
}
}
walk
}
/// Puts `overrides`, held by an occurrence of structure `owner`, in force. One naming an
/// unknown structure is left out.
fn activate(&mut self, owner: usize, overrides: &'t [Override]) {
for ov in overrides {
let named = match (ov.target.fs(), &ov.target) {
(Some(id), _) => match self.fs(id) {
Ok(n) => Some(n),
Err(_) => continue,
},
(None, Target::Entity { .. }) => Some(owner),
(None, Target::Topology { .. }) => None,
};
self.active.push((owner, named, ov));
}
}
fn fs(&self, id: UniqueId) -> Result<usize, PrcError> {
self.trees.iter().position(|t| t.0 == id).ok_or_else(|| malformed("reference to an unknown file structure".into()))
}
fn product(&self, fs: usize, index: usize) -> Result<&'t Product, PrcError> {
self.trees.get(fs).and_then(|t| t.1.products.get(index)).ok_or_else(|| malformed(format!("product occurrence {index} does not exist")))
}
/// The structure a file identifier names: `id`, or `fs` itself when it names none.
fn named(&self, id: Option<UniqueId>, fs: usize) -> Result<usize, PrcError> {
id.map_or(Ok(fs), |id| self.fs(id))
}
/// Walks occurrence `index` of structure `fs` under a father placed at `father`, whose
/// occurrences' graphics are `graphics` (root first), and lists it as a node. A hidden or
/// suppressed subtree is listed with `drawn` false and placed nowhere.
pub(super) fn occurrence(&mut self, fs: usize, index: usize, father: &Matrix, graphics: &[Graphics], at: At) -> Result<(), PrcError> {
self.visits = self.visits.saturating_add(1);
if at.depth > MAX_DEPTH || self.visits > MAX_VISITS {
return Err(malformed("the occurrence tree is too deep or too large".into()));
}
if self.path.contains(&(fs, index)) {
return Err(malformed(format!("product occurrence {index} contains itself")));
}
let p = self.product(fs, index)?;
let m = p.location.map_or(*father, |l| father.multiply(&l));
let mut chain = graphics.to_vec();
chain.push(Graphics { fs, ..p.graphics });
let r = self.resolve(fs, index, p)?;
let drawn = at.drawn && !p.hidden && !p.suppressed;
let in_force = self.active.len();
if self.scope == EntityOverrides::Subtree {
self.activate(r.overrides.0, r.overrides.1);
}
let node = self.nodes.len();
let first = self.out.len();
let (name, name_from) = self.name_of(p, &r);
self.nodes.push(ModelNode {
name,
name_from,
parent: at.parent,
depth: at.depth,
file_structure: fs,
occurrence: index,
hidden: p.hidden,
suppressed: p.suppressed,
drawn,
has_part: r.part.1 != 0,
placements: first..first,
});
if let (true, Some(part)) = (drawn, r.part.1.checked_sub(1)) {
self.part(r.part.0, offset(part), &m, &chain)?;
}
// Son indices are 0-based; the external one is biased.
let external = match p.external.checked_sub(1) {
Some(e) => Some((self.named(p.external_fs, fs)?, e)),
None => None,
};
let child = At { depth: at.depth + 1, parent: Some(node), drawn };
self.path.push((fs, index));
let walked =
r.sons.1.iter().map(|&s| (r.sons.0, s)).chain(external).try_for_each(|(sfs, s)| self.occurrence(sfs, offset(s), &m, &chain, child));
self.path.pop();
walked?;
self.active.truncate(in_force);
let end = self.out.len();
if let Some(n) = self.nodes.get_mut(node) {
n.placements = first..end;
}
Ok(())
}
/// The part and sons of `p` (occurrence `index` of `fs`), falling back to its prototype
/// chain's for whichever it leaves empty [WD 7.3.10.1], and the first name on that chain.
fn resolve(&self, fs: usize, index: usize, p: &'t Product) -> Result<Resolved<'t>, PrcError> {
let (mut part, mut sons) = ((fs, p.part), (fs, p.sons.as_slice()));
let mut proto_name = None;
let mut overrides = (fs, p.overrides.as_slice());
let mut proto = (fs, p.prototype, p.prototype_fs);
let mut seen = vec![(fs, index)];
while proto.1 != 0 && (part.1 == 0 || sons.1.is_empty() || proto_name.is_none() || overrides.1.is_empty()) {
let pfs = self.named(proto.2, proto.0)?;
let pi = offset(proto.1.saturating_sub(1));
if seen.contains(&(pfs, pi)) {
return Err(malformed(format!("product occurrence {pi} is its own prototype")));
}
if seen.len() > MAX_DEPTH {
return Err(malformed("prototype chain too long".into()));
}
seen.push((pfs, pi));
let q = self.product(pfs, pi)?;
if part.1 == 0 {
part = (pfs, q.part);
}
if sons.1.is_empty() {
sons = (pfs, q.sons.as_slice());
}
if proto_name.is_none() {
proto_name = q.name.as_deref();
}
if overrides.1.is_empty() {
overrides = (pfs, q.overrides.as_slice());
}
proto = (pfs, q.prototype, q.prototype_fs);
}
Ok(Resolved { part, sons, proto_name, overrides })
}
/// The display name: the occurrence's, its prototype chain's, then its part's.
fn name_of(&self, p: &Product, r: &Resolved<'_>) -> (Option<String>, NameSource) {
if let Some(n) = &p.name {
return (Some(n.clone()), NameSource::Occurrence);
}
if let Some(n) = r.proto_name {
return (Some(n.to_owned()), NameSource::Prototype);
}
let part = r.part.1.checked_sub(1).and_then(|i| self.trees.get(r.part.0)?.1.part_names.get(offset(i))).and_then(Option::as_ref);
match part {
Some(n) => (Some(n.clone()), NameSource::Part),
None => (None, NameSource::Unnamed),
}
}
/// Places part definition `index` of structure `fs` at `m`, under `graphics`.
fn part(&mut self, fs: usize, index: usize, m: &Matrix, graphics: &[Graphics]) -> Result<(), PrcError> {
let (_, tree, _) = self.trees.get(fs).copied().ok_or_else(|| malformed("file structure out of range".into()))?;
let items = tree.parts.get(index).ok_or_else(|| malformed(format!("part definition {index} does not exist")))?;
for item in items {
let reached = Reached::collect(&self.active, fs, item);
if reached.hidden {
continue;
}
if self.out.len() >= MAX_PLACEMENTS {
return Err(malformed(format!("more than {MAX_PLACEMENTS} placements")));
}
self.face_overrides = self.face_overrides.saturating_add(reached.faces.len());
if self.face_overrides > MAX_FACE_OVERRIDES {
return Err(malformed("too many face overrides".into()));
}
let matrix = match reached.local {
Some((owner, cs)) => self.located(m, owner, &[cs])?,
None => self.located(m, fs, &item.local)?,
};
let chain: Vec<Graphics> = graphics.iter().copied().chain(item.graphics.iter().map(|&g| Graphics { fs, ..g })).collect();
let won = reached.item.unwrap_or_else(|| resolve_style(&chain));
self.out.push(Placement {
file_structure: fs,
tessellation: offset(item.tessellation.saturating_sub(1)),
matrix,
colour: paint_of(&self.palettes, won).map(|p| p.rgba),
palettes: self.palettes.clone(),
chain,
item_override: reached.item,
face_overrides: reached.faces,
});
}
Ok(())
}
/// `m` × each of structure `fs`'s coordinate systems `local` (biased).
fn located(&self, m: &Matrix, fs: usize, local: &[u32]) -> Result<Matrix, PrcError> {
let globals = self.trees.get(fs).ok_or_else(|| malformed("file structure out of range".into()))?.2;
let mut placed = *m;
for &cs in local {
let l = style::biased(&globals.systems, cs).ok_or_else(|| malformed(format!("coordinate system {cs} does not exist")))?;
placed = placed.multiply(l);
}
Ok(placed)
}
}
crates/prc/tests/container.rs
+140
View File
@@ -0,0 +1,140 @@
//! The PRC container walk [WD 6.1-6.2] against synthetic streams.
#![allow(clippy::unwrap_used)]
use std::io::Write;
use pdfcraft_prc::{MAX_FILE_STRUCTURES, PrcError, PrcFile, SectionKind, UniqueId};
fn zlib(data: &[u8]) -> Vec<u8> {
let mut e = flate2::write::ZlibEncoder::new(Vec::new(), flate2::Compression::default());
e.write_all(data).unwrap();
e.finish().unwrap()
}
fn u32s(out: &mut Vec<u8>, vs: &[u32]) {
for v in vs {
out.extend_from_slice(&v.to_le_bytes());
}
}
/// One file structure with the given section payloads and model file.
fn build(sections: [&[u8]; 5], model: &[u8], padding: usize) -> Vec<u8> {
const HEADER_LEN: usize = 107;
let mut fs_header = b"PRC".to_vec();
u32s(&mut fs_header, &[8137, 8137, 5, 6, 7, 8, 0, 0, 0, 0, 1, 3]);
fs_header.extend_from_slice(b"\xff\xd8\xff");
let mut body = fs_header.clone();
let mut offs = vec![HEADER_LEN];
for s in sections {
offs.push(HEADER_LEN + body.len());
body.extend(zlib(s));
body.extend(std::iter::repeat_n(0u8, padding));
}
let mf_start = HEADER_LEN + body.len();
body.extend(zlib(model));
let mf_end = HEADER_LEN + body.len();
let mut out = b"PRC".to_vec();
u32s(&mut out, &[8137, 8137, 1, 2, 3, 4, 0, 0, 0, 0, 1]);
u32s(&mut out, &[5, 6, 7, 8, 0, 6]);
u32s(&mut out, &offs.iter().map(|&o| o as u32).collect::<Vec<_>>());
u32s(&mut out, &[mf_start as u32, mf_end as u32, 0]);
assert_eq!(out.len(), HEADER_LEN);
out.extend(body);
out
}
const SECTIONS: [&[u8]; 5] = [b"globals", b"tree", b"tess", b"", b"extra"];
#[test]
fn the_container_walk_inflates_every_section() {
for padding in [0, 3] {
let f = PrcFile::parse(&build(SECTIONS, b"model file", padding)).unwrap();
assert_eq!(f.header.min_version_for_read, 8137);
assert_eq!(f.header.file_id, UniqueId([1, 2, 3, 4]));
assert_eq!(f.file_structures.len(), 1);
let fs = &f.file_structures[0];
assert_eq!(fs.id, UniqueId([5, 6, 7, 8]));
assert_eq!(fs.pictures, vec![b"\xff\xd8\xff".to_vec()]);
for (kind, want) in SectionKind::ALL.into_iter().zip(SECTIONS) {
assert_eq!(fs.section(kind), want, "{}", kind.name());
}
assert_eq!(f.model_file, b"model file");
}
}
#[test]
fn damaged_containers_are_refused_by_name() {
let good = build(SECTIONS, b"m", 0);
assert_eq!(PrcFile::parse(b"U3D\0").unwrap_err(), PrcError::NotPrc);
assert!(matches!(PrcFile::parse(&good[..40]), Err(PrcError::Truncated(_))));
// Reserved field (offset 63) not zero.
let mut bad = good.clone();
bad[63] = 1;
assert!(matches!(PrcFile::parse(&bad), Err(PrcError::Malformed(_))));
// File-structure id disagrees with its description (FS header id at 107+11).
let mut bad = good.clone();
bad[118] ^= 0xff;
assert!(matches!(PrcFile::parse(&bad), Err(PrcError::Malformed(_))));
// A section that is not zlib: corrupt the globals stream's header byte.
let globals = u32::from_le_bytes(good[75..79].try_into().unwrap()) as usize;
let mut bad = good.clone();
bad[globals] = 0;
assert!(matches!(PrcFile::parse(&bad), Err(PrcError::Inflate { section: "globals", .. })));
// Offsets out of order.
let mut bad = good;
bad[75..79].copy_from_slice(&1u32.to_le_bytes());
assert!(matches!(PrcFile::parse(&bad), Err(PrcError::Malformed(_))));
}
#[test]
fn the_inflation_ceiling_is_reported_not_exceeded() {
// 1,200 inflated bytes and the 3-byte picture.
let f = build([&[0u8; 600], &[0u8; 600], b"", b"", b""], b"", 0);
assert!(PrcFile::parse_with_limit(&f, 1203).is_ok());
assert_eq!(PrcFile::parse_with_limit(&f, 1202).unwrap_err(), PrcError::TooLarge { limit: 1202 });
}
#[test]
fn copied_picture_blocks_are_charged_to_the_ceiling() {
// Nothing inflates to more than 0 bytes; the header's one picture is 3 bytes.
let f = build([b"", b"", b"", b"", b""], b"", 0);
assert!(PrcFile::parse_with_limit(&f, 3).is_ok());
assert_eq!(PrcFile::parse_with_limit(&f, 2).unwrap_err(), PrcError::TooLarge { limit: 2 });
}
#[test]
fn an_offset_or_count_past_the_data_is_an_error_not_a_panic() {
let mut bad = build(SECTIONS, b"m", 0);
// The model file's start (header offset 95) far past the end, its end further still.
bad[95..99].copy_from_slice(&u32::MAX.to_le_bytes());
bad[99..103].copy_from_slice(&u32::MAX.to_le_bytes());
assert!(PrcFile::parse(&bad).is_err());
// A model file ending one byte past the data, its zlib stream whole.
let mut bad = build(SECTIONS, b"m", 0);
let past = u32::try_from(bad.len() + 1).unwrap();
bad[99..103].copy_from_slice(&past.to_le_bytes());
assert!(matches!(PrcFile::parse(&bad), Err(PrcError::Malformed(_))));
// A section count that claims more offsets than the data holds.
let mut bad = build(SECTIONS, b"m", 0);
bad[67..71].copy_from_slice(&u32::MAX.to_le_bytes());
assert!(matches!(PrcFile::parse(&bad), Err(PrcError::Truncated(_))));
}
#[test]
fn no_file_structures_or_more_than_the_cap_is_refused_by_name() {
let good = build(SECTIONS, b"m", 0);
// The file-structure count follows the magic, two versions and two ids.
assert_eq!(good[43..47], 1u32.to_le_bytes());
for n in [0, u32::try_from(MAX_FILE_STRUCTURES).unwrap() + 1] {
let mut bad = good.clone();
bad[43..47].copy_from_slice(&n.to_le_bytes());
assert!(matches!(PrcFile::parse(&bad), Err(PrcError::Malformed(m)) if m == format!("{n} file structures")), "{n}");
}
}
crates/prc/tests/proptests.rs
+41
View File
@@ -0,0 +1,41 @@
//! Arbitrary bytes through every reader: an error or a value, never a panic.
use pdfcraft_prc::{BitReader, PrcFile, Schema};
use proptest::prelude::*;
proptest! {
#[test]
fn any_bytes_parse_or_fail_cleanly(data in proptest::collection::vec(any::<u8>(), 0..512), magic in any::<bool>()) {
let mut data = data;
if magic && data.len() >= 3 {
data[..3].copy_from_slice(b"PRC");
}
let _ = PrcFile::parse_with_limit(&data, 1 << 20);
}
#[test]
fn any_bits_read_or_fail_cleanly(data in proptest::collection::vec(any::<u8>(), 0..64), n in 0u32..40) {
let mut r = BitReader::new(&data);
let _ = r.unsigned_integer();
let _ = r.integer();
let _ = r.integer_vbn(n);
let _ = r.double_vbn(0.5, n);
let _ = r.nbits_then_unsigned();
let _ = r.string();
let _ = r.float_as_bytes();
let _ = r.double();
let _ = r.skip_bits(usize::try_from(n).unwrap_or(0));
prop_assert!(r.position() <= data.len() * 8);
}
#[test]
fn any_schema_runs_or_fails_cleanly(data in proptest::collection::vec(any::<u8>(), 0..256), entity in 0u32..4) {
let mut r = BitReader::new(&data);
if let Ok(schema) = Schema::read(&mut r) {
let types: Vec<u32> = schema.entity_types().chain([entity]).collect();
for t in types {
let _ = schema.skip_added_fields(t, &mut r.clone());
}
}
}
}
crates/redact/src/image.rs
+3 -2
View File
@@ -10,8 +10,9 @@
use pdfcraft_content::{Matrix, overlaps};
use pdfcraft_cos::{Dict, Document, ImageBudget, Object, Stream};
/// Most pixels an image may have to be cleared in place (larger ones are removed).
const MAX_PIXELS: u64 = 64 << 20;
/// Most pixels an image may have to be cleared in place (larger ones are removed), or to be stored
/// again without shared `/JBIG2Globals` (see [`without_globals`]).
const MAX_PIXELS: u64 = pdfcraft_cos::MAX_REDACTED_IMAGE_PIXELS;
fn components(doc: &Document, s: &Stream) -> Option<usize> {
let cs = doc.resolve(s.dict.get(b"ColorSpace")?);
crates/render/src/raster/tests.rs
+271
View File
@@ -8756,6 +8756,9 @@ mod default_colour_spaces;
// (vendored hayro-syntax patch 28, hayro-interpret patch 55).
mod devicen_inks;
// #5430: PNG-predicted Flate images are undone byte by byte (vendored hayro-syntax patch 35).
mod png_predicted_images;
// #3776: isolated DeviceCMYK groups blend in CMYK (vendored hayro-interpret patch 70, hayro
// patch 27).
mod isolated_cmyk_groups;
@@ -9127,3 +9130,271 @@ fn content_after_an_inline_image_holding_ei_is_still_read() {
// `EI` inside the data was not taken for the end.
assert!(page.contains("AFTER"), "the content after the image was lost: {page:?}");
}
/// `/Crypt` has nothing to undo, so a chain naming it thousands of times costs no copy of the data
/// for each. A chain of filters that does work has its own cost, which this isn't about.
#[test]
fn a_long_chain_of_crypt_filters_takes_no_time() {
use super::*;
let content = format!("1 0 0 rg 0 0 200 200 re f\n{}", " ".repeat(16 << 20));
let chain = "/Crypt ".repeat(100_000);
let pdf = format!(
"%PDF-1.7\n1 0 obj << /Type /Catalog /Pages 2 0 R >> endobj\n\
2 0 obj << /Type /Pages /Kids [3 0 R] /Count 1 >> endobj\n\
3 0 obj << /Type /Page /Parent 2 0 R /MediaBox [0 0 200 200] /Contents 4 0 R >> endobj\n\
4 0 obj << /Filter [{chain}] /Length {} >> stream\n{content}\nendstream endobj\n\
trailer << /Root 1 0 R >>\n%%EOF",
content.len()
);
let (done, finished) = std::sync::mpsc::channel();
std::thread::spawn(move || {
let page = PageRenderer::new(Arc::new(pdf.into_bytes()), RenderConfig::default()).render(RenderRequest {
page: 0,
kind: RequestKind::Pixels,
tile: None,
scale: 1.0,
tag: 0,
preview: false,
});
let start = (100 * page.width as usize + 100) * 4;
let _ = done.send(page.rgba.get(start..start + 4).map(<[u8]>::to_vec));
});
// Skipped, this takes a moment; copied, 1.6 TB, which a margin this wide tells apart however
// busy the machine.
let pixel = finished.recv_timeout(std::time::Duration::from_secs(120)).expect("the chain costs no copy for each entry");
assert_eq!(pixel, Some(vec![255, 0, 0, 255]));
}
/// A lone filter takes its parameters as a dictionary or as an array of one, and given as an array
/// of one itself it takes either too. The form of `/Filter` decided which was read, so a predictor
/// in the other form was lost and the content came out as noise. `/StmF` and `/StrF` are optional,
/// meaning `/Identity`: such a file didn't open at all, though a stream can still name a filter.
#[test]
fn a_filters_parameters_are_read_in_either_form() {
use super::*;
use pdfcraft_cos::{Algorithm, Dict, Document, NewEncryption, Object, SaveOptions, Stream, write_full, write_incremental};
let content = b"1 0 0 rg 0 0 200 200 re f";
let centre = |bytes: Vec<u8>| -> [u8; 4] {
let page = PageRenderer::new(Arc::new(bytes), RenderConfig::default()).render(RenderRequest {
page: 0,
kind: RequestKind::Pixels,
tile: None,
scale: 1.0,
tag: 0,
preview: false,
});
let start = (100 * page.width as usize + 100) * 4;
let mut pixel = [0; 4];
pixel.copy_from_slice(page.rgba.get(start..start + 4).expect("centre pixel"));
pixel
};
let page = |stream: &[u8]| {
let mut pdf = b"%PDF-1.7\n1 0 obj << /Type /Catalog /Pages 2 0 R >> endobj\n2 0 obj << /Type /Pages /Kids [3 0 R] /Count 1 >> endobj\n3 0 obj << /Type /Page /Parent 2 0 R /MediaBox [0 0 200 200] /Contents 4 0 R >> endobj\n".to_vec();
pdf.extend_from_slice(stream);
pdf.extend_from_slice(b"\ntrailer << /Root 1 0 R >>\n%%EOF\n");
pdf
};
// PNG Sub over one row, which reads as noise if it isn't undone.
let mut rows = vec![1u8];
let mut before = 0u8;
for b in content {
rows.push(b.wrapping_sub(before));
before = *b;
}
let coded = Stream::flate(Dict::new(), &rows).raw;
let parms = format!("<< /Predictor 11 /Columns {} >>", content.len());
for (filter, decode_parms) in [
("/FlateDecode", parms.clone()),
("/FlateDecode", format!("[{parms}]")),
("[/FlateDecode]", parms.clone()),
("[/FlateDecode]", format!("[{parms}]")),
] {
let mut stream = format!("4 0 obj << /Filter {filter} /DecodeParms {decode_parms} /Length {} >> stream\n", coded.len()).into_bytes();
stream.extend_from_slice(&coded);
stream.extend_from_slice(b"\nendstream endobj");
assert_eq!(centre(page(&stream)), [255, 0, 0, 255], "{filter} with {decode_parms}");
}
let plain = format!("4 0 obj << /Length {} >> stream\n{}\nendstream endobj", content.len(), String::from_utf8_lossy(content));
let mut doc = Document::open(Arc::new(page(plain.as_bytes()))).unwrap();
doc.set_encryption(&NewEncryption {
algorithm: Algorithm::Aes128,
user_password: "",
owner_password: "owner",
permissions: -1,
encrypt_metadata: true,
seed: [9; 32],
})
.unwrap();
// No object streams: they would be encrypted under the /StmF about to go.
let saved = write_full(&doc, &SaveOptions { object_streams: false, ..SaveOptions::default() }).unwrap();
let mut doc = Document::open(Arc::new(saved)).unwrap();
let encrypt = doc.trailer().reference(b"Encrypt").unwrap();
doc.update_dict(encrypt, |e| {
e.remove(b"StmF");
e.remove(b"StrF");
})
.unwrap();
let mut doc = Document::open(Arc::new(write_incremental(&doc, &SaveOptions::default()).unwrap())).unwrap();
let catalog = doc.get(doc.root().unwrap());
let pages = doc.get(catalog.as_dict().unwrap().reference(b"Pages").unwrap());
let first = doc.resolve(&pages.as_dict().unwrap().get(b"Kids").unwrap().as_array().unwrap()[0]);
let contents = first.as_dict().unwrap().reference(b"Contents").unwrap();
let mut named = Dict::new();
named.set(b"Name".to_vec(), Object::name("StdCF"));
let mut dict = Dict::new();
dict.set(b"Filter".to_vec(), Object::name("Crypt"));
dict.set(b"DecodeParms".to_vec(), Object::Dict(named));
doc.set(contents, Object::Stream(Stream::from_raw(dict, content.to_vec())));
assert_eq!(centre(write_incremental(&doc, &SaveOptions::default()).unwrap()), [255, 0, 0, 255], "no /StmF, and a stream naming StdCF");
}
/// A stream can pick its own crypt filter: `/Crypt` in `/Filter`, with the filter's name in
/// `/DecodeParms`, or `/Identity` without one (ISO 32000-2 §7.4.10). The renderer used the
/// document's filter for every stream, and then couldn't decode `/Crypt`, so the page stayed blank.
#[test]
fn a_stream_with_a_crypt_filter_of_its_own_is_drawn() {
use super::*;
use pdfcraft_cos::{Algorithm, Dict, Document, NewEncryption, Object, SaveOptions, Stream, write_full, write_incremental};
let content = "1 0 0 rg 0 0 200 200 re f";
let page = format!(
"%PDF-1.7\n1 0 obj << /Type /Catalog /Pages 2 0 R >> endobj\n\
2 0 obj << /Type /Pages /Kids [3 0 R] /Count 1 >> endobj\n\
3 0 obj << /Type /Page /Parent 2 0 R /MediaBox [0 0 200 200] /Contents 4 0 R >> endobj\n\
4 0 obj << /Length {} >> stream\n{content}\nendstream endobj\n\
trailer << /Root 1 0 R >>\n%%EOF",
content.len()
);
let centre = |bytes: Vec<u8>| -> [u8; 4] {
let page = PageRenderer::new(Arc::new(bytes), RenderConfig::default()).render(RenderRequest {
page: 0,
kind: RequestKind::Pixels,
tile: None,
scale: 1.0,
tag: 0,
preview: false,
});
let start = (100 * page.width as usize + 100) * 4;
let mut pixel = [0; 4];
pixel.copy_from_slice(page.rgba.get(start..start + 4).expect("centre pixel"));
pixel
};
let name = |n: &str| {
let mut parms = Dict::new();
parms.set(b"Name".to_vec(), Object::name(n));
Object::Dict(parms)
};
let hex: String = content.bytes().map(|b| format!("{b:02X}")).chain([">".to_string()]).collect();
let crypt = || Object::name("Crypt");
let contents_of = |doc: &Document| {
let catalog = doc.get(doc.root().unwrap());
let pages = doc.get(catalog.as_dict().unwrap().reference(b"Pages").unwrap());
let page = doc.resolve(&pages.as_dict().unwrap().get(b"Kids").unwrap().as_array().unwrap()[0]);
page.as_dict().unwrap().reference(b"Contents").unwrap()
};
for (algorithm, filters) in [(Algorithm::Rc4_128, false), (Algorithm::Aes128, true), (Algorithm::Aes256, true)] {
let mut doc = Document::open(Arc::new(page.clone().into_bytes())).unwrap();
doc.set_encryption(&NewEncryption {
algorithm,
user_password: "",
owner_password: "owner",
permissions: -1,
encrypt_metadata: true,
seed: [9; 32],
})
.unwrap();
let protected = write_full(&doc, &SaveOptions::default()).unwrap();
assert_eq!(centre(protected.clone()), [255, 0, 0, 255], "{algorithm:?}: the document's own filter");
// A filter of its own name that stores streams as they are, beside the document's.
let mut doc = Document::open(Arc::new(protected)).unwrap();
if filters {
let encrypt = doc.trailer().reference(b"Encrypt").unwrap();
doc.update_dict(encrypt, |e| {
let Some(Object::Dict(cf)) = e.get(b"CF") else { panic!("no /CF") };
let mut cf = cf.clone();
let mut stored = Dict::new();
stored.set(b"CFM".to_vec(), Object::name("None"));
cf.set(b"Stored".to_vec(), Object::Dict(stored));
// `/Identity` is never one of these, whatever a file says.
let mut named = Dict::new();
named.set(b"CFM".to_vec(), Object::name("AESV2"));
cf.set(b"Identity".to_vec(), Object::Dict(named));
e.set(b"CF".to_vec(), Object::Dict(cf));
})
.unwrap();
}
let protected = write_incremental(&doc, &SaveOptions::default()).unwrap();
let spellings = [
"no name",
"/Identity",
"StdCF",
"Stored",
"/DecodeParms by reference",
"/Filter by reference",
"an entry of /Filter by reference",
"an entry of /DecodeParms by reference",
"/Name by reference",
"before another filter",
"a lone dictionary for an array of one",
"an array of one for a name",
"a dictionary by reference for an array of one",
"an array of one by reference for a dictionary",
"a name by reference for an array",
"a lone dictionary before another filter",
"past the longest chain",
];
for what in spellings {
let mut doc = Document::open(Arc::new(protected.clone())).unwrap();
let (filter, parms) = match what {
"no name" => (crypt(), None),
"/Identity" => (crypt(), Some(name("Identity"))),
"StdCF" => (crypt(), Some(name("StdCF"))),
"Stored" => (crypt(), Some(name("Stored"))),
"/DecodeParms by reference" => (crypt(), Some(Object::Ref(doc.add(name("StdCF"))))),
"/Filter by reference" => (Object::Ref(doc.add(crypt())), Some(name("StdCF"))),
"an entry of /Filter by reference" => (Object::Array(vec![Object::Ref(doc.add(crypt()))]), Some(Object::Array(vec![name("StdCF")]))),
"an entry of /DecodeParms by reference" => {
(Object::Array(vec![crypt()]), Some(Object::Array(vec![Object::Ref(doc.add(name("StdCF")))])))
}
"/Name by reference" => {
let mut parms = Dict::new();
parms.set(b"Name".to_vec(), Object::Ref(doc.add(Object::name("StdCF"))));
(crypt(), Some(Object::Dict(parms)))
}
"a lone dictionary for an array of one" => (Object::Array(vec![crypt()]), Some(name("StdCF"))),
"an array of one for a name" => (crypt(), Some(Object::Array(vec![name("StdCF")]))),
"a dictionary by reference for an array of one" => (Object::Array(vec![crypt()]), Some(Object::Ref(doc.add(name("StdCF"))))),
"an array of one by reference for a dictionary" => (Object::Ref(doc.add(Object::Array(vec![crypt()]))), Some(name("StdCF"))),
"a name by reference for an array" => (Object::Ref(doc.add(crypt())), Some(Object::Array(vec![name("StdCF")]))),
"a lone dictionary before another filter" => (Object::Array(vec![crypt(), Object::name("ASCIIHexDecode")]), Some(name("StdCF"))),
// One filter more than cos decodes: it names none there, so here neither, and the
// stream is read with the document's filter, not the `Stored` it says.
"past the longest chain" => {
let mut chain = vec![crypt()];
chain.extend(std::iter::repeat_n(Object::name("ASCIIHexDecode"), 9));
(Object::Array(chain), Some(Object::Array(vec![name("Stored")])))
}
_ => (Object::Array(vec![crypt(), Object::name("ASCIIHexDecode")]), Some(Object::Array(vec![name("StdCF"), Object::Null]))),
};
let contents = contents_of(&doc);
let Object::Stream(s) = doc.get(contents).as_ref().clone() else { panic!("no content stream") };
let mut dict = s.dict.clone();
dict.set(b"Filter".to_vec(), filter);
if let Some(parms) = parms {
dict.set(b"DecodeParms".to_vec(), parms);
}
let raw = match what {
"before another filter" | "a lone dictionary before another filter" => hex.clone().into_bytes(),
"past the longest chain" => (0..9).fold(content.as_bytes().to_vec(), |data, _| {
let mut coded: Vec<u8> = data.iter().flat_map(|b| format!("{b:02X}").into_bytes()).collect();
coded.push(b'>');
coded
}),
_ => content.as_bytes().to_vec(),
};
doc.set(contents, Object::Stream(Stream::from_raw(dict, raw)));
let saved = write_incremental(&doc, &SaveOptions::default()).unwrap();
assert_eq!(centre(saved), [255, 0, 0, 255], "{algorithm:?}: {what}");
}
}
}
crates/render/src/raster/tests/png_predicted_images.rs
+69
View File
@@ -0,0 +1,69 @@
//! #5430: Flate images with PNG predictors (ISO 32000-2 §7.4.4.4) are undone a byte row at a
//! time (vendored hayro-syntax patch 35). The bit-level decoder they went through before dropped
//! the last byte of each filtered row that ends part-way through a pixel, so every later row
//! started a byte early and the picture came out sheared.
use super::rgb_at;
use crate::{PageRenderer, RenderConfig, RenderRequest, RequestKind};
use flate2::{Compression, write::ZlibEncoder};
use std::io::Write;
use std::sync::Arc;
/// The page is 150 × 200 pt, drawn at 72 dpi; the image fills it.
const WIDTH: usize = 150;
const HEIGHT: usize = 200;
/// The colour of each of the image's four rows, top first, as 4-bit samples.
const ROWS: [[u8; 3]; 4] = [[15, 0, 0], [0, 15, 0], [0, 0, 15], [15, 15, 0]];
#[test]
fn a_four_bit_rgb_image_of_odd_width_with_up_predicted_rows_is_not_sheared() {
// Three 4-bit RGB pixels are 4.5 bytes, so each row is five bytes and ends half-way through a
// two-byte pixel.
let rows: Vec<Vec<u8>> = ROWS
.iter()
.map(|rgb| {
let nibbles: Vec<u8> = (0..3).flat_map(|_| rgb.iter().copied()).chain([0]).collect();
nibbles.chunks(2).map(|pair| (pair[0] << 4) | pair[1]).collect()
})
.collect();
let mut predicted = Vec::new();
let mut above = vec![0u8; 5];
for row in &rows {
predicted.push(2);
predicted.extend(row.iter().zip(&above).map(|(b, a)| b.wrapping_sub(*a)));
above.clone_from(row);
}
let mut encoder = ZlibEncoder::new(Vec::new(), Compression::default());
encoder.write_all(&predicted).unwrap();
let data = encoder.finish().unwrap();
let content = "q 150 0 0 200 0 0 cm /Im0 Do Q";
let mut pdf = format!(
"%PDF-1.7\n1 0 obj << /Type /Catalog /Pages 2 0 R >> endobj\n\
2 0 obj << /Type /Pages /Kids [3 0 R] /Count 1 >> endobj\n\
3 0 obj << /Type /Page /Parent 2 0 R /MediaBox [0 0 150 200] /Resources << /XObject << /Im0 5 0 R >> >> /Contents 4 0 R >> endobj\n\
4 0 obj << /Length {} >> stream\n{content}\nendstream endobj\n\
5 0 obj << /Type /XObject /Subtype /Image /Width 3 /Height 4 /ColorSpace /DeviceRGB /BitsPerComponent 4 \
/Filter /FlateDecode /DecodeParms << /Predictor 15 /Colors 3 /BitsPerComponent 4 /Columns 3 >> /Length {} >> stream\n",
content.len(),
data.len()
)
.into_bytes();
pdf.extend_from_slice(&data);
pdf.extend_from_slice(b"\nendstream endobj\ntrailer << /Root 1 0 R >>\n%%EOF");
let mut renderer = PageRenderer::new(Arc::new(pdf), RenderConfig::default());
let page = renderer.render(RenderRequest { page: 0, kind: RequestKind::Pixels, tile: None, scale: 1.0, tag: 0, preview: false });
assert!(page.error.is_none(), "{:?}", page.error);
assert_eq!((page.width, page.height), (WIDTH as u32, HEIGHT as u32));
// Each image pixel is 50 pt square; look at the middle of each.
for (row, rgb) in ROWS.iter().enumerate() {
let expected = rgb.map(|sample| sample * 17);
for column in 0..3 {
let (x, y) = (column * 50 + 25, row * 50 + 25);
assert_eq!(rgb_at(&page.rgba, WIDTH, x, y), expected, "image row {row}, column {column}");
}
}
}
docs/roadmap.md
+1
View File
@@ -304,6 +304,7 @@ Estimates unchanged.
| Date | Change | Summary |
|---|---|---|
| 2026-11-03 | minor | M11: Optimize's JBIG2 images share a symbol dictionary (`/JBIG2Globals`), up to 16 at a time and when smaller (`pdfcraft_filters::encode_jbig2_shared`): 41–46% smaller on rendered text in proportional fonts, 10% in Courier |
| 2026-11-03 | patch | M5 #5850 review: indirect typewriter intent and composer edits preserve outer whitespace; movement regression commits by outside click; estimates unchanged. |
| 2026-11-03 | patch | M5 #5850: Enter adds Fill & Sign line breaks; outside clicks commit, Escape cancels, and saved multiline appearances retain their text and height; estimates unchanged. |
| 2026-11-02 | patch | M10 #5743: macOS print jobs carry the job name and owner some vendors' filters need; not yet checked on a physical printer |
licenses/prc-rs-LICENSE.txt
+7
View File
@@ -0,0 +1,7 @@
Copyright (c) 2025,2026 Kristof Ralovich
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.
parity/acrobat-features.toml
+4 -4
View File
@@ -226,8 +226,8 @@ milestone = "M1"
status = "shipped"
commands = []
tools = []
evidence = ["crates/crypt/src/tests.rs::identity_crypt_filters_leave_data_alone"]
notes = ""
evidence = ["crates/crypt/src/tests.rs::identity_crypt_filters_leave_data_alone", "crates/cos/tests/it/encryption.rs::a_crypt_filter_selected_by_reference_is_used", "crates/cos/tests/it/encryption.rs::an_identity_crypt_filter_selected_by_reference_leaves_a_stream_alone", "crates/render/src/raster/tests.rs::a_stream_with_a_crypt_filter_of_its_own_is_drawn"]
notes = "a stream can name its own filter (/Crypt in /Filter, its name in /DecodeParms), read and written, each part given directly or by reference, in cos and in the renderer; /StmF, /StrF, /EFF and /CFM by reference too. A /Filter given by reference selects the crypt filter, but Stream::decoded still refuses it, so such a stream is decrypted and not decoded outside the renderer."
[[feature]]
id = "core.attachment-only-encryption"
@@ -7463,8 +7463,8 @@ milestone = "M11"
status = "partial"
commands = ["optimize.advanced", "optimize.reduce"]
tools = ["doc_optimize", "doc_reduce"]
evidence = ["crates/optimize/src/images.rs::flate_images_past_the_runs_allowance_stay_as_they_are", "crates/optimize/tests/optimize.rs::eight_bit_black_and_white_images_become_one_bit", "crates/filters/src/ccitt.rs::bitmaps_round_trip", "crates/filters/src/ccitt.rs::a_page_of_text_like_marks_round_trips_and_shrinks", "crates/filters/src/ccitt.rs::what_it_cannot_encode_is_an_error", "crates/optimize/tests/optimize.rs::black_and_white_images_become_ccitt_group_4", "crates/optimize/tests/optimize.rs::group_3_fax_images_become_group_4", "crates/optimize/tests/optimize.rs::rgb_and_two_colour_indexed_black_and_white_images_become_one_bit", "crates/optimize/tests/optimize.rs::black_and_white_rgb_used_beyond_the_page_content_read_stays_rgb", "crates/optimize/tests/optimize.rs::black_and_white_rgb_drawn_only_where_the_optimizer_reads_becomes_grey", "crates/optimize/tests/optimize.rs::black_and_white_rgb_in_resources_its_page_tree_and_a_form_share_becomes_grey", "crates/automation/tests/it/automation.rs::doc_optimize_stores_black_and_white_images_as_ccitt_group_4", "crates/ui-egui/tests/it/create.rs::the_pdf_optimizer_dialog_saves_an_optimized_copy", "crates/filters/src/mq.rs::the_annex_h_test_sequence_encodes_to_its_bytes", "crates/filters/src/jbig2.rs::bitmaps_round_trip", "crates/filters/src/jbig2.rs::a_page_of_text_like_marks_round_trips_and_shrinks", "crates/optimize/tests/optimize.rs::black_and_white_images_become_jbig2", "crates/automation/tests/it/automation.rs::doc_optimize_stores_black_and_white_images_as_jbig2", "crates/filters/src/jbig2/symbols.rs::repeated_marks_are_stored_once", "crates/filters/src/jbig2/symbols.rs::scattered_marks_round_trip", "crates/optimize/tests/optimize.rs::rendered_text_becomes_jbig2_symbols", "crates/optimize/tests/optimize.rs::jbig2_scans_are_averaged_and_stored_again", "crates/optimize/src/images.rs::jbig2_images_past_the_runs_allowance_stay_as_they_are", "crates/optimize/tests/optimize.rs::an_image_too_large_for_the_jbig2_decoder_stays_as_it_is", "crates/optimize/tests/optimize.rs::what_is_too_large_for_jbig2_is_stored_another_way", "crates/optimize/tests/optimize.rs::group_4_takes_images_of_one_bit_a_pixel_up_to_the_pixel_limit"]
notes = "All of a run's images share one allowance of decoding, filters, decoders and pixels alike (about 1,000 scanned pages' worth, more for a longer file); those past it stay as they are, those the image pass read being counted in the report, which doc_optimize and doc_reduce return and the panel doesn't show yet. CCITT Group 4, lossless: PDF Optimizer ▸ Images ▸ Monochrome Images (on by default, so Reduce File Size does it too; doc_optimize mono) stores a 1-bit image of one colour component (grey, indexed, a separation) or an image mask, kept with no filter or general-purpose ones, as Group 4 when that is smaller as stored; the samples decode to the same bits, so colour space, decode array and masks stay. Packed to one bit first, then stored the same way (colour-key masks aside): eight-bit grey of only black and white, eight-bit DeviceRGB of only black and white (as DeviceGray; calibrated RGB, RGB with a profile, RGB drawn or listed where /DefaultGray or /DefaultRGB is in force or referred to from anywhere but the page and form resources read (an annotation's appearance or a pattern drawing it, directly or through resources or a form shared with a page; another image's /Alternates), and RGB whose soft mask has a /Matte aside), and an indexed image of 2, 4 or 8 bits that uses only palette entries 0 and 1 (keeping its palette), unless the grey or colour settings make it smaller still, as they can a dithered scan downsampled to JPEG, its soft mask counted. Group 4 wins on scans; on clean computer-drawn 1-bit art Flate can be smaller, and the image then stays. Group 3 fax images are stored again as Group 4 when that is smaller (damaged Group 3 with end-of-line codes as the decoder recovers it, as it reports no damage there; byte-aligned Group 3 with end-of-line codes but none before the first row, not as T.4 sends them, as PdfCraft draws it, which at /K 0 may be other rows than were coded). CCITT fax images are decoded to be downsampled (optimize.downsample-images), and a resampled image is stored as Group 4 or 1-bit Flate, whichever is smaller. Lossless JBIG2 with bounded exact-copy symbol coding is available too, with image export; lossy JBIG2 remains unsupported. JBIG2 images are read too: averaged like any (under Retain stored as JBIG2 again), and, not resampled, stored again as the compression asks when that is smaller (as JBIG2 symbols where its own coding is a generic region, say); a symbol-coded scan, averaged, loses its exact repeats and is often larger, and then stays as it is; one whose JBIG2 page isn't its size is left alone. Not yet: images over 80 million pixels (left alone by the image steps, whatever their settings; Clean Up may still Flate an unfiltered or LZW one), inline images, soft masks and /Mask images, Group 4 for rows wider than 32,767 samples, JBIG2 past 65,535 samples on a side, where the decoder stops: such an image isn't stored as JBIG2 (the image step leaves a 1-bit one as it is unless it is averaged, and may store one packed from more bits as 1-bit Flate)."
evidence = ["crates/optimize/src/images.rs::flate_images_past_the_runs_allowance_stay_as_they_are", "crates/optimize/tests/optimize.rs::eight_bit_black_and_white_images_become_one_bit", "crates/filters/src/ccitt.rs::bitmaps_round_trip", "crates/filters/src/ccitt.rs::a_page_of_text_like_marks_round_trips_and_shrinks", "crates/filters/src/ccitt.rs::what_it_cannot_encode_is_an_error", "crates/optimize/tests/optimize.rs::black_and_white_images_become_ccitt_group_4", "crates/optimize/tests/optimize.rs::group_3_fax_images_become_group_4", "crates/optimize/tests/optimize.rs::rgb_and_two_colour_indexed_black_and_white_images_become_one_bit", "crates/optimize/tests/optimize.rs::black_and_white_rgb_used_beyond_the_page_content_read_stays_rgb", "crates/optimize/tests/optimize.rs::black_and_white_rgb_drawn_only_where_the_optimizer_reads_becomes_grey", "crates/optimize/tests/optimize.rs::black_and_white_rgb_in_resources_its_page_tree_and_a_form_share_becomes_grey", "crates/automation/tests/it/automation.rs::doc_optimize_stores_black_and_white_images_as_ccitt_group_4", "crates/ui-egui/tests/it/create.rs::the_pdf_optimizer_dialog_saves_an_optimized_copy", "crates/filters/src/mq.rs::the_annex_h_test_sequence_encodes_to_its_bytes", "crates/filters/src/jbig2.rs::bitmaps_round_trip", "crates/filters/src/jbig2.rs::a_page_of_text_like_marks_round_trips_and_shrinks", "crates/optimize/tests/optimize.rs::black_and_white_images_become_jbig2", "crates/automation/tests/it/automation.rs::doc_optimize_stores_black_and_white_images_as_jbig2", "crates/filters/src/jbig2/symbols.rs::repeated_marks_are_stored_once", "crates/filters/src/jbig2/symbols.rs::scattered_marks_round_trip", "crates/optimize/tests/optimize.rs::rendered_text_becomes_jbig2_symbols", "crates/optimize/tests/optimize.rs::jbig2_scans_are_averaged_and_stored_again", "crates/optimize/src/images.rs::jbig2_images_past_the_runs_allowance_stay_as_they_are", "crates/optimize/tests/optimize.rs::an_image_too_large_for_the_jbig2_decoder_stays_as_it_is", "crates/optimize/tests/optimize.rs::what_is_too_large_for_jbig2_is_stored_another_way", "crates/optimize/tests/optimize.rs::group_4_takes_images_of_one_bit_a_pixel_up_to_the_pixel_limit", "crates/filters/src/jbig2/symbols.rs::pages_in_one_font_share_one_dictionary", "crates/filters/src/jbig2/symbols.rs::what_a_page_has_alone_stays_its_own", "crates/filters/src/jbig2/symbols.rs::past_the_shared_limit_the_most_widely_held_marks_are_shared", "crates/optimize/tests/optimize.rs::jbig2_pages_share_one_symbol_dictionary", "crates/optimize/tests/optimize.rs::a_dictionary_that_saves_less_than_it_takes_isnt_shared", "crates/optimize/tests/optimize.rs::sixteen_images_at_most_share_a_dictionary", "crates/engine/src/tests.rs::redacting_an_optimized_jbig2_page_stores_the_rest_of_its_group_again", "crates/optimize/src/images.rs::only_what_redaction_can_store_again_shares_a_dictionary"]
notes = "All of a run's images share one allowance of decoding, filters, decoders and pixels alike (about 1,000 scanned pages' worth, more for a longer file); those past it stay as they are, those the image pass read being counted in the report, which doc_optimize and doc_reduce return and the panel doesn't show yet. CCITT Group 4, lossless: PDF Optimizer ▸ Images ▸ Monochrome Images (on by default, so Reduce File Size does it too; doc_optimize mono) stores a 1-bit image of one colour component (grey, indexed, a separation) or an image mask, kept with no filter or general-purpose ones, as Group 4 when that is smaller as stored; the samples decode to the same bits, so colour space, decode array and masks stay. Packed to one bit first, then stored the same way (colour-key masks aside): eight-bit grey of only black and white, eight-bit DeviceRGB of only black and white (as DeviceGray; calibrated RGB, RGB with a profile, RGB drawn or listed where /DefaultGray or /DefaultRGB is in force or referred to from anywhere but the page and form resources read (an annotation's appearance or a pattern drawing it, directly or through resources or a form shared with a page; another image's /Alternates), and RGB whose soft mask has a /Matte aside), and an indexed image of 2, 4 or 8 bits that uses only palette entries 0 and 1 (keeping its palette), unless the grey or colour settings make it smaller still, as they can a dithered scan downsampled to JPEG, its soft mask counted. Group 4 wins on scans; on clean computer-drawn 1-bit art Flate can be smaller, and the image then stays. Group 3 fax images are stored again as Group 4 when that is smaller (damaged Group 3 with end-of-line codes as the decoder recovers it, as it reports no damage there; byte-aligned Group 3 with end-of-line codes but none before the first row, not as T.4 sends them, as PdfCraft draws it, which at /K 0 may be other rows than were coded). CCITT fax images are decoded to be downsampled (optimize.downsample-images), and a resampled image is stored as Group 4 or 1-bit Flate, whichever is smaller. Lossless JBIG2 with bounded exact-copy symbol coding is available too, with image export, up to 16 images sharing one symbol dictionary (/JBIG2Globals) where that is smaller still (image masks and DeviceGray images named directly, of at most 64 Mi pixels, which redaction can store again without it); lossy JBIG2 remains unsupported. JBIG2 images are read too: averaged like any (under Retain stored as JBIG2 again), and, not resampled, stored again as the compression asks when that is smaller (as JBIG2 symbols where its own coding is a generic region, say); a symbol-coded scan, averaged, loses its exact repeats and is often larger, and then stays as it is; one whose JBIG2 page isn't its size is left alone. Not yet: images over 80 million pixels (left alone by the image steps, whatever their settings; Clean Up may still Flate an unfiltered or LZW one), inline images, soft masks and /Mask images, Group 4 for rows wider than 32,767 samples, JBIG2 past 65,535 samples on a side, where the decoder stops: such an image isn't stored as JBIG2 (the image step leaves a 1-bit one as it is unless it is averaged, and may store one packed from more bits as 1-bit Flate)."
[[feature]]
id = "optimize.only-if-smaller"
vendor/README.md
Vendored
+2 -2
View File
@@ -41,9 +41,9 @@ Other resource categories retain their existing parent-chain lookup.
|---|---|---|---|---|
| hayro-interpret | 0.7.0 | Apache-2.0 OR MIT | (1) select `/AP /N` appearance states via `/AS` (checkboxes, radios, stateful icons) and honour the NoView flag; (2) Type3 Unicode fallback to `/Encoding` glyph names, then printable ASCII; (3) `Type3Glyph::advance_width`; (4) `InterpreterSettings::ocg_overrides` for viewer layer toggles; (5) soft masks whose group lacks `/CS` were dropped (Chrome gradient text); (6) paint nesting cap `MAX_PAINT_NESTING` for tiling patterns and Type 3 glyphs (self-referencing content overflowed the stack); (7) CID width ranges in `/W` and `/W2` clamped to `MAX_CID` (a `0 4294967295 w` range hung); (8) `InterpreterSettings::hide_comments` skips markup annotations but keeps widgets and links (View ▸ Hide all comments); (9) `image_size_ok`: images and masks over 2^28 pixels are not decoded (a fuzzed `/W 4294967295` stencil mask allocated 4 GiB); (10) `MAX_NESTED_PAINTS`: nested paints (forms, Type 3 glyphs and tiling patterns inside one another) share a per-page budget of 50,000 (a glyph showing eight glyphs of its own font, sixteen deep, hung); (11) depends on skrifa 0.47 instead of 0.42 (upstream read-fonts fixed a Type 1 tokenizer that recursed through runs of numbers: a fuzzed font hung or overflowed the stack), with the one API change (`Charset::glyph_id` returns `Option`); (12) annotation appearances whose `/BBox` or `/Matrix` collapses to a line or a point are skipped (mapping them onto `/Rect` divided by zero and handed the device infinite or NaN matrices); (13) a Highlight annotation without a usable normal appearance is drawn from its `/QuadPoints`, `/C` and `/CA` with Multiply blending, as pdfcraft-annot draws highlights (it was not drawn at all); (14) simple-font `/Widths` (`read_widths`): entries only for codes 0–255 (one entry per code below `/FirstChar` was allocated: `4294967295` asked for 34 GB), an entry that isn't a number leaves its code missing instead of ending the array, and a `/LastChar` below `/FirstChar` gives no widths instead of discarding the font for a standard one; (15) the appearance box is mapped onto `/Rect` corner to corner: the translation now accounts for the scale (an appearance whose box didn't start at the origin and differed in size from `/Rect` was drawn shifted); (16) a clip set by `W`/`W*` takes effect after whichever path-painting operator ends the path (`S`, `f`, `B`, … as well as `n`; ISO 32000-2 §8.5.4): it was applied only on `n`, so `re W* S` clipped nothing and the clip stayed pending for a later, unrelated `n`; (17) `InterpreterSettings::cancelled`: once set, interpretation stops before the next content operator (a render pool sets it for every worker when dropped, after an edit or on closing, and for one worker when the watchdog gives up on its render, so renders whose answers nobody can receive stop instead of running to the end); (18) `MAX_PAGE_CONTENT`: the content a page holds at once (its contents, and the forms, tiling patterns and Type 3 glyph procedures being painted) stays within 512 MiB (`decode_content`; once it runs out, `InterpreterWarning::ContentTruncated` is reported (once per page by pdfcraft-render) so a truncated page is not a clean render; each level gives its bytes back when it finishes): forms nest fifty deep and each level kept its content while the next ran, so a form painting itself around a stream inflating to 256 MiB would have held over 12 GB; and Type 0 sampled functions take at most `MAX_SAMPLE_ENTRIES` (2^21) table points and `MAX_SAMPLE_VALUES` (2^23) samples, read no further than `/Size` asks (256 MiB of 1-bit samples asked for over 8 GB); (19) mesh shadings (types 4–7) are sampled only inside the area being drawn (`ShadingPattern::encode_within`, which the vendored hayro renderer calls with that area plus a pixel), within 8 visits per pixel of it plus 4 per triangle (`TriangleSampler`), and patches are triangulated one at a time: points far off the page were sampled over their whole bounding box, up to 65536 × 65536 entries (a fuzzed 147-byte patch stream; a synthetic page passed 6 GB in six seconds), ten thousand overlapping triangles ran for minutes, and every patch became 722 triangles before any limit; meshes hold at most `MAX_MESH_PATCHES` (2^16) patches and `MAX_MESH_TRIANGLES` (2^20) triangles, a lattice needs two to 2^19 vertices per row (`/VerticesPerRow 0` pushed empty rows for ever; one huge row read the whole stream), and a page samples at most `MAX_PAGE_MESH_TRIANGLES` (2^25) mesh triangles in all (a mesh painted a thousand times was triangulated a thousand times); each cut logs a warning; (20) PDF function construction is limited to 64 levels and 10,000 total nodes with cycle detection; calculator parsing and evaluation share procedure depth/work budgets, integer division/bitshift/rotation/index are panic-free, and fixed-size stack errors propagate; (21) a Type 0 font drawn with a substitute that isn't CID-keyed (it isn't embedded, or its program doesn't load) draws `.nLine truncated
| hayro | 0.7.1 | Apache-2.0 OR MIT | (1) `RenderSettings::{x_offset, y_offset}` to render one tile of a large page; (2) images over `MAX_IMAGE_PIXELS` (2^28) are skipped (a fuzzed `/W 4294967295` hung in resampling); (3) `tiling_cell_scale` keeps a tiling pattern's cell pixmap within 3000 px a side whatever its `/XStep`/`/YStep` (a fuzzed step far beyond `/BBox` allocated 2 GB); (4) stroke widths clamped to 4 × (canvas width + height) device pixels (a fuzzed `/LW 9223372036854775807` allocated 10 GB in stroke expansion); (5) `usable_dash_pattern`: a stroke whose dash pattern could cut it into more than `MAX_DASHES_PER_STROKE` (250,000) pieces, counting kurbo's restart of the pattern at every subpath and `ClosePath`, is drawn solid (a fuzzed `/D [[11] 0]` on a line from x = 92234775807 allocated over 5 GB, `[0.000001] 0 d` on a 20 pt line over 10 GB); (6) a dash pattern with a negative or non-finite entry, or a period that isn't positive, is drawn solid (`[-1 -1] 0 d` looped for ever in kurbo); (7) `render_size` and `render_into`: render into a buffer the caller allocates (PdfCraft renders into pixel-aligned memory that the GUI takes over as texture data); `render` is `render_into` on a new pixmap; (8) checked image source/target/RGBA, alpha-premultiplication scratch and intermediate sizes before resampling, finite transforms and exact source/mask buffers; sources wider than u16 may shrink before backend limits, with a 2^20 source-axis cap and conservative 128 MiB filter-planning estimate; an over-limit or failed resize keeps the original image resolution and geometry when the source fits the backend, otherwise skips it, with a logged warning; staging, resampling output/scratch, RGBA conversion and padding buffers use fallible reserves; (9) `may_paint_canvas`: a fill or stroke whose control-point box, grown by how far its paint reaches past the path (half the stroke width times the larger of the miter limit and √2) plus 0.5 user units and 2 pixels, misses the canvas is not drawn, so a tile no longer strokes and fills every path of its page (item 5 of #623); `set_skip_offscreen_paths` turns this off for the regression test; (10) `/Interpolate` governs the pre-resize too (#624): a minified image that does not request interpolation is pre-resized with nearest-neighbour, planned without the Catmull-Rom filter limits (`image_resampling_size` takes the flag); a Type 3 glyph image is sampled bicubically only when interpolated; a minified image with a matching soft mask is nearest-sampled straight into premultiplied RGBA; (11) `may_paint_rect`: an image whose stream-size box, mapped to the device, misses the canvas is skipped before decoding (decoded data can only shrink against that box), so a tile of an image-heavy page no longer decodes, resamples and rasterizes every image on it; (12) preview renders (`InterpreterSettings::preview`: backdrops, thumbnails, grid cells, signature-drag backgrounds) skip images under `PREVIEW_MIN_IMAGE_AREA` device pixels, while final renders always draw them; (13) reading colours (#897): `RenderSettings::color_replacement` takes a `ColorReplacement` (text colour, background, `only_black`, `line_art`) that remaps solid text and line-art paint while rendering, glyph outlines counting as text and stencil-mask ink as line art; images, image alpha masks, soft masks and pattern cells keep their colours; `render_pdf` gains a `color_replacement: Option<ColorReplacement>` argument (pass `None` for true colours); the upstream-only `[dev-dependencies.log]` entry is removed from `Cargo.toml` (log is a normal dependency since the logging patch), so `cargo test -p hayro` runs this crate's unit tests; (14) a shrunk, interpolated image whose axes lie along the device's (upright, mirrored or a quarter turn, as on a page under `/Rotate`) is snapped to whole device pixels: shrunk once to its rounded device rectangle and drawn 1:1 from the rounded corner, instead of a ceil-sized raster resampled again at a fractional scale and offset (`snap_minified_image`; scans looked soft next to Acrobat, and until #5530 a turned one still did, up to 200 grey levels off the same page drawn upright). An image counts as axis-aligned when the terms the snap drops move its far edges by at most a hundredth of a device pixel (`SNAP_SKEW`), not by a tolerance on the coefficients, which let a slight skew of a very wide image through; and the snapped 1:1 transform is used only when the shrink produced the snapped size, so a failed resize keeps the full transform instead of drawing the source raster at its source size; (15) a soft mask of another size than its image is filtered when shrunk, whatever its `/Interpolate` (#1649): such a mask carries the shape on its own (Word saves text as a tiny black image with a glyph-bitmap mask), and nearest-neighbour dropped every stroke thinner than the shrink factor; (16) under a soft mask or a blend mode, axial and radial shadings are sampled instead of drawn as native gradients (#Line truncated
| hayro-jbig2 | 0.3.0 | Apache-2.0 OR MIT | (1) at most 2^28 pixels per bitmap and page bitmap, and 2^25 cells per halftone grid and grayscale image (each side could be 65535: 4.3 billion pixels decoded one by one, and a 4-byte value per cell); (2) at most 2^26 symbol pixels per symbol dictionary (a fuzzed dictionary decoded for minutes); (3) a symbol dictionary's height classes are capped at one per new symbol and its export runs at `2 × symbols + 1`, each plus `EXTRA_EMPTY_STEPS` (1024): an empty height class or a zero-length export run doesn't advance, and past the end of its data the arithmetic decoder can decode them for ever (one changed byte hung the renderer); (4) a segment header's long-form referred-to segment count is capped at `u16::MAX` and a larger count is refused before its retention or referred-to bytes are read: the 29-bit count went straight to `Vec::with_capacity`, a reservation of about 2 GiB whose failure aborts the process (from storytold/craft-libs#176); (5) what a page's segments hold for later ones (intermediate regions, pattern and symbol dictionaries with their headers and retained contexts, and Huffman tables) is at most 64 MiB, two square bitmaps of 16,384 a side (`MAX_RETAINED_WORDS`), and a dictionary's new and exported symbols are counted against it as they are made: each was bounded on its own, but a few dozen bytes an intermediate region held 33 MB each, and 8 MiB symbols exported again and again killed the process, so a few kilobytes could exhaust memory; (6) a segment may refer to at most 2^20 symbols, checked before any are collected: references may repeat, and 65,535 of them to one dictionary, in a 78 KB stream, asked for 17 GB; (7) a pattern dictionary keeps at most 16 MiB of shifted copies, which only speed up drawing, and none that wouldn't fit what the page has left (`MAX_SHIFTED_WORDS`); (8) a custom Huffman table has at most 2^16 lines, and a stream with its globals at most 2^20 segments and 2^22 references, checked as they are read: both grew before anything counted them, and PDFs of a kilobyte or so reached 5 GB and more behind nested Flate; (9) a page past the bounds of (1) is refused when the stream is opened: a caller sizes its output from the header before the page bitmap is made, and an Indexed image in a 743-byte PDF asked for 137 GB, which aborts; (10) a stream may ask for at most 2^30 units of decoding work, four of the largest pages, about 6 s to 17 s (`MAX_WORK`): decoding a bitmap costs a pixel each and 4 a row, copying one a word each and 1 a row, and each integer an item reads costs 38, what one takes at worst, so one with no pixels pays too, before it is decoded: each bitmap was bounded, but nothing bounded how many there were, and a 795-byte PDF took 265 s; (11) `Image::decode_within` spends from what a run of images may still do, starting with its page's pixels, and `charge_reading` charges reading a stream and its globals before anything is parsed, so an operation over a document can bound what `MAX_WORK` bounds for one image, and images that fail or decode nothing add up too: a file of thousands of images made to reach that limit took as many times as long; (12) adding to a location, a reference offset, a symbol's corner or a Huffman range line near the end of an `i32`, and negating a decoded integer of 2^31, overflowed: a panic wherever overflow is checked. The refinement context, a text region's corners, the integer decoder and the Huffman table wrap, as a release build did, and `Bitmap::combine` saturates, which comes to the same, as a location that overflows is past the end of any page. What is drawn doesn't change; (13) a bitmap filled with a default pixel of 1 (a page, or an intermediate text or halftone region) had 1s past its width in the last word of each row, and a refinement, which reads its reference a word at a time, read them as pixels where the standard has 0 (6.3.5.2): refining such a reference not a multiple of 32 wide decoded to other pixels than were coded, release builds too. `Bitmap::clear_padding` clears those bits when a bitmap is filled with 1s, as cutting symbols and patterns from a collective bitmap already did. Ghostscript reads the test's page and text streams as they decode now | (1) `raster::tests::jbig2_regions_of_billions_of_pixels_are_refused`, `raster::tests::jbig2_halftone_grids_past_their_bound_are_refused`; (2) the nightly `cargo xtask fuzz` finding, which now finishes in about a second; (3) `raster::tests::jbig2_symbol_dictionaries_that_never_advance_terminate`; (4) `segment::tests::test_referred_to_count_is_capped` (`cargo test --manifest-path vendor/hayro-jbig2/Cargo.toml`); (5) `raster::tests::jbig2_regions_held_past_a_pages_bound_are_refused`, `jbig2_symbols_without_pixels_count_towards_a_pages_bound`, `jbig2_retained_contexts_count_towards_a_pages_bound`, `jbig2_huffman_tables_count_towards_a_pages_bound`, `jbig2_new_symbols_count_towards_a_pages_bound`, `jbig2_new_symbols_are_held_to_what_a_page_haLine truncated
| hayro-jbig2 | 0.3.0 | Apache-2.0 OR MIT | (1) at most 2^28 pixels per bitmap and page bitmap, and 2^25 cells per halftone grid and grayscale image (each side could be 65535: 4.3 billion pixels decoded one by one, and a 4-byte value per cell); (2) at most 2^26 symbol pixels per symbol dictionary (a fuzzed dictionary decoded for minutes); (3) a symbol dictionary's height classes are capped at one per new symbol and its export runs at `2 × symbols + 1`, each plus `EXTRA_EMPTY_STEPS` (1024): an empty height class or a zero-length export run doesn't advance, and past the end of its data the arithmetic decoder can decode them for ever (one changed byte hung the renderer); (4) a segment header's long-form referred-to segment count is capped at `u16::MAX` and a larger count is refused before its retention or referred-to bytes are read: the 29-bit count went straight to `Vec::with_capacity`, a reservation of about 2 GiB whose failure aborts the process (from storytold/craft-libs#176); (5) what a page's segments hold for later ones (intermediate regions, pattern and symbol dictionaries with their headers and retained contexts, and Huffman tables) is at most 64 MiB, two square bitmaps of 16,384 a side (`MAX_RETAINED_WORDS`), and a dictionary's new and exported symbols are counted against it as they are made: each was bounded on its own, but a few dozen bytes an intermediate region held 33 MB each, and 8 MiB symbols exported again and again killed the process, so a few kilobytes could exhaust memory; (6) a segment may refer to at most 2^20 symbols, checked before any are collected: references may repeat, and 65,535 of them to one dictionary, in a 78 KB stream, asked for 17 GB; (7) a pattern dictionary keeps at most 16 MiB of shifted copies, which only speed up drawing, and none that wouldn't fit what the page has left (`MAX_SHIFTED_WORDS`); (8) a custom Huffman table has at most 2^16 lines, and a stream with its globals at most 2^20 segments and 2^22 references, checked as they are read: both grew before anything counted them, and PDFs of a kilobyte or so reached 5 GB and more behind nested Flate; (9) a page past the bounds of (1) is refused when the stream is opened: a caller sizes its output from the header before the page bitmap is made, and an Indexed image in a 743-byte PDF asked for 137 GB, which aborts; (10) a stream may ask for at most 2^30 units of decoding work, four of the largest pages, about 6 s to 17 s (`MAX_WORK`): decoding a bitmap costs a pixel each and 4 a row, copying one a word each and 1 a row, and each integer an item reads costs 38, what one takes at worst, so one with no pixels pays too, before it is decoded: each bitmap was bounded, but nothing bounded how many there were, and a 795-byte PDF took 265 s; (11) `Image::decode_within` spends from what a run of images may still do, starting with its page's pixels, and `charge_reading` charges reading a stream and its globals before anything is parsed, so an operation over a document can bound what `MAX_WORK` bounds for one image, and images that fail or decode nothing add up too: a file of thousands of images made to reach that limit took as many times as long; (12) adding to a location, a reference offset, a symbol's corner or a Huffman range line near the end of an `i32`, and negating a decoded integer of 2^31, overflowed: a panic wherever overflow is checked. The refinement context, a text region's corners, the integer decoder and the Huffman table wrap, as a release build did, and `Bitmap::combine` saturates, which comes to the same, as a location that overflows is past the end of any page. What is drawn doesn't change; (13) a bitmap filled with a default pixel of 1 (a page, or an intermediate text or halftone region) had 1s past its width in the last word of each row, and a refinement, which reads its reference a word at a time, read them as pixels where the standard has 0 (6.3.5.2): refining such a reference not a multiple of 32 wide decoded to other pixels than were coded, release builds too. `Bitmap::clear_padding` clears those bits when a bitmap is filled with 1s, as cutting symbols and patterns from a collective bitmap already did. Ghostscript reads the test's page and text streams as they decode now; (14) a region's location is unsigned (5.4.4), so one past `i32::MAX` is off the page, where the decoder took it for a signed one: a region there was drawn back onto the page from the left or the top (at 0xFFFFFFFC, four pixels left of it), and a refinement there, of the page or of a region at the same place (7.4.7.5), was refused as an overflow, and the page with it. `Bitmap::combine_region` keeps such a location past the page. A refinement of another region refines it where it is, as Table 35 has it (GRREFERENCEDX and GRREFERENCEDY 0), whatever the two locations say; a refinement of the page, see (16); (15) a refinement whose reference is offset right of it (GRREFERENCEDX above 0, which a refined text instance has from a wider bitmap, TaLine truncated
| lopdf | 0.45.0 | MIT | (1) PNG predictor rows longer than the data are refused before their buffers are allocated (a fuzzed `/Columns 4294967295` allocated two 4 GiB rows), and empty frames return without row buffers; (2) predictor row widths use saturating arithmetic or reject overflow; (3) sub-byte TIFF Predictor 2 scratch is bounded by the samples present in the input instead of the declared `/Colors`, aligned with [lopdf#589](https://github.com/J-F-Liu/lopdf/pull/589); (4) the object lookup keeps its cycle history through compressed objects, requires an ordinary in-file container, and caps the chain of indirect lookups at 16 (a chain of new objects, each a `/Length` compressed in a container whose own `/Length` names the next, or a stream whose `/Length` names the next stream, overflowed the stack: a dev build's 2 MiB thread within 800 hops); (5) object-stream members are parsed within their own extent (up to the next distinct offset), an entry whose offset repeats an earlier entry's is skipped (so a repeated object number can resolve to its earlier entry), and offsets are processed in index order; (6) `find_latest_trailer`: a rebuild takes a `/Type /XRef` stream dictionary as the trailer when the file has no `trailer` keyword (the latest in the file wins, as a later `trailer` would), so a concatenated or truncated file keeps its /Info and /ID instead of failing to load; a candidate whose /Root is the catalog beats one whose /Root is another dictionary, and an in-file /Root must match its generation (#2365) | (1) `inspect::tests::png_predictor_rows_longer_than_the_data_are_refused_before_allocating`, `inspect::tests::empty_png_predictor_frames_do_not_allocate_rows`; (2) `inspect::tests::tiff_subbyte_predictor_row_width_overflow_is_refused`; (3) `inspect::tests::tiff_subbyte_predictor_scratch_is_bounded_by_available_samples`, `inspect::tests::tiff_subbyte_predictors_keep_components_rows_and_padding`; (4) `inspect::tests::compressed_object_self_container_does_not_recurse`, `inspect::tests::compressed_object_mutual_containers_do_not_recurse`, `inspect::tests::object_stream_length_cycle_does_not_recurse`, `inspect::tests::compressed_object_container_chain_does_not_recurse`, `inspect::tests::compressed_length_chain_does_not_recurse`, `inspect::tests::plain_stream_length_chain_does_not_recurse`, `inspect::tests::compressed_objects_and_indirect_stream_length_still_load`, `inspect::tests::compressed_length_in_a_container_with_an_indirect_length_still_loads`; (5) `inspect::tests::object_stream_member_extents_bound_owned_strings`, `inspect::tests::object_stream_member_extents_preserve_index_order_and_whitespace`; (6) `inspect::tests::rebuilt_file_keeps_the_info_of_its_cross_reference_stream`, `inspect::tests::rebuilt_file_prefers_a_trailer_whose_root_is_the_catalog` |
| hayro-syntax | 0.7.2 | Apache-2.0 OR MIT | (1) Page-tree cycle guard in `resolve_pages` (visited set + depth cap): a `/Kids` loop among compressed objects overflowed the stack and aborted the process; (2) `ccitt_size_ok`: CCITT images wider than 2^20 columns or over 2^28 pixels are not decoded (a fuzzed `/Columns 4294967295` allocated 4 GiB); (3) Flate/LZW predictor row widths are saturating `usize`, a zero width is refused and a row longer than the data is not allocated (a fuzzed `/Columns 9223372036854775807` wrapped to a 2^61-byte allocation and aborted); (4) the inline-image end-of-data check (`EI`) doesn't nest inside its own look-ahead and examines at most 256 candidates and steps (50 images with "EI" in their data ran for over ten minutes); an EI followed by a delimiter (EI%..., EI[...) ends the image like one followed by white space; only a regular character after EI skips the candidate; (5) a stream whose `/Length` is wrong is recovered only when `stream` is the next token — scanning ahead to a later object's `stream` made an indirect appearance-state dictionary (Quartz checkboxes: `/AP /N` → `<< /Yes … /Off … >>`) render as a non-form, so the widget was skipped; (6) JPX rescaling uses an exact integer sample range for 1–32-bit components (32 shifted past u32, and floating-point maxima at 25–31 bits wrapped to zero), and refuses zero-sized rows; (7) `decode_limit`: Flate (through flate2 and the fallback inflater), LZW, RunLength and ASCII85 never write past `MAX_DECODED_STREAM` (256 MiB), or, for the last filter of an image of known size, past twice its pixel bytes (a predictor tag byte per byte), at most 1 GiB; `Stream::decoded_within` for budgeted callers; a page's `/Contents` array shares one `MAX_DECODED_STREAM` (a 2 MB page whose content stream or 8 × 8 image inflated to 2 GB took the renderer past 3 GB in under a second; naming the stream twenty times in `/Contents`, 5 GB); (8) high-precision numbers (jsPDF MediaBox coordinates with over 19 digits) parse without overflowing the u64 mantissa: fractional digits past it are dropped, integer digits past it scale the value (a real, kept finite); (9) large dictionary indexes are built on first use and shared across repeated reads within each PDF (#307); the validated-byte cache is bounded, reader contexts remain separate, repairs and inline/content dictionaries bypass sharing, and small dictionaries stay eager; (10) decoded object-stream slots publish once under contention, cold loading rejects recursive dependencies, and xref repair serializes without holding recursive read guards; this permits one parser per native render pool with private worker caches; (11) `sync.rs`: a poisoned lock is recovered instead of unwrapped (a worker panic no longer cascades into every reader of the same PDF), and xref repair takes a blocking write lock instead of asserting a non-blocking one; (12) `SegmentList` (`util.rs`) returns `None` for an out-of-range index instead of panicking; (13) a page's `/UserUnit` scales `render_dimensions` and `initial_transform`, so the page and everything on it are sized in points, as Acrobat shows them; it is read as Acrobat reads it (the page's own entry, not inherited; a number from 1 up, at most 75,000; anything else counts as 1), and a page without it keeps exactly the transform it had; (14) revision 2–4 passwords are tried as given and then in PDFDocEncoding (`legacy_passwords` in `crypto/mod.rs`, which resolves the upstream `TODO: Convert to PDFDocEncoding`): passwords arrive as UTF-8 text, so a password with characters outside ASCII (`Çok güzel`, `ılık€`) written in PDFDocEncoding, as ISO 32000-2 §7.6.4.3.2 asks and qpdf and Acrobat write it, was always wrong; (15) page content is read a piece at a time (`page::ContentReader`, `Page::content_reader`): plain streams and Flate streams without a predictor are decoded as they are read, with a budget of 64 times their compressed size and never less than `MAX_DECODED_STREAM` (a stream that expands past it is cut and reported); other streams are decoded whole, as before, and share `MAX_DECODED_STREAM`. The content tokenizer reads a window at a time (`UntypedIter::new_window`, `TypedIter::needs_more`, `TypedIter::committed`): an instruction that runs past the window is not decided until more data follows, which `Reader` records by flagging reads and `at_end` past the end of the data, including through the clones the parser makes. The Flate decoder keeps its own 32 KiB history, so it pauses at any output size. `ContentReader::new` reuses raw/decrypted stream bytes for budget accounting and piece creation, and `decoded_raw_within` applies the existing Whole-stream filters and limits to those bytes without decrypting twice; (16) revision 5–6 (AES-256) passwords are tried in their SASLprep form (RFC 4013, then UTF-8, at most 127 bytes, as ISO 32000-2 §7.6.4.3.3 Algorithm 2.A asks and pdfcraft-crypt writes them) and then, if that differs, as given (`aes256_passwLine truncated
| hayro-syntax | 0.7.2 | Apache-2.0 OR MIT | (1) Page-tree cycle guard in `resolve_pages` (visited set + depth cap): a `/Kids` loop among compressed objects overflowed the stack and aborted the process; (2) `ccitt_size_ok`: CCITT images wider than 2^20 columns or over 2^28 pixels are not decoded (a fuzzed `/Columns 4294967295` allocated 4 GiB); (3) Flate/LZW predictor row widths are saturating `usize`, a zero width is refused and a row longer than the data is not allocated (a fuzzed `/Columns 9223372036854775807` wrapped to a 2^61-byte allocation and aborted); (4) the inline-image end-of-data check (`EI`) doesn't nest inside its own look-ahead and examines at most 256 candidates and steps (50 images with "EI" in their data ran for over ten minutes); an EI followed by a delimiter (EI%..., EI[...) ends the image like one followed by white space; only a regular character after EI skips the candidate; (5) a stream whose `/Length` is wrong is recovered only when `stream` is the next token — scanning ahead to a later object's `stream` made an indirect appearance-state dictionary (Quartz checkboxes: `/AP /N` → `<< /Yes … /Off … >>`) render as a non-form, so the widget was skipped; (6) JPX rescaling uses an exact integer sample range for 1–32-bit components (32 shifted past u32, and floating-point maxima at 25–31 bits wrapped to zero), and refuses zero-sized rows; (7) `decode_limit`: Flate (through flate2 and the fallback inflater), LZW, RunLength and ASCII85 never write past `MAX_DECODED_STREAM` (256 MiB), or, for the last filter of an image of known size, past twice its pixel bytes (a predictor tag byte per byte), at most 1 GiB; `Stream::decoded_within` for budgeted callers; a page's `/Contents` array shares one `MAX_DECODED_STREAM` (a 2 MB page whose content stream or 8 × 8 image inflated to 2 GB took the renderer past 3 GB in under a second; naming the stream twenty times in `/Contents`, 5 GB); (8) high-precision numbers (jsPDF MediaBox coordinates with over 19 digits) parse without overflowing the u64 mantissa: fractional digits past it are dropped, integer digits past it scale the value (a real, kept finite); (9) large dictionary indexes are built on first use and shared across repeated reads within each PDF (#307); the validated-byte cache is bounded, reader contexts remain separate, repairs and inline/content dictionaries bypass sharing, and small dictionaries stay eager; (10) decoded object-stream slots publish once under contention, cold loading rejects recursive dependencies, and xref repair serializes without holding recursive read guards; this permits one parser per native render pool with private worker caches; (11) `sync.rs`: a poisoned lock is recovered instead of unwrapped (a worker panic no longer cascades into every reader of the same PDF), and xref repair takes a blocking write lock instead of asserting a non-blocking one; (12) `SegmentList` (`util.rs`) returns `None` for an out-of-range index instead of panicking; (13) a page's `/UserUnit` scales `render_dimensions` and `initial_transform`, so the page and everything on it are sized in points, as Acrobat shows them; it is read as Acrobat reads it (the page's own entry, not inherited; a number from 1 up, at most 75,000; anything else counts as 1), and a page without it keeps exactly the transform it had; (14) revision 2–4 passwords are tried as given and then in PDFDocEncoding (`legacy_passwords` in `crypto/mod.rs`, which resolves the upstream `TODO: Convert to PDFDocEncoding`): passwords arrive as UTF-8 text, so a password with characters outside ASCII (`Çok güzel`, `ılık€`) written in PDFDocEncoding, as ISO 32000-2 §7.6.4.3.2 asks and qpdf and Acrobat write it, was always wrong; (15) page content is read a piece at a time (`page::ContentReader`, `Page::content_reader`): plain streams and Flate streams without a predictor are decoded as they are read, with a budget of 64 times their compressed size and never less than `MAX_DECODED_STREAM` (a stream that expands past it is cut and reported); other streams are decoded whole, as before, and share `MAX_DECODED_STREAM`. The content tokenizer reads a window at a time (`UntypedIter::new_window`, `TypedIter::needs_more`, `TypedIter::committed`): an instruction that runs past the window is not decided until more data follows, which `Reader` records by flagging reads and `at_end` past the end of the data, including through the clones the parser makes. The Flate decoder keeps its own 32 KiB history, so it pauses at any output size. `ContentReader::new` reuses raw/decrypted stream bytes for budget accounting and piece creation, and `decoded_raw_within` applies the existing Whole-stream filters and limits to those bytes without decrypting twice; (16) revision 5–6 (AES-256) passwords are tried in their SASLprep form (RFC 4013, then UTF-8, at most 127 bytes, as ISO 32000-2 §7.6.4.3.3 Algorithm 2.A asks and pdfcraft-crypt writes them) and then, if that differs, as given (`aes256_passwLine truncated
| winit | 0.30.13 | Apache-2.0 | (1) on Windows 11 (build 22000 and later), `WM_DPICHANGED` applies the rect Windows suggests. It used to nudge the window onto the monitor `MonitorFromWindow` names, which during a drag is still the monitor being left; the nudge sent another `WM_DPICHANGED`, so a window dragged to a monitor with another scale factor grew and stayed on the wrong monitor at the wrong scale (#324). Backport of winit master 488c036a ([winit#4341](https://github.com/rust-windowing/winit/pull/4341)), which no 0.30 release has; Windows 10 keeps the old adjustment, as on winit master. (2) on Wayland, a seat's text input is destroyed when the seat goes away, not whenever it loses a capability: losing any capability (a touch screen or tablet unplugged, a remote-desktop session ending) destroyed it, and only an added capability recreated it, so IME stopped working until restart. Port of [winit#4747](https://github.com/rust-windowing/winit/pull/4747); (3) on Windows, an IME composition reports its cursor from `GCS_CURSORPOS` only when `WM_IME_COMPOSITION` says it is set, and at the end of the composition otherwise: the Microsoft Korean IME never sets it, so the cursor read as 0 (egui then drew no caret while composing; it now draws it after the syllable). Port of [winit#4746](https://github.com/rust-windowing/winit/pull/4746); (4) on Windows, a hidden window is not maximized until it is shown, and a hidden window shown while maximized gets one `ShowWindow(SW_MAXIMIZE)`: `SW_MAXIMIZE` shows a hidden window, so PdfCraft, which eframe keeps hidden until its first frame is drawn, appeared unpainted (white) when it restored a maximized window, and could lose its focus. Port of [winit#4587](https://github.com/rust-windowing/winit/pull/4587) (the later, focus-safe form of [winit#4575](https://github.com/rust-windowing/winit/pull/4575)); (5) on X11, when allowing or disallowing IME replaces the focused window's input context (egui does it each time a text field gains or loses focus), the new context is focused: no focus event follows, so it stayed unfocused until the window lost and regained focus. Port of [winit#4727](https://github.com/rust-windowing/winit/pull/4727); (6) on macOS, `insertText` commits through IME when a composition was started (`pending_commit`, set by `setMarkedText`) rather than when marked text is left: input methods that end a composition with `unmarkText` before `insertText` lost the text, and Apple Korean dropped the key typed after a syllable (`한` then `5` or `;`); other `insertText` calls stay `KeyboardInput`; a commit outside a key press (a candidate clicked with the mouse, dictation) clears the marked text and leaves no key to swallow, as in [winit#4748](https://github.com/rust-windowing/winit/pull/4748) (without it the next key, such as Backspace, was lost). `validAttributesForMarkedText` lists the underline and marked-clause attributes, without which some input methods don't compose. Port of [winit#4650](https://github.com/rust-windowing/winit/pull/4650), the 0.30 backport of [winit#4651](https://github.com/rust-windowing/winit/pull/4651) (merged on winit master), with the underline attribute spelled as AppKit's `NSUnderlineStyleAttributeName` (`NSUnderline`); (7) on macOS, disallowing IME with a composition in progress (focus leaving a text field) tells the input method to discard its marked text (`discardMarkedText`): it kept composing it once IME was allowed again, so the abandoned syllable came back (`하`, then `가` typed in the next field, became `학`, then `하` + `가`; Japanese `か` then `さ` became `傘`). Port of [winit#4745](https://github.com/rust-windowing/winit/pull/4745); (8) on macOS, text inserted outside a key press without a composition (the emoji picker) is reported as `Ime::Commit`; it was dropped. Port of the emoji-picker part of [winit#4749](https://github.com/rust-windowing/winit/pull/4749) (0.30 backport of [winit#4748](https://github.com/rust-windowing/winit/pull/4748)); its `selectedRange` change for dictation is left out because it switches on press-and-hold for every held key (an accent menu instead of key repeat, and the chosen accent added after the repeated letters); (9) on macOS, a key whose text was committed through IME isn't also sent as `KeyboardInput` unless AppKit forwards it as a command (Enter): Apple Korean answers Space with no syllable in progress with `setMarkedText(" ")`, `insertText(" ")`, `setMarkedText("")`, and the last call reset winit's state, so the space arrived twice. Same goal as [winit#4478](https://github.com/rust-windowing/winit/pull/4478), whose changes don't reach this call order (macOS 14); to be proposed upstream there; (10) on macOS, when the first key in a fresh app reaches Apple Korean's `insertText` as a raw compatibility jamo instead of starting a composition, that key is interpreted once more, synchronously, before it is sent as `KeyboardInput` (g k s typed ㅎㅏㄴ instead of 한); only an unmodified, Line truncated
| egui-wgpu | 0.36.2 | MIT OR Apache-2.0 | (1) `winit::surface_fit`: a window's surface is configured within the device's `max_texture_dimension_2d`, both sides shrunk by one factor that egui then draws at (`pixels_per_point × render_scale`), so the whole window is drawn into the surface (on DX12 it is stretched over the window and lines up with the pointer; wgpu's GL backend copies it unscaled into a corner); the longer side becomes exactly the limit; the depth and MSAA textures follow, and a recreated surface starts again from the window's own size. egui-wgpu configured the window's size as is, and `Surface::configure` panics beyond the limit: a window restored at another monitor's scale (opening an Outlook attachment on a mixed-DPI laptop asked an 8192-pixel device for 8600 × 3423, #577) or stretched across monitors closed PdfCraft, before its window appeared when it happened at start-up ([emilk/egui#8361](https://github.com/emilk/egui/issues/8361)). The published crate leaves out egui's licence files; `LICENSE-APACHE` and `LICENSE-MIT` are from the 0.36.2 tag; (2) `winit::catch_errors`: a new window's surface is configured inside wgpu error scopes (validation, out of memory, internal), and a failure is returned as `WgpuError::ConfigureSurface` (for the root window at start-up eframe returns it as `Error::Wgpu`, which PdfCraft retries with OpenGL); nothing is kept for the window. wgpu's default handler panicked instead, and eframe configures the root surface before the app is created, so a driver that can't configure one closed PdfCraft at launch (a 2015 Intel GPU through wgpu's GL backend timed out waiting for the GPU to go idle, `GpuWaitTimeout`, #519). Unchanged, so still a panic: an error in a later reconfigure (resize, a lost surface), a device lost during the first configure (wgpu reports it only to a callback), and a window shown at zero size (first configured on resize) | (1) `pdfcraft` `tests::a_window_larger_than_the_gpu_limit_gets_a_surface_within_it`, `tests::surface_fit_never_empties_or_overflows_a_surface`, and `tests::vendor_provenance_egui_wgpu_surface_fit_identity`, which keeps the patch in the build and in the paths that size a surface; (2) `pdfcraft` `tests::a_gpu_error_while_a_window_is_set_up_is_returned_not_a_panic` (a real device: an error inside `catch_errors` is returned, not a panic) and `tests::vendor_provenance_egui_wgpu_catch_errors_identity`, which keeps it around `add_surface`'s configure |
| vello_common | 0.0.8 | Apache-2.0 OR MIT | (1) `clip::intersect` (the clip step every clipped path passes through) starts its row walk at the first row both paths have strips in, not the earlier of the two first rows. The walk visited every row from the top of the clip for each path (on the A1 sample's full-page canvas, about half its strip rows per stroke), and rows where one path has no strips produce no output, so the strips are unchanged (vello_common 0.1 starts at the later row too). Its cost grew with the page, and a full-page render of the A1 sample was about 30% faster; the output is byte-identical | (1) `clip::tests::intersect_walks_only_rows_both_paths_have_strips` counts the rows the walk visits (`cargo test --manifest-path vendor/vello_common/Cargo.toml`) and fails without the patch; the render crate's pixel tests run through the patched crate |
vendor/hayro-jbig2/src/bitmap.rs
Vendored
+49
View File
@@ -221,6 +221,17 @@ impl Bitmap {
self.data[word_idx] |= (value as Word) << bit_pos;
}
/// PdfCraft patch: combine a decoded region into this page at the region's own location.
///
/// "Unless otherwise specified, all multi-bit values shall be treated as unsigned values"
/// (5.4.4), and a region's location (7.4.1.3, 7.4.1.4) is not specified otherwise. One past
/// `i32::MAX` is past any page. Cast to a signed coordinate it read as left of the page or above
/// it, and one within a region's size of 2^32 came back onto it.
pub(crate) fn combine_region(&mut self, region: &Self, operator: CombinationOperator) {
let signed = |location: u32| i32::try_from(location).unwrap_or(i32::MAX);
self.combine(region, signed(region.x_location), signed(region.y_location), operator);
}
/// Combine another bitmap into this one at a specific location.
///
/// "These operators describe how the segment's bitmap is to be combined with
@@ -307,4 +318,42 @@ impl Bitmap {
self.data[(row * self.stride + word_idx) as usize]
}
/// PdfCraft patch: the `width` × `height` area of this bitmap at `x`, `y`, as a bitmap there.
/// It is what a refinement of the page refines: "a bitmap containing the current contents of
/// the page buffer, restricted to the area of the page buffer specified by this segment's
/// region segment information field" (7.4.7.4). Off this bitmap the area is 0, past its width
/// too whatever the padding of its rows holds, and outside the area the refinement reads 0
/// (6.3.5.2), where reading the page itself took in the pixels around the area.
pub(crate) fn area(&self, x: u32, y: u32, width: u32, height: u32) -> Result<Self> {
let mut area = Self::new_with(width, height, x, y, false)?;
for row in 0..height {
let Some(from_row) = y.checked_add(row).filter(|r| *r < self.height) else {
continue;
};
for word in 0..area.stride {
// The first column of this word of the area, in this bitmap; past its width,
// or past where a column can be, the rest of the row is 0.
let Some(from) = x.checked_add(word * WORD_BITS).filter(|c| *c < self.width) else {
break;
};
let (index, shift) = (from / WORD_BITS, from % WORD_BITS);
let mut bits = self.get_word(from_row, index) << shift;
if shift > 0 {
bits |= self.get_word(from_row, index + 1) >> (WORD_BITS - shift);
}
// Both are above 0: `from` is inside this bitmap, and `word` inside the area.
let ours = self.width - from;
let theirs = width - word * WORD_BITS;
let kept = ours.min(theirs);
if kept < WORD_BITS {
bits &= !0 << (WORD_BITS - kept);
}
if let Some(slot) = area.data.get_mut((row * area.stride + word) as usize) {
*slot = bits;
}
}
}
Ok(area)
}
}
vendor/hayro-jbig2/src/decode/generic_refinement.rs
Vendored
+45 -40
View File
@@ -10,7 +10,7 @@ use crate::ScratchBuffers;
use crate::arithmetic_decoder::{ArithmeticDecoder, ArithmeticDecoderContext};
use crate::bitmap::{Bitmap, WORD_BITS, WORD_SHIFT, Word};
use crate::decode::generic::ContextGatherer;
use crate::error::{OverflowError, ParseError, RegionError, Result, bail};
use crate::error::{ParseError, RegionError, Result, bail};
use crate::reader::Reader;
/// Generic refinement region decoding procedure (6.3).
@@ -46,27 +46,18 @@ pub(crate) fn decode_into(
// Validate that the region fits within the reference bitmap.
// When referring to another segment, dimensions must match exactly (7.4.7.5).
// When using the page bitmap as reference, the region must fit within the page.
// PdfCraft patch: a refinement of the page refines the page's area of its own size (7.4.7.4,
// `Bitmap::area`), which it always fits.
if header.region_info.width > reference.width || header.region_info.height > reference.height {
bail!(RegionError::InvalidDimension);
}
let reference_dx = i32::try_from(reference.x_location)
.ok()
.and_then(|r: i32| {
i32::try_from(header.region_info.x_location)
.ok()
.and_then(|h| r.checked_sub(h))
})
.ok_or(OverflowError::ReferenceOffset)?;
let reference_dy = i32::try_from(reference.y_location)
.ok()
.and_then(|r: i32| {
i32::try_from(header.region_info.y_location)
.ok()
.and_then(|h| r.checked_sub(h))
})
.ok_or(OverflowError::ReferenceOffset)?;
// PdfCraft patch: "GRREFERENCEDX 0, GRREFERENCEDY 0" (Table 35). The reference is another
// region, which a refinement refines where it is (their locations should be equal, 7.4.7.5),
// or the page restricted to the refinement's area (7.4.7.4, `Bitmap::area`). Offsetting it by
// the difference of the locations refused one past `i32::MAX` as an overflow, and read the
// page around a refinement of it.
let (reference_dx, reference_dy) = (0, 0);
let mut decoder = ArithmeticDecoder::new(data);
let num_context_bits = header.template.context_bits();
@@ -194,10 +185,24 @@ impl<'a> RefinementContextGatherer<'a> {
};
self.reg_cur = 0;
self.ref_cur_x = 0;
self.ref_m1 = ContextGatherer::load_word(reference, ref_y.wrapping_sub(1) as u32, 0);
self.ref_cur = ContextGatherer::load_word(reference, ref_y as u32, 0);
self.ref_p1 = ContextGatherer::load_word(reference, ref_y.wrapping_add(1) as u32, 0);
// PdfCraft patch: the buffers start a column left of the reference column the row starts
// at, as `maybe_reload_buffers` would load them, or at column 0 where that is left of the
// reference. The row's first context takes in that column and the one left of it, which
// from column 32 on lay outside a word loaded from column 0 and read as 0: with the
// reference offset 32 left of the region its first column, and from 33 both (GRREFERENCEDX
// below −31, which a refined text instance has from a narrower bitmap or an RDX below −31,
// and a refined symbol from such an RDX). The region decoded to other pixels than were
// coded, or failed.
self.ref_cur_x = self
.reference_dx
.checked_neg()
.and_then(|column| u32::try_from(column).ok())
.map_or(0, |column| column.saturating_sub(1));
self.ref_m1 =
ContextGatherer::load_word(reference, ref_y.wrapping_sub(1) as u32, self.ref_cur_x);
self.ref_cur = ContextGatherer::load_word(reference, ref_y as u32, self.ref_cur_x);
self.ref_p1 =
ContextGatherer::load_word(reference, ref_y.wrapping_add(1) as u32, self.ref_cur_x);
self.ctx = match self.template {
RefinementTemplate::Template1 => {
@@ -259,25 +264,25 @@ impl<'a> RefinementContextGatherer<'a> {
self.reg_cur = ContextGatherer::load_word(region, self.reg_y, new_start);
}
// PdfCraft patch: left of the reference the buffers keep what `start_row` loaded, its words
// from column 0. The context takes in the reference a column to the right of the current
// one (Figures 12 and 13), so at column −1 it reads column 0, and from 0 on the buffers are
// the reference's own. They were zeroed here and, at column 0, not loaded again: with the
// reference offset right of the region (GRREFERENCEDX above 0, which a refined text
// instance or symbol has from a wider bitmap or an RDX above 0), its first 32 columns read
// as 0, and the region decoded to other pixels than were coded, or as garbage that failed.
let ref_x_signed = (x as i32).wrapping_sub(self.reference_dx);
if ref_x_signed < 0 {
self.ref_cur_x = 0;
self.ref_m1 = 0;
self.ref_cur = 0;
self.ref_p1 = 0;
} else {
let ref_x = ref_x_signed as u32;
if ref_x + 1 >= self.ref_cur_x + WORD_BITS || ref_x < self.ref_cur_x {
let new_start = ref_x.saturating_sub(1);
let ref_y = (self.reg_y as i32).wrapping_sub(self.reference_dy);
self.ref_cur_x = new_start;
self.ref_m1 =
ContextGatherer::load_word(reference, ref_y.wrapping_sub(1) as u32, new_start);
self.ref_cur = ContextGatherer::load_word(reference, ref_y as u32, new_start);
self.ref_p1 =
ContextGatherer::load_word(reference, ref_y.wrapping_add(1) as u32, new_start);
}
if let Ok(ref_x) = u32::try_from(ref_x_signed)
&& (ref_x + 1 >= self.ref_cur_x + WORD_BITS || ref_x < self.ref_cur_x)
{
let new_start = ref_x.saturating_sub(1);
let ref_y = (self.reg_y as i32).wrapping_sub(self.reference_dy);
self.ref_cur_x = new_start;
self.ref_m1 =
ContextGatherer::load_word(reference, ref_y.wrapping_sub(1) as u32, new_start);
self.ref_cur = ContextGatherer::load_word(reference, ref_y as u32, new_start);
self.ref_p1 =
ContextGatherer::load_word(reference, ref_y.wrapping_add(1) as u32, new_start);
}
}
vendor/hayro-jbig2/src/lib.rs
Vendored
+262 -30
View File
@@ -313,6 +313,13 @@ fn region_work(region: &decode::RegionSegmentInfo) -> u64 {
bitmap::decode_work(region.width, region.height)
}
/// PdfCraft patch: the page restricted to a refinement's area, its reference when it refers to no
/// other region (7.4.7.4). Copying it a word at a time costs less than the region's own decoding,
/// already charged, and it is held, as large as the region, only while the region decodes.
fn page_area(page: &Bitmap, region: &decode::RegionSegmentInfo) -> Result<Bitmap> {
page.area(region.x_location, region.y_location, region.width, region.height)
}
fn decode_segments(
segments: &[segment::Segment<'_>],
height_from_stripes: Option<u32>,
@@ -356,12 +363,7 @@ fn decode_segments(
generic::decode_into(&header, page_bitmap, scratch_buffers)?;
} else {
let region = generic::decode(&header, scratch_buffers)?;
page_bitmap.combine(
&region.bitmap,
region.bitmap.x_location as i32,
region.bitmap.y_location as i32,
region.combination_operator,
);
page_bitmap.combine_region(&region.bitmap, region.combination_operator);
}
page_state.page_pristine = false;
}
@@ -460,12 +462,7 @@ fn decode_segments(
scratch_buffers,
work_left,
)?;
page_bitmap.combine(
&region.bitmap,
region.bitmap.x_location as i32,
region.bitmap.y_location as i32,
region.combination_operator,
);
page_bitmap.combine_region(&region.bitmap, region.combination_operator);
}
page_state.page_pristine = false;
}
@@ -518,12 +515,7 @@ fn decode_segments(
halftone::decode_into(&header, pattern_dict, page_bitmap, scratch_buffers)?;
} else {
let region = halftone::decode(&header, pattern_dict, scratch_buffers)?;
page_bitmap.combine(
&region.bitmap,
region.bitmap.x_location as i32,
region.bitmap.y_location as i32,
region.combination_operator,
);
page_bitmap.combine_region(&region.bitmap, region.combination_operator);
}
page_state.page_pristine = false;
}
@@ -542,15 +534,23 @@ fn decode_segments(
}
SegmentType::IntermediateGenericRefinementRegion => {
// Same logic as immediate refinement, but store result instead of combining.
let reference = seg
let referred_segment = seg
.header
.referred_to_segments
.first()
.and_then(|&num| page_state.get_referred_segment(num))
.unwrap_or(page_bitmap);
.and_then(|&num| page_state.get_referred_segment(num));
let header = generic_refinement::parse(&mut reader)?;
charge_work(work_left, region_work(&header.region_info))?;
// PdfCraft patch: a refinement of the page refines its area (`Bitmap::area`).
let area;
let reference = match referred_segment {
Some(region) => region,
None => {
area = page_area(page_bitmap, &header.region_info)?;
&area
}
};
let region = generic_refinement::decode(&header, reference, scratch_buffers)?;
page_state.store_region(seg.header.segment_number, region.bitmap)?;
}
@@ -559,8 +559,8 @@ fn decode_segments(
// "3) Determine the buffer associated with the region segment that
// this segment refers to." (7.4.7.5)
//
// "2) If there are no referred-to segments, then use the page
// bitmap as the reference buffer." (7.4.7.5)
// With no region segment referred to, the reference is the page restricted to
// this segment's area (7.4.7.4).
let referred_segment = seg
.header
.referred_to_segments
@@ -580,14 +580,17 @@ fn decode_segments(
scratch_buffers,
)?;
} else {
let reference = referred_segment.unwrap_or(page_bitmap);
// PdfCraft patch: a refinement of the page refines its area (`Bitmap::area`).
let area;
let reference = match referred_segment {
Some(region) => region,
None => {
area = page_area(page_bitmap, &header.region_info)?;
&area
}
};
let region = generic_refinement::decode(&header, reference, scratch_buffers)?;
page_bitmap.combine(
&region.bitmap,
region.bitmap.x_location as i32,
region.bitmap.y_location as i32,
region.combination_operator,
);
page_bitmap.combine_region(&region.bitmap, region.combination_operator);
}
page_state.page_pristine = false;
}
@@ -833,6 +836,192 @@ mod tests {
assert!(Image::new_embedded(&stream(1 << 20, 1 << 20), None).is_err());
}
/// Segment `number` of `kind` on page 1, referring to `refers_to`.
fn segment(number: u8, kind: u8, refers_to: &[u8], data: &[u8]) -> Vec<u8> {
let mut segment = vec![0, 0, 0, number, kind, (refers_to.len() as u8) << 5];
segment.extend_from_slice(refers_to);
segment.push(1);
segment.extend_from_slice(&(data.len() as u32).to_be_bytes());
segment.extend_from_slice(data);
segment
}
/// A blank page of 8 × 8: resolution unknown, flags, not striped.
fn page_of_8() -> Vec<u8> {
segment(0, 48, &[], &[0, 0, 0, 8, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0x42, 0, 0])
}
/// Region information (7.4.1) of 4 × 4 at `x`, `y`, then the region's own `header`, then
/// arbitrary coded data.
fn region_of_4(x: u32, y: u32, operator: u8, header: &[u8]) -> Vec<u8> {
let mut data: Vec<u8> = [4u32, 4, x, y].iter().flat_map(|v| v.to_be_bytes()).collect();
data.push(operator);
data.extend_from_slice(header);
data.extend_from_slice(&[0x5a; 16]);
data
}
const GENERIC: &[u8] = &[0, 3, 0xFF, 0xFD, 0xFF, 2, 0xFE, 0xFE, 0xFE]; // template 0, AT
const REFINEMENT: &[u8] = &[0, 0xFF, 0xFF, 0xFF, 0xFF]; // template 0, AT
const OR: u8 = 0;
const REPLACE: u8 = 4;
/// PdfCraft patch: a region's location is unsigned (5.4.4), so one past `i32::MAX` is off the
/// page. Taken for a signed one, a region at 0xFFFFFFFE drew back onto the page two pixels left
/// of it, and a refinement there was refused, and the rest of the stream with it. Each region
/// here is 4 × 4 on a blank page of 8 × 8, its coded data arbitrary: on the page it draws, off
/// it nothing.
#[test]
fn a_region_located_past_i32_max_is_off_the_page() {
struct Ink(u32);
impl Decoder for Ink {
fn push_pixel(&mut self, black: bool) {
self.0 += u32::from(black);
}
fn push_pixel_chunk(&mut self, black: bool, chunks: u32) {
self.0 += if black { 8 * chunks } else { 0 };
}
fn next_line(&mut self) {}
}
let ink = |x: u32, y: u32| {
let forms = [
// An immediate generic region.
vec![segment(1, 38, &[], &region_of_4(x, y, OR, GENERIC))],
// An immediate refinement of the page, which reads the page at its own location (7.4.7.4).
vec![segment(1, 42, &[], &region_of_4(x, y, REPLACE, REFINEMENT))],
// An immediate refinement of an intermediate region at the same place (7.4.7.5).
vec![
segment(1, 36, &[], &region_of_4(x, y, OR, GENERIC)),
segment(2, 42, &[1], &region_of_4(x, y, OR, REFINEMENT)),
],
];
forms.map(|form| {
let stream = [page_of_8(), form.concat()].concat();
let mut ink = Ink(0);
Image::new_embedded(&stream, None).and_then(|image| image.decode(&mut ink)).map(|()| ink.0)
})
};
for (x, y) in [(0, 0), (2, 2)] {
assert!(ink(x, y).iter().all(|ink| matches!(ink, Ok(n) if *n > 0)), "{x}, {y}: {:?}", ink(x, y));
}
for (x, y) in [(0xFFFF_FFFE, 0), (0, 0xFFFF_FFFE), (0x8000_0000, 0x8000_0000), (u32::MAX, u32::MAX)] {
assert_eq!(ink(x, y).map(|ink| ink.ok()), [Some(0); 3], "{x:#x}, {y:#x}");
}
}
/// PdfCraft patch: a refinement of a region refines it where it is, "GRREFERENCEDX 0,
/// GRREFERENCEDY 0" (Table 35), not the page at the refinement's location. A region and its
/// refinement, directly or through an intermediate refinement, decode otherwise than the same
/// refinements of the page, and at 2, 3 to the pixels they decode to at 0, 0, moved.
#[test]
fn a_refinement_of_a_region_decodes_the_same_wherever_they_are() {
#[derive(Default)]
struct Pixels(Vec<bool>);
impl Decoder for Pixels {
fn push_pixel(&mut self, black: bool) {
self.0.push(black);
}
fn push_pixel_chunk(&mut self, black: bool, chunks: u32) {
self.0.extend((0..8 * chunks).map(|_| black));
}
fn next_line(&mut self) {}
}
// The first refinement refers to the region before it, or `of_page`, to nothing: the page.
let decode = |x: u32, y: u32, through_intermediate: bool, of_page: bool| {
let first: &[u8] = if of_page { &[] } else { &[1] };
let mut form = vec![segment(1, 36, &[], &region_of_4(x, y, OR, GENERIC))];
if through_intermediate {
form.push(segment(2, 40, first, &region_of_4(x, y, OR, REFINEMENT)));
form.push(segment(3, 42, &[2], &region_of_4(x, y, OR, REFINEMENT)));
} else {
form.push(segment(2, 42, first, &region_of_4(x, y, OR, REFINEMENT)));
}
let stream = [page_of_8(), form.concat()].concat();
let mut pixels = Pixels::default();
Image::new_embedded(&stream, None).unwrap().decode(&mut pixels).unwrap();
pixels.0
};
for through_intermediate in [false, true] {
let at_origin = decode(0, 0, through_intermediate, false);
assert!(at_origin.contains(&true), "draws");
assert_ne!(at_origin, decode(0, 0, through_intermediate, true), "the page refined instead");
for (i, &black) in decode(2, 3, through_intermediate, false).iter().enumerate() {
let (x, y) = (i % 8, i / 8);
let moved = x >= 2 && y >= 3 && at_origin[(y - 3) * 8 + x - 2];
assert_eq!(black, moved, "{x}, {y}, through an intermediate refinement: {through_intermediate}");
}
}
}
/// PdfCraft patch: a refinement of the page refines the page restricted to its area (7.4.7.4),
/// reading 0 around it, and a reference 32 or more left of a refinement is read from where each
/// row starts in it. So that a context read wrong changes what decodes, the refinements are
/// large, and their pictures come from the hash they were coded from: a 64 × 16 refinement at
/// 41, 4 of a 112 × 24 page, and a 70 × 12 text instance refined from a 140 × 12 symbol 35
/// left of it.
#[test]
fn a_refinement_refines_the_page_in_its_area_and_any_reference_where_it_is() {
#[derive(Default)]
struct Rows(Vec<Vec<u8>>, Vec<u8>);
impl Decoder for Rows {
fn push_pixel(&mut self, black: bool) {
self.1.push(u8::from(black));
}
fn push_pixel_chunk(&mut self, black: bool, chunks: u32) {
for _ in 0..8 * chunks {
self.push_pixel(black);
}
}
fn next_line(&mut self) {
self.0.push(core::mem::take(&mut self.1));
}
}
fn bit(seed: u32, x: u32, y: u32) -> u8 {
let mut h = x.wrapping_mul(0x9E37_79B1).wrapping_add(y.wrapping_mul(0x85EB_CA77)).wrapping_add(seed.wrapping_mul(0xC2B2_AE3D));
h ^= h >> 15;
h = h.wrapping_mul(0x2C1B_3C6D);
h ^= h >> 12;
h = h.wrapping_mul(0x297A_2D39);
h ^= h >> 15;
((h >> 7) & 1) as u8
}
// About one pixel in eight: where a refinement differs from its reference.
let flipped = |seed: u32, x: u32, y: u32| bit(seed, x, y) & bit(seed + 1, x, y) & bit(seed + 2, x, y);
// A page of bit(1, ..), and over it at 41, 4 the area refined from it.
const PAGE: &str = "000000003000010000001300000070000000180000000000000000420000000000012600010000016f00000070000000180000000000000000040003fffdff02fefefefb5d354db053c2a984c01af66c619b02c245055be23a2a431b04c60325c88676f6ff1b0a68c873ad9011a27a89fc99abc7db2e8f529ecf198ff8c6a726ddcb746dc51f3812e365e74ee668fa02f59182cae39f0ef43b3201da1bcd43a21f449889e15ba0ba1a9344da1bdb9dcb4015279a39d944509febc622a235fa2c623acb443f0c10dabf7fba5e9d6fef2f1289dfd0a6a3801d036f21a62045074f5d3158ab0373ad2334102ef867dc3132dc8d02fe517771c419cdbad47d67d409ec89d0425d1f51a48af6ba3bee6e0701185bfa5f46b347b0ec39e744b665d1e8aac868838d3db25162d65534ff4771d9c0d657bd48d5814fa7cc184d0e961defab2d75a79a88345cdae5546a54221a22ddfe9c8a0514f32ac9de806fbc5fb4f5275c79d679f0258f77900daaa273cee50e50c958f323414670d7761418639342fdb2082eac5e7934f1a06169991452b1a042eaee7871ffac000000022a000100000091000000400000001000000029000000040400ffffffffd24567306e52f57232cefa9800db00fb60c21b30b0e53d9fac8a1f863a580a7cc49ab401934ac8be3a18e2dc0f01774b76c3e9196283cb5504742c763a867bc1aae8c48d74d194dacda03ce7e91904897ab61add273d9188fda65dc6fefb995d85f48142e43c1970bedb9c5f4be3cb00d458e9f4ee9714a61fffac";
let page: Vec<Vec<u8>> = (0..24)
.map(|y| (0..112).map(|x| bit(1, x, y) ^ if (41..105).contains(&x) && (4..20).contains(&y) { flipped(10, x - 41, y - 4) } else { 0 }).collect())
.collect();
// A symbol of bit(3, ..), and a text instance refined from it, 70 narrower with RDX 0.
const TEXT: &str = "0000000030000100000013000000460000000c000000000000000042000000000001000001000000ed000003fffdff02fefefe00000001000000013f4efc0ce48e6b5c00246a648400fb605a44d542ed29da2b9b55c01f4e5af9842dd70c88f4913c7f552503ba52a5d7b5d9fd08ff5794b4dbfb3df7bafcf9c43d04154c1cefa181ca1aba5da826a4e4229858bd0950442df69c098ab3b61a32f71b136974b96bcb5306f3e75af1a4ef51b8f56a355acb8b69915cfa623f5a21933be8c056a348783a116ea914e886af2c64bf3b23e5610726c981092220f05411857529861fbf4c630a15fd00b081d2351279e06602f4408b25dc1d01c223027ecb8c87c4b1d76e3882a759c1adaf749f0e20735f8bd5a7306fffac000000020620010100000085000000460000000c0000000000000000040012ffffffff00000001a967c0b129999147062a4766ce10bc3dae7f1daf43dda1427d31203a1bc9fa021e0504e0a4b01739952970b54ad11ac08c0684d2f556a1843eb01dc75b963be6237b7f02fdfe17ccf7f061de310a936fd08c5ddea47609789e55f7cbca81ae38219c4abc5f9eff47ffac";
let text: Vec<Vec<u8>> = (0..12).map(|y| (0..70).map(|x| bit(3, x + 35, y) ^ flipped(30, x, y)).collect()).collect();
for (stream, picture) in [(PAGE, page), (TEXT, text)] {
let stream: Vec<u8> = (0..stream.len() / 2).map(|i| u8::from_str_radix(&stream[i * 2..i * 2 + 2], 16).unwrap()).collect();
let mut rows = Rows::default();
Image::new_embedded(&stream, None).unwrap().decode(&mut rows).unwrap();
assert_eq!(rows.0, picture);
}
}
/// PdfCraft patch: the area a refinement of the page refines is the page inside it and 0
/// outside: off the page's rows and columns, past where a column can be, and past the page's
/// width and the area's own whatever the padding of the page's rows holds. `new_with` clears
/// that padding (patch 13), so the page's words are set to all 1s, padding included.
#[test]
fn a_page_area_is_the_page_inside_it_and_0_outside() {
let mut page = Bitmap::new_with(40, 3, 0, 0, true).unwrap();
page.data.fill(!0);
let area = |x, y, width, height| page.area(x, y, width, height).unwrap().data;
assert_eq!(area(30, 1, 20, 3), [0xFFC0_0000, 0xFFC0_0000, 0], "10 columns and 2 rows of the page");
assert_eq!(area(0, 0, 33, 1), [!0, 0x8000_0000], "the whole of a word, and none of the area's padding");
assert_eq!(area(36, 0, 8, 1), [0xF000_0000], "4 columns, and none of the page's padding");
assert_eq!(area(5, 0, 8, 1), [0xFF00_0000], "inside the page");
assert_eq!(area(40, 0, 8, 1), [0], "right of the page");
assert_eq!(area(u32::MAX - 2, 0, 40, 1), [0, 0], "past where a column can be");
assert_eq!(area(0, u32::MAX, 8, 2), [0, 0], "below the page");
assert!(area(3, 0, 0, 2).is_empty(), "no width");
}
/// A stream and its globals are one stream of segments, so they have one count.
#[test]
fn the_segments_of_a_stream_and_its_globals_count_together() {
@@ -847,6 +1036,49 @@ mod tests {
assert!(refused(&more), "one more isn't");
}
/// PdfCraft patch: a refinement whose reference is offset right of it reads the reference from
/// its first column, where it read the first 32 as 0. So that a context read wrong changes what
/// decodes, the refinement is large, and its picture comes from the hash it was coded from: a
/// 104 × 12 text instance refined from a 100 × 12 symbol 2 right of it.
#[test]
fn a_refinement_reads_a_reference_right_of_it_from_its_first_column() {
#[derive(Default)]
struct Rows(Vec<Vec<u8>>, Vec<u8>);
impl Decoder for Rows {
fn push_pixel(&mut self, black: bool) {
self.1.push(u8::from(black));
}
fn push_pixel_chunk(&mut self, black: bool, chunks: u32) {
for _ in 0..8 * chunks {
self.push_pixel(black);
}
}
fn next_line(&mut self) {
self.0.push(core::mem::take(&mut self.1));
}
}
fn bit(seed: u32, x: u32, y: u32) -> u8 {
let mut h = x.wrapping_mul(0x9E37_79B1).wrapping_add(y.wrapping_mul(0x85EB_CA77)).wrapping_add(seed.wrapping_mul(0xC2B2_AE3D));
h ^= h >> 15;
h = h.wrapping_mul(0x2C1B_3C6D);
h ^= h >> 12;
h = h.wrapping_mul(0x297A_2D39);
h ^= h >> 15;
((h >> 7) & 1) as u8
}
// About one pixel in eight: where a refinement differs from its reference.
let flipped = |seed: u32, x: u32, y: u32| bit(seed, x, y) & bit(seed + 1, x, y) & bit(seed + 2, x, y);
// A symbol of bit(2, ..), and a text instance refined from it, 4 wider with RDX 0.
const TEXT: &str = "0000000030000100000013000000680000000c000000000000000042000000000001000001000000b1000003fffdff02fefefe00000001000000013f525ad7118f669a303f1b11efa5210e9765b834b1831c650f3a3d325dbd7317379ea4fb573b09a20c362f065d8f9301e74cbbc50c69910641c0e0eea7c2fd1e831ca1459a943be55ed8e074b426ad7ff1e8d8ff6f1aa44684de5da4b4c3483911604412e00e96a0db6ec7103feb2bc4301ae98d3f9c23078ae72dc46f76e9dfea209d39187f1194f7b9285cd6e7b2dc7abb5def43ff0abe2df554fc55ffac0000000206200101000000af000000680000000c0000000000000000040012ffffffff00000001a96b5febebec5a68693b51f5db25ddf176d4aae89904a71d1690f12888e10b038db723ac59941f76c2844b739ce524d9563f4005e1edbabf2e323e8e9ac1a3b9060587c3010e7d6bcf90c00dbf9000a2f17b1d9b598e01b9158dc16a63f4388a6f647b99dc7118aa09e08d59fba1bc24e3a0f1ebb0cae636b6bedbb65b01945228d3e5d2980a0ad6290c13d2f34f5c861415ffac";
let picture: Vec<Vec<u8>> = (0..12)
.map(|y| (0..104).map(|x| (if (2..102).contains(&x) { bit(2, x - 2, y) } else { 0 }) ^ flipped(20, x, y)).collect())
.collect();
let stream: Vec<u8> = (0..TEXT.len() / 2).map(|i| u8::from_str_radix(&TEXT[i * 2..i * 2 + 2], 16).unwrap()).collect();
let mut rows = Rows::default();
Image::new_embedded(&stream, None).unwrap().decode(&mut rows).unwrap();
assert_eq!(rows.0, picture);
}
/// A dictionary being decoded has what the page may still hold, not all of it: refused only
/// once it is stored, its copies would already have been made.
#[test]
vendor/hayro-syntax/src/crypto/mod.rs
Vendored
+22 -9
View File
@@ -74,9 +74,11 @@ pub(crate) enum Decryptor {
}
#[derive(Debug, Copy, Clone)]
pub(crate) enum DecryptionTarget {
pub(crate) enum DecryptionTarget<'a> {
String,
Stream,
/// PdfCraft patch (30): a stream that names its own crypt filter.
NamedStream(&'a str),
}
impl Decryptor {
@@ -84,7 +86,7 @@ impl Decryptor {
&self,
id: ObjectIdentifier,
data: &[u8],
target: DecryptionTarget,
target: DecryptionTarget<'_>,
) -> Option<Vec<u8>> {
match self {
Self::None => Some(data.to_vec()),
@@ -93,6 +95,8 @@ impl Decryptor {
let crypt_dict = match target {
DecryptionTarget::String => dict.string_filter,
DecryptionTarget::Stream => dict.stream_filter,
// `/Identity` isn't in the table, and a name it hasn't got reads as that.
DecryptionTarget::NamedStream(name) => dict.named.get(name).copied().unwrap_or(CryptDictionary::identity(0)),
};
match crypt_dict.cfm {
@@ -292,10 +296,12 @@ fn decrypt_rc_aes(
with_key(final_key)
}
#[derive(Debug, Copy, Clone)]
#[derive(Debug, Clone)]
pub(crate) struct DecryptorData {
stream_filter: CryptDictionary,
string_filter: CryptDictionary,
/// PdfCraft patch (30): `/CF`, for the streams that name a filter of their own.
named: HashMap<String, CryptDictionary>,
}
impl DecryptorData {
@@ -312,16 +318,23 @@ impl DecryptorData {
}
}
let stm_f = *mappings
.get(dict.get::<Name<'_>>(STM_F)?.as_str())
.unwrap_or(&CryptDictionary::identity(default_length));
let str_f = *mappings
.get(dict.get::<Name<'_>>(STR_F)?.as_str())
.unwrap_or(&CryptDictionary::identity(default_length));
// PdfCraft patch (30): `/Identity` is never an entry of `/CF`, whatever a file puts there,
// and `/StmF` and `/StrF` are optional, naming it by default (ISO 32000-2 Table 20).
mappings.remove("Identity");
let identity = CryptDictionary::identity(default_length);
let stm_f = dict
.get::<Name<'_>>(STM_F)
.and_then(|n| mappings.get(n.as_str()).copied())
.unwrap_or(identity);
let str_f = dict
.get::<Name<'_>>(STR_F)
.and_then(|n| mappings.get(n.as_str()).copied())
.unwrap_or(identity);
Some(Self {
stream_filter: stm_f,
string_filter: str_f,
named: mappings,
})
}
}
vendor/hayro-syntax/src/filter/lzw_flate.rs
Vendored
+235 -101
View File
@@ -1008,15 +1008,16 @@ fn apply_predictor(data: Vec<u8>, params: &PredictorParams) -> Option<Vec<u8>> {
return None;
}
let (bit_size, chunk_len) = if is_png_predictor {
(
8,
// PdfCraft patch: in usize (the u8 product overflowed).
(usize::from(params.colors) * usize::from(params.bits_per_component)).div_ceil(8),
)
} else {
(params.bits_per_component, params.colors as usize)
};
if is_png_predictor {
// PdfCraft patch: PNG predictors work on bytes whatever the bit depth, so they are
// undone a row at a time on byte slices instead of through the bit-level readers.
// In usize (the u8 product overflowed).
let bpp = (usize::from(params.colors) * usize::from(params.bits_per_component))
.div_ceil(8);
return Some(unfilter_png(&data, row_len, bpp));
}
let (bit_size, chunk_len) = (params.bits_per_component, params.colors as usize);
let zero_row = vec![0; row_len];
let mut prev_row = BitChunks::new(&zero_row, bit_size, chunk_len)?;
let zero_col = BitChunk::new(0, chunk_len);
@@ -1024,58 +1025,7 @@ fn apply_predictor(data: Vec<u8>, params: &PredictorParams) -> Option<Vec<u8>> {
let mut writer = BitWriter::new(&mut out, bit_size)?;
for in_row in data.chunks_exact(total_row_len) {
if is_png_predictor {
let predictor = in_row[0];
let in_data = &in_row[1..];
let in_data_chunks = BitChunks::new(in_data, bit_size, chunk_len)?;
match predictor {
1 => apply::<Sub>(
prev_row,
zero_col.clone(),
zero_col.clone(),
in_data_chunks,
&mut writer,
chunk_len,
bit_size,
)?,
2 => apply::<Up>(
prev_row,
zero_col.clone(),
zero_col.clone(),
in_data_chunks,
&mut writer,
chunk_len,
bit_size,
)?,
3 => apply::<Avg>(
prev_row,
zero_col.clone(),
zero_col.clone(),
in_data_chunks,
&mut writer,
chunk_len,
bit_size,
)?,
4 => apply::<Paeth>(
prev_row,
zero_col.clone(),
zero_col.clone(),
in_data_chunks,
&mut writer,
chunk_len,
bit_size,
)?,
_ => {
// Just copy the data.
let mut reader = BitReader::new(in_data);
while let Some(data) = reader.read(bit_size) {
writer.write(data);
}
}
}
} else if i == 2 {
if i == 2 {
apply::<Sub>(
prev_row,
zero_col.clone(),
@@ -1104,6 +1054,98 @@ fn apply_predictor(data: Vec<u8>, params: &PredictorParams) -> Option<Vec<u8>> {
}
}
/// PdfCraft patch: undoes PNG row filters (ISO 32000-2 §7.4.4.4, PNG specification §9) in
/// rows of `row_len` bytes, each after its filter-type byte, with `bpp` bytes per complete pixel
/// (at least 1). An unknown filter type copies the row as it is. Bytes after the last complete
/// row are dropped.
fn unfilter_png(data: &[u8], row_len: usize, bpp: usize) -> Vec<u8> {
let bpp = bpp.max(1);
let in_row_len = row_len.saturating_add(1);
let num_rows = data.len() / in_row_len;
let mut out = vec![0; num_rows.saturating_mul(row_len)];
let zero_row = vec![0; row_len];
let mut prev: &[u8] = &zero_row;
for (cur, in_row) in out
.chunks_exact_mut(row_len)
.zip(data.chunks_exact(in_row_len))
{
let Some((&filter, src)) = in_row.split_first() else {
break;
};
match filter {
1 => {
let mut left: &[u8] = &zero_row;
for (px, src) in cur.chunks_mut(bpp).zip(src.chunks(bpp)) {
for ((c, s), l) in px.iter_mut().zip(src).zip(left) {
*c = s.wrapping_add(*l);
}
left = px;
}
}
2 => {
for ((c, s), u) in cur.iter_mut().zip(src).zip(prev) {
*c = s.wrapping_add(*u);
}
}
3 => {
let mut left: &[u8] = &zero_row;
for ((px, src), up) in cur
.chunks_mut(bpp)
.zip(src.chunks(bpp))
.zip(prev.chunks(bpp))
{
for (((c, s), l), u) in px.iter_mut().zip(src).zip(left).zip(up) {
// The sum is taken before halving, without wrapping.
let avg = (u16::from(*l) + u16::from(*u)) / 2;
*c = s.wrapping_add(avg as u8);
}
left = px;
}
}
4 => {
let mut left: &[u8] = &zero_row;
let mut up_left: &[u8] = &zero_row;
for ((px, src), up) in cur
.chunks_mut(bpp)
.zip(src.chunks(bpp))
.zip(prev.chunks(bpp))
{
for ((((c, s), l), u), ul) in
px.iter_mut().zip(src).zip(left).zip(up).zip(up_left)
{
*c = s.wrapping_add(paeth_byte(*l, *u, *ul));
}
left = px;
up_left = up;
}
}
_ => {
for (c, s) in cur.iter_mut().zip(src) {
*c = *s;
}
}
}
prev = cur;
}
out
}
/// The Paeth predictor on bytes: the neighbour nearest `left + up - up_left`, preferring left,
/// then up.
fn paeth_byte(left: u8, up: u8, up_left: u8) -> u8 {
let (a, b, c) = (i16::from(left), i16::from(up), i16::from(up_left));
let pa = (b - c).abs();
let pb = (a - c).abs();
let pc = (a + b - c - c).abs();
let not_left = if pb <= pc { up } else { up_left };
if pa <= pb && pa <= pc { left } else { not_left }
}
fn apply<'a, T: Predictor>(
prev_row: BitChunks<'a>,
mut prev_col: BitChunk,
@@ -1153,46 +1195,6 @@ impl Predictor for Sub {
}
}
struct Up;
impl Predictor for Up {
fn predict(cur_row: u16, prev_row: u16, _: u16, _: u16) -> u16 {
cur_row.wrapping_add(prev_row)
}
}
struct Avg;
impl Predictor for Avg {
fn predict(cur_row: u16, prev_row: u16, prev_col: u16, _: u16) -> u16 {
cur_row.wrapping_add(((prev_col as u32 + prev_row as u32) / 2) as u16)
}
}
struct Paeth;
impl Predictor for Paeth {
fn predict(cur_row: u16, prev_row: u16, prev_col: u16, top_left: u16) -> u16 {
fn paeth(a: u16, b: u16, c: u16) -> u16 {
let a = a as i32;
let b = b as i32;
let c = c as i32;
let p = a + b - c;
let pa = (p - a).abs();
let pb = (p - b).abs();
let pc = (p - c).abs();
if pa <= pb && pa <= pc {
a as u16
} else if pb <= pc {
b as u16
} else {
c as u16
}
}
cur_row.wrapping_add(paeth(prev_col, prev_row, top_left))
}
}
#[cfg(test)]
#[rustfmt::skip]
mod tests {
@@ -1357,3 +1359,135 @@ mod tests {
);
}
}
/// PdfCraft patch tests: PNG predictors are undone byte by byte (`unfilter_png`).
#[cfg(test)]
mod pdfcraft_png_predictor_tests {
use crate::filter::lzw_flate::{PredictorParams, apply_predictor};
/// PNG unfiltering written out from the PNG specification (§9.2–9.4), one byte at a time.
fn reference(data: &[u8], row_len: usize, bpp: usize) -> Vec<u8> {
let mut out: Vec<u8> = Vec::new();
for (r, row) in data.chunks_exact(row_len + 1).enumerate() {
let start = r * row_len;
for x in 0..row_len {
let left = if x >= bpp { out[start + x - bpp] } else { 0 };
let up = if r > 0 { out[start + x - row_len] } else { 0 };
let up_left = if r > 0 && x >= bpp {
out[start + x - row_len - bpp]
} else {
0
};
let predicted = match row[0] {
1 => left,
2 => up,
3 => ((u16::from(left) + u16::from(up)) / 2) as u8,
4 => {
let p = i16::from(left) + i16::from(up) - i16::from(up_left);
let (pa, pb, pc) = (
(p - i16::from(left)).abs(),
(p - i16::from(up)).abs(),
(p - i16::from(up_left)).abs(),
);
if pa <= pb && pa <= pc {
left
} else if pb <= pc {
up
} else {
up_left
}
}
_ => 0,
};
out.push(row[1 + x].wrapping_add(predicted));
}
}
out
}
#[test]
fn png_predictors_match_the_specification_at_every_depth_and_pixel_size() {
let mut seed: u32 = 0x2545_f491;
let mut next = move || {
seed ^= seed << 13;
seed ^= seed >> 17;
seed ^= seed << 5;
seed
};
for case in 0..400 {
let colors = 1 + (next() % 4) as u8;
let bits_per_component = [1u8, 2, 4, 8, 16][(next() % 5) as usize];
let columns = 1 + (next() % 40) as usize;
let bpp = (usize::from(colors) * usize::from(bits_per_component)).div_ceil(8);
let row_len =
(columns * usize::from(colors) * usize::from(bits_per_component)).div_ceil(8);
let rows = 1 + (next() % 6) as usize;
let mut data = Vec::new();
for _ in 0..rows {
// Filter types 0–4, and 5–7, which are not PNG filters and copy the row.
data.push((next() % 8) as u8);
data.extend((0..row_len).map(|_| next() as u8));
}
// A partial row at the end is not decoded.
let tail = (next() % 3) as usize;
data.extend((0..tail.min(row_len)).map(|_| next() as u8));
let params = PredictorParams {
predictor: 10 + (next() % 6) as u8,
colors,
bits_per_component,
columns,
early_change: false,
};
let got = apply_predictor(data.clone(), &params).unwrap();
assert_eq!(
got,
reference(&data, row_len, bpp),
"case {case}: {colors} colours at {bits_per_component} bits, {columns} columns"
);
}
}
#[test]
fn a_row_ending_part_way_through_a_pixel_keeps_its_last_byte() {
// Three 4-bit samples are a byte and a half, so a three-column row is five bytes and ends
// half-way through a two-byte pixel. Each row is filtered Up.
let data = [
2, 10, 11, 12, 13, 14, //
2, 20, 21, 22, 23, 24, //
2, 30, 31, 32, 33, 34,
];
let params = PredictorParams {
predictor: 15,
colors: 3,
bits_per_component: 4,
columns: 3,
early_change: false,
};
assert_eq!(
apply_predictor(data.to_vec(), &params).unwrap(),
[10, 11, 12, 13, 14, 30, 32, 34, 36, 38, 60, 63, 66, 69, 72]
);
}
#[test]
fn png_average_and_paeth_carry_the_left_pixel_across_a_wide_row() {
// Three 16-bit samples (6 bytes) per pixel: the left neighbour is six bytes back.
let row_len = 6 * 3;
let mut data = vec![3u8];
data.extend((0..row_len).map(|i| (i * 37 + 200) as u8));
data.push(4);
data.extend((0..row_len).map(|i| (255 - i * 11) as u8));
let params = PredictorParams {
predictor: 15,
colors: 3,
bits_per_component: 16,
columns: 3,
early_change: false,
};
assert_eq!(
apply_predictor(data.clone(), &params).unwrap(),
reference(&data, row_len, 6)
);
}
}
vendor/hayro-syntax/src/filter/mod.rs
Vendored
+2 -1
View File
@@ -130,7 +130,8 @@ impl Filter {
warn!("image decoding is not supported (enable the `images` feature)");
Err(DecodeFailure::ImageDecode)
}
_ => Err(DecodeFailure::StreamDecode),
// PdfCraft patch (30): `Stream::raw_data` decrypted the data with the filter this names.
Self::Crypt => Ok(FilterResult::from_data(data.to_vec())),
};
if res.is_err() {
vendor/hayro-syntax/src/object/stream.rs
Vendored
+49 -19
View File
@@ -5,7 +5,7 @@ use crate::filter::Filter;
use crate::object;
use crate::object::Dict;
use crate::object::Name;
use crate::object::dict::keys::{DECODE_PARMS, DP, F, FILTER, LENGTH, TYPE};
use crate::object::dict::keys::{DECODE_PARMS, DP, F, FILTER, LENGTH, NAME, TYPE};
use crate::object::{Array, ObjectIdentifier};
use crate::object::{Object, ObjectLike, ObjectRefLike};
use crate::reader::Reader;
@@ -13,6 +13,7 @@ use crate::reader::{Readable, ReaderContext, ReaderExt, Skippable};
use crate::trivia::is_white_space_character;
use crate::util::{OptionLog, find_needle};
use alloc::borrow::Cow;
use alloc::string::{String, ToString};
use alloc::vec::Vec;
use core::fmt::{Debug, Formatter};
use smallvec::SmallVec;
@@ -73,38 +74,44 @@ impl<'a> Stream<'a> {
let mut collected_filters = SmallVec::new();
let mut collected_params = SmallVec::new();
// PdfCraft patch (30): `/DecodeParms` in either form, whichever form `/Filter` has: one filter
// in an array with a lone dictionary is an everyday spelling, and a lone dictionary is the
// first filter's. Read as the chain asks, so a long array costs no more than a short one.
let parms = self
.dict
.get::<Object<'_>>(DP)
.or_else(|| self.dict.get::<Object<'_>>(DECODE_PARMS));
let mut in_array = match &parms {
Some(Object::Array(a)) => Some(a.iter::<Object<'_>>()),
_ => None,
};
let mut lone = match parms {
Some(Object::Dict(d)) => Some(d),
_ => None,
};
let mut next_params = || {
lone.take()
.or_else(|| in_array.as_mut()?.next()?.into_dict())
.unwrap_or_default()
};
if let Some(filter) = self
.dict
.get::<Name<'_>>(F)
.or_else(|| self.dict.get::<Name<'_>>(FILTER))
.and_then(Filter::from_name)
{
let params = self
.dict
.get::<Dict<'_>>(DP)
.or_else(|| self.dict.get::<Dict<'_>>(DECODE_PARMS))
.unwrap_or_default();
collected_filters.push(filter);
collected_params.push(params);
collected_params.push(next_params());
} else if let Some(filters) = self
.dict
.get::<Array<'_>>(F)
.or_else(|| self.dict.get::<Array<'_>>(FILTER))
{
let filters = filters.iter::<Name<'_>>().map(Filter::from_name);
let mut params = self
.dict
.get::<Array<'_>>(DP)
.or_else(|| self.dict.get::<Array<'_>>(DECODE_PARMS))
.map(|a| a.iter::<Object<'_>>());
for filter in filters {
let params = params
.as_mut()
.and_then(|p| p.next())
.and_then(|p| p.into_dict())
.unwrap_or_default();
let params = next_params();
if let Some(filter) = filter {
collected_filters.push(filter);
@@ -119,6 +126,20 @@ impl<'a> Stream<'a> {
}
}
/// PdfCraft patch (30): the crypt filter the stream names for itself: `/Crypt` in its chain, its
/// name in that filter's parameters, or `/Identity` without one (ISO 32000-2 §7.4.10).
fn crypt_filter(&self) -> Option<String> {
let FiltersAndParams { filters, params } = self.filters_and_params();
// A chain longer than cos decodes names none there, so it names none here either:
// `pdfcraft_filters::MAX_CHAIN`, and `/Crypt`.
if filters.len() > 9 {
return None;
}
let i = filters.iter().position(|f| matches!(f, Filter::Crypt))?;
let name = params.get(i).and_then(|p| p.get::<Name<'_>>(NAME));
Some(name.map_or_else(|| "Identity".to_string(), |n| n.as_str().to_string()))
}
/// Return the raw, decrypted data of the stream.
///
/// Stream filters will not be applied.
@@ -132,9 +153,13 @@ impl<'a> Stream<'a> {
.map(|t| t.as_ref() != b"XRef")
.unwrap_or(true)
{
let own = self.crypt_filter();
let target = own
.as_deref()
.map_or(DecryptionTarget::Stream, DecryptionTarget::NamedStream);
Cow::Owned(
ctx.xref()
.decrypt(self.obj_id(), self.data, DecryptionTarget::Stream)
.decrypt(self.obj_id(), self.data, target)
// TODO: MAybe an error would be better?
.unwrap_or_default(),
)
@@ -241,6 +266,11 @@ impl<'a> Stream<'a> {
.zip(filters_and_params.params.iter())
.enumerate()
{
// PdfCraft patch (30): `raw_data` decrypted the data, so there's nothing to undo, and a
// chain can name this thousands of times.
if matches!(filter, Filter::Crypt) {
continue;
}
// PdfCraft patch: see `filter::decode_limit`.
let limit = crate::filter::decode_limit(image_params, i + 1 == count).min(max);
let new = filter.apply(
vendor/hayro-syntax/src/xref.rs
Vendored
+1 -1
View File
@@ -651,7 +651,7 @@ impl XRef {
&self,
id: ObjectIdentifier,
data: &[u8],
target: DecryptionTarget,
target: DecryptionTarget<'_>,
) -> Option<Vec<u8>> {
match &self.0 {
Inner::Dummy => Some(data.to_vec()),
xtask/src/layers.rs
+1
View File
@@ -34,6 +34,7 @@ pub const TABLE: &[(&str, Class)] = &[
("filters", Class::Standalone(0)),
("crypt", Class::Standalone(0)),
("arlington", Class::Standalone(0)),
("prc", Class::Standalone(0)),
// L1 object layer
("cos", Class::Standalone(1)),
// L2 core model