The Tor Browser / file comparison

comparison: gfx/skia/trunk/src/core/SkScalerContext.cpp

gfx/skia/trunk/src/core/SkScalerContext.cpp

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

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial