summaryrefslogtreecommitdiff
path: root/fpdfsdk/fpdfppo.cpp
diff options
context:
space:
mode:
authorxlou <xlou@chromium.org>2018-01-31 22:24:05 +0000
committerChromium commit bot <commit-bot@chromium.org>2018-01-31 22:24:05 +0000
commit66ce22c6cdb38ca5941c175aea371df92ae9cb8b (patch)
tree4557f587133e3005bde76d9b4fc12d19bd899b74 /fpdfsdk/fpdfppo.cpp
parentbb04c59ec30b00cae6c902fa8bc128220bcff4df (diff)
downloadpdfium-66ce22c6cdb38ca5941c175aea371df92ae9cb8b.tar.xz
Experimental API for N-up feature support for print
FPDF_ImportNPagesToOne function is added to support N-up feature for print. If numPagesOnXAxis * numPagesOnYAxis == 0 Returns a nullptr. If numPagesOnXAxis * numPagesOnYAxis == 1 Creates a new PDF document, and import one page to each output page of the PDF document If numPagesOnXAxis * numPagesOnYAxis > 1, FPDF_ImportNPagesToOne imports multiple pages onto the same page. This feature is intended for print pipeline to use. Change-Id: Iec1afffe377ff9b7fef3cb33414b29b324154fa4 Reviewed-on: https://pdfium-review.googlesource.com/22050 Commit-Queue: Shirleen Lou <xlou@chromium.org> Reviewed-by: Lei Zhang <thestig@chromium.org> Reviewed-by: Henrique Nakashima <hnakashima@chromium.org> Reviewed-by: dsinclair <dsinclair@chromium.org>
Diffstat (limited to 'fpdfsdk/fpdfppo.cpp')
-rw-r--r--fpdfsdk/fpdfppo.cpp370
1 files changed, 370 insertions, 0 deletions
diff --git a/fpdfsdk/fpdfppo.cpp b/fpdfsdk/fpdfppo.cpp
index d935ee9403..57417b56c7 100644
--- a/fpdfsdk/fpdfppo.cpp
+++ b/fpdfsdk/fpdfppo.cpp
@@ -11,19 +11,139 @@
#include <utility>
#include <vector>
+#include "core/fpdfapi/page/cpdf_page.h"
+#include "core/fpdfapi/page/cpdf_pageobject.h"
#include "core/fpdfapi/parser/cpdf_array.h"
#include "core/fpdfapi/parser/cpdf_document.h"
#include "core/fpdfapi/parser/cpdf_name.h"
#include "core/fpdfapi/parser/cpdf_number.h"
+#include "core/fpdfapi/parser/cpdf_object.h"
#include "core/fpdfapi/parser/cpdf_reference.h"
#include "core/fpdfapi/parser/cpdf_stream.h"
+#include "core/fpdfapi/parser/cpdf_stream_acc.h"
#include "core/fpdfapi/parser/cpdf_string.h"
+#include "core/fxcrt/retain_ptr.h"
#include "core/fxcrt/unowned_ptr.h"
#include "fpdfsdk/fsdk_define.h"
+#include "public/cpp/fpdf_deleters.h"
#include "third_party/base/ptr_util.h"
+#include "third_party/base/stl_util.h"
namespace {
+// Struct that stores sub page origin and scale information. When importing
+// more than one pages onto the same page, most likely the pages will need to be
+// scaled down, and scale is in range of (0, 1) exclusive.
+struct NupPageSettings {
+ CFX_PointF subPageStartPoint;
+ float scale;
+};
+
+// Calculates the N-up parameters. When importing multiple pages into one page.
+// The space of output page is evenly divided along the X axis and Y axis based
+// on the input |numPagesOnXAxis| and |numPagesOnYAxis|.
+class NupState {
+ public:
+ NupState(float destPageWidth,
+ float destPageHeight,
+ unsigned int numPagesOnXAxis,
+ unsigned int numPagesOnYAxis);
+
+ // Calculate sub page origin and scale with the source page |inWidth| and
+ // |inHeight| and new page |m_subPageWidth| and |m_subPageWidth|. With the
+ // result stored in out parameter |ret|.
+ void CalculateNewPagePosition(float inWidth,
+ float inHeight,
+ NupPageSettings* ret);
+
+ private:
+ // Helper function to get the subX, subY pair based on |m_subPageIndex|.
+ // The space of output page is evenly divided into slots along x and y axis.
+ // subX and subY are 0-based indices that indicate which allocation slot to
+ // use.
+ std::pair<size_t, size_t> ConvertPageOrder() const;
+ // Given the |subx| and |suby| subpage position within a page, and a source
+ // page with dimensions of |inPageWidth| x |inPageHeight|, calculate the sub
+ // page's origin and scale, and store them in |ret|.
+ void CalculatePageEdit(size_t subx,
+ size_t suby,
+ float inPageWidth,
+ float inPageHeight,
+ NupPageSettings* ret) const;
+
+ const size_t m_numPagesOnXAxis;
+ const size_t m_numPagesOnYAxis;
+ const float m_destPageWidth;
+ const float m_destPageHeight;
+ const size_t m_numPagesPerSheet;
+ float m_subPageWidth;
+ float m_subPageHeight;
+ // A 0-based index, in range of (0, m_numPagesPerSheet - 1) inclusive.
+ size_t m_subPageIndex = 0;
+};
+
+NupState::NupState(float destPageWidth,
+ float destPageHeight,
+ unsigned int numPagesOnXAxis,
+ unsigned int numPagesOnYAxis)
+ : m_numPagesOnXAxis(numPagesOnXAxis),
+ m_numPagesOnYAxis(numPagesOnYAxis),
+ m_destPageWidth(destPageWidth),
+ m_destPageHeight(destPageHeight),
+ m_numPagesPerSheet(numPagesOnXAxis * numPagesOnYAxis) {
+ ASSERT(m_numPagesOnXAxis > 0);
+ ASSERT(m_numPagesOnYAxis > 0);
+ ASSERT(m_destPageWidth > 0);
+ ASSERT(m_destPageHeight > 0);
+
+ m_subPageWidth = m_destPageWidth / m_numPagesOnXAxis;
+ m_subPageHeight = m_destPageHeight / m_numPagesOnYAxis;
+}
+
+std::pair<size_t, size_t> NupState::ConvertPageOrder() const {
+ size_t subX = m_subPageIndex % m_numPagesOnXAxis;
+ size_t subY = m_subPageIndex / m_numPagesOnXAxis;
+
+ // Y Axis, pages start from the top of the output page.
+ subY = m_numPagesOnYAxis - subY - 1;
+
+ return {subX, subY};
+}
+
+void NupState::CalculatePageEdit(size_t subXPos,
+ size_t subYPos,
+ float inPageWidth,
+ float inPageHeight,
+ NupPageSettings* pageEdit) const {
+ pageEdit->subPageStartPoint.x = subXPos * m_subPageWidth;
+ pageEdit->subPageStartPoint.y = subYPos * m_subPageHeight;
+
+ const float xScale = m_subPageWidth / inPageWidth;
+ const float yScale = m_subPageHeight / inPageHeight;
+
+ pageEdit->scale = std::min(xScale, yScale);
+
+ float subWidth = inPageWidth * pageEdit->scale;
+ float subHeight = inPageHeight * pageEdit->scale;
+ if (xScale > yScale)
+ pageEdit->subPageStartPoint.x += (m_subPageWidth - subWidth) / 2;
+ else
+ pageEdit->subPageStartPoint.y += (m_subPageHeight - subHeight) / 2;
+}
+
+void NupState::CalculateNewPagePosition(float inWidth,
+ float inHeight,
+ NupPageSettings* pageEdit) {
+ if (m_subPageIndex >= m_numPagesPerSheet)
+ m_subPageIndex = 0;
+
+ size_t subX;
+ size_t subY;
+ std::tie(subX, subY) = ConvertPageOrder();
+ CalculatePageEdit(subX, subY, inWidth, inHeight, pageEdit);
+ ++m_subPageIndex;
+}
+
CPDF_Object* PageDictGetInheritableTag(CPDF_Dictionary* pDict,
const ByteString& bsSrcTag) {
if (!pDict || bsSrcTag.IsEmpty())
@@ -55,6 +175,30 @@ CPDF_Object* PageDictGetInheritableTag(CPDF_Dictionary* pDict,
return nullptr;
}
+CFX_FloatRect GetMediaBox(CPDF_Dictionary* pPageDict) {
+ CPDF_Object* pMediaBox = PageDictGetInheritableTag(pPageDict, "MediaBox");
+ CPDF_Array* pArray = ToArray(pMediaBox->GetDirect());
+ if (!pArray)
+ return CFX_FloatRect();
+ return pArray->GetRect();
+}
+
+CFX_FloatRect GetCropBox(CPDF_Dictionary* pPageDict) {
+ if (pPageDict->KeyExist("CropBox"))
+ return pPageDict->GetRectFor("CropBox");
+ return GetMediaBox(pPageDict);
+}
+
+CFX_FloatRect GetTrimBox(CPDF_Dictionary* pPageDict) {
+ if (pPageDict->KeyExist("TrimBox"))
+ return pPageDict->GetRectFor("TrimBox");
+ return GetCropBox(pPageDict);
+}
+
+CPDF_Object* GetPageContent(CPDF_Dictionary* pPageDict) {
+ return pPageDict ? pPageDict->GetDirectObjectFor("Contents") : nullptr;
+}
+
bool CopyInheritable(CPDF_Dictionary* pCurPageDict,
CPDF_Dictionary* pSrcPageDict,
const ByteString& key) {
@@ -148,15 +292,36 @@ class CPDF_PageOrganizer {
bool PDFDocInit();
bool ExportPage(const std::vector<uint32_t>& pageNums, int nIndex);
+ bool ExportNPagesToOne(const std::vector<uint32_t>& pageNums,
+ float destPageWidth,
+ float destPageHeight,
+ unsigned int numPagesOnXAxis,
+ unsigned int numPagesOnYAxis);
private:
using ObjectNumberMap = std::map<uint32_t, uint32_t>;
+ static void SetMediaBox(CPDF_Dictionary* pDestPageDict,
+ const CFX_SizeF& pagesize);
+
bool UpdateReference(CPDF_Object* pObj, ObjectNumberMap* pObjNumberMap);
uint32_t GetNewObjId(ObjectNumberMap* pObjNumberMap, CPDF_Reference* pRef);
+ // Creates a xobject from the source page dictionary, and appends the content
+ // string with the xobject reference surrounded by the transformation matrix.
+ void AddSubPage(CPDF_Dictionary* pPageDict,
+ const CFX_PointF& position,
+ float scale,
+ ByteString* content);
+ CPDF_Object* MakeXObject(CPDF_Dictionary* pSrcPageDict,
+ CPDF_Document* pDestDoc);
+ void FinishPage(CPDF_Dictionary* pCurPageDict, const ByteString& content);
UnownedPtr<CPDF_Document> m_pDestPDFDoc;
UnownedPtr<CPDF_Document> m_pSrcPDFDoc;
+ uint32_t m_xobjectNum = 0;
+ CFX_SizeF m_pageSize;
+ // Key is XObject name
+ std::map<ByteString, UnownedPtr<CPDF_Object>> m_xobjs;
};
CPDF_PageOrganizer::CPDF_PageOrganizer(CPDF_Document* pDestPDFDoc,
@@ -206,6 +371,92 @@ bool CPDF_PageOrganizer::PDFDocInit() {
return true;
}
+void CPDF_PageOrganizer::AddSubPage(CPDF_Dictionary* pPageDict,
+ const CFX_PointF& position,
+ float scale,
+ ByteString* content) {
+ ++m_xobjectNum;
+ // TODO(Xlou): A better name schema to avoid possible object name collision.
+ ByteString xobjectName = ByteString::Format("X%d", m_xobjectNum);
+ m_xobjs[xobjectName] = MakeXObject(pPageDict, m_pDestPDFDoc.Get());
+
+ CFX_Matrix matrix;
+ matrix.Scale(scale, scale);
+ matrix.Translate(position.x, position.y);
+
+ std::ostringstream contentStream;
+ contentStream << "q\n"
+ << matrix.a << " " << matrix.b << " " << matrix.c << " "
+ << matrix.d << " " << matrix.e << " " << matrix.f << " cm\n"
+ << "/" << xobjectName << " Do Q\n";
+ *content += ByteString(contentStream);
+}
+
+CPDF_Object* CPDF_PageOrganizer::MakeXObject(CPDF_Dictionary* pSrcPageDict,
+ CPDF_Document* pDestDoc) {
+ ASSERT(pSrcPageDict);
+
+ auto pObjNumberMap = pdfium::MakeUnique<ObjectNumberMap>();
+
+ CPDF_Object* pSrcContentObj = GetPageContent(pSrcPageDict);
+ CPDF_Stream* pNewXObject = pDestDoc->NewIndirect<CPDF_Stream>(
+ nullptr, 0,
+ pdfium::MakeUnique<CPDF_Dictionary>(pDestDoc->GetByteStringPool()));
+ CPDF_Dictionary* pNewXObjectDict = pNewXObject->GetDict();
+ const ByteString resourceString = "Resources";
+ if (!CopyInheritable(pNewXObjectDict, pSrcPageDict, resourceString)) {
+ // Use a default empty resources if it does not exist.
+ pNewXObjectDict->SetNewFor<CPDF_Dictionary>(resourceString);
+ }
+ CPDF_Dictionary* pSrcRes = pSrcPageDict->GetDictFor(resourceString);
+ if (pSrcRes) {
+ uint32_t dwSrcPageResourcesObj = pSrcRes->GetObjNum();
+ uint32_t dwNewXobjectResourcesObj =
+ pNewXObjectDict->GetDictFor(resourceString)->GetObjNum();
+ (*pObjNumberMap)[dwSrcPageResourcesObj] = dwNewXobjectResourcesObj;
+ CPDF_Dictionary* pNewXORes = pNewXObjectDict->GetDictFor(resourceString);
+ UpdateReference(pNewXORes, pObjNumberMap.get());
+ }
+
+ pNewXObjectDict->SetNewFor<CPDF_Name>("Type", "XObject");
+ pNewXObjectDict->SetNewFor<CPDF_Name>("Subtype", "Form");
+ pNewXObjectDict->SetNewFor<CPDF_Number>("FormType", 1);
+ pNewXObjectDict->SetRectFor("BBox", GetTrimBox(pSrcPageDict));
+ // TODO(xlou): add matrix field to pNewXObjectDict.
+
+ if (CPDF_Array* pSrcContentArray = ToArray(pSrcContentObj)) {
+ ByteString srcContentStream;
+ for (size_t i = 0; i < pSrcContentArray->GetCount(); ++i) {
+ CPDF_Stream* pStream = pSrcContentArray->GetStreamAt(i);
+ auto pAcc = pdfium::MakeRetain<CPDF_StreamAcc>(pStream);
+ pAcc->LoadAllDataFiltered();
+ ByteString sStream(pAcc->GetData(), pAcc->GetSize());
+ srcContentStream += sStream;
+ srcContentStream += "\n";
+ }
+ pNewXObject->SetDataAndRemoveFilter(srcContentStream.raw_str(),
+ srcContentStream.GetLength());
+ } else {
+ CPDF_Stream* pStream = pSrcContentObj->AsStream();
+ auto pAcc = pdfium::MakeRetain<CPDF_StreamAcc>(pStream);
+ pAcc->LoadAllDataFiltered();
+ ByteString sStream(pAcc->GetData(), pAcc->GetSize());
+ pNewXObject->SetDataAndRemoveFilter(sStream.raw_str(), sStream.GetLength());
+ }
+
+ return pNewXObject;
+}
+
+// static
+void CPDF_PageOrganizer::SetMediaBox(CPDF_Dictionary* pDestPageDict,
+ const CFX_SizeF& pagesize) {
+ CPDF_Array* pArray = pDestPageDict->SetNewFor<CPDF_Array>("MediaBox");
+ pArray->AddNew<CPDF_Number>(0);
+ pArray->AddNew<CPDF_Number>(0);
+ pArray->AddNew<CPDF_Number>(pagesize.width);
+ pArray->AddNew<CPDF_Number>(pagesize.height);
+}
+
bool CPDF_PageOrganizer::ExportPage(const std::vector<uint32_t>& pageNums,
int nIndex) {
int curpage = nIndex;
@@ -269,6 +520,88 @@ bool CPDF_PageOrganizer::ExportPage(const std::vector<uint32_t>& pageNums,
return true;
}
+void CPDF_PageOrganizer::FinishPage(CPDF_Dictionary* pCurPageDict,
+ const ByteString& content) {
+ ASSERT(pCurPageDict);
+
+ CPDF_Dictionary* pRes = pCurPageDict->GetDictFor("Resources");
+ if (!pRes)
+ pRes = pCurPageDict->SetNewFor<CPDF_Dictionary>("Resources");
+
+ CPDF_Dictionary* pPageXObject = pRes->GetDictFor("XObject");
+ if (!pPageXObject)
+ pPageXObject = pRes->SetNewFor<CPDF_Dictionary>("XObject");
+
+ for (auto& it : m_xobjs) {
+ CPDF_Object* pObj = it.second.Get();
+ pPageXObject->SetNewFor<CPDF_Reference>(it.first, m_pDestPDFDoc.Get(),
+ pObj->GetObjNum());
+ }
+
+ auto pDict = pdfium::MakeUnique<CPDF_Dictionary>(
+ m_pDestPDFDoc.Get()->GetByteStringPool());
+ CPDF_Stream* pStream = m_pDestPDFDoc.Get()->NewIndirect<CPDF_Stream>(
+ nullptr, 0, std::move(pDict));
+ pStream->SetData(content.raw_str(), content.GetLength());
+ pCurPageDict->SetNewFor<CPDF_Reference>("Contents", m_pDestPDFDoc.Get(),
+ pStream->GetObjNum());
+ m_xobjs.clear();
+}
+
+bool CPDF_PageOrganizer::ExportNPagesToOne(
+ const std::vector<uint32_t>& pageNums,
+ float destPageWidth,
+ float destPageHeight,
+ unsigned int numPagesOnXAxis,
+ unsigned int numPagesOnYAxis) {
+ FX_SAFE_SIZE_T safe_numPagesPerSheet = numPagesOnXAxis;
+ safe_numPagesPerSheet *= numPagesOnYAxis;
+
+ if (!safe_numPagesPerSheet.IsValid())
+ return false;
+
+ size_t numPagesPerSheet = safe_numPagesPerSheet.ValueOrDie();
+ if (numPagesPerSheet == 1)
+ return ExportPage(pageNums, 0);
+
+ const CFX_SizeF pagesize(destPageWidth, destPageHeight);
+ NupState nupState(destPageWidth, destPageHeight, numPagesOnXAxis,
+ numPagesOnYAxis);
+
+ size_t curpage = 0;
+ for (size_t outerPage = 0; outerPage < pageNums.size();
+ outerPage += numPagesPerSheet) {
+ // Create a new page
+ CPDF_Dictionary* pCurPageDict = m_pDestPDFDoc->CreateNewPage(curpage);
+ if (!pCurPageDict)
+ return false;
+
+ SetMediaBox(pCurPageDict, pagesize);
+ ByteString content;
+ size_t innerPageMax =
+ std::min(outerPage + numPagesPerSheet, pageNums.size());
+ for (size_t innerPage = outerPage; innerPage < innerPageMax; ++innerPage) {
+ CPDF_Dictionary* pSrcPageDict =
+ m_pSrcPDFDoc->GetPage(pageNums[innerPage] - 1);
+ if (!pSrcPageDict)
+ return false;
+
+ CPDF_Page srcPage(m_pSrcPDFDoc.Get(), pSrcPageDict, true);
+ NupPageSettings pgEdit;
+ nupState.CalculateNewPagePosition(srcPage.GetPageWidth(),
+ srcPage.GetPageHeight(), &pgEdit);
+ AddSubPage(pSrcPageDict, pgEdit.subPageStartPoint, pgEdit.scale,
+ &content);
+ }
+
+ // Finish up the current page.
+ FinishPage(pCurPageDict, content);
+ ++curpage;
+ }
+
+ return true;
+}
+
bool CPDF_PageOrganizer::UpdateReference(CPDF_Object* pObj,
ObjectNumberMap* pObjNumberMap) {
switch (pObj->GetType()) {
@@ -384,6 +717,43 @@ FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDF_ImportPages(FPDF_DOCUMENT dest_doc,
return pageOrg.ExportPage(pageArray, index);
}
+FPDF_EXPORT FPDF_DOCUMENT FPDF_CALLCONV
+FPDF_ImportNPagesToOne(FPDF_DOCUMENT src_doc,
+ float output_width,
+ float output_height,
+ unsigned int num_pages_on_x_axis,
+ unsigned int num_pages_on_y_axis) {
+ CPDF_Document* pSrcDoc = CPDFDocumentFromFPDFDocument(src_doc);
+ if (!pSrcDoc)
+ return nullptr;
+
+ if (output_width <= 0 || output_height <= 0 || num_pages_on_x_axis <= 0 ||
+ num_pages_on_y_axis <= 0) {
+ return nullptr;
+ }
+
+ std::unique_ptr<void, FPDFDocumentDeleter> output_doc(
+ FPDF_CreateNewDocument());
+ if (!output_doc)
+ return nullptr;
+
+ CPDF_Document* pDestDoc = CPDFDocumentFromFPDFDocument(output_doc.get());
+ ASSERT(pDestDoc);
+
+ std::vector<uint32_t> pageArray;
+ if (!GetPageNumbers(nullptr, pSrcDoc, &pageArray))
+ return nullptr;
+
+ CPDF_PageOrganizer pageOrg(pDestDoc, pSrcDoc);
+ if (!pageOrg.PDFDocInit() ||
+ !pageOrg.ExportNPagesToOne(pageArray, output_width, output_height,
+ num_pages_on_x_axis, num_pages_on_y_axis)) {
+ return nullptr;
+ }
+
+ return output_doc.release();
+}
+
FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV
FPDF_CopyViewerPreferences(FPDF_DOCUMENT dest_doc, FPDF_DOCUMENT src_doc) {
CPDF_Document* pDstDoc = CPDFDocumentFromFPDFDocument(dest_doc);