Rotate emoji with FreeType.

src/ports/SkFontHost_FreeType_common.cpp

 /*
  * Copyright 2006-2012 The Android Open Source Project
  * Copyright 2012 Mozilla Foundation
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmap.h"
 #include "SkCanvas.h"
@@ skipping 159 matching lines @@
  *  FT_PIXEL_MODE_GRAY     N   Y  NR     N       Y
  *  FT_PIXEL_MODE_GRAY2   NP  NP  NR    NP      NP
  *  FT_PIXEL_MODE_GRAY4   NP  NP  NR    NP      NP
  *  FT_PIXEL_MODE_LCD     NP  NP  NR    NP      NP
  *  FT_PIXEL_MODE_LCD_V   NP  NP  NR    NP      NP
  *  FT_PIXEL_MODE_BGRA     N   N  NR     Y       N
  *
  *  TODO: All of these N need to be Y or otherwise ruled out.
  */
 static void copyFTBitmap(const FT_Bitmap& srcFTBitmap, SkMask& dstMask) {
-    SkASSERT(dstMask.fBounds.width() == static_cast<int>(srcFTBitmap.width));
-    SkASSERT(dstMask.fBounds.height() == static_cast<int>(srcFTBitmap.rows));
+    SkASSERTF(dstMask.fBounds.width() == static_cast<int>(srcFTBitmap.width),
+              "dstMask.fBounds.width() = %d\n"
+              "static_cast<int>(srcFTBitmap.width) = %d",
+              dstMask.fBounds.width(),
+              static_cast<int>(srcFTBitmap.width)
+    );
+    SkASSERTF(dstMask.fBounds.height() == static_cast<int>(srcFTBitmap.rows),
+              "dstMask.fBounds.height() = %d\n"
+              "static_cast<int>(srcFTBitmap.rows) = %d",
+              dstMask.fBounds.height(),
+              static_cast<int>(srcFTBitmap.rows)
+    );
 
     const uint8_t* src = reinterpret_cast<const uint8_t*>(srcFTBitmap.buffer);
     const FT_Pixel_Mode srcFormat = static_cast<FT_Pixel_Mode>(srcFTBitmap.pixel_mode);
     // FT_Bitmap::pitch is an int and allowed to be negative.
     const int srcPitch = srcFTBitmap.pitch;
     const size_t srcRowBytes = SkTAbs(srcPitch);
 
     uint8_t* dst = dstMask.fImage;
     const SkMask::Format dstFormat = static_cast<SkMask::Format>(dstMask.fFormat);
     const size_t dstRowBytes = dstMask.fRowBytes;
@@ skipping 135 matching lines @@
         case SkMask::kLCD16_Format:
             return kAlpha_8_SkColorType;
         case SkMask::kARGB32_Format:
             return kN32_SkColorType;
         default:
             SkDEBUGFAIL("unsupported destination SkBitmap::Config");
             return kAlpha_8_SkColorType;
     }
 }
 
