image.cpp

/* SLiM - Simple Login Manager
   Copyright (C) 2004-06 Simone Rota <sip@varlock.com>
   Copyright (C) 2004-06 Johannes Winkelmann <jw@tks6.net>
   Copyright (C) 2012    Nobuhiro Iwamatsu <iwamatsu@nigauri.org>
      
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
   
   The following code has been adapted and extended from
   xplanet 1.0.1, Copyright (C) 2002-04 Hari Nair <hari@alumni.caltech.edu>
*/

#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>

using namespace std;

#include "image.h"

extern "C" {
    #include <jpeglib.h>
    #include <png.h>
}

Image::Image() : width(0), height(0), area(0),
rgb_data(NULL), png_alpha(NULL), quality_(80) {}

Image::Image(const int w, const int h, const unsigned char *rgb, const unsigned char *alpha) :
width(w), height(h), area(w*h), quality_(80) {
    width = w;
    height = h;
    area = w * h;

    rgb_data = (unsigned char *) malloc(3 * area);
    memcpy(rgb_data, rgb, 3 * area);

    if (alpha == NULL) {
        png_alpha = NULL;
    } else {
        png_alpha = (unsigned char *) malloc(area);
        memcpy(png_alpha, alpha, area);
    }
}

Image::~Image() {
    free(rgb_data);
    free(png_alpha);
}

bool
Image::Read(const char *filename) {
    char buf[4];
    unsigned char *ubuf = (unsigned char *) buf;
    int success = 0;

    FILE *file;
    file = fopen(filename, "rb");
    if (file == NULL)
        return(false);

    /* see what kind of file we have */

    fread(buf, 1, 4, file);
    fclose(file);

    if ((ubuf[0] == 0x89) && !strncmp("PNG", buf+1, 3)) {
        success = readPng(filename, &width, &height, &rgb_data, &png_alpha);
    }
    else if ((ubuf[0] == 0xff) && (ubuf[1] == 0xd8)){
        success = readJpeg(filename, &width, &height, &rgb_data);
    } else {
        fprintf(stderr, "Unknown image format\n");
        success = 0;
    }
    return(success == 1);
}

void
Image::Reduce(const int factor) {
    if (factor < 1)
        return;

    int scale = 1;
    for (int i = 0; i < factor; i++)
        scale *= 2;

    double scale2 = scale*scale;

    int w = width / scale;
    int h = height / scale;
    int new_area = w * h;

    unsigned char *new_rgb = (unsigned char *) malloc(3 * new_area);
    memset(new_rgb, 0, 3 * new_area);

    unsigned char *new_alpha = NULL;
    if (png_alpha != NULL) {
        new_alpha = (unsigned char *) malloc(new_area);
        memset(new_alpha, 0, new_area);
    }

    int ipos = 0;
    for (int j = 0; j < height; j++) {
        int js = j / scale;
        for (int i = 0; i < width; i++) {
            int is = i/scale;
            for (int k = 0; k < 3; k++)
                new_rgb[3*(js * w + is) + k] += static_cast<unsigned char> ((rgb_data[3*ipos + k] + 0.5) / scale2);

            if (png_alpha != NULL)
                new_alpha[js * w + is] += static_cast<unsigned char> (png_alpha[ipos]/scale2);
            ipos++;
        }
    }

    free(rgb_data);
    free(png_alpha);

    rgb_data = new_rgb;
    png_alpha = new_alpha;
    width = w;
    height = h;

    area = w * h;
}

void
Image::Resize(const int w, const int h) {
    
    if (width==w && height==h){
        return;
    }

    int new_area = w * h;

    unsigned char *new_rgb = (unsigned char *) malloc(3 * new_area);
    unsigned char *new_alpha = NULL;
    if (png_alpha != NULL)
        new_alpha = (unsigned char *) malloc(new_area);

    const double scale_x = ((double) w) / width;
    const double scale_y = ((double) h) / height;

    int ipos = 0;
    for (int j = 0; j < h; j++) {
        const double y = j / scale_y;
        for (int i = 0; i < w; i++) {
            const double x = i / scale_x;
            if (new_alpha == NULL)
                getPixel(x, y, new_rgb + 3*ipos);
            else
                getPixel(x, y, new_rgb + 3*ipos, new_alpha + ipos);
            ipos++;
        }
    }

    free(rgb_data);
    free(png_alpha);

    rgb_data = new_rgb;
    png_alpha = new_alpha;
    width = w;
    height = h;

    area = w * h;
}

