C++ png_get_rows函数代码示例

void ImageFormat_PNG::CopyPixels(unsigned int* destination)
	{
	if (!info_ptr_ || !png_ptr_)
		{
		return;
		}

	png_infop info_ptr=static_cast<png_infop>(info_ptr_);
	png_structp png_ptr=static_cast<png_structp>(png_ptr_);

	Assert(info_ptr->color_type==PNG_COLOR_TYPE_RGB_ALPHA || info_ptr->color_type==PNG_COLOR_TYPE_RGB,"Unknown PNG format");
	if (info_ptr->color_type!=PNG_COLOR_TYPE_RGB_ALPHA && info_ptr->color_type!=PNG_COLOR_TYPE_RGB)
		{
		return;
		}

	if (info_ptr->color_type==PNG_COLOR_TYPE_RGB_ALPHA)
		{
		unsigned char* data=reinterpret_cast<unsigned char*>(destination);
		png_byte** row_pointers=png_get_rows(png_ptr, info_ptr);
		int rowSize=info_ptr->width*4;

		for (unsigned int y=0; y<info_ptr->height; y++)
			{
			for (unsigned int x=0; x<info_ptr->width; x++)
				{
				data[x*4+y*rowSize+0]=row_pointers[y][x*4+0];
				data[x*4+y*rowSize+1]=row_pointers[y][x*4+1];
				data[x*4+y*rowSize+2]=row_pointers[y][x*4+2];
				data[x*4+y*rowSize+3]=row_pointers[y][x*4+3];
				}
			}
		}
	else
		{
		unsigned char* data=reinterpret_cast<unsigned char*>(destination);
		png_byte** row_pointers=png_get_rows(png_ptr, info_ptr);
		int rowSize=info_ptr->width*4;

		for (unsigned int y=0; y<info_ptr->height; y++)
			{
			for (unsigned int x=0; x<info_ptr->width; x++)
				{
				data[x*4+y*rowSize+0]=row_pointers[y][x*3+0];
				data[x*4+y*rowSize+1]=row_pointers[y][x*3+1];
				data[x*4+y*rowSize+2]=row_pointers[y][x*3+2];
				data[x*4+y*rowSize+3]=0xff;
				}
			}
		}
	}

void TextWindow::ScreenBackgroundImage(int link, uint32_t v) {
    if(SS.bgImage.fromFile) MemFree(SS.bgImage.fromFile);
    SS.bgImage.fromFile = NULL;

    if(link == 'l') {
        FILE *f = NULL;
        png_struct *png_ptr = NULL;
        png_info *info_ptr = NULL;

        char importFile[MAX_PATH] = "";
        if(!GetOpenFile(importFile, PNG_EXT, PNG_PATTERN)) goto err;
        f = fopen(importFile, "rb");
        if(!f) goto err;

        uint8_t header[8];
        if (fread(header, 1, 8, f) != 8)
            goto err;
        if(png_sig_cmp(header, 0, 8)) goto err;

        png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
            NULL, NULL, NULL);
        if(!png_ptr) goto err;

        info_ptr = png_create_info_struct(png_ptr);
        if(!info_ptr) goto err;

        if(setjmp(png_jmpbuf(png_ptr))) goto err;

        png_init_io(png_ptr, f);
        png_set_sig_bytes(png_ptr, 8);

        png_read_png(png_ptr, info_ptr,
            PNG_TRANSFORM_EXPAND | PNG_TRANSFORM_STRIP_ALPHA, NULL);

        int w; w = (int)png_get_image_width(png_ptr, info_ptr);
        int h; h = (int)png_get_image_height(png_ptr, info_ptr);
        uint8_t **rows; rows = png_get_rows(png_ptr, info_ptr);

        // Round to next-highest powers of two, since the textures require
        // that. And round up to 4, to guarantee 32-bit alignment.
        int rw; rw = max(4, RoundUpToPowerOfTwo(w));
        int rh; rh = max(4, RoundUpToPowerOfTwo(h));

        SS.bgImage.fromFile = (uint8_t *)MemAlloc(rw*rh*3);
        {for(int i = 0; i < h; i++) {
            memcpy(SS.bgImage.fromFile + ((h - 1) - i)*(rw*3), rows[i], w*3);
        }}
        SS.bgImage.w      = w;
        SS.bgImage.h      = h;
        SS.bgImage.rw     = rw;
        SS.bgImage.rh     = rh;
        SS.bgImage.scale  = SS.GW.scale;
        SS.bgImage.origin = SS.GW.offset.ScaledBy(-1);

err:
        if(png_ptr) png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
        if(f) fclose(f);
    }
    SS.later.showTW = true;
}

