//========================================================================
//
// SplashBitmap.cc
//
//========================================================================

//========================================================================
//
// Modified under the Poppler project - http://poppler.freedesktop.org
//
// All changes made under the Poppler project to this file are licensed
// under GPL version 2 or later
//
// Copyright (C) 2006, 2009, 2010, 2012, 2015, 2018 Albert Astals Cid <aacid@kde.org>
// Copyright (C) 2007 Ilmari Heikkinen <ilmari.heikkinen@gmail.com>
// Copyright (C) 2009 Shen Liang <shenzhuxi@gmail.com>
// Copyright (C) 2009 Stefan Thomas <thomas@eload24.com>
// Copyright (C) 2010, 2012, 2017 Adrian Johnson <ajohnson@redneon.com>
// Copyright (C) 2010 Harry Roberts <harry.roberts@midnight-labs.org>
// Copyright (C) 2010 Christian Feuersänger <cfeuersaenger@googlemail.com>
// Copyright (C) 2010, 2015, 2019 William Bader <williambader@hotmail.com>
// Copyright (C) 2011-2013 Thomas Freitag <Thomas.Freitag@alfa.de>
// Copyright (C) 2012 Anthony Wesley <awesley@smartnetworks.com.au>
// Copyright (C) 2015, 2018 Adam Reichold <adamreichold@myopera.com>
// Copyright (C) 2016 Kenji Uno <ku@digitaldolphins.jp>
// Copyright (C) 2018 Martin Packman <gzlist@googlemail.com>
// Copyright (C) 2019 Christian Persch <chpe@src.gnome.org>
// Copyright (C) 2019 Oliver Sander <oliver.sander@tu-dresden.de>
//
// To see a description of the changes please see the Changelog file that
// came with your tarball or type make ChangeLog if you are building from git
//
//========================================================================

#include <config.h>

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <limits.h>
#include "goo/gfile.h"
#include "goo/gmem.h"
#include "SplashErrorCodes.h"
#include "SplashBitmap.h"
#include "poppler/Error.h"
#include "goo/JpegWriter.h"
#include "goo/PNGWriter.h"
#include "goo/TiffWriter.h"
#include "goo/ImgWriter.h"

//------------------------------------------------------------------------
// SplashBitmap
//------------------------------------------------------------------------

SplashBitmap::SplashBitmap(int widthA, int heightA, int rowPadA,
			   SplashColorMode modeA, bool alphaA,
			   bool topDown, std::vector<GfxSeparationColorSpace*> *separationListA) {
  width = widthA;
  height = heightA;
  mode = modeA;
  rowPad = rowPadA;
  switch (mode) {
  case splashModeMono1:
    if (width > 0) {
      rowSize = (width + 7) >> 3;
    } else {
      rowSize = -1;
    }
    break;
  case splashModeMono8:
    if (width > 0) {
      rowSize = width;
    } else {
      rowSize = -1;
    }
    break;
  case splashModeRGB8:
  case splashModeBGR8:
    if (width > 0 && width <= INT_MAX / 3) {
      rowSize = width * 3;
    } else {
      rowSize = -1;
    }
    break;
  case splashModeXBGR8:
    if (width > 0 && width <= INT_MAX / 4) {
      rowSize = width * 4;
    } else {
      rowSize = -1;
    }
    break;
#ifdef SPLASH_CMYK
  case splashModeCMYK8:
    if (width > 0 && width <= INT_MAX / 4) {
      rowSize = width * 4;
    } else {
      rowSize = -1;
    }
    break;
  case splashModeDeviceN8:
    if (width > 0 && width <= INT_MAX / 4) {
      rowSize = width * (SPOT_NCOMPS + 4);
    } else {
      rowSize = -1;
    }
    break;
#endif
  }
  if (rowSize > 0) {
    rowSize += rowPad - 1;
    rowSize -= rowSize % rowPad;
  }
  data = (SplashColorPtr)gmallocn_checkoverflow(rowSize, height);
  if (data != nullptr) {
    if (!topDown) {
      data += (height - 1) * rowSize;
      rowSize = -rowSize;
    }
    if (alphaA) {
      alpha = (unsigned char *)gmallocn(width, height);
    } else {
      alpha = nullptr;
    }
  } else {
    alpha = nullptr;
  }
  separationList = new std::vector<GfxSeparationColorSpace*>();
  if (separationListA != nullptr)
    for (std::size_t i = 0; i < separationListA->size(); i++)
      separationList->push_back((GfxSeparationColorSpace*)( (*separationListA)[i])->copy());
}

