winamp/Src/png/PNGWriter.cpp

#include "PNGWriter.h"
#include "api__png.h"
#include <png.h>
#include <wchar.h>
#include <bfc/platform/strcmp.h>


// valid items include "quality" for jpeg files with value "0" to "100"
// return value is 1 if the config item is supported, 0 if it is not.
int PNGWriter::setConfig(const wchar_t * item, const wchar_t * value) {
	return 0; // no config yet
}

// valid items include "quality" for jpeg files with value "0" to "100", "lossless" returns "1" if it is "0" otherwise
// return value is 1 if the config item is supported, 0 if it is not.
int PNGWriter::getConfig(const wchar_t * item, wchar_t * value, int valuelen) {
	if(!_wcsicmp(item,L"lossless")) lstrcpynW(value,L"1",valuelen);
	else return 0;
	return 1;
}

typedef struct {
	BYTE * data;
	unsigned int len;
	unsigned int alloc;
} pngWrite;

extern "C" static void PNGAPI png_write(png_structp png_ptr, png_bytep data, png_size_t len) {
	pngWrite * p = (pngWrite *)png_get_io_ptr(png_ptr);
	while (len + p->len > p->alloc) { // allocate more memory
		int d = ((p->alloc / 4) & 0xffffff00) + 0x100;
		if(d < 4096) d = 4096;
		p->alloc+=d;
		p->data = (BYTE*)WASABI_API_MEMMGR->sysRealloc(p->data,p->alloc);
	}
	memcpy(p->data+p->len,data,len);
	p->len += int(len);
}

extern "C" static void PNGAPI png_flush(png_structp png_ptr) {}

// returns 1 if the bit depth is supported (eg 32 for ARGB32, 24 for RGB24)
// ARGB32 MUST be supported
int PNGWriter::bitDepthSupported(int depth) {
	if(depth == 32 || depth == 24) return 1;
	return 0;
}