__error__ "PNG_FLAG_FILLER_AFTER" has an unexpected value
#endif
#endif

/*
 * Check if it's safe to access libpng's internal structures directly.
 * Some fields might have their offsets shifted due to changes in
 * libpng's configuration.
 */
static void
_opng_validate_internal(png_structp png_ptr, png_infop info_ptr)
{
#if defined(PNG_bKGD_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
   png_color_16p background;
#endif
#if defined(PNG_hIST_SUPPORTED)
   png_uint_16p hist;
#endif
#if defined(PNG_sBIT_SUPPORTED)
   png_color_8p sig_bit;
#endif
   png_bytep trans_alpha;
   int num_trans;
   png_color_16p trans_color;

   /* Check info_ptr. */
   if (png_get_rows(png_ptr, info_ptr) != info_ptr->row_pointers)
      goto error;
#if defined(PNG_bKGD_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
   if (png_get_bKGD(png_ptr, info_ptr, &background))
      if (background != &info_ptr->background)
         goto error;
#endif
#if defined(PNG_hIST_SUPPORTED)
   if (png_get_hIST(png_ptr, info_ptr, &hist))
      if (hist != info_ptr->hist)
         goto error;
#endif
#if defined(PNG_sBIT_SUPPORTED)
   if (png_get_sBIT(png_ptr, info_ptr, &sig_bit))
      if (sig_bit != &info_ptr->sig_bit)
         goto error;
#endif
   if (png_get_tRNS(png_ptr, info_ptr, &trans_alpha, &num_trans, &trans_color))
      if ((trans_alpha != NULL && (trans_alpha != info_ptr->trans_alpha ||
                                   num_trans != info_ptr->num_trans)) ||
          (trans_color != NULL && trans_color != &info_ptr->trans_color))
         goto error;

   /* Also check png_ptr. It's not much, we're doing what we can... */
   if (png_get_compression_buffer_size(png_ptr) != png_ptr->zbuf_size)
      goto error;

   /* Everything looks okay. */
   return;

error:
   png_error(png_ptr,
      "[internal error] Inconsistent internal structures (incorrect libpng?)");
}

/* Ripped from the libpng manual */
png_bytepp readpng(const char *filename, int* width, int* height) {
   FILE *fp = fopen(filename, "rb");
   char header[8];
   png_structp png_ptr;
   png_infop info_ptr, end_info;

   if (!fp) {
      fprintf(stderr, "%s ", filename);
      perror("fopen");
      return NULL;
   }
   fread(header, 1, 8, fp);
   if(png_sig_cmp((png_byte*)header, 0, 8))
   {
      fprintf(stderr, "%s: Not a PNG image!\n", filename);
      return NULL;
   }

   png_ptr = png_create_read_struct(
      PNG_LIBPNG_VER_STRING,
      NULL, NULL, NULL);
   if(!png_ptr)
      return NULL;

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

   end_info = png_create_info_struct(png_ptr);
   if(!end_info) {
      png_destroy_read_struct(&png_ptr, NULL, NULL);
      return NULL;
   }

   /* Set up jump target for libpng errors */
   if (setjmp(png_jmpbuf(png_ptr)))
   {
      png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
      fprintf(stderr, "libpng error!\n");
      fclose(fp);
      return NULL;
   }

   png_init_io(png_ptr, fp);
   png_set_sig_bytes(png_ptr, 8);
   png_read_png(png_ptr, info_ptr, 0, NULL);

   /* Make sure the image is in the format we want */
   *width = png_get_image_width(png_ptr, info_ptr);
   *height = png_get_image_height(png_ptr, info_ptr);
   if(png_get_bit_depth(png_ptr, info_ptr) != 8 ||
      png_get_color_type(png_ptr, info_ptr) != PNG_COLOR_TYPE_RGB)
      fprintf(stderr, "Need an 8 bit/color RGB image!!\n");

   /* Warning!  We leak these data structures!!! */
   return png_get_rows(png_ptr, info_ptr);
}