// Find the color of the desired point using bilinear interpolation.
// Assume the array indices refer to the denter of the pixel, so each
// pixel has corners at (i - 0.5, j - 0.5) and (i + 0.5, j + 0.5)
void
Image::getPixel(double x, double y, unsigned char *pixel) {
    getPixel(x, y, pixel, NULL);
}

void
Image::getPixel(double x, double y, unsigned char *pixel, unsigned char *alpha) {
    if (x < -0.5)
        x = -0.5;
    if (x >= width - 0.5)
        x = width - 0.5;

    if (y < -0.5)
        y = -0.5;
    if (y >= height - 0.5)
        y = height - 0.5;

    int ix0 = (int) (floor(x));
    int ix1 = ix0 + 1;
    if (ix0 < 0)
        ix0 = width - 1;
    if (ix1 >= width)
        ix1 = 0;

    int iy0 = (int) (floor(y));
    int iy1 = iy0 + 1;
    if (iy0 < 0)
        iy0 = 0;
    if (iy1 >= height)
        iy1 = height - 1;

    const double t = x - floor(x);
    const double u = 1 - (y - floor(y));

    double weight[4];
    weight[1] = t * u;
    weight[0] = u - weight[1];
    weight[2] = 1 - t - u + weight[1];
    weight[3] = t - weight[1];

    unsigned char *pixels[4];
    pixels[0] = rgb_data + 3 * (iy0 * width + ix0);
    pixels[1] = rgb_data + 3 * (iy0 * width + ix1);
    pixels[2] = rgb_data + 3 * (iy1 * width + ix0);
    pixels[3] = rgb_data + 3 * (iy1 * width + ix1);

    memset(pixel, 0, 3);
    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 3; j++)
            pixel[j] += (unsigned char) (weight[i] * pixels[i][j]);
    }

    if (alpha != NULL) {
        unsigned char pixels[4];
        pixels[0] = png_alpha[iy0 * width + ix0];
        pixels[1] = png_alpha[iy0 * width + ix1];
        pixels[2] = png_alpha[iy0 * width + ix0];
        pixels[3] = png_alpha[iy1 * width + ix1];

        for (int i = 0; i < 4; i++)
            *alpha = (unsigned char) (weight[i] * pixels[i]);
    }
}

/* Merge the image with a background, taking care of the
 * image Alpha transparency. (background alpha is ignored).
 * The images is merged on position (x, y) on the
 * background, the background must contain the image.
 */
void Image::Merge(Image* background, const int x, const int y) {

    if (x + width > background->Width()|| y + height > background->Height()) {
        return;
    }

    if (background->Width()*background->Height() != width*height)
        background->Crop(x, y, width, height);

    double tmp;
    unsigned char *new_rgb = (unsigned char *) malloc(3 * width * height);
    memset(new_rgb, 0, 3 * width * height);
    const unsigned char *bg_rgb = background->getRGBData();
    
    int ipos = 0;
    if (png_alpha != NULL){
        for (int j = 0; j < height; j++) {
            for (int i = 0; i < width; i++) {
                for (int k = 0; k < 3; k++) {
                    tmp = rgb_data[3*ipos + k]*png_alpha[ipos]/255.0
                            + bg_rgb[3*ipos + k]*(1-png_alpha[ipos]/255.0);
                    new_rgb[3*ipos + k] = static_cast<unsigned char> (tmp);
                }
                ipos++;
            }
        }
    } else {
        for (int j = 0; j < height; j++) {
            for (int i = 0; i < width; i++) {
                for (int k = 0; k < 3; k++) {
                    tmp = rgb_data[3*ipos + k];
                    new_rgb[3*ipos + k] = static_cast<unsigned char> (tmp);
                }
                ipos++;
            }
        }
    }

    free(rgb_data);
    free(png_alpha);
    rgb_data = new_rgb;
    png_alpha = NULL;

}

