Enhance pdf-create example

pdf-create now creates images with different color spaces and encoding
schemes and verifies them for data correctness.

examples/pdf-create.cc

@@ -1,7 +1,17 @@
+//
+// This is an example of creating a PDF file from scratch. It
+// illustrates use of several QPDF operations for creating objects and
+// streams. It also serves as an ullstration of how to use
+// StreamDataProvider with different types of filters.
+//
+
 #include <qpdf/QPDF.hh>
 #include <qpdf/QPDFWriter.hh>
 #include <qpdf/QPDFObjectHandle.hh>
 #include <qpdf/QUtil.hh>
+#include <qpdf/Pl_Buffer.hh>
+#include <qpdf/Pl_RunLength.hh>
+#include <qpdf/Pl_DCT.hh>
 #include <iostream>
 #include <string.h>
 #include <stdlib.h>
@@ -13,35 +23,112 @@ static char const* whoami = 0;
 class ImageProvider: public QPDFObjectHandle::StreamDataProvider
 {
   public:
-    ImageProvider(int width, int height);
+    ImageProvider(std::string const& color_space,
+                  std::string const& filter);
     virtual ~ImageProvider();
     virtual void provideStreamData(int objid, int generation,
 				   Pipeline* pipeline);
+    int getWidth() const;
+    int getHeight() const;
 
   private:
     int width;
-    int height;
+    int stripe_height;
+    std::string color_space;
+    std::string filter;
+    int n_stripes;
+    std::vector<std::string> stripes;
+    J_COLOR_SPACE j_color_space;
 };
 
-ImageProvider::ImageProvider(int width, int height) :
-    width(width),
-    height(height)
+ImageProvider::ImageProvider(std::string const& color_space,
+                             std::string const& filter) :
+    width(400),
+    stripe_height(80),
+    color_space(color_space),
+    filter(filter),
+    n_stripes(6),
+    j_color_space(JCS_UNKNOWN)
 {
+    if (color_space == "/DeviceCMYK")
+    {
+        j_color_space = JCS_CMYK;
+        stripes.push_back(std::string("\xff\x00\x00\x00", 4));
+        stripes.push_back(std::string("\x00\xff\x00\x00", 4));
+        stripes.push_back(std::string("\x00\x00\xff\x00", 4));
+        stripes.push_back(std::string("\xff\x00\xff\x00", 4));
+        stripes.push_back(std::string("\xff\xff\x00\x00", 4));
+        stripes.push_back(std::string("\x00\x00\x00\xff", 4));
+    }
+    else if (color_space == "/DeviceRGB")
+    {
+        j_color_space = JCS_RGB;
+        stripes.push_back(std::string("\xff\x00\x00", 3));
+        stripes.push_back(std::string("\x00\xff\x00", 3));
+        stripes.push_back(std::string("\x00\x00\xff", 3));
+        stripes.push_back(std::string("\xff\x00\xff", 3));
+        stripes.push_back(std::string("\xff\xff\x00", 3));
+        stripes.push_back(std::string("\x00\x00\x00", 3));
+    }
+    else if (color_space == "/DeviceGray")
+    {
+        j_color_space = JCS_GRAYSCALE;
+        stripes.push_back(std::string("\xee", 1));
+        stripes.push_back(std::string("\xcc", 1));
+        stripes.push_back(std::string("\x99", 1));
+        stripes.push_back(std::string("\x66", 1));
+        stripes.push_back(std::string("\x33", 1));
+        stripes.push_back(std::string("\x00", 1));
+    }
 }
 
 ImageProvider::~ImageProvider()
 {
 }
 