Image * pngfile_to_bytes(char* file_name) {
    printf("reading file %s\n",file_name);
    png_structp png_ptr;
    png_infop info_ptr, end_ptr;
    png_uint_32 width, height;
    int bit_depth;
    int color_type;
    int interlace_type;
    int i;

    FILE *fp = fopen(file_name, "rb");
    if (!fp) {
        fprintf(stderr, "can't open %s\n", file_name);
        return 0;
    }


    /* initialize stuff */
    png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
    if (!png_ptr) abort_("[read_png_file] png_create_read_struct failed");

    info_ptr = png_create_info_struct(png_ptr);
    if (!info_ptr) abort_("[read_png_file] png_create_info_struct failed");

    end_ptr = png_create_info_struct(png_ptr);
    if (!end_ptr) abort_("[read_png_file] png_create_info_struct failed");


    png_init_io(png_ptr, fp);
    png_set_sig_bytes(png_ptr, 0);
    png_read_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, NULL);

    png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, NULL, NULL);

    Image* img = (Image*)malloc(sizeof(Image));
    img->w = width;
    img->h = height;
    img->hasAlpha = (color_type == PNG_COLOR_TYPE_RGBA);
    int bytes_per_pixel = 3;
    if(img->hasAlpha) {
        bytes_per_pixel = 4;
    }

    unsigned int row_bytes = png_get_rowbytes(png_ptr, info_ptr);
    img->data = (char*) malloc(row_bytes * height);
    png_bytepp row_pointers = png_get_rows(png_ptr, info_ptr);

    for (i = 0; i < height; i++) {
        memcpy(img->data + row_bytes*i, row_pointers[i], row_bytes);
    }




    png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
    fclose(fp);

    return img;
}

//
////////////////////////////////////////////////////
//
// Image* readPNGIntoImage()
//
////////////////////////////////////////////////////
//
Image* PNGCodec::readPNGIntoImage(png_structp &png, png_infop &pngInfo)
{
	uint8 **buf;
	int y;
	png_uint_32 iWidth, iHeight, iRowLength;
	png_byte iColourType, iBitsPerChannel, iNumChannels;
	png_bytepp pngRows;
	Image* imgPNG;

	png_read_png(png, pngInfo, PNG_TRANSFORM_BGR | PNG_TRANSFORM_STRIP_ALPHA, png_voidp_NULL);
	
	// pixels are in info_ptr->row_pointers
	// where row_pointers is:
	//   png_bytep row_pointers[height];
	// and is probably not contiguous

	iColourType = png_get_color_type(png, pngInfo);
	//	if (iColourType != PNG_COLOR_TYPE_RGB_ALPHA)
	if (iColourType != PNG_COLOR_TYPE_RGB)
		throw new std::runtime_error("Colour type not supported - RGB only, PNGCodec::readPNGIntoImage()");



	iBitsPerChannel = png_get_bit_depth(png, pngInfo);
	iNumChannels = png_get_channels(png, pngInfo);

	iHeight = png_get_image_height(png, pngInfo);
	iWidth = png_get_image_width(png, pngInfo);

	iRowLength = iWidth * (iBitsPerChannel * iNumChannels) / 8; // Should be same as iWidth

	// 07-Jul-2009: Directly load the PNG into a pre-created image's
	//     buffer. Otherwise ImageRGB24 will make a copy of the buf, which
	//     is a waste of space (and problematic for very large PNGs!)
	imgPNG = new Image;
    imgPNG->width = iWidth;
    imgPNG->height = iHeight;
    imgPNG->data = new unsigned char*[iHeight];
	for (y = 0; y < iHeight; y++) {
        imgPNG->data[y] = new unsigned char[iRowLength];
    }

	buf = imgPNG->data;
	pngRows = png_get_rows(png, pngInfo);
	for (y = 0; y < iHeight; y++) {
		//		for (x = 0; x < iWidth; x++) {
		// This assumes BGR order, in readiness for the ImageRGB24 constructor
		// It also assumes 24-bit, no alpha
        // Yes, this is not good...
		memcpy(buf[y], pngRows[y], iRowLength);
		//memcpy((buf + (y * iRowLength)), pngRows[y], iRowLength);
	}
			

	// Clean up
	png_destroy_read_struct(&png, &pngInfo, png_infopp_NULL);

	return imgPNG;
}

