Hi All,
For a project, I needed to modify the PNGWriter class to write the PNG
in memory and not in a file so I took the original PNGWriter classes and
did needed modifications (extending the class as is was not good enough
because of private members not accessible).
Will be nice to have a "unified" class capable to do both in memory and
file export, but some change are needed in the base class "ImgWriter"
too to have a clean implementation.
Attaching source in case someone like to have a took to it.
Cheers,
Daniele.
#include "MemoryPNGWriter.h"
#ifdef ENABLE_LIBPNG
#include "poppler/Error.h"
MemoryPNGWriter::MemoryPNGWriter(Format formatA) : format(formatA)
{
icc_data = NULL;
icc_data_size = 0;
icc_name = NULL;
sRGB_profile = false;
}
MemoryPNGWriter::~MemoryPNGWriter()
{
/* cleanup heap allocation */
png_destroy_write_struct(&png_ptr, &info_ptr);
if (icc_data)
{
gfree(icc_data);
free(icc_name);
}
}
void MemoryPNGWriter::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);
}
void MemoryPNGWriter::setSRGBProfile()
{
sRGB_profile = true;
}
void write_data_in_memory(png_structp png_ptr, png_bytep data, png_size_t length)
{
MemoryBuffer *memBuffer;
memBuffer=(MemoryBuffer *)png_get_io_ptr(png_ptr);
memBuffer->addData(data,length);
}
void flush_data_in_memory(png_structp png_ptr)
{
}
void MemoryBuffer::ensureBufferSpace(unsigned int len)
{
while (io_buffer_size-io_buffer_len<=len)
{
write_io_ptr=realloc(write_io_ptr , io_buffer_size + BUFFER_INCREASE);
io_buffer_size += BUFFER_INCREASE;
}
}
void MemoryBuffer::addData(voidp data,unsigned int len)
{
ensureBufferSpace(len);
memcpy((char*)write_io_ptr+io_buffer_len, data,len);
io_buffer_len+=len;
}
bool MemoryPNGWriter::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;
#else
png_const_bytep icc_data_ptr = (png_const_bytep)icc_data;
#endif
/* initialize stuff */
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (!png_ptr) {
error(errInternal, -1, "png_create_write_struct failed");
return false;
}
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
error(errInternal, -1, "png_create_info_struct failed");
return false;
}
if (setjmp(png_jmpbuf(png_ptr))) {
error(errInternal, -1, "png_jmpbuf failed");
return false;
}
// /* write header */
// png_init_io(png_ptr, f);
// if (setjmp(png_jmpbuf(png_ptr))) {
// error(errInternal, -1, "Error during writing header");
// return false;
// }
//IMPORTANT: we need to setup custom write function instead of png_init_io
png_set_write_fn(png_ptr,&memBuffer, write_data_in_memory, flush_data_in_memory);
// Set up the type of PNG image and the compression level
png_set_compression_level(png_ptr, Z_BEST_COMPRESSION);
// Silence silly gcc
png_byte bit_depth = -1;
png_byte color_type = -1;
switch (format) {
case RGB:
bit_depth = 8;
color_type = PNG_COLOR_TYPE_RGB;
break;
case RGBA:
bit_depth = 8;
color_type = PNG_COLOR_TYPE_RGB_ALPHA;
break;
case GRAY:
bit_depth = 8;
color_type = PNG_COLOR_TYPE_GRAY;
break;
case MONOCHROME:
bit_depth = 1;
color_type = PNG_COLOR_TYPE_GRAY;
break;
}
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_pHYs(png_ptr, info_ptr, hDPI, vDPI, 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);
png_write_info(png_ptr, info_ptr);
if (setjmp(png_jmpbuf(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);
return true;
}
bool MemoryPNGWriter::writePointers(unsigned char **rowPointers, int rowCount)
{
png_write_image(png_ptr, rowPointers);
/* write bytes */
if (setjmp(png_jmpbuf(png_ptr))) {
error(errInternal, -1, "Error during writing bytes");
return false;
}
return true;
}
bool MemoryPNGWriter::writeRow(unsigned char **row)
{
// Write the row to the file
png_write_rows(png_ptr, row, 1);
if (setjmp(png_jmpbuf(png_ptr))) {
error(errInternal, -1, "error during png row write");
return false;
}
return true;
}
bool MemoryPNGWriter::close()
{
/* end write */
png_write_end(png_ptr, info_ptr);
if (setjmp(png_jmpbuf(png_ptr))) {
error(errInternal, -1, "Error during end of write");
return false;
}
return true;
}
#endif
#ifndef PNGWRITER_H
#define PNGWRITER_H
#include <config.h>
#ifdef ENABLE_LIBPNG
#include <cstdio>
#include <png.h>
#include "goo/ImgWriter.h"
#include "goo/gmem.h"
#include <stdlib.h>
#define BUFFER_INCREASE (1024*1024)
/* NOTE: write_io_ptr need to be freed externally */
class MemoryBuffer
{
public:
MemoryBuffer()
{
write_io_ptr=NULL;
io_buffer_size=0;
io_buffer_len=0;
}
voidp getBuffer(){return write_io_ptr;};
void addData(voidp data,unsigned int len);
~MemoryBuffer()
{
// if (write_io_ptr != NULL)
// free(write_io_ptr);
}
unsigned int getLength(){return io_buffer_len;};
private:
void ensureBufferSpace(unsigned int len);
voidp write_io_ptr;
unsigned int io_buffer_size;
unsigned int io_buffer_len;
};
class MemoryPNGWriter : public ImgWriter
{
public:
/* RGB - 3 bytes/pixel
* RGBA - 4 bytes/pixel
* GRAY - 1 byte/pixel
* MONOCHROME - 1 byte/pixel. PNGWriter will bitpack to 8 pixels/byte
*/
enum Format { RGB, RGBA, GRAY, MONOCHROME };
MemoryPNGWriter(Format format = RGB);
~MemoryPNGWriter();
void setICCProfile(const char *name, unsigned char *data, int size);
void setSRGBProfile();
bool init(FILE *f, int width, int height, int hDPI, int vDPI);
bool writePointers(unsigned char **rowPointers, int rowCount);
bool writeRow(unsigned char **row);
MemoryBuffer *getMemoryBuffer(){return &memBuffer;}
bool close();
private:
png_structp png_ptr;
png_infop info_ptr;
MemoryBuffer memBuffer;
Format format;
unsigned char *icc_data;
int icc_data_size;
char *icc_name;
bool sRGB_profile;
};
#endif
#endif
_______________________________________________
poppler mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/poppler