SplashBitmap *SplashBitmap::copy(SplashBitmap *src) {
  SplashBitmap *result = new SplashBitmap(src->getWidth(), src->getHeight(), src->getRowPad(), 
    src->getMode(), src->getAlphaPtr() != nullptr, src->getRowSize() >= 0, src->getSeparationList());
  unsigned char *dataSource = src->getDataPtr();
  unsigned char *dataDest = result->getDataPtr();
  int amount = src->getRowSize();
  if (amount < 0) {
    dataSource = dataSource + (src->getHeight() - 1) * amount;
    dataDest = dataDest + (src->getHeight() - 1) * amount;
    amount *= -src->getHeight();
  } else {
    amount *= src->getHeight();
  }
  memcpy(dataDest, dataSource, amount);
  if (src->getAlphaPtr() != nullptr) {
    memcpy(result->getAlphaPtr(), src->getAlphaPtr(), src->getWidth() * src->getHeight());
  }
  return result;
}

SplashBitmap::~SplashBitmap() {
  if (data) {
    if (rowSize < 0) {
      gfree(data + (height - 1) * rowSize);
    } else {
      gfree(data);
    }
  }
  gfree(alpha);
  for (auto entry : *separationList) {
    delete entry;
  }
  delete separationList;
}


SplashError SplashBitmap::writePNMFile(char *fileName) {
  FILE *f;
  SplashError e;

  if (!(f = openFile(fileName, "wb"))) {
    return splashErrOpenFile;
  }

  e = this->writePNMFile(f);
  
  fclose(f);
  return e;
}


SplashError SplashBitmap::writePNMFile(FILE *f) {
  SplashColorPtr row, p;
  int x, y;

  switch (mode) {

  case splashModeMono1:
    fprintf(f, "P4\n%d %d\n", width, height);
    row = data;
    for (y = 0; y < height; ++y) {
      p = row;
      for (x = 0; x < width; x += 8) {
	fputc(*p ^ 0xff, f);
	++p;
      }
      row += rowSize;
    }
    break;

  case splashModeMono8:
    fprintf(f, "P5\n%d %d\n255\n", width, height);
    row = data;
    for (y = 0; y < height; ++y) {
      fwrite(row, 1, width, f);
      row += rowSize;
    }
    break;

  case splashModeRGB8:
    fprintf(f, "P6\n%d %d\n255\n", width, height);
    row = data;
    for (y = 0; y < height; ++y) {
      fwrite(row, 1, 3 * width, f);
      row += rowSize;
    }
    break;

  case splashModeXBGR8:
    fprintf(f, "P6\n%d %d\n255\n", width, height);
    row = data;
    for (y = 0; y < height; ++y) {
      p = row;
      for (x = 0; x < width; ++x) {
	fputc(splashBGR8R(p), f);
	fputc(splashBGR8G(p), f);
	fputc(splashBGR8B(p), f);
	p += 4;
      }
      row += rowSize;
    }
    break;


  case splashModeBGR8:
    fprintf(f, "P6\n%d %d\n255\n", width, height);
    row = data;
    for (y = 0; y < height; ++y) {
      p = row;
      for (x = 0; x < width; ++x) {
	fputc(splashBGR8R(p), f);
	fputc(splashBGR8G(p), f);
	fputc(splashBGR8B(p), f);
	p += 3;
      }
      row += rowSize;
    }
    break;

#ifdef SPLASH_CMYK
  case splashModeCMYK8:
  case splashModeDeviceN8:
    // PNM doesn't support CMYK
    error(errInternal, -1, "unsupported SplashBitmap mode");
    return splashErrGeneric;
    break;
#endif
  }
  return splashOk;
}