void Image::loadWithPng()
{

	FILE* file = fopen(this->file.c_str(), "rb");

	png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);

	png_infop info_ptr = png_create_info_struct(png_ptr);

	setjmp(png_jmpbuf(png_ptr));


	png_init_io(png_ptr, file);


	png_read_png(png_ptr, info_ptr, PNG_TRANSFORM_EXPAND, 0);



	int m_width = png_get_image_width(png_ptr, info_ptr);
	int m_height = png_get_image_height(png_ptr, info_ptr);


	int color_type = png_get_color_type(png_ptr, info_ptr);

	int size = m_height * m_width * 4;

	unsigned char* rgba = (unsigned char*)malloc(size);

	int pos = 0;

	png_bytep* row_pointers = png_get_rows(png_ptr, info_ptr);
	for (int i = 0; i < m_height; i++)
	{
		for (int j = 0; j < (4 * m_width); j += 4)
		{
			rgba[pos++] = row_pointers[i][j];  //R
			rgba[pos++] = row_pointers[i][j + 1];  //B 
			rgba[pos++] = row_pointers[i][j + 2];    //G
			rgba[pos++] = row_pointers[i][j + 3];  //A
		}
	}
	png_destroy_read_struct(&png_ptr, &info_ptr, 0);

	fclose(file);
	auto _data = rgba;

	this->width = m_width;
	this->height = m_height;
	this->size = size;

	_rect.x = m_width;
	_rect.y = m_height;


	this->_data = rgba;

}

static png_bytep *
read_png(png_structp png_ptr, png_infop info_ptr, at_input_opts_type * opts)
{
	int row;
	png_color_16p original_bg;
	png_color_16  my_bg;

	png_read_info(png_ptr, info_ptr);

	png_set_strip_16(png_ptr);
	png_set_packing(png_ptr);
	if ((png_get_bit_depth(png_ptr, info_ptr) < 8) ||
	    (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_PALETTE) ||
	    (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)))
		png_set_expand(png_ptr);

	if (png_get_bKGD(png_ptr, info_ptr, &original_bg)) {
		/* Fill transparent region with ... */
		my_bg.index = 0;

		if (opts && opts->background_color) {
			my_bg.red   = 256 * opts->background_color->r;
			my_bg.green = 256 * opts->background_color->g;
			my_bg.blue  = 256 * opts->background_color->b;
			my_bg.gray  = 256* ((opts->background_color->r
					     + opts->background_color->g
					     + opts->background_color->b) / 3);
		} else
			  /* else, use white */
			  my_bg.red = my_bg.green = my_bg.blue = my_bg.gray = 0xFFFF;
		
		png_set_background(png_ptr, &my_bg,
				   PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
	} else
		png_set_strip_alpha(png_ptr);

	png_set_interlace_handling(png_ptr);
	png_read_update_info(png_ptr, info_ptr);

	// PGC to replace commented lines
	png_read_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, NULL);
	png_read_end(png_ptr, info_ptr);
	return png_get_rows(png_ptr, info_ptr);
	
//	info_ptr->row_pointers = (png_bytepp)png_malloc(png_ptr,
//							info_ptr->height * sizeof(png_bytep));
//#ifdef PNG_FREE_ME_SUPPORTED
//	info_ptr->free_me |= PNG_FREE_ROWS;
//#endif
//	for (row = 0; row < (int)info_ptr->height; row++)
//		info_ptr->row_pointers[row] = (png_bytep)png_malloc(png_ptr,
//								    png_get_rowbytes(png_ptr, info_ptr));
//	
//	png_read_image(png_ptr, info_ptr->row_pointers);
//	info_ptr->valid |= PNG_INFO_IDAT;
//	png_read_end(png_ptr, info_ptr);
//	return png_get_rows(png_ptr, info_ptr);
}

