Support more swizzles to 565 in SkCodec

src/codec/SkMaskSwizzler.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 "SkCodecPriv.h"
 #include "SkColorPriv.h"
 #include "SkMaskSwizzler.h"
@@ skipping 45 matching lines @@
         uint8_t red = masks->getRed(p);
         uint8_t green = masks->getGreen(p);
         uint8_t blue = masks->getBlue(p);
         uint8_t alpha = masks->getAlpha(p);
         UPDATE_RESULT_ALPHA(alpha);
         dstPtr[i] = SkPreMultiplyARGB(alpha, red, green, blue);
     }
     return COMPUTE_RESULT_ALPHA;
 }
 
+static SkSwizzler::ResultAlpha swizzle_mask16_to_565(

[msarett, 2015/08/10 17:44:24]

Would you mind adding a TODO (msarett) here to improve this routine?  IMO, one
of the few reasonable uses of bmp mask mode is to an encode an image as 565.  I
think we ought to be able to recognize that the image is encoded as 565 and
swizzle directly to 565 rather than promote to 888 and then move back down to
565.

This is something that I neglected in the past that I think should be done.

[scroggo, 2015/08/10 17:50:45]

Done.

+        void* dstRow, const uint8_t* srcRow, int width, SkMasks* masks) {
+
+    // Use the masks to decode to the destination
+    uint16_t* srcPtr = (uint16_t*) srcRow;
+    uint16_t* dstPtr = (uint16_t*) dstRow;
+    for (int i = 0; i < width; i++) {
+        uint16_t p = srcPtr[i];
+        uint8_t red = masks->getRed(p);
+        uint8_t green = masks->getGreen(p);
+        uint8_t blue = masks->getBlue(p);
+        dstPtr[i] = SkPack888ToRGB16(red, green, blue);
+    }
+    return SkSwizzler::kOpaque_ResultAlpha;
+}
+
 static SkSwizzler::ResultAlpha swizzle_mask24_to_n32_opaque(
         void* dstRow, const uint8_t* srcRow, int width, SkMasks* masks) {
 
     // Use the masks to decode to the destination
     SkPMColor* dstPtr = (SkPMColor*) dstRow;
     for (int i = 0; i < 3*width; i += 3) {
         uint32_t p = srcRow[i] | (srcRow[i + 1] << 8) | srcRow[i + 2] << 16;
         uint8_t red = masks->getRed(p);
         uint8_t green = masks->getGreen(p);
         uint8_t blue = masks->getBlue(p);
@@ skipping 31 matching lines @@
         uint8_t red = masks->getRed(p);
         uint8_t green = masks->getGreen(p);
         uint8_t blue = masks->getBlue(p);
         uint8_t alpha = masks->getAlpha(p);
         UPDATE_RESULT_ALPHA(alpha);
         dstPtr[i/3] = SkPreMultiplyARGB(alpha, red, green, blue);
     }
     return COMPUTE_RESULT_ALPHA;
 }
 
+static SkSwizzler::ResultAlpha swizzle_mask24_to_565(
+        void* dstRow, const uint8_t* srcRow, int width, SkMasks* masks) {
+
+    // Use the masks to decode to the destination
+    uint16_t* dstPtr = (uint16_t*) dstRow;
+    for (int i = 0; i < 3*width; i += 3) {
+        uint32_t p = srcRow[i] | (srcRow[i + 1] << 8) | srcRow[i + 2] << 16;
+        uint8_t red = masks->getRed(p);
+        uint8_t green = masks->getGreen(p);
+        uint8_t blue = masks->getBlue(p);
+        dstPtr[i/3] = SkPack888ToRGB16(red, green, blue);
+    }
+    return SkSwizzler::kOpaque_ResultAlpha;
+}
+
 static SkSwizzler::ResultAlpha swizzle_mask32_to_n32_opaque(
         void* dstRow, const uint8_t* srcRow, int width, SkMasks* masks) {
 
     // Use the masks to decode to the destination
     uint32_t* srcPtr = (uint32_t*) srcRow;
     SkPMColor* dstPtr = (SkPMColor*) dstRow;
     for (int i = 0; i < width; i++) {
         uint32_t p = srcPtr[i];
         uint8_t red = masks->getRed(p);
         uint8_t green = masks->getGreen(p);
@@ skipping 34 matching lines @@
         uint8_t red = masks->getRed(p);
         uint8_t green = masks->getGreen(p);
         uint8_t blue = masks->getBlue(p);
         uint8_t alpha = masks->getAlpha(p);
         UPDATE_RESULT_ALPHA(alpha);
         dstPtr[i] = SkPreMultiplyARGB(alpha, red, green, blue);
     }
     return COMPUTE_RESULT_ALPHA;
 }
 