SplashError SplashBitmap::writeAlphaPGMFile(char *fileName) {
  FILE *f;

  if (!alpha) {
    return splashErrModeMismatch;
  }
  if (!(f = openFile(fileName, "wb"))) {
    return splashErrOpenFile;
  }
  fprintf(f, "P5\n%d %d\n255\n", width, height);
  fwrite(alpha, 1, width * height, f);
  fclose(f);
  return splashOk;
}

void SplashBitmap::getPixel(int x, int y, SplashColorPtr pixel) {
  SplashColorPtr p;

  if (y < 0 || y >= height || x < 0 || x >= width || !data) {
    return;
  }
  switch (mode) {
  case splashModeMono1:
    p = &data[y * rowSize + (x >> 3)];
    pixel[0] = (p[0] & (0x80 >> (x & 7))) ? 0xff : 0x00;
    break;
  case splashModeMono8:
    p = &data[y * rowSize + x];
    pixel[0] = p[0];
    break;
  case splashModeRGB8:
    p = &data[y * rowSize + 3 * x];
    pixel[0] = p[0];
    pixel[1] = p[1];
    pixel[2] = p[2];
    break;
  case splashModeXBGR8:
    p = &data[y * rowSize + 4 * x];
    pixel[0] = p[2];
    pixel[1] = p[1];
    pixel[2] = p[0];
    pixel[3] = p[3];
    break;
  case splashModeBGR8:
    p = &data[y * rowSize + 3 * x];
    pixel[0] = p[2];
    pixel[1] = p[1];
    pixel[2] = p[0];
    break;
#ifdef SPLASH_CMYK
  case splashModeCMYK8:
    p = &data[y * rowSize + 4 * x];
    pixel[0] = p[0];
    pixel[1] = p[1];
    pixel[2] = p[2];
    pixel[3] = p[3];
    break;
  case splashModeDeviceN8:
    p = &data[y * rowSize + (SPOT_NCOMPS + 4) * x];
    for (int cp = 0; cp < SPOT_NCOMPS + 4; cp++)
      pixel[cp] = p[cp];
    break;
#endif
  }
}

unsigned char SplashBitmap::getAlpha(int x, int y) {
  return alpha[y * width + x];
}

SplashColorPtr SplashBitmap::takeData() {
  SplashColorPtr data2;

  data2 = data;
  data = nullptr;
  return data2;
}

SplashError SplashBitmap::writeImgFile(SplashImageFileFormat format, const char *fileName, int hDPI, int vDPI, WriteImgParams* params) {
  FILE *f;
  SplashError e;

  if (!(f = openFile(fileName, "wb"))) {
    return splashErrOpenFile;
  }

  e = writeImgFile(format, f, hDPI, vDPI, params);

  fclose(f);
  return e;
}

void SplashBitmap::setJpegParams(ImgWriter *writer, WriteImgParams* params)
{
#ifdef ENABLE_LIBJPEG
  if (params) {
    static_cast<JpegWriter*>(writer)->setProgressive(params->jpegProgressive);
    static_cast<JpegWriter*>(writer)->setOptimize(params->jpegOptimize);
    if (params->jpegQuality >= 0)
      static_cast<JpegWriter*>(writer)->setQuality(params->jpegQuality);
  }
#endif
}

