Bmp Image Decoding

src/codec/SkSwizzler.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 "SkColorPriv.h"
 #include "SkSwizzler.h"
 #include "SkTemplates.h"
 
-// index
-
 #define A32_MASK_IN_PLACE   (SkPMColor)(SK_A32_MASK << SK_A32_SHIFT)
 
-static bool swizzle_index_to_n32(void* SK_RESTRICT dstRow,
-                                 const uint8_t* SK_RESTRICT src,
-                                 int width, int deltaSrc, int, const SkPMColor ctable[]) {
+// kIndex1, kIndex2, kIndex4
+
+static SkSwizzler::ResultAlpha swizzle_small_index_to_n32(
+        void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
+        int bitsPerPixel, int y, const SkPMColor ctable[]) {
+
+    SkPMColor* SK_RESTRICT dst = (SkPMColor*) dstRow;
+    SkPMColor maxAlpha = A32_MASK_IN_PLACE;
+    SkPMColor zeroAlpha = 0;
+    const uint32_t pixelsPerByte = 8 / bitsPerPixel;
+    const uint32_t rowBytes = (width + pixelsPerByte - 1) / pixelsPerByte;
+    const uint8_t mask = (1 << bitsPerPixel) - 1;
+
+    uint32_t x = 0;
+    for (uint32_t byte = 0; byte < rowBytes; byte++) {
+        uint8_t pixelData = src[byte];
+        for (uint32_t p = 0; p < pixelsPerByte && x < width; p++) {
+            uint8_t index = (pixelData >> (8 - bitsPerPixel)) & mask;
+            SkPMColor c = ctable[index];
+            dst[x] = c;
+            maxAlpha &= c;
+            zeroAlpha |= c & A32_MASK_IN_PLACE;
+            pixelData <<= bitsPerPixel;
+            x++;
+        }
+    }
+    return SkSwizzler::GetResult(zeroAlpha, maxAlpha >> SK_A32_SHIFT);
+}
+
+// kIndex
+
+static SkSwizzler::ResultAlpha swizzle_index_to_n32(
+        void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
+        int bitsPerPixel, int y, const SkPMColor ctable[]) {
 
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
-    SkPMColor cc = A32_MASK_IN_PLACE;
+    SkPMColor maxAlpha = A32_MASK_IN_PLACE;
+    SkPMColor zeroAlpha = 0;
     for (int x = 0; x < width; x++) {
         SkPMColor c = ctable[*src];
-        cc &= c;
+        maxAlpha &= c;
+        zeroAlpha |= c & A32_MASK_IN_PLACE;
         dst[x] = c;
-        src += deltaSrc;
+        src++;
     }
-    return cc != A32_MASK_IN_PLACE;
+    return SkSwizzler::GetResult(zeroAlpha, maxAlpha >> SK_A32_SHIFT);
 }
 
-static bool swizzle_index_to_n32_skipZ(void* SK_RESTRICT dstRow,
-                                      const uint8_t* SK_RESTRICT src,
-                                      int width, int deltaSrc, int,
-                                      const SkPMColor ctable[]) {
+static SkSwizzler::ResultAlpha swizzle_index_to_n32_skipZ(
+        void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
+        int bitsPerPixel, int y, const SkPMColor ctable[]) {
 
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
-    SkPMColor cc = A32_MASK_IN_PLACE;
+    SkPMColor maxAlpha = A32_MASK_IN_PLACE;
+    SkPMColor zeroAlpha = 0;
     for (int x = 0; x < width; x++) {
         SkPMColor c = ctable[*src];
-        cc &= c;
+        maxAlpha &= c;
+        zeroAlpha |= c & A32_MASK_IN_PLACE;
         if (c != 0) {
             dst[x] = c;
         }
-        src += deltaSrc;
+        src++;
     }
-    return cc != A32_MASK_IN_PLACE;
+    return SkSwizzler::GetResult(zeroAlpha, maxAlpha);
 }
 
 #undef A32_MASK_IN_PLACE
 
+static SkSwizzler::ResultAlpha swizzle_bgrx_to_n32(
+        void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
+        int bitsPerPixel, int y, const SkPMColor ctable[]) {
+
+    SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
+    int deltaSrc = bitsPerPixel / 8;
+    for (int x = 0; x < width; x++) {
+        dst[x] = SkPackARGB32NoCheck(0xFF, src[2], src[1], src[0]);
+        src += deltaSrc;
+    }
+    return SkSwizzler::kOpaque_ResultAlpha;
+}
+
+// kBGRA
+
+static SkSwizzler::ResultAlpha swizzle_bgra_to_n32(
+        void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
+        int bitsPerPixel, int y, const SkPMColor ctable[]) {
+
+    SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
+    uint8_t maxAlpha = 0xFF;
+    uint8_t zeroAlpha = 0;
+    int deltaSrc = bitsPerPixel / 8;
+    for (uint32_t x = 0; x < width; x++) {
+        uint8_t alpha = src[3];
+        maxAlpha &= alpha;
+        zeroAlpha |= alpha;
+        dst[x] = SkPackARGB32NoCheck(alpha, src[2], src[1], src[0]);
+        src += deltaSrc;
+    }
+    return SkSwizzler::GetResult(zeroAlpha, maxAlpha);
+}
+
 // n32
-static bool swizzle_rgbx_to_n32(void* SK_RESTRICT dstRow,
-                                const uint8_t* SK_RESTRICT src,
-                                int width, int deltaSrc, int, const SkPMColor[]) {
+static SkSwizzler::ResultAlpha swizzle_rgbx_to_n32(
+        void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
+        int bitsPerPixel, int y, const SkPMColor ctable[]) {
+
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
+    int deltaSrc = bitsPerPixel / 8;
     for (int x = 0; x < width; x++) {
         dst[x] = SkPackARGB32(0xFF, src[0], src[1], src[2]);
         src += deltaSrc;
     }
-    return false;
+    return SkSwizzler::kOpaque_ResultAlpha;
 }
 
-static bool swizzle_rgba_to_n32_premul(void* SK_RESTRICT dstRow,
-                                       const uint8_t* SK_RESTRICT src,
-                                       int width, int deltaSrc, int, const SkPMColor[]) {
+static SkSwizzler::ResultAlpha swizzle_rgba_to_n32_premul(
+        void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
+        int bitsPerPixel, int y, const SkPMColor ctable[]) {
+
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
-    unsigned alphaMask = 0xFF;
+    int deltaSrc = bitsPerPixel / 8;
+    uint8_t maxAlpha = 0xFF;
+    uint8_t zeroAlpha = 0;
     for (int x = 0; x < width; x++) {
         unsigned alpha = src[3];
         dst[x] = SkPreMultiplyARGB(alpha, src[0], src[1], src[2]);
         src += deltaSrc;
-        alphaMask &= alpha;
+        maxAlpha &= alpha;
+        zeroAlpha |= alpha;
     }
-    return alphaMask != 0xFF;
+    return SkSwizzler::GetResult(zeroAlpha, maxAlpha);
 }
 
-static bool swizzle_rgba_to_n32_unpremul(void* SK_RESTRICT dstRow,
-                                         const uint8_t* SK_RESTRICT src,
-                                         int width, int deltaSrc, int,
-                                         const SkPMColor[]) {
+static SkSwizzler::ResultAlpha swizzle_rgba_to_n32_unpremul(
+        void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
+        int bitsPerPixel, int y, const SkPMColor ctable[]) {
+
     uint32_t* SK_RESTRICT dst = reinterpret_cast<uint32_t*>(dstRow);
-    unsigned alphaMask = 0xFF;
+    int deltaSrc = bitsPerPixel / 8;
+    uint8_t maxAlpha = 0xFF;
+    uint8_t zeroAlpha = 0;
     for (int x = 0; x < width; x++) {
         unsigned alpha = src[3];
         dst[x] = SkPackARGB32NoCheck(alpha, src[0], src[1], src[2]);
         src += deltaSrc;
-        alphaMask &= alpha;
+        maxAlpha &= alpha;
+        zeroAlpha |= alpha;
     }
-    return alphaMask != 0xFF;
+    return SkSwizzler::GetResult(zeroAlpha, maxAlpha);
 }
 
-static bool swizzle_rgba_to_n32_premul_skipZ(void* SK_RESTRICT dstRow,
-                                             const uint8_t* SK_RESTRICT src,
-                                             int width, int deltaSrc, int,
-                                             const SkPMColor[]) {
+static SkSwizzler::ResultAlpha swizzle_rgba_to_n32_premul_skipZ(
+        void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
+        int bitsPerPixel, int y, const SkPMColor ctable[]) {
+
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
-    unsigned alphaMask = 0xFF;
+    int deltaSrc = bitsPerPixel / 8;
+    uint8_t maxAlpha = 0xFF;
+    uint8_t zeroAlpha = 0;
     for (int x = 0; x < width; x++) {
         unsigned alpha = src[3];
         if (0 != alpha) {
             dst[x] = SkPreMultiplyARGB(alpha, src[0], src[1], src[2]);
         }
         src += deltaSrc;
-        alphaMask &= alpha;
+        maxAlpha &= alpha;
+        zeroAlpha |= alpha;
     }
-    return alphaMask != 0xFF;
+    return SkSwizzler::GetResult(zeroAlpha, maxAlpha);
 }
 
 /**
     FIXME: This was my idea to cheat in order to continue taking advantage of skipping zeroes.
     This would be fine for drawing normally, but not for drawing with transfer modes. Being
     honest means we can draw correctly with transfer modes, with the cost of not being able
     to take advantage of Android's free unwritten pages. Something to keep in mind when we
     decide whether to switch to unpremul default.
 static bool swizzle_rgba_to_n32_unpremul_skipZ(void* SK_RESTRICT dstRow,
                                                const uint8_t* SK_RESTRICT src,
-                                               int width, int deltaSrc, int,
+                                               int width, int bitsPerPixel,
                                                const SkPMColor[]) {
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
     unsigned alphaMask = 0xFF;
     for (int x = 0; x < width; x++) {
         unsigned alpha = src[3];
         // NOTE: We cheat here. The caller requested unpremul and skip zeroes. It's possible
         // the color components are not zero, but we skip them anyway, meaning they'll remain
         // zero (implied by the request to skip zeroes).
         if (0 != alpha) {
             dst[x] = SkPackARGB32NoCheck(alpha, src[0], src[1], src[2]);
         }
         src += deltaSrc;
         alphaMask &= alpha;
     }
     return alphaMask != 0xFF;
 }
 */
 
-SkSwizzler* SkSwizzler::CreateSwizzler(SkSwizzler::SrcConfig sc, const SkPMColor* ctable,
+SkSwizzler::ResultAlpha SkSwizzler::GetResult(uint8_t zeroAlpha,
+                                              uint8_t maxAlpha) {
+    return (maxAlpha == 0xFF) ? SkSwizzler::kOpaque_ResultAlpha :
+            ((zeroAlpha == 0) ? SkSwizzler::kTransparent_ResultAlpha :
+            SkSwizzler::kNeither_ResultAlpha);
+}
+
+SkSwizzler* SkSwizzler::CreateSwizzler(SkSwizzler::SrcConfig sc,
+                                       const SkPMColor* ctable,
                                        const SkImageInfo& info, void* dst,
                                        size_t dstRowBytes, bool skipZeroes) {
-    if (info.colorType() == kUnknown_SkColorType) {
+    if (kUnknown_SkColorType == info.colorType()) {
         return NULL;
     }
     if (info.minRowBytes() > dstRowBytes) {
         return  NULL;
     }
-    if (kIndex == sc && NULL == ctable) {
+    if ((kIndex == sc || kIndex4 == sc || kIndex2 == sc || kIndex1 == sc)
+            && NULL == ctable) {
         return NULL;
     }
     RowProc proc = NULL;
     switch (sc) {
+        case kIndex1:
+        case kIndex2:
+        case kIndex4:
+            switch (info.colorType()) {
+                case kN32_SkColorType:
+                    proc = &swizzle_small_index_to_n32;
+                    break;
+                default:
+                    break;
+            }
+            break;
         case kIndex:
             switch (info.colorType()) {
                 case kN32_SkColorType:
-                    // We assume the color premultiplied ctable (or not) as desired.
-                    if (skipZeroes) {
-                        proc = &swizzle_index_to_n32_skipZ;
-                    } else {
-                        proc = &swizzle_index_to_n32;
-                    }
+                    proc = &swizzle_index_to_n32;
                     break;
-                    
                 default:
                     break;
             }
+            break;
+        case kBGR:
+        case kBGRX:
+            switch (info.colorType()) {
+                case kN32_SkColorType:
+                    proc = &swizzle_bgrx_to_n32;
+                    break;
+                default:
+                    break;
+            }
+            break;
+        case kBGRA:
+            switch (info.colorType()) {
+                case kN32_SkColorType:
+                    proc = &swizzle_bgra_to_n32;
+                    break;
+                default:
+                    break;
+            }
             break;
         case kRGBX:
             // TODO: Support other swizzles.
             switch (info.colorType()) {
                 case kN32_SkColorType:
                     proc = &swizzle_rgbx_to_n32;
                     break;
                 default:
                     break;
             }
             break;
         case kRGBA:
             switch (info.colorType()) {
                 case kN32_SkColorType:
                     if (info.alphaType() == kUnpremul_SkAlphaType) {
                         // Respect skipZeroes?
                         proc = &swizzle_rgba_to_n32_unpremul;
                     } else {
                         if (skipZeroes) {
                             proc = &swizzle_rgba_to_n32_premul_skipZ;
                         } else {
                             proc = &swizzle_rgba_to_n32_premul;
                         }
                     }
                     break;
                 default:
                     break;
             }
             break;
+        case kRGB:
+            switch (info.colorType()) {
+                case kN32_SkColorType:
+                    proc = &swizzle_rgbx_to_n32;
+                    break;
+                default:
+                    break;
+            }
+            break;
         default:
             break;
     }
     if (NULL == proc) {
         return NULL;
     }
-    return SkNEW_ARGS(SkSwizzler, (proc, ctable, BytesPerPixel(sc), info, dst, dstRowBytes));
+    return SkNEW_ARGS(SkSwizzler, (proc, ctable, BitsPerPixel(sc), info, dst,
+                                   dstRowBytes));
 }
 
-SkSwizzler::SkSwizzler(RowProc proc, const SkPMColor* ctable, int srcBpp,
-                       const SkImageInfo& info, void* dst, size_t rowBytes)
+SkSwizzler::SkSwizzler(RowProc proc, const SkPMColor* ctable,
+                       int srcBitsPerPixel, const SkImageInfo& info, void* dst,
+                       size_t rowBytes)
     : fRowProc(proc)
     , fColorTable(ctable)
-    , fSrcPixelSize(srcBpp)
+    , fSrcBitsPerPixel(srcBitsPerPixel)
     , fDstInfo(info)
     , fDstRow(dst)
     , fDstRowBytes(rowBytes)
     , fCurrY(0)
 {
 }
 
-bool SkSwizzler::next(const uint8_t* SK_RESTRICT src) {
+SkSwizzler::ResultAlpha SkSwizzler::next(const uint8_t* SK_RESTRICT src) {
     SkASSERT(fCurrY < fDstInfo.height());
-    const bool hadAlpha = fRowProc(fDstRow, src, fDstInfo.width(), fSrcPixelSize,
-                                   fCurrY, fColorTable);
-    fCurrY++;
+
+    // Decode a row
+    const ResultAlpha result = fRowProc(fDstRow, src, fDstInfo.width(),
+            fSrcBitsPerPixel, fCurrY, fColorTable);
+
+    // Move to the next row and return the result
     fDstRow = SkTAddOffset<void>(fDstRow, fDstRowBytes);
-    return hadAlpha;
+    return result;
 }
 
+SkSwizzler::ResultAlpha SkSwizzler::next(const uint8_t* SK_RESTRICT src,
+        uint32_t y) {
+    SkASSERT(y < fDstInfo.height());
+    
+    // Choose the row
+    void* row = SkTAddOffset<void>(fDstRow, y*fDstRowBytes);
+
+    // Decode the row
+    return fRowProc(row, src, fDstInfo.width(), fSrcBitsPerPixel, fCurrY,
+            fColorTable);
+}