src/core/SkScalerContext.cpp

   1
   2 /*
   3  * Copyright 2006 The Android Open Source Project
   4  *
   5  * Use of this source code is governed by a BSD-style license that can be
   6  * found in the LICENSE file.
   7  */
   8
   9
  10 #include "SkScalerContext.h"
  11 #include "SkColorPriv.h"
  12 #include "SkDescriptor.h"
  13 #include "SkDraw.h"
  14 #include "SkGlyph.h"
  15 #include "SkMaskFilter.h"
  16 #include "SkMaskGamma.h"
  17 #include "SkMatrix22.h"
  18 #include "SkReadBuffer.h"
  19 #include "SkWriteBuffer.h"
  20 #include "SkPathEffect.h"
  21 #include "SkRasterizer.h"
  22 #include "SkRasterClip.h"
  23 #include "SkStroke.h"
  24 #include "SkThread.h"
  25
  26 #define ComputeBWRowBytes(width)        (((unsigned)(width) + 7) >> 3)
  27
  28 void SkGlyph::toMask(SkMask* mask) const {
  29     SkASSERT(mask);
  30
  31     mask->fImage = (uint8_t*)fImage;
  32     mask->fBounds.set(fLeft, fTop, fLeft + fWidth, fTop + fHeight);
  33     mask->fRowBytes = this->rowBytes();
  34     mask->fFormat = static_cast<SkMask::Format>(fMaskFormat);
  35 }
  36
  37 size_t SkGlyph::computeImageSize() const {
  38     const size_t size = this->rowBytes() * fHeight;
  39
  40     switch (fMaskFormat) {
  41         case SkMask::k3D_Format:
  42             return 3 * size;
  43         default:
  44             return size;
  45     }
  46 }
  47
  48 void SkGlyph::zeroMetrics() {
  49     fAdvanceX = 0;
  50     fAdvanceY = 0;
  51     fWidth    = 0;
  52     fHeight   = 0;
  53     fTop      = 0;
  54     fLeft     = 0;
  55     fRsbDelta = 0;
  56     fLsbDelta = 0;
  57 }
  58
  59 ///////////////////////////////////////////////////////////////////////////////
  60
  61 #ifdef SK_DEBUG
  62     #define DUMP_RECx
  63 #endif
  64
  65 static SkFlattenable* load_flattenable(const SkDescriptor* desc, uint32_t tag,
  66                                        SkFlattenable::Type ft) {
  67     SkFlattenable*  obj = NULL;
  68     uint32_t        len;
  69     const void*     data = desc->findEntry(tag, &len);
  70
  71     if (data) {
  72         SkReadBuffer buffer(data, len);
  73         obj = buffer.readFlattenable(ft);
  74         SkASSERT(buffer.offset() == buffer.size());
  75     }
  76     return obj;
  77 }
  78
  79 SkScalerContext::SkScalerContext(SkTypeface* typeface, const SkDescriptor* desc)
  80     : fRec(*static_cast<const Rec*>(desc->findEntry(kRec_SkDescriptorTag, NULL)))
  81
  82     , fTypeface(SkRef(typeface))
  83     , fPathEffect(static_cast<SkPathEffect*>(load_flattenable(desc, kPathEffect_SkDescriptorTag,
  84                                              SkFlattenable::kSkPathEffect_Type)))
  85     , fMaskFilter(static_cast<SkMaskFilter*>(load_flattenable(desc, kMaskFilter_SkDescriptorTag,
  86                                              SkFlattenable::kSkMaskFilter_Type)))
  87     , fRasterizer(static_cast<SkRasterizer*>(load_flattenable(desc, kRasterizer_SkDescriptorTag,
  88                                              SkFlattenable::kSkRasterizer_Type)))
  89       // Initialize based on our settings. Subclasses can also force this.
  90     , fGenerateImageFromPath(fRec.fFrameWidth > 0 || fPathEffect != NULL || fRasterizer != NULL)
  91
  92     , fPreBlend(fMaskFilter ? SkMaskGamma::PreBlend() : SkScalerContext::GetMaskPreBlend(fRec))
  93     , fPreBlendForFilter(fMaskFilter ? SkScalerContext::GetMaskPreBlend(fRec)
  94                                      : SkMaskGamma::PreBlend())
  95 {
  96 #ifdef DUMP_REC
  97     desc->assertChecksum();
  98     SkDebugf("SkScalerContext checksum %x count %d length %d\n",
  99              desc->getChecksum(), desc->getCount(), desc->getLength());
 100     SkDebugf(" textsize %g prescale %g preskew %g post [%g %g %g %g]\n",
 101         rec->fTextSize, rec->fPreScaleX, rec->fPreSkewX, rec->fPost2x2[0][0],
 102         rec->fPost2x2[0][1], rec->fPost2x2[1][0], rec->fPost2x2[1][1]);
 103     SkDebugf("  frame %g miter %g hints %d framefill %d format %d join %d\n",
 104         rec->fFrameWidth, rec->fMiterLimit, rec->fHints, rec->fFrameAndFill,
 105         rec->fMaskFormat, rec->fStrokeJoin);
 106     SkDebugf("  pathEffect %x maskFilter %x\n",
 107              desc->findEntry(kPathEffect_SkDescriptorTag, NULL),
 108         desc->findEntry(kMaskFilter_SkDescriptorTag, NULL));
 109 #endif
 110 }
 111
 112 SkScalerContext::~SkScalerContext() {
 113     SkSafeUnref(fPathEffect);
 114     SkSafeUnref(fMaskFilter);
 115     SkSafeUnref(fRasterizer);
 116 }
 117
 118 void SkScalerContext::getAdvance(SkGlyph* glyph) {
 119     // mark us as just having a valid advance
 120     glyph->fMaskFormat = MASK_FORMAT_JUST_ADVANCE;
 121     // we mark the format before making the call, in case the impl
 122     // internally ends up calling its generateMetrics, which is OK
 123     // albeit slower than strictly necessary
 124     generateAdvance(glyph);
 125 }
 126
 127 void SkScalerContext::getMetrics(SkGlyph* glyph) {
 128     generateMetrics(glyph);
 129
 130     // for now we have separate cache entries for devkerning on and off
 131     // in the future we might share caches, but make our measure/draw
 132     // code make the distinction. Thus we zap the values if the caller
 133     // has not asked for them.
 134     if ((fRec.fFlags & SkScalerContext::kDevKernText_Flag) == 0) {
 135         // no devkern, so zap the fields
 136         glyph->fLsbDelta = glyph->fRsbDelta = 0;
 137     }
 138
 139     // if either dimension is empty, zap the image bounds of the glyph
 140     if (0 == glyph->fWidth || 0 == glyph->fHeight) {
 141         glyph->fWidth   = 0;
 142         glyph->fHeight  = 0;
 143         glyph->fTop     = 0;
 144         glyph->fLeft    = 0;
 145         glyph->fMaskFormat = 0;
 146         return;
 147     }
 148
 149     if (fGenerateImageFromPath) {
 150         SkPath      devPath, fillPath;
 151         SkMatrix    fillToDevMatrix;
 152
 153         this->internalGetPath(*glyph, &fillPath, &devPath, &fillToDevMatrix);
 154
 155         if (fRasterizer) {
 156             SkMask  mask;
 157
 158             if (fRasterizer->rasterize(fillPath, fillToDevMatrix, NULL,
 159                                        fMaskFilter, &mask,
 160                                        SkMask::kJustComputeBounds_CreateMode)) {
 161                 glyph->fLeft    = mask.fBounds.fLeft;
 162                 glyph->fTop     = mask.fBounds.fTop;
 163                 glyph->fWidth   = SkToU16(mask.fBounds.width());
 164                 glyph->fHeight  = SkToU16(mask.fBounds.height());
 165             } else {
 166                 goto SK_ERROR;
 167             }
 168         } else {
 169             // just use devPath
 170             const SkIRect ir = devPath.getBounds().roundOut();
 171
 172             if (ir.isEmpty() || !ir.is16Bit()) {
 173                 goto SK_ERROR;
 174             }
 175             glyph->fLeft    = ir.fLeft;
 176             glyph->fTop     = ir.fTop;
 177             glyph->fWidth   = SkToU16(ir.width());
 178             glyph->fHeight  = SkToU16(ir.height());
 179
 180             if (glyph->fWidth > 0) {
 181                 switch (fRec.fMaskFormat) {
 182                 case SkMask::kLCD16_Format:
 183                     glyph->fWidth += 2;
 184                     glyph->fLeft -= 1;
 185                     break;
 186                 default:
 187                     break;
 188                 }
 189             }
 190         }
 191     }
 192
 193     if (SkMask::kARGB32_Format != glyph->fMaskFormat) {
 194         glyph->fMaskFormat = fRec.fMaskFormat;
 195     }
 196
 197     // If we are going to create the mask, then we cannot keep the color
 198     if ((fGenerateImageFromPath || fMaskFilter) &&
 199             SkMask::kARGB32_Format == glyph->fMaskFormat) {
 200         glyph->fMaskFormat = SkMask::kA8_Format;
 201     }
 202
 203     if (fMaskFilter) {
 204         SkMask      src, dst;
 205         SkMatrix    matrix;
 206
 207         glyph->toMask(&src);
 208         fRec.getMatrixFrom2x2(&matrix);
 209
 210         src.fImage = NULL;  // only want the bounds from the filter
 211         if (fMaskFilter->filterMask(&dst, src, matrix, NULL)) {
 212             if (dst.fBounds.isEmpty() || !dst.fBounds.is16Bit()) {
 213                 goto SK_ERROR;
 214             }
 215             SkASSERT(dst.fImage == NULL);
 216             glyph->fLeft    = dst.fBounds.fLeft;
 217             glyph->fTop     = dst.fBounds.fTop;
 218             glyph->fWidth   = SkToU16(dst.fBounds.width());
 219             glyph->fHeight  = SkToU16(dst.fBounds.height());
 220             glyph->fMaskFormat = dst.fFormat;
 221         }
 222     }
 223     return;
 224
 225 SK_ERROR:
 226     // draw nothing 'cause we failed
 227     glyph->fLeft    = 0;
 228     glyph->fTop     = 0;
 229     glyph->fWidth   = 0;
 230     glyph->fHeight  = 0;
 231     // put a valid value here, in case it was earlier set to
 232     // MASK_FORMAT_JUST_ADVANCE
 233     glyph->fMaskFormat = fRec.fMaskFormat;
 234 }
 235
 236 #define SK_SHOW_TEXT_BLIT_COVERAGE 0
 237
 238 static void applyLUTToA8Mask(const SkMask& mask, const uint8_t* lut) {
 239     uint8_t* SK_RESTRICT dst = (uint8_t*)mask.fImage;
 240     unsigned rowBytes = mask.fRowBytes;
 241
 242     for (int y = mask.fBounds.height() - 1; y >= 0; --y) {
 243         for (int x = mask.fBounds.width() - 1; x >= 0; --x) {
 244             dst[x] = lut[dst[x]];
 245         }
 246         dst += rowBytes;
 247     }
 248 }
 249
 250 template<bool APPLY_PREBLEND>
 251 static void pack4xHToLCD16(const SkBitmap& src, const SkMask& dst,
 252                            const SkMaskGamma::PreBlend& maskPreBlend) {
 253 #define SAMPLES_PER_PIXEL 4
 254 #define LCD_PER_PIXEL 3
 255     SkASSERT(kAlpha_8_SkColorType == src.colorType());
 256     SkASSERT(SkMask::kLCD16_Format == dst.fFormat);
 257
 258     const int sample_width = src.width();
 259     const int height = src.height();
 260
 261     uint16_t* dstP = (uint16_t*)dst.fImage;
 262     size_t dstRB = dst.fRowBytes;
 263     // An N tap FIR is defined by
 264     // out[n] = coeff[0]*x[n] + coeff[1]*x[n-1] + ... + coeff[N]*x[n-N]
 265     // or
 266     // out[n] = sum(i, 0, N, coeff[i]*x[n-i])
 267
 268     // The strategy is to use one FIR (different coefficients) for each of r, g, and b.
 269     // This means using every 4th FIR output value of each FIR and discarding the rest.
 270     // The FIRs are aligned, and the coefficients reach 5 samples to each side of their 'center'.
 271     // (For r and b this is technically incorrect, but the coeffs outside round to zero anyway.)
 272
 273     // These are in some fixed point repesentation.
 274     // Adding up to more than one simulates ink spread.
 275     // For implementation reasons, these should never add up to more than two.
 276
 277     // Coefficients determined by a gausian where 5 samples = 3 std deviations (0x110 'contrast').
 278     // Calculated using tools/generate_fir_coeff.py
 279     // With this one almost no fringing is ever seen, but it is imperceptibly blurry.
 280     // The lcd smoothed text is almost imperceptibly different from gray,
 281     // but is still sharper on small stems and small rounded corners than gray.
 282     // This also seems to be about as wide as one can get and only have a three pixel kernel.
 283     // TODO: caculate these at runtime so parameters can be adjusted (esp contrast).
 284     static const unsigned int coefficients[LCD_PER_PIXEL][SAMPLES_PER_PIXEL*3] = {
 285         //The red subpixel is centered inside the first sample (at 1/6 pixel), and is shifted.
 286         { 0x03, 0x0b, 0x1c, 0x33,  0x40, 0x39, 0x24, 0x10,  0x05, 0x01, 0x00, 0x00, },
 287         //The green subpixel is centered between two samples (at 1/2 pixel), so is symetric
 288         { 0x00, 0x02, 0x08, 0x16,  0x2b, 0x3d, 0x3d, 0x2b,  0x16, 0x08, 0x02, 0x00, },
 289         //The blue subpixel is centered inside the last sample (at 5/6 pixel), and is shifted.
 290         { 0x00, 0x00, 0x01, 0x05,  0x10, 0x24, 0x39, 0x40,  0x33, 0x1c, 0x0b, 0x03, },
 291     };
 292
 293     for (int y = 0; y < height; ++y) {
 294         const uint8_t* srcP = src.getAddr8(0, y);
 295
 296         // TODO: this fir filter implementation is straight forward, but slow.
 297         // It should be possible to make it much faster.
 298         for (int sample_x = -4, pixel_x = 0; sample_x < sample_width + 4; sample_x += 4, ++pixel_x) {
 299             int fir[LCD_PER_PIXEL] = { 0 };
 300             for (int sample_index = SkMax32(0, sample_x - 4), coeff_index = sample_index - (sample_x - 4)
 301                 ; sample_index < SkMin32(sample_x + 8, sample_width)
 302                 ; ++sample_index, ++coeff_index)
 303             {
 304                 int sample_value = srcP[sample_index];
 305                 for (int subpxl_index = 0; subpxl_index < LCD_PER_PIXEL; ++subpxl_index) {
 306                     fir[subpxl_index] += coefficients[subpxl_index][coeff_index] * sample_value;
 307                 }
 308             }
 309             for (int subpxl_index = 0; subpxl_index < LCD_PER_PIXEL; ++subpxl_index) {
 310                 fir[subpxl_index] /= 0x100;
 311                 fir[subpxl_index] = SkMin32(fir[subpxl_index], 255);
 312             }
 313
 314             U8CPU r = sk_apply_lut_if<APPLY_PREBLEND>(fir[0], maskPreBlend.fR);
 315             U8CPU g = sk_apply_lut_if<APPLY_PREBLEND>(fir[1], maskPreBlend.fG);
 316             U8CPU b = sk_apply_lut_if<APPLY_PREBLEND>(fir[2], maskPreBlend.fB);
 317 #if SK_SHOW_TEXT_BLIT_COVERAGE
 318             r = SkMax32(r, 10); g = SkMax32(g, 10); b = SkMax32(b, 10);
 319 #endif
 320             dstP[pixel_x] = SkPack888ToRGB16(r, g, b);
 321         }
 322         dstP = (uint16_t*)((char*)dstP + dstRB);
 323     }
 324 }
 325
 326 static inline int convert_8_to_1(unsigned byte) {
 327     SkASSERT(byte <= 0xFF);
 328     return byte >> 7;
 329 }
 330
 331 static uint8_t pack_8_to_1(const uint8_t alpha[8]) {
 332     unsigned bits = 0;
 333     for (int i = 0; i < 8; ++i) {
 334         bits <<= 1;
 335         bits |= convert_8_to_1(alpha[i]);
 336     }
 337     return SkToU8(bits);
 338 }
 339
 340 static void packA8ToA1(const SkMask& mask, const uint8_t* src, size_t srcRB) {
 341     const int height = mask.fBounds.height();
 342     const int width = mask.fBounds.width();
 343     const int octs = width >> 3;
 344     const int leftOverBits = width & 7;
 345
 346     uint8_t* dst = mask.fImage;
 347     const int dstPad = mask.fRowBytes - SkAlign8(width)/8;
 348     SkASSERT(dstPad >= 0);
 349
 350     SkASSERT(width >= 0);
 351     SkASSERT(srcRB >= (size_t)width);
 352     const size_t srcPad = srcRB - width;
 353
 354     for (int y = 0; y < height; ++y) {
 355         for (int i = 0; i < octs; ++i) {
 356             *dst++ = pack_8_to_1(src);
 357             src += 8;
 358         }
 359         if (leftOverBits > 0) {
 360             unsigned bits = 0;
 361             int shift = 7;
 362             for (int i = 0; i < leftOverBits; ++i, --shift) {
 363                 bits |= convert_8_to_1(*src++) << shift;
 364             }
 365             *dst++ = bits;
 366         }
 367         src += srcPad;
 368         dst += dstPad;
 369     }
 370 }
 371
 372 static void generateMask(const SkMask& mask, const SkPath& path,
 373                          const SkMaskGamma::PreBlend& maskPreBlend) {
 374     SkPaint paint;
 375
 376     int srcW = mask.fBounds.width();
 377     int srcH = mask.fBounds.height();
 378     int dstW = srcW;
 379     int dstH = srcH;
 380     int dstRB = mask.fRowBytes;
 381
 382     SkMatrix matrix;
 383     matrix.setTranslate(-SkIntToScalar(mask.fBounds.fLeft),
 384                         -SkIntToScalar(mask.fBounds.fTop));
 385
 386     paint.setAntiAlias(SkMask::kBW_Format != mask.fFormat);
 387     switch (mask.fFormat) {
 388         case SkMask::kBW_Format:
 389             dstRB = 0;  // signals we need a copy
 390             break;
 391         case SkMask::kA8_Format:
 392             break;
 393         case SkMask::kLCD16_Format:
 394             // TODO: trigger off LCD orientation
 395             dstW = 4*dstW - 8;
 396             matrix.setTranslate(-SkIntToScalar(mask.fBounds.fLeft + 1),
 397                                 -SkIntToScalar(mask.fBounds.fTop));
 398             matrix.postScale(SkIntToScalar(4), SK_Scalar1);
 399             dstRB = 0;  // signals we need a copy
 400             break;
 401         default:
 402             SkDEBUGFAIL("unexpected mask format");
 403     }
 404
 405     SkRasterClip clip;
 406     clip.setRect(SkIRect::MakeWH(dstW, dstH));
 407
 408     const SkImageInfo info = SkImageInfo::MakeA8(dstW, dstH);
 409     SkBitmap bm;
 410
 411     if (0 == dstRB) {
 412         if (!bm.tryAllocPixels(info)) {
 413             // can't allocate offscreen, so empty the mask and return
 414             sk_bzero(mask.fImage, mask.computeImageSize());
 415             return;
 416         }
 417     } else {
 418         bm.installPixels(info, mask.fImage, dstRB);
 419     }
 420     sk_bzero(bm.getPixels(), bm.getSafeSize());
 421
 422     SkDraw  draw;
 423     draw.fRC    = &clip;
 424     draw.fClip  = &clip.bwRgn();
 425     draw.fMatrix = &matrix;
 426     draw.fBitmap = &bm;
 427     draw.drawPath(path, paint);
 428
 429     switch (mask.fFormat) {
 430         case SkMask::kBW_Format:
 431             packA8ToA1(mask, bm.getAddr8(0, 0), bm.rowBytes());
 432             break;
 433         case SkMask::kA8_Format:
 434             if (maskPreBlend.isApplicable()) {
 435                 applyLUTToA8Mask(mask, maskPreBlend.fG);
 436             }
 437             break;
 438         case SkMask::kLCD16_Format:
 439             if (maskPreBlend.isApplicable()) {
 440                 pack4xHToLCD16<true>(bm, mask, maskPreBlend);
 441             } else {
 442                 pack4xHToLCD16<false>(bm, mask, maskPreBlend);
 443             }
 444             break;
 445         default:
 446             break;
 447     }
 448 }
 449
 450 static void extract_alpha(const SkMask& dst,
 451                           const SkPMColor* srcRow, size_t srcRB) {
 452     int width = dst.fBounds.width();
 453     int height = dst.fBounds.height();
 454     int dstRB = dst.fRowBytes;
 455     uint8_t* dstRow = dst.fImage;
 456
 457     for (int y = 0; y < height; ++y) {
 458         for (int x = 0; x < width; ++x) {
 459             dstRow[x] = SkGetPackedA32(srcRow[x]);
 460         }
 461         // zero any padding on each row
 462         for (int x = width; x < dstRB; ++x) {
 463             dstRow[x] = 0;
 464         }
 465         dstRow += dstRB;
 466         srcRow = (const SkPMColor*)((const char*)srcRow + srcRB);
 467     }
 468 }
 469
 470 void SkScalerContext::getImage(const SkGlyph& origGlyph) {
 471     const SkGlyph*  glyph = &origGlyph;
 472     SkGlyph         tmpGlyph;
 473
 474     // in case we need to call generateImage on a mask-format that is different
 475     // (i.e. larger) than what our caller allocated by looking at origGlyph.
 476     SkAutoMalloc tmpGlyphImageStorage;
 477
 478     // If we are going to draw-from-path, then we cannot generate color, since
 479     // the path only makes a mask. This case should have been caught up in
 480     // generateMetrics().
 481     SkASSERT(!fGenerateImageFromPath ||
 482              SkMask::kARGB32_Format != origGlyph.fMaskFormat);
 483
 484     if (fMaskFilter) {   // restore the prefilter bounds
 485         tmpGlyph.initGlyphIdFrom(origGlyph);
 486
 487         // need the original bounds, sans our maskfilter
 488         SkMaskFilter* mf = fMaskFilter;
 489         fMaskFilter = NULL;             // temp disable
 490         this->getMetrics(&tmpGlyph);
 491         fMaskFilter = mf;               // restore
 492
 493         // we need the prefilter bounds to be <= filter bounds
 494         SkASSERT(tmpGlyph.fWidth <= origGlyph.fWidth);
 495         SkASSERT(tmpGlyph.fHeight <= origGlyph.fHeight);
 496
 497         if (tmpGlyph.fMaskFormat == origGlyph.fMaskFormat) {
 498             tmpGlyph.fImage = origGlyph.fImage;
 499         } else {
 500             tmpGlyphImageStorage.reset(tmpGlyph.computeImageSize());
 501             tmpGlyph.fImage = tmpGlyphImageStorage.get();
 502         }
 503         glyph = &tmpGlyph;
 504     }
 505
 506     if (fGenerateImageFromPath) {
 507         SkPath      devPath, fillPath;
 508         SkMatrix    fillToDevMatrix;
 509         SkMask      mask;
 510
 511         this->internalGetPath(*glyph, &fillPath, &devPath, &fillToDevMatrix);
 512         glyph->toMask(&mask);
 513
 514         if (fRasterizer) {
 515             mask.fFormat = SkMask::kA8_Format;
 516             sk_bzero(glyph->fImage, mask.computeImageSize());
 517
 518             if (!fRasterizer->rasterize(fillPath, fillToDevMatrix, NULL,
 519                                         fMaskFilter, &mask,
 520                                         SkMask::kJustRenderImage_CreateMode)) {
 521                 return;
 522             }
 523             if (fPreBlend.isApplicable()) {
 524                 applyLUTToA8Mask(mask, fPreBlend.fG);
 525             }
 526         } else {
 527             SkASSERT(SkMask::kARGB32_Format != mask.fFormat);
 528             generateMask(mask, devPath, fPreBlend);
 529         }
 530     } else {
 531         generateImage(*glyph);
 532     }
 533
 534     if (fMaskFilter) {
 535         SkMask      srcM, dstM;
 536         SkMatrix    matrix;
 537
 538         // the src glyph image shouldn't be 3D
 539         SkASSERT(SkMask::k3D_Format != glyph->fMaskFormat);
 540
 541         SkAutoSMalloc<32*32> a8storage;
 542         glyph->toMask(&srcM);
 543         if (SkMask::kARGB32_Format == srcM.fFormat) {
 544             // now we need to extract the alpha-channel from the glyph's image
 545             // and copy it into a temp buffer, and then point srcM at that temp.
 546             srcM.fFormat = SkMask::kA8_Format;
 547             srcM.fRowBytes = SkAlign4(srcM.fBounds.width());
 548             size_t size = srcM.computeImageSize();
 549             a8storage.reset(size);
 550             srcM.fImage = (uint8_t*)a8storage.get();
 551             extract_alpha(srcM,
 552                           (const SkPMColor*)glyph->fImage, glyph->rowBytes());
 553         }
 554
 555         fRec.getMatrixFrom2x2(&matrix);
 556
 557         if (fMaskFilter->filterMask(&dstM, srcM, matrix, NULL)) {
 558             int width = SkFastMin32(origGlyph.fWidth, dstM.fBounds.width());
 559             int height = SkFastMin32(origGlyph.fHeight, dstM.fBounds.height());
 560             int dstRB = origGlyph.rowBytes();
 561             int srcRB = dstM.fRowBytes;
 562
 563             const uint8_t* src = (const uint8_t*)dstM.fImage;
 564             uint8_t* dst = (uint8_t*)origGlyph.fImage;
 565
 566             if (SkMask::k3D_Format == dstM.fFormat) {
 567                 // we have to copy 3 times as much
 568                 height *= 3;
 569             }
 570
 571             // clean out our glyph, since it may be larger than dstM
 572             //sk_bzero(dst, height * dstRB);
 573
 574             while (--height >= 0) {
 575                 memcpy(dst, src, width);
 576                 src += srcRB;
 577                 dst += dstRB;
 578             }
 579             SkMask::FreeImage(dstM.fImage);
 580
 581             if (fPreBlendForFilter.isApplicable()) {
 582                 applyLUTToA8Mask(srcM, fPreBlendForFilter.fG);
 583             }
 584         }
 585     }
 586 }
 587
 588 void SkScalerContext::getPath(const SkGlyph& glyph, SkPath* path) {
 589     this->internalGetPath(glyph, NULL, path, NULL);
 590 }
 591
 592 void SkScalerContext::getFontMetrics(SkPaint::FontMetrics* fm) {
 593     this->generateFontMetrics(fm);
 594 }
 595
 596 SkUnichar SkScalerContext::generateGlyphToChar(uint16_t glyph) {
 597     return 0;
 598 }
 599
 600 ///////////////////////////////////////////////////////////////////////////////
 601
 602 void SkScalerContext::internalGetPath(const SkGlyph& glyph, SkPath* fillPath,
 603                                   SkPath* devPath, SkMatrix* fillToDevMatrix) {
 604     SkPath  path;
 605     generatePath(glyph, &path);
 606
 607     if (fRec.fFlags & SkScalerContext::kSubpixelPositioning_Flag) {
 608         SkFixed dx = glyph.getSubXFixed();
 609         SkFixed dy = glyph.getSubYFixed();
 610         if (dx | dy) {
 611             path.offset(SkFixedToScalar(dx), SkFixedToScalar(dy));
 612         }
 613     }
 614
 615     if (fRec.fFrameWidth > 0 || fPathEffect != NULL) {
 616         // need the path in user-space, with only the point-size applied
 617         // so that our stroking and effects will operate the same way they
 618         // would if the user had extracted the path themself, and then
 619         // called drawPath
 620         SkPath      localPath;
 621         SkMatrix    matrix, inverse;
 622
 623         fRec.getMatrixFrom2x2(&matrix);
 624         if (!matrix.invert(&inverse)) {
 625             // assume fillPath and devPath are already empty.
 626             return;
 627         }
 628         path.transform(inverse, &localPath);
 629         // now localPath is only affected by the paint settings, and not the canvas matrix
 630
 631         SkStrokeRec rec(SkStrokeRec::kFill_InitStyle);
 632
 633         if (fRec.fFrameWidth > 0) {
 634             rec.setStrokeStyle(fRec.fFrameWidth,
 635                                SkToBool(fRec.fFlags & kFrameAndFill_Flag));
 636             // glyphs are always closed contours, so cap type is ignored,
 637             // so we just pass something.
 638             rec.setStrokeParams(SkPaint::kButt_Cap,
 639                                 (SkPaint::Join)fRec.fStrokeJoin,
 640                                 fRec.fMiterLimit);
 641         }
 642
 643         if (fPathEffect) {
 644             SkPath effectPath;
 645             if (fPathEffect->filterPath(&effectPath, localPath, &rec, NULL)) {
 646                 localPath.swap(effectPath);
 647             }
 648         }
 649
 650         if (rec.needToApply()) {
 651             SkPath strokePath;
 652             if (rec.applyToPath(&strokePath, localPath)) {
 653                 localPath.swap(strokePath);
 654             }
 655         }
 656
 657         // now return stuff to the caller
 658         if (fillToDevMatrix) {
 659             *fillToDevMatrix = matrix;
 660         }
 661         if (devPath) {
 662             localPath.transform(matrix, devPath);
 663         }
 664         if (fillPath) {
 665             fillPath->swap(localPath);
 666         }
 667     } else {   // nothing tricky to do
 668         if (fillToDevMatrix) {
 669             fillToDevMatrix->reset();
 670         }
 671         if (devPath) {
 672             if (fillPath == NULL) {
 673                 devPath->swap(path);
 674             } else {
 675                 *devPath = path;
 676             }
 677         }
 678
 679         if (fillPath) {
 680             fillPath->swap(path);
 681         }
 682     }
 683
 684     if (devPath) {
 685         devPath->updateBoundsCache();
 686     }
 687     if (fillPath) {
 688         fillPath->updateBoundsCache();
 689     }
 690 }
 691
 692
 693 void SkScalerContextRec::getMatrixFrom2x2(SkMatrix* dst) const {
 694     dst->setAll(fPost2x2[0][0], fPost2x2[0][1], 0,
 695                 fPost2x2[1][0], fPost2x2[1][1], 0,
 696                 0,              0,              1);
 697 }
 698
 699 void SkScalerContextRec::getLocalMatrix(SkMatrix* m) const {
 700     SkPaint::SetTextMatrix(m, fTextSize, fPreScaleX, fPreSkewX);
 701 }
 702
 703 void SkScalerContextRec::getSingleMatrix(SkMatrix* m) const {
 704     this->getLocalMatrix(m);
 705
 706     //  now concat the device matrix
 707     SkMatrix    deviceMatrix;
 708     this->getMatrixFrom2x2(&deviceMatrix);
 709     m->postConcat(deviceMatrix);
 710 }
 711
 712 void SkScalerContextRec::computeMatrices(PreMatrixScale preMatrixScale, SkVector* s, SkMatrix* sA,
 713                                          SkMatrix* GsA, SkMatrix* G_inv, SkMatrix* A_out)
 714 {
 715     // A is the 'total' matrix.
 716     SkMatrix A;
 717     this->getSingleMatrix(&A);
 718
 719     // The caller may find the 'total' matrix useful when dealing directly with EM sizes.
 720     if (A_out) {
 721         *A_out = A;
 722     }
 723
 724     // If the 'total' matrix is singular, set the 'scale' to something finite and zero the matrices.
 725     // All underlying ports have issues with zero text size, so use the matricies to zero.
 726
 727     // Map the vectors [1,1] and [1,-1] (the EM) through the 'total' matrix.
 728     // If the length of one of these vectors is less than 1/256 then an EM filling square will
 729     // never affect any pixels.
 730     SkVector diag[2] = { { A.getScaleX() + A.getSkewX(), A.getScaleY() + A.getSkewY() },
 731                          { A.getScaleX() - A.getSkewX(), A.getScaleY() - A.getSkewY() }, };
 732     if (diag[0].lengthSqd() <= SK_ScalarNearlyZero * SK_ScalarNearlyZero ||
 733         diag[1].lengthSqd() <= SK_ScalarNearlyZero * SK_ScalarNearlyZero)
 734     {
 735         s->fX = SK_Scalar1;
 736         s->fY = SK_Scalar1;
 737         sA->setScale(0, 0);
 738         if (GsA) {
 739             GsA->setScale(0, 0);
 740         }
 741         if (G_inv) {
 742             G_inv->reset();
 743         }
 744         return;
 745     }
 746
 747     // GA is the matrix A with rotation removed.
 748     SkMatrix GA;
 749     bool skewedOrFlipped = A.getSkewX() || A.getSkewY() || A.getScaleX() < 0 || A.getScaleY() < 0;
 750     if (skewedOrFlipped) {
 751         // h is where A maps the horizontal baseline.
 752         SkPoint h = SkPoint::Make(SK_Scalar1, 0);
 753         A.mapPoints(&h, 1);
 754
 755         // G is the Givens Matrix for A (rotational matrix where GA[0][1] == 0).
 756         SkMatrix G;
 757         SkComputeGivensRotation(h, &G);
 758
 759         GA = G;
 760         GA.preConcat(A);
 761
 762         // The 'remainingRotation' is G inverse, which is fairly simple since G is 2x2 rotational.
 763         if (G_inv) {
 764             G_inv->setAll(
 765                 G.get(SkMatrix::kMScaleX), -G.get(SkMatrix::kMSkewX), G.get(SkMatrix::kMTransX),
 766                 -G.get(SkMatrix::kMSkewY), G.get(SkMatrix::kMScaleY), G.get(SkMatrix::kMTransY),
 767                 G.get(SkMatrix::kMPersp0), G.get(SkMatrix::kMPersp1), G.get(SkMatrix::kMPersp2));
 768         }
 769     } else {
 770         GA = A;
 771         if (G_inv) {
 772             G_inv->reset();
 773         }
 774     }
 775
 776     // At this point, given GA, create s.
 777     switch (preMatrixScale) {
 778         case kFull_PreMatrixScale:
 779             s->fX = SkScalarAbs(GA.get(SkMatrix::kMScaleX));
 780             s->fY = SkScalarAbs(GA.get(SkMatrix::kMScaleY));
 781             break;
 782         case kVertical_PreMatrixScale: {
 783             SkScalar yScale = SkScalarAbs(GA.get(SkMatrix::kMScaleY));
 784             s->fX = yScale;
 785             s->fY = yScale;
 786             break;
 787         }
 788         case kVerticalInteger_PreMatrixScale: {
 789             SkScalar realYScale = SkScalarAbs(GA.get(SkMatrix::kMScaleY));
 790             SkScalar intYScale = SkScalarRoundToScalar(realYScale);
 791             if (intYScale == 0) {
 792                 intYScale = SK_Scalar1;
 793             }
 794             s->fX = intYScale;
 795             s->fY = intYScale;
 796             break;
 797         }
 798     }
 799
 800     // The 'remaining' matrix sA is the total matrix A without the scale.
 801     if (!skewedOrFlipped && (
 802             (kFull_PreMatrixScale == preMatrixScale) ||
 803             (kVertical_PreMatrixScale == preMatrixScale && A.getScaleX() == A.getScaleY())))
 804     {
 805         // If GA == A and kFull_PreMatrixScale, sA is identity.
 806         // If GA == A and kVertical_PreMatrixScale and A.scaleX == A.scaleY, sA is identity.
 807         sA->reset();
 808     } else if (!skewedOrFlipped && kVertical_PreMatrixScale == preMatrixScale) {
 809         // If GA == A and kVertical_PreMatrixScale, sA.scaleY is SK_Scalar1.
 810         sA->reset();
 811         sA->setScaleX(A.getScaleX() / s->fY);
 812     } else {
 813         // TODO: like kVertical_PreMatrixScale, kVerticalInteger_PreMatrixScale with int scales.
 814         *sA = A;
 815         sA->preScale(SkScalarInvert(s->fX), SkScalarInvert(s->fY));
 816     }
 817
 818     // The 'remainingWithoutRotation' matrix GsA is the non-rotational part of A without the scale.
 819     if (GsA) {
 820         *GsA = GA;
 821          // G is rotational so reorders with the scale.
 822         GsA->preScale(SkScalarInvert(s->fX), SkScalarInvert(s->fY));
 823     }
 824 }
 825
 826 SkAxisAlignment SkComputeAxisAlignmentForHText(const SkMatrix& matrix) {
 827     SkASSERT(!matrix.hasPerspective());
 828
 829     if (0 == matrix[SkMatrix::kMSkewY]) {
 830         return kX_SkAxisAlignment;
 831     }
 832     if (0 == matrix[SkMatrix::kMScaleX]) {
 833         return kY_SkAxisAlignment;
 834     }
 835     return kNone_SkAxisAlignment;
 836 }
 837
 838 ///////////////////////////////////////////////////////////////////////////////
 839
 840 class SkScalerContext_Empty : public SkScalerContext {
 841 public:
 842     SkScalerContext_Empty(SkTypeface* face, const SkDescriptor* desc)
 843         : SkScalerContext(face, desc) {}
 844
 845 protected:
 846     unsigned generateGlyphCount() SK_OVERRIDE {
 847         return 0;
 848     }
 849     uint16_t generateCharToGlyph(SkUnichar uni) SK_OVERRIDE {
 850         return 0;
 851     }
 852     void generateAdvance(SkGlyph* glyph) SK_OVERRIDE {
 853         glyph->zeroMetrics();
 854     }
 855     void generateMetrics(SkGlyph* glyph) SK_OVERRIDE {
 856         glyph->zeroMetrics();
 857     }
 858     void generateImage(const SkGlyph& glyph) SK_OVERRIDE {}
 859     void generatePath(const SkGlyph& glyph, SkPath* path) SK_OVERRIDE {}
 860     void generateFontMetrics(SkPaint::FontMetrics* metrics) SK_OVERRIDE {
 861         if (metrics) {
 862             sk_bzero(metrics, sizeof(*metrics));
 863         }
 864     }
 865 };
 866
 867 extern SkScalerContext* SkCreateColorScalerContext(const SkDescriptor* desc);
 868
 869 SkScalerContext* SkTypeface::createScalerContext(const SkDescriptor* desc,
 870                                                  bool allowFailure) const {
 871     SkScalerContext* c = this->onCreateScalerContext(desc);
 872
 873     if (!c && !allowFailure) {
 874         c = SkNEW_ARGS(SkScalerContext_Empty,
 875                        (const_cast<SkTypeface*>(this), desc));
 876     }
 877     return c;
 878 }