SplashError SplashBitmap::writeImgFile(SplashImageFileFormat format, FILE *f, int hDPI, int vDPI, WriteImgParams* params) {
  ImgWriter *writer;
	SplashError e;
  
  SplashColorMode imageWriterFormat = splashModeRGB8;

  switch (format) {
    #ifdef ENABLE_LIBPNG
    case splashFormatPng:
	  writer = new PNGWriter();
      break;
    #endif

    #ifdef ENABLE_LIBJPEG
    #ifdef SPLASH_CMYK
    case splashFormatJpegCMYK:
      writer = new JpegWriter(JpegWriter::CMYK);
      setJpegParams(writer, params);
      break;
    #endif
    case splashFormatJpeg:
      writer = new JpegWriter();
      setJpegParams(writer, params);
      break;
    #endif
	
    #ifdef ENABLE_LIBTIFF
    case splashFormatTiff:
      switch (mode) {
      case splashModeMono1:
        writer = new TiffWriter(TiffWriter::MONOCHROME);
        imageWriterFormat = splashModeMono1;
        break;
      case splashModeMono8:
        writer = new TiffWriter(TiffWriter::GRAY);
        imageWriterFormat = splashModeMono8;
        break;
      case splashModeRGB8:
      case splashModeBGR8:
        writer = new TiffWriter(TiffWriter::RGB);
        break;
#ifdef SPLASH_CMYK
      case splashModeCMYK8:
      case splashModeDeviceN8:
        writer = new TiffWriter(TiffWriter::CMYK);
        break;
#endif
      default:
        fprintf(stderr, "TiffWriter: Mode %d not supported\n", mode);
        writer = new TiffWriter();
      }
      if (writer && params) {
        ((TiffWriter *)writer)->setCompressionString(params->tiffCompression.c_str());
      }
      break;
    #endif

    default:
      // Not the greatest error message, but users of this function should
      // have already checked whether their desired format is compiled in.
      error(errInternal, -1, "Support for this image type not compiled in");
      return splashErrGeneric;
  }

	e = writeImgFile(writer, f, hDPI, vDPI, imageWriterFormat);
	delete writer;
	return e;
}

#include "poppler/GfxState_helpers.h"

void SplashBitmap::getRGBLine(int yl, SplashColorPtr line) {
  SplashColor col;
  double c, m, y, k, c1, m1, y1, k1, r, g, b;

  for (int x = 0; x < width; x++) {
    getPixel(x, yl, col);
    c = byteToDbl(col[0]);
    m = byteToDbl(col[1]);
    y = byteToDbl(col[2]);
    k = byteToDbl(col[3]);
#ifdef SPLASH_CMYK
    if (separationList->size() > 0) {
      for (std::size_t i = 0; i < separationList->size(); i++) {
        if (col[i+4] > 0) {
          GfxCMYK cmyk;
          GfxColor input;
          input.c[0] = byteToCol(col[i+4]);
          GfxSeparationColorSpace *sepCS = (GfxSeparationColorSpace *)((*separationList)[i]);
          sepCS->getCMYK(&input, &cmyk);
          col[0] = colToByte(cmyk.c);
          col[1] = colToByte(cmyk.m);
          col[2] = colToByte(cmyk.y);
          col[3] = colToByte(cmyk.k);
          c += byteToDbl(col[0]);
          m += byteToDbl(col[1]);
          y += byteToDbl(col[2]);
          k += byteToDbl(col[3]);
        }
      }
      if (c > 1) c = 1;
      if (m > 1) m = 1;
      if (y > 1) y = 1;
      if (k > 1) k = 1;
    }
#endif
    c1 = 1 - c;
    m1 = 1 - m;
    y1 = 1 - y;
    k1 = 1 - k;
    cmykToRGBMatrixMultiplication(c, m, y, k, c1, m1, y1, k1, r, g, b);
    *line++ = dblToByte(clip01(r));
    *line++ = dblToByte(clip01(g));
    *line++ = dblToByte(clip01(b));
  }
}

