add kGray_8_SkColorType

src/core/SkConfig8888.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmap.h"
 #include "SkCanvas.h"
 #include "SkConfig8888.h"
@@ skipping 119 matching lines @@
                         int rowCount) {
     SkASSERT(bytesPerRow <= srcRB);
     SkASSERT(bytesPerRow <= dstRB);
     for (int i = 0; i < rowCount; ++i) {
         memcpy(dst, src, bytesPerRow);
         dst = (char*)dst + dstRB;
         src = (const char*)src + srcRB;
     }
 }
 
+static void copy_g8_to_32(void* dst, size_t dstRB, const void* src, size_t srcRB, int w, int h) {
+    uint32_t* dst32 = (uint32_t*)dst;
+    const uint8_t* src8 = (const uint8_t*)src;
+    
+    for (int y = 0; y < h; ++y) {
+        for (int x = 0; x < w; ++x) {
+            dst32[x] = SkPackARGB32(0xFF, src8[x], src8[x], src8[x]);
+        }
+        dst32 = (uint32_t*)((char*)dst32 + dstRB);
+        src8 += srcRB;
+    }
+}
+
+static void copy_32_to_g8(void* dst, size_t dstRB, const void* src, size_t srcRB,
+                          const SkImageInfo& srcInfo) {
+    uint8_t* dst8 = (uint8_t*)dst;
+    const uint32_t* src32 = (const uint32_t*)src;
+
+    const int w = srcInfo.width();
+    const int h = srcInfo.height();
+    const bool isBGRA = (kBGRA_8888_SkColorType == srcInfo.colorType());
+
+    for (int y = 0; y < h; ++y) {
+        if (isBGRA) {
+            // BGRA
+            for (int x = 0; x < w; ++x) {
+                uint32_t s = src32[x];
+                dst8[x] = SkComputeLuminance((s >> 16) & 0xFF, (s >> 8) & 0xFF, s & 0xFF);
+            }
+        } else {
+            // RGBA
+            for (int x = 0; x < w; ++x) {
+                uint32_t s = src32[x];
+                dst8[x] = SkComputeLuminance(s & 0xFF, (s >> 8) & 0xFF, (s >> 16) & 0xFF);
+            }
+        }
+        src32 = (const uint32_t*)((const char*)src32 + srcRB);
+        dst8 += dstRB;
+    }
+}
+
 bool SkPixelInfo::CopyPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRB,
                              const SkImageInfo& srcInfo, const void* srcPixels, size_t srcRB,
                              SkColorTable* ctable) {
     if (srcInfo.dimensions() != dstInfo.dimensions()) {
         return false;
     }
 
     const int width = srcInfo.width();
     const int height = srcInfo.height();
 
@@ skipping 13 matching lines @@
 
         return srcPI.convertPixelsTo(&dstPI, width, height);
     }
 
     // If they agree on colorType and the alphaTypes are compatible, then we just memcpy.
     // Note: we've already taken care of 32bit colortypes above.
     if (srcInfo.colorType() == dstInfo.colorType()) {
         switch (srcInfo.colorType()) {
             case kRGB_565_SkColorType:
             case kAlpha_8_SkColorType:
+            case kGray_8_SkColorType:
                 break;
             case kIndex_8_SkColorType:
             case kARGB_4444_SkColorType:
                 if (srcInfo.alphaType() != dstInfo.alphaType()) {
                     return false;
                 }
                 break;
             default:
                 return false;
         }
         rect_memcpy(dstPixels, dstRB, srcPixels, srcRB, width * srcInfo.bytesPerPixel(), height);
         return true;
     }
 
     /*
      *  Begin section where we try to change colorTypes along the way. Not all combinations
      *  are supported.
      */
 
+    if (kGray_8_SkColorType == srcInfo.colorType() && 4 == dstInfo.bytesPerPixel()) {
+        copy_g8_to_32(dstPixels, dstRB, srcPixels, srcRB, width, height);
+        return true;
+    }
+    if (kGray_8_SkColorType == dstInfo.colorType() && 4 == srcInfo.bytesPerPixel()) {
+        copy_32_to_g8(dstPixels, dstRB, srcPixels, srcRB, srcInfo);
+        return true;
+    }
+
     // Can no longer draw directly into 4444, but we can manually whack it for a few combinations
     if (kARGB_4444_SkColorType == dstInfo.colorType() &&
         (kN32_SkColorType == srcInfo.colorType() || kIndex_8_SkColorType == srcInfo.colorType())) {
         if (srcInfo.alphaType() == kUnpremul_SkAlphaType) {
             // Our method for converting to 4444 assumes premultiplied.
             return false;
         }
 
         const SkPMColor* table = NULL;
         if (kIndex_8_SkColorType == srcInfo.colorType()) {
@@ skipping 44 matching lines @@
 
         SkPaint  paint;
         paint.setDither(true);
 
         canvas->clear(0);
         canvas->drawBitmap(bm, 0, 0, &paint);
         return true;
     }
 }