Bmp Image Decoding

src/codec/SkCodec_libpng.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCodec_libpng.h"
 #include "SkColorPriv.h"
 #include "SkColorTable.h"
@@ skipping 328 matching lines @@
     , fInfo_ptr(info_ptr) {}
 
 SkPngCodec::~SkPngCodec() {
     png_destroy_read_struct(&fPng_ptr, &fInfo_ptr, png_infopp_NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Getting the pixels
 ///////////////////////////////////////////////////////////////////////////////
 
-static bool premul_and_unpremul(SkAlphaType A, SkAlphaType B) {
-    return kPremul_SkAlphaType == A && kUnpremul_SkAlphaType == B;
-}
-
 static bool conversion_possible(const SkImageInfo& A, const SkImageInfo& B) {
     // TODO: Support other conversions
     if (A.colorType() != B.colorType()) {
         return false;
     }
     if (A.profileType() != B.profileType()) {
         return false;
     }
     if (A.alphaType() == B.alphaType()) {
         return true;
@@ skipping 78 matching lines @@
         return kUnimplemented;
     }
 
     // FIXME: Here is where we should likely insert some of the modifications
     // made in the factory.
     png_read_update_info(fPng_ptr, fInfo_ptr);
 
     if (numberPasses > 1) {
         const int width = requestedInfo.width();
         const int height = requestedInfo.height();
-        const int bpp = SkSwizzler::BytesPerPixel(sc);
+        const int bpp = SkSwizzler::DeltaSrc(sc);
         const size_t rowBytes = width * bpp;
 
         storage.reset(width * height * bpp);
         uint8_t* const base = static_cast<uint8_t*>(storage.get());
 
         for (int i = 0; i < numberPasses; i++) {
             uint8_t* row = base;
             for (int y = 0; y < height; y++) {
                 uint8_t* bmRow = row;
                 png_read_rows(fPng_ptr, &bmRow, png_bytepp_NULL, 1);
                 row += rowBytes;
             }
         }
 
         // Now swizzle it.
         uint8_t* row = base;
         for (int y = 0; y < height; y++) {
-            reallyHasAlpha |= swizzler->next(row);
+            reallyHasAlpha |= !SkSwizzler::IsOpaque(swizzler->next(row));
             row += rowBytes;
         }
     } else {
-        storage.reset(requestedInfo.width() * SkSwizzler::BytesPerPixel(sc));
+        storage.reset(requestedInfo.width() * SkSwizzler::DeltaSrc(sc));
         uint8_t* srcRow = static_cast<uint8_t*>(storage.get());
         for (int y = 0; y < requestedInfo.height(); y++) {
             png_read_rows(fPng_ptr, &srcRow, png_bytepp_NULL, 1);
-            reallyHasAlpha |= swizzler->next(srcRow);
+            reallyHasAlpha |= !SkSwizzler::IsOpaque(swizzler->next(srcRow));
         }
     }
 
     /* read rest of file, and get additional chunks in info_ptr - REQUIRED */
     png_read_end(fPng_ptr, fInfo_ptr);
 
     // FIXME: do we need substituteTranspColor?
 
     if (reallyHasAlpha && requestedInfo.alphaType() != kOpaque_SkAlphaType) {
         // FIXME: We want to alert the caller. Is this the right way?
         SkImageInfo* modInfo = const_cast<SkImageInfo*>(&requestedInfo);
         *modInfo = requestedInfo.makeAlphaType(kOpaque_SkAlphaType);
     }
     return kSuccess;
 }