void SplashBitmap::getXBGRLine(int yl, SplashColorPtr line, ConversionMode conversionMode) {
  SplashColor col;
  double c, m, y, k, c1, m1, y1, k1, r, g, b;

  for (int x = 0; x < width; x++) {
    getPixel(x, yl, col);
    c = byteToDbl(col[0]);
    m = byteToDbl(col[1]);
    y = byteToDbl(col[2]);
    k = byteToDbl(col[3]);
#ifdef SPLASH_CMYK
    if (separationList->size() > 0) {
      for (std::size_t i = 0; i < separationList->size(); i++) {
        if (col[i+4] > 0) {
          GfxCMYK cmyk;
          GfxColor input;
          input.c[0] = byteToCol(col[i+4]);
          GfxSeparationColorSpace *sepCS = (GfxSeparationColorSpace *)((*separationList)[i]);
          sepCS->getCMYK(&input, &cmyk);
          col[0] = colToByte(cmyk.c);
          col[1] = colToByte(cmyk.m);
          col[2] = colToByte(cmyk.y);
          col[3] = colToByte(cmyk.k);
          c += byteToDbl(col[0]);
          m += byteToDbl(col[1]);
          y += byteToDbl(col[2]);
          k += byteToDbl(col[3]);
        }
      }
      if (c > 1) c = 1;
      if (m > 1) m = 1;
      if (y > 1) y = 1;
      if (k > 1) k = 1;
    }
#endif
    c1 = 1 - c;
    m1 = 1 - m;
    y1 = 1 - y;
    k1 = 1 - k;
    cmykToRGBMatrixMultiplication(c, m, y, k, c1, m1, y1, k1, r, g, b);

    if (conversionMode == conversionAlphaPremultiplied) {
        const double a = getAlpha(x, yl) / 255.0;

        *line++ = dblToByte(clip01(b * a));
        *line++ = dblToByte(clip01(g * a));
        *line++ = dblToByte(clip01(r * a));
    } else {
        *line++ = dblToByte(clip01(b));
        *line++ = dblToByte(clip01(g));
        *line++ = dblToByte(clip01(r));
    }

    if (conversionMode != conversionOpaque) {
        *line++ = getAlpha(x, yl);
    } else {
        *line++ = 255;
    }
  }
}

static inline unsigned char div255(int x) {
  return (unsigned char)((x + (x >> 8) + 0x80) >> 8);
}

bool SplashBitmap::convertToXBGR(ConversionMode conversionMode) {
  if (mode == splashModeXBGR8) {
    if (conversionMode != conversionOpaque) {
      // Copy the alpha channel into the fourth component so that XBGR becomes ABGR.
      const SplashColorPtr dbegin = data;
      const SplashColorPtr dend = data + rowSize * height;

      unsigned char *const abegin = alpha;
      unsigned char *const aend = alpha + width * height;

      SplashColorPtr d = dbegin;
      unsigned char *a = abegin;

      if (conversionMode == conversionAlphaPremultiplied) {
          for (; d < dend && a < aend; d += 4, a += 1) {
              d[0] = div255(d[0] * *a);
              d[1] = div255(d[1] * *a);
              d[2] = div255(d[2] * *a);
              d[3] = *a;
          }
      } else {
          for (d += 3; d < dend && a < aend; d += 4, a += 1) {
              *d = *a;
          }
      }
    }

    return true;
  }
  
  int newrowSize = width * 4;
  SplashColorPtr newdata = (SplashColorPtr)gmallocn_checkoverflow(newrowSize, height);
  if (newdata != nullptr) {
    for (int y = 0; y < height; y++) {
      unsigned char *row = newdata + y * newrowSize;
      getXBGRLine(y, row, conversionMode);
    }
    if (rowSize < 0) {
      gfree(data + (height - 1) * rowSize);
    } else {
      gfree(data);
    }
    data = newdata;
    rowSize = newrowSize;
    mode = splashModeXBGR8;
  }
  return newdata != nullptr;
}

