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;
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
96pub fn render_page(
98 document: &Document,
99 page: &Page,
100 options: &RenderOptions,
101) -> crate::Result<RenderedPage> {
102 let scale = if options.scale.is_finite() && options.scale > 0.0 {
103 options.scale
104 } else {
105 1.0
106 };
107 let media = page
108 .media_box
109 .unwrap_or(pdf2::Rect::new(0.0, 0.0, 612.0, 792.0));
110 let rotate = page.rotate.rem_euclid(360);
113 let landscape = rotate == 90 || rotate == 270;
114 let (width_points, height_points) = if landscape {
115 (media.height(), media.width())
116 } else {
117 (media.width(), media.height())
118 };
119 let width = ((width_points * scale).round().max(1.0)) as u32;
120 let height = ((height_points * scale).round().max(1.0)) as u32;
121 let mut canvas = Canvas::new(width, height, options.background);
122 let mut report = Report::default();
123
124 let base = match rotate {
128 90 => Matrix::new(0.0, scale, scale, 0.0, -media.y0 * scale, -media.x0 * scale),
129 180 => Matrix::new(-scale, 0.0, 0.0, scale, media.x1 * scale, -media.y0 * scale),
130 270 => Matrix::new(0.0, scale, -scale, 0.0, media.y1 * scale, -media.x0 * scale),
131 _ => Matrix::new(scale, 0.0, 0.0, -scale, -media.x0 * scale, media.y1 * scale),
132 };
133
134 let content = document.page_content(page)?;
135 let mut walker = Walker {
136 canvas: &mut canvas,
137 report: &mut report,
138 document,
139 resources: page.resources.clone(),
140 state: State::new(base),
141 stack: Vec::new(),
142 path: Path::new(),
143 pending_clip: None,
144 mask: ClipMask::all(width, height),
145 };
146 walker.run(&content)?;
147 Ok(RenderedPage { canvas, report })
148}
149
150#[derive(Debug, Clone)]
152struct State {
153 ctm: Matrix,
154 line_width: f64,
155 cap: Cap,
156 join: Join,
157 dash: Dash,
158 fill: Color,
159 stroke: Color,
160 font: Option<Font>,
161 font_size: f64,
162 miter_limit: f64,
163 char_spacing: f64,
164 word_spacing: f64,
165 horizontal_scale: f64,
166 leading: f64,
167 rise: f64,
168 text_matrix: Matrix,
169 line_matrix: Matrix,
170}
171
172impl State {
173 fn new(ctm: Matrix) -> Self {
174 Self {
175 ctm,
176 line_width: 1.0,
177 cap: Cap::Butt,
178 join: Join::Miter,
179 dash: Dash::solid(),
180 fill: Color::BLACK,
181 stroke: Color::BLACK,
182 font: None,
183 font_size: 0.0,
184 miter_limit: 10.0,
185 char_spacing: 0.0,
186 word_spacing: 0.0,
187 horizontal_scale: 1.0,
188 leading: 0.0,
189 rise: 0.0,
190 text_matrix: Matrix::IDENTITY,
191 line_matrix: Matrix::IDENTITY,
192 }
193 }
194}
195
196struct Walker<'a> {
197 canvas: &'a mut Canvas,
198 report: &'a mut Report,
199 document: &'a Document,
200 resources: Option<Dictionary>,
201 state: State,
202 stack: Vec<(State, ClipMask)>,
203 path: Path,
204 pending_clip: Option<bool>,
205 mask: ClipMask,
206}
207
208impl Walker<'_> {
209 fn run(&mut self, content: &[u8]) -> crate::Result<()> {
210 let mut parser = Parser::new(content);
211 let mut operands: Vec<Object> = Vec::new();
212 loop {
213 match parser.peek_token()? {
214 Token::Eof => break,
215 Token::Keyword(_) => {
216 let operator = match parser.next_token()? {
217 Token::Keyword(operator) => operator,
218 _ => return Err(crate::Error::malformed("content-stream operator")),
219 };
220 self.execute(&operator, &mut operands, &mut parser)?;
221 operands.clear();
222 }
223 _ => {
224 operands.push(parser.parse_object()?);
225 }
226 }
227 }
228 Ok(())
229 }
230
231 fn execute(
232 &mut self,
233 operator: &[u8],
234 operands: &mut [Object],
235 parser: &mut Parser<'_>,
236 ) -> crate::Result<()> {
237 match operator {
238 b"q" => {
239 self.stack.push((self.state.clone(), self.mask.clone()));
240 }
241 b"Q" => {
242 if let Some((state, mask)) = self.stack.pop() {
243 self.state = state;
244 self.mask = mask;
245 }
246 }
247 b"cm" => {
248 if let Some(matrix) = matrix_operand(operands) {
249 self.state.ctm = matrix.multiply(self.state.ctm);
250 }
251 }
252 b"w" => self.state.line_width = number(operands, 0),
253 b"J" => {
254 self.state.cap = match integer(operands, 0) {
255 1 => Cap::Round,
256 2 => Cap::Square,
257 _ => Cap::Butt,
258 }
259 }
260 b"j" => {
261 self.state.join = match integer(operands, 0) {
262 1 => Join::Round,
263 2 => Join::Bevel,
264 _ => Join::Miter,
265 }
266 }
267 b"M" => self.state.miter_limit = number(operands, 0).max(1.0),
268 b"d" => self.state.dash = dash_operand(operands),
269 b"m" => {
270 if let Some(point) = point_operand(operands, 0) {
271 self.path.move_to(point);
272 }
273 }
274 b"l" => {
275 if let Some(point) = point_operand(operands, 0) {
276 self.path.line_to(point);
277 }
278 }
279 b"c" => {
280 if let (Some(c1), Some(c2), Some(to)) = (
281 point_operand(operands, 0),
282 point_operand(operands, 1),
283 point_operand(operands, 2),
284 ) {
285 self.path.curve_to(c1, c2, to);
286 }
287 }
288 b"v" | b"y" => {
289 if let Some(to) = point_operand(operands, 1) {
292 self.path.line_to(to);
293 }
294 }
295 b"h" => self.path.close(),
296 b"re" => {
297 let x = number(operands, 0);
298 let y = number(operands, 1);
299 let width = number(operands, 2);
300 let height = number(operands, 3);
301 self.path.add_rect(x, y, width, height);
302 }
303 b"S" => self.paint(Paint::Stroke, false)?,
304 b"s" => {
305 self.path.close();
306 self.paint(Paint::Stroke, false)?;
307 }
308 b"f" | b"F" => self.paint(Paint::Fill, false)?,
309 b"f*" => self.paint(Paint::Fill, true)?,
310 b"B" => self.paint(Paint::Both, false)?,
311 b"B*" => self.paint(Paint::Both, true)?,
312 b"b" => {
313 self.path.close();
314 self.paint(Paint::Both, false)?;
315 }
316 b"b*" => {
317 self.path.close();
318 self.paint(Paint::Both, true)?;
319 }
320 b"W" => self.pending_clip = Some(false),
321 b"W*" => self.pending_clip = Some(true),
322 b"n" => {
323 self.apply_pending_clip();
324 self.path = Path::new();
325 }
326 b"g" => {
327 self.state.fill = Color::rgb(
328 number(operands, 0),
329 number(operands, 0),
330 number(operands, 0),
331 )
332 }
333 b"G" => {
334 self.state.stroke = Color::rgb(
335 number(operands, 0),
336 number(operands, 0),
337 number(operands, 0),
338 )
339 }
340 b"rg" => {
341 self.state.fill = Color::rgb(
342 number(operands, 0),
343 number(operands, 1),
344 number(operands, 2),
345 );
346 }
347 b"RG" => {
348 self.state.stroke = Color::rgb(
349 number(operands, 0),
350 number(operands, 1),
351 number(operands, 2),
352 );
353 }
354 b"k" => {
355 self.state.fill = Color::from_cmyk(
356 number(operands, 0),
357 number(operands, 1),
358 number(operands, 2),
359 number(operands, 3),
360 );
361 }
362 b"K" => {
363 self.state.stroke = Color::from_cmyk(
364 number(operands, 0),
365 number(operands, 1),
366 number(operands, 2),
367 number(operands, 3),
368 );
369 }
370 b"BT" => {
371 self.state.text_matrix = Matrix::IDENTITY;
372 self.state.line_matrix = Matrix::IDENTITY;
373 }
374 b"ET" => {}
375 b"Tf" => {
376 let name = match operands.first() {
377 Some(Object::Name(name)) => name.clone(),
378 _ => return Err(crate::Error::malformed("/Tf needs a font name")),
379 };
380 self.state.font_size = number(operands, 1);
381 self.state.font = self.load_font(&name);
382 }
383 b"Td" | b"TD" => {
384 let tx = number(operands, 0);
385 let ty = number(operands, 1);
386 self.state.line_matrix =
387 Matrix::new(1.0, 0.0, 0.0, 1.0, tx, ty).multiply(self.state.line_matrix);
388 self.state.text_matrix = self.state.line_matrix;
389 if operator == b"TD" {
390 self.state.leading = -ty;
391 }
392 }
393 b"T*" => {
394 self.state.line_matrix = Matrix::new(1.0, 0.0, 0.0, 1.0, 0.0, -self.state.leading)
395 .multiply(self.state.line_matrix);
396 self.state.text_matrix = self.state.line_matrix;
397 }
398 b"Tm" => {
399 if let Some(matrix) = matrix_operand(operands) {
400 self.state.line_matrix = matrix;
401 self.state.text_matrix = matrix;
402 }
403 }
404 b"TL" => self.state.leading = number(operands, 0),
405 b"Tc" => self.state.char_spacing = number(operands, 0),
406 b"Tw" => self.state.word_spacing = number(operands, 0),
407 b"Tz" => self.state.horizontal_scale = number(operands, 0) / 100.0,
408 b"Ts" => self.state.rise = number(operands, 0),
409 b"Tj" => {
410 if let Some(Object::String(string)) = operands.first() {
411 let bytes = string.as_bytes().to_vec();
412 self.show_text(&bytes)?;
413 }
414 }
415 b"'" => {
416 self.state.line_matrix = Matrix::new(1.0, 0.0, 0.0, 1.0, 0.0, -self.state.leading)
417 .multiply(self.state.line_matrix);
418 self.state.text_matrix = self.state.line_matrix;
419 if let Some(Object::String(string)) = operands.first() {
420 let bytes = string.as_bytes().to_vec();
421 self.show_text(&bytes)?;
422 }
423 }
424 b"\"" => {
425 self.state.word_spacing = number(operands, 0);
426 self.state.char_spacing = number(operands, 1);
427 self.state.line_matrix = Matrix::new(1.0, 0.0, 0.0, 1.0, 0.0, -self.state.leading)
428 .multiply(self.state.line_matrix);
429 self.state.text_matrix = self.state.line_matrix;
430 if let Some(Object::String(string)) = operands.get(2) {
431 let bytes = string.as_bytes().to_vec();
432 self.show_text(&bytes)?;
433 }
434 }
435 b"TJ" => {
436 if let Some(Object::Array(items)) = operands.first() {
437 for item in items {
438 match item {
439 Object::String(string) => {
440 let bytes = string.as_bytes().to_vec();
441 self.show_text(&bytes)?;
442 }
443 Object::Integer(adjustment) => {
444 self.adjust_text(*adjustment as f64);
445 }
446 Object::Real(adjustment) => self.adjust_text(*adjustment),
447 _ => {}
448 }
449 }
450 }
451 }
452 b"Do" => {
453 if let Some(Object::Name(name)) = operands.first() {
454 let name = name.clone();
455 self.draw_image(&name)?;
456 }
457 }
458 b"BI" => {
459 skip_inline_image(parser)?;
460 self.report.note(operator);
461 }
462 _ => self.report.note(operator),
463 }
464 Ok(())
465 }
466
467 fn paint(&mut self, what: Paint, even_odd: bool) -> crate::Result<()> {
468 self.apply_pending_clip();
469 let ctm = self.state.ctm;
470 let scale = determinant_scale(ctm);
471 let polylines = self.path.flatten(ctm);
472 let painted = match what {
473 Paint::Fill | Paint::Both => true,
474 Paint::Stroke => false,
475 };
476 if painted && !polylines.is_empty() {
477 fill_polygons(
478 self.canvas,
479 &self.mask,
480 &polylines,
481 self.state.fill,
482 even_odd,
483 1.0,
484 );
485 }
486 if matches!(what, Paint::Stroke | Paint::Both) {
487 let mut stroked: Vec<Vec<Point>> = Vec::new();
488 for polyline in &polylines {
489 stroked.extend(dash_polyline(polyline, &self.state.dash, scale));
490 }
491 let outline = stroke_outline(
492 &stroked,
493 self.state.line_width * scale,
494 self.state.cap,
495 self.state.join,
496 self.state.miter_limit,
497 );
498 if !outline.is_empty() {
499 fill_polygons(
500 self.canvas,
501 &self.mask,
502 &outline,
503 self.state.stroke,
504 false,
505 1.0,
506 );
507 }
508 }
509 self.path = Path::new();
510 Ok(())
511 }
512
513 fn adjust_text(&mut self, adjustment: f64) {
514 let tx = -adjustment / 1000.0 * self.state.font_size * self.state.horizontal_scale;
515 self.state.text_matrix =
516 Matrix::new(1.0, 0.0, 0.0, 1.0, tx, 0.0).multiply(self.state.text_matrix);
517 }
518
519 fn show_text(&mut self, bytes: &[u8]) -> crate::Result<()> {
520 let Some(font) = self.state.font.clone() else {
521 return Ok(());
522 };
523 for &code in bytes {
524 if let Some(glyph) = font.glyph(code) {
525 if !glyph.contours.is_empty() {
526 let scale = Matrix::new(
527 self.state.font_size * self.state.horizontal_scale,
528 0.0,
529 0.0,
530 self.state.font_size,
531 0.0,
532 self.state.rise,
533 );
534 let transform = scale
535 .multiply(self.state.text_matrix)
536 .multiply(self.state.ctm);
537 let polygons: Vec<Vec<Point>> = glyph
538 .contours
539 .iter()
540 .map(|contour| {
541 contour
542 .iter()
543 .map(|point| transform.apply(*point))
544 .collect()
545 })
546 .collect();
547 fill_polygons(
548 self.canvas,
549 &self.mask,
550 &polygons,
551 self.state.fill,
552 false,
553 1.0,
554 );
555 }
556 }
557 let mut advance = font.advance(code) * self.state.font_size + self.state.char_spacing;
558 if code == b' ' {
559 advance += self.state.word_spacing;
560 }
561 advance *= self.state.horizontal_scale;
562 self.state.text_matrix =
563 Matrix::new(1.0, 0.0, 0.0, 1.0, advance, 0.0).multiply(self.state.text_matrix);
564 }
565 Ok(())
566 }
567
568 fn draw_image(&mut self, name: &[u8]) -> crate::Result<()> {
569 let Some(resources) = self.resources.clone() else {
570 self.report.note(b"Do");
571 return Ok(());
572 };
573 let xobjects = match resolve(self.document, resources.get(b"XObject")) {
574 Ok(Object::Dictionary(xobjects)) => xobjects,
575 _ => {
576 self.report.note(b"Do");
577 return Ok(());
578 }
579 };
580 let entry = match xobjects.get(name) {
581 Some(entry) => entry.clone(),
582 None => {
583 self.report.note(b"Do");
584 return Ok(());
585 }
586 };
587 let object = resolve(self.document, Some(&entry))?;
588 let Object::Stream(stream) = object else {
589 self.report.note(b"Do");
590 return Ok(());
591 };
592 if !matches!(stream.dict().get(b"Subtype"), Some(Object::Name(name)) if name == b"Image") {
593 self.report.note(b"Do");
594 return Ok(());
595 }
596 match Image::from_stream(self.document, &stream) {
597 Ok(image) => {
598 image.paint(self.canvas, &self.mask, self.state.ctm);
599 }
600 Err(_) => self.report.note(b"Do"),
603 }
604 Ok(())
605 }
606
607 fn load_font(&mut self, name: &[u8]) -> Option<Font> {
608 let resources = self.resources.clone()?;
609 let fonts = match resolve(self.document, resources.get(b"Font")) {
610 Ok(Object::Dictionary(fonts)) => fonts,
611 _ => return None,
612 };
613 let entry = fonts.get(name)?.clone();
614 let font_object = resolve(self.document, Some(&entry)).ok()?;
615 let Object::Dictionary(font) = font_object else {
616 return None;
617 };
618 let encoding = self.encoding_for(&font);
619 if let Some(descriptor) = font.get(b"FontDescriptor") {
620 let descriptor = resolve(self.document, Some(descriptor)).ok()?;
621 if let Object::Dictionary(descriptor) = descriptor {
622 if let Some(font_file) = descriptor.get(b"FontFile2") {
623 let data = match font_file {
624 Object::Reference(id) => self.document.stream_data(*id).ok(),
625 _ => None,
626 };
627 if let Some(data) = data {
628 if let Some(font) = Font::true_type(encoding.clone(), data) {
629 return Some(font);
630 }
631 }
632 }
633 }
634 }
635 Some(Font::builtin(encoding))
636 }
637
638 fn encoding_for(&self, font: &Dictionary) -> Encoding {
639 let Some(encoding_object) = font.get(b"Encoding") else {
640 return Encoding::standard();
641 };
642 let Ok(encoding_object) = resolve(self.document, Some(encoding_object)) else {
643 return Encoding::standard();
644 };
645 let mut encoding = Encoding::from_object(Some(&encoding_object)).unwrap_or_default();
646 if let Object::Dictionary(dict) = &encoding_object {
647 if let Some(differences) = dict.get(b"Differences") {
648 if let Ok(Object::Array(items)) = resolve(self.document, Some(differences)) {
649 let _ = encoding.apply_differences(&items);
650 }
651 }
652 }
653 encoding
654 }
655
656 fn apply_pending_clip(&mut self) {
657 let Some(even_odd) = self.pending_clip.take() else {
658 return;
659 };
660 let polylines = self.path.flatten(self.state.ctm);
661 let mask = clip_mask(
662 self.canvas.width(),
663 self.canvas.height(),
664 &polylines,
665 even_odd,
666 );
667 self.mask.intersect(&mask);
668 }
669}
670
671#[derive(Debug, Clone, Copy, PartialEq, Eq)]
672enum Paint {
673 Fill,
674 Stroke,
675 Both,
676}
677
678fn determinant_scale(ctm: Matrix) -> f64 {
679 let determinant = ctm.a * ctm.d - ctm.b * ctm.c;
680 determinant.abs().sqrt()
681}
682
683fn number(operands: &[Object], index: usize) -> f64 {
684 operands.get(index).and_then(Object::as_real).unwrap_or(0.0)
685}
686
687fn integer(operands: &[Object], index: usize) -> i64 {
688 operands
689 .get(index)
690 .and_then(Object::as_integer)
691 .unwrap_or(0)
692}
693
694fn matrix_operand(operands: &[Object]) -> Option<Matrix> {
695 if operands.len() < 6 {
696 return None;
697 }
698 Some(Matrix::new(
699 number(operands, 0),
700 number(operands, 1),
701 number(operands, 2),
702 number(operands, 3),
703 number(operands, 4),
704 number(operands, 5),
705 ))
706}
707
708fn point_operand(operands: &[Object], pair: usize) -> Option<Point> {
715 let start = pair * 2;
716 if operands.len() < start + 2 {
717 return None;
718 }
719 Some(Point::new(
720 number(operands, start),
721 number(operands, start + 1),
722 ))
723}
724
725fn dash_operand(operands: &[Object]) -> Dash {
726 let pattern = match operands.first() {
727 Some(Object::Array(items)) => items
728 .iter()
729 .filter_map(Object::as_real)
730 .collect::<Vec<f64>>(),
731 _ => Vec::new(),
732 };
733 let phase = number(operands, 1);
734 Dash { pattern, phase }
735}
736
737fn skip_inline_image(parser: &mut Parser<'_>) -> crate::Result<()> {
739 let start = parser.raw_position();
740 let content = parser.content();
741 let found = content
742 .get(start..)
743 .and_then(|rest| find_operator(rest, b"EI"))
744 .ok_or_else(|| crate::Error::malformed("inline image without a closing EI"))?;
745 parser.seek(start + found + 2);
746 Ok(())
747}
748
749fn find_operator(haystack: &[u8], needle: &[u8]) -> Option<usize> {
750 let mut index = 0;
751 while index + needle.len() <= haystack.len() {
752 if &haystack[index..index + needle.len()] == needle {
753 let delimiter = |byte: u8| is_whitespace(byte) || is_delimiter(byte);
754 let before_ok = index == 0 || delimiter(haystack[index - 1]);
755 let after = index + needle.len();
756 let after_ok = after >= haystack.len() || delimiter(haystack[after]);
757 if before_ok && after_ok {
758 return Some(index);
759 }
760 }
761 index += 1;
762 }
763 None
764}
765
766#[cfg(test)]
767mod tests {
768 use super::{dash_operand, Report};
769 use pdf2::Object;
770
771 #[test]
772 fn reports_collect_operator_counts_in_order() {
773 let mut report = Report::default();
774 report.note(b"Tj");
775 report.note(b"Tj");
776 report.note(b"Do");
777 assert_eq!(report.unsupported_total(), 3);
778 assert_eq!(report.unsupported.get("Tj"), Some(&2));
779 assert_eq!(report.to_string(), "Do×1, Tj×2");
780 }
781
782 #[test]
783 fn dash_operands_default_to_solid() {
784 assert!(dash_operand(&[]).is_solid());
785 let dash = dash_operand(&[
786 Object::array([Object::Integer(4), Object::Integer(2)]),
787 Object::Integer(1),
788 ]);
789 assert_eq!(dash.pattern, vec![4.0, 2.0]);
790 assert_eq!(dash.phase, 1.0);
791 }
792}