+int
+ImageProvider::getWidth() const
+{
+    return width;
+}
+
+int
+ImageProvider::getHeight() const
+{
+    return stripe_height * n_stripes;
+}
+
 void
 ImageProvider::provideStreamData(int objid, int generation,
                                  Pipeline* pipeline)
 {
-    for (int i = 0; i < width * height; ++i)
+    std::vector<PointerHolder<Pipeline> > to_delete;
+    Pipeline* p = pipeline;
+
+    if (filter == "/DCTDecode")
     {
-        pipeline->write(QUtil::unsigned_char_pointer("\xff\x7f\x00"), 3);
+        p = new Pl_DCT(
+            "image encoder", pipeline,
+            width, getHeight(), stripes[0].length(), j_color_space);
+        to_delete.push_back(p);
     }
-    pipeline->finish();
+    else if (filter == "/RunLengthDecode")
+    {
+        p = new Pl_RunLength(
+            "image encoder", pipeline, Pl_RunLength::a_encode);
+        to_delete.push_back(p);
+    }
+
+    for (int i = 0; i < n_stripes; ++i)
+    {
+        for (int j = 0; j < width * stripe_height; ++j)
+        {
+            p->write(
+                QUtil::unsigned_char_pointer(stripes[i].c_str()),
+                stripes[i].length());
+        }
+    }
+    p->finish();
 }
 
 void usage()
@@ -56,8 +143,8 @@ static QPDFObjectHandle createPageContents(QPDF& pdf, std::string const& text)
     // Create a stream that displays our image and the given text in
     // our font.
     std::string contents =
-        "BT /F1 24 Tf 72 720 Td (" + text + ") Tj ET\n"
-        "q 144 0 0 144 234 324 cm /Im1 Do Q\n";
+        "BT /F1 24 Tf 72 320 Td (" + text + ") Tj ET\n"
+        "q 244 0 0 144 184 100 cm /Im1 Do Q\n";
     return QPDFObjectHandle::newStream(&pdf, contents);
 }
 
@@ -71,43 +158,34 @@ QPDFObjectHandle newInteger(int val)
     return QPDFObjectHandle::newInteger(val);
 }
 