#ifdef SPLASH_CMYK
void SplashBitmap::getCMYKLine(int yl, SplashColorPtr line) {
  SplashColor col;

  for (int x = 0; x < width; x++) {
    getPixel(x, yl, col);
    if (separationList->size() > 0) {
      double c, m, y, k;
      c = byteToDbl(col[0]);
      m = byteToDbl(col[1]);
      y = byteToDbl(col[2]);
      k = byteToDbl(col[3]);
      for (std::size_t i = 0; i < separationList->size(); i++) {
        if (col[i+4] > 0) {
          GfxCMYK cmyk;
          GfxColor input;
          input.c[0] = byteToCol(col[i+4]);
          GfxSeparationColorSpace *sepCS = (GfxSeparationColorSpace *)((*separationList)[i]);
          sepCS->getCMYK(&input, &cmyk);
          col[0] = colToByte(cmyk.c);
          col[1] = colToByte(cmyk.m);
          col[2] = colToByte(cmyk.y);
          col[3] = colToByte(cmyk.k);
          c += byteToDbl(col[0]);
          m += byteToDbl(col[1]);
          y += byteToDbl(col[2]);
          k += byteToDbl(col[3]);
        }
      }
      col[0] = dblToByte(clip01(c));
      col[1] = dblToByte(clip01(m));
      col[2] = dblToByte(clip01(y));
      col[3] = dblToByte(clip01(k));
    }
    *line++ = col[0];
    *line++ = col[1];
    *line++ = col[2];
    *line++ = col[3];
  }
}
#endif

