add kGray_8_SkColorType

src/pdf/SkPDFImage.cpp

 /*
  * Copyright 2010 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkPDFImage.h"
 
 #include "SkBitmap.h"
@@ skipping 13 matching lines @@
                                     const SkIRect& srcRect) {
     switch (bitmap.colorType()) {
         case kIndex_8_SkColorType:
             return srcRect.width() * srcRect.height();
         case kARGB_4444_SkColorType:
             return ((srcRect.width() * 3 + 1) / 2) * srcRect.height();
         case kRGB_565_SkColorType:
             return srcRect.width() * 3 * srcRect.height();
         case kRGBA_8888_SkColorType:
         case kBGRA_8888_SkColorType:
+        case kGray_8_SkColorType:
             return srcRect.width() * 3 * srcRect.height();
         case kAlpha_8_SkColorType:
             return 1;
         default:
             SkASSERT(false);
             return 0;
     }
 }
 
 static SkStream* extract_index8_image(const SkBitmap& bitmap,
@@ skipping 62 matching lines @@
             }
         }
     }
     return stream;
 }
 
 static SkStream* extract_rgb565_image(const SkBitmap& bitmap,
                                       const SkIRect& srcRect) {
     SkStream* stream = SkNEW_ARGS(SkMemoryStream,
                                   (get_uncompressed_size(bitmap,
-                                                     srcRect)));
+                                                         srcRect)));
     uint8_t* dst = (uint8_t*)stream->getMemoryBase();
     for (int y = srcRect.fTop; y < srcRect.fBottom; y++) {
         uint16_t* src = bitmap.getAddr16(0, y);
         for (int x = srcRect.fLeft; x < srcRect.fRight; x++) {
             dst[0] = SkGetPackedR16(src[x]);
             dst[1] = SkGetPackedG16(src[x]);
             dst[2] = SkGetPackedB16(src[x]);
             dst += 3;
         }
     }
     return stream;
 }
 
+static SkStream* extract_gray8_image(const SkBitmap& bitmap, const SkIRect& srcRect) {
+    SkStream* stream = SkNEW_ARGS(SkMemoryStream,
+                                  (get_uncompressed_size(bitmap, srcRect)));
+    uint8_t* dst = (uint8_t*)stream->getMemoryBase();
+    for (int y = srcRect.fTop; y < srcRect.fBottom; y++) {
+        uint8_t* src = bitmap.getAddr8(0, y);
+        for (int x = srcRect.fLeft; x < srcRect.fRight; x++) {
+            dst[0] = dst[1] = dst[2] = src[x];
+            dst += 3;
+        }
+    }
+    return stream;
+}
+
 static uint32_t get_argb8888_neighbor_avg_color(const SkBitmap& bitmap,
                                                 int xOrig,
                                                 int yOrig);
 
 static SkStream* extract_argb8888_data(const SkBitmap& bitmap,
                                        const SkIRect& srcRect,
                                        bool extractAlpha,
                                        bool* isOpaque,
                                        bool* isTransparent) {
     size_t streamSize = extractAlpha ? srcRect.width() * srcRect.height()
@@ skipping 80 matching lines @@
  *                      extractAlpha == true.
  * @return              Unencoded image data, or NULL if either data was not
  *                      available or alpha data was requested but the image was
  *                      entirely transparent or opaque.
  */
 static SkStream* extract_image_data(const SkBitmap& bitmap,
                                     const SkIRect& srcRect,
                                     bool extractAlpha, bool* isTransparent) {
     SkColorType colorType = bitmap.colorType();
     if (extractAlpha && (kIndex_8_SkColorType == colorType ||
-                         kRGB_565_SkColorType == colorType)) {
+                         kRGB_565_SkColorType == colorType ||
+                         kGray_8_SkColorType  == colorType)) {
         if (isTransparent != NULL) {
             *isTransparent = false;
         }
         return NULL;
     }
 
     SkAutoLockPixels lock(bitmap);
     if (NULL == bitmap.getPixels()) {
         return NULL;
     }
@@ skipping 10 matching lines @@
             break;
         case kARGB_4444_SkColorType:
             stream.reset(extract_argb4444_data(bitmap, srcRect, extractAlpha,
                                                &isOpaque, &transparent));
             break;
         case kRGB_565_SkColorType:
             if (!extractAlpha) {
                 stream.reset(extract_rgb565_image(bitmap, srcRect));
             }
             break;
+        case kGray_8_SkColorType:
+            if (!extractAlpha) {
+                stream.reset(extract_gray8_image(bitmap, srcRect));
+            }
+            break;
         case kN32_SkColorType:
             stream.reset(extract_argb8888_data(bitmap, srcRect, extractAlpha,
                                                &isOpaque, &transparent));
             break;
         case kAlpha_8_SkColorType:
             if (!extractAlpha) {
                 stream.reset(create_black_image());
             } else {
                 stream.reset(extract_a8_alpha(bitmap, srcRect,
                                               &isOpaque, &transparent));
@@ skipping 426 matching lines @@
     if (SkIRect::MakeWH(bitmap.width(), bitmap.height()) == subset) {
         SkAutoTUnref<SkData> encodedData(ref_encoded_data(bitmap));
         if (is_jfif_jpeg(encodedData)) {
             return SkNEW_ARGS(PDFJPEGImage,
                               (encodedData, bitmap.width(), bitmap.height()));
         }
     }
 #endif
     return SkPDFImage::CreateImage(bitmap, subset);
 }