/* Merge the image with a background, taking care of the
 * image Alpha transparency. (background alpha is ignored).
 * The images is merged on position (x, y) on the
 * background, the background must contain the image.
 */
#define IMG_POS_RGB(p, x) (3 * p + x)
void Image::Merge_non_crop(Image* background, const int x, const int y)
{
	int bg_w = background->Width();
	int bg_h = background->Height();

	if (x + width > bg_w || y + height > bg_h)
		return;

	double tmp;
	unsigned char *new_rgb = (unsigned char *)malloc(3 * bg_w * bg_h);
	const unsigned char *bg_rgb = background->getRGBData();
	int pnl_pos = 0;
	int bg_pos = 0;
	int pnl_w_end = x + width;
	int pnl_h_end = y + height;

	memcpy(new_rgb, bg_rgb, 3 * bg_w * bg_h);

	for (int j = 0; j < bg_h; j++) {
		for (int i = 0; i < bg_w; i++) {
			if (j >= y && i >= x && j < pnl_h_end && i < pnl_w_end ) {
				for (int k = 0; k < 3; k++) {
					if (png_alpha != NULL)
						tmp = rgb_data[IMG_POS_RGB(pnl_pos, k)]
							* png_alpha[pnl_pos]/255.0
							+ bg_rgb[IMG_POS_RGB(bg_pos, k)]
							* (1 - png_alpha[pnl_pos]/255.0);
					else
						tmp = rgb_data[IMG_POS_RGB(pnl_pos, k)];

					new_rgb[IMG_POS_RGB(bg_pos, k)] = static_cast<unsigned char>(tmp);
				}
				pnl_pos++;
			}
			bg_pos++;
		}
	}

	width = bg_w;
	height = bg_h;

	free(rgb_data);
	free(png_alpha);
	rgb_data = new_rgb;
	png_alpha = NULL;
}

/* Tile the image growing its size to the minimum entire
 * multiple of w * h.
 * The new dimensions should be > of the current ones.
 * Note that this flattens image (alpha removed)
 */
void Image::Tile(const int w, const int h) {

    if (w < width || h < height)
        return;

    int nx = w / width;
    if (w % width > 0)
        nx++;
    int ny = h / height;
    if (h % height > 0)
        ny++;

    int newwidth = nx*width;
    int newheight=ny*height;
        
    unsigned char *new_rgb = (unsigned char *) malloc(3 * newwidth * newheight);
    memset(new_rgb, 0, 3 * width * height * nx * ny);

    int ipos = 0;
    int opos = 0;

    for (int r = 0; r < ny; r++) {
        for (int c = 0; c < nx; c++) {
            for (int j = 0; j < height; j++) {
                for (int i = 0; i < width; i++) {
                    opos = j*width + i;
                    ipos = r*width*height*nx + j*newwidth + c*width +i;
                    for (int k = 0; k < 3; k++) {
                        new_rgb[3*ipos + k] = static_cast<unsigned char> (rgb_data[3*opos + k]);
                    }
                }
            }
        }
    }

    free(rgb_data);
    free(png_alpha);
    rgb_data = new_rgb;
    png_alpha = NULL;
    width = newwidth;
    height = newheight;
    area = width * height;
    Crop(0,0,w,h);

}

/* Crop the image
 */
