Document.cpp 4.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160
  1. /*
  2. * Copyright (c) 2021, Matthew Olsson <mattco@serenityos.org>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #include <LibPDF/Document.h>
  7. #include <LibPDF/Parser.h>
  8. namespace PDF {
  9. Document::Document(const ReadonlyBytes& bytes)
  10. : m_parser(Parser({}, bytes))
  11. {
  12. m_parser.set_document(this);
  13. VERIFY(m_parser.perform_validation());
  14. auto [xref_table, trailer] = m_parser.parse_last_xref_table_and_trailer();
  15. m_xref_table = xref_table;
  16. m_trailer = trailer;
  17. m_catalog = m_trailer->get_dict(this, "Root");
  18. build_page_tree();
  19. }
  20. Value Document::get_or_load_value(u32 index)
  21. {
  22. auto value = get_value(index);
  23. if (value)
  24. return value;
  25. VERIFY(m_xref_table.has_object(index));
  26. auto byte_offset = m_xref_table.byte_offset_for_object(index);
  27. auto indirect_value = m_parser.parse_indirect_value_at_offset(byte_offset);
  28. VERIFY(indirect_value->index() == index);
  29. value = indirect_value->value();
  30. m_values.set(index, value);
  31. return value;
  32. }
  33. u32 Document::get_first_page_index() const
  34. {
  35. // FIXME: A PDF can have a different default first page, which
  36. // should be fetched and returned here
  37. return 0;
  38. }
  39. u32 Document::get_page_count() const
  40. {
  41. return m_page_object_indices.size();
  42. }
  43. Page Document::get_page(u32 index)
  44. {
  45. VERIFY(index < m_page_object_indices.size());
  46. auto cached_page = m_pages.get(index);
  47. if (cached_page.has_value())
  48. return cached_page.value();
  49. auto page_object_index = m_page_object_indices[index];
  50. auto raw_page_object = resolve_to<DictObject>(get_or_load_value(page_object_index));
  51. auto resources = raw_page_object->get_dict(this, "Resources");
  52. auto contents = raw_page_object->get_object(this, "Contents");
  53. auto media_box_array = raw_page_object->get_array(this, "MediaBox");
  54. auto media_box = Rectangle {
  55. media_box_array->at(0).to_float(),
  56. media_box_array->at(1).to_float(),
  57. media_box_array->at(2).to_float(),
  58. media_box_array->at(3).to_float(),
  59. };
  60. auto crop_box = media_box;
  61. if (raw_page_object->contains("CropBox")) {
  62. auto crop_box_array = raw_page_object->get_array(this, "CropBox");
  63. crop_box = Rectangle {
  64. crop_box_array->at(0).to_float(),
  65. crop_box_array->at(1).to_float(),
  66. crop_box_array->at(2).to_float(),
  67. crop_box_array->at(3).to_float(),
  68. };
  69. }
  70. float user_unit = 1.0f;
  71. if (raw_page_object->contains("UserUnit"))
  72. user_unit = raw_page_object->get_value("UserUnit").to_float();
  73. int rotate = 0;
  74. if (raw_page_object->contains("Rotate")) {
  75. rotate = raw_page_object->get_value("Rotate").as_int();
  76. VERIFY(rotate % 90 == 0);
  77. }
  78. Page page { move(resources), move(contents), media_box, crop_box, user_unit, rotate };
  79. m_pages.set(index, page);
  80. return page;
  81. }
  82. Value Document::resolve(const Value& value)
  83. {
  84. if (!value.is_object())
  85. return value;
  86. auto obj = value.as_object();
  87. // FIXME: Surely indirect PDF objects can't contain another indirect PDF object,
  88. // right? Unsure from the spec, but if they can, these return values would have
  89. // to be wrapped with another resolve() call.
  90. if (obj->is_indirect_value_ref()) {
  91. auto object_index = static_cast<NonnullRefPtr<IndirectValueRef>>(obj)->index();
  92. return get_or_load_value(object_index);
  93. }
  94. if (obj->is_indirect_value())
  95. return static_cast<NonnullRefPtr<IndirectValue>>(obj)->value();
  96. return obj;
  97. }
  98. void Document::build_page_tree()
  99. {
  100. auto page_tree = m_catalog->get_dict(this, "Pages");
  101. add_page_tree_node_to_page_tree(page_tree);
  102. }
  103. void Document::add_page_tree_node_to_page_tree(NonnullRefPtr<DictObject> page_tree)
  104. {
  105. auto kids_array = page_tree->get_array(this, "Kids");
  106. auto page_count = page_tree->get("Count").value().as_int();
  107. if (static_cast<size_t>(page_count) != kids_array->elements().size()) {
  108. // This page tree contains child page trees, so we recursively add
  109. // these pages to the overall page tree
  110. for (auto& value : *kids_array) {
  111. auto reference = object_cast<IndirectValueRef>(value.as_object());
  112. auto byte_offset = m_xref_table.byte_offset_for_object(reference->index());
  113. auto maybe_page_tree_node = m_parser.conditionally_parse_page_tree_node_at_offset(byte_offset);
  114. if (maybe_page_tree_node) {
  115. add_page_tree_node_to_page_tree(maybe_page_tree_node.release_nonnull());
  116. } else {
  117. m_page_object_indices.append(reference->index());
  118. }
  119. }
  120. return;
  121. }
  122. // We know all of the kids are leaf nodes
  123. for (auto& value : *kids_array) {
  124. auto reference = object_cast<IndirectValueRef>(value.as_object());
  125. m_page_object_indices.append(reference->index());
  126. }
  127. }
  128. }