Support for libpng > 1.2.

src/images/SkImageDecoder_libpng.cpp

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkImageDecoder.h"
 #include "SkImageEncoder.h"
 #include "SkColor.h"
 #include "SkColorPriv.h"
 #include "SkDither.h"
 #include "SkMath.h"
 #include "SkScaledBitmapSampler.h"
 #include "SkStream.h"
 #include "SkTemplates.h"
 #include "SkUtils.h"
 #include "transform_scanline.h"
 
 extern "C" {
 #include "png.h"
 }
 
+/* These were dropped in libpng >= 1.4 */
+#ifndef png_infopp_NULL
+#define png_infopp_NULL NULL
+#endif
+
+#ifndef png_bytepp_NULL
+#define png_bytepp_NULL NULL
+#endif
+
+#ifndef int_p_NULL
+#define int_p_NULL NULL
+#endif
+
+#ifndef png_flush_ptr_NULL
+#define png_flush_ptr_NULL NULL
+#endif
+
 class SkPNGImageIndex {
 public:
     SkPNGImageIndex(png_structp png_ptr, png_infop info_ptr) {
         this->png_ptr = png_ptr;
         this->info_ptr = info_ptr;
     }
     ~SkPNGImageIndex() {
         if (NULL != png_ptr) {
             png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL);
         }
@@ skipping 47 matching lines @@
     PNGAutoClean(png_structp p, png_infop i): png_ptr(p), info_ptr(i) {}
     ~PNGAutoClean() {
         png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL);
     }
 private:
     png_structp png_ptr;
     png_infop info_ptr;
 };
 
 static void sk_read_fn(png_structp png_ptr, png_bytep data, png_size_t length) {
-    SkStream* sk_stream = (SkStream*) png_ptr->io_ptr;
+    SkStream* sk_stream = (SkStream*) png_get_io_ptr(png_ptr);
     size_t bytes = sk_stream->read(data, length);
     if (bytes != length) {
         png_error(png_ptr, "Read Error!");
     }
 }
 
 #ifdef SK_BUILD_FOR_ANDROID
 static void sk_seek_fn(png_structp png_ptr, png_uint_32 offset) {
-    SkStream* sk_stream = (SkStream*) png_ptr->io_ptr;
+    SkStream* sk_stream = (SkStream*) png_get_io_ptr(png_ptr);
     sk_stream->rewind();
     (void)sk_stream->skip(offset);
 }
 #endif
 
 static int sk_read_user_chunk(png_structp png_ptr, png_unknown_chunkp chunk) {
     SkImageDecoder::Peeker* peeker =
                     (SkImageDecoder::Peeker*)png_get_user_chunk_ptr(png_ptr);
     // peek() returning true means continue decoding
     return peeker->peek((const char*)chunk->name, chunk->data, chunk->size) ?
@@ skipping 120 matching lines @@
     if (bitDepth == 16) {
         png_set_strip_16(png_ptr);
     }
     /* Extract multiple pixels with bit depths of 1, 2, and 4 from a single
      * byte into separate bytes (useful for paletted and grayscale images). */
     if (bitDepth < 8) {
         png_set_packing(png_ptr);
     }
     /* Expand grayscale images to the full 8 bits from 1, 2, or 4 bits/pixel */
     if (colorType == PNG_COLOR_TYPE_GRAY && bitDepth < 8) {
-        png_set_gray_1_2_4_to_8(png_ptr);
+        png_set_expand_gray_1_2_4_to_8(png_ptr);
     }
 
     /* Make a grayscale image into RGB. */
     if (colorType == PNG_COLOR_TYPE_GRAY || colorType == PNG_COLOR_TYPE_GRAY_ALPHA) {
         png_set_gray_to_rgb(png_ptr);
     }
     return true;
 }
 
 bool SkPNGImageDecoder::onDecode(SkStream* sk_stream, SkBitmap* decodedBitmap,
@@ skipping 176 matching lines @@
 bool SkPNGImageDecoder::getBitmapConfig(png_structp png_ptr, png_infop info_ptr,
                                         SkBitmap::Config *configp, bool *hasAlphap,
                                         bool *doDitherp, SkPMColor *theTranspColorp) {
     png_uint_32 origWidth, origHeight;
     int bitDepth, colorType;
     png_get_IHDR(png_ptr, info_ptr, &origWidth, &origHeight, &bitDepth,
                  &colorType, int_p_NULL, int_p_NULL, int_p_NULL);
 
     // check for sBIT chunk data, in case we should disable dithering because
     // our data is not truely 8bits per component
-    if (*doDitherp) {
+    png_color_8p sig_bit;
+    if (*doDitherp && png_get_sBIT(png_ptr, info_ptr, &sig_bit)) {
 #if 0
-        SkDebugf("----- sBIT %d %d %d %d\n", info_ptr->sig_bit.red,
-                 info_ptr->sig_bit.green, info_ptr->sig_bit.blue,
-                 info_ptr->sig_bit.alpha);
+        SkDebugf("----- sBIT %d %d %d %d\n", sig_bit->red, sig_bit->green,
+                 sig_bit->blue, sig_bit->alpha);
 #endif
         // 0 seems to indicate no information available
-        if (pos_le(info_ptr->sig_bit.red, SK_R16_BITS) &&
-            pos_le(info_ptr->sig_bit.green, SK_G16_BITS) &&
-            pos_le(info_ptr->sig_bit.blue, SK_B16_BITS)) {
+        if (pos_le(sig_bit->red, SK_R16_BITS) &&
+            pos_le(sig_bit->green, SK_G16_BITS) &&
+            pos_le(sig_bit->blue, SK_B16_BITS)) {
             *doDitherp = false;
         }
     }
 
     if (colorType == PNG_COLOR_TYPE_PALETTE) {
         bool paletteHasAlpha = hasTransparencyInPalette(png_ptr, info_ptr);
         *configp = this->getPrefConfig(kIndex_SrcDepth, paletteHasAlpha);
         // now see if we can upscale to their requested config
         if (!canUpscalePaletteToConfig(*configp, paletteHasAlpha)) {
             *configp = SkBitmap::kIndex8_Config;
@@ skipping 242 matching lines @@
     * png_read_image().  To see how to handle interlacing passes,
     * see the png_read_row() method below:
     */
     const int number_passes = (interlaceType != PNG_INTERLACE_NONE) ?
                               png_set_interlace_handling(png_ptr) : 1;
 
     /* Optional call to gamma correct and add the background to the palette
     * and update info structure.  REQUIRED if you are expecting libpng to
     * update the palette for you (ie you selected such a transform above).
     */
+
+    // Direct access to png_ptr fields is deprecated in libpng > 1.2.
+#if defined(PNG_1_0_X) || defined (PNG_1_2_X)
     png_ptr->pass = 0;

[scroggo, 2013/05/02 15:06:37]

There is a function call png_set_interlaced_pass, which sets png_ptr->pass. It
also sets png_ptr->iwidth, which is probably the correct thing to do, but I'm
not sure yet.

+#else
+    // FIXME: Figure out what (if anything) to do when Android moves to
+    // libpng > 1.2.
+#endif
     png_read_update_info(png_ptr, info_ptr);
 
     int actualTop = rect.fTop;
 
     if (SkBitmap::kIndex8_Config == config && 1 == sampleSize) {
         for (int i = 0; i < number_passes; i++) {
             png_configure_decoder(png_ptr, &actualTop, i);
             for (int j = 0; j < rect.fTop - actualTop; j++) {
                 uint8_t* bmRow = decodedBitmap.getAddr8(0, 0);
                 png_read_rows(png_ptr, &bmRow, png_bytepp_NULL, 1);
@@ skipping 87 matching lines @@
     return true;
 }
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkColorPriv.h"
 #include "SkUnPreMultiply.h"
 
 static void sk_write_fn(png_structp png_ptr, png_bytep data, png_size_t len) {
-    SkWStream* sk_stream = (SkWStream*)png_ptr->io_ptr;
+    SkWStream* sk_stream = (SkWStream*)png_get_io_ptr(png_ptr);
     if (!sk_stream->write(data, len)) {
         png_error(png_ptr, "sk_write_fn Error!");
     }
 }
 
 static transform_scanline_proc choose_proc(SkBitmap::Config config,
                                            bool hasAlpha) {
     // we don't care about search on alpha if we're kIndex8, since only the
     // colortable packing cares about that distinction, not the pixels
     if (SkBitmap::kIndex8_Config == config) {
@@ skipping 279 matching lines @@
     return SkImageDecoder::kUnknown_Format;
 }
 
 SkImageEncoder* sk_libpng_efactory(SkImageEncoder::Type t) {
     return (SkImageEncoder::kPNG_Type == t) ? SkNEW(SkPNGImageEncoder) : NULL;
 }
 
 static SkTRegistry<SkImageEncoder*, SkImageEncoder::Type> gEReg(sk_libpng_efactory);
 static SkTRegistry<SkImageDecoder::Format, SkStream*> gFormatReg(get_format_png);
 static SkTRegistry<SkImageDecoder*, SkStream*> gDReg(sk_libpng_dfactory);