void Image::Crop(const int x, const int y, const int w, const int h) {

    if (x+w > width || y+h > height) {
        return;
    }

    int x2 = x + w;
    int y2 = y + h;
    unsigned char *new_rgb = (unsigned char *) malloc(3 * w * h);
    memset(new_rgb, 0, 3 * w * h);
    unsigned char *new_alpha = NULL;
    if (png_alpha != NULL) {
        new_alpha = (unsigned char *) malloc(w * h);
        memset(new_alpha, 0, w * h);
    }

    int ipos = 0;
    int opos = 0;

    for (int j = 0; j < height; j++) {
        for (int i = 0; i < width; i++) {
            if (j>=y && i>=x && j<y2 && i<x2) {
                for (int k = 0; k < 3; k++) {
                    new_rgb[3*ipos + k] = static_cast<unsigned char> (rgb_data[3*opos + k]);
                }
                if (png_alpha != NULL)
                    new_alpha[ipos] = static_cast<unsigned char> (png_alpha[opos]);
                ipos++;
            }
            opos++;
        }
    }

    free(rgb_data);
    free(png_alpha);
    rgb_data = new_rgb;
    if (png_alpha != NULL)
        png_alpha = new_alpha;
    width = w;
    height = h;
    area = w * h;


}

/* Center the image in a rectangle of given width and height.
 * Fills the remaining space (if any) with the hex color
 */
void Image::Center(const int w, const int h, const char *hex) {

    unsigned long packed_rgb;
    sscanf(hex, "%lx", &packed_rgb);  

    unsigned long r = packed_rgb>>16;
    unsigned long g = packed_rgb>>8 & 0xff;
    unsigned long b = packed_rgb & 0xff;    

    unsigned char *new_rgb = (unsigned char *) malloc(3 * w * h);
    memset(new_rgb, 0, 3 * w * h);

    int x = (w - width) / 2;
    int y = (h - height) / 2;
    
    if (x<0) {
        Crop((width - w)/2,0,w,height);
        x = 0;
    }
    if (y<0) {
        Crop(0,(height - h)/2,width,h);
        y = 0;
    }
    int x2 = x + width;
    int y2 = y + height;

    int ipos = 0;
    int opos = 0;
    double tmp;

    area = w * h;
    for (int i = 0; i < area; i++) {
        new_rgb[3*i] = r;
        new_rgb[3*i+1] = g;
        new_rgb[3*i+2] = b;
    }

    if (png_alpha != NULL) {
        for (int j = 0; j < h; j++) {
            for (int i = 0; i < w; i++) {
                if (j>=y && i>=x && j<y2 && i<x2) {
                    ipos = j*w + i;
                    for (int k = 0; k < 3; k++) {
                        tmp = rgb_data[3*opos + k]*png_alpha[opos]/255.0
                              + new_rgb[k]*(1-png_alpha[opos]/255.0);
                        new_rgb[3*ipos + k] = static_cast<unsigned char> (tmp);
                    }
                    opos++;
                }

            }
        }
    } else {
        for (int j = 0; j < h; j++) {
            for (int i = 0; i < w; i++) {
                if (j>=y && i>=x && j<y2 && i<x2) {
                    ipos = j*w + i;
                    for (int k = 0; k < 3; k++) {
                        tmp = rgb_data[3*opos + k];
                        new_rgb[3*ipos + k] = static_cast<unsigned char> (tmp);
                    }
                    opos++;
                }

            }
        }
    }
    
    free(rgb_data);
    free(png_alpha);
    rgb_data = new_rgb;
    png_alpha = NULL;
    width = w;
    height = h;
    
}

/* Fill the image with the given color and adjust its dimensions
 * to passed values.
 */
void Image::Plain(const int w, const int h, const char *hex) {

    unsigned long packed_rgb;
    sscanf(hex, "%lx", &packed_rgb);  

    unsigned long r = packed_rgb>>16;
    unsigned long g = packed_rgb>>8 & 0xff;
    unsigned long b = packed_rgb & 0xff;    

    unsigned char *new_rgb = (unsigned char *) malloc(3 * w * h);
    memset(new_rgb, 0, 3 * w * h);

    area = w * h;
    for (int i = 0; i < area; i++) {
        new_rgb[3*i] = r;
        new_rgb[3*i+1] = g;
        new_rgb[3*i+2] = b;
    }

    free(rgb_data);
    free(png_alpha);
    rgb_data = new_rgb;
    png_alpha = NULL;
    width = w;
    height = h;
    
}

