| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 * Copyright (C) 2006 Apple Computer, Inc. | |
| 3 * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved. | |
| 4 * | |
| 5 * Portions are Copyright (C) 2001 mozilla.org | |
| 6 * | |
| 7 * Other contributors: | |
| 8 * Stuart Parmenter <stuart@mozilla.com> | |
| 9 * | |
| 10 * This library is free software; you can redistribute it and/or | |
| 11 * modify it under the terms of the GNU Lesser General Public | |
| 12 * License as published by the Free Software Foundation; either | |
| 13 * version 2.1 of the License, or (at your option) any later version. | |
| 14 * | |
| 15 * This library is distributed in the hope that it will be useful, | |
| 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| 18 * Lesser General Public License for more details. | |
| 19 * | |
| 20 * You should have received a copy of the GNU Lesser General Public | |
| 21 * License along with this library; if not, write to the Free Software | |
| 22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 US
A | |
| 23 * | |
| 24 * Alternatively, the contents of this file may be used under the terms | |
| 25 * of either the Mozilla Public License Version 1.1, found at | |
| 26 * http://www.mozilla.org/MPL/ (the "MPL") or the GNU General Public | |
| 27 * License Version 2.0, found at http://www.fsf.org/copyleft/gpl.html | |
| 28 * (the "GPL"), in which case the provisions of the MPL or the GPL are | |
| 29 * applicable instead of those above. If you wish to allow use of your | |
| 30 * version of this file only under the terms of one of those two | |
| 31 * licenses (the MPL or the GPL) and not to allow others to use your | |
| 32 * version of this file under the LGPL, indicate your decision by | |
| 33 * deletingthe provisions above and replace them with the notice and | |
| 34 * other provisions required by the MPL or the GPL, as the case may be. | |
| 35 * If you do not delete the provisions above, a recipient may use your | |
| 36 * version of this file under any of the LGPL, the MPL or the GPL. | |
| 37 */ | |
| 38 | |
| 39 #include "config.h" | |
| 40 #include "core/platform/image-decoders/png/PNGImageDecoder.h" | |
| 41 | |
| 42 #include "platform/PlatformInstrumentation.h" | |
| 43 #include "wtf/PassOwnPtr.h" | |
| 44 | |
| 45 #include "png.h" | |
| 46 #if USE(QCMSLIB) | |
| 47 #include "qcms.h" | |
| 48 #endif | |
| 49 | |
| 50 #if defined(PNG_LIBPNG_VER_MAJOR) && defined(PNG_LIBPNG_VER_MINOR) && (PNG_LIBPN
G_VER_MAJOR > 1 || (PNG_LIBPNG_VER_MAJOR == 1 && PNG_LIBPNG_VER_MINOR >= 4)) | |
| 51 #define JMPBUF(png_ptr) png_jmpbuf(png_ptr) | |
| 52 #else | |
| 53 #define JMPBUF(png_ptr) png_ptr->jmpbuf | |
| 54 #endif | |
| 55 | |
| 56 namespace WebCore { | |
| 57 | |
| 58 // Gamma constants. | |
| 59 const double cMaxGamma = 21474.83; | |
| 60 const double cDefaultGamma = 2.2; | |
| 61 const double cInverseGamma = 0.45455; | |
| 62 | |
| 63 // Protect against large PNGs. See Mozilla's bug #251381 for more info. | |
| 64 const unsigned long cMaxPNGSize = 1000000UL; | |
| 65 | |
| 66 // Called if the decoding of the image fails. | |
| 67 static void PNGAPI decodingFailed(png_structp png, png_const_charp) | |
| 68 { | |
| 69 longjmp(JMPBUF(png), 1); | |
| 70 } | |
| 71 | |
| 72 // Callbacks given to the read struct. The first is for warnings (we want to | |
| 73 // treat a particular warning as an error, which is why we have to register this | |
| 74 // callback). | |
| 75 static void PNGAPI decodingWarning(png_structp png, png_const_charp warningMsg) | |
| 76 { | |
| 77 // Mozilla did this, so we will too. | |
| 78 // Convert a tRNS warning to be an error (see | |
| 79 // http://bugzilla.mozilla.org/show_bug.cgi?id=251381 ) | |
| 80 if (!strncmp(warningMsg, "Missing PLTE before tRNS", 24)) | |
| 81 png_error(png, warningMsg); | |
| 82 } | |
| 83 | |
| 84 // Called when we have obtained the header information (including the size). | |
| 85 static void PNGAPI headerAvailable(png_structp png, png_infop) | |
| 86 { | |
| 87 static_cast<PNGImageDecoder*>(png_get_progressive_ptr(png))->headerAvailable
(); | |
| 88 } | |
| 89 | |
| 90 // Called when a row is ready. | |
| 91 static void PNGAPI rowAvailable(png_structp png, png_bytep rowBuffer, png_uint_3
2 rowIndex, int interlacePass) | |
| 92 { | |
| 93 static_cast<PNGImageDecoder*>(png_get_progressive_ptr(png))->rowAvailable(ro
wBuffer, rowIndex, interlacePass); | |
| 94 } | |
| 95 | |
| 96 // Called when we have completely finished decoding the image. | |
| 97 static void PNGAPI pngComplete(png_structp png, png_infop) | |
| 98 { | |
| 99 static_cast<PNGImageDecoder*>(png_get_progressive_ptr(png))->pngComplete(); | |
| 100 } | |
| 101 | |
| 102 class PNGImageReader { | |
| 103 WTF_MAKE_FAST_ALLOCATED; | |
| 104 public: | |
| 105 PNGImageReader(PNGImageDecoder* decoder) | |
| 106 : m_readOffset(0) | |
| 107 , m_currentBufferSize(0) | |
| 108 , m_decodingSizeOnly(false) | |
| 109 , m_hasAlpha(false) | |
| 110 , m_interlaceBuffer(0) | |
| 111 #if USE(QCMSLIB) | |
| 112 , m_transform(0) | |
| 113 , m_rowBuffer() | |
| 114 #endif | |
| 115 { | |
| 116 m_png = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, decodingFailed,
decodingWarning); | |
| 117 m_info = png_create_info_struct(m_png); | |
| 118 png_set_progressive_read_fn(m_png, decoder, headerAvailable, rowAvailabl
e, pngComplete); | |
| 119 } | |
| 120 | |
| 121 ~PNGImageReader() | |
| 122 { | |
| 123 close(); | |
| 124 } | |
| 125 | |
| 126 void close() | |
| 127 { | |
| 128 if (m_png && m_info) | |
| 129 // This will zero the pointers. | |
| 130 png_destroy_read_struct(&m_png, &m_info, 0); | |
| 131 #if USE(QCMSLIB) | |
| 132 if (m_transform) | |
| 133 qcms_transform_release(m_transform); | |
| 134 m_transform = 0; | |
| 135 #endif | |
| 136 delete[] m_interlaceBuffer; | |
| 137 m_interlaceBuffer = 0; | |
| 138 m_readOffset = 0; | |
| 139 } | |
| 140 | |
| 141 bool decode(const SharedBuffer& data, bool sizeOnly) | |
| 142 { | |
| 143 m_decodingSizeOnly = sizeOnly; | |
| 144 PNGImageDecoder* decoder = static_cast<PNGImageDecoder*>(png_get_progres
sive_ptr(m_png)); | |
| 145 | |
| 146 // We need to do the setjmp here. Otherwise bad things will happen. | |
| 147 if (setjmp(JMPBUF(m_png))) | |
| 148 return decoder->setFailed(); | |
| 149 | |
| 150 const char* segment; | |
| 151 while (unsigned segmentLength = data.getSomeData(segment, m_readOffset))
{ | |
| 152 m_readOffset += segmentLength; | |
| 153 m_currentBufferSize = m_readOffset; | |
| 154 png_process_data(m_png, m_info, reinterpret_cast<png_bytep>(const_ca
st<char*>(segment)), segmentLength); | |
| 155 // We explicitly specify the superclass isSizeAvailable() because we | |
| 156 // merely want to check if we've managed to set the size, not | |
| 157 // (recursively) trigger additional decoding if we haven't. | |
| 158 if (sizeOnly ? decoder->ImageDecoder::isSizeAvailable() : decoder->i
sComplete()) | |
| 159 return true; | |
| 160 } | |
| 161 return false; | |
| 162 } | |
| 163 | |
| 164 png_structp pngPtr() const { return m_png; } | |
| 165 png_infop infoPtr() const { return m_info; } | |
| 166 | |
| 167 void setReadOffset(unsigned offset) { m_readOffset = offset; } | |
| 168 unsigned currentBufferSize() const { return m_currentBufferSize; } | |
| 169 bool decodingSizeOnly() const { return m_decodingSizeOnly; } | |
| 170 void setHasAlpha(bool hasAlpha) { m_hasAlpha = hasAlpha; } | |
| 171 bool hasAlpha() const { return m_hasAlpha; } | |
| 172 | |
| 173 png_bytep interlaceBuffer() const { return m_interlaceBuffer; } | |
| 174 void createInterlaceBuffer(int size) { m_interlaceBuffer = new png_byte[size
]; } | |
| 175 #if USE(QCMSLIB) | |
| 176 png_bytep rowBuffer() const { return m_rowBuffer.get(); } | |
| 177 void createRowBuffer(int size) { m_rowBuffer = adoptArrayPtr(new png_byte[si
ze]); } | |
| 178 qcms_transform* colorTransform() const { return m_transform; } | |
| 179 | |
| 180 void createColorTransform(const ColorProfile& colorProfile, bool hasAlpha) | |
| 181 { | |
| 182 if (m_transform) | |
| 183 qcms_transform_release(m_transform); | |
| 184 m_transform = 0; | |
| 185 | |
| 186 if (colorProfile.isEmpty()) | |
| 187 return; | |
| 188 qcms_profile* deviceProfile = ImageDecoder::qcmsOutputDeviceProfile(); | |
| 189 if (!deviceProfile) | |
| 190 return; | |
| 191 qcms_profile* inputProfile = qcms_profile_from_memory(colorProfile.data(
), colorProfile.size()); | |
| 192 if (!inputProfile) | |
| 193 return; | |
| 194 // We currently only support color profiles for RGB and RGBA images. | |
| 195 ASSERT(icSigRgbData == qcms_profile_get_color_space(inputProfile)); | |
| 196 qcms_data_type dataFormat = hasAlpha ? QCMS_DATA_RGBA_8 : QCMS_DATA_RGB_
8; | |
| 197 // FIXME: Don't force perceptual intent if the image profile contains an
intent. | |
| 198 m_transform = qcms_transform_create(inputProfile, dataFormat, deviceProf
ile, dataFormat, QCMS_INTENT_PERCEPTUAL); | |
| 199 qcms_profile_release(inputProfile); | |
| 200 } | |
| 201 #endif | |
| 202 | |
| 203 private: | |
| 204 png_structp m_png; | |
| 205 png_infop m_info; | |
| 206 unsigned m_readOffset; | |
| 207 unsigned m_currentBufferSize; | |
| 208 bool m_decodingSizeOnly; | |
| 209 bool m_hasAlpha; | |
| 210 png_bytep m_interlaceBuffer; | |
| 211 #if USE(QCMSLIB) | |
| 212 qcms_transform* m_transform; | |
| 213 OwnPtr<png_byte[]> m_rowBuffer; | |
| 214 #endif | |
| 215 }; | |
| 216 | |
| 217 PNGImageDecoder::PNGImageDecoder(ImageSource::AlphaOption alphaOption, | |
| 218 ImageSource::GammaAndColorProfileOption gammaAndColorProfileOption, | |
| 219 size_t maxDecodedBytes) | |
| 220 : ImageDecoder(alphaOption, gammaAndColorProfileOption, maxDecodedBytes) | |
| 221 , m_doNothingOnFailure(false) | |
| 222 { | |
| 223 } | |
| 224 | |
| 225 PNGImageDecoder::~PNGImageDecoder() | |
| 226 { | |
| 227 } | |
| 228 | |
| 229 bool PNGImageDecoder::isSizeAvailable() | |
| 230 { | |
| 231 if (!ImageDecoder::isSizeAvailable()) | |
| 232 decode(true); | |
| 233 | |
| 234 return ImageDecoder::isSizeAvailable(); | |
| 235 } | |
| 236 | |
| 237 ImageFrame* PNGImageDecoder::frameBufferAtIndex(size_t index) | |
| 238 { | |
| 239 if (index) | |
| 240 return 0; | |
| 241 | |
| 242 if (m_frameBufferCache.isEmpty()) { | |
| 243 m_frameBufferCache.resize(1); | |
| 244 m_frameBufferCache[0].setPremultiplyAlpha(m_premultiplyAlpha); | |
| 245 } | |
| 246 | |
| 247 ImageFrame& frame = m_frameBufferCache[0]; | |
| 248 if (frame.status() != ImageFrame::FrameComplete) { | |
| 249 PlatformInstrumentation::willDecodeImage("PNG"); | |
| 250 decode(false); | |
| 251 PlatformInstrumentation::didDecodeImage(); | |
| 252 } | |
| 253 | |
| 254 frame.notifyBitmapIfPixelsChanged(); | |
| 255 return &frame; | |
| 256 } | |
| 257 | |
| 258 bool PNGImageDecoder::setFailed() | |
| 259 { | |
| 260 if (m_doNothingOnFailure) | |
| 261 return false; | |
| 262 m_reader.clear(); | |
| 263 return ImageDecoder::setFailed(); | |
| 264 } | |
| 265 | |
| 266 #if USE(QCMSLIB) | |
| 267 static void readColorProfile(png_structp png, png_infop info, ColorProfile& colo
rProfile) | |
| 268 { | |
| 269 #ifdef PNG_iCCP_SUPPORTED | |
| 270 char* profileName; | |
| 271 int compressionType; | |
| 272 #if (PNG_LIBPNG_VER < 10500) | |
| 273 png_charp profile; | |
| 274 #else | |
| 275 png_bytep profile; | |
| 276 #endif | |
| 277 png_uint_32 profileLength; | |
| 278 if (!png_get_iCCP(png, info, &profileName, &compressionType, &profile, &prof
ileLength)) | |
| 279 return; | |
| 280 | |
| 281 // Only accept RGB color profiles from input class devices. | |
| 282 bool ignoreProfile = false; | |
| 283 char* profileData = reinterpret_cast<char*>(profile); | |
| 284 if (profileLength < ImageDecoder::iccColorProfileHeaderLength) | |
| 285 ignoreProfile = true; | |
| 286 else if (!ImageDecoder::rgbColorProfile(profileData, profileLength)) | |
| 287 ignoreProfile = true; | |
| 288 else if (!ImageDecoder::inputDeviceColorProfile(profileData, profileLength)) | |
| 289 ignoreProfile = true; | |
| 290 | |
| 291 ASSERT(colorProfile.isEmpty()); | |
| 292 if (!ignoreProfile) | |
| 293 colorProfile.append(profileData, profileLength); | |
| 294 #else | |
| 295 UNUSED_PARAM(png); | |
| 296 UNUSED_PARAM(info); | |
| 297 UNUSED_PARAM(colorProfile); | |
| 298 #endif | |
| 299 } | |
| 300 #endif | |
| 301 | |
| 302 void PNGImageDecoder::headerAvailable() | |
| 303 { | |
| 304 png_structp png = m_reader->pngPtr(); | |
| 305 png_infop info = m_reader->infoPtr(); | |
| 306 png_uint_32 width = png_get_image_width(png, info); | |
| 307 png_uint_32 height = png_get_image_height(png, info); | |
| 308 | |
| 309 // Protect against large images. | |
| 310 if (width > cMaxPNGSize || height > cMaxPNGSize) { | |
| 311 longjmp(JMPBUF(png), 1); | |
| 312 return; | |
| 313 } | |
| 314 | |
| 315 // We can fill in the size now that the header is available. Avoid memory | |
| 316 // corruption issues by neutering setFailed() during this call; if we don't | |
| 317 // do this, failures will cause |m_reader| to be deleted, and our jmpbuf | |
| 318 // will cease to exist. Note that we'll still properly set the failure flag | |
| 319 // in this case as soon as we longjmp(). | |
| 320 m_doNothingOnFailure = true; | |
| 321 bool result = setSize(width, height); | |
| 322 m_doNothingOnFailure = false; | |
| 323 if (!result) { | |
| 324 longjmp(JMPBUF(png), 1); | |
| 325 return; | |
| 326 } | |
| 327 | |
| 328 int bitDepth, colorType, interlaceType, compressionType, filterType, channel
s; | |
| 329 png_get_IHDR(png, info, &width, &height, &bitDepth, &colorType, &interlaceTy
pe, &compressionType, &filterType); | |
| 330 | |
| 331 // The options we set here match what Mozilla does. | |
| 332 | |
| 333 // Expand to ensure we use 24-bit for RGB and 32-bit for RGBA. | |
| 334 if (colorType == PNG_COLOR_TYPE_PALETTE || (colorType == PNG_COLOR_TYPE_GRAY
&& bitDepth < 8)) | |
| 335 png_set_expand(png); | |
| 336 | |
| 337 png_bytep trns = 0; | |
| 338 int trnsCount = 0; | |
| 339 if (png_get_valid(png, info, PNG_INFO_tRNS)) { | |
| 340 png_get_tRNS(png, info, &trns, &trnsCount, 0); | |
| 341 png_set_expand(png); | |
| 342 } | |
| 343 | |
| 344 if (bitDepth == 16) | |
| 345 png_set_strip_16(png); | |
| 346 | |
| 347 if (colorType == PNG_COLOR_TYPE_GRAY || colorType == PNG_COLOR_TYPE_GRAY_ALP
HA) | |
| 348 png_set_gray_to_rgb(png); | |
| 349 | |
| 350 #if USE(QCMSLIB) | |
| 351 if ((colorType & PNG_COLOR_MASK_COLOR) && !m_ignoreGammaAndColorProfile) { | |
| 352 // We only support color profiles for color PALETTE and RGB[A] PNG. Supp
orting | |
| 353 // color profiles for gray-scale images is slightly tricky, at least usi
ng the | |
| 354 // CoreGraphics ICC library, because we expand gray-scale images to RGB
but we | |
| 355 // do not similarly transform the color profile. We'd either need to tra
nsform | |
| 356 // the color profile or we'd need to decode into a gray-scale image buff
er and | |
| 357 // hand that to CoreGraphics. | |
| 358 ColorProfile colorProfile; | |
| 359 readColorProfile(png, info, colorProfile); | |
| 360 bool decodedImageHasAlpha = (colorType & PNG_COLOR_MASK_ALPHA) || trnsCo
unt; | |
| 361 m_reader->createColorTransform(colorProfile, decodedImageHasAlpha); | |
| 362 } | |
| 363 #endif | |
| 364 | |
| 365 // Deal with gamma and keep it under our control. | |
| 366 double gamma; | |
| 367 if (!m_ignoreGammaAndColorProfile && png_get_gAMA(png, info, &gamma)) { | |
| 368 if ((gamma <= 0.0) || (gamma > cMaxGamma)) { | |
| 369 gamma = cInverseGamma; | |
| 370 png_set_gAMA(png, info, gamma); | |
| 371 } | |
| 372 png_set_gamma(png, cDefaultGamma, gamma); | |
| 373 } else | |
| 374 png_set_gamma(png, cDefaultGamma, cInverseGamma); | |
| 375 | |
| 376 // Tell libpng to send us rows for interlaced pngs. | |
| 377 if (interlaceType == PNG_INTERLACE_ADAM7) | |
| 378 png_set_interlace_handling(png); | |
| 379 | |
| 380 // Update our info now. | |
| 381 png_read_update_info(png, info); | |
| 382 channels = png_get_channels(png, info); | |
| 383 ASSERT(channels == 3 || channels == 4); | |
| 384 | |
| 385 m_reader->setHasAlpha(channels == 4); | |
| 386 | |
| 387 if (m_reader->decodingSizeOnly()) { | |
| 388 // If we only needed the size, halt the reader. | |
| 389 #if defined(PNG_LIBPNG_VER_MAJOR) && defined(PNG_LIBPNG_VER_MINOR) && (PNG_LIBPN
G_VER_MAJOR > 1 || (PNG_LIBPNG_VER_MAJOR == 1 && PNG_LIBPNG_VER_MINOR >= 5)) | |
| 390 // '0' argument to png_process_data_pause means: Do not cache unprocesse
d data. | |
| 391 m_reader->setReadOffset(m_reader->currentBufferSize() - png_process_data
_pause(png, 0)); | |
| 392 #else | |
| 393 m_reader->setReadOffset(m_reader->currentBufferSize() - png->buffer_size
); | |
| 394 png->buffer_size = 0; | |
| 395 #endif | |
| 396 } | |
| 397 } | |
| 398 | |
| 399 void PNGImageDecoder::rowAvailable(unsigned char* rowBuffer, unsigned rowIndex,
int) | |
| 400 { | |
| 401 if (m_frameBufferCache.isEmpty()) | |
| 402 return; | |
| 403 | |
| 404 // Initialize the framebuffer if needed. | |
| 405 ImageFrame& buffer = m_frameBufferCache[0]; | |
| 406 if (buffer.status() == ImageFrame::FrameEmpty) { | |
| 407 png_structp png = m_reader->pngPtr(); | |
| 408 if (!buffer.setSize(size().width(), size().height())) { | |
| 409 longjmp(JMPBUF(png), 1); | |
| 410 return; | |
| 411 } | |
| 412 | |
| 413 unsigned colorChannels = m_reader->hasAlpha() ? 4 : 3; | |
| 414 if (PNG_INTERLACE_ADAM7 == png_get_interlace_type(png, m_reader->infoPtr
())) { | |
| 415 m_reader->createInterlaceBuffer(colorChannels * size().width() * siz
e().height()); | |
| 416 if (!m_reader->interlaceBuffer()) { | |
| 417 longjmp(JMPBUF(png), 1); | |
| 418 return; | |
| 419 } | |
| 420 } | |
| 421 | |
| 422 #if USE(QCMSLIB) | |
| 423 if (m_reader->colorTransform()) { | |
| 424 m_reader->createRowBuffer(colorChannels * size().width()); | |
| 425 if (!m_reader->rowBuffer()) { | |
| 426 longjmp(JMPBUF(png), 1); | |
| 427 return; | |
| 428 } | |
| 429 } | |
| 430 #endif | |
| 431 buffer.setStatus(ImageFrame::FramePartial); | |
| 432 buffer.setHasAlpha(false); | |
| 433 | |
| 434 // For PNGs, the frame always fills the entire image. | |
| 435 buffer.setOriginalFrameRect(IntRect(IntPoint(), size())); | |
| 436 } | |
| 437 | |
| 438 /* libpng comments (here to explain what follows). | |
| 439 * | |
| 440 * this function is called for every row in the image. If the | |
| 441 * image is interlacing, and you turned on the interlace handler, | |
| 442 * this function will be called for every row in every pass. | |
| 443 * Some of these rows will not be changed from the previous pass. | |
| 444 * When the row is not changed, the new_row variable will be NULL. | |
| 445 * The rows and passes are called in order, so you don't really | |
| 446 * need the row_num and pass, but I'm supplying them because it | |
| 447 * may make your life easier. | |
| 448 */ | |
| 449 | |
| 450 // Nothing to do if the row is unchanged, or the row is outside | |
| 451 // the image bounds: libpng may send extra rows, ignore them to | |
| 452 // make our lives easier. | |
| 453 if (!rowBuffer) | |
| 454 return; | |
| 455 int y = rowIndex; | |
| 456 if (y < 0 || y >= size().height()) | |
| 457 return; | |
| 458 | |
| 459 /* libpng comments (continued). | |
| 460 * | |
| 461 * For the non-NULL rows of interlaced images, you must call | |
| 462 * png_progressive_combine_row() passing in the row and the | |
| 463 * old row. You can call this function for NULL rows (it will | |
| 464 * just return) and for non-interlaced images (it just does the | |
| 465 * memcpy for you) if it will make the code easier. Thus, you | |
| 466 * can just do this for all cases: | |
| 467 * | |
| 468 * png_progressive_combine_row(png_ptr, old_row, new_row); | |
| 469 * | |
| 470 * where old_row is what was displayed for previous rows. Note | |
| 471 * that the first pass (pass == 0 really) will completely cover | |
| 472 * the old row, so the rows do not have to be initialized. After | |
| 473 * the first pass (and only for interlaced images), you will have | |
| 474 * to pass the current row, and the function will combine the | |
| 475 * old row and the new row. | |
| 476 */ | |
| 477 | |
| 478 bool hasAlpha = m_reader->hasAlpha(); | |
| 479 unsigned colorChannels = hasAlpha ? 4 : 3; | |
| 480 png_bytep row = rowBuffer; | |
| 481 | |
| 482 if (png_bytep interlaceBuffer = m_reader->interlaceBuffer()) { | |
| 483 row = interlaceBuffer + (rowIndex * colorChannels * size().width()); | |
| 484 png_progressive_combine_row(m_reader->pngPtr(), row, rowBuffer); | |
| 485 } | |
| 486 | |
| 487 #if USE(QCMSLIB) | |
| 488 if (qcms_transform* transform = m_reader->colorTransform()) { | |
| 489 qcms_transform_data(transform, row, m_reader->rowBuffer(), size().width(
)); | |
| 490 row = m_reader->rowBuffer(); | |
| 491 } | |
| 492 #endif | |
| 493 | |
| 494 // Write the decoded row pixels to the frame buffer. | |
| 495 ImageFrame::PixelData* address = buffer.getAddr(0, y); | |
| 496 bool nonTrivialAlpha = false; | |
| 497 int width = size().width(); | |
| 498 | |
| 499 png_bytep pixel = row; | |
| 500 for (int x = 0; x < width; ++x, pixel += colorChannels) { | |
| 501 unsigned alpha = hasAlpha ? pixel[3] : 255; | |
| 502 buffer.setRGBA(address++, pixel[0], pixel[1], pixel[2], alpha); | |
| 503 nonTrivialAlpha |= alpha < 255; | |
| 504 } | |
| 505 | |
| 506 if (nonTrivialAlpha && !buffer.hasAlpha()) | |
| 507 buffer.setHasAlpha(nonTrivialAlpha); | |
| 508 | |
| 509 buffer.setPixelsChanged(true); | |
| 510 } | |
| 511 | |
| 512 void PNGImageDecoder::pngComplete() | |
| 513 { | |
| 514 if (!m_frameBufferCache.isEmpty()) | |
| 515 m_frameBufferCache.first().setStatus(ImageFrame::FrameComplete); | |
| 516 } | |
| 517 | |
| 518 void PNGImageDecoder::decode(bool onlySize) | |
| 519 { | |
| 520 if (failed()) | |
| 521 return; | |
| 522 | |
| 523 if (!m_reader) | |
| 524 m_reader = adoptPtr(new PNGImageReader(this)); | |
| 525 | |
| 526 // If we couldn't decode the image but we've received all the data, decoding | |
| 527 // has failed. | |
| 528 if (!m_reader->decode(*m_data, onlySize) && isAllDataReceived()) | |
| 529 setFailed(); | |
| 530 // If we're done decoding the image, we don't need the PNGImageReader | |
| 531 // anymore. (If we failed, |m_reader| has already been cleared.) | |
| 532 else if (isComplete()) | |
| 533 m_reader.clear(); | |
| 534 } | |
| 535 | |
| 536 } // namespace WebCore | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 99103006:
Moving GraphicsContext and dependencies from core to platform. (Closed)
Base URL: svn://svn.chromium.org/blink/trunk
