PNGImageDecoder.cpp [plain text]
#include "config.h"
#include "PNGImageDecoder.h"
#include "png.h"
#include "assert.h"
namespace WebCore {
const double cMaxGamma = 21474.83;
const double cDefaultGamma = 2.2;
const double cInverseGamma = 0.45455;
const unsigned long cMaxPNGSize = 1000000UL;
static void PNGAPI decodingFailed(png_structp png_ptr, png_const_charp error_msg);
static void PNGAPI decodingWarning(png_structp png_ptr, png_const_charp warning_msg);
static void PNGAPI headerAvailable(png_structp png_ptr, png_infop info_ptr);
static void PNGAPI rowAvailable(png_structp png_ptr, png_bytep new_row,
png_uint_32 row_num, int pass);
static void PNGAPI pngComplete(png_structp png_ptr, png_infop info_ptr);
class PNGImageReader
{
public:
PNGImageReader(PNGImageDecoder* decoder)
: m_readOffset(0)
, m_decodingSizeOnly(false)
, m_interlaceBuffer(0)
, m_hasAlpha(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)
png_destroy_read_struct(&m_png, &m_info, 0); delete []m_interlaceBuffer;
m_interlaceBuffer = 0;
m_readOffset = 0;
}
void decode(const Vector<char>& data, bool sizeOnly)
{
m_decodingSizeOnly = sizeOnly;
if (setjmp(m_png->jmpbuf)) {
close();
return;
}
unsigned offset = m_readOffset;
unsigned remaining = data.size() - m_readOffset;
m_readOffset = data.size();
png_process_data(m_png, m_info, (png_bytep)(data.data()) + offset, remaining);
}
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;
};
PNGImageDecoder::PNGImageDecoder()
: m_reader(0)
{
}
PNGImageDecoder::~PNGImageDecoder()
{
delete m_reader;
}
void PNGImageDecoder::setData(SharedBuffer* data, bool allDataReceived)
{
if (m_failed)
return;
ImageDecoder::setData(data, allDataReceived);
if (!m_reader && !m_failed)
m_reader = new PNGImageReader(this);
}
bool PNGImageDecoder::isSizeAvailable()
{
if (!ImageDecoder::isSizeAvailable() && !failed() && m_reader)
decode(true);
return ImageDecoder::isSizeAvailable();
}
RGBA32Buffer* PNGImageDecoder::frameBufferAtIndex(size_t index)
{
if (index)
return 0;
if (m_frameBufferCache.isEmpty())
m_frameBufferCache.resize(1);
RGBA32Buffer& frame = m_frameBufferCache[0];
if (frame.status() != RGBA32Buffer::FrameComplete && m_reader)
decode();
return &frame;
}
void PNGImageDecoder::decode(bool sizeOnly)
{
if (m_failed)
return;
m_reader->decode(m_data->buffer(), sizeOnly);
if (m_failed || (!m_frameBufferCache.isEmpty() && m_frameBufferCache[0].status() == RGBA32Buffer::FrameComplete)) {
delete m_reader;
m_reader = 0;
}
}
void decodingFailed(png_structp png, png_const_charp errorMsg)
{
static_cast<PNGImageDecoder*>(png_get_progressive_ptr(png))->decodingFailed();
longjmp(png->jmpbuf, 1);
}
void decodingWarning(png_structp png, png_const_charp warningMsg)
{
if (!strncmp(warningMsg, "Missing PLTE before tRNS", 24))
png_error(png, warningMsg);
}
void headerAvailable(png_structp png, png_infop info)
{
static_cast<PNGImageDecoder*>(png_get_progressive_ptr(png))->headerAvailable();
}
void PNGImageDecoder::decodingFailed()
{
m_failed = true;
}
void PNGImageDecoder::headerAvailable()
{
png_structp png = reader()->pngPtr();
png_infop info = reader()->infoPtr();
png_uint_32 width = png->width;
png_uint_32 height = png->height;
if (png->width > cMaxPNGSize || png->height > cMaxPNGSize) {
m_failed = true;
longjmp(png->jmpbuf, 1);
return;
}
if (!ImageDecoder::isSizeAvailable()) {
if (!setSize(width, height)) {
longjmp(png->jmpbuf, 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_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);
double gamma;
if (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);
if (interlaceType == PNG_INTERLACE_ADAM7)
png_set_interlace_handling(png);
png_read_update_info(png, info);
channels = png_get_channels(png, info);
assert(channels == 3 || channels == 4);
reader()->setHasAlpha(channels == 4);
if (reader()->decodingSizeOnly()) {
reader()->setReadOffset(m_data->size() - png->buffer_size);
png->buffer_size = 0;
}
}
void 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);
}
void PNGImageDecoder::rowAvailable(unsigned char* rowBuffer, unsigned rowIndex, int interlacePass)
{
if (m_frameBufferCache.isEmpty())
return;
RGBA32Buffer& buffer = m_frameBufferCache[0];
if (buffer.status() == RGBA32Buffer::FrameEmpty) {
if (!buffer.setSize(size().width(), size().height())) {
static_cast<PNGImageDecoder*>(png_get_progressive_ptr(reader()->pngPtr()))->decodingFailed();
longjmp(reader()->pngPtr()->jmpbuf, 1);
return;
}
buffer.setStatus(RGBA32Buffer::FramePartial);
buffer.setHasAlpha(false);
buffer.setRect(IntRect(IntPoint(), size()));
if (reader()->pngPtr()->interlaced)
reader()->createInterlaceBuffer((reader()->hasAlpha() ? 4 : 3) * size().width() * size().height());
}
if (rowBuffer == 0)
return;
png_structp png = reader()->pngPtr();
bool hasAlpha = reader()->hasAlpha();
unsigned colorChannels = hasAlpha ? 4 : 3;
png_bytep row;
png_bytep interlaceBuffer = reader()->interlaceBuffer();
if (interlaceBuffer) {
row = interlaceBuffer + (rowIndex * colorChannels * size().width());
png_progressive_combine_row(png, row, rowBuffer);
}
else
row = rowBuffer;
int width = size().width();
bool sawAlpha = false;
for (int x = 0; x < width; x++) {
unsigned red = *row++;
unsigned green = *row++;
unsigned blue = *row++;
unsigned alpha = (hasAlpha ? *row++ : 255);
buffer.setRGBA(x, rowIndex, red, green, blue, alpha);
if (!sawAlpha && alpha < 255) {
sawAlpha = true;
buffer.setHasAlpha(true);
}
}
}
void pngComplete(png_structp png, png_infop info)
{
static_cast<PNGImageDecoder*>(png_get_progressive_ptr(png))->pngComplete();
}
void PNGImageDecoder::pngComplete()
{
if (m_frameBufferCache.isEmpty())
return;
RGBA32Buffer& buffer = m_frameBufferCache[0];
buffer.setStatus(RGBA32Buffer::FrameComplete);
}
}