void
Image::computeShift(unsigned long mask,
                    unsigned char &left_shift,
                    unsigned char &right_shift) {
    left_shift = 0;
    right_shift = 8;
    if (mask != 0) {
        while ((mask & 0x01) == 0) {
            left_shift++;
            mask >>= 1;
        }
        while ((mask & 0x01) == 1) {
            right_shift--;
            mask >>= 1;
        }
    }
}

Pixmap
Image::createPixmap(Display* dpy, int scr, Window win) {
    int i, j;   // loop variables

    const int depth = DefaultDepth(dpy, scr);
    Visual *visual = DefaultVisual(dpy, scr);
    Colormap colormap = DefaultColormap(dpy, scr);

    Pixmap tmp = XCreatePixmap(dpy, win, width, height,
                               depth);

    char *pixmap_data = NULL;
    switch (depth) {
    case 32:
    case 24:
        pixmap_data = new char[4 * width * height];
        break;
    case 16:
    case 15:
        pixmap_data = new char[2 * width * height];
        break;
    case 8:
        pixmap_data = new char[width * height];
        break;
    default:
        break;
    }

    XImage *ximage = XCreateImage(dpy, visual, depth, ZPixmap, 0,
                                  pixmap_data, width, height,
                                  8, 0);

    int entries;
    XVisualInfo v_template;
    v_template.visualid = XVisualIDFromVisual(visual);
    XVisualInfo *visual_info = XGetVisualInfo(dpy, VisualIDMask,
                               &v_template, &entries);

    unsigned long ipos = 0;
    switch (visual_info->c_class) {
    case PseudoColor: {
            XColor xc;
            xc.flags = DoRed | DoGreen | DoBlue;

            int num_colors = 256;
            XColor *colors = new XColor[num_colors];
            for (i = 0; i < num_colors; i++)
                colors[i].pixel = (unsigned long) i;
            XQueryColors(dpy, colormap, colors, num_colors);

            int *closest_color = new int[num_colors];

            for (i = 0; i < num_colors; i++) {
                xc.red = (i & 0xe0) << 8;           // highest 3 bits
                xc.green = (i & 0x1c) << 11;        // middle 3 bits
                xc.blue = (i & 0x03) << 14;         // lowest 2 bits

                // find the closest color in the colormap
                double distance, distance_squared, min_distance = 0;
                for (int ii = 0; ii < num_colors; ii++) {
                    distance = colors[ii].red - xc.red;
                    distance_squared = distance * distance;
                    distance = colors[ii].green - xc.green;
                    distance_squared += distance * distance;
                    distance = colors[ii].blue - xc.blue;
                    distance_squared += distance * distance;

                    if ((ii == 0) || (distance_squared <= min_distance)) {
                        min_distance = distance_squared;
                        closest_color[i] = ii;
                    }
                }
            }

            for (j = 0; j < height; j++) {
                for (i = 0; i < width; i++) {
                    xc.red = (unsigned short) (rgb_data[ipos++] & 0xe0);
                    xc.green = (unsigned short) (rgb_data[ipos++] & 0xe0);
                    xc.blue = (unsigned short) (rgb_data[ipos++] & 0xc0);

                    xc.pixel = xc.red | (xc.green >> 3) | (xc.blue >> 6);
                    XPutPixel(ximage, i, j,
                              colors[closest_color[xc.pixel]].pixel);
                }
            }
            delete [] colors;
            delete [] closest_color;
        }
        break;
    case TrueColor: {
            unsigned char red_left_shift;
            unsigned char red_right_shift;
            unsigned char green_left_shift;
            unsigned char green_right_shift;
            unsigned char blue_left_shift;
            unsigned char blue_right_shift;

            computeShift(visual_info->red_mask, red_left_shift,
                         red_right_shift);
            computeShift(visual_info->green_mask, green_left_shift,
                         green_right_shift);
            computeShift(visual_info->blue_mask, blue_left_shift,
                         blue_right_shift);

            unsigned long pixel;
            unsigned long red, green, blue;
            for (j = 0; j < height; j++) {
                for (i = 0; i < width; i++) {
                    red = (unsigned long)
                          rgb_data[ipos++] >> red_right_shift;
                    green = (unsigned long)
                            rgb_data[ipos++] >> green_right_shift;
                    blue = (unsigned long)
                           rgb_data[ipos++] >> blue_right_shift;

                    pixel = (((red << red_left_shift) & visual_info->red_mask)
                             | ((green << green_left_shift)
                                & visual_info->green_mask)
                             | ((blue << blue_left_shift)
                                & visual_info->blue_mask));

                    XPutPixel(ximage, i, j, pixel);
                }
            }
        }
        break;
    default: {
            logStream << "Login.app: could not load image" << endl;
            return(tmp);
        }
    }

    GC gc = XCreateGC(dpy, win, 0, NULL);
    XPutImage(dpy, tmp, gc, ximage, 0, 0, 0, 0, width, height);

    XFreeGC(dpy, gc);

    XFree(visual_info);

    delete [] pixmap_data;

    // Set ximage data to NULL since pixmap data was deallocated above
    ximage->data = NULL;
    XDestroyImage(ximage);

    return(tmp);
}