+static SkSwizzler::ResultAlpha swizzle_mask32_to_565(
+        void* dstRow, const uint8_t* srcRow, int width, SkMasks* masks) {
+    // Use the masks to decode to the destination
+    uint32_t* srcPtr = (uint32_t*) srcRow;
+    uint16_t* dstPtr = (uint16_t*) dstRow;
+    for (int i = 0; i < width; i++) {
+        uint32_t p = srcPtr[i];
+        uint8_t red = masks->getRed(p);
+        uint8_t green = masks->getGreen(p);
+        uint8_t blue = masks->getBlue(p);
+        dstPtr[i] = SkPack888ToRGB16(red, green, blue);
+    }
+    return SkSwizzler::kOpaque_ResultAlpha;
+}
+
 /*
  *
  * Create a new mask swizzler
  *
  */
 SkMaskSwizzler* SkMaskSwizzler::CreateMaskSwizzler(
         const SkImageInfo& info, SkMasks* masks, uint32_t bitsPerPixel) {
 
     // Choose the appropriate row procedure
     RowProc proc = NULL;
     switch (bitsPerPixel) {
         case 16:
             switch (info.colorType()) {
                 case kN32_SkColorType:
                     switch (info.alphaType()) {
                         case kUnpremul_SkAlphaType:
                             proc = &swizzle_mask16_to_n32_unpremul;
                             break;
                         case kPremul_SkAlphaType:
                             proc = &swizzle_mask16_to_n32_premul;
                             break;
                         case kOpaque_SkAlphaType:
                             proc = &swizzle_mask16_to_n32_opaque;
                             break;
                         default:
                             break;
                     }
                     break;
+                case kRGB_565_SkColorType:
+                    switch (info.alphaType()) {
+                        case kOpaque_SkAlphaType:
+                            proc = &swizzle_mask16_to_565;
+                            break;
+                        default:
+                            break;
+                    }
+                    break;
                 default:
                     break;
             }
             break;
         case 24:
             switch (info.colorType()) {
                 case kN32_SkColorType:
                     switch (info.alphaType()) {
                         case kUnpremul_SkAlphaType:
                             proc = &swizzle_mask24_to_n32_unpremul;
                             break;
                         case kPremul_SkAlphaType:
                             proc = &swizzle_mask24_to_n32_premul;
                             break;
                         case kOpaque_SkAlphaType:
                             proc = &swizzle_mask24_to_n32_opaque;
                             break;
                         default:
                             break;
                     }
                     break;
+                case kRGB_565_SkColorType:
+                    switch (info.alphaType()) {
+                        case kOpaque_SkAlphaType:
+                            proc = &swizzle_mask24_to_565;
+                            break;
+                        default:
+                            break;
+                    }
+                    break;
                 default:
                     break;
             }
             break;
         case 32:
             switch (info.colorType()) {
                 case kN32_SkColorType:
                     switch (info.alphaType()) {
                         case kUnpremul_SkAlphaType:
                             proc = &swizzle_mask32_to_n32_unpremul;
                             break;
                         case kPremul_SkAlphaType:
                             proc = &swizzle_mask32_to_n32_premul;
                             break;
                         case kOpaque_SkAlphaType:
                             proc = &swizzle_mask32_to_n32_opaque;
                             break;
                         default:
                             break;
                     }
                     break;
+                case kRGB_565_SkColorType:
+                    switch (info.alphaType()) {
+                        case kOpaque_SkAlphaType:
+                            proc = &swizzle_mask32_to_565;
+                            break;
+                        default:
+                            break;
+                    }
+                    break;
                 default:
                     break;
             }
             break;
         default:
             SkASSERT(false);
             return NULL;
     }
     return SkNEW_ARGS(SkMaskSwizzler, (info, masks, proc));
 }
@@ skipping 12 matching lines @@
 
 /*
  *
  * Swizzle the specified row
  *
  */
 SkSwizzler::ResultAlpha SkMaskSwizzler::swizzle(void* dst, const uint8_t* SK_RESTRICT src) {
     SkASSERT(NULL != dst && NULL != src);
     return fRowProc(dst, src, fDstInfo.width(), fMasks);
 }