Support linearized loading

samples/pdfium_test.cc

 // 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 <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include <list>
@@ skipping 419 matching lines @@
   return 1;
 }
 
 FPDF_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) {
 }
 
+FPDF_BOOL RenderPage(const std::string& name,
+                     const FPDF_DOCUMENT& doc,
+                     const FPDF_FORMHANDLE& form,
+                     const int page_index,
+                     const Options& options) {
+  FPDF_PAGE page = FPDF_LoadPage(doc, page_index);
+  if (!page) {
+    return FALSE;
+  }
+  FPDF_TEXTPAGE text_page = FPDFText_LoadPage(page);
+  FORM_OnAfterLoadPage(page, form);
+  FORM_DoPageAAction(page, form, FPDFPAGE_AACTION_OPEN);
+
+  double scale = 1.0;
+  if (!options.scale_factor_as_string.empty()) {
+    std::stringstream(options.scale_factor_as_string) >> scale;
+  }
+  int width = static_cast<int>(FPDF_GetPageWidth(page) * scale);
+  int height = static_cast<int>(FPDF_GetPageHeight(page) * scale);
+
+  FPDF_BITMAP bitmap = FPDFBitmap_Create(width, height, 0);
+  if (!bitmap) {
+    fprintf(stderr, "Page was too large to be rendered.\n");
+    return FALSE;
+  }
+
+  FPDFBitmap_FillRect(bitmap, 0, 0, width, height, 0xFFFFFFFF);
+  FPDF_RenderPageBitmap(bitmap, page, 0, 0, width, height, 0, 0);
+
+  FPDF_FFLDraw(form, bitmap, page, 0, 0, width, height, 0, 0);
+  int stride = FPDFBitmap_GetStride(bitmap);
+  const char* buffer =
+      reinterpret_cast<const char*>(FPDFBitmap_GetBuffer(bitmap));
+
+  switch (options.output_format) {
+#ifdef _WIN32
+    case OUTPUT_BMP:
+      WriteBmp(name.c_str(), page_index, buffer, stride, width, height);
+      break;
+
+    case OUTPUT_EMF:
+      WriteEmf(page, name.c_str(), page_index);
+      break;
+#endif
+    case OUTPUT_PNG:
+      WritePng(name.c_str(), page_index, buffer, stride, width, height);
+      break;
+
+    case OUTPUT_PPM:
+      WritePpm(name.c_str(), page_index, buffer, stride, width, height);
+      break;
+
+    default:
+      break;
+  }
+
+  FPDFBitmap_Destroy(bitmap);
+  FORM_DoPageAAction(page, form, FPDFPAGE_AACTION_CLOSE);
+  FORM_OnBeforeClosePage(page, form);
+  FPDFText_ClosePage(text_page);
+  FPDF_ClosePage(page);
+  return TRUE;
+}
+
 void RenderPdf(const std::string& name, const char* pBuf, size_t len,
                const Options& options) {
   fprintf(stderr, "Rendering PDF file %s.\n", name.c_str());
 
   IPDF_JSPLATFORM platform_callbacks;
   memset(&platform_callbacks, '\0', sizeof(platform_callbacks));
   platform_callbacks.version = 3;
   platform_callbacks.app_alert = ExampleAppAlert;
   platform_callbacks.Doc_gotoPage = ExampleDocGotoPage;
 
@@ skipping 14 matching lines @@
   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;
+  int32_t nRet = PDF_DATA_NOTAVAIL;
+  FPDF_BOOL bIsLinearized = FALSE;
   FPDF_AVAIL pdf_avail = FPDFAvail_Create(&file_avail, &file_access);
-
-  (void)FPDFAvail_IsDocAvail(pdf_avail, &hints);
-
-  if (FPDFAvail_IsLinearized(pdf_avail)) {
+  if (FPDFAvail_IsLinearized(pdf_avail) == PDF_LINEARIZED) {
     fprintf(stderr, "Linearized path...\n");
     doc = FPDFAvail_GetDocument(pdf_avail, nullptr);
+    if (!doc) {
+      fprintf(stderr, "Load linearized pdf docs unsuccessful.\n");
+      return;
+    }
+    while (nRet == PDF_DATA_NOTAVAIL) {
+      nRet = FPDFAvail_IsDocAvail(pdf_avail, &hints);

[Tom Sepez, 2015/10/21 17:53:08]

For example, if we had a separate function to check if the reason for the
unavailability was due to error, the public API stays stable, e.g.

  while (!FPDFAvail_IsDocAvail(pdf_avail, &hints) {
    if (FPDFAvail_Error(fpdf_avail))
      return;
  }

[jun_fang, 2015/10/22 00:50:06]

Using the example as above, we shall use 
FPDFAvail_Error(fpdf_avail, &hints) and there should be almost 
the same code in FPDFAvail_Error as FPDFAvail_IsDocAvail. Because
some errors are raised in the process of checking doc. As I 
mentioned in the previous comment, it returns true when any errors
are found in checking whether docs or pages are available (It causes
infinite loop if returning false). It really makes readers confused. 

+    }
+    if (nRet == PDF_DATA_ERROR) {
+      return;
+    }
+    if (FPDFAvail_IsFormAvail(pdf_avail, &hints) == PDF_FORM_NOTAVAIL) {
+      return;
+    }
+    bIsLinearized = TRUE;
   } else {
     fprintf(stderr, "Non-linearized path...\n");
     doc = FPDF_LoadCustomDocument(&file_access, nullptr);
-  }
-
-  if (!doc) {
-    fprintf(stderr, "Load pdf docs unsuccessful.\n");
-    return;
+    if (!doc) {
+      fprintf(stderr, "Load non-linearized pdf docs unsuccessful.\n");
+      return;
+    }
   }
 
   (void)FPDF_GetDocPermissions(doc);
-  (void)FPDFAvail_IsFormAvail(pdf_avail, &hints);
 
   FPDF_FORMHANDLE form = FPDFDOC_InitFormFillEnvironment(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);
 
+  int page_count = FPDF_GetPageCount(doc);
   int rendered_pages = 0;
   int bad_pages = 0;
   for (int i = 0; i < page_count; ++i) {
-    FPDF_PAGE page = FPDF_LoadPage(doc, i);
-    if (!page) {
+    if (bIsLinearized) {
+      nRet = PDF_DATA_NOTAVAIL;
+      while (nRet == PDF_DATA_NOTAVAIL) {
+        nRet = FPDFAvail_IsPageAvail(pdf_avail, i, &hints);
+      }
+      if (nRet == PDF_DATA_ERROR) {
+        return;
+      }
+    }
+    if (RenderPage(name, doc, form, i, options)) {
+      ++rendered_pages;
+    } else {
       ++bad_pages;
-      continue;
     }
-    FPDF_TEXTPAGE text_page = FPDFText_LoadPage(page);
-    FORM_OnAfterLoadPage(page, form);
-    FORM_DoPageAAction(page, form, FPDFPAGE_AACTION_OPEN);
-
-    double scale = 1.0;
-    if (!options.scale_factor_as_string.empty()) {
-      std::stringstream(options.scale_factor_as_string) >> scale;
-    }
-    int width = static_cast<int>(FPDF_GetPageWidth(page) * scale);
-    int height = static_cast<int>(FPDF_GetPageHeight(page) * scale);
-
-    FPDF_BITMAP bitmap = FPDFBitmap_Create(width, height, 0);
-    if (!bitmap) {
-      fprintf(stderr, "Page was too large to be rendered.\n");
-      bad_pages++;
-      continue;
-    }
-
-    FPDFBitmap_FillRect(bitmap, 0, 0, width, height, 0xFFFFFFFF);
-    FPDF_RenderPageBitmap(bitmap, page, 0, 0, width, height, 0, 0);
-    ++rendered_pages;
-
-    FPDF_FFLDraw(form, bitmap, page, 0, 0, width, height, 0, 0);
-    int stride = FPDFBitmap_GetStride(bitmap);
-    const char* buffer =
-        reinterpret_cast<const char*>(FPDFBitmap_GetBuffer(bitmap));
-
-    switch (options.output_format) {
-#ifdef _WIN32
-      case OUTPUT_BMP:
-        WriteBmp(name.c_str(), i, buffer, stride, width, height);
-        break;
-
-      case OUTPUT_EMF:
-        WriteEmf(page, name.c_str(), i);
-        break;
-#endif
-      case OUTPUT_PNG:
-        WritePng(name.c_str(), i, buffer, stride, width, height);
-        break;
-
-      case OUTPUT_PPM:
-        WritePpm(name.c_str(), i, buffer, stride, width, height);
-        break;
-
-      default:
-        break;
-    }
-
-    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_ExitFormFillEnvironment(form);
   FPDF_CloseDocument(doc);
   FPDFAvail_Destroy(pdf_avail);
 
   fprintf(stderr, "Rendered %d pages.\n", rendered_pages);
   fprintf(stderr, "Skipped %d bad pages.\n", bad_pages);
 }
@@ skipping 75 matching lines @@
   }
 
   FPDF_DestroyLibrary();
 #ifdef PDF_ENABLE_V8
   v8::V8::ShutdownPlatform();
   delete platform;
 #endif  // PDF_ENABLE_V8
 
   return 0;
 }