From 70e2270a8ac049bbcef0f13ae0848e3a2d01966b Mon Sep 17 00:00:00 2001 From: John Abd-El-Malek Date: Thu, 22 May 2014 16:14:52 -0700 Subject: Create a standalone pdfium build. I moved pdfium_test from chromium's repo to pdfium's. It's now buildable as a sample following the instructions on the wiki. --- samples/pdfium_test.cc | 309 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 309 insertions(+) create mode 100644 samples/pdfium_test.cc (limited to 'samples/pdfium_test.cc') diff --git a/samples/pdfium_test.cc b/samples/pdfium_test.cc new file mode 100644 index 0000000000..67c15e0ea5 --- /dev/null +++ b/samples/pdfium_test.cc @@ -0,0 +1,309 @@ +// Copyright (c) 2010 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include +#include +#include +#include + +#include +#include +#include + +#include "fpdfsdk/include/fpdf_dataavail.h" +#include "fpdfsdk/include/fpdf_ext.h" +#include "fpdfsdk/include/fpdfformfill.h" +#include "fpdfsdk/include/fpdftext.h" +#include "fpdfsdk/include/fpdfview.h" +#include "v8/include/v8.h" + +#ifdef _WIN32 + #define snprintf _snprintf + /* in Windows, rb for open and read binary file */ + #define FOPEN_READ "rb" +#else + #define FOPEN_READ "r" +#endif + +static void WritePpm(const char* pdf_name, int num, + const char* buffer, int stride, int width, int height) { + if (stride < 0 || width < 0 || height < 0) + return; + if (height > 0 && width > INT_MAX / height) + return; + int out_len = width * height; + if (out_len > INT_MAX / 3) + return; + out_len *= 3; + + char filename[256]; + snprintf(filename, sizeof(filename), "%s.%d.ppm", pdf_name, num); + FILE* fp = fopen(filename, "w"); + if (!fp) + return; + fprintf(fp, "P6\n# PDF test render\n%d %d\n255\n", width, height); + // Source data is B, G, R, unused. + // Dest data is R, G, B. + char* result = new char[out_len]; + if (result) { + for (int h = 0; h < height; ++h) { + const char* src_line = buffer + (stride * h); + char* dest_line = result + (width * h * 3); + for (int w = 0; w < width; ++w) { + // R + dest_line[w * 3] = src_line[(w * 4) + 2]; + // G + dest_line[(w * 3) + 1] = src_line[(w * 4) + 1]; + // B + dest_line[(w * 3) + 2] = src_line[w * 4]; + } + } + fwrite(result, out_len, 1, fp); + delete [] result; + } + fclose(fp); +} + +int Form_Alert(IPDF_JSPLATFORM*, FPDF_WIDESTRING, FPDF_WIDESTRING, int, int) { + printf("Form_Alert called.\n"); + return 0; +} + +void Unsupported_Handler(UNSUPPORT_INFO*, int type) { + std::string feature = "Unknown"; + switch (type) { + case FPDF_UNSP_DOC_XFAFORM: + feature = "XFA"; + break; + case FPDF_UNSP_DOC_PORTABLECOLLECTION: + feature = "Portfolios_Packages"; + break; + case FPDF_UNSP_DOC_ATTACHMENT: + case FPDF_UNSP_ANNOT_ATTACHMENT: + feature = "Attachment"; + break; + case FPDF_UNSP_DOC_SECURITY: + feature = "Rights_Management"; + break; + case FPDF_UNSP_DOC_SHAREDREVIEW: + feature = "Shared_Review"; + break; + case FPDF_UNSP_DOC_SHAREDFORM_ACROBAT: + case FPDF_UNSP_DOC_SHAREDFORM_FILESYSTEM: + case FPDF_UNSP_DOC_SHAREDFORM_EMAIL: + feature = "Shared_Form"; + break; + case FPDF_UNSP_ANNOT_3DANNOT: + feature = "3D"; + break; + case FPDF_UNSP_ANNOT_MOVIE: + feature = "Movie"; + break; + case FPDF_UNSP_ANNOT_SOUND: + feature = "Sound"; + break; + case FPDF_UNSP_ANNOT_SCREEN_MEDIA: + case FPDF_UNSP_ANNOT_SCREEN_RICHMEDIA: + feature = "Screen"; + break; + case FPDF_UNSP_ANNOT_SIG: + feature = "Digital_Signature"; + break; + } + printf("Unsupported feature: %s.\n", feature.c_str()); +} + +bool ParseCommandLine(int argc, const char* argv[], bool* write_images, + std::list* files) { + *write_images = false; + files->clear(); + + int cur_arg = 1; + if (cur_arg < argc && + strcmp(argv[cur_arg], "--write_images") == 0) { + *write_images = true; + cur_arg++; + } + + if (cur_arg >= argc) + return false; + + for (int i = cur_arg; i < argc; i++) + files->push_back(argv[i]); + + return true; +} + +class TestLoader { + public: + TestLoader(const char* pBuf, size_t len); + + const char* m_pBuf; + size_t m_Len; +}; + +TestLoader::TestLoader(const char* pBuf, size_t len) + : m_pBuf(pBuf), m_Len(len) { +} + +int Get_Block(void* param, unsigned long pos, unsigned char* pBuf, + unsigned long size) { + TestLoader* pLoader = (TestLoader*) param; + if (pos + size < pos || pos + size > pLoader->m_Len) return 0; + memcpy(pBuf, pLoader->m_pBuf + pos, size); + return 1; +} + +bool Is_Data_Avail(FX_FILEAVAIL* pThis, size_t offset, size_t size) { + return true; +} + +void Add_Segment(FX_DOWNLOADHINTS* pThis, size_t offset, size_t size) { +} + +void RenderPdf(const char* name, const char* pBuf, size_t len, + bool write_images) { + printf("Rendering PDF file %s.\n", name); + + IPDF_JSPLATFORM platform_callbacks; + memset(&platform_callbacks, '\0', sizeof(platform_callbacks)); + platform_callbacks.version = 1; + platform_callbacks.app_alert = Form_Alert; + + FPDF_FORMFILLINFO form_callbacks; + memset(&form_callbacks, '\0', sizeof(form_callbacks)); + form_callbacks.version = 1; + form_callbacks.m_pJsPlatform = &platform_callbacks; + + TestLoader loader(pBuf, len); + + FPDF_FILEACCESS file_access; + memset(&file_access, '\0', sizeof(file_access)); + file_access.m_FileLen = len; + file_access.m_GetBlock = Get_Block; + file_access.m_Param = &loader; + + FX_FILEAVAIL file_avail; + memset(&file_avail, '\0', sizeof(file_avail)); + file_avail.version = 1; + file_avail.IsDataAvail = Is_Data_Avail; + + FX_DOWNLOADHINTS hints; + memset(&hints, '\0', sizeof(hints)); + hints.version = 1; + hints.AddSegment = Add_Segment; + + FPDF_DOCUMENT doc; + FPDF_AVAIL pdf_avail = FPDFAvail_Create(&file_avail, &file_access); + + (void) FPDFAvail_IsDocAvail(pdf_avail, &hints); + + if (!FPDFAvail_IsLinearized(pdf_avail)) { + printf("Non-linearized path...\n"); + doc = FPDF_LoadCustomDocument(&file_access, NULL); + } else { + printf("Linearized path...\n"); + doc = FPDFAvail_GetDocument(pdf_avail, NULL); + } + + (void) FPDF_GetDocPermissions(doc); + (void) FPDFAvail_IsFormAvail(pdf_avail, &hints); + + FPDF_FORMHANDLE form = FPDFDOC_InitFormFillEnviroument(doc, &form_callbacks); + FPDF_SetFormFieldHighlightColor(form, 0, 0xFFE4DD); + FPDF_SetFormFieldHighlightAlpha(form, 100); + + int first_page = FPDFAvail_GetFirstPageNum(doc); + (void) FPDFAvail_IsPageAvail(pdf_avail, first_page, &hints); + + int page_count = FPDF_GetPageCount(doc); + for (int i = 0; i < page_count; ++i) { + (void) FPDFAvail_IsPageAvail(pdf_avail, i, &hints); + } + + FORM_DoDocumentJSAction(form); + FORM_DoDocumentOpenAction(form); + + for (int i = 0; i < page_count; ++i) { + FPDF_PAGE page = FPDF_LoadPage(doc, i); + FPDF_TEXTPAGE text_page = FPDFText_LoadPage(page); + FORM_OnAfterLoadPage(page, form); + FORM_DoPageAAction(page, form, FPDFPAGE_AACTION_OPEN); + + int width = static_cast(FPDF_GetPageWidth(page)); + int height = static_cast(FPDF_GetPageHeight(page)); + FPDF_BITMAP bitmap = FPDFBitmap_Create(width, height, 0); + FPDFBitmap_FillRect(bitmap, 0, 0, width, height, 255, 255, 255, 255); + + FPDF_RenderPageBitmap(bitmap, page, 0, 0, width, height, 0, 0); + FPDF_FFLDraw(form, bitmap, page, 0, 0, width, height, 0, 0); + if (write_images) { + const char* buffer = reinterpret_cast( + FPDFBitmap_GetBuffer(bitmap)); + int stride = FPDFBitmap_GetStride(bitmap); + WritePpm(name, i, buffer, stride, width, height); + } + + FPDFBitmap_Destroy(bitmap); + + FORM_DoPageAAction(page, form, FPDFPAGE_AACTION_CLOSE); + FORM_OnBeforeClosePage(page, form); + FPDFText_ClosePage(text_page); + FPDF_ClosePage(page); + } + + FORM_DoDocumentAAction(form, FPDFDOC_AACTION_WC); + FPDFDOC_ExitFormFillEnviroument(form); + FPDF_CloseDocument(doc); + FPDFAvail_Destroy(pdf_avail); + + printf("Loaded, parsed and rendered %d pages.\n", page_count); +} + +int main(int argc, const char* argv[]) { + v8::V8::InitializeICU(); + bool write_images = false; + std::list files; + if (!ParseCommandLine(argc, argv, &write_images, &files)) { + printf("Usage is: test [--write_images] /path/to/pdf\n"); + printf("--write_images - to write page images ..ppm\n"); + return 1; + } + + FPDF_InitLibrary(NULL); + + UNSUPPORT_INFO unsuppored_info; + memset(&unsuppored_info, '\0', sizeof(unsuppored_info)); + unsuppored_info.version = 1; + unsuppored_info.FSDK_UnSupport_Handler = Unsupported_Handler; + + FSDK_SetUnSpObjProcessHandler(&unsuppored_info); + + while (!files.empty()) { + const char* filename = files.front(); + files.pop_front(); + FILE* file = fopen(filename, FOPEN_READ); + if (!file) { + fprintf(stderr, "Failed to open: %s\n", filename); + continue; + } + (void) fseek(file, 0, SEEK_END); + size_t len = ftell(file); + (void) fseek(file, 0, SEEK_SET); + char* pBuf = (char*) malloc(len); + size_t ret = fread(pBuf, 1, len, file); + (void) fclose(file); + if (ret != len) { + fprintf(stderr, "Failed to read: %s\n", filename); + } else { + RenderPdf(filename, pBuf, len, write_images); + } + free(pBuf); + } + + FPDF_DestroyLibrary(); + + return 0; +} + -- cgit v1.2.3