remove unused kLCD_MaskFormat

src/core/SkScalerContext.cpp

 
 /*
  * Copyright 2006 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 "SkScalerContext.h"
@@ skipping 163 matching lines @@
                 goto SK_ERROR;
             }
             glyph->fLeft    = ir.fLeft;
             glyph->fTop     = ir.fTop;
             glyph->fWidth   = SkToU16(ir.width());
             glyph->fHeight  = SkToU16(ir.height());
 
             if (glyph->fWidth > 0) {
                 switch (fRec.fMaskFormat) {
                 case SkMask::kLCD16_Format:
-                case SkMask::kLCD32_Format:
                     glyph->fWidth += 2;
                     glyph->fLeft -= 1;
                     break;
                 default:
                     break;
                 }
             }
         }
     }
 
@@ skipping 123 matching lines @@
             U8CPU b = sk_apply_lut_if<APPLY_PREBLEND>(fir[2], maskPreBlend.fB);
 #if SK_SHOW_TEXT_BLIT_COVERAGE
             r = SkMax32(r, 10); g = SkMax32(g, 10); b = SkMax32(b, 10);
 #endif
             dstP[pixel_x] = SkPack888ToRGB16(r, g, b);
         }
         dstP = (uint16_t*)((char*)dstP + dstRB);
     }
 }
 
-template<bool APPLY_PREBLEND>
-static void pack4xHToLCD32(const SkBitmap& src, const SkMask& dst,
-                           const SkMaskGamma::PreBlend& maskPreBlend) {
-    SkASSERT(kAlpha_8_SkColorType == src.colorType());
-    SkASSERT(SkMask::kLCD32_Format == dst.fFormat);
-
-    const int width = dst.fBounds.width();
-    const int height = dst.fBounds.height();
-    SkPMColor* dstP = (SkPMColor*)dst.fImage;
-    size_t dstRB = dst.fRowBytes;
-
-    for (int y = 0; y < height; ++y) {
-        const uint8_t* srcP = src.getAddr8(0, y);
-
-        // TODO: need to use fir filter here as well.
-        for (int x = 0; x < width; ++x) {
-            U8CPU r = sk_apply_lut_if<APPLY_PREBLEND>(*srcP++, maskPreBlend.fR);
-            U8CPU g = sk_apply_lut_if<APPLY_PREBLEND>(*srcP++, maskPreBlend.fG);
-            U8CPU b = sk_apply_lut_if<APPLY_PREBLEND>(*srcP++, maskPreBlend.fB);
-            dstP[x] = SkPackARGB32(0xFF, r, g, b);
-        }
-        dstP = (SkPMColor*)((char*)dstP + dstRB);
-    }
-}
-
 static inline int convert_8_to_1(unsigned byte) {
     SkASSERT(byte <= 0xFF);
     return byte >> 7;
 }
 
 static uint8_t pack_8_to_1(const uint8_t alpha[8]) {
     unsigned bits = 0;
     for (int i = 0; i < 8; ++i) {
         bits <<= 1;
         bits |= convert_8_to_1(alpha[i]);
@@ skipping 48 matching lines @@
                         -SkIntToScalar(mask.fBounds.fTop));
 
     paint.setAntiAlias(SkMask::kBW_Format != mask.fFormat);
     switch (mask.fFormat) {
         case SkMask::kBW_Format:
             dstRB = 0;  // signals we need a copy
             break;
         case SkMask::kA8_Format:
             break;
         case SkMask::kLCD16_Format:
-        case SkMask::kLCD32_Format:
             // TODO: trigger off LCD orientation
             dstW = 4*dstW - 8;
             matrix.setTranslate(-SkIntToScalar(mask.fBounds.fLeft + 1),
                                 -SkIntToScalar(mask.fBounds.fTop));
             matrix.postScale(SkIntToScalar(4), SK_Scalar1);
             dstRB = 0;  // signals we need a copy
             break;
         default:
             SkDEBUGFAIL("unexpected mask format");
     }
@@ skipping 31 matching lines @@
                 applyLUTToA8Mask(mask, maskPreBlend.fG);
             }
             break;
         case SkMask::kLCD16_Format:
             if (maskPreBlend.isApplicable()) {
                 pack4xHToLCD16<true>(bm, mask, maskPreBlend);
             } else {
                 pack4xHToLCD16<false>(bm, mask, maskPreBlend);
             }
             break;
-        case SkMask::kLCD32_Format:
-            if (maskPreBlend.isApplicable()) {
-                pack4xHToLCD32<true>(bm, mask, maskPreBlend);
-            } else {
-                pack4xHToLCD32<false>(bm, mask, maskPreBlend);
-            }
-            break;
         default:
             break;
     }
 }
 
 static void extract_alpha(const SkMask& dst,
                           const SkPMColor* srcRow, size_t srcRB) {
     int width = dst.fBounds.width();
     int height = dst.fBounds.height();
     int dstRB = dst.fRowBytes;
@@ skipping 302 matching lines @@
 SkScalerContext* SkTypeface::createScalerContext(const SkDescriptor* desc,
                                                  bool allowFailure) const {
     SkScalerContext* c = this->onCreateScalerContext(desc);
 
     if (!c && !allowFailure) {
         c = SkNEW_ARGS(SkScalerContext_Empty,
                        (const_cast<SkTypeface*>(this), desc));
     }
     return c;
 }