-void SkScalerContext_FreeType_Base::generateGlyphImage(FT_Face face, const SkGlyph& glyph) {
+void SkScalerContext_FreeType_Base::generateGlyphImage(
+    FT_Face face,
+    const SkGlyph& glyph,
+    const SkMatrix& bitmapTransform)
+{
     const bool doBGR = SkToBool(fRec.fFlags & SkScalerContext::kLCD_BGROrder_Flag);
     const bool doVert = SkToBool(fRec.fFlags & SkScalerContext::kLCD_Vertical_Flag);
 
     switch ( face->glyph->format ) {
         case FT_GLYPH_FORMAT_OUTLINE: {
             FT_Outline* outline = &face->glyph->outline;
             FT_BBox     bbox;
             FT_Bitmap   target;
 
             int dx = 0, dy = 0;
@@ skipping 47 matching lines @@
             SkASSERT(FT_PIXEL_MODE_MONO == pixel_mode ||
                      FT_PIXEL_MODE_GRAY == pixel_mode ||
                      FT_PIXEL_MODE_BGRA == pixel_mode);
 
             // These are the only formats this ScalerContext should request.
             SkASSERT(SkMask::kBW_Format == maskFormat ||
                      SkMask::kA8_Format == maskFormat ||
                      SkMask::kARGB32_Format == maskFormat ||
                      SkMask::kLCD16_Format == maskFormat);
 
-            if (fRec.fFlags & SkScalerContext::kEmbolden_Flag &&
-                !(face->style_flags & FT_STYLE_FLAG_BOLD))
-            {
-                FT_GlyphSlot_Own_Bitmap(face->glyph);
-                FT_Bitmap_Embolden(face->glyph->library, &face->glyph->bitmap,
-                                   kBitmapEmboldenStrength, 0);
-            }
-
             // If no scaling needed, directly copy glyph bitmap.
-            if (glyph.fWidth == face->glyph->bitmap.width &&
-                glyph.fHeight == face->glyph->bitmap.rows &&
-                glyph.fTop == -face->glyph->bitmap_top &&
-                glyph.fLeft == face->glyph->bitmap_left)
-            {
+            if (bitmapTransform.isIdentity()) {
                 SkMask dstMask;
                 glyph.toMask(&dstMask);
                 copyFTBitmap(face->glyph->bitmap, dstMask);
                 break;
             }
 
             // Otherwise, scale the bitmap.
 
             // Copy the FT_Bitmap into an SkBitmap (either A8 or ARGB)
             SkBitmap unscaledBitmap;
+            // TODO: mark this as sRGB when the blits will be sRGB.
             unscaledBitmap.allocPixels(SkImageInfo::Make(face->glyph->bitmap.width,
                                                          face->glyph->bitmap.rows,
                                                          SkColorType_for_FTPixelMode(pixel_mode),
                                                          kPremul_SkAlphaType));
 
             SkMask unscaledBitmapAlias;
             unscaledBitmapAlias.fImage = reinterpret_cast<uint8_t*>(unscaledBitmap.getPixels());
             unscaledBitmapAlias.fBounds.set(0, 0, unscaledBitmap.width(), unscaledBitmap.height());
             unscaledBitmapAlias.fRowBytes = unscaledBitmap.rowBytes();
             unscaledBitmapAlias.fFormat = SkMaskFormat_for_SkColorType(unscaledBitmap.colorType());
             copyFTBitmap(face->glyph->bitmap, unscaledBitmapAlias);
 
             // Wrap the glyph's mask in a bitmap, unless the glyph's mask is BW or LCD.
             // BW requires an A8 target for resizing, which can then be down sampled.
             // LCD should use a 4x A8 target, which will then be down sampled.
             // For simplicity, LCD uses A8 and is replicated.
             int bitmapRowBytes = 0;
             if (SkMask::kBW_Format != maskFormat && SkMask::kLCD16_Format != maskFormat) {
                 bitmapRowBytes = glyph.rowBytes();
             }
             SkBitmap dstBitmap;
+            // TODO: mark this as sRGB when the blits will be sRGB.
             dstBitmap.setInfo(SkImageInfo::Make(glyph.fWidth, glyph.fHeight,
                                                 SkColorType_for_SkMaskFormat(maskFormat),
                                                 kPremul_SkAlphaType),
                               bitmapRowBytes);
             if (SkMask::kBW_Format == maskFormat || SkMask::kLCD16_Format == maskFormat) {
                 dstBitmap.allocPixels();
             } else {
                 dstBitmap.setPixels(glyph.fImage);
             }
 
             // Scale unscaledBitmap into dstBitmap.
             SkCanvas canvas(dstBitmap);
+#ifdef SK_SHOW_TEXT_BLIT_COVERAGE
+            canvas.clear(0x33FF0000);
+#else
             canvas.clear(SK_ColorTRANSPARENT);
-            canvas.scale(SkIntToScalar(glyph.fWidth) / SkIntToScalar(face->glyph->bitmap.width),
-                         SkIntToScalar(glyph.fHeight) / SkIntToScalar(face->glyph->bitmap.rows));
+#endif
+            canvas.translate(-glyph.fLeft, -glyph.fTop);
+            canvas.concat(bitmapTransform);
+            canvas.translate(face->glyph->bitmap_left, -face->glyph->bitmap_top);
+
             SkPaint paint;
             paint.setFilterQuality(kMedium_SkFilterQuality);
             canvas.drawBitmap(unscaledBitmap, 0, 0, &paint);
 
             // If the destination is BW or LCD, convert from A8.
             if (SkMask::kBW_Format == maskFormat) {
                 // Copy the A8 dstBitmap into the A1 glyph.fImage.
                 SkMask dstMask;
                 glyph.toMask(&dstMask);
                 packA8ToA1(dstMask, dstBitmap.getAddr8(0, 0), dstBitmap.rowBytes());
@@ skipping 81 matching lines @@
 
     FT_Error err = FT_Outline_Decompose(&face->glyph->outline, &funcs, path);
 
     if (err != 0) {
         path->reset();
         return;
     }
 
     path->close();
 }