232 lines
6.6 KiB
C++
232 lines
6.6 KiB
C++
#include "PNGLoader.h"
|
|
#include "api__png.h"
|
|
#include <png.h>
|
|
#include <wchar.h>
|
|
#include <malloc.h>
|
|
#include <bfc/platform/strcmp.h>
|
|
#include <intsafe.h>
|
|
void premultiplyARGB32(ARGB32 *words, int nwords)
|
|
{
|
|
for (; nwords > 0; nwords--, words++) {
|
|
unsigned char *pixel = (unsigned char *)words;
|
|
unsigned int alpha = pixel[3];
|
|
if (alpha == 255) continue;
|
|
pixel[0] = (pixel[0] * alpha) >> 8; // blue
|
|
pixel[1] = (pixel[1] * alpha) >> 8; // green
|
|
pixel[2] = (pixel[2] * alpha) >> 8; // red
|
|
}
|
|
}
|
|
|
|
static bool StringEnds(const wchar_t *a, const wchar_t *b)
|
|
{
|
|
size_t aLen = wcslen(a);
|
|
size_t bLen = wcslen(b);
|
|
if (aLen < bLen) return false; // too short
|
|
if (!_wcsicmp(a + aLen- bLen, b))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
int PNGLoader::isMine(const wchar_t *filename)
|
|
{
|
|
if (filename && StringEnds(filename, L".PNG"))
|
|
return 1;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
const wchar_t *PNGLoader::mimeType()
|
|
{
|
|
return L"image/png";
|
|
}
|
|
|
|
int PNGLoader::getHeaderSize()
|
|
{
|
|
return 8;
|
|
}
|
|
|
|
int PNGLoader::testData(const void *data, int datalen) {
|
|
unsigned char *ptr = (unsigned char *)data;
|
|
return !png_sig_cmp(ptr, 0, datalen);
|
|
}
|
|
|
|
typedef struct {
|
|
const unsigned char *data;
|
|
size_t pos;
|
|
size_t datalen;
|
|
} my_read_info;
|
|
|
|
static void my_png_read_data(png_structp png_ptr, png_bytep data, png_size_t length) {
|
|
my_read_info *mri = (my_read_info *)png_get_io_ptr(png_ptr);
|
|
if (mri->datalen - mri->pos < length)
|
|
length = mri->datalen - mri->pos;
|
|
memmove(data, mri->data + mri->pos, length);
|
|
mri->pos += length;
|
|
}
|
|
|
|
ARGB32 *PNGLoader::loadImage(const void *data, int datalen, int *w, int *h, ifc_xmlreaderparams *params) {
|
|
int w0=0, h0=0;
|
|
|
|
ARGB32 *pixels = read_png(data, datalen, &w0, &h0, FALSE);
|
|
|
|
if (pixels == NULL) return NULL;
|
|
|
|
premultiplyARGB32(pixels, w0 * h0);
|
|
|
|
if(w) *w = w0;
|
|
if(h) *h = h0;
|
|
|
|
return pixels;
|
|
}
|
|
|
|
ARGB32 *PNGLoader::loadImageData(const void *data, int datalen, int *w, int *h, ifc_xmlreaderparams *params)
|
|
{
|
|
return read_png(data, datalen, w, h, FALSE);
|
|
}
|
|
|
|
int PNGLoader::getDimensions(const void *data, int datalen, int *w, int *h) {
|
|
return (read_png(data, datalen, w, h, TRUE) == reinterpret_cast<ARGB32*>(-1));
|
|
}
|
|
|
|
// From libpng example.c
|
|
ARGB32 *PNGLoader::read_png(const void *data, int datalen, int *w, int *h, int dimensions_only) {
|
|
png_structp png_ptr;
|
|
png_infop info_ptr;
|
|
png_uint_32 width, height;
|
|
int bit_depth, color_type, interlace_type;
|
|
my_read_info mri;
|
|
mri.data = static_cast<const unsigned char *>(data);
|
|
mri.pos = 0;
|
|
mri.datalen = datalen;
|
|
|
|
/* 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 supply the
|
|
* the compiler header file version, so that we know if the application
|
|
* was compiled with a compatible version of the library. REQUIRED
|
|
*/
|
|
png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
|
|
NULL, NULL, NULL);
|
|
|
|
if (png_ptr == NULL)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
/* Allocate/initialize the memory for image information. REQUIRED. */
|
|
info_ptr = png_create_info_struct(png_ptr);
|
|
if (info_ptr == NULL)
|
|
{
|
|
png_destroy_read_struct(&png_ptr, (png_infopp)NULL, (png_infopp)NULL);
|
|
return NULL;
|
|
}
|
|
|
|
/* Set error handling if you are using the setjmp/longjmp method (this is
|
|
* the normal method of doing things with libpng). REQUIRED unless you
|
|
* set up your own error handlers in the png_create_read_struct() earlier.
|
|
*/
|
|
if (setjmp(png_jmpbuf(png_ptr)))
|
|
{
|
|
/* Free all of the memory associated with the png_ptr and info_ptr */
|
|
png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
|
|
/* If we get here, we had a problem reading the file */
|
|
return NULL;
|
|
}
|
|
|
|
png_set_read_fn(png_ptr, &mri, my_png_read_data);
|
|
|
|
/* The call to png_read_info() gives us all of the information from the
|
|
* PNG file before the first IDAT (image data chunk). REQUIRED
|
|
*/
|
|
png_read_info(png_ptr, info_ptr);
|
|
|
|
png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
|
|
&interlace_type, NULL, NULL);
|
|
|
|
if (w) *w = (int)width;
|
|
if (h) *h = (int)height;
|
|
|
|
ARGB32 *retval = 0;
|
|
|
|
if (!dimensions_only) {
|
|
|
|
/* tell libpng to strip 16 bit/color files down to 8 bits/color */
|
|
if (bit_depth == 16) png_set_strip_16(png_ptr);
|
|
if (bit_depth < 8) png_set_packing(png_ptr);
|
|
|
|
/* flip the RGB pixels to BGR (or RGBA to BGRA) */
|
|
png_set_bgr(png_ptr);
|
|
|
|
/* Expand paletted colors into true RGB triplets */
|
|
if (color_type == PNG_COLOR_TYPE_PALETTE) png_set_expand(png_ptr);
|
|
|
|
/* Expand grayscale images to the full 8 bits from 1, 2, or 4 bits/pixel */
|
|
if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
|
|
png_set_expand(png_ptr);
|
|
|
|
png_set_gray_to_rgb(png_ptr);
|
|
|
|
/* Expand paletted or RGB images with transparency to full alpha channels
|
|
* so the data will be available as RGBA quartets.
|
|
*/
|
|
if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
|
|
png_set_expand(png_ptr);
|
|
}
|
|
|
|
/* Add filler (or alpha) byte (before/after each RGB triplet) */
|
|
png_set_filler(png_ptr, 0xff, PNG_FILLER_AFTER);
|
|
|
|
/* Optional call to gamma correct and add the background to the palette
|
|
* and update info structure. REQUIRED if you are expecting libpng to
|
|
* update the palette for you (ie you selected such a transform above).
|
|
*/
|
|
png_read_update_info(png_ptr, info_ptr);
|
|
|
|
/* Allocate the memory to hold the image using the fields of info_ptr. */
|
|
|
|
/* The easiest way to read the image: */
|
|
//row_pointers = (png_bytep*)malloc(sizeof(png_bytep*)*height);
|
|
size_t row_ptr_size = 0;
|
|
if (SizeTMult(sizeof(png_bytep*), height, &row_ptr_size) == S_OK)
|
|
{
|
|
png_bytep *row_pointers = (png_bytep*)alloca(row_ptr_size);
|
|
size_t image_size=0;
|
|
if (SizeTMult(width, height, &image_size) == S_OK && SizeTMult(image_size, 4, &image_size)== S_OK)
|
|
{
|
|
ARGB32 *bytes = (ARGB32 *)WASABI_API_MEMMGR->sysMalloc(image_size);
|
|
|
|
for (unsigned int row = 0; row < height; row++) {
|
|
row_pointers[row] = ((unsigned char *)bytes) + width * 4 * (row);
|
|
}
|
|
|
|
/* Now it's time to read the image. One of these methods is REQUIRED */
|
|
png_read_image(png_ptr, row_pointers);
|
|
|
|
/* read rest of file, and get additional chunks in info_ptr - REQUIRED */
|
|
png_read_end(png_ptr, info_ptr);
|
|
|
|
retval = bytes;
|
|
}
|
|
}
|
|
|
|
//free(row_pointers);
|
|
}
|
|
|
|
/* clean up after the read, and free any memory allocated - REQUIRED */
|
|
png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
|
|
|
|
/* that's it */
|
|
return retval;
|
|
}
|
|
|
|
#define CBCLASS PNGLoader
|
|
START_DISPATCH;
|
|
CB(ISMINE, isMine);
|
|
CB(MIMETYPE, mimeType);
|
|
CB(TESTDATA, testData);
|
|
CB(GETHEADERSIZE, getHeaderSize);
|
|
CB(GETDIMENSIONS, getDimensions);
|
|
CB(LOADIMAGE, loadImage);
|
|
CB(LOADIMAGEDATA, loadImageData);
|
|
END_DISPATCH;
|
|
#undef CBCLASS |