gfx/2d/ScaledFontBase.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "ScaledFontBase.h"
   8
   9 #ifdef USE_SKIA
  10 #  include "PathSkia.h"
  11 #  include "skia/include/core/SkFont.h"
  12 #endif
  13
  14 #ifdef USE_CAIRO
  15 #  include "PathCairo.h"
  16 #  include "DrawTargetCairo.h"
  17 #  include "HelpersCairo.h"
  18 #endif
  19
  20 #include <vector>
  21 #include <cmath>
  22
  23 namespace mozilla {
  24 namespace gfx {
  25
  26 Atomic<uint32_t> UnscaledFont::sDeletionCounter(0);
  27
  28 UnscaledFont::~UnscaledFont() { sDeletionCounter++; }
  29
  30 Atomic<uint32_t> ScaledFont::sDeletionCounter(0);
  31
  32 ScaledFont::~ScaledFont() { sDeletionCounter++; }
  33
  34 ScaledFontBase::~ScaledFontBase() {
  35 #ifdef USE_SKIA
  36   SkSafeUnref<SkTypeface>(mTypeface);
  37 #endif
  38 #ifdef USE_CAIRO_SCALED_FONT
  39   cairo_scaled_font_destroy(mScaledFont);
  40 #endif
  41 }
  42
  43 ScaledFontBase::ScaledFontBase(const RefPtr<UnscaledFont>& aUnscaledFont,
  44                                Float aSize)
  45     : ScaledFont(aUnscaledFont)
  46 #ifdef USE_SKIA
  47       ,
  48       mTypeface(nullptr)
  49 #endif
  50 #ifdef USE_CAIRO_SCALED_FONT
  51       ,
  52       mScaledFont(nullptr)
  53 #endif
  54       ,
  55       mSize(aSize) {
  56 }
  57
  58 #ifdef USE_SKIA
  59 SkTypeface* ScaledFontBase::GetSkTypeface() {
  60   if (!mTypeface) {
  61     SkTypeface* typeface = CreateSkTypeface();
  62     if (!mTypeface.compareExchange(nullptr, typeface)) {
  63       SkSafeUnref(typeface);
  64     }
  65   }
  66   return mTypeface;
  67 }
  68 #endif
  69
  70 #ifdef USE_CAIRO_SCALED_FONT
  71 cairo_scaled_font_t* ScaledFontBase::GetCairoScaledFont() {
  72   if (mScaledFont) {
  73     return mScaledFont;
  74   }
  75
  76   cairo_font_options_t* fontOptions = cairo_font_options_create();
  77   cairo_font_face_t* fontFace = CreateCairoFontFace(fontOptions);
  78   if (!fontFace) {
  79     cairo_font_options_destroy(fontOptions);
  80     return nullptr;
  81   }
  82
  83   cairo_matrix_t sizeMatrix;
  84   cairo_matrix_t identityMatrix;
  85
  86   cairo_matrix_init_scale(&sizeMatrix, mSize, mSize);
  87   cairo_matrix_init_identity(&identityMatrix);
  88
  89   cairo_scaled_font_t* scaledFont = cairo_scaled_font_create(
  90       fontFace, &sizeMatrix, &identityMatrix, fontOptions);
  91
  92   cairo_font_options_destroy(fontOptions);
  93   cairo_font_face_destroy(fontFace);
  94
  95   if (cairo_scaled_font_status(scaledFont) != CAIRO_STATUS_SUCCESS) {
  96     cairo_scaled_font_destroy(scaledFont);
  97     return nullptr;
  98   }
  99
 100   PrepareCairoScaledFont(scaledFont);
 101   mScaledFont = scaledFont;
 102   return mScaledFont;
 103 }
 104 #endif
 105
 106 #ifdef USE_SKIA
 107 SkPath ScaledFontBase::GetSkiaPathForGlyphs(const GlyphBuffer& aBuffer) {
 108   SkTypeface* typeFace = GetSkTypeface();
 109   MOZ_ASSERT(typeFace);
 110
 111   SkFont font(sk_ref_sp(typeFace), SkFloatToScalar(mSize));
 112
 113   std::vector<uint16_t> indices;
 114   indices.resize(aBuffer.mNumGlyphs);
 115   for (unsigned int i = 0; i < aBuffer.mNumGlyphs; i++) {
 116     indices[i] = aBuffer.mGlyphs[i].mIndex;
 117   }
 118
 119   struct Context {
 120     const Glyph* mGlyph;
 121     SkPath mPath;
 122   } ctx = {aBuffer.mGlyphs};
 123
 124   font.getPaths(
 125       indices.data(), indices.size(),
 126       [](const SkPath* glyphPath, const SkMatrix& scaleMatrix, void* ctxPtr) {
 127         Context& ctx = *reinterpret_cast<Context*>(ctxPtr);
 128         if (glyphPath) {
 129           SkMatrix transMatrix(scaleMatrix);
 130           transMatrix.postTranslate(SkFloatToScalar(ctx.mGlyph->mPosition.x),
 131                                     SkFloatToScalar(ctx.mGlyph->mPosition.y));
 132           ctx.mPath.addPath(*glyphPath, transMatrix);
 133         }
 134         ++ctx.mGlyph;
 135       },
 136       &ctx);
 137
 138   return ctx.mPath;
 139 }
 140 #endif
 141
 142 already_AddRefed<Path> ScaledFontBase::GetPathForGlyphs(
 143     const GlyphBuffer& aBuffer, const DrawTarget* aTarget) {
 144 #ifdef USE_SKIA
 145   if (aTarget->GetBackendType() == BackendType::SKIA) {
 146     SkPath path = GetSkiaPathForGlyphs(aBuffer);
 147     return MakeAndAddRef<PathSkia>(path, FillRule::FILL_WINDING);
 148   }
 149 #endif
 150 #ifdef USE_CAIRO
 151   if (aTarget->GetBackendType() == BackendType::CAIRO) {
 152     MOZ_ASSERT(mScaledFont);
 153
 154     DrawTarget* dt = const_cast<DrawTarget*>(aTarget);
 155     cairo_t* ctx = static_cast<cairo_t*>(
 156         dt->GetNativeSurface(NativeSurfaceType::CAIRO_CONTEXT));
 157
 158     bool isNewContext = !ctx;
 159     if (!ctx) {
 160       ctx = cairo_create(DrawTargetCairo::GetDummySurface());
 161       cairo_matrix_t mat;
 162       GfxMatrixToCairoMatrix(aTarget->GetTransform(), mat);
 163       cairo_set_matrix(ctx, &mat);
 164     }
 165
 166     cairo_set_scaled_font(ctx, mScaledFont);
 167
 168     // Convert our GlyphBuffer into an array of Cairo glyphs.
 169     std::vector<cairo_glyph_t> glyphs(aBuffer.mNumGlyphs);
 170     for (uint32_t i = 0; i < aBuffer.mNumGlyphs; ++i) {
 171       glyphs[i].index = aBuffer.mGlyphs[i].mIndex;
 172       glyphs[i].x = aBuffer.mGlyphs[i].mPosition.x;
 173       glyphs[i].y = aBuffer.mGlyphs[i].mPosition.y;
 174     }
 175
 176     cairo_new_path(ctx);
 177
 178     cairo_glyph_path(ctx, &glyphs[0], aBuffer.mNumGlyphs);
 179
 180     RefPtr<PathCairo> newPath = new PathCairo(ctx);
 181     if (isNewContext) {
 182       cairo_destroy(ctx);
 183     }
 184
 185     return newPath.forget();
 186   }
 187 #endif
 188 #ifdef USE_SKIA
 189   RefPtr<PathBuilder> builder = aTarget->CreatePathBuilder();
 190   SkPath skPath = GetSkiaPathForGlyphs(aBuffer);
 191   RefPtr<Path> path = MakeAndAddRef<PathSkia>(skPath, FillRule::FILL_WINDING);
 192   path->StreamToSink(builder);
 193   return builder->Finish();
 194 #endif
 195   return nullptr;
 196 }
 197
 198 void ScaledFontBase::CopyGlyphsToBuilder(const GlyphBuffer& aBuffer,
 199                                          PathBuilder* aBuilder,
 200                                          const Matrix* aTransformHint) {
 201   BackendType backendType = aBuilder->GetBackendType();
 202 #ifdef USE_SKIA
 203   if (backendType == BackendType::SKIA) {
 204     PathBuilderSkia* builder = static_cast<PathBuilderSkia*>(aBuilder);
 205     builder->AppendPath(GetSkiaPathForGlyphs(aBuffer));
 206     return;
 207   }
 208 #endif
 209 #ifdef USE_CAIRO
 210   if (backendType == BackendType::CAIRO) {
 211     MOZ_ASSERT(mScaledFont);
 212
 213     PathBuilderCairo* builder = static_cast<PathBuilderCairo*>(aBuilder);
 214     cairo_t* ctx = cairo_create(DrawTargetCairo::GetDummySurface());
 215
 216     if (aTransformHint) {
 217       cairo_matrix_t mat;
 218       GfxMatrixToCairoMatrix(*aTransformHint, mat);
 219       cairo_set_matrix(ctx, &mat);
 220     }
 221
 222     // Convert our GlyphBuffer into an array of Cairo glyphs.
 223     std::vector<cairo_glyph_t> glyphs(aBuffer.mNumGlyphs);
 224     for (uint32_t i = 0; i < aBuffer.mNumGlyphs; ++i) {
 225       glyphs[i].index = aBuffer.mGlyphs[i].mIndex;
 226       glyphs[i].x = aBuffer.mGlyphs[i].mPosition.x;
 227       glyphs[i].y = aBuffer.mGlyphs[i].mPosition.y;
 228     }
 229
 230     cairo_set_scaled_font(ctx, mScaledFont);
 231     cairo_glyph_path(ctx, &glyphs[0], aBuffer.mNumGlyphs);
 232
 233     RefPtr<PathCairo> cairoPath = new PathCairo(ctx);
 234     cairo_destroy(ctx);
 235
 236     cairoPath->AppendPathToBuilder(builder);
 237     return;
 238   }
 239 #endif
 240 #ifdef USE_SKIA
 241   if (backendType == BackendType::RECORDING) {
 242     SkPath skPath = GetSkiaPathForGlyphs(aBuffer);
 243     RefPtr<Path> path = MakeAndAddRef<PathSkia>(skPath, FillRule::FILL_WINDING);
 244     path->StreamToSink(aBuilder);
 245     return;
 246   }
 247 #endif
 248   MOZ_ASSERT(false, "Path not being copied");
 249 }
 250
 251 }  // namespace gfx
 252 }  // namespace mozilla