Renderer.cpp 33 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063
  1. /*
  2. * Copyright (c) 2021-2022, Matthew Olsson <mattco@serenityos.org>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #include <AK/Utf8View.h>
  7. #include <LibPDF/CommonNames.h>
  8. #include <LibPDF/Fonts/PDFFont.h>
  9. #include <LibPDF/Interpolation.h>
  10. #include <LibPDF/Renderer.h>
  11. #define RENDERER_HANDLER(name) \
  12. PDFErrorOr<void> Renderer::handle_##name([[maybe_unused]] ReadonlySpan<Value> args, [[maybe_unused]] Optional<NonnullRefPtr<DictObject>> extra_resources)
  13. #define RENDERER_TODO(name) \
  14. RENDERER_HANDLER(name) \
  15. { \
  16. return Error(Error::Type::RenderingUnsupported, "draw operation: " #name); \
  17. }
  18. namespace PDF {
  19. // Use a RAII object to restore the graphics state, to make sure it gets restored even if
  20. // a TRY(handle_operator()) causes us to exit the operators loop early.
  21. // Explicitly resize stack size at the end so that if the recursive document contains
  22. // `q q unsupportedop Q Q`, we undo the stack pushes from the inner `q q` even if
  23. // `unsupportedop` terminates processing the inner instruction stream before `Q Q`
  24. // would normally pop state.
  25. class Renderer::ScopedState {
  26. public:
  27. ScopedState(Renderer& renderer)
  28. : m_renderer(renderer)
  29. , m_starting_stack_depth(m_renderer.m_graphics_state_stack.size())
  30. {
  31. MUST(m_renderer.handle_save_state({}));
  32. }
  33. ~ScopedState()
  34. {
  35. m_renderer.m_graphics_state_stack.shrink(m_starting_stack_depth);
  36. }
  37. private:
  38. Renderer& m_renderer;
  39. size_t m_starting_stack_depth;
  40. };
  41. PDFErrorsOr<void> Renderer::render(Document& document, Page const& page, RefPtr<Gfx::Bitmap> bitmap, RenderingPreferences rendering_preferences)
  42. {
  43. return Renderer(document, page, bitmap, rendering_preferences).render();
  44. }
  45. static void rect_path(Gfx::Path& path, float x, float y, float width, float height)
  46. {
  47. path.move_to({ x, y });
  48. path.line_to({ x + width, y });
  49. path.line_to({ x + width, y + height });
  50. path.line_to({ x, y + height });
  51. path.close();
  52. }
  53. template<typename T>
  54. static void rect_path(Gfx::Path& path, Gfx::Rect<T> rect)
  55. {
  56. return rect_path(path, rect.x(), rect.y(), rect.width(), rect.height());
  57. }
  58. template<typename T>
  59. static Gfx::Path rect_path(Gfx::Rect<T> const& rect)
  60. {
  61. Gfx::Path path;
  62. rect_path(path, rect);
  63. return path;
  64. }
  65. Renderer::Renderer(RefPtr<Document> document, Page const& page, RefPtr<Gfx::Bitmap> bitmap, RenderingPreferences rendering_preferences)
  66. : m_document(document)
  67. , m_bitmap(bitmap)
  68. , m_page(page)
  69. , m_painter(*bitmap)
  70. , m_anti_aliasing_painter(m_painter)
  71. , m_rendering_preferences(rendering_preferences)
  72. {
  73. auto media_box = m_page.media_box;
  74. Gfx::AffineTransform userspace_matrix;
  75. userspace_matrix.translate(media_box.lower_left_x, media_box.lower_left_y);
  76. float width = media_box.width();
  77. float height = media_box.height();
  78. float scale_x = static_cast<float>(bitmap->width()) / width;
  79. float scale_y = static_cast<float>(bitmap->height()) / height;
  80. userspace_matrix.scale(scale_x, scale_y);
  81. // PDF user-space coordinate y axis increases from bottom to top, so we have to
  82. // insert a horizontal reflection about the vertical midpoint into our transformation
  83. // matrix
  84. static Gfx::AffineTransform horizontal_reflection_matrix = { 1, 0, 0, -1, 0, 0 };
  85. userspace_matrix.multiply(horizontal_reflection_matrix);
  86. userspace_matrix.translate(0.0f, -height);
  87. auto initial_clipping_path = rect_path(userspace_matrix.map(Gfx::FloatRect(0, 0, width, height)));
  88. m_graphics_state_stack.append(GraphicsState { userspace_matrix, { initial_clipping_path, initial_clipping_path } });
  89. m_bitmap->fill(Gfx::Color::NamedColor::White);
  90. }
  91. PDFErrorsOr<void> Renderer::render()
  92. {
  93. auto operators = TRY(Parser::parse_operators(m_document, TRY(m_page.page_contents(*m_document))));
  94. Errors errors;
  95. for (auto& op : operators) {
  96. auto maybe_error = handle_operator(op);
  97. if (maybe_error.is_error()) {
  98. errors.add_error(maybe_error.release_error());
  99. }
  100. }
  101. if (!errors.errors().is_empty())
  102. return errors;
  103. return {};
  104. }
  105. PDFErrorOr<void> Renderer::handle_operator(Operator const& op, Optional<NonnullRefPtr<DictObject>> extra_resources)
  106. {
  107. switch (op.type()) {
  108. #define V(name, snake_name, symbol) \
  109. case OperatorType::name: \
  110. TRY(handle_##snake_name(op.arguments(), extra_resources)); \
  111. break;
  112. ENUMERATE_OPERATORS(V)
  113. #undef V
  114. case OperatorType::TextNextLineShowString:
  115. TRY(handle_text_next_line_show_string(op.arguments()));
  116. break;
  117. case OperatorType::TextNextLineShowStringSetSpacing:
  118. TRY(handle_text_next_line_show_string_set_spacing(op.arguments()));
  119. break;
  120. }
  121. return {};
  122. }
  123. RENDERER_HANDLER(save_state)
  124. {
  125. m_graphics_state_stack.append(state());
  126. return {};
  127. }
  128. RENDERER_HANDLER(restore_state)
  129. {
  130. m_graphics_state_stack.take_last();
  131. return {};
  132. }
  133. RENDERER_HANDLER(concatenate_matrix)
  134. {
  135. Gfx::AffineTransform new_transform(
  136. args[0].to_float(),
  137. args[1].to_float(),
  138. args[2].to_float(),
  139. args[3].to_float(),
  140. args[4].to_float(),
  141. args[5].to_float());
  142. state().ctm.multiply(new_transform);
  143. m_text_rendering_matrix_is_dirty = true;
  144. return {};
  145. }
  146. RENDERER_HANDLER(set_line_width)
  147. {
  148. state().line_width = args[0].to_float();
  149. return {};
  150. }
  151. RENDERER_HANDLER(set_line_cap)
  152. {
  153. state().line_cap_style = static_cast<LineCapStyle>(args[0].get<int>());
  154. return {};
  155. }
  156. RENDERER_HANDLER(set_line_join)
  157. {
  158. state().line_join_style = static_cast<LineJoinStyle>(args[0].get<int>());
  159. return {};
  160. }
  161. RENDERER_HANDLER(set_miter_limit)
  162. {
  163. state().miter_limit = args[0].to_float();
  164. return {};
  165. }
  166. RENDERER_HANDLER(set_dash_pattern)
  167. {
  168. auto dash_array = MUST(m_document->resolve_to<ArrayObject>(args[0]));
  169. Vector<int> pattern;
  170. for (auto& element : *dash_array)
  171. pattern.append(element.to_int());
  172. state().line_dash_pattern = LineDashPattern { pattern, args[1].to_int() };
  173. return {};
  174. }
  175. RENDERER_HANDLER(set_color_rendering_intent)
  176. {
  177. state().color_rendering_intent = MUST(m_document->resolve_to<NameObject>(args[0]))->name();
  178. return {};
  179. }
  180. RENDERER_HANDLER(set_flatness_tolerance)
  181. {
  182. state().flatness_tolerance = args[0].to_float();
  183. return {};
  184. }
  185. RENDERER_HANDLER(set_graphics_state_from_dict)
  186. {
  187. auto resources = extra_resources.value_or(m_page.resources);
  188. auto dict_name = MUST(m_document->resolve_to<NameObject>(args[0]))->name();
  189. auto ext_gstate_dict = MUST(resources->get_dict(m_document, CommonNames::ExtGState));
  190. auto target_dict = MUST(ext_gstate_dict->get_dict(m_document, dict_name));
  191. TRY(set_graphics_state_from_dict(target_dict));
  192. return {};
  193. }
  194. RENDERER_HANDLER(path_move)
  195. {
  196. m_current_path.move_to(map(args[0].to_float(), args[1].to_float()));
  197. return {};
  198. }
  199. RENDERER_HANDLER(path_line)
  200. {
  201. VERIFY(!m_current_path.segments().is_empty());
  202. m_current_path.line_to(map(args[0].to_float(), args[1].to_float()));
  203. return {};
  204. }
  205. RENDERER_HANDLER(path_cubic_bezier_curve)
  206. {
  207. VERIFY(args.size() == 6);
  208. m_current_path.cubic_bezier_curve_to(
  209. map(args[0].to_float(), args[1].to_float()),
  210. map(args[2].to_float(), args[3].to_float()),
  211. map(args[4].to_float(), args[5].to_float()));
  212. return {};
  213. }
  214. RENDERER_HANDLER(path_cubic_bezier_curve_no_first_control)
  215. {
  216. VERIFY(args.size() == 4);
  217. VERIFY(!m_current_path.segments().is_empty());
  218. auto current_point = (*m_current_path.segments().rbegin())->point();
  219. m_current_path.cubic_bezier_curve_to(
  220. current_point,
  221. map(args[0].to_float(), args[1].to_float()),
  222. map(args[2].to_float(), args[3].to_float()));
  223. return {};
  224. }
  225. RENDERER_HANDLER(path_cubic_bezier_curve_no_second_control)
  226. {
  227. VERIFY(args.size() == 4);
  228. VERIFY(!m_current_path.segments().is_empty());
  229. auto first_control_point = map(args[0].to_float(), args[1].to_float());
  230. auto second_control_point = map(args[2].to_float(), args[3].to_float());
  231. m_current_path.cubic_bezier_curve_to(
  232. first_control_point,
  233. second_control_point,
  234. second_control_point);
  235. return {};
  236. }
  237. RENDERER_HANDLER(path_close)
  238. {
  239. m_current_path.close();
  240. return {};
  241. }
  242. RENDERER_HANDLER(path_append_rect)
  243. {
  244. auto rect = Gfx::FloatRect(args[0].to_float(), args[1].to_float(), args[2].to_float(), args[3].to_float());
  245. rect_path(m_current_path, map(rect));
  246. return {};
  247. }
  248. ///
  249. // Path painting operations
  250. ///
  251. void Renderer::begin_path_paint()
  252. {
  253. auto bounding_box = state().clipping_paths.current.bounding_box();
  254. m_painter.clear_clip_rect();
  255. if (m_rendering_preferences.show_clipping_paths) {
  256. m_painter.stroke_path(rect_path(bounding_box), Color::Black, 1);
  257. }
  258. m_painter.add_clip_rect(bounding_box.to_type<int>());
  259. }
  260. void Renderer::end_path_paint()
  261. {
  262. m_current_path.clear();
  263. m_painter.clear_clip_rect();
  264. state().clipping_paths.current = state().clipping_paths.next;
  265. }
  266. RENDERER_HANDLER(path_stroke)
  267. {
  268. begin_path_paint();
  269. m_anti_aliasing_painter.stroke_path(m_current_path, state().stroke_color, state().ctm.x_scale() * state().line_width);
  270. end_path_paint();
  271. return {};
  272. }
  273. RENDERER_HANDLER(path_close_and_stroke)
  274. {
  275. m_current_path.close();
  276. TRY(handle_path_stroke(args));
  277. return {};
  278. }
  279. RENDERER_HANDLER(path_fill_nonzero)
  280. {
  281. begin_path_paint();
  282. m_current_path.close_all_subpaths();
  283. m_anti_aliasing_painter.fill_path(m_current_path, state().paint_color, Gfx::Painter::WindingRule::Nonzero);
  284. end_path_paint();
  285. return {};
  286. }
  287. RENDERER_HANDLER(path_fill_nonzero_deprecated)
  288. {
  289. return handle_path_fill_nonzero(args);
  290. }
  291. RENDERER_HANDLER(path_fill_evenodd)
  292. {
  293. begin_path_paint();
  294. m_current_path.close_all_subpaths();
  295. m_anti_aliasing_painter.fill_path(m_current_path, state().paint_color, Gfx::Painter::WindingRule::EvenOdd);
  296. end_path_paint();
  297. return {};
  298. }
  299. RENDERER_HANDLER(path_fill_stroke_nonzero)
  300. {
  301. m_anti_aliasing_painter.stroke_path(m_current_path, state().stroke_color, state().ctm.x_scale() * state().line_width);
  302. return handle_path_fill_nonzero(args);
  303. }
  304. RENDERER_HANDLER(path_fill_stroke_evenodd)
  305. {
  306. m_anti_aliasing_painter.stroke_path(m_current_path, state().stroke_color, state().ctm.x_scale() * state().line_width);
  307. return handle_path_fill_evenodd(args);
  308. }
  309. RENDERER_HANDLER(path_close_fill_stroke_nonzero)
  310. {
  311. m_current_path.close();
  312. return handle_path_fill_stroke_nonzero(args);
  313. }
  314. RENDERER_HANDLER(path_close_fill_stroke_evenodd)
  315. {
  316. m_current_path.close();
  317. return handle_path_fill_stroke_evenodd(args);
  318. }
  319. RENDERER_HANDLER(path_end)
  320. {
  321. begin_path_paint();
  322. end_path_paint();
  323. return {};
  324. }
  325. RENDERER_HANDLER(path_intersect_clip_nonzero)
  326. {
  327. // FIXME: Support arbitrary path clipping in Path and utilize that here
  328. auto next_clipping_bbox = state().clipping_paths.next.bounding_box();
  329. next_clipping_bbox.intersect(m_current_path.bounding_box());
  330. state().clipping_paths.next = rect_path(next_clipping_bbox);
  331. return {};
  332. }
  333. RENDERER_HANDLER(path_intersect_clip_evenodd)
  334. {
  335. // FIXME: Should have different behavior than path_intersect_clip_nonzero
  336. return handle_path_intersect_clip_nonzero(args);
  337. }
  338. RENDERER_HANDLER(text_begin)
  339. {
  340. m_text_matrix = Gfx::AffineTransform();
  341. m_text_line_matrix = Gfx::AffineTransform();
  342. return {};
  343. }
  344. RENDERER_HANDLER(text_end)
  345. {
  346. // FIXME: Do we need to do anything here?
  347. return {};
  348. }
  349. RENDERER_HANDLER(text_set_char_space)
  350. {
  351. text_state().character_spacing = args[0].to_float();
  352. return {};
  353. }
  354. RENDERER_HANDLER(text_set_word_space)
  355. {
  356. text_state().word_spacing = args[0].to_float();
  357. return {};
  358. }
  359. RENDERER_HANDLER(text_set_horizontal_scale)
  360. {
  361. m_text_rendering_matrix_is_dirty = true;
  362. text_state().horizontal_scaling = args[0].to_float() / 100.0f;
  363. return {};
  364. }
  365. RENDERER_HANDLER(text_set_leading)
  366. {
  367. text_state().leading = args[0].to_float();
  368. return {};
  369. }
  370. PDFErrorOr<NonnullRefPtr<PDFFont>> Renderer::get_font(FontCacheKey const& key)
  371. {
  372. auto it = m_font_cache.find(key);
  373. if (it != m_font_cache.end())
  374. return it->value;
  375. auto font = TRY(PDFFont::create(m_document, key.font_dictionary, key.font_size));
  376. m_font_cache.set(key, font);
  377. return font;
  378. }
  379. RENDERER_HANDLER(text_set_font)
  380. {
  381. auto target_font_name = MUST(m_document->resolve_to<NameObject>(args[0]))->name();
  382. text_state().font_size = args[1].to_float();
  383. auto& text_rendering_matrix = calculate_text_rendering_matrix();
  384. auto font_size = text_rendering_matrix.x_scale() * text_state().font_size;
  385. auto resources = extra_resources.value_or(m_page.resources);
  386. auto fonts_dictionary = MUST(resources->get_dict(m_document, CommonNames::Font));
  387. auto font_dictionary = MUST(fonts_dictionary->get_dict(m_document, target_font_name));
  388. FontCacheKey cache_key { move(font_dictionary), font_size };
  389. text_state().font = TRY(get_font(cache_key));
  390. m_text_rendering_matrix_is_dirty = true;
  391. return {};
  392. }
  393. RENDERER_HANDLER(text_set_rendering_mode)
  394. {
  395. text_state().rendering_mode = static_cast<TextRenderingMode>(args[0].get<int>());
  396. return {};
  397. }
  398. RENDERER_HANDLER(text_set_rise)
  399. {
  400. m_text_rendering_matrix_is_dirty = true;
  401. text_state().rise = args[0].to_float();
  402. return {};
  403. }
  404. RENDERER_HANDLER(text_next_line_offset)
  405. {
  406. Gfx::AffineTransform transform(1.0f, 0.0f, 0.0f, 1.0f, args[0].to_float(), args[1].to_float());
  407. m_text_line_matrix.multiply(transform);
  408. m_text_matrix = m_text_line_matrix;
  409. return {};
  410. }
  411. RENDERER_HANDLER(text_next_line_and_set_leading)
  412. {
  413. text_state().leading = -args[1].to_float();
  414. TRY(handle_text_next_line_offset(args));
  415. return {};
  416. }
  417. RENDERER_HANDLER(text_set_matrix_and_line_matrix)
  418. {
  419. Gfx::AffineTransform new_transform(
  420. args[0].to_float(),
  421. args[1].to_float(),
  422. args[2].to_float(),
  423. args[3].to_float(),
  424. args[4].to_float(),
  425. args[5].to_float());
  426. m_text_line_matrix = new_transform;
  427. m_text_matrix = new_transform;
  428. m_text_rendering_matrix_is_dirty = true;
  429. // Settings the text/line matrix retroactively affects fonts
  430. if (text_state().font) {
  431. auto new_text_rendering_matrix = calculate_text_rendering_matrix();
  432. text_state().font->set_font_size(text_state().font_size * new_text_rendering_matrix.x_scale());
  433. }
  434. return {};
  435. }
  436. RENDERER_HANDLER(text_next_line)
  437. {
  438. TRY(handle_text_next_line_offset(Array<Value, 2> { 0.0f, -text_state().leading }));
  439. return {};
  440. }
  441. RENDERER_HANDLER(text_show_string)
  442. {
  443. auto text = MUST(m_document->resolve_to<StringObject>(args[0]))->string();
  444. TRY(show_text(text));
  445. return {};
  446. }
  447. RENDERER_HANDLER(text_next_line_show_string)
  448. {
  449. TRY(handle_text_next_line(args));
  450. TRY(handle_text_show_string(args));
  451. return {};
  452. }
  453. RENDERER_HANDLER(text_next_line_show_string_set_spacing)
  454. {
  455. TRY(handle_text_set_word_space(args.slice(0, 1)));
  456. TRY(handle_text_set_char_space(args.slice(1, 1)));
  457. TRY(handle_text_next_line_show_string(args.slice(2)));
  458. return {};
  459. }
  460. RENDERER_HANDLER(text_show_string_array)
  461. {
  462. auto elements = MUST(m_document->resolve_to<ArrayObject>(args[0]))->elements();
  463. for (auto& element : elements) {
  464. if (element.has<int>()) {
  465. float shift = (float)element.get<int>() / 1000.0f;
  466. m_text_matrix.translate(-shift * text_state().font_size * text_state().horizontal_scaling, 0.0f);
  467. } else if (element.has<float>()) {
  468. float shift = element.get<float>() / 1000.0f;
  469. m_text_matrix.translate(-shift * text_state().font_size * text_state().horizontal_scaling, 0.0f);
  470. } else {
  471. auto str = element.get<NonnullRefPtr<Object>>()->cast<StringObject>()->string();
  472. TRY(show_text(str));
  473. }
  474. }
  475. return {};
  476. }
  477. RENDERER_HANDLER(type3_font_set_glyph_width)
  478. {
  479. // FIXME: Do something with this.
  480. return {};
  481. }
  482. RENDERER_HANDLER(type3_font_set_glyph_width_and_bbox)
  483. {
  484. // FIXME: Do something with this.
  485. return {};
  486. }
  487. RENDERER_HANDLER(set_stroking_space)
  488. {
  489. state().stroke_color_space = TRY(get_color_space_from_resources(args[0], extra_resources.value_or(m_page.resources)));
  490. VERIFY(state().stroke_color_space);
  491. return {};
  492. }
  493. RENDERER_HANDLER(set_painting_space)
  494. {
  495. state().paint_color_space = TRY(get_color_space_from_resources(args[0], extra_resources.value_or(m_page.resources)));
  496. VERIFY(state().paint_color_space);
  497. return {};
  498. }
  499. RENDERER_HANDLER(set_stroking_color)
  500. {
  501. state().stroke_color = TRY(state().stroke_color_space->color(args));
  502. return {};
  503. }
  504. RENDERER_HANDLER(set_stroking_color_extended)
  505. {
  506. // FIXME: Handle Pattern color spaces
  507. auto last_arg = args.last();
  508. if (last_arg.has<NonnullRefPtr<Object>>() && last_arg.get<NonnullRefPtr<Object>>()->is<NameObject>()) {
  509. dbgln("pattern space {}", last_arg.get<NonnullRefPtr<Object>>()->cast<NameObject>()->name());
  510. return Error::rendering_unsupported_error("Pattern color spaces not yet implemented");
  511. }
  512. state().stroke_color = TRY(state().stroke_color_space->color(args));
  513. return {};
  514. }
  515. RENDERER_HANDLER(set_painting_color)
  516. {
  517. state().paint_color = TRY(state().paint_color_space->color(args));
  518. return {};
  519. }
  520. RENDERER_HANDLER(set_painting_color_extended)
  521. {
  522. // FIXME: Handle Pattern color spaces
  523. auto last_arg = args.last();
  524. if (last_arg.has<NonnullRefPtr<Object>>() && last_arg.get<NonnullRefPtr<Object>>()->is<NameObject>()) {
  525. dbgln("pattern space {}", last_arg.get<NonnullRefPtr<Object>>()->cast<NameObject>()->name());
  526. return Error::rendering_unsupported_error("Pattern color spaces not yet implemented");
  527. }
  528. state().paint_color = TRY(state().paint_color_space->color(args));
  529. return {};
  530. }
  531. RENDERER_HANDLER(set_stroking_color_and_space_to_gray)
  532. {
  533. state().stroke_color_space = DeviceGrayColorSpace::the();
  534. state().stroke_color = TRY(state().stroke_color_space->color(args));
  535. return {};
  536. }
  537. RENDERER_HANDLER(set_painting_color_and_space_to_gray)
  538. {
  539. state().paint_color_space = DeviceGrayColorSpace::the();
  540. state().paint_color = TRY(state().paint_color_space->color(args));
  541. return {};
  542. }
  543. RENDERER_HANDLER(set_stroking_color_and_space_to_rgb)
  544. {
  545. state().stroke_color_space = DeviceRGBColorSpace::the();
  546. state().stroke_color = TRY(state().stroke_color_space->color(args));
  547. return {};
  548. }
  549. RENDERER_HANDLER(set_painting_color_and_space_to_rgb)
  550. {
  551. state().paint_color_space = DeviceRGBColorSpace::the();
  552. state().paint_color = TRY(state().paint_color_space->color(args));
  553. return {};
  554. }
  555. RENDERER_HANDLER(set_stroking_color_and_space_to_cmyk)
  556. {
  557. state().stroke_color_space = DeviceCMYKColorSpace::the();
  558. state().stroke_color = TRY(state().stroke_color_space->color(args));
  559. return {};
  560. }
  561. RENDERER_HANDLER(set_painting_color_and_space_to_cmyk)
  562. {
  563. state().paint_color_space = DeviceCMYKColorSpace::the();
  564. state().paint_color = TRY(state().paint_color_space->color(args));
  565. return {};
  566. }
  567. RENDERER_TODO(shade)
  568. RENDERER_TODO(inline_image_begin)
  569. RENDERER_TODO(inline_image_begin_data)
  570. RENDERER_TODO(inline_image_end)
  571. RENDERER_HANDLER(paint_xobject)
  572. {
  573. VERIFY(args.size() > 0);
  574. auto resources = extra_resources.value_or(m_page.resources);
  575. auto xobject_name = args[0].get<NonnullRefPtr<Object>>()->cast<NameObject>()->name();
  576. auto xobjects_dict = TRY(resources->get_dict(m_document, CommonNames::XObject));
  577. auto xobject = TRY(xobjects_dict->get_stream(m_document, xobject_name));
  578. Optional<NonnullRefPtr<DictObject>> xobject_resources {};
  579. if (xobject->dict()->contains(CommonNames::Resources)) {
  580. xobject_resources = xobject->dict()->get_dict(m_document, CommonNames::Resources).value();
  581. }
  582. auto subtype = MUST(xobject->dict()->get_name(m_document, CommonNames::Subtype))->name();
  583. if (subtype == CommonNames::Image) {
  584. TRY(show_image(xobject));
  585. return {};
  586. }
  587. ScopedState scoped_state { *this };
  588. Vector<Value> matrix;
  589. if (xobject->dict()->contains(CommonNames::Matrix)) {
  590. matrix = xobject->dict()->get_array(m_document, CommonNames::Matrix).value()->elements();
  591. } else {
  592. matrix = Vector { Value { 1 }, Value { 0 }, Value { 0 }, Value { 1 }, Value { 0 }, Value { 0 } };
  593. }
  594. MUST(handle_concatenate_matrix(matrix));
  595. auto operators = TRY(Parser::parse_operators(m_document, xobject->bytes()));
  596. for (auto& op : operators)
  597. TRY(handle_operator(op, xobject_resources));
  598. return {};
  599. }
  600. RENDERER_HANDLER(marked_content_point)
  601. {
  602. // nop
  603. return {};
  604. }
  605. RENDERER_HANDLER(marked_content_designate)
  606. {
  607. // nop
  608. return {};
  609. }
  610. RENDERER_HANDLER(marked_content_begin)
  611. {
  612. // nop
  613. return {};
  614. }
  615. RENDERER_HANDLER(marked_content_begin_with_property_list)
  616. {
  617. // nop
  618. return {};
  619. }
  620. RENDERER_HANDLER(marked_content_end)
  621. {
  622. // nop
  623. return {};
  624. }
  625. RENDERER_TODO(compatibility_begin)
  626. RENDERER_TODO(compatibility_end)
  627. template<typename T>
  628. Gfx::Point<T> Renderer::map(T x, T y) const
  629. {
  630. return state().ctm.map(Gfx::Point<T> { x, y });
  631. }
  632. template<typename T>
  633. Gfx::Size<T> Renderer::map(Gfx::Size<T> size) const
  634. {
  635. return state().ctm.map(size);
  636. }
  637. template<typename T>
  638. Gfx::Rect<T> Renderer::map(Gfx::Rect<T> rect) const
  639. {
  640. return state().ctm.map(rect);
  641. }
  642. PDFErrorOr<void> Renderer::set_graphics_state_from_dict(NonnullRefPtr<DictObject> dict)
  643. {
  644. // ISO 32000 (PDF 2.0), 8.4.5 Graphics state parameter dictionaries
  645. if (dict->contains(CommonNames::LW))
  646. TRY(handle_set_line_width(Array { dict->get_value(CommonNames::LW) }));
  647. if (dict->contains(CommonNames::LC))
  648. TRY(handle_set_line_cap(Array { dict->get_value(CommonNames::LC) }));
  649. if (dict->contains(CommonNames::LJ))
  650. TRY(handle_set_line_join(Array { dict->get_value(CommonNames::LJ) }));
  651. if (dict->contains(CommonNames::ML))
  652. TRY(handle_set_miter_limit(Array { dict->get_value(CommonNames::ML) }));
  653. if (dict->contains(CommonNames::D)) {
  654. auto array = MUST(dict->get_array(m_document, CommonNames::D));
  655. TRY(handle_set_dash_pattern(array->elements()));
  656. }
  657. if (dict->contains(CommonNames::RI))
  658. TRY(handle_set_color_rendering_intent(Array { dict->get_value(CommonNames::RI) }));
  659. // FIXME: OP
  660. // FIXME: op
  661. // FIXME: OPM
  662. // FIXME: Font
  663. // FIXME: BG
  664. // FIXME: BG2
  665. // FIXME: UCR
  666. // FIXME: UCR2
  667. // FIXME: TR
  668. // FIXME: TR2
  669. // FIXME: HT
  670. if (dict->contains(CommonNames::FL))
  671. TRY(handle_set_flatness_tolerance(Array { dict->get_value(CommonNames::FL) }));
  672. // FIXME: SM
  673. // FIXME: SA
  674. // FIXME: BM
  675. // FIXME: SMask
  676. // FIXME: CA
  677. // FIXME: ca
  678. // FIXME: AIS
  679. // FIXME: TK
  680. // FIXME: UseBlackPtComp
  681. // FIXME: HTO
  682. return {};
  683. }
  684. PDFErrorOr<void> Renderer::show_text(DeprecatedString const& string)
  685. {
  686. if (!text_state().font)
  687. return Error::rendering_unsupported_error("Can't draw text because an invalid font was in use");
  688. auto const& text_rendering_matrix = calculate_text_rendering_matrix();
  689. auto start_position = text_rendering_matrix.map(Gfx::FloatPoint { 0.0f, 0.0f });
  690. auto end_position = TRY(text_state().font->draw_string(m_painter, start_position, string, *this));
  691. // Update text matrix
  692. auto delta_x = end_position.x() - start_position.x();
  693. m_text_rendering_matrix_is_dirty = true;
  694. m_text_matrix.translate(delta_x / text_rendering_matrix.x_scale(), 0.0f);
  695. return {};
  696. }
  697. static Vector<u8> upsample_to_8_bit(ReadonlyBytes content, int bits_per_component)
  698. {
  699. VERIFY(bits_per_component == 1 || bits_per_component == 2 || bits_per_component == 4);
  700. Vector<u8> upsampled_storage;
  701. upsampled_storage.ensure_capacity(content.size() * 8 / bits_per_component);
  702. u8 const mask = (1 << bits_per_component) - 1;
  703. for (auto byte : content) {
  704. for (int i = 0; i < 8; i += bits_per_component) {
  705. auto value = (byte >> (8 - bits_per_component - i)) & mask;
  706. upsampled_storage.append(value * (255 / mask));
  707. }
  708. }
  709. return upsampled_storage;
  710. }
  711. PDFErrorOr<NonnullRefPtr<Gfx::Bitmap>> Renderer::load_image(NonnullRefPtr<StreamObject> image)
  712. {
  713. auto image_dict = image->dict();
  714. auto width = TRY(m_document->resolve_to<int>(image_dict->get_value(CommonNames::Width)));
  715. auto height = TRY(m_document->resolve_to<int>(image_dict->get_value(CommonNames::Height)));
  716. auto is_filter = [&](DeprecatedFlyString const& name) -> PDFErrorOr<bool> {
  717. if (!image_dict->contains(CommonNames::Filter))
  718. return false;
  719. auto filter_object = TRY(image_dict->get_object(m_document, CommonNames::Filter));
  720. if (filter_object->is<NameObject>())
  721. return filter_object->cast<NameObject>()->name() == name;
  722. auto filters = filter_object->cast<ArrayObject>();
  723. auto last_filter_index = filters->elements().size() - 1;
  724. return MUST(filters->get_name_at(m_document, last_filter_index))->name() == name;
  725. };
  726. if (TRY(is_filter(CommonNames::JPXDecode))) {
  727. return Error(Error::Type::RenderingUnsupported, "JPXDecode filter");
  728. }
  729. if (image_dict->contains(CommonNames::ImageMask)) {
  730. auto is_mask = TRY(m_document->resolve_to<bool>(image_dict->get_value(CommonNames::ImageMask)));
  731. if (is_mask) {
  732. return Error(Error::Type::RenderingUnsupported, "Image masks");
  733. }
  734. }
  735. // "(Required for images, except those that use the JPXDecode filter; not allowed for image masks) [...]
  736. // it can be any type of color space except Pattern."
  737. auto color_space_object = MUST(image_dict->get_object(m_document, CommonNames::ColorSpace));
  738. auto color_space = TRY(get_color_space_from_document(color_space_object));
  739. auto color_rendering_intent = state().color_rendering_intent;
  740. if (image_dict->contains(CommonNames::Intent))
  741. color_rendering_intent = TRY(image_dict->get_name(m_document, CommonNames::Intent))->name();
  742. // FIXME: Do something with color_rendering_intent.
  743. // "Valid values are 1, 2, 4, 8, and (in PDF 1.5) 16."
  744. auto bits_per_component = TRY(m_document->resolve_to<int>(image_dict->get_value(CommonNames::BitsPerComponent)));
  745. switch (bits_per_component) {
  746. case 1:
  747. case 2:
  748. case 4:
  749. case 8:
  750. case 16:
  751. // Ok!
  752. break;
  753. default:
  754. return Error(Error::Type::MalformedPDF, "Image's /BitsPerComponent invalid");
  755. }
  756. auto content = image->bytes();
  757. Vector<u8> upsampled_storage;
  758. if (bits_per_component < 8) {
  759. upsampled_storage = upsample_to_8_bit(content, bits_per_component);
  760. content = upsampled_storage;
  761. bits_per_component = 8;
  762. }
  763. if (bits_per_component == 16) {
  764. return Error(Error::Type::RenderingUnsupported, "16 bpp images not yet supported");
  765. }
  766. Vector<float> decode_array;
  767. if (image_dict->contains(CommonNames::Decode)) {
  768. decode_array = MUST(image_dict->get_array(m_document, CommonNames::Decode))->float_elements();
  769. } else {
  770. decode_array = color_space->default_decode();
  771. }
  772. Vector<LinearInterpolation1D> component_value_decoders;
  773. component_value_decoders.ensure_capacity(decode_array.size());
  774. for (size_t i = 0; i < decode_array.size(); i += 2) {
  775. auto dmin = decode_array[i];
  776. auto dmax = decode_array[i + 1];
  777. component_value_decoders.empend(0.0f, 255.0f, dmin, dmax);
  778. }
  779. if (TRY(is_filter(CommonNames::DCTDecode))) {
  780. // TODO: stream objects could store Variant<bytes/Bitmap> to avoid serialisation/deserialisation here
  781. return TRY(Gfx::Bitmap::create_from_serialized_bytes(image->bytes()));
  782. }
  783. auto bitmap = MUST(Gfx::Bitmap::create(Gfx::BitmapFormat::BGRA8888, { width, height }));
  784. int x = 0;
  785. int y = 0;
  786. int const n_components = color_space->number_of_components();
  787. auto const bytes_per_component = bits_per_component / 8;
  788. Vector<Value> component_values;
  789. component_values.resize(n_components);
  790. while (!content.is_empty() && y < height) {
  791. auto sample = content.slice(0, bytes_per_component * n_components);
  792. content = content.slice(bytes_per_component * n_components);
  793. for (int i = 0; i < n_components; ++i) {
  794. auto component = sample.slice(0, bytes_per_component);
  795. sample = sample.slice(bytes_per_component);
  796. component_values[i] = Value { component_value_decoders[i].interpolate(component[0]) };
  797. }
  798. auto color = TRY(color_space->color(component_values));
  799. bitmap->set_pixel(x, y, color);
  800. ++x;
  801. if (x == width) {
  802. x = 0;
  803. ++y;
  804. }
  805. }
  806. return bitmap;
  807. }
  808. Gfx::AffineTransform Renderer::calculate_image_space_transformation(int width, int height)
  809. {
  810. // Image space maps to a 1x1 unit of user space and starts at the top-left
  811. auto image_space = state().ctm;
  812. image_space.multiply(Gfx::AffineTransform(
  813. 1.0f / width,
  814. 0.0f,
  815. 0.0f,
  816. -1.0f / height,
  817. 0.0f,
  818. 1.0f));
  819. return image_space;
  820. }
  821. void Renderer::show_empty_image(int width, int height)
  822. {
  823. auto image_space_transofmation = calculate_image_space_transformation(width, height);
  824. auto image_border = image_space_transofmation.map(Gfx::IntRect { 0, 0, width, height });
  825. m_painter.stroke_path(rect_path(image_border), Color::Black, 1);
  826. }
  827. PDFErrorOr<void> Renderer::show_image(NonnullRefPtr<StreamObject> image)
  828. {
  829. auto image_dict = image->dict();
  830. auto width = TRY(m_document->resolve_to<int>(image_dict->get_value(CommonNames::Width)));
  831. auto height = TRY(m_document->resolve_to<int>(image_dict->get_value(CommonNames::Height)));
  832. if (!m_rendering_preferences.show_images) {
  833. show_empty_image(width, height);
  834. return {};
  835. }
  836. auto image_bitmap = TRY(load_image(image));
  837. if (image_dict->contains(CommonNames::SMask)) {
  838. auto smask_bitmap = TRY(load_image(TRY(image_dict->get_stream(m_document, CommonNames::SMask))));
  839. // Make softmask same size as image.
  840. // FIXME: The smask code here is fairly ad-hoc and incomplete.
  841. if (smask_bitmap->size() != image_bitmap->size())
  842. smask_bitmap = TRY(smask_bitmap->scaled_to_size(image_bitmap->size()));
  843. image_bitmap->add_alpha_channel();
  844. for (int j = 0; j < image_bitmap->height(); ++j) {
  845. for (int i = 0; i < image_bitmap->width(); ++i) {
  846. auto image_color = image_bitmap->get_pixel(i, j);
  847. auto smask_color = smask_bitmap->get_pixel(i, j);
  848. image_color = image_color.with_alpha(smask_color.luminosity());
  849. image_bitmap->set_pixel(i, j, image_color);
  850. }
  851. }
  852. }
  853. auto image_space = calculate_image_space_transformation(width, height);
  854. auto image_rect = Gfx::FloatRect { 0, 0, width, height };
  855. m_painter.draw_scaled_bitmap_with_transform(image_bitmap->rect(), image_bitmap, image_rect, image_space);
  856. return {};
  857. }
  858. PDFErrorOr<NonnullRefPtr<ColorSpace>> Renderer::get_color_space_from_resources(Value const& value, NonnullRefPtr<DictObject> resources)
  859. {
  860. auto color_space_name = value.get<NonnullRefPtr<Object>>()->cast<NameObject>()->name();
  861. auto maybe_color_space_family = ColorSpaceFamily::get(color_space_name);
  862. if (!maybe_color_space_family.is_error()) {
  863. auto color_space_family = maybe_color_space_family.release_value();
  864. if (color_space_family.may_be_specified_directly()) {
  865. return ColorSpace::create(color_space_name);
  866. }
  867. }
  868. auto color_space_resource_dict = TRY(resources->get_dict(m_document, CommonNames::ColorSpace));
  869. if (!color_space_resource_dict->contains(color_space_name)) {
  870. dbgln("missing key {}", color_space_name);
  871. return Error::rendering_unsupported_error("Missing entry for color space name");
  872. }
  873. return get_color_space_from_document(TRY(color_space_resource_dict->get_object(m_document, color_space_name)));
  874. }
  875. PDFErrorOr<NonnullRefPtr<ColorSpace>> Renderer::get_color_space_from_document(NonnullRefPtr<Object> color_space_object)
  876. {
  877. return ColorSpace::create(m_document, color_space_object);
  878. }
  879. Gfx::AffineTransform const& Renderer::calculate_text_rendering_matrix() const
  880. {
  881. if (m_text_rendering_matrix_is_dirty) {
  882. m_text_rendering_matrix = Gfx::AffineTransform(
  883. text_state().horizontal_scaling,
  884. 0.0f,
  885. 0.0f,
  886. 1.0f,
  887. 0.0f,
  888. text_state().rise);
  889. m_text_rendering_matrix.multiply(state().ctm);
  890. m_text_rendering_matrix.multiply(m_text_matrix);
  891. m_text_rendering_matrix_is_dirty = false;
  892. }
  893. return m_text_rendering_matrix;
  894. }
  895. PDFErrorOr<void> Renderer::render_type3_glyph(Gfx::FloatPoint point, StreamObject const& glyph_data, Gfx::AffineTransform const& font_matrix, Optional<NonnullRefPtr<DictObject>> resources)
  896. {
  897. ScopedState scoped_state { *this };
  898. auto text_rendering_matrix = calculate_text_rendering_matrix();
  899. text_rendering_matrix.set_translation(point);
  900. state().ctm = text_rendering_matrix;
  901. state().ctm.scale(text_state().font_size, text_state().font_size);
  902. state().ctm.multiply(font_matrix);
  903. m_text_rendering_matrix_is_dirty = true;
  904. auto operators = TRY(Parser::parse_operators(m_document, glyph_data.bytes()));
  905. for (auto& op : operators)
  906. TRY(handle_operator(op, resources));
  907. return {};
  908. }
  909. }