int
Image::readJpeg(const char *filename, int *width, int *height,
                unsigned char **rgb)
{
    int ret = 0;
    struct jpeg_decompress_struct cinfo;
    struct jpeg_error_mgr jerr;
    unsigned char *ptr = NULL;

    FILE *infile = fopen(filename, "rb");
    if (infile == NULL) {
        logStream << APPNAME << "Cannot fopen file: " << filename << endl;
        return ret;
    }

    cinfo.err = jpeg_std_error(&jerr);
    jpeg_create_decompress(&cinfo);
    jpeg_stdio_src(&cinfo, infile);
    jpeg_read_header(&cinfo, TRUE);
    jpeg_start_decompress(&cinfo);

    /* Prevent against integer overflow */
    if(cinfo.output_width >= MAX_DIMENSION
       || cinfo.output_height >= MAX_DIMENSION)
    {
        logStream << APPNAME << "Unreasonable dimension found in file: "
                  << filename << endl;
        goto close_file;
    }

    *width = cinfo.output_width;
    *height = cinfo.output_height;

    rgb[0] = (unsigned char*)
                malloc(3 * cinfo.output_width * cinfo.output_height);
    if (rgb[0] == NULL) {
        logStream << APPNAME << ": Can't allocate memory for JPEG file."
                  << endl;
        goto close_file;
    }

    if (cinfo.output_components == 3) {
        ptr = rgb[0];
        while (cinfo.output_scanline < cinfo.output_height) {
            jpeg_read_scanlines(&cinfo, &ptr, 1);
            ptr += 3 * cinfo.output_width;
        }
    } else if (cinfo.output_components == 1) {
        ptr = (unsigned char*) malloc(cinfo.output_width);
        if (ptr == NULL) {
            logStream << APPNAME << ": Can't allocate memory for JPEG file."
                      << endl;
            goto rgb_free;
        }

        unsigned int ipos = 0;
        while (cinfo.output_scanline < cinfo.output_height) {
            jpeg_read_scanlines(&cinfo, &ptr, 1);

            for (unsigned int i = 0; i < cinfo.output_width; i++) {
                memset(rgb[0] + ipos, ptr[i], 3);
                ipos += 3;
            }
        }

        free(ptr);
    }

    jpeg_finish_decompress(&cinfo);

    ret = 1;
    goto close_file;

rgb_free:
    free(rgb[0]);

close_file:
    jpeg_destroy_decompress(&cinfo);
    fclose(infile);

    return(ret);
}

int
Image::readPng(const char *filename, int *width, int *height,
               unsigned char **rgb, unsigned char **alpha)
{
    int ret = 0;

    png_structp png_ptr;
    png_infop info_ptr;
    png_bytepp row_pointers;

    unsigned char *ptr = NULL;
    png_uint_32 w, h;
    int bit_depth, color_type, interlace_type;
    int i;

    FILE *infile = fopen(filename, "rb");
    if (infile == NULL) {
        logStream << APPNAME << "Can not fopen file: " << filename << endl;
        return ret;
    }

    png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
                                     (png_voidp) NULL,
                                     (png_error_ptr) NULL,
                                     (png_error_ptr) NULL);
    if (!png_ptr) {
        goto file_close;
    }

    info_ptr = png_create_info_struct(png_ptr);
    if (!info_ptr) {
        png_destroy_read_struct(&png_ptr, (png_infopp) NULL,
                                (png_infopp) NULL);
    }

