Support for interlaced PNGs (in gfx::PNGCodec)

ui/gfx/codec/png_codec.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/gfx/codec/png_codec.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_util.h"
 #include "ui/gfx/size.h"
@@ skipping 36 matching lines @@
                       unsigned char* rgb, bool* is_opaque) {
   for (int x = 0; x < pixel_width; x++) {
     const unsigned char* pixel_in = &rgba[x * 4];
     unsigned char* pixel_out = &rgb[x * 3];
     pixel_out[0] = pixel_in[0];
     pixel_out[1] = pixel_in[1];
     pixel_out[2] = pixel_in[2];
   }
 }
 
-void ConvertRGBtoSkia(const unsigned char* rgb, int pixel_width,
-                      unsigned char* rgba, bool* is_opaque) {
-  for (int x = 0; x < pixel_width; x++) {
-    const unsigned char* pixel_in = &rgb[x * 3];
-    uint32_t* pixel_out = reinterpret_cast<uint32_t*>(&rgba[x * 4]);
-    *pixel_out = SkPackARGB32(0xFF, pixel_in[0], pixel_in[1], pixel_in[2]);
-  }
-}
-
-void ConvertRGBAtoSkia(const unsigned char* rgb, int pixel_width,
-                       unsigned char* rgba, bool* is_opaque) {
-  int total_length = pixel_width * 4;
-  for (int x = 0; x < total_length; x += 4) {
-    const unsigned char* pixel_in = &rgb[x];
-    uint32_t* pixel_out = reinterpret_cast<uint32_t*>(&rgba[x]);
-
-    unsigned char alpha = pixel_in[3];
-    if (alpha != 255) {
-      *is_opaque = false;
-      *pixel_out = SkPreMultiplyARGB(alpha,
-           pixel_in[0], pixel_in[1], pixel_in[2]);
-    } else {
-      *pixel_out = SkPackARGB32(alpha,
-           pixel_in[0], pixel_in[1], pixel_in[2]);
-    }
-  }
-}
-
 void ConvertSkiatoRGB(const unsigned char* skia, int pixel_width,
                       unsigned char* rgb, bool* is_opaque) {
   for (int x = 0; x < pixel_width; x++) {
     const uint32_t pixel_in = *reinterpret_cast<const uint32_t*>(&skia[x * 4]);
     unsigned char* pixel_out = &rgb[x * 3];
 
     int alpha = SkGetPackedA32(pixel_in);
     if (alpha != 0 && alpha != 255) {
       SkColor unmultiplied = SkUnPreMultiply::PMColorToColor(pixel_in);
       pixel_out[0] = SkColorGetR(unmultiplied);
@@ skipping 46 matching lines @@
 
 class PngDecoderState {
  public:
   // Output is a vector<unsigned char>.
   PngDecoderState(PNGCodec::ColorFormat ofmt, std::vector<unsigned char>* o)
       : output_format(ofmt),
         output_channels(0),
         bitmap(NULL),
         is_opaque(true),
         output(o),
-        row_converter(NULL),
         width(0),
         height(0),
         done(false) {
   }
 
   // Output is an SkBitmap.
   explicit PngDecoderState(SkBitmap* skbitmap)
       : output_format(PNGCodec::FORMAT_SkBitmap),
         output_channels(0),
         bitmap(skbitmap),
         is_opaque(true),
         output(NULL),
-        row_converter(NULL),
         width(0),
         height(0),
         done(false) {
   }
 
   PNGCodec::ColorFormat output_format;
   int output_channels;
 
   // An incoming SkBitmap to write to. If NULL, we write to output instead.
   SkBitmap* bitmap;
 
   // Used during the reading of an SkBitmap. Defaults to true until we see a
   // pixel with anything other than an alpha of 255.
   bool is_opaque;
 
   // The other way to decode output, where we write into an intermediary buffer
   // instead of directly to an SkBitmap.
   std::vector<unsigned char>* output;
 
-  // Called to convert a row from the library to the correct output format.
-  // When NULL, no conversion is necessary.
-  void (*row_converter)(const unsigned char* in, int w, unsigned char* out,
-                        bool* is_opaque);
-
   // Size of the image, set in the info callback.
   int width;
   int height;
 
   // Set to true when we've found the end of the data.
   bool done;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PngDecoderState);
 };
 
-void ConvertRGBtoRGBA(const unsigned char* rgb, int pixel_width,
-                      unsigned char* rgba, bool* is_opaque) {
-  for (int x = 0; x < pixel_width; x++) {
-    const unsigned char* pixel_in = &rgb[x * 3];
-    unsigned char* pixel_out = &rgba[x * 4];
-    pixel_out[0] = pixel_in[0];
-    pixel_out[1] = pixel_in[1];
-    pixel_out[2] = pixel_in[2];
-    pixel_out[3] = 0xff;
+// User transform (passed to libpng) which converts a row decoded by libpng to
+// Skia format. Expects the row to have 4 channels, otherwise there won't be
+// enough room in |data|.
+void ConvertRGBARowToSkia(png_structp png_ptr,
+                          png_row_infop row_info,
+                          png_bytep data) {
+  const int channels = row_info->channels;
+  DCHECK_EQ(channels, 4);
+
+  PngDecoderState* state =
+      static_cast<PngDecoderState*>(png_get_user_transform_ptr(png_ptr));
+  DCHECK(state) << "LibPNG user transform pointer is NULL";
+
+  unsigned char* const end = data + row_info->rowbytes;
+  for (unsigned char* p = data; p < end; p += channels) {
+    uint32_t* sk_pixel = reinterpret_cast<uint32_t*>(p);
+    const unsigned char alpha = p[channels - 1];
+    if (alpha != 255) {
+      state->is_opaque = false;
+      *sk_pixel = SkPreMultiplyARGB(alpha, p[0], p[1], p[2]);
+    } else {
+      *sk_pixel = SkPackARGB32(alpha, p[0], p[1], p[2]);
+    }
   }
 }
 
-void ConvertRGBtoBGRA(const unsigned char* rgb, int pixel_width,
-                      unsigned char* bgra, bool* is_opaque) {
-  for (int x = 0; x < pixel_width; x++) {
-    const unsigned char* pixel_in = &rgb[x * 3];
-    unsigned char* pixel_out = &bgra[x * 4];
-    pixel_out[0] = pixel_in[2];
-    pixel_out[1] = pixel_in[1];
-    pixel_out[2] = pixel_in[0];
-    pixel_out[3] = 0xff;
-  }
-}
-
 // Called when the png header has been read. This code is based on the WebKit
 // PNGImageDecoder
 void DecodeInfoCallback(png_struct* png_ptr, png_info* info_ptr) {
   PngDecoderState* state = static_cast<PngDecoderState*>(
       png_get_progressive_ptr(png_ptr));
 
   int bit_depth, color_type, interlace_type, compression_type;
-  int filter_type, channels;
+  int filter_type;
   png_uint_32 w, h;
   png_get_IHDR(png_ptr, info_ptr, &w, &h, &bit_depth, &color_type,
                &interlace_type, &compression_type, &filter_type);
 
   // Bounds check. When the image is unreasonably big, we'll error out and
   // end up back at the setjmp call when we set up decoding.  "Unreasonably big"
   // means "big enough that w * h * 32bpp might overflow an int"; we choose this
   // threshold to match WebKit and because a number of places in code assume
   // that an image's size (in bytes) fits in a (signed) int.
   unsigned long long total_size =
       static_cast<unsigned long long>(w) * static_cast<unsigned long long>(h);
   if (total_size > ((1 << 29) - 1))
     longjmp(png_jmpbuf(png_ptr), 1);
   state->width = static_cast<int>(w);
   state->height = static_cast<int>(h);
 
+  // The following png_set_* calls have to be done in the order dictated by
+  // the libpng docs. This is why certain things are done outside of the
+  // switch, even though they look like they belong there.
+
   // Expand to ensure we use 24-bit for RGB and 32-bit for RGBA.
   if (color_type == PNG_COLOR_TYPE_PALETTE ||
       (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8))
     png_set_expand(png_ptr);
 
+  bool input_has_alpha = (color_type & PNG_COLOR_MASK_ALPHA);
+
   // Transparency for paletted images.
-  if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
+  if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
     png_set_expand(png_ptr);
+    input_has_alpha = true;
+  }
 
   // Convert 16-bit to 8-bit.
   if (bit_depth == 16)
     png_set_strip_16(png_ptr);
 
+  // See comment about png_set_* call ordering, above.
+  if (state->output_format == PNGCodec::FORMAT_BGRA)
+    png_set_bgr(png_ptr);

[tony, 2012/03/06 19:55:30]

Why do we call this? Does it replace ConvertRGBtoBGRA usage in the old code?

[Francois, 2012/03/07 07:40:10]

That's correct. I've moved this into the switch statement in patch set 5. It's
probably cleaner to have it in there, even after the coming refactoring changes.

+
+  // Pick our row format converter necessary for this data.
+  if (!input_has_alpha) {
+    switch (state->output_format) {
+      case PNGCodec::FORMAT_RGB:
+        state->output_channels = 3;
+        break;
+      case PNGCodec::FORMAT_RGBA:
+        state->output_channels = 4;
+        png_set_add_alpha(png_ptr, 0xFF, PNG_FILLER_AFTER);
+        break;
+      case PNGCodec::FORMAT_BGRA:
+        state->output_channels = 4;
+        png_set_add_alpha(png_ptr, 0xFF, PNG_FILLER_AFTER);
+        break;
+      case PNGCodec::FORMAT_SkBitmap:
+        state->output_channels = 4;
+        png_set_add_alpha(png_ptr, 0xFF, PNG_FILLER_AFTER);
+        break;
+      default:
+        NOTREACHED() << "Unknown output format";

[tony, 2012/03/06 19:55:30]

Please remove the default case.  The compiler will notify us if we forgot a
case.

[Francois, 2012/03/07 07:40:10]

Done.

+        break;
+    }
+  } else {
+    switch (state->output_format) {
+      case PNGCodec::FORMAT_RGB:
+        png_set_strip_alpha(png_ptr);
+        state->output_channels = 3;
+        break;
+      case PNGCodec::FORMAT_RGBA:
+        state->output_channels = 4;
+        break;
+      case PNGCodec::FORMAT_BGRA:
+        state->output_channels = 4;

[tony, 2012/03/06 19:55:30]

I assume that ConvertBetweenBGRAandRGBA is not needed because of the call to
png_set_bgr?

[Francois, 2012/03/07 07:40:10]

Correct.

+        break;
+      case PNGCodec::FORMAT_SkBitmap:
+        state->output_channels = 4;
+        break;
+      default:
+        NOTREACHED() << "Unknown output format";

[tony, 2012/03/06 19:55:30]

Please remove the default case.  The compiler will notify us if we forgot a
case.

[Francois, 2012/03/07 07:40:10]

Done.

+        break;
+    }
+  }
+
   // Expand grayscale to RGB.
   if (color_type == PNG_COLOR_TYPE_GRAY ||
       color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
     png_set_gray_to_rgb(png_ptr);
 
   // Deal with gamma and keep it under our control.
   double gamma;
   if (png_get_gAMA(png_ptr, info_ptr, &gamma)) {
     if (gamma <= 0.0 || gamma > kMaxGamma) {
       gamma = kInverseGamma;
       png_set_gAMA(png_ptr, info_ptr, gamma);
     }
     png_set_gamma(png_ptr, kDefaultGamma, gamma);
   } else {
     png_set_gamma(png_ptr, kDefaultGamma, kInverseGamma);
   }
 
+  // See comment about png_set_* call ordering, above.
+  if (state->output_format == PNGCodec::FORMAT_SkBitmap) {
+    png_set_read_user_transform_fn(png_ptr, ConvertRGBARowToSkia);
+    png_set_user_transform_info(png_ptr, state, 0, 0);

[tony, 2012/03/06 19:55:30]

Can you make the comment explicit?  E.g., png_set_user_transform_info must be
called after png_set_strip_alpha (I'm not sure if that's true, but you get the
idea).

[Francois, 2012/03/07 07:40:10]

Done.

+  }
+
   // Tell libpng to send us rows for interlaced pngs.
   if (interlace_type == PNG_INTERLACE_ADAM7)
     png_set_interlace_handling(png_ptr);
 
-  // Update our info now
   png_read_update_info(png_ptr, info_ptr);
-  channels = png_get_channels(png_ptr, info_ptr);
-
-  // Pick our row format converter necessary for this data.
-  if (channels == 3) {
-    switch (state->output_format) {
-      case PNGCodec::FORMAT_RGB:
-        state->row_converter = NULL;  // no conversion necessary
-        state->output_channels = 3;
-        break;
-      case PNGCodec::FORMAT_RGBA:
-        state->row_converter = &ConvertRGBtoRGBA;
-        state->output_channels = 4;
-        break;
-      case PNGCodec::FORMAT_BGRA:
-        state->row_converter = &ConvertRGBtoBGRA;
-        state->output_channels = 4;
-        break;
-      case PNGCodec::FORMAT_SkBitmap:
-        state->row_converter = &ConvertRGBtoSkia;
-        state->output_channels = 4;
-        break;
-      default:
-        NOTREACHED() << "Unknown output format";
-        break;
-    }
-  } else if (channels == 4) {
-    switch (state->output_format) {
-      case PNGCodec::FORMAT_RGB:
-        state->row_converter = &ConvertRGBAtoRGB;
-        state->output_channels = 3;
-        break;
-      case PNGCodec::FORMAT_RGBA:
-        state->row_converter = NULL;  // no conversion necessary
-        state->output_channels = 4;
-        break;
-      case PNGCodec::FORMAT_BGRA:
-        state->row_converter = &ConvertBetweenBGRAandRGBA;
-        state->output_channels = 4;
-        break;
-      case PNGCodec::FORMAT_SkBitmap:
-        state->row_converter = &ConvertRGBAtoSkia;
-        state->output_channels = 4;
-        break;
-      default:
-        NOTREACHED() << "Unknown output format";
-        break;
-    }
-  } else {
-    NOTREACHED() << "Unknown input channels";
-    longjmp(png_jmpbuf(png_ptr), 1);
-  }
 
   if (state->bitmap) {
     state->bitmap->setConfig(SkBitmap::kARGB_8888_Config,
                              state->width, state->height);
     state->bitmap->allocPixels();
   } else if (state->output) {
     state->output->resize(
         state->width * state->output_channels * state->height);
   }
 }
 
 void DecodeRowCallback(png_struct* png_ptr, png_byte* new_row,
                        png_uint_32 row_num, int pass) {
+  if (!new_row)
+    return;  // Interlaced image; row didn't change this pass.
+
   PngDecoderState* state = static_cast<PngDecoderState*>(
       png_get_progressive_ptr(png_ptr));
 
-  DCHECK(pass == 0) << "We didn't turn on interlace handling, but libpng is "
-                       "giving us interlaced data.";
   if (static_cast<int>(row_num) > state->height) {
     NOTREACHED() << "Invalid row";
     return;
   }
 
   unsigned char* base = NULL;
   if (state->bitmap)
     base = reinterpret_cast<unsigned char*>(state->bitmap->getAddr32(0, 0));
   else if (state->output)
     base = &state->output->front();
 
   unsigned char* dest = &base[state->width * state->output_channels * row_num];
-  if (state->row_converter)
-    state->row_converter(new_row, state->width, dest, &state->is_opaque);
-  else
-    memcpy(dest, new_row, state->width * state->output_channels);
+  png_progressive_combine_row(png_ptr, dest, new_row);

[tony, 2012/03/06 19:55:30]

This is what add interlaced png support, right?

[Francois, 2012/03/07 07:40:10]

Yes, this is the core change that was required for interlaced support.

 }
 
 void DecodeEndCallback(png_struct* png_ptr, png_info* info) {
   PngDecoderState* state = static_cast<PngDecoderState*>(
       png_get_progressive_ptr(png_ptr));
 
   // Mark the image as complete, this will tell the Decode function that we
   // have successfully found the end of the data.
   state->done = true;
 }
@@ skipping 406 matching lines @@
 }
 
 PNGCodec::Comment::Comment(const std::string& k, const std::string& t)
     : key(k), text(t) {
 }
 
 PNGCodec::Comment::~Comment() {
 }
 
 }  // namespace gfx