-static void create_pdf(char const* filename)
+void add_page(QPDF& pdf, QPDFObjectHandle font,
+              std::string const& color_space,
+              std::string const& filter)
 {
-    QPDF pdf;
-
-    // Start with an empty PDF that has no pages or non-required objects.
-    pdf.emptyPDF();
-
-    // Add an indirect object to contain a font descriptor for the
-    // built-in Helvetica font.
-    QPDFObjectHandle font = pdf.makeIndirectObject(
-        QPDFObjectHandle::parse(
-            "<<"
-            " /Type /Font"
-            " /Subtype /Type1"
-            " /Name /F1"
-            " /BaseFont /Helvetica"
-            " /Encoding /WinAnsiEncoding"
-            ">>"));
-
-    // Create a stream to encode our image.  We don't have to set the
-    // length or filters.  QPDFWriter will fill in the length and
-    // compress the stream data using FlateDecode by default.
+    // Create a stream to encode our image. QPDFWriter will fill in
+    // the length and will respect our filters based on stream data
+    // mode. Since we are not specifying, QPDFWriter will compress
+    // with /FlateDecode if we don't provide any other form of
+    // compression.
+    ImageProvider* p = new ImageProvider(color_space, filter);
+    PointerHolder<QPDFObjectHandle::StreamDataProvider> provider(p);
+    int width = p->getWidth();
+    int height = p->getHeight();
     QPDFObjectHandle image = QPDFObjectHandle::newStream(&pdf);
     image.replaceDict(QPDFObjectHandle::parse(
                           "<<"
                           " /Type /XObject"
                           " /Subtype /Image"
-                          " /ColorSpace /DeviceRGB"
                           " /BitsPerComponent 8"
-                          " /Width 100"
-                          " /Height 100"
                           ">>"));
+    QPDFObjectHandle image_dict = image.getDict();
+    image_dict.replaceKey("/ColorSpace", newName(color_space));
+    image_dict.replaceKey("/Width", newInteger(width));
+    image_dict.replaceKey("/Height", newInteger(height));
+
     // Provide the stream data.
-    ImageProvider* p = new ImageProvider(100, 100);
-    PointerHolder<QPDFObjectHandle::StreamDataProvider> provider(p);
     image.replaceStreamData(provider,
-                            QPDFObjectHandle::newNull(),
+                            QPDFObjectHandle::parse(filter),
                             QPDFObjectHandle::newNull());
 
     // Create direct objects as needed by the page dictionary.
@@ -129,11 +207,11 @@ static void create_pdf(char const* filename)
     mediabox.appendItem(newInteger(0));
     mediabox.appendItem(newInteger(0));
     mediabox.appendItem(newInteger(612));
-    mediabox.appendItem(newInteger(792));
+    mediabox.appendItem(newInteger(392));
 
     // Create the page content stream
     QPDFObjectHandle contents = createPageContents(
-        pdf, "Look at the pretty, orange square!");
+        pdf, color_space + " with filter " + filter);
 
     // Create the page dictionary
     QPDFObjectHandle page = pdf.makeIndirectObject(
@@ -144,14 +222,191 @@ static void create_pdf(char const* filename)
     page.replaceKey("/Resources", resources);
 
     // Add the page to the PDF file
-    pdf.addPage(page, true);
+    pdf.addPage(page, false);
+}
+
+static void check(char const* filename,
+                  std::vector<std::string> const& color_spaces,
+                  std::vector<std::string> const& filters)
+{
+    // Each stream is compressed the way it is supposed to be. We will
+    // add additional tests in qpdf.test to exercise QPDFWriter more
+    // fully. In this case, we want to make sure that we actually have
+    // RunLengthDecode and DCTDecode where we are supposed to and
+    // FlateDecode where we provided no filters.
+
+    // Each image is correct. For non-lossy image compression, the
+    // uncompressed image data should exactly match what ImageProvider
+    // provided. For the DCTDecode data, allow for some fuzz to handle
+    // jpeg compression as well as its variance on different systems.
+
+    // These tests should use QPDFObjectHandle's stream data retrieval
+    // methods, but don't try to fully exercise them here. That is
+    // done elsewhere.
+
+    size_t n_color_spaces = color_spaces.size();
+    size_t n_filters = filters.size();
+
+    QPDF pdf;
+    pdf.processFile(filename);
+    std::vector<QPDFObjectHandle> const& pages = pdf.getAllPages();
+    if (n_color_spaces * n_filters != pages.size())
+    {
+        throw std::logic_error("incorrect number of pages");
+    }
+    size_t pageno = 1;
+    bool errors = false;
+    for (std::vector<QPDFObjectHandle>::const_iterator page_iter =
+             pages.begin();
+         page_iter != pages.end(); ++page_iter)
+    {
+        QPDFObjectHandle page = *page_iter;
+        std::map<std::string, QPDFObjectHandle> images = page.getPageImages();
+        if (images.size() != 1)
+        {
+            throw std::logic_error("incorrect number of images on page");
+        }
+
+        // Check filter and color space.
+        std::string desired_color_space =
+            color_spaces[(pageno - 1) / n_color_spaces];
+        std::string desired_filter =
+            filters[(pageno - 1) % n_filters];
+        // In the default mode, QPDFWriter will compress with
+        // /FlateDecode if no filters are provided.
+        if (desired_filter == "null")
+        {
+            desired_filter = "/FlateDecode";
+        }
+        QPDFObjectHandle image = images.begin()->second;
+        QPDFObjectHandle image_dict = image.getDict();
+        QPDFObjectHandle color_space = image_dict.getKey("/ColorSpace");
+        QPDFObjectHandle filter = image_dict.getKey("/Filter");
+        bool this_errors = false;
+        if (! (filter.isName() && (filter.getName() == desired_filter)))
+        {
+            this_errors = errors = true;
+            std::cout << "page " << pageno << ": expected filter "
+                      << desired_filter << "; actual filter = "
+                      << filter.unparse() << std::endl;
+        }
+        if (! (color_space.isName() &&
+               (color_space.getName() == desired_color_space)))
+        {
+            this_errors = errors = true;
+            std::cout << "page " << pageno << ": expected color space "
+                      << desired_color_space << "; actual color space = "
+                      << color_space.unparse() << std::endl;
+        }
+
+        if (! this_errors)
+        {
+            // Check image data
+            PointerHolder<Buffer> actual_data =
+                image.getStreamData(qpdf_dl_all);
+            ImageProvider* p = new ImageProvider(desired_color_space, "null");
+            PointerHolder<QPDFObjectHandle::StreamDataProvider> provider(p);
+            Pl_Buffer b_p("get image data");
+            provider->provideStreamData(0, 0, &b_p);
+            PointerHolder<Buffer> desired_data(b_p.getBuffer());
+
+            if (desired_data->getSize() != actual_data->getSize())
+            {
+                std::cout << "page " << pageno
+                          << ": image data length mismatch" << std::endl;
+                this_errors = errors = true;
+            }
+            else
+            {
+                // Compare bytes. For JPEG, allow a certain number of
+                // the bytes to be off desired by more than a given
+                // tolerance. Any of the samples may be a little off
+                // because of lossy compression, and around sharp
+                // edges, things can be quite off. For non-lossy
+                // compression, do not allow any tolerance.
+                unsigned char const* actual_bytes = actual_data->getBuffer();
+                unsigned char const* desired_bytes = desired_data->getBuffer();
+                size_t len = actual_data->getSize();
+                unsigned int mismatches = 0;
+                int tolerance = (
+                    desired_filter == "/DCTDecode" ? 10 : 0);
+                unsigned int threshold = (
+                    desired_filter == "/DCTDecode" ? len / 40 : 0);
+                for (size_t i = 0; i < len; ++i)
+                {
+                    int delta = actual_bytes[i] - desired_bytes[i];
+                    if ((delta > tolerance) || (delta < -tolerance))
+                    {
+                        ++mismatches;
+                    }
+                }
+                if (mismatches > threshold)
+                {
+                    std::cout << "page " << pageno
+                              << ": " << desired_color_space << ", "
+                              << desired_filter
+                              << ": mismatches: " << mismatches
+                              << " of " << len << std::endl;
+                    this_errors = errors = true;
+                }
+            }
+        }
+
+        ++pageno;
+    }
+    if (errors)
+    {
+        throw std::logic_error("errors found");
+    }
+    else
+    {
+        std::cout << "all checks passed" << std::endl;
+    }
+}
+
+static void create_pdf(char const* filename)
+{
+    QPDF pdf;
+
+    // Start with an empty PDF that has no pages or non-required objects.
+    pdf.emptyPDF();
+
+    // Add an indirect object to contain a font descriptor for the
+    // built-in Helvetica font.
+    QPDFObjectHandle font = pdf.makeIndirectObject(
+        QPDFObjectHandle::parse(
+            "<<"
+            " /Type /Font"
+            " /Subtype /Type1"
+            " /Name /F1"
+            " /BaseFont /Helvetica"
+            " /Encoding /WinAnsiEncoding"
+            ">>"));
+
+    std::vector<std::string> color_spaces;
+    color_spaces.push_back("/DeviceCMYK");
+    color_spaces.push_back("/DeviceRGB");
+    color_spaces.push_back("/DeviceGray");
+    std::vector<std::string> filters;
+    filters.push_back("null");
+    filters.push_back("/DCTDecode");
+    filters.push_back("/RunLengthDecode");
+    for (std::vector<std::string>::iterator c_iter = color_spaces.begin();
+         c_iter != color_spaces.end(); ++c_iter)
+    {
+        for (std::vector<std::string>::iterator f_iter = filters.begin();
+             f_iter != filters.end(); ++f_iter)
+        {
+            add_page(pdf, font, *c_iter, *f_iter);
+        }
+    }
 
-    // Write the results.  A real application would not call
-    // setStaticID here, but this example does it for the sake of its
-    // test suite.
     QPDFWriter w(pdf, filename);
-    w.setStaticID(true);    // for testing only
     w.write();
+
+    // For test suite, verify that everything is the way it is
+    // supposed to be.
+    check(filename, color_spaces, filters);
 }
 
 int main(int argc, char* argv[])

examples/qtest/create.test

@@ -13,15 +13,12 @@ my $td = new TestDriver('create');
 
 $td->runtest("create a simple PDF",
 	     {$td->COMMAND => "pdf-create a.pdf"},
-	     {$td->STRING => "", $td->EXIT_STATUS => 0});
-
-$td->runtest("check",
-	     {$td->FILE => "a.pdf"},
-	     {$td->FILE => "orange-square.pdf"});
+	     {$td->FILE => "create.out", $td->EXIT_STATUS => 0},
+             $td->NORMALIZE_NEWLINES);
 
 cleanup();
 
-$td->report(2);
+$td->report(1);
 
 sub cleanup
 {

examples/qtest/create/create.out

@@ -0,0 +1 @@
+all checks passed