#if PNG_LIBPNG_VER_MAJOR >= 1 && PNG_LIBPNG_VER_MINOR >= 4
    if (setjmp(png_jmpbuf((png_ptr)))) {
#else
    if (setjmp(png_ptr->jmpbuf)) {
#endif
        goto png_destroy;
    }

    png_init_io(png_ptr, infile);
    png_read_info(png_ptr, info_ptr);

    png_get_IHDR(png_ptr, info_ptr, &w, &h, &bit_depth, &color_type,
                 &interlace_type, (int *) NULL, (int *) NULL);

    /* Prevent against integer overflow */
    if(w >= MAX_DIMENSION || h >= MAX_DIMENSION) {
        logStream << APPNAME << "Unreasonable dimension found in file: "
                  << filename << endl;
        goto png_destroy;
    }

    *width = (int) w;
    *height = (int) h;

    if (color_type == PNG_COLOR_TYPE_RGB_ALPHA
        || color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
    {
        alpha[0] = (unsigned char *) malloc(*width * *height);
        if (alpha[0] == NULL) {
            logStream << APPNAME
                    << ": Can't allocate memory for alpha channel in PNG file."
                    << endl;
            goto png_destroy;
        }
    }

    /* Change a paletted/grayscale image to RGB */
    if (color_type == PNG_COLOR_TYPE_PALETTE && bit_depth <= 8)
    {
        png_set_expand(png_ptr);
    }

    /* Change a grayscale image to RGB */
    if (color_type == PNG_COLOR_TYPE_GRAY
        || color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
    {
        png_set_gray_to_rgb(png_ptr);
    }

    /* If the PNG file has 16 bits per channel, strip them down to 8 */
    if (bit_depth == 16) {
      png_set_strip_16(png_ptr);
    }

    /* use 1 byte per pixel */
    png_set_packing(png_ptr);

    row_pointers = (png_byte **) malloc(*height * sizeof(png_bytep));
    if (row_pointers == NULL) {
        logStream << APPNAME << ": Can't allocate memory for PNG file." << endl;
        goto png_destroy;
    }

    for (i = 0; i < *height; i++) {
        row_pointers[i] = (png_byte*) malloc(4 * *width);
        if (row_pointers == NULL) {
            logStream << APPNAME << ": Can't allocate memory for PNG file."
                      << endl;
            goto rows_free;
        }
    }

    png_read_image(png_ptr, row_pointers);

    rgb[0] = (unsigned char *) malloc(3 * (*width) * (*height));
    if (rgb[0] == NULL) {
        logStream << APPNAME << ": Can't allocate memory for PNG file." << endl;
        goto rows_free;
    }

    if (alpha[0] == NULL) {
        ptr = rgb[0];
        for (i = 0; i < *height; i++) {
            memcpy(ptr, row_pointers[i], 3 * (*width));
            ptr += 3 * (*width);
        }
    } else {
        ptr = rgb[0];
        for (i = 0; i < *height; i++) {
            unsigned int ipos = 0;
            for (int j = 0; j < *width; j++) {
                *ptr++ = row_pointers[i][ipos++];
                *ptr++ = row_pointers[i][ipos++];
                *ptr++ = row_pointers[i][ipos++];
                alpha[0][i * (*width) + j] = row_pointers[i][ipos++];
            }
        }
    }

    ret = 1; /* data reading is OK */

rows_free:
    for (i = 0; i < *height; i++) {
        if (row_pointers[i] != NULL ) {
            free(row_pointers[i]);
        }
    }

    free(row_pointers);

png_destroy:
    png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp) NULL);

file_close:
    fclose(infile);
    return(ret);
}