mirror of
https://github.com/storytold/craft-libs.git
synced 2026-11-18 00:12:57 +00:00
* pdf inspection: count pending text clips and drop page content after reading - hayro-interpret: state_bytes counts the pending text-clip outlines a saved state copies, so MAX_SAVED_STATE_BYTES bounds them too. - plate-test structure: read each page through a ContentReader into a buffer dropped after the page, instead of page.operations(), which keeps every page's decoded content for as long as the document. * address review: cap page content read at the 256 MiB decode limit * fix the saved-state test: start the clip outline with a MoveTo
720 lines
26 KiB
Rust
720 lines
26 KiB
Rust
use crate::cache::{Cache, CacheKey, DecodedImageCache};
|
||
use crate::color::ColorSpace;
|
||
use crate::convert::convert_transform;
|
||
use crate::font::{Font, StandardFont};
|
||
use crate::interpret::state::{ClipType, State, TextStateFont};
|
||
use crate::ocg::OcgState;
|
||
use crate::util::{BezPathExt, Float64Ext};
|
||
use crate::{ClipPath, Device, FillRule, InterpreterSettings, StrokeProps};
|
||
use hayro_syntax::content::ops::Transform;
|
||
use hayro_syntax::object::Dict;
|
||
use hayro_syntax::object::Name;
|
||
use hayro_syntax::object::Stream;
|
||
use hayro_syntax::page::Resources;
|
||
use hayro_syntax::xref::XRef;
|
||
use kurbo::{Affine, BezPath, PathEl, Point, Rect, Shape};
|
||
use std::borrow::Cow;
|
||
use std::cell::RefCell;
|
||
use std::collections::HashMap;
|
||
use std::rc::Rc;
|
||
|
||
/// Maximum nesting depth for interpreting `XObject`'s/patterns/streams.
|
||
pub(crate) const MAX_NESTED_INTERPRETATION_DEPTH: u32 = 50;
|
||
/// PdfCraft patch: maximum nesting for content that is painted recursively by the device
|
||
/// (tiling patterns, Type 3 glyphs). Either can refer back to itself through resources it
|
||
/// inherits, which recursed until the stack overflowed (found by fuzzing).
|
||
pub(crate) const MAX_PAINT_NESTING: u32 = 16;
|
||
|
||
/// PdfCraft patch: how many nested paints (a form inside a form, a Type 3 glyph or tiling
|
||
/// pattern painted from inside another one) one page may do. Nesting depth alone doesn't bound
|
||
/// the work: a glyph that shows ten glyphs of its own font, nested sixteen deep, is 10^16
|
||
/// paints (a fuzzed file hung). Ordinary pages stay far below this.
|
||
pub(crate) const MAX_NESTED_PAINTS: u32 = 50_000;
|
||
|
||
std::thread_local! {
|
||
static NESTED_PAINTS: core::cell::Cell<u32> = const { core::cell::Cell::new(0) };
|
||
static CONTENT_LEFT: core::cell::Cell<usize> = const { core::cell::Cell::new(MAX_PAGE_CONTENT) };
|
||
// PdfCraft patch (18): whether this page's content budget ran out, reported as
|
||
// `InterpreterWarning::ContentTruncated`.
|
||
static CONTENT_TRUNCATED: core::cell::Cell<bool> = const { core::cell::Cell::new(false) };
|
||
}
|
||
|
||
/// PdfCraft patch: decoded content-stream bytes one page may hold at once: its contents, and
|
||
/// the forms, tiling patterns and Type 3 glyph procedures being painted. Each stream already
|
||
/// stops at `MAX_DECODED_STREAM`, but forms nest fifty deep and every level keeps its content
|
||
/// while the next one runs: a form painting itself around a stream that inflates to 256 MiB
|
||
/// would have held over 12 GB. A level gives its bytes back when it finishes, so content
|
||
/// painted again and again doesn't use the budget up. Ordinary pages hold a few megabytes.
|
||
pub(crate) const MAX_PAGE_CONTENT: usize = 512 << 20;
|
||
|
||
/// PdfCraft patch: a content stream decoded within the page's [`MAX_PAGE_CONTENT`]. The bytes
|
||
/// it decoded count against the budget until it is dropped; a stream without filters is
|
||
/// borrowed from the file and costs nothing.
|
||
pub(crate) struct DecodedContent<'a> {
|
||
data: Cow<'a, [u8]>,
|
||
held: usize,
|
||
}
|
||
|
||
impl AsRef<[u8]> for DecodedContent<'_> {
|
||
fn as_ref(&self) -> &[u8] {
|
||
&self.data
|
||
}
|
||
}
|
||
|
||
impl Drop for DecodedContent<'_> {
|
||
fn drop(&mut self) {
|
||
let held = self.held;
|
||
CONTENT_LEFT.with(|c| c.set(c.get().saturating_add(held).min(MAX_PAGE_CONTENT)));
|
||
}
|
||
}
|
||
|
||
/// PdfCraft patch: decode a content stream within what is left of this page's
|
||
/// [`MAX_PAGE_CONTENT`]. `None` once the budget is spent (the content is skipped).
|
||
pub(crate) fn decode_content<'a>(stream: &Stream<'a>) -> Option<DecodedContent<'a>> {
|
||
let left = CONTENT_LEFT.with(core::cell::Cell::get);
|
||
if left == 0 {
|
||
CONTENT_TRUNCATED.with(|truncated| truncated.set(true));
|
||
warn!("page content budget exceeded");
|
||
return None;
|
||
}
|
||
let filtered = !stream.filters().is_empty();
|
||
let limit = if filtered { left.min(stream.decode_limits().max_decoded_stream()) } else { left };
|
||
let Ok(data) = stream.decoded_within(limit) else {
|
||
CONTENT_TRUNCATED.with(|truncated| truncated.set(true));
|
||
return None;
|
||
};
|
||
// The whole-stream decoders do not expose completion. Conservatively report a
|
||
// filtered form, pattern or Type 3 procedure reaching its effective budget.
|
||
if filtered && data.len() >= limit {
|
||
CONTENT_TRUNCATED.with(|truncated| truncated.set(true));
|
||
}
|
||
let held = match &data {
|
||
Cow::Owned(v) => v.len(),
|
||
Cow::Borrowed(_) => 0,
|
||
};
|
||
charge_content(held);
|
||
Some(DecodedContent { data, held })
|
||
}
|
||
|
||
/// PdfCraft patch: count `len` bytes held for the rest of the page (its own contents).
|
||
pub(crate) fn charge_content(len: usize) {
|
||
CONTENT_LEFT.with(|c| c.set(c.get().saturating_sub(len)));
|
||
}
|
||
|
||
/// PdfCraft patch (18): whether content was skipped because the page's budget ran out.
|
||
pub(crate) fn content_was_truncated() -> bool {
|
||
CONTENT_TRUNCATED.with(core::cell::Cell::get)
|
||
}
|
||
|
||
/// PdfCraft patch: count a paint at `depth` (top-level ones are free); `false` once this
|
||
/// page's budget is spent, and the paint is skipped.
|
||
pub(crate) fn take_nested_paint(depth: u32) -> bool {
|
||
if depth < 2 {
|
||
return true;
|
||
}
|
||
NESTED_PAINTS.with(|n| {
|
||
let used = n.get();
|
||
if used >= MAX_NESTED_PAINTS {
|
||
return false;
|
||
}
|
||
n.set(used + 1);
|
||
true
|
||
})
|
||
}
|
||
|
||
/// A cache used by the interpreter.
|
||
///
|
||
/// Ideally, such a cache should be constructed once per PDF and then reused across
|
||
/// multiple interpreter invocations on the same document.
|
||
#[derive(Clone)]
|
||
pub struct InterpreterCache<'a> {
|
||
pub(crate) font_cache: Rc<RefCell<HashMap<u128, Option<Font<'a>>>>>,
|
||
pub(crate) object_cache: Cache,
|
||
/// PdfCraft patch: decoded images, shared by every render through this cache so a tile
|
||
/// no longer decodes its page's images again.
|
||
pub(crate) decoded_cache: DecodedImageCache,
|
||
}
|
||
|
||
impl<'a> Default for InterpreterCache<'a> {
|
||
fn default() -> Self {
|
||
Self::new()
|
||
}
|
||
}
|
||
|
||
impl<'a> InterpreterCache<'a> {
|
||
/// Create a new interpreter cache.
|
||
pub fn new() -> Self {
|
||
Self {
|
||
font_cache: Rc::new(RefCell::new(HashMap::new())),
|
||
object_cache: Cache::new(),
|
||
decoded_cache: DecodedImageCache::new(),
|
||
}
|
||
}
|
||
|
||
/// PdfCraft patch (32): how many images were decoded through this cache (its misses, not
|
||
/// counting images that are never cached), for diagnostics and tests.
|
||
pub fn decoded_image_decodes(&self) -> usize {
|
||
self.decoded_cache.decodes()
|
||
}
|
||
|
||
/// PdfCraft patch (#3020): how many `/ICCBased` profiles were read through this cache, for
|
||
/// diagnostics and tests. A profile used again, by the same stream object or by a copy with
|
||
/// the same dictionary and bytes, is read once.
|
||
pub fn icc_profile_reads(&self) -> usize {
|
||
self.object_cache.icc_profile_reads()
|
||
}
|
||
}
|
||
|
||
/// A per-page interpretation context that borrows shared data from an [`InterpreterCache`].
|
||
pub struct Context<'a> {
|
||
states: Vec<State<'a>>,
|
||
path: BezPath,
|
||
sub_path_start: Point,
|
||
last_point: Point,
|
||
clip: Option<FillRule>,
|
||
root_transforms: Vec<Affine>,
|
||
bbox: Vec<Rect>,
|
||
pub(crate) settings: InterpreterSettings,
|
||
pub(crate) interpreter_cache: InterpreterCache<'a>,
|
||
pub(crate) xref: &'a XRef,
|
||
pub(crate) ocg_state: OcgState,
|
||
nesting_depth: u32,
|
||
/// PdfCraft patch: estimated bytes held by saved states, and for each `q` not saved because
|
||
/// a limit was reached, the clip count to return to at its `Q`.
|
||
saved_bytes: usize,
|
||
skipped_saves: Vec<usize>,
|
||
}
|
||
|
||
/// PdfCraft patch: most graphics states saved at once. Every `q` copies the current state, dash
|
||
/// array and clip list included, so without a limit short operators multiply one large state.
|
||
const MAX_SAVED_STATES: usize = 4096;
|
||
/// PdfCraft patch: most bytes all saved states may hold together.
|
||
const MAX_SAVED_STATE_BYTES: usize = 64 << 20;
|
||
|
||
/// Roughly what a saved copy of `state` holds.
|
||
/// PdfCraft patch (51): the sums saturate, so a huge dash array or clip list counts as over the
|
||
/// bound rather than wrapping on a 32-bit target. The pending text-clip outlines (text render
|
||
/// modes 4–7) are copied with the state too, so they count.
|
||
fn state_bytes(state: &State<'_>) -> usize {
|
||
size_of::<State<'_>>()
|
||
.saturating_add(
|
||
state
|
||
.graphics_state
|
||
.stroke_props
|
||
.dash_array
|
||
.len()
|
||
.saturating_mul(size_of::<f32>()),
|
||
)
|
||
.saturating_add(state.clips.len().saturating_mul(size_of::<ClipType>()))
|
||
.saturating_add(state.text_state.clip_paths.elements().len().saturating_mul(size_of::<PathEl>()))
|
||
}
|
||
|
||
impl<'a> Context<'a> {
|
||
/// Create a new context.
|
||
pub fn new(
|
||
initial_transform: Affine,
|
||
bbox: Rect,
|
||
cache: &InterpreterCache<'a>,
|
||
xref: &'a XRef,
|
||
settings: InterpreterSettings,
|
||
) -> Self {
|
||
let state = State::new(initial_transform);
|
||
// PdfCraft patch: a page (or other top-level content) starts with fresh budgets.
|
||
NESTED_PAINTS.with(|n| n.set(0));
|
||
CONTENT_LEFT.with(|c| c.set(MAX_PAGE_CONTENT));
|
||
CONTENT_TRUNCATED.with(|truncated| truncated.set(false));
|
||
crate::encode::reset_mesh_budget();
|
||
|
||
Self::new_with(initial_transform, bbox, cache, xref, settings, state, 0)
|
||
}
|
||
|
||
pub(crate) fn new_with(
|
||
initial_transform: Affine,
|
||
bbox: Rect,
|
||
cache: &InterpreterCache<'a>,
|
||
xref: &'a XRef,
|
||
settings: InterpreterSettings,
|
||
state: State<'a>,
|
||
nesting_depth: u32,
|
||
) -> Self {
|
||
let mut ocg_state = {
|
||
let root_ref = xref.root_id();
|
||
xref.get::<Dict<'_>>(root_ref)
|
||
.map(|catalog| OcgState::from_catalog(&catalog))
|
||
.unwrap_or_default()
|
||
};
|
||
// PdfCraft patch: apply viewer layer toggles.
|
||
for (num, generation, visible) in settings.ocg_overrides.iter() {
|
||
ocg_state.set_active(hayro_syntax::object::ObjectIdentifier::new(*num, *generation), *visible);
|
||
}
|
||
|
||
Self {
|
||
states: vec![state],
|
||
settings,
|
||
xref,
|
||
root_transforms: vec![initial_transform],
|
||
last_point: Point::default(),
|
||
sub_path_start: Point::default(),
|
||
clip: None,
|
||
bbox: vec![bbox],
|
||
path: BezPath::new(),
|
||
interpreter_cache: cache.clone(),
|
||
ocg_state,
|
||
nesting_depth,
|
||
saved_bytes: 0,
|
||
skipped_saves: Vec::new(),
|
||
}
|
||
}
|
||
|
||
pub(crate) fn save_state(&mut self) {
|
||
let Some(cur) = self.states.last() else {
|
||
warn!("attempted to save state without existing state");
|
||
return;
|
||
};
|
||
|
||
// PdfCraft patch: past either limit the `q` is recorded but nothing is copied. Its `Q`
|
||
// still removes the clips added since; other changes made in between are kept.
|
||
let bytes = state_bytes(cur);
|
||
if !self.skipped_saves.is_empty()
|
||
|| self.states.len() >= MAX_SAVED_STATES
|
||
|| self.saved_bytes.saturating_add(bytes) > MAX_SAVED_STATE_BYTES
|
||
{
|
||
if self.skipped_saves.is_empty() {
|
||
warn!("too many saved graphics states; further saves are not kept");
|
||
}
|
||
self.skipped_saves.push(cur.clips.len());
|
||
return;
|
||
}
|
||
|
||
let cur = cur.clone();
|
||
self.saved_bytes = self.saved_bytes.saturating_add(bytes);
|
||
self.states.push(cur);
|
||
}
|
||
|
||
pub(crate) fn bbox(&self) -> Rect {
|
||
self.bbox.last().copied().unwrap_or_else(|| {
|
||
warn!("failed to get a bbox");
|
||
|
||
Rect::new(0.0, 0.0, 1.0, 1.0)
|
||
})
|
||
}
|
||
|
||
fn push_bbox(&mut self, bbox: Rect) {
|
||
let new = self.bbox().intersect(bbox);
|
||
self.bbox.push(new);
|
||
}
|
||
|
||
pub(crate) fn push_clip_path(
|
||
&mut self,
|
||
clip_path: BezPath,
|
||
fill: FillRule,
|
||
device: &mut impl Device<'a>,
|
||
) {
|
||
if let Some(clip_rect) = path_as_rect(&clip_path) {
|
||
let cur_bbox = self.bbox();
|
||
|
||
// If the clip path is a rect and completely covers the current bbox, don't emit it.
|
||
if cur_bbox
|
||
.min_x()
|
||
.is_nearly_greater_or_equal(clip_rect.min_x())
|
||
&& cur_bbox
|
||
.min_y()
|
||
.is_nearly_greater_or_equal(clip_rect.min_y())
|
||
&& cur_bbox.max_x().is_nearly_less_or_equal(clip_rect.max_x())
|
||
&& cur_bbox.max_y().is_nearly_less_or_equal(clip_rect.max_y())
|
||
{
|
||
self.get_mut().clips.push(ClipType::Dummy);
|
||
return;
|
||
}
|
||
}
|
||
|
||
let bbox = clip_path.bounding_box();
|
||
device.push_clip_path(&ClipPath {
|
||
path: clip_path,
|
||
fill,
|
||
});
|
||
self.push_bbox(bbox);
|
||
self.get_mut().clips.push(ClipType::Real);
|
||
}
|
||
|
||
pub(crate) fn pop_clip_path(&mut self, device: &mut impl Device<'a>) {
|
||
if let Some(ClipType::Real) = self.get_mut().clips.pop() {
|
||
device.pop_clip_path();
|
||
self.pop_bbox();
|
||
}
|
||
}
|
||
|
||
fn pop_bbox(&mut self) {
|
||
self.bbox.pop();
|
||
}
|
||
|
||
pub(crate) fn push_root_transform(&mut self) {
|
||
self.root_transforms.push(self.get().ctm);
|
||
}
|
||
|
||
pub(crate) fn pop_root_transform(&mut self) {
|
||
self.root_transforms.pop();
|
||
}
|
||
|
||
pub(crate) fn root_transform(&self) -> Affine {
|
||
self.root_transforms
|
||
.last()
|
||
.copied()
|
||
.unwrap_or(Affine::IDENTITY)
|
||
}
|
||
|
||
pub(crate) fn restore_state(&mut self, device: &mut impl Device<'a>) {
|
||
// PdfCraft patch: a save that was not kept is the most recent one.
|
||
if let Some(target_clips) = self.skipped_saves.pop() {
|
||
while self.get().clips.len() > target_clips {
|
||
self.pop_clip_path(device);
|
||
}
|
||
return;
|
||
}
|
||
|
||
let Some(target_clips) = self
|
||
.states
|
||
.get(self.states.len().saturating_sub(2))
|
||
.map(|s| s.clips.len())
|
||
else {
|
||
warn!("underflowed graphics state");
|
||
return;
|
||
};
|
||
|
||
while self.get().clips.len() > target_clips {
|
||
self.pop_clip_path(device);
|
||
}
|
||
|
||
// The first state should never be popped.
|
||
if self.states.len() > 1 {
|
||
self.states.pop();
|
||
// PdfCraft patch: the state now on top is the copy that was charged when saved.
|
||
if let Some(top) = self.states.last() {
|
||
self.saved_bytes = self.saved_bytes.saturating_sub(state_bytes(top));
|
||
}
|
||
}
|
||
|
||
device.set_soft_mask(
|
||
self.states
|
||
.last()
|
||
.and_then(|l| l.graphics_state.soft_mask.clone()),
|
||
);
|
||
}
|
||
|
||
pub(crate) fn path(&self) -> &BezPath {
|
||
&self.path
|
||
}
|
||
|
||
pub(crate) fn path_mut(&mut self) -> &mut BezPath {
|
||
&mut self.path
|
||
}
|
||
|
||
pub(crate) fn sub_path_start(&self) -> &Point {
|
||
&self.sub_path_start
|
||
}
|
||
|
||
pub(crate) fn sub_path_start_mut(&mut self) -> &mut Point {
|
||
&mut self.sub_path_start
|
||
}
|
||
|
||
pub(crate) fn last_point(&self) -> &Point {
|
||
&self.last_point
|
||
}
|
||
|
||
pub(crate) fn last_point_mut(&mut self) -> &mut Point {
|
||
&mut self.last_point
|
||
}
|
||
|
||
pub(crate) fn clip_mut(&mut self) -> &mut Option<FillRule> {
|
||
&mut self.clip
|
||
}
|
||
|
||
pub(crate) fn get(&self) -> &State<'a> {
|
||
self.states.last().unwrap()
|
||
}
|
||
|
||
pub(crate) fn get_mut(&mut self) -> &mut State<'a> {
|
||
self.states.last_mut().unwrap()
|
||
}
|
||
|
||
pub(crate) fn pre_concat_transform(&mut self, transform: Transform) {
|
||
self.pre_concat_affine(convert_transform(transform));
|
||
}
|
||
|
||
pub(crate) fn pre_concat_affine(&mut self, transform: Affine) {
|
||
self.get_mut().ctm *= transform;
|
||
}
|
||
|
||
pub(crate) fn get_color_space(
|
||
&mut self,
|
||
resources: &Resources<'_>,
|
||
name: &Name<'_>,
|
||
) -> Option<ColorSpace> {
|
||
let cs_object = resources.get_color_space(name)?;
|
||
self.interpreter_cache
|
||
.object_cache
|
||
.get_or_insert_with(cs_object.cache_key(), || {
|
||
ColorSpace::new(cs_object.clone(), &self.interpreter_cache.object_cache)
|
||
})
|
||
}
|
||
|
||
pub(crate) fn stroke_props(&self) -> StrokeProps {
|
||
self.get().graphics_state.stroke_props.clone()
|
||
}
|
||
|
||
pub(crate) fn num_states(&self) -> usize {
|
||
// PdfCraft patch: saves not kept still count, so callers restore back past them.
|
||
self.states.len().saturating_add(self.skipped_saves.len())
|
||
}
|
||
|
||
pub(crate) fn nesting_depth(&self) -> u32 {
|
||
self.nesting_depth
|
||
}
|
||
|
||
pub(crate) fn begin_nested_interpretation(&mut self) -> bool {
|
||
if self.nesting_depth >= MAX_NESTED_INTERPRETATION_DEPTH {
|
||
warn!("interpreter nesting depth exceeded");
|
||
|
||
return false;
|
||
}
|
||
if !take_nested_paint(self.nesting_depth + 1) {
|
||
warn!("nested paint budget exceeded");
|
||
|
||
return false;
|
||
}
|
||
|
||
self.nesting_depth += 1;
|
||
|
||
true
|
||
}
|
||
|
||
pub(crate) fn end_nested_interpretation(&mut self) {
|
||
self.nesting_depth = self.nesting_depth.saturating_sub(1);
|
||
}
|
||
pub(crate) fn resolve_font(&mut self, font_dict: &Dict<'a>) -> Option<TextStateFont<'a>> {
|
||
let cache_key = font_dict.cache_key();
|
||
|
||
let resolved = {
|
||
let mut font_cache = self.interpreter_cache.font_cache.borrow_mut();
|
||
font_cache
|
||
.entry(cache_key)
|
||
.or_insert_with(|| {
|
||
Font::new(
|
||
font_dict,
|
||
&self.settings.font_resolver,
|
||
&self.settings.cmap_resolver,
|
||
)
|
||
})
|
||
.clone()
|
||
};
|
||
|
||
if let Some(resolved) = resolved {
|
||
Some(TextStateFont::Font(resolved))
|
||
} else {
|
||
Font::new_standard(StandardFont::Helvetica, &self.settings.font_resolver)
|
||
.map(TextStateFont::Fallback)
|
||
}
|
||
}
|
||
}
|
||
|
||
pub(crate) fn path_as_rect(path: &BezPath) -> Option<Rect> {
|
||
// One MoveTo, three LineTo, one ClosePath
|
||
if path.elements().len() != 5 {
|
||
return None;
|
||
}
|
||
|
||
// PdfCraft patch (35), PdfCraft #3327: the points have to trace the rectangle, not merely
|
||
// reach its corners. The length check above admits one MoveTo and four LineTo as well as the
|
||
// intended one MoveTo, three LineTo and one ClosePath, and asking only that each corner of
|
||
// the bounding box was visited says nothing about the order or the steps between: a
|
||
// five-point polyline whose ends reached every corner of its own bounding box was painted as
|
||
// that box, and a clip of that shape was discarded. Four distinct points, each step along one
|
||
// axis, the last point back at the first: that is a rectangle and nothing else is.
|
||
let mut points: Vec<Point> = Vec::with_capacity(5);
|
||
let mut closed = false;
|
||
for (idx, el) in path.elements().iter().enumerate() {
|
||
match el {
|
||
PathEl::MoveTo(p) => {
|
||
if idx != 0 {
|
||
return None;
|
||
}
|
||
points.push(*p);
|
||
}
|
||
PathEl::LineTo(p) => points.push(*p),
|
||
PathEl::QuadTo(_, _) => return None,
|
||
PathEl::CurveTo(_, _, _) => return None,
|
||
// A subpath that ends and starts again is more than one shape.
|
||
PathEl::ClosePath => {
|
||
if idx + 1 != path.elements().len() {
|
||
return None;
|
||
}
|
||
closed = true;
|
||
}
|
||
}
|
||
}
|
||
|
||
// Exactly equal, not nearly: `is_nearly_equal` allows a 256th of a path unit, and the matrix
|
||
// is applied after this, so a large `cm` turns that into whole device units: a path that only
|
||
// nearly closes would be painted as the rectangle, with a side it does not have. A
|
||
// rectangle's coordinates are equal in the content stream, so nothing that is one loses the
|
||
// fast path by this; a path that misses takes the general route and is painted as written.
|
||
let same = |a: Point, b: Point| a.x == b.x && a.y == b.y;
|
||
// `m l l l l`: the fourth line goes back to the start, which `m l l l h` does with ClosePath.
|
||
if !closed {
|
||
match (points.first(), points.get(4)) {
|
||
(Some(first), Some(last)) if points.len() == 5 && same(*first, *last) => {}
|
||
_ => return None,
|
||
}
|
||
points.pop();
|
||
}
|
||
if points.len() != 4 {
|
||
return None;
|
||
}
|
||
// Distinct, so a degenerate path is not one, and each step along one axis only: the four
|
||
// points of an axis-aligned rectangle, in order round it.
|
||
for (i, p) in points.iter().enumerate() {
|
||
let q = points.get((i + 1) % 4)?;
|
||
let along_x = p.y == q.y && p.x != q.x;
|
||
let along_y = p.x == q.x && p.y != q.y;
|
||
if !(along_x || along_y) {
|
||
return None;
|
||
}
|
||
if points.iter().skip(i + 1).any(|o| same(*p, *o)) {
|
||
return None;
|
||
}
|
||
}
|
||
|
||
Some(path.fast_bounding_box())
|
||
}
|
||
|
||
/// PdfCraft patch (35) tests: only a path that traces an axis-aligned rectangle is one.
|
||
#[cfg(test)]
|
||
mod path_as_rect_tests {
|
||
use super::*;
|
||
|
||
fn path(points: &[(f64, f64)], close: bool) -> BezPath {
|
||
let mut path = BezPath::new();
|
||
for (i, p) in points.iter().enumerate() {
|
||
if i == 0 {
|
||
path.move_to(*p);
|
||
} else {
|
||
path.line_to(*p);
|
||
}
|
||
}
|
||
if close {
|
||
path.close_path();
|
||
}
|
||
path
|
||
}
|
||
|
||
#[test]
|
||
fn an_open_polyline_through_every_corner_is_not_a_rectangle() {
|
||
// VectorCraft #2920: the zigzag's ends reach all four corners; its peak reaches none.
|
||
let zigzag = [(80.0, 38.0), (80.0, 21.75), (60.571, 29.875), (40.0, 21.75), (40.0, 38.0)];
|
||
assert_eq!(path_as_rect(&path(&zigzag, false)), None);
|
||
}
|
||
|
||
#[test]
|
||
fn corners_visited_out_of_order_are_not_a_rectangle() {
|
||
let bow_tie = [(10.0, 10.0), (50.0, 40.0), (10.0, 40.0), (50.0, 10.0)];
|
||
assert_eq!(path_as_rect(&path(&bow_tie, true)), None);
|
||
}
|
||
|
||
#[test]
|
||
fn a_path_that_only_nearly_closes_is_not_a_rectangle() {
|
||
let open = [(10.0, 10.0), (50.0, 10.0), (50.0, 40.0), (10.0, 40.0), (10.0, 10.001)];
|
||
assert_eq!(path_as_rect(&path(&open, false)), None);
|
||
}
|
||
|
||
#[test]
|
||
fn closed_rectangles_are_rectangles() {
|
||
let expected = Some(Rect::new(10.0, 10.0, 50.0, 40.0));
|
||
let closed = [(10.0, 10.0), (50.0, 10.0), (50.0, 40.0), (10.0, 40.0)];
|
||
assert_eq!(path_as_rect(&path(&closed, true)), expected);
|
||
let back_to_start = [(10.0, 10.0), (10.0, 40.0), (50.0, 40.0), (50.0, 10.0), (10.0, 10.0)];
|
||
assert_eq!(path_as_rect(&path(&back_to_start, false)), expected);
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod saved_state_tests {
|
||
use super::*;
|
||
use crate::device::DummyDevice;
|
||
use hayro_syntax::Pdf;
|
||
|
||
fn pdf() -> Pdf {
|
||
let objects = ["<< /Type /Catalog /Pages 2 0 R >>", "<< /Type /Pages /Count 0 /Kids [] >>"];
|
||
let mut out = b"%PDF-1.7\n".to_vec();
|
||
let mut offsets = Vec::new();
|
||
for (i, body) in objects.iter().enumerate() {
|
||
offsets.push(out.len());
|
||
out.extend_from_slice(format!("{} 0 obj\n{body}\nendobj\n", i + 1).as_bytes());
|
||
}
|
||
let xref = out.len();
|
||
out.extend_from_slice(b"xref\n0 3\n0000000000 65535 f \n");
|
||
for offset in offsets {
|
||
out.extend_from_slice(format!("{offset:010} 00000 n \n").as_bytes());
|
||
}
|
||
out.extend_from_slice(format!("trailer\n<< /Size 3 /Root 1 0 R >>\nstartxref\n{xref}\n%%EOF\n").as_bytes());
|
||
Pdf::new(out).expect("synthetic pdf")
|
||
}
|
||
|
||
#[test]
|
||
fn repeated_saves_of_a_large_state_stay_bounded_and_balanced() {
|
||
let pdf = pdf();
|
||
let cache = InterpreterCache::new();
|
||
let mut ctx = Context::new(Affine::IDENTITY, Rect::new(0.0, 0.0, 100.0, 100.0), &cache, pdf.xref(), InterpreterSettings::default());
|
||
ctx.get_mut().graphics_state.stroke_props.dash_array = crate::types::dash_array((0..crate::types::MAX_DASH_ENTRIES).map(|i| i as f32 + 1.0));
|
||
for _ in 0..20_000 {
|
||
ctx.save_state();
|
||
}
|
||
assert!(ctx.states.len() <= MAX_SAVED_STATES);
|
||
assert!(ctx.saved_bytes <= MAX_SAVED_STATE_BYTES);
|
||
assert_eq!(ctx.num_states(), 20_001, "every q still counts");
|
||
|
||
// A clip added after a save that was not kept is removed by its Q.
|
||
let mut device = DummyDevice;
|
||
let mut triangle = BezPath::new();
|
||
triangle.move_to((10.0, 10.0));
|
||
triangle.line_to((90.0, 10.0));
|
||
triangle.line_to((50.0, 90.0));
|
||
triangle.close_path();
|
||
let clips = ctx.get().clips.len();
|
||
ctx.push_clip_path(triangle, FillRule::NonZero, &mut device);
|
||
assert_eq!(ctx.get().clips.len(), clips + 1);
|
||
ctx.restore_state(&mut device);
|
||
assert_eq!(ctx.get().clips.len(), clips);
|
||
|
||
while ctx.num_states() > 1 {
|
||
ctx.restore_state(&mut device);
|
||
}
|
||
assert_eq!(ctx.states.len(), 1);
|
||
assert_eq!(ctx.saved_bytes, 0);
|
||
}
|
||
|
||
#[test]
|
||
fn pending_text_clip_outlines_count_toward_the_saved_bytes() {
|
||
let pdf = pdf();
|
||
let cache = InterpreterCache::new();
|
||
let mut ctx = Context::new(Affine::IDENTITY, Rect::new(0.0, 0.0, 100.0, 100.0), &cache, pdf.xref(), InterpreterSettings::default());
|
||
let empty = state_bytes(ctx.get());
|
||
ctx.get_mut().text_state.clip_paths.move_to((0.0, 0.0));
|
||
for i in 0..100_000 {
|
||
ctx.get_mut().text_state.clip_paths.line_to((f64::from(i), 1.0));
|
||
}
|
||
assert!(state_bytes(ctx.get()) >= empty + 100_000 * size_of::<PathEl>());
|
||
for _ in 0..20_000 {
|
||
ctx.save_state();
|
||
}
|
||
assert!(ctx.saved_bytes <= MAX_SAVED_STATE_BYTES);
|
||
}
|
||
|
||
#[test]
|
||
fn an_overlong_dash_array_strokes_solid() {
|
||
let max = crate::types::MAX_DASH_ENTRIES;
|
||
assert_eq!(crate::types::dash_array((0..max).map(|_| 2.0)).len(), max);
|
||
assert!(crate::types::dash_array((0..max + 1).map(|_| 2.0)).is_empty());
|
||
assert_eq!(crate::types::dash_array([0.0, 3.0].into_iter()).as_slice(), &[0.01, 3.0]);
|
||
}
|
||
}
|