// returns the image in our format, free the returned buffer with api_memmgr::sysFree()
void * PNGWriter::convert(const void *pixels0, int bitDepth, int w, int h, int *length) {
	if(bitDepth != 32 && bitDepth != 24) return 0;
	BYTE * pixels = (BYTE*)pixels0;
	png_structp png_ptr;
	png_infop info_ptr;


	/* Create and initialize the png_struct with the desired error handler
	 * functions.  If you want to use the default stderr and longjump method,
	 * you can supply NULL for the last three parameters.  We also check that
	 * the library version is compatible with the one used at compile time,
	 * in case we are using dynamically linked libraries.  REQUIRED.
	 */
	png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
		(png_voidp*)NULL, NULL, NULL);

	if (png_ptr == NULL)
		return 0;

	/* Allocate/initialize the image information data.  REQUIRED */
	info_ptr = png_create_info_struct(png_ptr);
	if (info_ptr == NULL)
	{
		png_destroy_write_struct(&png_ptr,  NULL);
		return 0;
	}
	pngWrite writer={0};

	/* Set error handling.  REQUIRED if you aren't supplying your own
	 * error handling functions in the png_create_write_struct() call.
	 */
	if (setjmp(png_jmpbuf(png_ptr)))
	{
		/* If we get here, we had a problem reading the file */
		png_destroy_write_struct(&png_ptr, &info_ptr);
		if(writer.data) WASABI_API_MEMMGR->sysFree(writer.data);
		return 0;
	}

	writer.alloc = (int(double(w*h)*1.25) & 0xffffff00) + 0x100;
	if (writer.alloc < 4096) writer.alloc = 4096;
	writer.data = (BYTE*)WASABI_API_MEMMGR->sysMalloc(writer.alloc);
	
	/* If you are using replacement read functions, instead of calling
	 * png_init_io() here you would call */
	png_set_write_fn(png_ptr, (void *)&writer, png_write,
		png_flush);

	/* Set the image information here.  Width and height are up to 2^31,
	 * bit_depth is one of 1, 2, 4, 8, or 16, but valid values also depend on
	 * the color_type selected. color_type is one of PNG_COLOR_TYPE_GRAY,
	 * PNG_COLOR_TYPE_GRAY_ALPHA, PNG_COLOR_TYPE_PALETTE, PNG_COLOR_TYPE_RGB,
	 * or PNG_COLOR_TYPE_RGB_ALPHA.  interlace is either PNG_INTERLACE_NONE or
	 * PNG_INTERLACE_ADAM7, and the compression_type and filter_type MUST
	 * currently be PNG_COMPRESSION_TYPE_BASE and PNG_FILTER_TYPE_BASE. REQUIRED
	 */
	int colortype = (bitDepth == 32) ? PNG_COLOR_TYPE_RGB_ALPHA : PNG_COLOR_TYPE_RGB;
	png_set_IHDR(png_ptr, info_ptr, w, h, 8, colortype,
		PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);

	/* optional significant bit chunk */
	png_color_8 sig_bit;
	/* if we are dealing with a grayscale image then */
	sig_bit.gray = 8;
	/* otherwise, if we are dealing with a color image then */
	sig_bit.red = 8;
	sig_bit.green = 8;
	sig_bit.blue = 8;
	/* if the image has an alpha channel then */
	sig_bit.alpha = (bitDepth==32)?8:0;
	png_set_sBIT(png_ptr, info_ptr, &sig_bit);

	/* Write the file header information.  REQUIRED */
	png_write_info(png_ptr, info_ptr);

	/* set up the transformations you want.  Note that these are
	 * all optional.  Only call them if you want them.
	 */

	/* invert monochrome pixels */
	png_set_invert_mono(png_ptr);

	/* Shift the pixels up to a legal bit depth and fill in
	 * as appropriate to correctly scale the image.
	 */
	png_set_shift(png_ptr, &sig_bit);

	/* pack pixels into bytes */
	png_set_packing(png_ptr);

	/* flip BGR pixels to RGB */
	png_set_bgr(png_ptr);

	/* swap bytes of 16-bit files to most significant byte first */
	png_set_swap(png_ptr);

	/* swap bits of 1, 2, 4 bit packed pixel formats */
	png_set_packswap(png_ptr);

	/*if (interlacing)
		number_passes = png_set_interlace_handling(png_ptr);
	else*/
	png_uint_32 number_passes = 1;

	/* The easiest way to write the image (you may have a different memory
	 * layout, however, so choose what fits your needs best).  You need to
	 * use the first method if you aren't handling interlacing yourself.
	 */
	int bytes_per_pixel = bitDepth / 8;

  /* The number of passes is either 1 for non-interlaced images,
   * or 7 for interlaced images.
   */
	for (png_uint_32 pass = 0; pass < number_passes; pass++)
	{
		BYTE * row = pixels; // + (h*w*bytes_per_pixel);
		for (int y = 0; y < h; y++) {
			//row -= w*bytes_per_pixel;
			png_write_rows(png_ptr, &row, 1);
			row += w*bytes_per_pixel;
		}
	}

	/* It is REQUIRED to call this to finish writing the rest of the file */
	png_write_end(png_ptr, info_ptr);

	/* clean up after the write, and free any memory allocated */
	png_destroy_write_struct(&png_ptr, &info_ptr);

	/* that's it */
	if(length) *length = writer.len;
	return writer.data;
}

#define CBCLASS PNGWriter
START_DISPATCH;
  CB(GETIMAGETYPENAME, getImageTypeName);
  CB(GETEXTENSIONS, getExtensions);
  CB(SETCONFIG, setConfig);
	CB(GETCONFIG, getConfig);
	CB(BITDEPTHSUPPORTED, bitDepthSupported);
	CB(CONVERT, convert);
END_DISPATCH;
#undef CBCLASS