static void
read_png(struct display *dp, struct buffer *bp, const char *operation,
   int transforms)
{
   png_structp pp;
   png_infop   ip;

   /* This cleans out any previous read and sets operation and transforms to
    * empty.
    */
   display_clean_read(dp);

   if (operation != NULL) /* else this is a verify and do not overwrite info */
   {
      dp->operation = operation;
      dp->transforms = transforms;
   }

   dp->read_pp = pp = png_create_read_struct(PNG_LIBPNG_VER_STRING, dp,
      display_error, display_warning);
   if (pp == NULL)
      display_log(dp, LIBPNG_ERROR, "failed to create read struct");

   /* The png_read_png API requires us to make the info struct, but it does the
    * call to png_read_info.
    */
   dp->read_ip = ip = png_create_info_struct(pp);
   if (ip == NULL)
      display_log(dp, LIBPNG_ERROR, "failed to create info struct");

#  ifdef PNG_SET_USER_LIMITS_SUPPORTED
      /* Remove the user limits, if any */
      png_set_user_limits(pp, 0x7fffffff, 0x7fffffff);
#  endif

   /* Set the IO handling */
   buffer_start_read(bp);
   png_set_read_fn(pp, bp, read_function);

   png_read_png(pp, ip, transforms, NULL/*params*/);

#if 0 /* crazy debugging */
   {
      png_bytep pr = png_get_rows(pp, ip)[0];
      size_t rb = png_get_rowbytes(pp, ip);
      size_t cb;
      char c = ' ';

      fprintf(stderr, "%.4x %2d (%3lu bytes):", transforms, png_get_bit_depth(pp,ip), (unsigned long)rb);

      for (cb=0; cb<rb; ++cb)
         fputc(c, stderr), fprintf(stderr, "%.2x", pr[cb]), c='.';

      fputc('\n', stderr);
   }
#endif
}

int main(int argc, char **argv)
{
    FILE *fin, *fout;

    if (argc < 3)
    {
        printf("Usage: vmuicon <icon.raw> <icon.c>\n");
        exit(0);
    }

    fin = fopen(argv[1], "rb");
    if (!fin)
        abort_("File %s could not be opened for reading", argv[1]);

    png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
    if (!png_ptr)
        abort_("Failed to create PNG read struct\n");

    info_ptr = png_create_info_struct(png_ptr);
    if (!info_ptr)
        abort_("Failed to create PNG info struct\n");

    if (setjmp(png_jmpbuf(png_ptr)))
    {
        png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
        fclose(fin);

        abort_("Error reading PNG\n");
    }

    png_init_io(png_ptr, fin);
    png_read_png(png_ptr, info_ptr, PNG_TRANSFORM_INVERT_MONO | PNG_TRANSFORM_PACKSWAP, NULL);

    if ((png_get_image_width(png_ptr, info_ptr) != IMAGE_WIDTH) ||
        (png_get_image_height(png_ptr, info_ptr) != IMAGE_HEIGHT))
        abort_("Image is not %ix%i pixels\n", IMAGE_WIDTH, IMAGE_HEIGHT);

    if ((png_get_color_type(png_ptr, info_ptr) != PNG_COLOR_TYPE_GRAY)
        || (png_get_bit_depth(png_ptr, info_ptr) != 1))
        abort_("Image is not a grayscale image with bit depth 1\n");

    rows = png_get_rows(png_ptr, info_ptr);

    fout = fopen(argv[2], "w+");
    if (!fout)
        abort_("File %s could not be opened for writing", argv[2]);

    write_data(fout);

    png_destroy_read_struct(&png_ptr, &info_ptr, NULL);

    fclose(fin);
    fclose(fout);

    return 0;
}

