pngwriter: move #include <png.h> into .cc file

Move all the private data (including the libpng types) to a private class.

This requires HtmlOutputDev.cc to include <png.h> on its own (which is correct, since it uses the libpng API directly).

2 files changed, 60 insertions, 50 deletions

diff --git a/goo/PNGWriter.cc b/goo/PNGWriter.cc
index 63ef7c7d..1f35d8e0 100644
--- a/goo/PNGWriter.cc
+++ b/goo/PNGWriter.cc
@@ -24,78 +24,94 @@
 #include "poppler/Error.h"
 #include "goo/gmem.h"
 
-PNGWriter::PNGWriter(Format formatA) : format(formatA)
+#include <png.h>
+
+struct PNGWriterPrivate {
+  PNGWriter::Format format;
+  png_structp png_ptr;
+  png_infop info_ptr;
+  unsigned char *icc_data;
+  int icc_data_size;
+  char *icc_name;
+  bool sRGB_profile;
+};
+
+PNGWriter::PNGWriter(Format formatA)
 {
-  icc_data = NULL;
-  icc_data_size = 0;
-  icc_name = NULL;
-  sRGB_profile = false;
+  priv = new PNGWriterPrivate;
+  priv->format = formatA;
+  priv->icc_data = NULL;
+  priv->icc_data_size = 0;
+  priv->icc_name = NULL;
+  priv->sRGB_profile = false;
 }
 
 PNGWriter::~PNGWriter()
 {
   /* cleanup heap allocation */
-  png_destroy_write_struct(&png_ptr, &info_ptr);
-  if (icc_data) {
-    gfree(icc_data);
-    free(icc_name);
+  png_destroy_write_struct(&priv->png_ptr, &priv->info_ptr);
+  if (priv->icc_data) {
+    gfree(priv->icc_data);
+    free(priv->icc_name);
   }
+
+  delete priv;
 }
 
 void PNGWriter::setICCProfile(const char *name, unsigned char *data, int size)
 {
-  icc_data = (unsigned char *)gmalloc(size);
-  memcpy(icc_data, data, size);
-  icc_data_size = size;
-  icc_name = strdup(name);
+  priv->icc_data = (unsigned char *)gmalloc(size);
+  memcpy(priv->icc_data, data, size);
+  priv->icc_data_size = size;
+  priv->icc_name = strdup(name);
 }
 
 void PNGWriter::setSRGBProfile()
 {
-  sRGB_profile = true;
+  priv->sRGB_profile = true;
 }
 
 bool PNGWriter::init(FILE *f, int width, int height, int hDPI, int vDPI)
 {
   /* libpng changed the png_set_iCCP() prototype in 1.5.0 */
 #if PNG_LIBPNG_VER < 10500
-  png_charp icc_data_ptr = (png_charp)icc_data;
+  png_charp icc_data_ptr = (png_charp)priv->icc_data;
 #else
-  png_const_bytep icc_data_ptr = (png_const_bytep)icc_data;
+  png_const_bytep icc_data_ptr = (png_const_bytep)priv->icc_data;
 #endif
 
   /* initialize stuff */
-  png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
-  if (!png_ptr) {
+  priv->png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+  if (!priv->png_ptr) {
     error(errInternal, -1, "png_create_write_struct failed");
     return false;
   }
 
-  info_ptr = png_create_info_struct(png_ptr);
-  if (!info_ptr) {
+  priv->info_ptr = png_create_info_struct(priv->png_ptr);
+  if (!priv->info_ptr) {
     error(errInternal, -1, "png_create_info_struct failed");
     return false;
   }
 
-  if (setjmp(png_jmpbuf(png_ptr))) {
+  if (setjmp(png_jmpbuf(priv->png_ptr))) {
     error(errInternal, -1, "png_jmpbuf failed");
     return false;
   }
 
   /* write header */
-  png_init_io(png_ptr, f);
-  if (setjmp(png_jmpbuf(png_ptr))) {
+  png_init_io(priv->png_ptr, f);
+  if (setjmp(png_jmpbuf(priv->png_ptr))) {
     error(errInternal, -1, "Error during writing header");
     return false;
   }
 
   // Set up the type of PNG image and the compression level
-  png_set_compression_level(png_ptr, Z_BEST_COMPRESSION);
+  png_set_compression_level(priv->png_ptr, Z_BEST_COMPRESSION);
 
   // Silence silly gcc
   png_byte bit_depth = -1;
   png_byte color_type = -1;
-  switch (format) {
+  switch (priv->format) {
     case RGB:
       bit_depth = 8;
       color_type = PNG_COLOR_TYPE_RGB;
@@ -115,33 +131,33 @@ bool PNGWriter::init(FILE *f, int width, int height, int hDPI, int vDPI)
   }
   png_byte interlace_type = PNG_INTERLACE_NONE;
 
-  png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth, color_type, interlace_type, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+  png_set_IHDR(priv->png_ptr, priv->info_ptr, width, height, bit_depth, color_type, interlace_type, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
 
-  png_set_pHYs(png_ptr, info_ptr, hDPI/0.0254, vDPI/0.0254, PNG_RESOLUTION_METER);
+  png_set_pHYs(priv->png_ptr, priv->info_ptr, hDPI/0.0254, vDPI/0.0254, PNG_RESOLUTION_METER);
 
-  if (icc_data)
-    png_set_iCCP(png_ptr, info_ptr, icc_name, PNG_COMPRESSION_TYPE_BASE, icc_data_ptr, icc_data_size);
-  else if (sRGB_profile)
-    png_set_sRGB(png_ptr, info_ptr, PNG_sRGB_INTENT_RELATIVE);
+  if (priv->icc_data)
+    png_set_iCCP(priv->png_ptr, priv->info_ptr, priv->icc_name, PNG_COMPRESSION_TYPE_BASE, icc_data_ptr, priv->icc_data_size);
+  else if (priv->sRGB_profile)
+    png_set_sRGB(priv->png_ptr, priv->info_ptr, PNG_sRGB_INTENT_RELATIVE);
 
-  png_write_info(png_ptr, info_ptr);
-  if (setjmp(png_jmpbuf(png_ptr))) {
+  png_write_info(priv->png_ptr, priv->info_ptr);
+  if (setjmp(png_jmpbuf(priv->png_ptr))) {
     error(errInternal, -1, "error during writing png info bytes");
     return false;
   }
 
   // pack 1 pixel/byte rows into 8 pixels/byte
-  if (format == MONOCHROME)
-    png_set_packing(png_ptr);
+  if (priv->format == MONOCHROME)
+    png_set_packing(priv->png_ptr);
 
   return true;
 }
 
 bool PNGWriter::writePointers(unsigned char **rowPointers, int rowCount)
 {
-  png_write_image(png_ptr, rowPointers);
+  png_write_image(priv->png_ptr, rowPointers);
   /* write bytes */
-  if (setjmp(png_jmpbuf(png_ptr))) {
+  if (setjmp(png_jmpbuf(priv->png_ptr))) {
     error(errInternal, -1, "Error during writing bytes");
     return false;
   }
@@ -152,8 +168,8 @@ bool PNGWriter::writePointers(unsigned char **rowPointers, int rowCount)
 bool PNGWriter::writeRow(unsigned char **row)
 {
   // Write the row to the file
-  png_write_rows(png_ptr, row, 1);
-  if (setjmp(png_jmpbuf(png_ptr))) {
+  png_write_rows(priv->png_ptr, row, 1);
+  if (setjmp(png_jmpbuf(priv->png_ptr))) {
     error(errInternal, -1, "error during png row write");
     return false;
   }
@@ -164,8 +180,8 @@ bool PNGWriter::writeRow(unsigned char **row)
 bool PNGWriter::close()
 {
   /* end write */
-  png_write_end(png_ptr, info_ptr);
-  if (setjmp(png_jmpbuf(png_ptr))) {
+  png_write_end(priv->png_ptr, priv->info_ptr);
+  if (setjmp(png_jmpbuf(priv->png_ptr))) {
     error(errInternal, -1, "Error during end of write");
     return false;
   }
diff --git a/goo/PNGWriter.h b/goo/PNGWriter.h
index dc905d7d..67cd31e6 100644
--- a/goo/PNGWriter.h
+++ b/goo/PNGWriter.h
@@ -19,10 +19,10 @@
 
 #ifdef ENABLE_LIBPNG
 
-#include <cstdio>
-#include <png.h>
 #include "ImgWriter.h"
 
+class PNGWriterPrivate;
+
 class PNGWriter : public ImgWriter
 {
 public:
@@ -52,13 +52,7 @@ private:
   PNGWriter(const PNGWriter &other);
   PNGWriter& operator=(const PNGWriter &other);
 
-  Format format;
-  png_structp png_ptr;
-  png_infop info_ptr;
-  unsigned char *icc_data;
-  int icc_data_size;
-  char *icc_name;
-  bool sRGB_profile;
+  PNGWriterPrivate *priv;
 };
 
 #endif