diff options
author | Steve Block <steveblock@google.com> | 2011-05-06 11:45:16 +0100 |
---|---|---|
committer | Steve Block <steveblock@google.com> | 2011-05-12 13:44:10 +0100 |
commit | cad810f21b803229eb11403f9209855525a25d57 (patch) | |
tree | 29a6fd0279be608e0fe9ffe9841f722f0f4e4269 /Source/WebCore/platform/image-decoders/png | |
parent | 121b0cf4517156d0ac5111caf9830c51b69bae8f (diff) | |
download | external_webkit-cad810f21b803229eb11403f9209855525a25d57.zip external_webkit-cad810f21b803229eb11403f9209855525a25d57.tar.gz external_webkit-cad810f21b803229eb11403f9209855525a25d57.tar.bz2 |
Merge WebKit at r75315: Initial merge by git.
Change-Id: I570314b346ce101c935ed22a626b48c2af266b84
Diffstat (limited to 'Source/WebCore/platform/image-decoders/png')
-rw-r--r-- | Source/WebCore/platform/image-decoders/png/PNGImageDecoder.cpp | 434 | ||||
-rw-r--r-- | Source/WebCore/platform/image-decoders/png/PNGImageDecoder.h | 74 |
2 files changed, 508 insertions, 0 deletions
diff --git a/Source/WebCore/platform/image-decoders/png/PNGImageDecoder.cpp b/Source/WebCore/platform/image-decoders/png/PNGImageDecoder.cpp new file mode 100644 index 0000000..3fe4d3c --- /dev/null +++ b/Source/WebCore/platform/image-decoders/png/PNGImageDecoder.cpp @@ -0,0 +1,434 @@ +/* + * Copyright (C) 2006 Apple Computer, Inc. + * Copyright (C) 2007-2009 Torch Mobile, 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 "config.h" +#include "PNGImageDecoder.h" +#include "png.h" + +#if defined(PNG_LIBPNG_VER_MAJOR) && defined(PNG_LIBPNG_VER_MINOR) && (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 WebCore { + +// Gamma constants. +const double cMaxGamma = 21474.83; +const double cDefaultGamma = 2.2; +const double cInverseGamma = 0.45455; + +// Protect against large PNGs. See Mozilla's bug #251381 for more info. +const unsigned long cMaxPNGSize = 1000000UL; + +// Called if the decoding of the image fails. +static void PNGAPI decodingFailed(png_structp png, png_const_charp) +{ + longjmp(JMPBUF(png), 1); +} + +// Callbacks given to the read struct. The first is for warnings (we want to +// treat a particular warning as an error, which is why we have to register this +// callback). +static void PNGAPI decodingWarning(png_structp png, png_const_charp warningMsg) +{ + // Mozilla did this, so we will too. + // Convert a tRNS warning to be an error (see + // http://bugzilla.mozilla.org/show_bug.cgi?id=251381 ) + if (!strncmp(warningMsg, "Missing PLTE before tRNS", 24)) + png_error(png, warningMsg); +} + +// Called when we have obtained the header information (including the size). +static void PNGAPI headerAvailable(png_structp png, png_infop) +{ + static_cast<PNGImageDecoder*>(png_get_progressive_ptr(png))->headerAvailable(); +} + +// Called when a row is ready. +static void PNGAPI rowAvailable(png_structp png, png_bytep rowBuffer, png_uint_32 rowIndex, int interlacePass) +{ + static_cast<PNGImageDecoder*>(png_get_progressive_ptr(png))->rowAvailable(rowBuffer, rowIndex, interlacePass); +} + +// Called when we have completely finished decoding the image. +static void PNGAPI pngComplete(png_structp png, png_infop) +{ + static_cast<PNGImageDecoder*>(png_get_progressive_ptr(png))->pngComplete(); +} + +class PNGImageReader +{ +public: + PNGImageReader(PNGImageDecoder* decoder) + : m_readOffset(0) + , m_decodingSizeOnly(false) + , m_interlaceBuffer(0) + , m_hasAlpha(false) + , m_currentBufferSize(0) + { + m_png = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, decodingFailed, decodingWarning); + m_info = png_create_info_struct(m_png); + png_set_progressive_read_fn(m_png, decoder, headerAvailable, rowAvailable, pngComplete); + } + + ~PNGImageReader() + { + close(); + } + + void close() + { + if (m_png && m_info) + // This will zero the pointers. + png_destroy_read_struct(&m_png, &m_info, 0); + delete[] m_interlaceBuffer; + m_interlaceBuffer = 0; + m_readOffset = 0; + } + + unsigned currentBufferSize() const { return m_currentBufferSize; } + + bool decode(const SharedBuffer& data, bool sizeOnly) + { + m_decodingSizeOnly = sizeOnly; + PNGImageDecoder* decoder = static_cast<PNGImageDecoder*>(png_get_progressive_ptr(m_png)); + + // We need to do the setjmp here. Otherwise bad things will happen. + if (setjmp(JMPBUF(m_png))) + return decoder->setFailed(); + + const char* segment; + while (unsigned 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); + // We explicitly specify the superclass isSizeAvailable() because we + // merely want to check if we've managed to set the size, not + // (recursively) trigger additional decoding if we haven't. + if (sizeOnly ? decoder->ImageDecoder::isSizeAvailable() : decoder->isComplete()) + return true; + } + return false; + } + + bool decodingSizeOnly() const { return m_decodingSizeOnly; } + png_structp pngPtr() const { return m_png; } + png_infop infoPtr() const { return m_info; } + png_bytep interlaceBuffer() const { return m_interlaceBuffer; } + bool hasAlpha() const { return m_hasAlpha; } + + void setReadOffset(unsigned offset) { m_readOffset = offset; } + void setHasAlpha(bool b) { m_hasAlpha = b; } + + void createInterlaceBuffer(int size) { m_interlaceBuffer = new png_byte[size]; } + +private: + unsigned m_readOffset; + bool m_decodingSizeOnly; + png_structp m_png; + png_infop m_info; + png_bytep m_interlaceBuffer; + bool m_hasAlpha; + unsigned m_currentBufferSize; +}; + +PNGImageDecoder::PNGImageDecoder(ImageSource::AlphaOption alphaOption, + ImageSource::GammaAndColorProfileOption gammaAndColorProfileOption) + : ImageDecoder(alphaOption, gammaAndColorProfileOption) + , m_doNothingOnFailure(false) +{ +} + +PNGImageDecoder::~PNGImageDecoder() +{ +} + +bool PNGImageDecoder::isSizeAvailable() +{ + if (!ImageDecoder::isSizeAvailable()) + decode(true); + + return ImageDecoder::isSizeAvailable(); +} + +bool PNGImageDecoder::setSize(unsigned width, unsigned height) +{ + if (!ImageDecoder::setSize(width, height)) + return false; + + prepareScaleDataIfNecessary(); + return true; +} + +RGBA32Buffer* PNGImageDecoder::frameBufferAtIndex(size_t index) +{ + if (index) + return 0; + + if (m_frameBufferCache.isEmpty()) { + m_frameBufferCache.resize(1); + m_frameBufferCache[0].setPremultiplyAlpha(m_premultiplyAlpha); + } + + RGBA32Buffer& frame = m_frameBufferCache[0]; + if (frame.status() != RGBA32Buffer::FrameComplete) + decode(false); + return &frame; +} + +bool PNGImageDecoder::setFailed() +{ + if (m_doNothingOnFailure) + return false; + m_reader.clear(); + return ImageDecoder::setFailed(); +} + +static ColorProfile readColorProfile(png_structp png, png_infop info) +{ +#ifdef PNG_iCCP_SUPPORTED + char* profileName; + int compressionType; + char* profile; + png_uint_32 profileLength; + if (png_get_iCCP(png, info, &profileName, &compressionType, &profile, &profileLength)) { + ColorProfile colorProfile; + colorProfile.append(profile, profileLength); + return colorProfile; + } +#endif + return ColorProfile(); +} + +void PNGImageDecoder::headerAvailable() +{ + png_structp png = m_reader->pngPtr(); + png_infop info = m_reader->infoPtr(); + png_uint_32 width = png->width; + png_uint_32 height = png->height; + + // Protect against large images. + if (png->width > cMaxPNGSize || png->height > cMaxPNGSize) { + longjmp(JMPBUF(png), 1); + return; + } + + // We can fill in the size now that the header is available. Avoid memory + // corruption issues by neutering setFailed() during this call; if we don't + // do this, failures will cause |m_reader| to be deleted, and our jmpbuf + // will cease to exist. Note that we'll still properly set the failure flag + // in this case as soon as we longjmp(). + m_doNothingOnFailure = true; + bool result = setSize(width, height); + m_doNothingOnFailure = false; + if (!result) { + longjmp(JMPBUF(png), 1); + return; + } + + int bitDepth, colorType, interlaceType, compressionType, filterType, channels; + png_get_IHDR(png, info, &width, &height, &bitDepth, &colorType, &interlaceType, &compressionType, &filterType); + + if ((colorType == PNG_COLOR_TYPE_RGB || colorType == PNG_COLOR_TYPE_RGB_ALPHA) && !m_ignoreGammaAndColorProfile) { + // We currently support color profiles only for RGB and RGBA PNGs. 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 + // don't 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. + m_colorProfile = readColorProfile(png, info); + } + + // 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); + + // Deal with gamma and keep it under our control. + double gamma; + if (!m_ignoreGammaAndColorProfile && png_get_gAMA(png, info, &gamma)) { + if ((gamma <= 0.0) || (gamma > cMaxGamma)) { + gamma = cInverseGamma; + png_set_gAMA(png, info, gamma); + } + png_set_gamma(png, cDefaultGamma, gamma); + } else + png_set_gamma(png, cDefaultGamma, cInverseGamma); + + // 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. + m_reader->setReadOffset(m_reader->currentBufferSize() - png->buffer_size); + png->buffer_size = 0; + } +} + +void PNGImageDecoder::rowAvailable(unsigned char* rowBuffer, unsigned rowIndex, int interlacePass) +{ + if (m_frameBufferCache.isEmpty()) + return; + + // Initialize the framebuffer if needed. + RGBA32Buffer& buffer = m_frameBufferCache[0]; + if (buffer.status() == RGBA32Buffer::FrameEmpty) { + if (!buffer.setSize(scaledSize().width(), scaledSize().height())) { + longjmp(JMPBUF(m_reader->pngPtr()), 1); + return; + } + buffer.setStatus(RGBA32Buffer::FramePartial); + buffer.setHasAlpha(false); + buffer.setColorProfile(m_colorProfile); + + // For PNGs, the frame always fills the entire image. + buffer.setRect(IntRect(IntPoint(), size())); + + if (m_reader->pngPtr()->interlaced) + m_reader->createInterlaceBuffer((m_reader->hasAlpha() ? 4 : 3) * size().width() * size().height()); + } + + if (!rowBuffer) + return; + + // libpng comments (pasted in 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. + * + * 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. + */ + + png_structp png = m_reader->pngPtr(); + bool hasAlpha = m_reader->hasAlpha(); + unsigned colorChannels = hasAlpha ? 4 : 3; + png_bytep row; + png_bytep interlaceBuffer = m_reader->interlaceBuffer(); + if (interlaceBuffer) { + row = interlaceBuffer + (rowIndex * colorChannels * size().width()); + png_progressive_combine_row(png, row, rowBuffer); + } else + row = rowBuffer; + + // Copy the data into our buffer. + int width = scaledSize().width(); + int destY = scaledY(rowIndex); + + // Check that the row is within the image bounds. LibPNG may supply an extra row. + if (destY < 0 || destY >= scaledSize().height()) + return; + bool nonTrivialAlpha = false; + for (int x = 0; x < width; ++x) { + png_bytep pixel = row + (m_scaled ? m_scaledColumns[x] : x) * colorChannels; + unsigned alpha = hasAlpha ? pixel[3] : 255; + buffer.setRGBA(x, destY, pixel[0], pixel[1], pixel[2], alpha); + nonTrivialAlpha |= alpha < 255; + } + if (nonTrivialAlpha && !buffer.hasAlpha()) + buffer.setHasAlpha(nonTrivialAlpha); +} + +void PNGImageDecoder::pngComplete() +{ + if (!m_frameBufferCache.isEmpty()) + m_frameBufferCache.first().setStatus(RGBA32Buffer::FrameComplete); +} + +void PNGImageDecoder::decode(bool onlySize) +{ + if (failed()) + return; + + if (!m_reader) + m_reader.set(new PNGImageReader(this)); + + // If we couldn't decode the image but we've received all the data, decoding + // has failed. + if (!m_reader->decode(*m_data, onlySize) && isAllDataReceived()) + setFailed(); + // If we're done decoding the image, we don't need the PNGImageReader + // anymore. (If we failed, |m_reader| has already been cleared.) + else if (isComplete()) + m_reader.clear(); +} + +} // namespace WebCore diff --git a/Source/WebCore/platform/image-decoders/png/PNGImageDecoder.h b/Source/WebCore/platform/image-decoders/png/PNGImageDecoder.h new file mode 100644 index 0000000..1e8902f --- /dev/null +++ b/Source/WebCore/platform/image-decoders/png/PNGImageDecoder.h @@ -0,0 +1,74 @@ +/* + * Copyright (C) 2006 Apple Computer, Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef PNGImageDecoder_h +#define PNGImageDecoder_h + +#include "ImageDecoder.h" +#include <wtf/OwnPtr.h> + +namespace WebCore { + + class PNGImageReader; + + // This class decodes the PNG image format. + class PNGImageDecoder : public ImageDecoder { + public: + PNGImageDecoder(ImageSource::AlphaOption, ImageSource::GammaAndColorProfileOption); + virtual ~PNGImageDecoder(); + + // ImageDecoder + virtual String filenameExtension() const { return "png"; } + virtual bool isSizeAvailable(); + virtual bool setSize(unsigned width, unsigned height); + virtual RGBA32Buffer* frameBufferAtIndex(size_t index); + // CAUTION: setFailed() deletes |m_reader|. Be careful to avoid + // accessing deleted memory, especially when calling this from inside + // PNGImageReader! + virtual bool setFailed(); + + // Callbacks from libpng + void headerAvailable(); + void rowAvailable(unsigned char* rowBuffer, unsigned rowIndex, int interlacePass); + void pngComplete(); + + bool isComplete() const + { + return !m_frameBufferCache.isEmpty() && (m_frameBufferCache.first().status() == RGBA32Buffer::FrameComplete); + } + + private: + // Decodes the image. If |onlySize| is true, stops decoding after + // calculating the image size. If decoding fails but there is no more + // data coming, sets the "decode failure" flag. + void decode(bool onlySize); + + OwnPtr<PNGImageReader> m_reader; + bool m_doNothingOnFailure; + }; + +} // namespace WebCore + +#endif |