1use 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#[derive(Debug, Clone, PartialEq)]
24pub struct RenderOptions {
25 pub scale: f64,
27 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#[derive(Debug, Clone, Default, PartialEq)]
42pub struct Report {
43 pub unsupported: BTreeMap<String, usize>,
46}
47
48impl Report {
49 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#[derive(Debug, Clone)]
79pub struct RenderedPage {
80 pub canvas: Canvas,
82 pub report: Report,
84}
85
86pub 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#[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#[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#[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 ranges: Vec<(u32, Vec<f64>)>,
148 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
171pub 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 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 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#[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 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 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 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 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 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 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 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 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 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 _ => 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 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 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
1026fn 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
1055fn 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}