1 /* 2 * Copyright (C) 2012 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #define LOG_TAG "OpenGLRenderer" 18 #define ATRACE_TAG ATRACE_TAG_VIEW 19 20 #include <cutils/compiler.h> 21 22 #include <utils/JenkinsHash.h> 23 #include <utils/Trace.h> 24 25 #include <SkGlyph.h> 26 #include <SkGlyphCache.h> 27 #include <SkUtils.h> 28 29 #include "FontUtil.h" 30 #include "Font.h" 31 #include "../Debug.h" 32 #include "../FontRenderer.h" 33 #include "../PixelBuffer.h" 34 #include "../Properties.h" 35 36 namespace android { 37 namespace uirenderer { 38 39 /////////////////////////////////////////////////////////////////////////////// 40 // Font 41 /////////////////////////////////////////////////////////////////////////////// 42 43 Font::Font(FontRenderer* state, const Font::FontDescription& desc) : 44 mState(state), mDescription(desc) { 45 mDeviceProperties = SkDeviceProperties::Make(SkDeviceProperties::Geometry::MakeDefault(), 1.0f); 46 } 47 48 Font::FontDescription::FontDescription(const SkPaint* paint, const SkMatrix& rasterMatrix) 49 : mLookupTransform(rasterMatrix) { 50 mFontId = SkTypeface::UniqueID(paint->getTypeface()); 51 mFontSize = paint->getTextSize(); 52 mFlags = 0; 53 if (paint->isFakeBoldText()) { 54 mFlags |= Font::kFakeBold; 55 } 56 mItalicStyle = paint->getTextSkewX(); 57 mScaleX = paint->getTextScaleX(); 58 mStyle = paint->getStyle(); 59 mStrokeWidth = paint->getStrokeWidth(); 60 mAntiAliasing = paint->isAntiAlias(); 61 mHinting = paint->getHinting(); 62 if (!mLookupTransform.invert(&mInverseLookupTransform)) { 63 ALOGW("Could not query the inverse lookup transform for this font"); 64 } 65 } 66 67 Font::~Font() { 68 mState->removeFont(this); 69 70 for (uint32_t i = 0; i < mCachedGlyphs.size(); i++) { 71 delete mCachedGlyphs.valueAt(i); 72 } 73 } 74 75 hash_t Font::FontDescription::hash() const { 76 uint32_t hash = JenkinsHashMix(0, mFontId); 77 hash = JenkinsHashMix(hash, android::hash_type(mFontSize)); 78 hash = JenkinsHashMix(hash, android::hash_type(mFlags)); 79 hash = JenkinsHashMix(hash, android::hash_type(mItalicStyle)); 80 hash = JenkinsHashMix(hash, android::hash_type(mScaleX)); 81 hash = JenkinsHashMix(hash, android::hash_type(mStyle)); 82 hash = JenkinsHashMix(hash, android::hash_type(mStrokeWidth)); 83 hash = JenkinsHashMix(hash, int(mAntiAliasing)); 84 hash = JenkinsHashMix(hash, android::hash_type(mHinting)); 85 hash = JenkinsHashMix(hash, android::hash_type(mLookupTransform[SkMatrix::kMScaleX])); 86 hash = JenkinsHashMix(hash, android::hash_type(mLookupTransform[SkMatrix::kMScaleY])); 87 return JenkinsHashWhiten(hash); 88 } 89 90 int Font::FontDescription::compare(const Font::FontDescription& lhs, 91 const Font::FontDescription& rhs) { 92 int deltaInt = int(lhs.mFontId) - int(rhs.mFontId); 93 if (deltaInt != 0) return deltaInt; 94 95 if (lhs.mFontSize < rhs.mFontSize) return -1; 96 if (lhs.mFontSize > rhs.mFontSize) return +1; 97 98 if (lhs.mItalicStyle < rhs.mItalicStyle) return -1; 99 if (lhs.mItalicStyle > rhs.mItalicStyle) return +1; 100 101 deltaInt = int(lhs.mFlags) - int(rhs.mFlags); 102 if (deltaInt != 0) return deltaInt; 103 104 if (lhs.mScaleX < rhs.mScaleX) return -1; 105 if (lhs.mScaleX > rhs.mScaleX) return +1; 106 107 deltaInt = int(lhs.mStyle) - int(rhs.mStyle); 108 if (deltaInt != 0) return deltaInt; 109 110 if (lhs.mStrokeWidth < rhs.mStrokeWidth) return -1; 111 if (lhs.mStrokeWidth > rhs.mStrokeWidth) return +1; 112 113 deltaInt = int(lhs.mAntiAliasing) - int(rhs.mAntiAliasing); 114 if (deltaInt != 0) return deltaInt; 115 116 deltaInt = int(lhs.mHinting) - int(rhs.mHinting); 117 if (deltaInt != 0) return deltaInt; 118 119 if (lhs.mLookupTransform[SkMatrix::kMScaleX] < 120 rhs.mLookupTransform[SkMatrix::kMScaleX]) return -1; 121 if (lhs.mLookupTransform[SkMatrix::kMScaleX] > 122 rhs.mLookupTransform[SkMatrix::kMScaleX]) return +1; 123 124 if (lhs.mLookupTransform[SkMatrix::kMScaleY] < 125 rhs.mLookupTransform[SkMatrix::kMScaleY]) return -1; 126 if (lhs.mLookupTransform[SkMatrix::kMScaleY] > 127 rhs.mLookupTransform[SkMatrix::kMScaleY]) return +1; 128 129 return 0; 130 } 131 132 void Font::invalidateTextureCache(CacheTexture* cacheTexture) { 133 for (uint32_t i = 0; i < mCachedGlyphs.size(); i++) { 134 CachedGlyphInfo* cachedGlyph = mCachedGlyphs.valueAt(i); 135 if (!cacheTexture || cachedGlyph->mCacheTexture == cacheTexture) { 136 cachedGlyph->mIsValid = false; 137 } 138 } 139 } 140 141 void Font::measureCachedGlyph(CachedGlyphInfo *glyph, int x, int y, 142 uint8_t* bitmap, uint32_t bitmapW, uint32_t bitmapH, Rect* bounds, const float* pos) { 143 int width = (int) glyph->mBitmapWidth; 144 int height = (int) glyph->mBitmapHeight; 145 146 int nPenX = x + glyph->mBitmapLeft; 147 int nPenY = y + glyph->mBitmapTop; 148 149 if (bounds->bottom > nPenY) { 150 bounds->bottom = nPenY; 151 } 152 if (bounds->left > nPenX) { 153 bounds->left = nPenX; 154 } 155 if (bounds->right < nPenX + width) { 156 bounds->right = nPenX + width; 157 } 158 if (bounds->top < nPenY + height) { 159 bounds->top = nPenY + height; 160 } 161 } 162 163 void Font::drawCachedGlyph(CachedGlyphInfo* glyph, int x, int y, 164 uint8_t* bitmap, uint32_t bitmapW, uint32_t bitmapH, Rect* bounds, const float* pos) { 165 float width = (float) glyph->mBitmapWidth; 166 float height = (float) glyph->mBitmapHeight; 167 168 float nPenX = x + glyph->mBitmapLeft; 169 float nPenY = y + glyph->mBitmapTop + height; 170 171 float u1 = glyph->mBitmapMinU; 172 float u2 = glyph->mBitmapMaxU; 173 float v1 = glyph->mBitmapMinV; 174 float v2 = glyph->mBitmapMaxV; 175 176 mState->appendMeshQuad(nPenX, nPenY, u1, v2, 177 nPenX + width, nPenY, u2, v2, 178 nPenX + width, nPenY - height, u2, v1, 179 nPenX, nPenY - height, u1, v1, glyph->mCacheTexture); 180 } 181 182 void Font::drawCachedGlyphTransformed(CachedGlyphInfo* glyph, int x, int y, 183 uint8_t* bitmap, uint32_t bitmapW, uint32_t bitmapH, Rect* bounds, const float* pos) { 184 float width = (float) glyph->mBitmapWidth; 185 float height = (float) glyph->mBitmapHeight; 186 187 SkPoint p[4]; 188 p[0].iset(glyph->mBitmapLeft, glyph->mBitmapTop + height); 189 p[1].iset(glyph->mBitmapLeft + width, glyph->mBitmapTop + height); 190 p[2].iset(glyph->mBitmapLeft + width, glyph->mBitmapTop); 191 p[3].iset(glyph->mBitmapLeft, glyph->mBitmapTop); 192 193 mDescription.mInverseLookupTransform.mapPoints(p, 4); 194 195 p[0].offset(x, y); 196 p[1].offset(x, y); 197 p[2].offset(x, y); 198 p[3].offset(x, y); 199 200 float u1 = glyph->mBitmapMinU; 201 float u2 = glyph->mBitmapMaxU; 202 float v1 = glyph->mBitmapMinV; 203 float v2 = glyph->mBitmapMaxV; 204 205 mState->appendRotatedMeshQuad( 206 p[0].x(), p[0].y(), u1, v2, 207 p[1].x(), p[1].y(), u2, v2, 208 p[2].x(), p[2].y(), u2, v1, 209 p[3].x(), p[3].y(), u1, v1, glyph->mCacheTexture); 210 } 211 212 void Font::drawCachedGlyphBitmap(CachedGlyphInfo* glyph, int x, int y, uint8_t* bitmap, 213 uint32_t bitmapWidth, uint32_t bitmapHeight, Rect* bounds, const float* pos) { 214 int dstX = x + glyph->mBitmapLeft; 215 int dstY = y + glyph->mBitmapTop; 216 217 CacheTexture* cacheTexture = glyph->mCacheTexture; 218 PixelBuffer* pixelBuffer = cacheTexture->getPixelBuffer(); 219 220 uint32_t formatSize = PixelBuffer::formatSize(pixelBuffer->getFormat()); 221 uint32_t alpha_channel_offset = PixelBuffer::formatAlphaOffset(pixelBuffer->getFormat()); 222 uint32_t cacheWidth = cacheTexture->getWidth(); 223 uint32_t srcStride = formatSize * cacheWidth; 224 uint32_t startY = glyph->mStartY * srcStride; 225 uint32_t endY = startY + (glyph->mBitmapHeight * srcStride); 226 227 const uint8_t* cacheBuffer = pixelBuffer->map(); 228 229 for (uint32_t cacheY = startY, bitmapY = dstY * bitmapWidth; cacheY < endY; 230 cacheY += srcStride, bitmapY += bitmapWidth) { 231 232 if (formatSize == 1) { 233 memcpy(&bitmap[bitmapY + dstX], &cacheBuffer[cacheY + glyph->mStartX], glyph->mBitmapWidth); 234 } else { 235 for (uint32_t i = 0; i < glyph->mBitmapWidth; ++i) { 236 bitmap[bitmapY + dstX + i] = cacheBuffer[cacheY + (glyph->mStartX + i)*formatSize + alpha_channel_offset]; 237 } 238 } 239 } 240 241 } 242 243 void Font::drawCachedGlyph(CachedGlyphInfo* glyph, float x, float hOffset, float vOffset, 244 SkPathMeasure& measure, SkPoint* position, SkVector* tangent) { 245 const float halfWidth = glyph->mBitmapWidth * 0.5f; 246 const float height = glyph->mBitmapHeight; 247 248 vOffset += glyph->mBitmapTop + height; 249 250 SkPoint destination[4]; 251 bool ok = measure.getPosTan(x + hOffset + glyph->mBitmapLeft + halfWidth, position, tangent); 252 if (!ok) { 253 ALOGW("The path for drawTextOnPath is empty or null"); 254 } 255 256 // Move along the tangent and offset by the normal 257 destination[0].set(-tangent->fX * halfWidth - tangent->fY * vOffset, 258 -tangent->fY * halfWidth + tangent->fX * vOffset); 259 destination[1].set(tangent->fX * halfWidth - tangent->fY * vOffset, 260 tangent->fY * halfWidth + tangent->fX * vOffset); 261 destination[2].set(destination[1].fX + tangent->fY * height, 262 destination[1].fY - tangent->fX * height); 263 destination[3].set(destination[0].fX + tangent->fY * height, 264 destination[0].fY - tangent->fX * height); 265 266 const float u1 = glyph->mBitmapMinU; 267 const float u2 = glyph->mBitmapMaxU; 268 const float v1 = glyph->mBitmapMinV; 269 const float v2 = glyph->mBitmapMaxV; 270 271 mState->appendRotatedMeshQuad( 272 position->x() + destination[0].x(), 273 position->y() + destination[0].y(), u1, v2, 274 position->x() + destination[1].x(), 275 position->y() + destination[1].y(), u2, v2, 276 position->x() + destination[2].x(), 277 position->y() + destination[2].y(), u2, v1, 278 position->x() + destination[3].x(), 279 position->y() + destination[3].y(), u1, v1, 280 glyph->mCacheTexture); 281 } 282 283 CachedGlyphInfo* Font::getCachedGlyph(const SkPaint* paint, glyph_t textUnit, bool precaching) { 284 CachedGlyphInfo* cachedGlyph = mCachedGlyphs.valueFor(textUnit); 285 if (cachedGlyph) { 286 // Is the glyph still in texture cache? 287 if (!cachedGlyph->mIsValid) { 288 SkAutoGlyphCache autoCache(*paint, &mDeviceProperties, &mDescription.mLookupTransform); 289 const SkGlyph& skiaGlyph = GET_METRICS(autoCache.getCache(), textUnit); 290 updateGlyphCache(paint, skiaGlyph, autoCache.getCache(), cachedGlyph, precaching); 291 } 292 } else { 293 cachedGlyph = cacheGlyph(paint, textUnit, precaching); 294 } 295 296 return cachedGlyph; 297 } 298 299 void Font::render(const SkPaint* paint, const char *text, uint32_t start, uint32_t len, 300 int numGlyphs, int x, int y, const float* positions) { 301 render(paint, text, start, len, numGlyphs, x, y, FRAMEBUFFER, NULL, 302 0, 0, NULL, positions); 303 } 304 305 void Font::render(const SkPaint* paint, const char *text, uint32_t start, uint32_t len, 306 int numGlyphs, const SkPath* path, float hOffset, float vOffset) { 307 if (numGlyphs == 0 || text == NULL || len == 0) { 308 return; 309 } 310 311 text += start; 312 313 int glyphsCount = 0; 314 SkFixed prevRsbDelta = 0; 315 316 float penX = 0.0f; 317 318 SkPoint position; 319 SkVector tangent; 320 321 SkPathMeasure measure(*path, false); 322 float pathLength = SkScalarToFloat(measure.getLength()); 323 324 if (paint->getTextAlign() != SkPaint::kLeft_Align) { 325 float textWidth = SkScalarToFloat(paint->measureText(text, len)); 326 float pathOffset = pathLength; 327 if (paint->getTextAlign() == SkPaint::kCenter_Align) { 328 textWidth *= 0.5f; 329 pathOffset *= 0.5f; 330 } 331 penX += pathOffset - textWidth; 332 } 333 334 while (glyphsCount < numGlyphs && penX < pathLength) { 335 glyph_t glyph = GET_GLYPH(text); 336 337 if (IS_END_OF_STRING(glyph)) { 338 break; 339 } 340 341 CachedGlyphInfo* cachedGlyph = getCachedGlyph(paint, glyph); 342 penX += SkFixedToFloat(AUTO_KERN(prevRsbDelta, cachedGlyph->mLsbDelta)); 343 prevRsbDelta = cachedGlyph->mRsbDelta; 344 345 if (cachedGlyph->mIsValid && cachedGlyph->mCacheTexture) { 346 drawCachedGlyph(cachedGlyph, penX, hOffset, vOffset, measure, &position, &tangent); 347 } 348 349 penX += SkFixedToFloat(cachedGlyph->mAdvanceX); 350 351 glyphsCount++; 352 } 353 } 354 355 void Font::measure(const SkPaint* paint, const char* text, uint32_t start, uint32_t len, 356 int numGlyphs, Rect *bounds, const float* positions) { 357 if (bounds == NULL) { 358 ALOGE("No return rectangle provided to measure text"); 359 return; 360 } 361 bounds->set(1e6, -1e6, -1e6, 1e6); 362 render(paint, text, start, len, numGlyphs, 0, 0, MEASURE, NULL, 0, 0, bounds, positions); 363 } 364 365 void Font::precache(const SkPaint* paint, const char* text, int numGlyphs) { 366 ATRACE_NAME("Precache Glyphs"); 367 368 if (numGlyphs == 0 || text == NULL) { 369 return; 370 } 371 372 int glyphsCount = 0; 373 while (glyphsCount < numGlyphs) { 374 glyph_t glyph = GET_GLYPH(text); 375 376 // Reached the end of the string 377 if (IS_END_OF_STRING(glyph)) { 378 break; 379 } 380 381 CachedGlyphInfo* cachedGlyph = getCachedGlyph(paint, glyph, true); 382 glyphsCount++; 383 } 384 } 385 386 void Font::render(const SkPaint* paint, const char* text, uint32_t start, uint32_t len, 387 int numGlyphs, int x, int y, RenderMode mode, uint8_t *bitmap, 388 uint32_t bitmapW, uint32_t bitmapH, Rect* bounds, const float* positions) { 389 if (numGlyphs == 0 || text == NULL || len == 0) { 390 return; 391 } 392 393 static RenderGlyph gRenderGlyph[] = { 394 &android::uirenderer::Font::drawCachedGlyph, 395 &android::uirenderer::Font::drawCachedGlyphTransformed, 396 &android::uirenderer::Font::drawCachedGlyphBitmap, 397 &android::uirenderer::Font::drawCachedGlyphBitmap, 398 &android::uirenderer::Font::measureCachedGlyph, 399 &android::uirenderer::Font::measureCachedGlyph 400 }; 401 RenderGlyph render = gRenderGlyph[(mode << 1) + !mIdentityTransform]; 402 403 text += start; 404 int glyphsCount = 0; 405 406 const SkPaint::Align align = paint->getTextAlign(); 407 408 while (glyphsCount < numGlyphs) { 409 glyph_t glyph = GET_GLYPH(text); 410 411 // Reached the end of the string 412 if (IS_END_OF_STRING(glyph)) { 413 break; 414 } 415 416 CachedGlyphInfo* cachedGlyph = getCachedGlyph(paint, glyph); 417 418 // If it's still not valid, we couldn't cache it, so we shouldn't 419 // draw garbage; also skip empty glyphs (spaces) 420 if (cachedGlyph->mIsValid && cachedGlyph->mCacheTexture) { 421 int penX = x + (int) roundf(positions[(glyphsCount << 1)]); 422 int penY = y + (int) roundf(positions[(glyphsCount << 1) + 1]); 423 424 (*this.*render)(cachedGlyph, penX, penY, 425 bitmap, bitmapW, bitmapH, bounds, positions); 426 } 427 428 glyphsCount++; 429 } 430 } 431 432 void Font::updateGlyphCache(const SkPaint* paint, const SkGlyph& skiaGlyph, 433 SkGlyphCache* skiaGlyphCache, CachedGlyphInfo* glyph, bool precaching) { 434 glyph->mAdvanceX = skiaGlyph.fAdvanceX; 435 glyph->mAdvanceY = skiaGlyph.fAdvanceY; 436 glyph->mBitmapLeft = skiaGlyph.fLeft; 437 glyph->mBitmapTop = skiaGlyph.fTop; 438 glyph->mLsbDelta = skiaGlyph.fLsbDelta; 439 glyph->mRsbDelta = skiaGlyph.fRsbDelta; 440 441 uint32_t startX = 0; 442 uint32_t startY = 0; 443 444 // Get the bitmap for the glyph 445 if (!skiaGlyph.fImage) { 446 skiaGlyphCache->findImage(skiaGlyph); 447 } 448 mState->cacheBitmap(skiaGlyph, glyph, &startX, &startY, precaching); 449 450 if (!glyph->mIsValid) { 451 return; 452 } 453 454 uint32_t endX = startX + skiaGlyph.fWidth; 455 uint32_t endY = startY + skiaGlyph.fHeight; 456 457 glyph->mStartX = startX; 458 glyph->mStartY = startY; 459 glyph->mBitmapWidth = skiaGlyph.fWidth; 460 glyph->mBitmapHeight = skiaGlyph.fHeight; 461 462 bool empty = skiaGlyph.fWidth == 0 || skiaGlyph.fHeight == 0; 463 if (!empty) { 464 uint32_t cacheWidth = glyph->mCacheTexture->getWidth(); 465 uint32_t cacheHeight = glyph->mCacheTexture->getHeight(); 466 467 glyph->mBitmapMinU = startX / (float) cacheWidth; 468 glyph->mBitmapMinV = startY / (float) cacheHeight; 469 glyph->mBitmapMaxU = endX / (float) cacheWidth; 470 glyph->mBitmapMaxV = endY / (float) cacheHeight; 471 472 mState->setTextureDirty(); 473 } 474 } 475 476 CachedGlyphInfo* Font::cacheGlyph(const SkPaint* paint, glyph_t glyph, bool precaching) { 477 CachedGlyphInfo* newGlyph = new CachedGlyphInfo(); 478 mCachedGlyphs.add(glyph, newGlyph); 479 480 SkAutoGlyphCache autoCache(*paint, &mDeviceProperties, &mDescription.mLookupTransform); 481 const SkGlyph& skiaGlyph = GET_METRICS(autoCache.getCache(), glyph); 482 newGlyph->mIsValid = false; 483 newGlyph->mGlyphIndex = skiaGlyph.fID; 484 485 updateGlyphCache(paint, skiaGlyph, autoCache.getCache(), newGlyph, precaching); 486 487 return newGlyph; 488 } 489 490 Font* Font::create(FontRenderer* state, const SkPaint* paint, const SkMatrix& matrix) { 491 FontDescription description(paint, matrix); 492 Font* font = state->mActiveFonts.get(description); 493 494 if (!font) { 495 font = new Font(state, description); 496 state->mActiveFonts.put(description, font); 497 } 498 font->mIdentityTransform = matrix.isIdentity(); 499 500 return font; 501 } 502 503 }; // namespace uirenderer 504 }; // namespace android 505