CNSL_Display Pnger_Load(const char* filename)
{
    CNSL_Display null;
    null.width = 0;
    null.height = 0;
    null.pixels = NULL;
    FILE* pngfile = fopen(filename, "rb");
    if (!pngfile) {
        fprintf(stderr, "unable to open %s\n", filename);
        return null;
    }

    png_structp png_ptr = png_create_read_struct(
        PNG_LIBPNG_VER_STRING, NULL, NULL, NULL
    );

    if (!png_ptr) {
        fprintf(stderr, "unable to create png read struct.\n");
        return null;
    }

    png_infop info_ptr = png_create_info_struct(png_ptr);
    if (!info_ptr)
    {
        png_destroy_read_struct(&png_ptr, (png_infopp)NULL, (png_infopp)NULL);
        fprintf(stderr, "unable to create png info struct.\n");
        return null;
    }

    png_init_io(png_ptr, pngfile);
    unsigned int transforms = 
          PNG_TRANSFORM_STRIP_16 | PNG_TRANSFORM_STRIP_ALPHA
        | PNG_TRANSFORM_PACKING | PNG_TRANSFORM_GRAY_TO_RGB
        | PNG_TRANSFORM_EXPAND;

    png_read_png(png_ptr, info_ptr, transforms, NULL);

    uint8_t** row_pointers = png_get_rows(png_ptr, info_ptr);

    int width = png_get_image_width(png_ptr, info_ptr);
    int height = png_get_image_height(png_ptr, info_ptr);
    CNSL_Display pixels = CNSL_AllocDisplay(width, height);

    int x, y;
    for (y = 0; y < pixels.height; y++) {
        for (x = 0; x < pixels.width; x++) {
            uint8_t rc = row_pointers[y][3*x];
            uint8_t gc = row_pointers[y][3*x+1];
            uint8_t bc = row_pointers[y][3*x+2];
            CNSL_SetPixel(pixels, x, y, CNSL_MakeColor(rc, gc, bc));
        }
    }

    return pixels;
}

void ogl::texture::load_png(const void *buf, size_t len, std::vector<GLubyte>& p)
{
    // Initialize all PNG import data structures.

    png_structp rp = 0;
    png_infop   ip = 0;
    png_bytep  *bp = 0;

    if (!(rp = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0)))
        throw std::runtime_error("Failure creating PNG read structure");

    if (!(ip = png_create_info_struct(rp)))
        throw std::runtime_error("Failure creating PNG info structure");

    // Initialize the user-defined IO structure.

    struct png_user_io user;

    user.buf = (png_bytep)  buf;
    user.len = (png_size_t) len;

    png_set_read_fn(rp, &user, png_user_read);

    // Enable the default PNG error handler.

    if (setjmp(png_jmpbuf(rp)) == 0)
    {
        // Read the PNG header.

        png_read_png(rp, ip, PNG_TRANSFORM_EXPAND   |
                             PNG_TRANSFORM_PACKING  |
                             PNG_TRANSFORM_STRIP_16 |
                             PNG_TRANSFORM_SWAP_ENDIAN, 0);

        // Extract image properties.

        w = GLsizei(png_get_image_width (rp, ip));
        h = GLsizei(png_get_image_height(rp, ip));
        c = GLsizei(png_get_channels    (rp, ip));

        p.resize(w * h * c);

        // Read the pixel data.

        if ((bp = png_get_rows(rp, ip)))

            for (GLsizei i = 0, j = h - 1; i < h; ++i, --j)
                memcpy(&p[w * c * i], bp[j], (w * c));
    }

    // Release all resources.

    png_destroy_read_struct(&rp, &ip, 0);
}

/**
 * The PNG Heightmap loader.
 */
static void ReadHeightmapPNGImageData(byte *map, png_structp png_ptr, png_infop info_ptr)
{
	uint x, y;
	byte gray_palette[256];
	png_bytep *row_pointers = nullptr;
	bool has_palette = png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_PALETTE;
	uint channels = png_get_channels(png_ptr, info_ptr);

	/* Get palette and convert it to grayscale */
	if (has_palette) {
		int i;
		int palette_size;
		png_color *palette;
		bool all_gray = true;

		png_get_PLTE(png_ptr, info_ptr, &palette, &palette_size);
		for (i = 0; i < palette_size && (palette_size != 16 || all_gray); i++) {
			all_gray &= palette[i].red == palette[i].green && palette[i].red == palette[i].blue;
			gray_palette[i] = RGBToGrayscale(palette[i].red, palette[i].green, palette[i].blue);
		}

		/**
		 * For a non-gray palette of size 16 we assume that
		 * the order of the palette determines the height;
		 * the first entry is the sea (level 0), the second one
		 * level 1, etc.
		 */
		if (palette_size == 16 && !all_gray) {
			for (i = 0; i < palette_size; i++) {
				gray_palette[i] = 256 * i / palette_size;
			}
		}
	}

	row_pointers = png_get_rows(png_ptr, info_ptr);

	/* Read the raw image data and convert in 8-bit grayscale */
	for (x = 0; x < png_get_image_width(png_ptr, info_ptr); x++) {
		for (y = 0; y < png_get_image_height(png_ptr, info_ptr); y++) {
			byte *pixel = &map[y * png_get_image_width(png_ptr, info_ptr) + x];
			uint x_offset = x * channels;

			if (has_palette) {
				*pixel = gray_palette[row_pointers[y][x_offset]];
			} else if (channels == 3) {
				*pixel = RGBToGrayscale(row_pointers[y][x_offset + 0],
						row_pointers[y][x_offset + 1], row_pointers[y][x_offset + 2]);
			} else {
				*pixel = row_pointers[y][x_offset];
			}
		}
	}
}

