remove kA1_Config, as it is no longer supported

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 18 matching lines @@
                                     const SkIRect& srcRect) {
     switch (bitmap.config()) {
         case SkBitmap::kIndex8_Config:
             return srcRect.width() * srcRect.height();
         case SkBitmap::kARGB_4444_Config:
             return ((srcRect.width() * 3 + 1) / 2) * srcRect.height();
         case SkBitmap::kRGB_565_Config:
             return srcRect.width() * 3 * srcRect.height();
         case SkBitmap::kARGB_8888_Config:
             return srcRect.width() * 3 * srcRect.height();
-        case SkBitmap::kA1_Config:
         case SkBitmap::kA8_Config:
             return 1;
         default:
             SkASSERT(false);
             return 0;
     }
 }
 
 static SkStream* extract_index8_image(const SkBitmap& bitmap,
                                       const SkIRect& srcRect) {
@@ skipping 109 matching lines @@
                 dst[0] = SkGetPackedR32(src[x]);
                 dst[1] = SkGetPackedG32(src[x]);
                 dst[2] = SkGetPackedB32(src[x]);
                 dst += 3;
             }
         }
     }
     return stream;
 }
 
-static SkStream* extract_a1_alpha(const SkBitmap& bitmap,
-                                  const SkIRect& srcRect,
-                                  bool* isOpaque,
-                                  bool* isTransparent) {
-    const int alphaRowBytes = (srcRect.width() + 7) / 8;
-    SkStream* stream = SkNEW_ARGS(SkMemoryStream,
-                                  (alphaRowBytes * srcRect.height()));
-    uint8_t* alphaDst = (uint8_t*)stream->getMemoryBase();
-
-    int offset1 = srcRect.fLeft % 8;
-    int offset2 = 8 - offset1;
-
-    for (int y = srcRect.fTop; y < srcRect.fBottom; y++) {
-        uint8_t* src = bitmap.getAddr1(0, y);
-        // This may read up to one byte after src, but the
-        // potentially invalid bits are never used for computation.
-        for (int x = srcRect.fLeft; x < srcRect.fRight; x += 8)  {
-            if (offset1) {
-                alphaDst[0] = src[x / 8] << offset1 |
-                    src[x / 8 + 1] >> offset2;
-            } else {
-                alphaDst[0] = src[x / 8];
-            }
-            if (x + 7 < srcRect.fRight) {
-                *isOpaque &= alphaDst[0] == SK_AlphaOPAQUE;
-                *isTransparent &= alphaDst[0] == SK_AlphaTRANSPARENT;
-            }
-            alphaDst++;
-        }
-        // Calculate the mask of bits we're interested in within the
-        // last byte of alphaDst.
-        // width mod 8  == 1 -> 0x80 ... width mod 8 == 7 -> 0xFE
-        uint8_t mask = ~((1 << (8 - (srcRect.width() % 8))) - 1);
-        if (srcRect.width() % 8) {
-            *isOpaque &= (alphaDst[-1] & mask) == (SK_AlphaOPAQUE & mask);
-            *isTransparent &=
-                    (alphaDst[-1] & mask) == (SK_AlphaTRANSPARENT & mask);
-        }
-    }
-    return stream;
-}
-
 static SkStream* extract_a8_alpha(const SkBitmap& bitmap,
                                   const SkIRect& srcRect,
                                   bool* isOpaque,
                                   bool* isTransparent) {
     const int alphaRowBytes = srcRect.width();
     SkStream* stream = SkNEW_ARGS(SkMemoryStream,
                                   (alphaRowBytes * srcRect.height()));
     uint8_t* alphaDst = (uint8_t*)stream->getMemoryBase();
 
     for (int y = srcRect.fTop; y < srcRect.fBottom; y++) {
@@ skipping 55 matching lines @@
             break;
         case SkBitmap::kRGB_565_Config:
             if (!extractAlpha) {
                 stream = extract_rgb565_image(bitmap, srcRect);
             }
             break;
         case SkBitmap::kARGB_8888_Config:
             stream = extract_argb8888_data(bitmap, srcRect, extractAlpha,
                                            &isOpaque, &transparent);
             break;
-        case SkBitmap::kA1_Config:
-            if (!extractAlpha) {
-                stream = create_black_image();
-            } else {
-                stream = extract_a1_alpha(bitmap, srcRect,
-                                          &isOpaque, &transparent);
-            }
-            break;
         case SkBitmap::kA8_Config:
             if (!extractAlpha) {
                 stream = create_black_image();
             } else {
                 stream = extract_a8_alpha(bitmap, srcRect,
                                           &isOpaque, &transparent);
             }
             break;
         default:
             SkASSERT(false);
@@ skipping 263 matching lines @@
         fStreamValid = true;
     } else {
         fStreamValid = false;
     }
 
     SkBitmap::Config config = fBitmap.config();
 
     insertName("Type", "XObject");
     insertName("Subtype", "Image");
 
-    bool alphaOnly = (config == SkBitmap::kA1_Config ||
-                      config == SkBitmap::kA8_Config);
+    bool alphaOnly = (config == SkBitmap::kA8_Config);
 
     if (!isAlpha && alphaOnly) {
         // For alpha only images, we stretch a single pixel of black for
         // the color/shape part.
         SkAutoTUnref<SkPDFInt> one(new SkPDFInt(1));
         insert("Width", one.get());
         insert("Height", one.get());
     } else {
         insertInt("Width", fSrcRect.width());
         insertInt("Height", fSrcRect.height());
     }
 
     if (isAlpha || alphaOnly) {
         insertName("ColorSpace", "DeviceGray");
     } else if (config == SkBitmap::kIndex8_Config) {
         SkAutoLockPixels alp(fBitmap);
         insert("ColorSpace",
                make_indexed_color_space(fBitmap.getColorTable()))->unref();
     } else {
         insertName("ColorSpace", "DeviceRGB");
     }
 
     int bitsPerComp = 8;
     if (config == SkBitmap::kARGB_4444_Config) {
         bitsPerComp = 4;
-    } else if (isAlpha && config == SkBitmap::kA1_Config) {
-        bitsPerComp = 1;
     }
     insertInt("BitsPerComponent", bitsPerComp);
 
     if (config == SkBitmap::kRGB_565_Config) {
         SkASSERT(!isAlpha);
         SkAutoTUnref<SkPDFInt> zeroVal(new SkPDFInt(0));
         SkAutoTUnref<SkPDFScalar> scale5Val(
                 new SkPDFScalar(SkFloatToScalar(8.2258f)));  // 255/2^5-1
         SkAutoTUnref<SkPDFScalar> scale6Val(
                 new SkPDFScalar(SkFloatToScalar(4.0476f)));  // 255/2^6-1
@@ skipping 64 matching lines @@
         // but the new catalog wants it compressed.
         if (!getSubstitute()) {
             SkPDFStream* substitute = SkNEW_ARGS(SkPDFImage, (*this));
             setSubstitute(substitute);
             catalog->setSubstitute(this, substitute);
         }
         return false;
     }
     return true;
 }