third_party/WebKit/Source/platform/image-decoders/png/PNGImageDecoder.cpp - chromium/src - Git at Google

 /*
  * Copyright (C) 2006 Apple Computer, Inc.
  * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.
  *
  * Portions are Copyright (C) 2001 mozilla.org
  *
  * Other contributors:
  *   Stuart Parmenter <stuart@mozilla.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  *
  * Alternatively, the contents of this file may be used under the terms
  * of either the Mozilla Public License Version 1.1, found at
  * http://www.mozilla.org/MPL/ (the "MPL") or the GNU General Public
  * License Version 2.0, found at http://www.fsf.org/copyleft/gpl.html
  * (the "GPL"), in which case the provisions of the MPL or the GPL are
  * applicable instead of those above.  If you wish to allow use of your
  * version of this file only under the terms of one of those two
  * licenses (the MPL or the GPL) and not to allow others to use your
  * version of this file under the LGPL, indicate your decision by
  * deletingthe provisions above and replace them with the notice and
  * other provisions required by the MPL or the GPL, as the case may be.
  * If you do not delete the provisions above, a recipient may use your
  * version of this file under any of the LGPL, the MPL or the GPL.
  */

 #include "platform/image-decoders/png/PNGImageDecoder.h"

 #include "png.h"
 #include "wtf/PtrUtil.h"
 #include <memory>

 #if !defined(PNG_LIBPNG_VER_MAJOR) || !defined(PNG_LIBPNG_VER_MINOR)
 #error version error: compile against a versioned libpng.
 #endif

 #if PNG_LIBPNG_VER_MAJOR > 1 || \
     (PNG_LIBPNG_VER_MAJOR == 1 && PNG_LIBPNG_VER_MINOR >= 4)
 #define JMPBUF(png_ptr) png_jmpbuf(png_ptr)
 #else
 #define JMPBUF(png_ptr) png_ptr->jmpbuf
 #endif

 namespace {

 inline blink::PNGImageDecoder* imageDecoder(png_structp png) {
   return static_cast<blink::PNGImageDecoder*>(png_get_progressive_ptr(png));
 }

 void PNGAPI pngHeaderAvailable(png_structp png, png_infop) {
   imageDecoder(png)->headerAvailable();
 }

 void PNGAPI pngRowAvailable(png_structp png,
                             png_bytep row,
                             png_uint_32 rowIndex,
                             int state) {
   imageDecoder(png)->rowAvailable(row, rowIndex, state);
 }

 void PNGAPI pngComplete(png_structp png, png_infop) {
   imageDecoder(png)->complete();
 }

 void PNGAPI pngFailed(png_structp png, png_const_charp) {
   longjmp(JMPBUF(png), 1);
 }

 }  // namespace

 namespace blink {

 class PNGImageReader final {
   USING_FAST_MALLOC(PNGImageReader);
   WTF_MAKE_NONCOPYABLE(PNGImageReader);

  public:
   PNGImageReader(PNGImageDecoder* decoder, size_t readOffset)
       : m_decoder(decoder),
         m_readOffset(readOffset),
         m_currentBufferSize(0),
         m_decodingSizeOnly(false),
         m_hasAlpha(false)
   {
     m_png = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, pngFailed, 0);
     m_info = png_create_info_struct(m_png);
     png_set_progressive_read_fn(m_png, m_decoder, pngHeaderAvailable,
                                 pngRowAvailable, pngComplete);
   }

   ~PNGImageReader() {
     png_destroy_read_struct(m_png ? &m_png : 0, m_info ? &m_info : 0, 0);
     ASSERT(!m_png && !m_info);

     m_readOffset = 0;
   }

   bool decode(const SegmentReader& data, bool sizeOnly) {
     m_decodingSizeOnly = sizeOnly;

     // We need to do the setjmp here. Otherwise bad things will happen.
     if (setjmp(JMPBUF(m_png)))
       return m_decoder->setFailed();

     const char* segment;
     while (size_t segmentLength = data.getSomeData(segment, m_readOffset)) {
       m_readOffset += segmentLength;
       m_currentBufferSize = m_readOffset;
       png_process_data(m_png, m_info,
                        reinterpret_cast<png_bytep>(const_cast<char*>(segment)),
                        segmentLength);
       if (sizeOnly ? m_decoder->isDecodedSizeAvailable()
                    : m_decoder->frameIsCompleteAtIndex(0))
         return true;
     }

     return false;
   }

   png_structp pngPtr() const { return m_png; }
   png_infop infoPtr() const { return m_info; }

   size_t getReadOffset() const { return m_readOffset; }
   void setReadOffset(size_t offset) { m_readOffset = offset; }
   size_t currentBufferSize() const { return m_currentBufferSize; }
   bool decodingSizeOnly() const { return m_decodingSizeOnly; }
   void setHasAlpha(bool hasAlpha) { m_hasAlpha = hasAlpha; }
   bool hasAlpha() const { return m_hasAlpha; }

   png_bytep interlaceBuffer() const { return m_interlaceBuffer.get(); }
   void createInterlaceBuffer(int size) {
     m_interlaceBuffer = wrapArrayUnique(new png_byte[size]);
   }

  private:
   png_structp m_png;
   png_infop m_info;
   PNGImageDecoder* m_decoder;
   size_t m_readOffset;
   size_t m_currentBufferSize;
   bool m_decodingSizeOnly;
   bool m_hasAlpha;
   std::unique_ptr<png_byte[]> m_interlaceBuffer;
 };

 PNGImageDecoder::PNGImageDecoder(AlphaOption alphaOption,
                                  ColorSpaceOption colorOptions,
                                  size_t maxDecodedBytes,
                                  size_t offset)
     : ImageDecoder(alphaOption, colorOptions, maxDecodedBytes),
       m_offset(offset) {}

 PNGImageDecoder::~PNGImageDecoder() {}

 void PNGImageDecoder::headerAvailable() {
   png_structp png = m_reader->pngPtr();
   png_infop info = m_reader->infoPtr();
   png_uint_32 width = png_get_image_width(png, info);
   png_uint_32 height = png_get_image_height(png, info);

   // Protect against large PNGs. See http://bugzil.la/251381 for more details.
   const unsigned long maxPNGSize = 1000000UL;
   if (width > maxPNGSize || height > maxPNGSize) {
     longjmp(JMPBUF(png), 1);
     return;
   }

   // Set the image size now that the image header is available.
   if (!setSize(width, height)) {
     longjmp(JMPBUF(png), 1);
     return;
   }

   int bitDepth, colorType, interlaceType, compressionType, filterType, channels;
   png_get_IHDR(png, info, &width, &height, &bitDepth, &colorType,
                &interlaceType, &compressionType, &filterType);

   // The options we set here match what Mozilla does.

   // Expand to ensure we use 24-bit for RGB and 32-bit for RGBA.
   if (colorType == PNG_COLOR_TYPE_PALETTE ||
       (colorType == PNG_COLOR_TYPE_GRAY && bitDepth < 8))
     png_set_expand(png);

   png_bytep trns = 0;
   int trnsCount = 0;
   if (png_get_valid(png, info, PNG_INFO_tRNS)) {
     png_get_tRNS(png, info, &trns, &trnsCount, 0);
     png_set_expand(png);
   }

   if (bitDepth == 16)
     png_set_strip_16(png);

   if (colorType == PNG_COLOR_TYPE_GRAY ||
       colorType == PNG_COLOR_TYPE_GRAY_ALPHA)
     png_set_gray_to_rgb(png);

   if ((colorType & PNG_COLOR_MASK_COLOR) && !m_ignoreColorSpace) {
     // We only support color profiles for color PALETTE and RGB[A] PNG.
     // Supporting color profiles for gray-scale images is slightly tricky, at
     // least using the CoreGraphics ICC library, because we expand gray-scale
     // images to RGB but we do not similarly transform the color profile. We'd
     // either need to transform the color profile or we'd need to decode into a
     // gray-scale image buffer and hand that to CoreGraphics.
 #ifdef PNG_iCCP_SUPPORTED
     if (png_get_valid(png, info, PNG_INFO_sRGB)) {
       setColorSpaceAndComputeTransform(
           SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named));
     } else {
       char* profileName = nullptr;
       int compressionType = 0;
 #if (PNG_LIBPNG_VER < 10500)
       png_charp profile = nullptr;
 #else
       png_bytep profile = nullptr;
 #endif
       png_uint_32 profileLength = 0;
       if (png_get_iCCP(png, info, &profileName, &compressionType, &profile,
                        &profileLength)) {
         setColorProfileAndComputeTransform(reinterpret_cast<char*>(profile),
                                            profileLength);
       }
     }
 #endif  // PNG_iCCP_SUPPORTED
   }

   if (!hasEmbeddedColorSpace()) {
     // TODO (msarett):
     // Applying the transfer function (gamma) should be handled by
     // SkColorSpaceXform.  Here we always convert to a transfer function that
     // is a 2.2 exponential.  This is a little strange given that the dst
     // transfer function is not necessarily a 2.2 exponential.
     // TODO (msarett):
     // Often, PNGs that specify their transfer function with the gAMA tag will
     // also specify their gamut with the cHRM tag.  We should read this tag
     // and do a full color space transformation if it is present.
     const double inverseGamma = 0.45455;
     const double defaultGamma = 2.2;
     double gamma;
     if (!m_ignoreColorSpace && png_get_gAMA(png, info, &gamma)) {
       const double maxGamma = 21474.83;
       if ((gamma <= 0.0) || (gamma > maxGamma)) {
         gamma = inverseGamma;
         png_set_gAMA(png, info, gamma);
       }
       png_set_gamma(png, defaultGamma, gamma);
     } else {
       png_set_gamma(png, defaultGamma, inverseGamma);
     }
   }

   // Tell libpng to send us rows for interlaced pngs.
   if (interlaceType == PNG_INTERLACE_ADAM7)
     png_set_interlace_handling(png);

   // Update our info now.
   png_read_update_info(png, info);
   channels = png_get_channels(png, info);
   ASSERT(channels == 3 || channels == 4);

   m_reader->setHasAlpha(channels == 4);

   if (m_reader->decodingSizeOnly()) {
 // If we only needed the size, halt the reader.
 #if PNG_LIBPNG_VER_MAJOR > 1 || \
     (PNG_LIBPNG_VER_MAJOR == 1 && PNG_LIBPNG_VER_MINOR >= 5)
     // Passing '0' tells png_process_data_pause() not to cache unprocessed data.
     m_reader->setReadOffset(m_reader->currentBufferSize() -
                             png_process_data_pause(png, 0));
 #else
     m_reader->setReadOffset(m_reader->currentBufferSize() - png->buffer_size);
     png->buffer_size = 0;
 #endif
   }
 }

 void PNGImageDecoder::rowAvailable(unsigned char* rowBuffer,
                                    unsigned rowIndex,
                                    int) {
   if (m_frameBufferCache.isEmpty())
     return;

   // Initialize the framebuffer if needed.
   ImageFrame& buffer = m_frameBufferCache[0];
   if (buffer.getStatus() == ImageFrame::FrameEmpty) {
     png_structp png = m_reader->pngPtr();
     if (!buffer.setSizeAndColorSpace(size().width(), size().height(),
                                      colorSpace())) {
       longjmp(JMPBUF(png), 1);
       return;
     }

     unsigned colorChannels = m_reader->hasAlpha() ? 4 : 3;
     if (PNG_INTERLACE_ADAM7 ==
         png_get_interlace_type(png, m_reader->infoPtr())) {
       m_reader->createInterlaceBuffer(colorChannels * size().width() *
                                       size().height());
       if (!m_reader->interlaceBuffer()) {
         longjmp(JMPBUF(png), 1);
         return;
       }
     }

     buffer.setStatus(ImageFrame::FramePartial);
     buffer.setHasAlpha(false);

     // For PNGs, the frame always fills the entire image.
     buffer.setOriginalFrameRect(IntRect(IntPoint(), size()));
   }

   /* libpng comments (here to explain what follows).
      *
      * this function is called for every row in the image. If the
      * image is interlacing, and you turned on the interlace handler,
      * this function will be called for every row in every pass.
      * Some of these rows will not be changed from the previous pass.
      * When the row is not changed, the new_row variable will be NULL.
      * The rows and passes are called in order, so you don't really
      * need the row_num and pass, but I'm supplying them because it
      * may make your life easier.
      */

   // Nothing to do if the row is unchanged, or the row is outside
   // the image bounds: libpng may send extra rows, ignore them to
   // make our lives easier.
   if (!rowBuffer)
     return;
   int y = rowIndex;
   if (y < 0 || y >= size().height())
     return;

   /* libpng comments (continued).
      *
      * For the non-NULL rows of interlaced images, you must call
      * png_progressive_combine_row() passing in the row and the
      * old row.  You can call this function for NULL rows (it will
      * just return) and for non-interlaced images (it just does the
      * memcpy for you) if it will make the code easier. Thus, you
      * can just do this for all cases:
      *
      *    png_progressive_combine_row(png_ptr, old_row, new_row);
      *
      * where old_row is what was displayed for previous rows. Note
      * that the first pass (pass == 0 really) will completely cover
      * the old row, so the rows do not have to be initialized. After
      * the first pass (and only for interlaced images), you will have
      * to pass the current row, and the function will combine the
      * old row and the new row.
      */

   bool hasAlpha = m_reader->hasAlpha();
   png_bytep row = rowBuffer;

   if (png_bytep interlaceBuffer = m_reader->interlaceBuffer()) {
     unsigned colorChannels = hasAlpha ? 4 : 3;
     row = interlaceBuffer + (rowIndex * colorChannels * size().width());
     png_progressive_combine_row(m_reader->pngPtr(), row, rowBuffer);
   }

   // Write the decoded row pixels to the frame buffer. The repetitive
   // form of the row write loops is for speed.
   ImageFrame::PixelData* const dstRow = buffer.getAddr(0, y);
   unsigned alphaMask = 255;
   int width = size().width();

   png_bytep srcPtr = row;
   if (hasAlpha) {
     // Here we apply the color space transformation to the dst space.
     // It does not really make sense to transform to a gamma-encoded
     // space and then immediately after, perform a linear premultiply.
     // Ideally we would pass kPremul_SkAlphaType to xform->apply(),
     // instructing SkColorSpaceXform to perform the linear premultiply
     // while the pixels are a linear space.
     // We cannot do this because when we apply the gamma encoding after
     // the premultiply, we will very likely end up with valid pixels
     // where R, G, and/or B are greater than A.  The legacy drawing
     // pipeline does not know how to handle this.
     if (SkColorSpaceXform* xform = colorTransform()) {
       SkColorSpaceXform::ColorFormat colorFormat =
           SkColorSpaceXform::kRGBA_8888_ColorFormat;
       xform->apply(colorFormat, dstRow, colorFormat, srcPtr, size().width(),
                    kUnpremul_SkAlphaType);
       srcPtr = (png_bytep)dstRow;
     }

     if (buffer.premultiplyAlpha()) {
       for (auto *dstPixel = dstRow; dstPixel < dstRow + width;
            dstPixel++, srcPtr += 4) {
         buffer.setRGBAPremultiply(dstPixel, srcPtr[0], srcPtr[1], srcPtr[2],
                                   srcPtr[3]);
         alphaMask &= srcPtr[3];
       }
     } else {
       for (auto *dstPixel = dstRow; dstPixel < dstRow + width;
            dstPixel++, srcPtr += 4) {
         buffer.setRGBARaw(dstPixel, srcPtr[0], srcPtr[1], srcPtr[2], srcPtr[3]);
         alphaMask &= srcPtr[3];
       }
     }
   } else {
     for (auto *dstPixel = dstRow; dstPixel < dstRow + width;
          dstPixel++, srcPtr += 3) {
       buffer.setRGBARaw(dstPixel, srcPtr[0], srcPtr[1], srcPtr[2], 255);
     }

     // We'll apply the color space xform to opaque pixels after they have been
     // written to the ImageFrame, purely because SkColorSpaceXform supports
     // RGBA (and not RGB).
     if (SkColorSpaceXform* xform = colorTransform()) {
       xform->apply(xformColorFormat(), dstRow, xformColorFormat(), dstRow,
                    size().width(), kOpaque_SkAlphaType);
     }
   }

   if (alphaMask != 255 && !buffer.hasAlpha())
     buffer.setHasAlpha(true);

   buffer.setPixelsChanged(true);
 }

 void PNGImageDecoder::complete() {
   if (m_frameBufferCache.isEmpty())
     return;

   m_frameBufferCache[0].setStatus(ImageFrame::FrameComplete);
 }

 inline bool isComplete(const PNGImageDecoder* decoder) {
   return decoder->frameIsCompleteAtIndex(0);
 }

 void PNGImageDecoder::decode(bool onlySize) {
   if (failed())
     return;

   if (!m_reader)
     m_reader = wrapUnique(new PNGImageReader(this, m_offset));

   // If we couldn't decode the image but have received all the data, decoding
   // has failed.
   if (!m_reader->decode(*m_data, onlySize) && isAllDataReceived())
     setFailed();

   // If decoding is done or failed, we don't need the PNGImageReader anymore.
   if (isComplete(this) || failed())
     m_reader.reset();
 }

 }  // namespace blink
	/*
	* Copyright (C) 2006 Apple Computer, Inc.
	* Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.
	*
	* Portions are Copyright (C) 2001 mozilla.org
	*
	* Other contributors:
	* Stuart Parmenter <stuart@mozilla.com>
	*
	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public
	* License as published by the Free Software Foundation; either
	* version 2.1 of the License, or (at your option) any later version.
	*
	* This library is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public
	* License along with this library; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	*
	* Alternatively, the contents of this file may be used under the terms
	* of either the Mozilla Public License Version 1.1, found at
	* http://www.mozilla.org/MPL/ (the "MPL") or the GNU General Public
	* License Version 2.0, found at http://www.fsf.org/copyleft/gpl.html
	* (the "GPL"), in which case the provisions of the MPL or the GPL are
	* applicable instead of those above. If you wish to allow use of your
	* version of this file only under the terms of one of those two
	* licenses (the MPL or the GPL) and not to allow others to use your
	* version of this file under the LGPL, indicate your decision by
	* deletingthe provisions above and replace them with the notice and
	* other provisions required by the MPL or the GPL, as the case may be.
	* If you do not delete the provisions above, a recipient may use your
	* version of this file under any of the LGPL, the MPL or the GPL.
	*/

	#include "platform/image-decoders/png/PNGImageDecoder.h"

	#include "png.h"
	#include "wtf/PtrUtil.h"
	#include <memory>

	#if !defined(PNG_LIBPNG_VER_MAJOR) \|\| !defined(PNG_LIBPNG_VER_MINOR)
	#error version error: compile against a versioned libpng.
	#endif

	#if PNG_LIBPNG_VER_MAJOR > 1 \|\| \
	(PNG_LIBPNG_VER_MAJOR == 1 && PNG_LIBPNG_VER_MINOR >= 4)
	#define JMPBUF(png_ptr) png_jmpbuf(png_ptr)
	#else
	#define JMPBUF(png_ptr) png_ptr->jmpbuf
	#endif

	namespace {

	inline blink::PNGImageDecoder* imageDecoder(png_structp png) {
	return static_cast<blink::PNGImageDecoder*>(png_get_progressive_ptr(png));
	}

	void PNGAPI pngHeaderAvailable(png_structp png, png_infop) {
	imageDecoder(png)->headerAvailable();
	}

	void PNGAPI pngRowAvailable(png_structp png,
	png_bytep row,
	png_uint_32 rowIndex,
	int state) {
	imageDecoder(png)->rowAvailable(row, rowIndex, state);
	}

	void PNGAPI pngComplete(png_structp png, png_infop) {
	imageDecoder(png)->complete();
	}

	void PNGAPI pngFailed(png_structp png, png_const_charp) {
	longjmp(JMPBUF(png), 1);
	}

	} // namespace

	namespace blink {

	class PNGImageReader final {
	USING_FAST_MALLOC(PNGImageReader);
	WTF_MAKE_NONCOPYABLE(PNGImageReader);

	public:
	PNGImageReader(PNGImageDecoder* decoder, size_t readOffset)
	: m_decoder(decoder),
	m_readOffset(readOffset),
	m_currentBufferSize(0),
	m_decodingSizeOnly(false),
	m_hasAlpha(false)
	{
	m_png = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, pngFailed, 0);
	m_info = png_create_info_struct(m_png);
	png_set_progressive_read_fn(m_png, m_decoder, pngHeaderAvailable,
	pngRowAvailable, pngComplete);
	}

	~PNGImageReader() {
	png_destroy_read_struct(m_png ? &m_png : 0, m_info ? &m_info : 0, 0);
	ASSERT(!m_png && !m_info);

	m_readOffset = 0;
	}

	bool decode(const SegmentReader& data, bool sizeOnly) {
	m_decodingSizeOnly = sizeOnly;

	// We need to do the setjmp here. Otherwise bad things will happen.
	if (setjmp(JMPBUF(m_png)))
	return m_decoder->setFailed();

	const char* segment;
	while (size_t segmentLength = data.getSomeData(segment, m_readOffset)) {
	m_readOffset += segmentLength;
	m_currentBufferSize = m_readOffset;
	png_process_data(m_png, m_info,
	reinterpret_cast<png_bytep>(const_cast<char*>(segment)),
	segmentLength);
	if (sizeOnly ? m_decoder->isDecodedSizeAvailable()
	: m_decoder->frameIsCompleteAtIndex(0))
	return true;
	}

	return false;
	}

	png_structp pngPtr() const { return m_png; }
	png_infop infoPtr() const { return m_info; }

	size_t getReadOffset() const { return m_readOffset; }
	void setReadOffset(size_t offset) { m_readOffset = offset; }
	size_t currentBufferSize() const { return m_currentBufferSize; }
	bool decodingSizeOnly() const { return m_decodingSizeOnly; }
	void setHasAlpha(bool hasAlpha) { m_hasAlpha = hasAlpha; }
	bool hasAlpha() const { return m_hasAlpha; }

	png_bytep interlaceBuffer() const { return m_interlaceBuffer.get(); }
	void createInterlaceBuffer(int size) {
	m_interlaceBuffer = wrapArrayUnique(new png_byte[size]);
	}

	private:
	png_structp m_png;
	png_infop m_info;
	PNGImageDecoder* m_decoder;
	size_t m_readOffset;
	size_t m_currentBufferSize;
	bool m_decodingSizeOnly;
	bool m_hasAlpha;
	std::unique_ptr<png_byte[]> m_interlaceBuffer;
	};

	PNGImageDecoder::PNGImageDecoder(AlphaOption alphaOption,
	ColorSpaceOption colorOptions,
	size_t maxDecodedBytes,
	size_t offset)
	: ImageDecoder(alphaOption, colorOptions, maxDecodedBytes),
	m_offset(offset) {}

	PNGImageDecoder::~PNGImageDecoder() {}

	void PNGImageDecoder::headerAvailable() {
	png_structp png = m_reader->pngPtr();
	png_infop info = m_reader->infoPtr();
	png_uint_32 width = png_get_image_width(png, info);
	png_uint_32 height = png_get_image_height(png, info);

	// Protect against large PNGs. See http://bugzil.la/251381 for more details.
	const unsigned long maxPNGSize = 1000000UL;
	if (width > maxPNGSize \|\| height > maxPNGSize) {
	longjmp(JMPBUF(png), 1);
	return;
	}

	// Set the image size now that the image header is available.
	if (!setSize(width, height)) {
	longjmp(JMPBUF(png), 1);
	return;
	}

	int bitDepth, colorType, interlaceType, compressionType, filterType, channels;
	png_get_IHDR(png, info, &width, &height, &bitDepth, &colorType,
	&interlaceType, &compressionType, &filterType);

	// The options we set here match what Mozilla does.

	// Expand to ensure we use 24-bit for RGB and 32-bit for RGBA.
	if (colorType == PNG_COLOR_TYPE_PALETTE \|\|
	(colorType == PNG_COLOR_TYPE_GRAY && bitDepth < 8))
	png_set_expand(png);

	png_bytep trns = 0;
	int trnsCount = 0;
	if (png_get_valid(png, info, PNG_INFO_tRNS)) {
	png_get_tRNS(png, info, &trns, &trnsCount, 0);
	png_set_expand(png);
	}

	if (bitDepth == 16)
	png_set_strip_16(png);

	if (colorType == PNG_COLOR_TYPE_GRAY \|\|
	colorType == PNG_COLOR_TYPE_GRAY_ALPHA)
	png_set_gray_to_rgb(png);

	if ((colorType & PNG_COLOR_MASK_COLOR) && !m_ignoreColorSpace) {
	// We only support color profiles for color PALETTE and RGB[A] PNG.
	// Supporting color profiles for gray-scale images is slightly tricky, at
	// least using the CoreGraphics ICC library, because we expand gray-scale
	// images to RGB but we do not similarly transform the color profile. We'd
	// either need to transform the color profile or we'd need to decode into a
	// gray-scale image buffer and hand that to CoreGraphics.
	#ifdef PNG_iCCP_SUPPORTED
	if (png_get_valid(png, info, PNG_INFO_sRGB)) {
	setColorSpaceAndComputeTransform(
	SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named));
	} else {
	char* profileName = nullptr;
	int compressionType = 0;
	#if (PNG_LIBPNG_VER < 10500)
	png_charp profile = nullptr;
	#else
	png_bytep profile = nullptr;
	#endif
	png_uint_32 profileLength = 0;
	if (png_get_iCCP(png, info, &profileName, &compressionType, &profile,
	&profileLength)) {
	setColorProfileAndComputeTransform(reinterpret_cast<char*>(profile),
	profileLength);
	}
	}
	#endif // PNG_iCCP_SUPPORTED
	}

	if (!hasEmbeddedColorSpace()) {
	// TODO (msarett):
	// Applying the transfer function (gamma) should be handled by
	// SkColorSpaceXform. Here we always convert to a transfer function that
	// is a 2.2 exponential. This is a little strange given that the dst
	// transfer function is not necessarily a 2.2 exponential.
	// TODO (msarett):
	// Often, PNGs that specify their transfer function with the gAMA tag will
	// also specify their gamut with the cHRM tag. We should read this tag
	// and do a full color space transformation if it is present.
	const double inverseGamma = 0.45455;
	const double defaultGamma = 2.2;
	double gamma;
	if (!m_ignoreColorSpace && png_get_gAMA(png, info, &gamma)) {
	const double maxGamma = 21474.83;
	if ((gamma <= 0.0) \|\| (gamma > maxGamma)) {
	gamma = inverseGamma;
	png_set_gAMA(png, info, gamma);
	}
	png_set_gamma(png, defaultGamma, gamma);
	} else {
	png_set_gamma(png, defaultGamma, inverseGamma);
	}
	}

	// Tell libpng to send us rows for interlaced pngs.
	if (interlaceType == PNG_INTERLACE_ADAM7)
	png_set_interlace_handling(png);

	// Update our info now.
	png_read_update_info(png, info);
	channels = png_get_channels(png, info);
	ASSERT(channels == 3 \|\| channels == 4);

	m_reader->setHasAlpha(channels == 4);

	if (m_reader->decodingSizeOnly()) {
	// If we only needed the size, halt the reader.
	#if PNG_LIBPNG_VER_MAJOR > 1 \|\| \
	(PNG_LIBPNG_VER_MAJOR == 1 && PNG_LIBPNG_VER_MINOR >= 5)
	// Passing '0' tells png_process_data_pause() not to cache unprocessed data.
	m_reader->setReadOffset(m_reader->currentBufferSize() -
	png_process_data_pause(png, 0));
	#else
	m_reader->setReadOffset(m_reader->currentBufferSize() - png->buffer_size);
	png->buffer_size = 0;
	#endif
	}
	}

	void PNGImageDecoder::rowAvailable(unsigned char* rowBuffer,
	unsigned rowIndex,
	int) {
	if (m_frameBufferCache.isEmpty())
	return;

	// Initialize the framebuffer if needed.
	ImageFrame& buffer = m_frameBufferCache[0];
	if (buffer.getStatus() == ImageFrame::FrameEmpty) {
	png_structp png = m_reader->pngPtr();
	if (!buffer.setSizeAndColorSpace(size().width(), size().height(),
	colorSpace())) {
	longjmp(JMPBUF(png), 1);
	return;
	}

	unsigned colorChannels = m_reader->hasAlpha() ? 4 : 3;
	if (PNG_INTERLACE_ADAM7 ==
	png_get_interlace_type(png, m_reader->infoPtr())) {
	m_reader->createInterlaceBuffer(colorChannels * size().width() *
	size().height());
	if (!m_reader->interlaceBuffer()) {
	longjmp(JMPBUF(png), 1);
	return;
	}
	}

	buffer.setStatus(ImageFrame::FramePartial);
	buffer.setHasAlpha(false);

	// For PNGs, the frame always fills the entire image.
	buffer.setOriginalFrameRect(IntRect(IntPoint(), size()));
	}

	/* libpng comments (here to explain what follows).
	*
	* this function is called for every row in the image. If the
	* image is interlacing, and you turned on the interlace handler,
	* this function will be called for every row in every pass.
	* Some of these rows will not be changed from the previous pass.
	* When the row is not changed, the new_row variable will be NULL.
	* The rows and passes are called in order, so you don't really
	* need the row_num and pass, but I'm supplying them because it
	* may make your life easier.
	*/

	// Nothing to do if the row is unchanged, or the row is outside
	// the image bounds: libpng may send extra rows, ignore them to
	// make our lives easier.
	if (!rowBuffer)
	return;
	int y = rowIndex;
	if (y < 0 \|\| y >= size().height())
	return;

	/* libpng comments (continued).
	*
	* For the non-NULL rows of interlaced images, you must call
	* png_progressive_combine_row() passing in the row and the
	* old row. You can call this function for NULL rows (it will
	* just return) and for non-interlaced images (it just does the
	* memcpy for you) if it will make the code easier. Thus, you
	* can just do this for all cases:
	*
	* png_progressive_combine_row(png_ptr, old_row, new_row);
	*
	* where old_row is what was displayed for previous rows. Note
	* that the first pass (pass == 0 really) will completely cover
	* the old row, so the rows do not have to be initialized. After
	* the first pass (and only for interlaced images), you will have
	* to pass the current row, and the function will combine the
	* old row and the new row.
	*/

	bool hasAlpha = m_reader->hasAlpha();
	png_bytep row = rowBuffer;

	if (png_bytep interlaceBuffer = m_reader->interlaceBuffer()) {
	unsigned colorChannels = hasAlpha ? 4 : 3;
	row = interlaceBuffer + (rowIndex * colorChannels * size().width());
	png_progressive_combine_row(m_reader->pngPtr(), row, rowBuffer);
	}

	// Write the decoded row pixels to the frame buffer. The repetitive
	// form of the row write loops is for speed.
	ImageFrame::PixelData* const dstRow = buffer.getAddr(0, y);
	unsigned alphaMask = 255;
	int width = size().width();

	png_bytep srcPtr = row;
	if (hasAlpha) {
	// Here we apply the color space transformation to the dst space.
	// It does not really make sense to transform to a gamma-encoded
	// space and then immediately after, perform a linear premultiply.
	// Ideally we would pass kPremul_SkAlphaType to xform->apply(),
	// instructing SkColorSpaceXform to perform the linear premultiply
	// while the pixels are a linear space.
	// We cannot do this because when we apply the gamma encoding after
	// the premultiply, we will very likely end up with valid pixels
	// where R, G, and/or B are greater than A. The legacy drawing
	// pipeline does not know how to handle this.
	if (SkColorSpaceXform* xform = colorTransform()) {
	SkColorSpaceXform::ColorFormat colorFormat =
	SkColorSpaceXform::kRGBA_8888_ColorFormat;
	xform->apply(colorFormat, dstRow, colorFormat, srcPtr, size().width(),
	kUnpremul_SkAlphaType);
	srcPtr = (png_bytep)dstRow;
	}

	if (buffer.premultiplyAlpha()) {
	for (auto *dstPixel = dstRow; dstPixel < dstRow + width;
	dstPixel++, srcPtr += 4) {
	buffer.setRGBAPremultiply(dstPixel, srcPtr[0], srcPtr[1], srcPtr[2],
	srcPtr[3]);
	alphaMask &= srcPtr[3];
	}
	} else {
	for (auto *dstPixel = dstRow; dstPixel < dstRow + width;
	dstPixel++, srcPtr += 4) {
	buffer.setRGBARaw(dstPixel, srcPtr[0], srcPtr[1], srcPtr[2], srcPtr[3]);
	alphaMask &= srcPtr[3];
	}
	}
	} else {
	for (auto *dstPixel = dstRow; dstPixel < dstRow + width;
	dstPixel++, srcPtr += 3) {
	buffer.setRGBARaw(dstPixel, srcPtr[0], srcPtr[1], srcPtr[2], 255);
	}

	// We'll apply the color space xform to opaque pixels after they have been
	// written to the ImageFrame, purely because SkColorSpaceXform supports
	// RGBA (and not RGB).
	if (SkColorSpaceXform* xform = colorTransform()) {
	xform->apply(xformColorFormat(), dstRow, xformColorFormat(), dstRow,
	size().width(), kOpaque_SkAlphaType);
	}
	}

	if (alphaMask != 255 && !buffer.hasAlpha())
	buffer.setHasAlpha(true);

	buffer.setPixelsChanged(true);
	}

	void PNGImageDecoder::complete() {
	if (m_frameBufferCache.isEmpty())
	return;

	m_frameBufferCache[0].setStatus(ImageFrame::FrameComplete);
	}

	inline bool isComplete(const PNGImageDecoder* decoder) {
	return decoder->frameIsCompleteAtIndex(0);
	}

	void PNGImageDecoder::decode(bool onlySize) {
	if (failed())
	return;

	if (!m_reader)
	m_reader = wrapUnique(new PNGImageReader(this, m_offset));

	// If we couldn't decode the image but have received all the data, decoding
	// has failed.
	if (!m_reader->decode(*m_data, onlySize) && isAllDataReceived())
	setFailed();

	// If decoding is done or failed, we don't need the PNGImageReader anymore.
	if (isComplete(this) \|\| failed())
	m_reader.reset();
	}

	} // namespace blink