bool PNGImageLoader::loadImageData(PixelOrigin origin, 
                                   DataSource* data, 
                                   ImageContext* context)
{
    PNGImageContext* png = static_cast<PNGImageContext*>(context);
    byte red;
    byte green;
    byte blue;
    byte alpha;
    size_t width = png->getWidth();
    size_t height = png->getHeight();
    png_bytepp row_pointers = png_get_rows(png->d_png_ptr, png->d_info_ptr);
    if (png->d_bit_depth == 8)
    {
        // Read RGBA 
        if (png->d_num_channels == 4)
        {
            for (size_t j = 0 ; j < height ; ++j)
            {
                for(size_t i = 0 ; i < width ; ++i)
                {
                    size_t pixel_offset = 4 * i;
                    red   = *(row_pointers[j] + pixel_offset);
                    green = *(row_pointers[j] + pixel_offset + 1);
                    blue  = *(row_pointers[j] + pixel_offset + 2);
                    alpha = *(row_pointers[j] + pixel_offset + 3);
                    png->setNextPixel(red, green, blue, alpha);
                }
            }
        }
        else if (png->d_num_channels == 3)
        {
            alpha = 0xff;
            for (size_t j = 0 ; j < height ; ++j)
            {
                for(size_t i = 0 ; i < width ; ++i)
                {
                    size_t pixel_offset = 3 * i;
                    red   = *(row_pointers[j] + pixel_offset);
                    green = *(row_pointers[j] + pixel_offset + 1);
                    blue  = *(row_pointers[j] + pixel_offset + 2);
                    png->setNextPixel(red, green, blue, alpha);
                }
            }

        }
    }
    if (origin == PO_BOTTOM_LEFT)
        return png->flipVertically();
    
    return true;    
}

/*
 * Analyze the usage of samples.
 * The output value usage_map[n] indicates whether the sample n
 * is used. The usage_map[] array must have 256 entries.
 * The function requires a valid bit depth between 1 and 8.
 */
static void opng_analyze_sample_usage(png_structp png_ptr, png_infop info_ptr, png_bytep usage_map)
{
   png_bytep sample_ptr;
   int init_shift, init_mask, shift, mask;
   png_uint_32 i, j;
   png_uint_32 height = png_get_image_height(png_ptr, info_ptr);
   png_uint_32 width = png_get_image_width(png_ptr, info_ptr);
   int bit_depth = png_get_bit_depth(png_ptr, info_ptr);
   png_bytepp row_ptr = png_get_rows(png_ptr, info_ptr);

   /* Initialize the output entries with 0. */
   memset(usage_map, 0, 256);

   /* Iterate through all sample values. */
   if (bit_depth == 8)
   {
      for (i = 0; i < height; ++i, ++row_ptr)
      {
         for (j = 0, sample_ptr = *row_ptr; j < width; ++j, ++sample_ptr)
            usage_map[*sample_ptr] = 1;
      }
   }
   else
   {
      OPNG_ASSERT(bit_depth < 8);
      init_shift = 8 - bit_depth;
      init_mask = (1 << 8) - (1 << init_shift);
      for (i = 0; i < height; ++i, ++row_ptr)
      {
         for (j = 0, sample_ptr = *row_ptr; j < width; ++sample_ptr)
         {
            mask = init_mask;
            shift = init_shift;
            do
            {
               usage_map[(*sample_ptr & mask) >> shift] = 1;
               mask >>= bit_depth;
               shift -= bit_depth;
               ++j;
            } while (mask > 0 && j < width);
         }
      }
   }

#ifdef PNG_bKGD_SUPPORTED
    png_color_16p background;
   /* bKGD also counts as a used sample. */
   if (png_get_bKGD(png_ptr, info_ptr, &background))
      usage_map[background->index] = 1;
#endif
}