Skip to main content

pdf2_render/
walk.rs

1//! The content-stream walker: graphics state, path construction, painting
2//! operators, clipping and dash handling.
3//!
4//! The walker reuses [`pdf2::Parser`] (the same tokenizer the object parser
5//! uses) and maps operators to draw calls. Operators it does not implement —
6//! text and images, until the next round — are counted and reported, never
7//! fatal: a page with text still paints its paths.
8
9use std::collections::BTreeMap;
10use std::fmt;
11
12use pdf2::lexer::{is_delimiter, is_whitespace};
13use pdf2::{Dictionary, Document, Encoding, Object, Page, Parser, Token};
14
15use crate::canvas::{Canvas, ClipMask, Color};
16use crate::font::{Font, Glyph};
17use crate::geom::{Matrix, Point};
18use crate::image::{resolve, Image};
19use crate::path::{dash_polyline, stroke_outline, Cap, Dash, Join, Path};
20use crate::raster::{clip_mask, fill_polygons};
21
22/// What a page render should look like.
23#[derive(Debug, Clone, PartialEq)]
24pub struct RenderOptions {
25    /// Device pixels per PDF point: `1.0` is 72 dpi.
26    pub scale: f64,
27    /// Canvas background.
28    pub background: Color,
29}
30
31impl Default for RenderOptions {
32    fn default() -> Self {
33        Self {
34            scale: 1.0,
35            background: Color::WHITE,
36        }
37    }
38}
39
40/// What happened while rendering, beyond the pixels.
41#[derive(Debug, Clone, Default, PartialEq)]
42pub struct Report {
43    /// Operators that were recognised but not drawn, with how often each
44    /// appeared. Text and image operators land here until they are implemented.
45    pub unsupported: BTreeMap<String, usize>,
46}
47
48impl Report {
49    /// Total unsupported operators.
50    pub fn unsupported_total(&self) -> usize {
51        self.unsupported.values().sum()
52    }
53
54    fn note(&mut self, operator: &[u8]) {
55        let name = String::from_utf8_lossy(operator).into_owned();
56        *self.unsupported.entry(name).or_insert(0) += 1;
57    }
58}
59
60impl fmt::Display for Report {
61    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
62        if self.unsupported.is_empty() {
63            return write!(formatter, "all operators supported");
64        }
65        let mut first = true;
66        for (name, count) in &self.unsupported {
67            if !first {
68                write!(formatter, ", ")?;
69            }
70            first = false;
71            write!(formatter, "{name}×{count}")?;
72        }
73        Ok(())
74    }
75}
76
77/// A rendered page.
78#[derive(Debug, Clone)]
79pub struct RenderedPage {
80    /// The raster.
81    pub canvas: Canvas,
82    /// What was skipped.
83    pub report: Report,
84}
85
86/// A document, page number (zero based) and rasterisation scale in one call.
87pub fn render_page_number(
88    document: &Document,
89    page_index: usize,
90    options: &RenderOptions,
91) -> crate::Result<RenderedPage> {
92    let page = document.page(page_index)?;
93    render_page(document, &page, options)
94}
95
96/// `/Widths` of a simple font, in 1/1000 em, with the descriptor's
97/// `/MissingWidth` for codes the array does not cover (9.2.4).
98#[derive(Debug, Clone, Default, PartialEq)]
99struct SimpleWidths {
100    first: i64,
101    widths: Vec<f64>,
102    missing: f64,
103}
104
105impl SimpleWidths {
106    fn advance(&self, code: u8) -> f64 {
107        let code = i64::from(code);
108        let index = code - self.first;
109        if index >= 0 {
110            #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
111            if let Some(width) = self.widths.get(index as usize) {
112                return width / 1000.0;
113            }
114        }
115        self.missing / 1000.0
116    }
117}
118
119/// What a font resource yields, with the reason it is not drawable when it is
120/// not.
121#[derive(Debug, Clone, Default)]
122struct LoadedFont {
123    font: Option<Font>,
124    widths: Option<SimpleWidths>,
125    cid: Option<CidFont>,
126    note: Option<&'static str>,
127}
128
129/// A composite (Type 0) font: two-byte codes, CIDs mapped to glyph ids through
130/// `/CIDToGIDMap`, and advances from `/W` with `/DW` as the default (9.7.4).
131#[derive(Debug, Clone)]
132struct CidFont {
133    font: Font,
134    to_gid: CidToGid,
135    widths: CidWidths,
136}
137
138#[derive(Debug, Clone)]
139enum CidToGid {
140    Identity,
141    Table(Vec<u16>),
142}
143
144#[derive(Debug, Clone, Default)]
145struct CidWidths {
146    /// `(first CID, widths)` runs from `/W`, in 1/1000 em.
147    ranges: Vec<(u32, Vec<f64>)>,
148    /// `/DW`, which the standard sets to 1000 when absent.
149    default: f64,
150}
151
152impl CidFont {
153    fn glyph_id(&self, cid: u16) -> u16 {
154        match &self.to_gid {
155            CidToGid::Identity => cid,
156            CidToGid::Table(table) => table.get(usize::from(cid)).copied().unwrap_or(0),
157        }
158    }
159
160    fn advance(&self, cid: u16) -> f64 {
161        for (start, widths) in &self.widths.ranges {
162            let index = u32::from(cid).wrapping_sub(*start);
163            if let Some(width) = widths.get(index as usize) {
164                return width / 1000.0;
165            }
166        }
167        self.widths.default / 1000.0
168    }
169}
170
171/// Rasterise one page.
172pub fn render_page(
173    document: &Document,
174    page: &Page,
175    options: &RenderOptions,
176) -> crate::Result<RenderedPage> {
177    let scale = if options.scale.is_finite() && options.scale > 0.0 {
178        options.scale
179    } else {
180        1.0
181    };
182    let media = page
183        .media_box
184        .unwrap_or(pdf2::Rect::new(0.0, 0.0, 612.0, 792.0));
185    // `/Rotate` turns the page clockwise for display, so a quarter turn swaps
186    // the canvas dimensions.
187    let rotate = page.rotate.rem_euclid(360);
188    let landscape = rotate == 90 || rotate == 270;
189    let (width_points, height_points) = if landscape {
190        (media.height(), media.width())
191    } else {
192        (media.width(), media.height())
193    };
194    let width = ((width_points * scale).round().max(1.0)) as u32;
195    let height = ((height_points * scale).round().max(1.0)) as u32;
196    let mut canvas = Canvas::new(width, height, options.background);
197    let mut report = Report::default();
198
199    // PDF user space to device space. Every case shifts the media box origin to
200    // (0, 0); the y axis grows downwards in the raster, and `/Rotate` composes
201    // a clockwise quarter turn (or two) on top of that flip.
202    let base = match rotate {
203        90 => Matrix::new(0.0, scale, scale, 0.0, -media.y0 * scale, -media.x0 * scale),
204        180 => Matrix::new(-scale, 0.0, 0.0, scale, media.x1 * scale, -media.y0 * scale),
205        270 => Matrix::new(0.0, scale, -scale, 0.0, media.y1 * scale, -media.x0 * scale),
206        _ => Matrix::new(scale, 0.0, 0.0, -scale, -media.x0 * scale, media.y1 * scale),
207    };
208
209    let content = document.page_content(page)?;
210    let mut walker = Walker {
211        canvas: &mut canvas,
212        report: &mut report,
213        document,
214        resources: page.resources.clone(),
215        state: State::new(base),
216        stack: Vec::new(),
217        path: Path::new(),
218        pending_clip: None,
219        mask: ClipMask::all(width, height),
220    };
221    walker.run(&content)?;
222    Ok(RenderedPage { canvas, report })
223}
224
225/// The part of the graphics state that painting depends on.
226#[derive(Debug, Clone)]
227struct State {
228    ctm: Matrix,
229    line_width: f64,
230    cap: Cap,
231    join: Join,
232    dash: Dash,
233    fill: Color,
234    stroke: Color,
235    font: Option<Font>,
236    font_size: f64,
237    miter_limit: f64,
238    widths: Option<SimpleWidths>,
239    cid: Option<CidFont>,
240    char_spacing: f64,
241    word_spacing: f64,
242    horizontal_scale: f64,
243    leading: f64,
244    rise: f64,
245    text_matrix: Matrix,
246    line_matrix: Matrix,
247}
248
249impl State {
250    fn new(ctm: Matrix) -> Self {
251        Self {
252            ctm,
253            line_width: 1.0,
254            cap: Cap::Butt,
255            join: Join::Miter,
256            dash: Dash::solid(),
257            fill: Color::BLACK,
258            stroke: Color::BLACK,
259            font: None,
260            font_size: 0.0,
261            miter_limit: 10.0,
262            widths: None,
263            cid: None,
264            char_spacing: 0.0,
265            word_spacing: 0.0,
266            horizontal_scale: 1.0,
267            leading: 0.0,
268            rise: 0.0,
269            text_matrix: Matrix::IDENTITY,
270            line_matrix: Matrix::IDENTITY,
271        }
272    }
273}
274
275struct Walker<'a> {
276    canvas: &'a mut Canvas,
277    report: &'a mut Report,
278    document: &'a Document,
279    resources: Option<Dictionary>,
280    state: State,
281    stack: Vec<(State, ClipMask)>,
282    path: Path,
283    pending_clip: Option<bool>,
284    mask: ClipMask,
285}
286
287impl Walker<'_> {
288    fn run(&mut self, content: &[u8]) -> crate::Result<()> {
289        let mut parser = Parser::new(content);
290        let mut operands: Vec<Object> = Vec::new();
291        loop {
292            match parser.peek_token()? {
293                Token::Eof => break,
294                Token::Keyword(_) => {
295                    let operator = match parser.next_token()? {
296                        Token::Keyword(operator) => operator,
297                        _ => return Err(crate::Error::malformed("content-stream operator")),
298                    };
299                    self.execute(&operator, &mut operands, &mut parser)?;
300                    operands.clear();
301                }
302                _ => {
303                    operands.push(parser.parse_object()?);
304                }
305            }
306        }
307        Ok(())
308    }
309
310    fn execute(
311        &mut self,
312        operator: &[u8],
313        operands: &mut [Object],
314        parser: &mut Parser<'_>,
315    ) -> crate::Result<()> {
316        match operator {
317            b"q" => {
318                self.stack.push((self.state.clone(), self.mask.clone()));
319            }
320            b"Q" => {
321                if let Some((state, mask)) = self.stack.pop() {
322                    self.state = state;
323                    self.mask = mask;
324                }
325            }
326            b"cm" => {
327                if let Some(matrix) = matrix_operand(operands) {
328                    self.state.ctm = matrix.multiply(self.state.ctm);
329                }
330            }
331            b"w" => self.state.line_width = number(operands, 0),
332            b"J" => {
333                self.state.cap = match integer(operands, 0) {
334                    1 => Cap::Round,
335                    2 => Cap::Square,
336                    _ => Cap::Butt,
337                }
338            }
339            b"j" => {
340                self.state.join = match integer(operands, 0) {
341                    1 => Join::Round,
342                    2 => Join::Bevel,
343                    _ => Join::Miter,
344                }
345            }
346            b"M" => self.state.miter_limit = number(operands, 0).max(1.0),
347            b"d" => self.state.dash = dash_operand(operands),
348            b"m" => {
349                if let Some(point) = point_operand(operands, 0) {
350                    self.path.move_to(point);
351                }
352            }
353            b"l" => {
354                if let Some(point) = point_operand(operands, 0) {
355                    self.path.line_to(point);
356                }
357            }
358            b"c" => {
359                if let (Some(c1), Some(c2), Some(to)) = (
360                    point_operand(operands, 0),
361                    point_operand(operands, 1),
362                    point_operand(operands, 2),
363                ) {
364                    self.path.curve_to(c1, c2, to);
365                }
366            }
367            b"v" | b"y" => {
368                // `v` and `y` are shorthand curves; draw them as a straight
369                // line to the end point, which keeps the path closed.
370                if let Some(to) = point_operand(operands, 1) {
371                    self.path.line_to(to);
372                }
373            }
374            b"h" => self.path.close(),
375            b"re" => {
376                let x = number(operands, 0);
377                let y = number(operands, 1);
378                let width = number(operands, 2);
379                let height = number(operands, 3);
380                self.path.add_rect(x, y, width, height);
381            }
382            b"S" => self.paint(Paint::Stroke, false)?,
383            b"s" => {
384                self.path.close();
385                self.paint(Paint::Stroke, false)?;
386            }
387            b"f" | b"F" => self.paint(Paint::Fill, false)?,
388            b"f*" => self.paint(Paint::Fill, true)?,
389            b"B" => self.paint(Paint::Both, false)?,
390            b"B*" => self.paint(Paint::Both, true)?,
391            b"b" => {
392                self.path.close();
393                self.paint(Paint::Both, false)?;
394            }
395            b"b*" => {
396                self.path.close();
397                self.paint(Paint::Both, true)?;
398            }
399            b"W" => self.pending_clip = Some(false),
400            b"W*" => self.pending_clip = Some(true),
401            b"n" => {
402                self.apply_pending_clip();
403                self.path = Path::new();
404            }
405            b"g" => {
406                self.state.fill = Color::rgb(
407                    number(operands, 0),
408                    number(operands, 0),
409                    number(operands, 0),
410                )
411            }
412            b"G" => {
413                self.state.stroke = Color::rgb(
414                    number(operands, 0),
415                    number(operands, 0),
416                    number(operands, 0),
417                )
418            }
419            b"rg" => {
420                self.state.fill = Color::rgb(
421                    number(operands, 0),
422                    number(operands, 1),
423                    number(operands, 2),
424                );
425            }
426            b"RG" => {
427                self.state.stroke = Color::rgb(
428                    number(operands, 0),
429                    number(operands, 1),
430                    number(operands, 2),
431                );
432            }
433            b"k" => {
434                self.state.fill = Color::from_cmyk(
435                    number(operands, 0),
436                    number(operands, 1),
437                    number(operands, 2),
438                    number(operands, 3),
439                );
440            }
441            b"K" => {
442                self.state.stroke = Color::from_cmyk(
443                    number(operands, 0),
444                    number(operands, 1),
445                    number(operands, 2),
446                    number(operands, 3),
447                );
448            }
449            b"BT" => {
450                self.state.text_matrix = Matrix::IDENTITY;
451                self.state.line_matrix = Matrix::IDENTITY;
452            }
453            b"ET" => {}
454            b"Tf" => {
455                let name = match operands.first() {
456                    Some(Object::Name(name)) => name.clone(),
457                    _ => return Err(crate::Error::malformed("/Tf needs a font name")),
458                };
459                self.state.font_size = number(operands, 1);
460                let (font, widths, cid) = self.load_font(&name);
461                self.state.font = font;
462                self.state.widths = widths;
463                self.state.cid = cid;
464            }
465            b"Td" | b"TD" => {
466                let tx = number(operands, 0);
467                let ty = number(operands, 1);
468                self.state.line_matrix =
469                    Matrix::new(1.0, 0.0, 0.0, 1.0, tx, ty).multiply(self.state.line_matrix);
470                self.state.text_matrix = self.state.line_matrix;
471                if operator == b"TD" {
472                    self.state.leading = -ty;
473                }
474            }
475            b"T*" => {
476                self.state.line_matrix = Matrix::new(1.0, 0.0, 0.0, 1.0, 0.0, -self.state.leading)
477                    .multiply(self.state.line_matrix);
478                self.state.text_matrix = self.state.line_matrix;
479            }
480            b"Tm" => {
481                if let Some(matrix) = matrix_operand(operands) {
482                    self.state.line_matrix = matrix;
483                    self.state.text_matrix = matrix;
484                }
485            }
486            b"TL" => self.state.leading = number(operands, 0),
487            b"Tc" => self.state.char_spacing = number(operands, 0),
488            b"Tw" => self.state.word_spacing = number(operands, 0),
489            b"Tz" => self.state.horizontal_scale = number(operands, 0) / 100.0,
490            b"Ts" => self.state.rise = number(operands, 0),
491            b"Tj" => {
492                if let Some(Object::String(string)) = operands.first() {
493                    let bytes = string.as_bytes().to_vec();
494                    self.show_text(&bytes)?;
495                }
496            }
497            b"'" => {
498                self.state.line_matrix = Matrix::new(1.0, 0.0, 0.0, 1.0, 0.0, -self.state.leading)
499                    .multiply(self.state.line_matrix);
500                self.state.text_matrix = self.state.line_matrix;
501                if let Some(Object::String(string)) = operands.first() {
502                    let bytes = string.as_bytes().to_vec();
503                    self.show_text(&bytes)?;
504                }
505            }
506            b"\"" => {
507                self.state.word_spacing = number(operands, 0);
508                self.state.char_spacing = number(operands, 1);
509                self.state.line_matrix = Matrix::new(1.0, 0.0, 0.0, 1.0, 0.0, -self.state.leading)
510                    .multiply(self.state.line_matrix);
511                self.state.text_matrix = self.state.line_matrix;
512                if let Some(Object::String(string)) = operands.get(2) {
513                    let bytes = string.as_bytes().to_vec();
514                    self.show_text(&bytes)?;
515                }
516            }
517            b"TJ" => {
518                if let Some(Object::Array(items)) = operands.first() {
519                    for item in items {
520                        match item {
521                            Object::String(string) => {
522                                let bytes = string.as_bytes().to_vec();
523                                self.show_text(&bytes)?;
524                            }
525                            Object::Integer(adjustment) => {
526                                self.adjust_text(*adjustment as f64);
527                            }
528                            Object::Real(adjustment) => self.adjust_text(*adjustment),
529                            _ => {}
530                        }
531                    }
532                }
533            }
534            b"Do" => {
535                if let Some(Object::Name(name)) = operands.first() {
536                    let name = name.clone();
537                    self.draw_image(&name)?;
538                }
539            }
540            b"BI" => {
541                skip_inline_image(parser)?;
542                self.report.note(operator);
543            }
544            _ => self.report.note(operator),
545        }
546        Ok(())
547    }
548
549    fn paint(&mut self, what: Paint, even_odd: bool) -> crate::Result<()> {
550        self.apply_pending_clip();
551        let ctm = self.state.ctm;
552        let scale = determinant_scale(ctm);
553        let polylines = self.path.flatten(ctm);
554        let painted = match what {
555            Paint::Fill | Paint::Both => true,
556            Paint::Stroke => false,
557        };
558        if painted && !polylines.is_empty() {
559            fill_polygons(
560                self.canvas,
561                &self.mask,
562                &polylines,
563                self.state.fill,
564                even_odd,
565                1.0,
566            );
567        }
568        if matches!(what, Paint::Stroke | Paint::Both) {
569            let mut stroked: Vec<Vec<Point>> = Vec::new();
570            for polyline in &polylines {
571                stroked.extend(dash_polyline(polyline, &self.state.dash, scale));
572            }
573            let outline = stroke_outline(
574                &stroked,
575                self.state.line_width * scale,
576                self.state.cap,
577                self.state.join,
578                self.state.miter_limit,
579            );
580            if !outline.is_empty() {
581                fill_polygons(
582                    self.canvas,
583                    &self.mask,
584                    &outline,
585                    self.state.stroke,
586                    false,
587                    1.0,
588                );
589            }
590        }
591        self.path = Path::new();
592        Ok(())
593    }
594
595    fn adjust_text(&mut self, adjustment: f64) {
596        let tx = -adjustment / 1000.0 * self.state.font_size * self.state.horizontal_scale;
597        self.state.text_matrix =
598            Matrix::new(1.0, 0.0, 0.0, 1.0, tx, 0.0).multiply(self.state.text_matrix);
599    }
600
601    fn show_text(&mut self, bytes: &[u8]) -> crate::Result<()> {
602        if let Some(cid) = self.state.cid.clone() {
603            // Identity-H and friends: the string is a run of two-byte codes.
604            for pair in bytes.chunks_exact(2) {
605                let code = u16::from_be_bytes([pair[0], pair[1]]);
606                if let Some(glyph) = cid.font.glyph_by_id(cid.glyph_id(code)) {
607                    self.place_glyph(&glyph);
608                }
609                let advance = cid.advance(code) * self.state.font_size + self.state.char_spacing;
610                self.advance_text(advance * self.state.horizontal_scale);
611            }
612            return Ok(());
613        }
614        let Some(font) = self.state.font.clone() else {
615            return Ok(());
616        };
617        for &code in bytes {
618            if let Some(glyph) = font.glyph(code) {
619                self.place_glyph(&glyph);
620            }
621            let em = self
622                .state
623                .widths
624                .as_ref()
625                .map_or_else(|| font.advance(code), |widths| widths.advance(code));
626            let mut advance = em * self.state.font_size + self.state.char_spacing;
627            if code == b' ' {
628                advance += self.state.word_spacing;
629            }
630            self.advance_text(advance * self.state.horizontal_scale);
631        }
632        Ok(())
633    }
634
635    /// Fill one glyph outline at the current text position.
636    fn place_glyph(&mut self, glyph: &Glyph) {
637        if glyph.contours.is_empty() {
638            return;
639        }
640        let scale = Matrix::new(
641            self.state.font_size * self.state.horizontal_scale,
642            0.0,
643            0.0,
644            self.state.font_size,
645            0.0,
646            self.state.rise,
647        );
648        let transform = scale
649            .multiply(self.state.text_matrix)
650            .multiply(self.state.ctm);
651        let polygons: Vec<Vec<Point>> = glyph
652            .contours
653            .iter()
654            .map(|contour| {
655                contour
656                    .iter()
657                    .map(|point| transform.apply(*point))
658                    .collect()
659            })
660            .collect();
661        fill_polygons(
662            self.canvas,
663            &self.mask,
664            &polygons,
665            self.state.fill,
666            false,
667            1.0,
668        );
669    }
670
671    /// Move the text position by `advance` in unscaled text space.
672    fn advance_text(&mut self, advance: f64) {
673        self.state.text_matrix =
674            Matrix::new(1.0, 0.0, 0.0, 1.0, advance, 0.0).multiply(self.state.text_matrix);
675    }
676
677    fn draw_image(&mut self, name: &[u8]) -> crate::Result<()> {
678        let Some(resources) = self.resources.clone() else {
679            self.report.note(b"Do");
680            return Ok(());
681        };
682        let xobjects = match resolve(self.document, resources.get(b"XObject")) {
683            Ok(Object::Dictionary(xobjects)) => xobjects,
684            _ => {
685                self.report.note(b"Do");
686                return Ok(());
687            }
688        };
689        let entry = match xobjects.get(name) {
690            Some(entry) => entry.clone(),
691            None => {
692                self.report.note(b"Do");
693                return Ok(());
694            }
695        };
696        let object = resolve(self.document, Some(&entry))?;
697        let Object::Stream(stream) = object else {
698            self.report.note(b"Do");
699            return Ok(());
700        };
701        if !matches!(stream.dict().get(b"Subtype"), Some(Object::Name(name)) if name == b"Image") {
702            self.report.note(b"Do");
703            return Ok(());
704        }
705        match Image::from_stream(self.document, &stream) {
706            Ok(image) => {
707                image.paint(self.canvas, &self.mask, self.state.ctm);
708            }
709            // An image we cannot decode is reported, not fatal: the rest of the
710            // page still renders.
711            Err(_) => self.report.note(b"Do"),
712        }
713        Ok(())
714    }
715
716    fn load_font(&mut self, name: &[u8]) -> (Option<Font>, Option<SimpleWidths>, Option<CidFont>) {
717        let Some(loaded) = self.font_entry(name) else {
718            return (None, None, None);
719        };
720        if let Some(note) = loaded.note {
721            self.report.note(note.as_bytes());
722        }
723        (loaded.font, loaded.widths, loaded.cid)
724    }
725
726    /// Everything the walker needs from a font resource, with a note when the
727    /// family is one this renderer cannot draw.
728    fn font_entry(&mut self, name: &[u8]) -> Option<LoadedFont> {
729        let resources = self.resources.clone()?;
730        let fonts = match resolve(self.document, resources.get(b"Font")) {
731            Ok(Object::Dictionary(fonts)) => fonts,
732            _ => return None,
733        };
734        let entry = fonts.get(name)?.clone();
735        let font_object = resolve(self.document, Some(&entry)).ok()?;
736        let Object::Dictionary(font) = font_object else {
737            return None;
738        };
739        let subtype = match font.get(b"Subtype") {
740            Some(Object::Name(name)) => name.clone(),
741            _ => Vec::new(),
742        };
743        match subtype.as_slice() {
744            b"Type0" => return Some(self.cid_entry(&font)),
745            b"Type3" => {
746                return Some(LoadedFont {
747                    note: Some("font:Type3"),
748                    ..LoadedFont::default()
749                })
750            }
751            _ => {}
752        }
753        let encoding = self.encoding_for(&font);
754        let widths = self.widths_for(&font);
755        if let Some(descriptor) = font.get(b"FontDescriptor") {
756            let descriptor = resolve(self.document, Some(descriptor)).ok()?;
757            if let Object::Dictionary(descriptor) = descriptor {
758                for (key, kind) in [
759                    (&b"FontFile3"[..], "font:FontFile3"),
760                    (&b"FontFile"[..], "font:FontFile"),
761                ] {
762                    if descriptor.get(key).is_some() {
763                        return Some(LoadedFont {
764                            font: Some(Font::builtin(encoding)),
765                            widths,
766                            cid: None,
767                            note: Some(kind),
768                        });
769                    }
770                }
771                if let Some(font_file) = descriptor.get(b"FontFile2") {
772                    let data = match font_file {
773                        Object::Reference(id) => self.document.stream_data(*id).ok(),
774                        _ => None,
775                    };
776                    if let Some(data) = data {
777                        if let Some(font) = Font::true_type(encoding.clone(), data) {
778                            return Some(LoadedFont {
779                                font: Some(font),
780                                widths,
781                                cid: None,
782                                note: None,
783                            });
784                        }
785                    }
786                }
787            }
788        }
789        Some(LoadedFont {
790            font: Some(Font::builtin(encoding)),
791            widths,
792            cid: None,
793            note: None,
794        })
795    }
796
797    /// A Type 0 font: a descendant CIDFontType2 with an embedded program and an
798    /// identity CMap is drawable; anything else is reported by reason.
799    fn cid_entry(&mut self, font: &Dictionary) -> LoadedFont {
800        let identity = matches!(
801            resolve(self.document, font.get(b"Encoding")).ok(),
802            Some(Object::Name(name)) if name.starts_with(b"Identity")
803        );
804        if !identity {
805            return LoadedFont {
806                note: Some("font:Type0-cmap"),
807                ..LoadedFont::default()
808            };
809        }
810        let descendant = match resolve(self.document, font.get(b"DescendantFonts")).ok() {
811            Some(Object::Array(items)) => items
812                .first()
813                .and_then(|item| resolve(self.document, Some(item)).ok()),
814            _ => None,
815        };
816        let Some(Object::Dictionary(descendant)) = descendant else {
817            return LoadedFont {
818                note: Some("font:Type0-descendant"),
819                ..LoadedFont::default()
820            };
821        };
822        let subtype = match descendant.get(b"Subtype") {
823            Some(Object::Name(name)) => name.clone(),
824            _ => Vec::new(),
825        };
826        if subtype != b"CIDFontType2" {
827            // CIDFontType0 is CFF, whose charstrings this renderer cannot read.
828            return LoadedFont {
829                note: Some("font:CIDFontType0"),
830                ..LoadedFont::default()
831            };
832        }
833        let program = descendant
834            .get(b"FontDescriptor")
835            .and_then(|descriptor| resolve(self.document, Some(descriptor)).ok())
836            .and_then(|descriptor| match descriptor {
837                Object::Dictionary(descriptor) => {
838                    descriptor.get(b"FontFile2").and_then(|file| match file {
839                        Object::Reference(id) => self.document.stream_data(*id).ok(),
840                        _ => None,
841                    })
842                }
843                _ => None,
844            })
845            .and_then(|data| Font::true_type(Encoding::standard(), data));
846        let Some(program) = program else {
847            return LoadedFont {
848                note: Some("font:Type0-no-program"),
849                ..LoadedFont::default()
850            };
851        };
852        // Read the entry unresolved: resolving it would dereference the stream
853        // reference and lose the id the bytes are behind.
854        let to_gid = match descendant.get(b"CIDToGIDMap") {
855            Some(Object::Name(name)) if name == b"Identity" => CidToGid::Identity,
856            Some(Object::Reference(id)) => self
857                .document
858                .stream_data(*id)
859                .map(|data| {
860                    CidToGid::Table(
861                        data.chunks_exact(2)
862                            .map(|pair| u16::from_be_bytes([pair[0], pair[1]]))
863                            .collect(),
864                    )
865                })
866                .unwrap_or(CidToGid::Identity),
867            // Absent means identity.
868            _ => CidToGid::Identity,
869        };
870        LoadedFont {
871            font: None,
872            widths: None,
873            cid: Some(CidFont {
874                font: program,
875                to_gid,
876                widths: self.cid_widths(&descendant),
877            }),
878            note: None,
879        }
880    }
881
882    /// `/W` runs and `/DW` from a CID font dictionary (9.7.4.3).
883    fn cid_widths(&self, descendant: &Dictionary) -> CidWidths {
884        let mut ranges = vec![];
885        if let Ok(Object::Array(items)) = resolve(self.document, descendant.get(b"W")) {
886            let number = |item: Option<&Object>| {
887                item.and_then(|item| resolve(self.document, Some(item)).ok())
888                    .and_then(|item| item.as_real())
889            };
890            let mut index = 0;
891            while index + 1 < items.len() {
892                let Some(first) = number(items.get(index)) else {
893                    break;
894                };
895                match items.get(index + 1) {
896                    Some(Object::Array(list)) => {
897                        let widths = list
898                            .iter()
899                            .map(Object::as_real)
900                            .map(|w| w.unwrap_or(0.0))
901                            .collect();
902                        ranges.push((first as u32, widths));
903                        index += 2;
904                    }
905                    second => {
906                        let Some(last) = number(second) else { break };
907                        let Some(width) = number(items.get(index + 2)) else {
908                            break;
909                        };
910                        let count = (last - first).max(0.0) as usize + 1;
911                        ranges.push((first as u32, vec![width; count]));
912                        index += 3;
913                    }
914                }
915            }
916        }
917        let default = number_of(self.document, descendant.get(b"DW")).unwrap_or(1000.0);
918        CidWidths { ranges, default }
919    }
920
921    /// `/Widths` plus the descriptor's `/MissingWidth`, when the font states
922    /// them. A base-14 font usually does not, and then the glyph's own advance
923    /// is the best available answer.
924    fn widths_for(&self, font: &Dictionary) -> Option<SimpleWidths> {
925        let first = font.get(b"FirstChar").and_then(Object::as_integer)?;
926        let Object::Array(items) = resolve(self.document, font.get(b"Widths")).ok()? else {
927            return None;
928        };
929        let widths: Vec<f64> = items
930            .iter()
931            .map(|item| number_of(self.document, Some(item)).unwrap_or(0.0))
932            .collect();
933        let missing = font
934            .get(b"FontDescriptor")
935            .and_then(|descriptor| resolve(self.document, Some(descriptor)).ok())
936            .and_then(|descriptor| match descriptor {
937                Object::Dictionary(descriptor) => {
938                    number_of(self.document, descriptor.get(b"MissingWidth"))
939                }
940                _ => None,
941            })
942            .unwrap_or(0.0);
943        Some(SimpleWidths {
944            first,
945            widths,
946            missing,
947        })
948    }
949
950    fn encoding_for(&self, font: &Dictionary) -> Encoding {
951        let Some(encoding_object) = font.get(b"Encoding") else {
952            return Encoding::standard();
953        };
954        let Ok(encoding_object) = resolve(self.document, Some(encoding_object)) else {
955            return Encoding::standard();
956        };
957        let mut encoding = Encoding::from_object(Some(&encoding_object)).unwrap_or_default();
958        if let Object::Dictionary(dict) = &encoding_object {
959            if let Some(differences) = dict.get(b"Differences") {
960                if let Ok(Object::Array(items)) = resolve(self.document, Some(differences)) {
961                    let _ = encoding.apply_differences(&items);
962                }
963            }
964        }
965        encoding
966    }
967
968    fn apply_pending_clip(&mut self) {
969        let Some(even_odd) = self.pending_clip.take() else {
970            return;
971        };
972        let polylines = self.path.flatten(self.state.ctm);
973        let mask = clip_mask(
974            self.canvas.width(),
975            self.canvas.height(),
976            &polylines,
977            even_odd,
978        );
979        self.mask.intersect(&mask);
980    }
981}
982
983#[derive(Debug, Clone, Copy, PartialEq, Eq)]
984enum Paint {
985    Fill,
986    Stroke,
987    Both,
988}
989
990fn determinant_scale(ctm: Matrix) -> f64 {
991    let determinant = ctm.a * ctm.d - ctm.b * ctm.c;
992    determinant.abs().sqrt()
993}
994
995fn number(operands: &[Object], index: usize) -> f64 {
996    operands.get(index).and_then(Object::as_real).unwrap_or(0.0)
997}
998
999fn integer(operands: &[Object], index: usize) -> i64 {
1000    operands
1001        .get(index)
1002        .and_then(Object::as_integer)
1003        .unwrap_or(0)
1004}
1005
1006fn number_of(document: &Document, object: Option<&Object>) -> Option<f64> {
1007    resolve(document, object)
1008        .ok()
1009        .and_then(|object| object.as_real())
1010}
1011
1012fn matrix_operand(operands: &[Object]) -> Option<Matrix> {
1013    if operands.len() < 6 {
1014        return None;
1015    }
1016    Some(Matrix::new(
1017        number(operands, 0),
1018        number(operands, 1),
1019        number(operands, 2),
1020        number(operands, 3),
1021        number(operands, 4),
1022        number(operands, 5),
1023    ))
1024}
1025
1026/// The `pair`th point in the operands, if all of its numbers are there.
1027///
1028/// Callers name a *point*, not a number: `c` takes three of them at slots 0, 1
1029/// and 2, which are the numbers `(0, 1)`, `(2, 3)` and `(4, 5)`. Reading the
1030/// slot as a number index silently turned every curve's last control point into
1031/// its end point, which is what a wrong index looks like on the page.
1032fn point_operand(operands: &[Object], pair: usize) -> Option<Point> {
1033    let start = pair * 2;
1034    if operands.len() < start + 2 {
1035        return None;
1036    }
1037    Some(Point::new(
1038        number(operands, start),
1039        number(operands, start + 1),
1040    ))
1041}
1042
1043fn dash_operand(operands: &[Object]) -> Dash {
1044    let pattern = match operands.first() {
1045        Some(Object::Array(items)) => items
1046            .iter()
1047            .filter_map(Object::as_real)
1048            .collect::<Vec<f64>>(),
1049        _ => Vec::new(),
1050    };
1051    let phase = number(operands, 1);
1052    Dash { pattern, phase }
1053}
1054
1055/// Skip inline image data (`BI` … `EI`), which cannot be tokenised.
1056fn skip_inline_image(parser: &mut Parser<'_>) -> crate::Result<()> {
1057    let start = parser.raw_position();
1058    let content = parser.content();
1059    let found = content
1060        .get(start..)
1061        .and_then(|rest| find_operator(rest, b"EI"))
1062        .ok_or_else(|| crate::Error::malformed("inline image without a closing EI"))?;
1063    parser.seek(start + found + 2);
1064    Ok(())
1065}
1066
1067fn find_operator(haystack: &[u8], needle: &[u8]) -> Option<usize> {
1068    let mut index = 0;
1069    while index + needle.len() <= haystack.len() {
1070        if &haystack[index..index + needle.len()] == needle {
1071            let delimiter = |byte: u8| is_whitespace(byte) || is_delimiter(byte);
1072            let before_ok = index == 0 || delimiter(haystack[index - 1]);
1073            let after = index + needle.len();
1074            let after_ok = after >= haystack.len() || delimiter(haystack[after]);
1075            if before_ok && after_ok {
1076                return Some(index);
1077            }
1078        }
1079        index += 1;
1080    }
1081    None
1082}
1083
1084#[cfg(test)]
1085mod tests {
1086    use super::{dash_operand, Report};
1087    use pdf2::Object;
1088
1089    #[test]
1090    fn reports_collect_operator_counts_in_order() {
1091        let mut report = Report::default();
1092        report.note(b"Tj");
1093        report.note(b"Tj");
1094        report.note(b"Do");
1095        assert_eq!(report.unsupported_total(), 3);
1096        assert_eq!(report.unsupported.get("Tj"), Some(&2));
1097        assert_eq!(report.to_string(), "Do×1, Tj×2");
1098    }
1099
1100    #[test]
1101    fn dash_operands_default_to_solid() {
1102        assert!(dash_operand(&[]).is_solid());
1103        let dash = dash_operand(&[
1104            Object::array([Object::Integer(4), Object::Integer(2)]),
1105            Object::Integer(1),
1106        ]);
1107        assert_eq!(dash.pattern, vec![4.0, 2.0]);
1108        assert_eq!(dash.phase, 1.0);
1109    }
1110}