SplashError SplashBitmap::writeImgFile(ImgWriter *writer, FILE *f, int hDPI, int vDPI, SplashColorMode imageWriterFormat) {
  if (mode != splashModeRGB8 && mode != splashModeMono8 && mode != splashModeMono1 && mode != splashModeXBGR8 && mode != splashModeBGR8
#ifdef SPLASH_CMYK
      && mode != splashModeCMYK8 && mode != splashModeDeviceN8
#endif
     ) {
    error(errInternal, -1, "unsupported SplashBitmap mode");
    return splashErrGeneric;
  }

  if (!writer->init(f, width, height, hDPI, vDPI)) {
    return splashErrGeneric;
  }

  switch (mode) {
#ifdef SPLASH_CMYK
    case splashModeCMYK8:
      if (writer->supportCMYK()) {
        SplashColorPtr row;
        unsigned char **row_pointers = new unsigned char*[height];
        row = data;

        for (int y = 0; y < height; ++y) {
          row_pointers[y] = row;
          row += rowSize;
        }
        if (!writer->writePointers(row_pointers, height)) {
          delete[] row_pointers;
          return splashErrGeneric;
        }
        delete[] row_pointers;
      } else {
        unsigned char *row = new unsigned char[3 * width];
        for (int y = 0; y < height; y++) {
          getRGBLine(y, row);
          if (!writer->writeRow(&row)) {
            delete[] row;
            return splashErrGeneric;
          }
        }
        delete[] row;
      }
    break;
    case splashModeDeviceN8:
      if (writer->supportCMYK()) {
        unsigned char *row = new unsigned char[4 * width];
        for (int y = 0; y < height; y++) {
          getCMYKLine(y, row);
          if (!writer->writeRow(&row)) {
            delete[] row;
            return splashErrGeneric;
          }
        }
        delete[] row;
      } else {
        unsigned char *row = new unsigned char[3 * width];
        for (int y = 0; y < height; y++) {
          getRGBLine(y, row);
          if (!writer->writeRow(&row)) {
            delete[] row;
            return splashErrGeneric;
          }
        }
        delete[] row;
      }
    break;
#endif
    case splashModeRGB8:
    {
      SplashColorPtr row;
      unsigned char **row_pointers = new unsigned char*[height];
      row = data;

      for (int y = 0; y < height; ++y) {
        row_pointers[y] = row;
        row += rowSize;
      }
      if (!writer->writePointers(row_pointers, height)) {
        delete[] row_pointers;
        return splashErrGeneric;
      }
      delete[] row_pointers;
    }
    break;
    
    case splashModeBGR8:
    {
      unsigned char *row = new unsigned char[3 * width];
      for (int y = 0; y < height; y++) {
        // Convert into a PNG row
        for (int x = 0; x < width; x++) {
          row[3*x] = data[y * rowSize + x * 3 + 2];
          row[3*x+1] = data[y * rowSize + x * 3 + 1];
          row[3*x+2] = data[y * rowSize + x * 3];
        }

        if (!writer->writeRow(&row)) {
          delete[] row;
          return splashErrGeneric;
        }
      }
      delete[] row;
    }
    break;
    
    case splashModeXBGR8:
    {
      unsigned char *row = new unsigned char[3 * width];
      for (int y = 0; y < height; y++) {
        // Convert into a PNG row
        for (int x = 0; x < width; x++) {
          row[3*x] = data[y * rowSize + x * 4 + 2];
          row[3*x+1] = data[y * rowSize + x * 4 + 1];
          row[3*x+2] = data[y * rowSize + x * 4];
        }

        if (!writer->writeRow(&row)) {
          delete[] row;
          return splashErrGeneric;
        }
      }
      delete[] row;
    }
    break;
    
    case splashModeMono8:
    {
      if (imageWriterFormat == splashModeMono8) {
        SplashColorPtr row;
        unsigned char **row_pointers = new unsigned char*[height];
        row = data;

        for (int y = 0; y < height; ++y) {
          row_pointers[y] = row;
          row += rowSize;
        }
        if (!writer->writePointers(row_pointers, height)) {
          delete[] row_pointers;
          return splashErrGeneric;
        }
        delete[] row_pointers;
      } else if (imageWriterFormat == splashModeRGB8) {
        unsigned char *row = new unsigned char[3 * width];
        for (int y = 0; y < height; y++) {
          // Convert into a PNG row
          for (int x = 0; x < width; x++) {
            row[3*x] = data[y * rowSize + x];
            row[3*x+1] = data[y * rowSize + x];
            row[3*x+2] = data[y * rowSize + x];
          }

          if (!writer->writeRow(&row)) {
            delete[] row;
            return splashErrGeneric;
          }
        }
        delete[] row;
      }
      else {
        // only splashModeMono8 or splashModeRGB8
        return splashErrGeneric;
      }
    }
    break;
    
    case splashModeMono1:
    {
      if (imageWriterFormat == splashModeMono1) {
        SplashColorPtr row;
        unsigned char **row_pointers = new unsigned char*[height];
        row = data;

        for (int y = 0; y < height; ++y) {
          row_pointers[y] = row;
          row += rowSize;
        }
        if (!writer->writePointers(row_pointers, height)) {
          delete[] row_pointers;
          return splashErrGeneric;
        }
        delete[] row_pointers;
      } else if (imageWriterFormat == splashModeRGB8) {
        unsigned char *row = new unsigned char[3 * width];
        for (int y = 0; y < height; y++) {
          // Convert into a PNG row
          for (int x = 0; x < width; x++) {
            getPixel(x, y, &row[3*x]);
            row[3*x+1] = row[3*x];
            row[3*x+2] = row[3*x];
          }

          if (!writer->writeRow(&row)) {
            delete[] row;
            return splashErrGeneric;
          }
        }
        delete[] row;
      }
      else {
        // only splashModeMono1 or splashModeRGB8
        return splashErrGeneric;
      }
    }
    break;
    
    default:
    // can't happen
    break;
  }
  
  if (!writer->close()) {
    return splashErrGeneric;
  }

  return splashOk;
}