/* * Copyright 2006 The Android Open Source Project * * 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" #include "SkColorPriv.h" #include "SkDescriptor.h" #include "SkFDot6.h" #include "SkFloatingPoint.h" #include "SkFontHost.h" #include "SkMask.h" #include "SkAdvancedTypefaceMetrics.h" #include "SkScalerContext.h" #include "SkStream.h" #include "SkString.h" #include "SkTemplates.h" #include "SkThread.h" #include #include FT_FREETYPE_H #include FT_OUTLINE_H #include FT_SIZES_H #include FT_TRUETYPE_TABLES_H #include FT_TYPE1_TABLES_H #include FT_BITMAP_H // In the past, FT_GlyphSlot_Own_Bitmap was defined in this header file. #include FT_SYNTHESIS_H #include FT_XFREE86_H #ifdef FT_LCD_FILTER_H #include FT_LCD_FILTER_H #endif #ifdef FT_ADVANCES_H #include FT_ADVANCES_H #endif #if 0 // Also include the files by name for build tools which require this. #include #include #include #include #include #include #include #include #endif //#define ENABLE_GLYPH_SPEW // for tracing calls //#define DUMP_STRIKE_CREATION //#define SK_GAMMA_APPLY_TO_A8 //#define SK_GAMMA_SRGB #ifndef SK_GAMMA_CONTRAST #define SK_GAMMA_CONTRAST 0x66 #endif #ifndef SK_GAMMA_EXPONENT #define SK_GAMMA_EXPONENT 2.2 #endif // hand-tuned value to reduce outline embolden strength #ifndef SK_OUTLINE_EMBOLDEN_DIVISOR #ifdef SK_BUILD_FOR_ANDROID #define SK_OUTLINE_EMBOLDEN_DIVISOR 34 #else #define SK_OUTLINE_EMBOLDEN_DIVISOR 24 #endif #endif #ifdef SK_DEBUG #define SkASSERT_CONTINUE(pred) \ do { \ if (!(pred)) \ SkDebugf("file %s:%d: assert failed '" #pred "'\n", __FILE__, __LINE__); \ } while (false) #else #define SkASSERT_CONTINUE(pred) #endif using namespace skia_advanced_typeface_metrics_utils; static bool isLCD(const SkScalerContext::Rec& rec) { switch (rec.fMaskFormat) { case SkMask::kLCD16_Format: case SkMask::kLCD32_Format: return true; default: return false; } } ////////////////////////////////////////////////////////////////////////// struct SkFaceRec; SK_DECLARE_STATIC_MUTEX(gFTMutex); static int gFTCount; static FT_Library gFTLibrary; static SkFaceRec* gFaceRecHead; static bool gLCDSupportValid; // true iff |gLCDSupport| has been set. static bool gLCDSupport; // true iff LCD is supported by the runtime. static int gLCDExtra; // number of extra pixels for filtering. static const uint8_t* gGammaTables[2]; ///////////////////////////////////////////////////////////////////////// // See http://freetype.sourceforge.net/freetype2/docs/reference/ft2-bitmap_handling.html#FT_Bitmap_Embolden // This value was chosen by eyeballing the result in Firefox and trying to match it. static const FT_Pos kBitmapEmboldenStrength = 1 << 6; // convert from Skia's fixed (16.16) to FreeType's fixed (26.6) representation static inline int FixedToDot6(SkFixed x) { return x >> 10; } // convert from FreeType's fixed (26.6) to Skia's fixed (16.16) representation static inline SkFixed Dot6ToFixed(int x) { return x << 10; } static bool InitFreetype() { FT_Error err = FT_Init_FreeType(&gFTLibrary); if (err) { return false; } // Setup LCD filtering. This reduces colour fringes for LCD rendered // glyphs. #ifdef FT_LCD_FILTER_H err = FT_Library_SetLcdFilter(gFTLibrary, FT_LCD_FILTER_DEFAULT); // err = FT_Library_SetLcdFilter(gFTLibrary, FT_LCD_FILTER_LIGHT); gLCDSupport = err == 0; if (gLCDSupport) { gLCDExtra = 2; //DEFAULT and LIGHT add one pixel to each side. } #else gLCDSupport = false; #endif gLCDSupportValid = true; return true; } class SkScalerContext_FreeType : public SkScalerContext { public: SkScalerContext_FreeType(const SkDescriptor* desc); virtual ~SkScalerContext_FreeType(); bool success() const { return fFaceRec != NULL && fFTSize != NULL && fFace != NULL; } protected: virtual unsigned generateGlyphCount(); virtual uint16_t generateCharToGlyph(SkUnichar uni); virtual void generateAdvance(SkGlyph* glyph); virtual void generateMetrics(SkGlyph* glyph); virtual void generateImage(const SkGlyph& glyph); virtual void generatePath(const SkGlyph& glyph, SkPath* path); virtual void generateFontMetrics(SkPaint::FontMetrics* mx, SkPaint::FontMetrics* my); virtual SkUnichar generateGlyphToChar(uint16_t glyph); private: SkFaceRec* fFaceRec; FT_Face fFace; // reference to shared face in gFaceRecHead FT_Size fFTSize; // our own copy SkFixed fScaleX, fScaleY; FT_Matrix fMatrix22; uint32_t fLoadGlyphFlags; bool fDoLinearMetrics; FT_Error setupSize(); void emboldenOutline(FT_Outline* outline); void getBBoxForCurrentGlyph(SkGlyph* glyph, FT_BBox* bbox, bool snapToPixelBoundary = false); void updateGlyphIfLCD(SkGlyph* glyph); }; /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// #include "SkStream.h" struct SkFaceRec { SkFaceRec* fNext; FT_Face fFace; FT_StreamRec fFTStream; SkStream* fSkStream; uint32_t fRefCnt; uint32_t fFontID; // assumes ownership of the stream, will call unref() when its done SkFaceRec(SkStream* strm, uint32_t fontID); ~SkFaceRec() { fSkStream->unref(); } }; extern "C" { static unsigned long sk_stream_read(FT_Stream stream, unsigned long offset, unsigned char* buffer, unsigned long count ) { SkStream* str = (SkStream*)stream->descriptor.pointer; if (count) { if (!str->rewind()) { return 0; } else { unsigned long ret; if (offset) { ret = str->read(NULL, offset); if (ret != offset) { return 0; } } ret = str->read(buffer, count); if (ret != count) { return 0; } count = ret; } } return count; } static void sk_stream_close( FT_Stream stream) {} } SkFaceRec::SkFaceRec(SkStream* strm, uint32_t fontID) : fSkStream(strm), fFontID(fontID) { // SkDEBUGF(("SkFaceRec: opening %s (%p)\n", key.c_str(), strm)); sk_bzero(&fFTStream, sizeof(fFTStream)); fFTStream.size = fSkStream->getLength(); fFTStream.descriptor.pointer = fSkStream; fFTStream.read = sk_stream_read; fFTStream.close = sk_stream_close; } // Will return 0 on failure static SkFaceRec* ref_ft_face(uint32_t fontID) { SkFaceRec* rec = gFaceRecHead; while (rec) { if (rec->fFontID == fontID) { SkASSERT(rec->fFace); rec->fRefCnt += 1; return rec; } rec = rec->fNext; } SkStream* strm = SkFontHost::OpenStream(fontID); if (NULL == strm) { SkDEBUGF(("SkFontHost::OpenStream failed opening %x\n", fontID)); return 0; } // this passes ownership of strm to the rec rec = SkNEW_ARGS(SkFaceRec, (strm, fontID)); FT_Open_Args args; memset(&args, 0, sizeof(args)); const void* memoryBase = strm->getMemoryBase(); if (NULL != memoryBase) { //printf("mmap(%s)\n", keyString.c_str()); args.flags = FT_OPEN_MEMORY; args.memory_base = (const FT_Byte*)memoryBase; args.memory_size = strm->getLength(); } else { //printf("fopen(%s)\n", keyString.c_str()); args.flags = FT_OPEN_STREAM; args.stream = &rec->fFTStream; } int face_index; int length = SkFontHost::GetFileName(fontID, NULL, 0, &face_index); FT_Error err = FT_Open_Face(gFTLibrary, &args, length ? face_index : 0, &rec->fFace); if (err) { // bad filename, try the default font fprintf(stderr, "ERROR: unable to open font '%x'\n", fontID); SkDELETE(rec); return 0; } else { SkASSERT(rec->fFace); //fprintf(stderr, "Opened font '%s'\n", filename.c_str()); rec->fNext = gFaceRecHead; gFaceRecHead = rec; rec->fRefCnt = 1; return rec; } } static void unref_ft_face(FT_Face face) { SkFaceRec* rec = gFaceRecHead; SkFaceRec* prev = NULL; while (rec) { SkFaceRec* next = rec->fNext; if (rec->fFace == face) { if (--rec->fRefCnt == 0) { if (prev) { prev->fNext = next; } else { gFaceRecHead = next; } FT_Done_Face(face); SkDELETE(rec); } return; } prev = rec; rec = next; } SkDEBUGFAIL("shouldn't get here, face not in list"); } /////////////////////////////////////////////////////////////////////////// // Work around for old versions of freetype. static FT_Error getAdvances(FT_Face face, FT_UInt start, FT_UInt count, FT_Int32 loadFlags, FT_Fixed* advances) { #ifdef FT_ADVANCES_H return FT_Get_Advances(face, start, count, loadFlags, advances); #else if (!face || start >= face->num_glyphs || start + count > face->num_glyphs || loadFlags != FT_LOAD_NO_SCALE) { return 6; // "Invalid argument." } if (count == 0) return 0; for (int i = 0; i < count; i++) { FT_Error err = FT_Load_Glyph(face, start + i, FT_LOAD_NO_SCALE); if (err) return err; advances[i] = face->glyph->advance.x; } return 0; #endif } static bool canEmbed(FT_Face face) { #ifdef FT_FSTYPE_RESTRICTED_LICENSE_EMBEDDING FT_UShort fsType = FT_Get_FSType_Flags(face); return (fsType & (FT_FSTYPE_RESTRICTED_LICENSE_EMBEDDING | FT_FSTYPE_BITMAP_EMBEDDING_ONLY)) == 0; #else // No embedding is 0x2 and bitmap embedding only is 0x200. TT_OS2* os2_table; if ((os2_table = (TT_OS2*)FT_Get_Sfnt_Table(face, ft_sfnt_os2)) != NULL) { return (os2_table->fsType & 0x202) == 0; } return false; // We tried, fail safe. #endif } static bool GetLetterCBox(FT_Face face, char letter, FT_BBox* bbox) { const FT_UInt glyph_id = FT_Get_Char_Index(face, letter); if (!glyph_id) return false; FT_Load_Glyph(face, glyph_id, FT_LOAD_NO_SCALE); FT_Outline_Get_CBox(&face->glyph->outline, bbox); return true; } static bool getWidthAdvance(FT_Face face, int gId, int16_t* data) { FT_Fixed advance = 0; if (getAdvances(face, gId, 1, FT_LOAD_NO_SCALE, &advance)) { return false; } SkASSERT(data); *data = advance; return true; } static void populate_glyph_to_unicode(FT_Face& face, SkTDArray* glyphToUnicode) { // Check and see if we have Unicode cmaps. for (int i = 0; i < face->num_charmaps; ++i) { // CMaps known to support Unicode: // Platform ID Encoding ID Name // ----------- ----------- ----------------------------------- // 0 0,1 Apple Unicode // 0 3 Apple Unicode 2.0 (preferred) // 3 1 Microsoft Unicode UCS-2 // 3 10 Microsoft Unicode UCS-4 (preferred) // // See Apple TrueType Reference Manual // http://developer.apple.com/fonts/TTRefMan/RM06/Chap6cmap.html // http://developer.apple.com/fonts/TTRefMan/RM06/Chap6name.html#ID // Microsoft OpenType Specification // http://www.microsoft.com/typography/otspec/cmap.htm FT_UShort platformId = face->charmaps[i]->platform_id; FT_UShort encodingId = face->charmaps[i]->encoding_id; if (platformId != 0 && platformId != 3) { continue; } if (platformId == 3 && encodingId != 1 && encodingId != 10) { continue; } bool preferredMap = ((platformId == 3 && encodingId == 10) || (platformId == 0 && encodingId == 3)); FT_Set_Charmap(face, face->charmaps[i]); if (glyphToUnicode->isEmpty()) { glyphToUnicode->setCount(face->num_glyphs); memset(glyphToUnicode->begin(), 0, sizeof(SkUnichar) * face->num_glyphs); } // Iterate through each cmap entry. FT_UInt glyphIndex; for (SkUnichar charCode = FT_Get_First_Char(face, &glyphIndex); glyphIndex != 0; charCode = FT_Get_Next_Char(face, charCode, &glyphIndex)) { if (charCode && ((*glyphToUnicode)[glyphIndex] == 0 || preferredMap)) { (*glyphToUnicode)[glyphIndex] = charCode; } } } } // static SkAdvancedTypefaceMetrics* SkFontHost::GetAdvancedTypefaceMetrics( uint32_t fontID, SkAdvancedTypefaceMetrics::PerGlyphInfo perGlyphInfo, const uint32_t* glyphIDs, uint32_t glyphIDsCount) { #if defined(SK_BUILD_FOR_MAC) return NULL; #else SkAutoMutexAcquire ac(gFTMutex); FT_Library libInit = NULL; if (gFTCount == 0) { if (!InitFreetype()) sk_throw(); libInit = gFTLibrary; } SkAutoTCallIProc ftLib(libInit); SkFaceRec* rec = ref_ft_face(fontID); if (NULL == rec) return NULL; FT_Face face = rec->fFace; SkAdvancedTypefaceMetrics* info = new SkAdvancedTypefaceMetrics; info->fFontName.set(FT_Get_Postscript_Name(face)); info->fMultiMaster = FT_HAS_MULTIPLE_MASTERS(face); info->fLastGlyphID = face->num_glyphs - 1; info->fEmSize = 1000; bool cid = false; const char* fontType = FT_Get_X11_Font_Format(face); if (strcmp(fontType, "Type 1") == 0) { info->fType = SkAdvancedTypefaceMetrics::kType1_Font; } else if (strcmp(fontType, "CID Type 1") == 0) { info->fType = SkAdvancedTypefaceMetrics::kType1CID_Font; cid = true; } else if (strcmp(fontType, "CFF") == 0) { info->fType = SkAdvancedTypefaceMetrics::kCFF_Font; } else if (strcmp(fontType, "TrueType") == 0) { info->fType = SkAdvancedTypefaceMetrics::kTrueType_Font; cid = true; TT_Header* ttHeader; if ((ttHeader = (TT_Header*)FT_Get_Sfnt_Table(face, ft_sfnt_head)) != NULL) { info->fEmSize = ttHeader->Units_Per_EM; } } info->fStyle = 0; if (FT_IS_FIXED_WIDTH(face)) info->fStyle |= SkAdvancedTypefaceMetrics::kFixedPitch_Style; if (face->style_flags & FT_STYLE_FLAG_ITALIC) info->fStyle |= SkAdvancedTypefaceMetrics::kItalic_Style; // We should set either Symbolic or Nonsymbolic; Nonsymbolic if the font's // character set is a subset of 'Adobe standard Latin.' info->fStyle |= SkAdvancedTypefaceMetrics::kSymbolic_Style; PS_FontInfoRec ps_info; TT_Postscript* tt_info; if (FT_Get_PS_Font_Info(face, &ps_info) == 0) { info->fItalicAngle = ps_info.italic_angle; } else if ((tt_info = (TT_Postscript*)FT_Get_Sfnt_Table(face, ft_sfnt_post)) != NULL) { info->fItalicAngle = SkFixedToScalar(tt_info->italicAngle); } else { info->fItalicAngle = 0; } info->fAscent = face->ascender; info->fDescent = face->descender; // Figure out a good guess for StemV - Min width of i, I, !, 1. // This probably isn't very good with an italic font. int16_t min_width = SHRT_MAX; info->fStemV = 0; char stem_chars[] = {'i', 'I', '!', '1'}; for (size_t i = 0; i < SK_ARRAY_COUNT(stem_chars); i++) { FT_BBox bbox; if (GetLetterCBox(face, stem_chars[i], &bbox)) { int16_t width = bbox.xMax - bbox.xMin; if (width > 0 && width < min_width) { min_width = width; info->fStemV = min_width; } } } TT_PCLT* pclt_info; TT_OS2* os2_table; if ((pclt_info = (TT_PCLT*)FT_Get_Sfnt_Table(face, ft_sfnt_pclt)) != NULL) { info->fCapHeight = pclt_info->CapHeight; uint8_t serif_style = pclt_info->SerifStyle & 0x3F; if (serif_style >= 2 && serif_style <= 6) info->fStyle |= SkAdvancedTypefaceMetrics::kSerif_Style; else if (serif_style >= 9 && serif_style <= 12) info->fStyle |= SkAdvancedTypefaceMetrics::kScript_Style; } else if ((os2_table = (TT_OS2*)FT_Get_Sfnt_Table(face, ft_sfnt_os2)) != NULL) { info->fCapHeight = os2_table->sCapHeight; } else { // Figure out a good guess for CapHeight: average the height of M and X. FT_BBox m_bbox, x_bbox; bool got_m, got_x; got_m = GetLetterCBox(face, 'M', &m_bbox); got_x = GetLetterCBox(face, 'X', &x_bbox); if (got_m && got_x) { info->fCapHeight = (m_bbox.yMax - m_bbox.yMin + x_bbox.yMax - x_bbox.yMin) / 2; } else if (got_m && !got_x) { info->fCapHeight = m_bbox.yMax - m_bbox.yMin; } else if (!got_m && got_x) { info->fCapHeight = x_bbox.yMax - x_bbox.yMin; } } info->fBBox = SkIRect::MakeLTRB(face->bbox.xMin, face->bbox.yMax, face->bbox.xMax, face->bbox.yMin); if (!canEmbed(face) || !FT_IS_SCALABLE(face) || info->fType == SkAdvancedTypefaceMetrics::kOther_Font) { perGlyphInfo = SkAdvancedTypefaceMetrics::kNo_PerGlyphInfo; } if (perGlyphInfo & SkAdvancedTypefaceMetrics::kHAdvance_PerGlyphInfo) { if (FT_IS_FIXED_WIDTH(face)) { appendRange(&info->fGlyphWidths, 0); int16_t advance = face->max_advance_width; info->fGlyphWidths->fAdvance.append(1, &advance); finishRange(info->fGlyphWidths.get(), 0, SkAdvancedTypefaceMetrics::WidthRange::kDefault); } else if (!cid) { appendRange(&info->fGlyphWidths, 0); // So as to not blow out the stack, get advances in batches. for (int gID = 0; gID < face->num_glyphs; gID += 128) { FT_Fixed advances[128]; int advanceCount = 128; if (gID + advanceCount > face->num_glyphs) advanceCount = face->num_glyphs - gID + 1; getAdvances(face, gID, advanceCount, FT_LOAD_NO_SCALE, advances); for (int i = 0; i < advanceCount; i++) { int16_t advance = advances[gID + i]; info->fGlyphWidths->fAdvance.append(1, &advance); } } finishRange(info->fGlyphWidths.get(), face->num_glyphs - 1, SkAdvancedTypefaceMetrics::WidthRange::kRange); } else { info->fGlyphWidths.reset( getAdvanceData(face, face->num_glyphs, glyphIDs, glyphIDsCount, &getWidthAdvance)); } } if (perGlyphInfo & SkAdvancedTypefaceMetrics::kVAdvance_PerGlyphInfo && FT_HAS_VERTICAL(face)) { SkASSERT(false); // Not implemented yet. } if (perGlyphInfo & SkAdvancedTypefaceMetrics::kGlyphNames_PerGlyphInfo && info->fType == SkAdvancedTypefaceMetrics::kType1_Font) { // Postscript fonts may contain more than 255 glyphs, so we end up // using multiple font descriptions with a glyph ordering. Record // the name of each glyph. info->fGlyphNames.reset( new SkAutoTArray(face->num_glyphs)); for (int gID = 0; gID < face->num_glyphs; gID++) { char glyphName[128]; // PS limit for names is 127 bytes. FT_Get_Glyph_Name(face, gID, glyphName, 128); info->fGlyphNames->get()[gID].set(glyphName); } } if (perGlyphInfo & SkAdvancedTypefaceMetrics::kToUnicode_PerGlyphInfo && info->fType != SkAdvancedTypefaceMetrics::kType1_Font && face->num_charmaps) { populate_glyph_to_unicode(face, &(info->fGlyphToUnicode)); } if (!canEmbed(face)) info->fType = SkAdvancedTypefaceMetrics::kNotEmbeddable_Font; unref_ft_face(face); return info; #endif } /////////////////////////////////////////////////////////////////////////// #define BLACK_LUMINANCE_LIMIT 0x40 #define WHITE_LUMINANCE_LIMIT 0xA0 static bool bothZero(SkScalar a, SkScalar b) { return 0 == a && 0 == b; } // returns false if there is any non-90-rotation or skew static bool isAxisAligned(const SkScalerContext::Rec& rec) { return 0 == rec.fPreSkewX && (bothZero(rec.fPost2x2[0][1], rec.fPost2x2[1][0]) || bothZero(rec.fPost2x2[0][0], rec.fPost2x2[1][1])); } void SkFontHost::FilterRec(SkScalerContext::Rec* rec) { //BOGUS: http://code.google.com/p/chromium/issues/detail?id=121119 //Cap the requested size as larger sizes give bogus values. //Remove when http://code.google.com/p/skia/issues/detail?id=554 is fixed. if (rec->fTextSize > SkIntToScalar(1 << 14)) { rec->fTextSize = SkIntToScalar(1 << 14); } if (!gLCDSupportValid) { InitFreetype(); FT_Done_FreeType(gFTLibrary); } if (!gLCDSupport && isLCD(*rec)) { // If the runtime Freetype library doesn't support LCD mode, we disable // it here. rec->fMaskFormat = SkMask::kA8_Format; } SkPaint::Hinting h = rec->getHinting(); if (SkPaint::kFull_Hinting == h && !isLCD(*rec)) { // collapse full->normal hinting if we're not doing LCD h = SkPaint::kNormal_Hinting; } if ((rec->fFlags & SkScalerContext::kSubpixelPositioning_Flag)) { if (SkPaint::kNo_Hinting != h) { h = SkPaint::kSlight_Hinting; } } #ifndef SK_IGNORE_ROTATED_FREETYPE_FIX // rotated text looks bad with hinting, so we disable it as needed if (!isAxisAligned(*rec)) { h = SkPaint::kNo_Hinting; } #endif rec->setHinting(h); #ifndef SK_USE_COLOR_LUMINANCE // for compatibility at the moment, discretize luminance to 3 settings // black, white, gray. This helps with fontcache utilization, since we // won't create multiple entries that in the end map to the same results. { unsigned lum = rec->getLuminanceByte(); if (gGammaTables[0] || gGammaTables[1]) { if (lum <= BLACK_LUMINANCE_LIMIT) { lum = 0; } else if (lum >= WHITE_LUMINANCE_LIMIT) { lum = SkScalerContext::kLuminance_Max; } else { lum = SkScalerContext::kLuminance_Max >> 1; } } else { lum = 0; // no gamma correct, so use 0 since SkPaint uses that // when measuring text w/o regard for luminance } rec->setLuminanceBits(lum); } #endif } #ifdef SK_BUILD_FOR_ANDROID uint32_t SkFontHost::GetUnitsPerEm(SkFontID fontID) { SkAutoMutexAcquire ac(gFTMutex); SkFaceRec *rec = ref_ft_face(fontID); uint16_t unitsPerEm = 0; if (rec != NULL && rec->fFace != NULL) { unitsPerEm = rec->fFace->units_per_EM; unref_ft_face(rec->fFace); } return (uint32_t)unitsPerEm; } #endif SkScalerContext_FreeType::SkScalerContext_FreeType(const SkDescriptor* desc) : SkScalerContext(desc) { SkAutoMutexAcquire ac(gFTMutex); if (gFTCount == 0) { if (!InitFreetype()) { sk_throw(); } SkFontHost::GetGammaTables(gGammaTables); } ++gFTCount; // load the font file fFTSize = NULL; fFace = NULL; fFaceRec = ref_ft_face(fRec.fFontID); if (NULL == fFaceRec) { return; } fFace = fFaceRec->fFace; // compute our factors from the record SkMatrix m; fRec.getSingleMatrix(&m); #ifdef DUMP_STRIKE_CREATION SkString keyString; SkFontHost::GetDescriptorKeyString(desc, &keyString); printf("========== strike [%g %g %g] [%g %g %g %g] hints %d format %d %s\n", SkScalarToFloat(fRec.fTextSize), SkScalarToFloat(fRec.fPreScaleX), SkScalarToFloat(fRec.fPreSkewX), SkScalarToFloat(fRec.fPost2x2[0][0]), SkScalarToFloat(fRec.fPost2x2[0][1]), SkScalarToFloat(fRec.fPost2x2[1][0]), SkScalarToFloat(fRec.fPost2x2[1][1]), fRec.getHinting(), fRec.fMaskFormat, keyString.c_str()); #endif // now compute our scale factors SkScalar sx = m.getScaleX(); SkScalar sy = m.getScaleY(); if (m.getSkewX() || m.getSkewY() || sx < 0 || sy < 0) { // sort of give up on hinting sx = SkMaxScalar(SkScalarAbs(sx), SkScalarAbs(m.getSkewX())); sy = SkMaxScalar(SkScalarAbs(m.getSkewY()), SkScalarAbs(sy)); sx = sy = SkScalarAve(sx, sy); SkScalar inv = SkScalarInvert(sx); // flip the skew elements to go from our Y-down system to FreeType's fMatrix22.xx = SkScalarToFixed(SkScalarMul(m.getScaleX(), inv)); fMatrix22.xy = -SkScalarToFixed(SkScalarMul(m.getSkewX(), inv)); fMatrix22.yx = -SkScalarToFixed(SkScalarMul(m.getSkewY(), inv)); fMatrix22.yy = SkScalarToFixed(SkScalarMul(m.getScaleY(), inv)); } else { fMatrix22.xx = fMatrix22.yy = SK_Fixed1; fMatrix22.xy = fMatrix22.yx = 0; } fScaleX = SkScalarToFixed(sx); fScaleY = SkScalarToFixed(sy); // compute the flags we send to Load_Glyph { FT_Int32 loadFlags = FT_LOAD_DEFAULT; bool linearMetrics = SkToBool(fRec.fFlags & SkScalerContext::kSubpixelPositioning_Flag); if (SkMask::kBW_Format == fRec.fMaskFormat) { // See http://code.google.com/p/chromium/issues/detail?id=43252#c24 loadFlags = FT_LOAD_TARGET_MONO; if (fRec.getHinting() == SkPaint::kNo_Hinting) { loadFlags = FT_LOAD_NO_HINTING; linearMetrics = true; } } else { switch (fRec.getHinting()) { case SkPaint::kNo_Hinting: loadFlags = FT_LOAD_NO_HINTING; linearMetrics = true; break; case SkPaint::kSlight_Hinting: loadFlags = FT_LOAD_TARGET_LIGHT; // This implies FORCE_AUTOHINT break; case SkPaint::kNormal_Hinting: if (fRec.fFlags & SkScalerContext::kAutohinting_Flag) loadFlags = FT_LOAD_FORCE_AUTOHINT; else loadFlags = FT_LOAD_NO_AUTOHINT; break; case SkPaint::kFull_Hinting: if (fRec.fFlags & SkScalerContext::kAutohinting_Flag) { loadFlags = FT_LOAD_FORCE_AUTOHINT; break; } loadFlags = FT_LOAD_TARGET_NORMAL; if (isLCD(fRec)) { if (fRec.fFlags & SkScalerContext::kLCD_Vertical_Flag) { loadFlags = FT_LOAD_TARGET_LCD_V; } else { loadFlags = FT_LOAD_TARGET_LCD; } } break; default: SkDebugf("---------- UNKNOWN hinting %d\n", fRec.getHinting()); break; } } if ((fRec.fFlags & SkScalerContext::kEmbeddedBitmapText_Flag) == 0) { loadFlags |= FT_LOAD_NO_BITMAP; } // Always using FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH to get correct // advances, as fontconfig and cairo do. // See http://code.google.com/p/skia/issues/detail?id=222. loadFlags |= FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH; fLoadGlyphFlags = loadFlags; fDoLinearMetrics = linearMetrics; } // now create the FT_Size { FT_Error err; err = FT_New_Size(fFace, &fFTSize); if (err != 0) { SkDEBUGF(("SkScalerContext_FreeType::FT_New_Size(%x): FT_Set_Char_Size(0x%x, 0x%x) returned 0x%x\n", fFaceRec->fFontID, fScaleX, fScaleY, err)); fFace = NULL; return; } err = FT_Activate_Size(fFTSize); if (err != 0) { SkDEBUGF(("SkScalerContext_FreeType::FT_Activate_Size(%x, 0x%x, 0x%x) returned 0x%x\n", fFaceRec->fFontID, fScaleX, fScaleY, err)); fFTSize = NULL; } err = FT_Set_Char_Size( fFace, SkFixedToFDot6(fScaleX), SkFixedToFDot6(fScaleY), 72, 72); if (err != 0) { SkDEBUGF(("SkScalerContext_FreeType::FT_Set_Char_Size(%x, 0x%x, 0x%x) returned 0x%x\n", fFaceRec->fFontID, fScaleX, fScaleY, err)); fFace = NULL; return; } FT_Set_Transform( fFace, &fMatrix22, NULL); } } SkScalerContext_FreeType::~SkScalerContext_FreeType() { if (fFTSize != NULL) { FT_Done_Size(fFTSize); } SkAutoMutexAcquire ac(gFTMutex); if (fFace != NULL) { unref_ft_face(fFace); } if (--gFTCount == 0) { // SkDEBUGF(("FT_Done_FreeType\n")); FT_Done_FreeType(gFTLibrary); SkDEBUGCODE(gFTLibrary = NULL;) } } /* We call this before each use of the fFace, since we may be sharing this face with other context (at different sizes). */ FT_Error SkScalerContext_FreeType::setupSize() { FT_Error err = FT_Activate_Size(fFTSize); if (err != 0) { SkDEBUGF(("SkScalerContext_FreeType::FT_Activate_Size(%x, 0x%x, 0x%x) returned 0x%x\n", fFaceRec->fFontID, fScaleX, fScaleY, err)); fFTSize = NULL; } else { // seems we need to reset this every time (not sure why, but without it // I get random italics from some other fFTSize) FT_Set_Transform( fFace, &fMatrix22, NULL); } return err; } void SkScalerContext_FreeType::emboldenOutline(FT_Outline* outline) { FT_Pos strength; strength = FT_MulFix(fFace->units_per_EM, fFace->size->metrics.y_scale) / SK_OUTLINE_EMBOLDEN_DIVISOR; FT_Outline_Embolden(outline, strength); } unsigned SkScalerContext_FreeType::generateGlyphCount() { return fFace->num_glyphs; } uint16_t SkScalerContext_FreeType::generateCharToGlyph(SkUnichar uni) { return SkToU16(FT_Get_Char_Index( fFace, uni )); } SkUnichar SkScalerContext_FreeType::generateGlyphToChar(uint16_t glyph) { // iterate through each cmap entry, looking for matching glyph indices FT_UInt glyphIndex; SkUnichar charCode = FT_Get_First_Char( fFace, &glyphIndex ); while (glyphIndex != 0) { if (glyphIndex == glyph) { return charCode; } charCode = FT_Get_Next_Char( fFace, charCode, &glyphIndex ); } return 0; } static FT_Pixel_Mode compute_pixel_mode(SkMask::Format format) { switch (format) { case SkMask::kBW_Format: return FT_PIXEL_MODE_MONO; case SkMask::kA8_Format: default: return FT_PIXEL_MODE_GRAY; } } void SkScalerContext_FreeType::generateAdvance(SkGlyph* glyph) { #ifdef FT_ADVANCES_H /* unhinted and light hinted text have linearly scaled advances * which are very cheap to compute with some font formats... */ if (fDoLinearMetrics) { SkAutoMutexAcquire ac(gFTMutex); if (this->setupSize()) { glyph->zeroMetrics(); return; } FT_Error error; FT_Fixed advance; error = FT_Get_Advance( fFace, glyph->getGlyphID(fBaseGlyphCount), fLoadGlyphFlags | FT_ADVANCE_FLAG_FAST_ONLY, &advance ); if (0 == error) { glyph->fRsbDelta = 0; glyph->fLsbDelta = 0; glyph->fAdvanceX = SkFixedMul(fMatrix22.xx, advance); glyph->fAdvanceY = - SkFixedMul(fMatrix22.yx, advance); return; } } #endif /* FT_ADVANCES_H */ /* otherwise, we need to load/hint the glyph, which is slower */ this->generateMetrics(glyph); return; } void SkScalerContext_FreeType::getBBoxForCurrentGlyph(SkGlyph* glyph, FT_BBox* bbox, bool snapToPixelBoundary) { FT_Outline_Get_CBox(&fFace->glyph->outline, bbox); if (fRec.fFlags & SkScalerContext::kSubpixelPositioning_Flag) { int dx = FixedToDot6(glyph->getSubXFixed()); int dy = FixedToDot6(glyph->getSubYFixed()); // negate dy since freetype-y-goes-up and skia-y-goes-down bbox->xMin += dx; bbox->yMin -= dy; bbox->xMax += dx; bbox->yMax -= dy; } // outset the box to integral boundaries if (snapToPixelBoundary) { bbox->xMin &= ~63; bbox->yMin &= ~63; bbox->xMax = (bbox->xMax + 63) & ~63; bbox->yMax = (bbox->yMax + 63) & ~63; } } void SkScalerContext_FreeType::updateGlyphIfLCD(SkGlyph* glyph) { if (isLCD(fRec)) { glyph->fWidth += gLCDExtra; glyph->fLeft -= gLCDExtra >> 1; } } void SkScalerContext_FreeType::generateMetrics(SkGlyph* glyph) { SkAutoMutexAcquire ac(gFTMutex); glyph->fRsbDelta = 0; glyph->fLsbDelta = 0; FT_Error err; if (this->setupSize()) { goto ERROR; } err = FT_Load_Glyph( fFace, glyph->getGlyphID(fBaseGlyphCount), fLoadGlyphFlags ); if (err != 0) { SkDEBUGF(("SkScalerContext_FreeType::generateMetrics(%x): FT_Load_Glyph(glyph:%d flags:%d) returned 0x%x\n", fFaceRec->fFontID, glyph->getGlyphID(fBaseGlyphCount), fLoadGlyphFlags, err)); ERROR: glyph->zeroMetrics(); return; } SkFixed vLeft, vTop; switch ( fFace->glyph->format ) { case FT_GLYPH_FORMAT_OUTLINE: { FT_BBox bbox; if (0 == fFace->glyph->outline.n_contours) { glyph->fWidth = 0; glyph->fHeight = 0; glyph->fTop = 0; glyph->fLeft = 0; break; } if ((fRec.fFlags & kEmbolden_Flag) && !(fFace->style_flags & FT_STYLE_FLAG_BOLD)) { emboldenOutline(&fFace->glyph->outline); } getBBoxForCurrentGlyph(glyph, &bbox, true); glyph->fWidth = SkToU16((bbox.xMax - bbox.xMin) >> 6); glyph->fHeight = SkToU16((bbox.yMax - bbox.yMin) >> 6); glyph->fTop = -SkToS16(bbox.yMax >> 6); glyph->fLeft = SkToS16(bbox.xMin >> 6); if ((fRec.fFlags & SkScalerContext::kVertical_Flag)) { vLeft = Dot6ToFixed(bbox.xMin); vTop = Dot6ToFixed(bbox.yMax); } updateGlyphIfLCD(glyph); break; } case FT_GLYPH_FORMAT_BITMAP: if ((fRec.fFlags & kEmbolden_Flag) && !(fFace->style_flags & FT_STYLE_FLAG_BOLD)) { FT_GlyphSlot_Own_Bitmap(fFace->glyph); FT_Bitmap_Embolden(gFTLibrary, &fFace->glyph->bitmap, kBitmapEmboldenStrength, 0); } glyph->fWidth = SkToU16(fFace->glyph->bitmap.width); glyph->fHeight = SkToU16(fFace->glyph->bitmap.rows); glyph->fTop = -SkToS16(fFace->glyph->bitmap_top); glyph->fLeft = SkToS16(fFace->glyph->bitmap_left); break; default: SkDEBUGFAIL("unknown glyph format"); goto ERROR; } if (fDoLinearMetrics) { glyph->fAdvanceX = SkFixedMul(fMatrix22.xx, fFace->glyph->linearHoriAdvance); glyph->fAdvanceY = -SkFixedMul(fMatrix22.yx, fFace->glyph->linearHoriAdvance); } else { glyph->fAdvanceX = SkFDot6ToFixed(fFace->glyph->advance.x); glyph->fAdvanceY = -SkFDot6ToFixed(fFace->glyph->advance.y); if (fRec.fFlags & kDevKernText_Flag) { glyph->fRsbDelta = SkToS8(fFace->glyph->rsb_delta); glyph->fLsbDelta = SkToS8(fFace->glyph->lsb_delta); } } if ((fRec.fFlags & SkScalerContext::kVertical_Flag) && fFace->glyph->format == FT_GLYPH_FORMAT_OUTLINE) { //TODO: do we need to specially handle SubpixelPositioning and Kerning? FT_Matrix identityMatrix; identityMatrix.xx = identityMatrix.yy = SK_Fixed1; identityMatrix.xy = identityMatrix.yx = 0; // if the matrix is not the identity matrix then we need to re-load the // glyph with the identity matrix to get the necessary bounding box if (memcmp(&fMatrix22, &identityMatrix, sizeof(FT_Matrix)) != 0) { FT_Set_Transform(fFace, &identityMatrix, NULL); err = FT_Load_Glyph( fFace, glyph->getGlyphID(fBaseGlyphCount), fLoadGlyphFlags ); if (err != 0) { SkDEBUGF(("SkScalerContext_FreeType::generateMetrics(%x): FT_Load_Glyph(glyph:%d flags:%d) returned 0x%x\n", fFaceRec->fFontID, glyph->getGlyphID(fBaseGlyphCount), fLoadGlyphFlags, err)); goto ERROR; } if ((fRec.fFlags & kEmbolden_Flag) && !(fFace->style_flags & FT_STYLE_FLAG_BOLD)) { emboldenOutline(&fFace->glyph->outline); } } // bounding box of the unskewed and unscaled glyph FT_BBox bbox; getBBoxForCurrentGlyph(glyph, &bbox); // compute the vertical gap above and below the glyph if the glyph were // centered within the linearVertAdvance SkFixed vGap = (fFace->glyph->linearVertAdvance - Dot6ToFixed(bbox.yMax - bbox.yMin)) / 2; // the origin point of the glyph when rendered vertically FT_Vector vOrigin; vOrigin.x = fFace->glyph->linearHoriAdvance / 2; vOrigin.y = vGap + Dot6ToFixed(bbox.yMax); // transform the vertical origin based on the matrix of the actual glyph FT_Vector_Transform(&vOrigin, &fMatrix22); // compute a new offset vector for the glyph by subtracting the vertical // origin from the original horizontal offset vector glyph->fLeft = SkFixedRoundToInt(vLeft - vOrigin.x); glyph->fTop = -SkFixedRoundToInt(vTop - vOrigin.y); updateGlyphIfLCD(glyph); // use the vertical advance values computed by freetype glyph->fAdvanceX = -SkFixedMul(fMatrix22.xy, fFace->glyph->linearVertAdvance); glyph->fAdvanceY = SkFixedMul(fMatrix22.yy, fFace->glyph->linearVertAdvance); } #ifdef ENABLE_GLYPH_SPEW SkDEBUGF(("FT_Set_Char_Size(this:%p sx:%x sy:%x ", this, fScaleX, fScaleY)); SkDEBUGF(("Metrics(glyph:%d flags:0x%x) w:%d\n", glyph->getGlyphID(fBaseGlyphCount), fLoadGlyphFlags, glyph->fWidth)); #endif } /////////////////////////////////////////////////////////////////////////////// #ifdef SK_USE_COLOR_LUMINANCE static float apply_contrast(float srca, float contrast) { return srca + ((1.0f - srca) * contrast * srca); } #ifdef SK_GAMMA_SRGB static float lin(float per) { if (per <= 0.04045f) { return per / 12.92f; } return powf((per + 0.055f) / 1.055, 2.4f); } static float per(float lin) { if (lin <= 0.0031308f) { return lin * 12.92f; } return 1.055f * powf(lin, 1.0f / 2.4f) - 0.055f; } #else //SK_GAMMA_SRGB static float lin(float per) { const float g = SK_GAMMA_EXPONENT; return powf(per, g); } static float per(float lin) { const float g = SK_GAMMA_EXPONENT; return powf(lin, 1.0f / g); } #endif //SK_GAMMA_SRGB static void build_gamma_table(uint8_t table[256], int srcI) { const float src = (float)srcI / 255.0f; const float linSrc = lin(src); const float linDst = 1.0f - linSrc; const float dst = per(linDst); // have our contrast value taper off to 0 as the src luminance becomes white const float contrast = SK_GAMMA_CONTRAST / 255.0f * linDst; const float step = 1.0f / 256.0f; //Remove discontinuity and instability when src is close to dst. if (fabs(src - dst) < 0.01f) { float rawSrca = 0.0f; for (int i = 0; i < 256; ++i, rawSrca += step) { float srca = apply_contrast(rawSrca, contrast); table[i] = sk_float_round2int(255.0f * srca); } } else { float rawSrca = 0.0f; for (int i = 0; i < 256; ++i, rawSrca += step) { float srca = apply_contrast(rawSrca, contrast); SkASSERT(srca <= 1.0f); float dsta = 1 - srca; //Calculate the output we want. float linOut = (linSrc * srca + dsta * linDst); SkASSERT(linOut <= 1.0f); float out = per(linOut); //Undo what the blit blend will do. float result = (out - dst) / (src - dst); SkASSERT(sk_float_round2int(255.0f * result) <= 255); table[i] = sk_float_round2int(255.0f * result); } } } static const uint8_t* getGammaTable(U8CPU luminance) { static uint8_t gGammaTables[4][256]; static bool gInited; if (!gInited) { build_gamma_table(gGammaTables[0], 0x00); build_gamma_table(gGammaTables[1], 0x55); build_gamma_table(gGammaTables[2], 0xAA); build_gamma_table(gGammaTables[3], 0xFF); gInited = true; } SkASSERT(0 == (luminance >> 8)); return gGammaTables[luminance >> 6]; } #else //SK_USE_COLOR_LUMINANCE static const uint8_t* getIdentityTable() { static bool gOnce; static uint8_t gIdentityTable[256]; if (!gOnce) { for (int i = 0; i < 256; ++i) { gIdentityTable[i] = i; } gOnce = true; } return gIdentityTable; } #endif //SK_USE_COLOR_LUMINANCE static uint16_t packTriple(unsigned r, unsigned g, unsigned b) { return SkPackRGB16(r >> 3, g >> 2, b >> 3); } static uint16_t grayToRGB16(U8CPU gray) { SkASSERT(gray <= 255); return SkPackRGB16(gray >> 3, gray >> 2, gray >> 3); } static int bittst(const uint8_t data[], int bitOffset) { SkASSERT(bitOffset >= 0); int lowBit = data[bitOffset >> 3] >> (~bitOffset & 7); return lowBit & 1; } static void copyFT2LCD16(const SkGlyph& glyph, const FT_Bitmap& bitmap, int lcdIsBGR, const uint8_t* tableR, const uint8_t* tableG, const uint8_t* tableB) { SkASSERT(glyph.fHeight == bitmap.rows); uint16_t* dst = reinterpret_cast(glyph.fImage); const size_t dstRB = glyph.rowBytes(); const int width = glyph.fWidth; const uint8_t* src = bitmap.buffer; switch (bitmap.pixel_mode) { case FT_PIXEL_MODE_MONO: { for (int y = 0; y < glyph.fHeight; ++y) { for (int x = 0; x < width; ++x) { dst[x] = -bittst(src, x); } dst = (uint16_t*)((char*)dst + dstRB); src += bitmap.pitch; } } break; case FT_PIXEL_MODE_GRAY: { for (int y = 0; y < glyph.fHeight; ++y) { for (int x = 0; x < width; ++x) { dst[x] = grayToRGB16(src[x]); } dst = (uint16_t*)((char*)dst + dstRB); src += bitmap.pitch; } } break; default: { SkASSERT(glyph.fWidth * 3 == bitmap.width); for (int y = 0; y < glyph.fHeight; y++) { const uint8_t* triple = src; if (lcdIsBGR) { for (int x = 0; x < width; x++) { dst[x] = packTriple(tableR[triple[2]], tableG[triple[1]], tableB[triple[0]]); triple += 3; } } else { for (int x = 0; x < width; x++) { dst[x] = packTriple(tableR[triple[0]], tableG[triple[1]], tableB[triple[2]]); triple += 3; } } src += bitmap.pitch; dst = (uint16_t*)((char*)dst + dstRB); } } break; } } void SkScalerContext_FreeType::generateImage(const SkGlyph& glyph) { SkAutoMutexAcquire ac(gFTMutex); FT_Error err; if (this->setupSize()) { goto ERROR; } err = FT_Load_Glyph( fFace, glyph.getGlyphID(fBaseGlyphCount), fLoadGlyphFlags); if (err != 0) { SkDEBUGF(("SkScalerContext_FreeType::generateImage: FT_Load_Glyph(glyph:%d width:%d height:%d rb:%d flags:%d) returned 0x%x\n", glyph.getGlyphID(fBaseGlyphCount), glyph.fWidth, glyph.fHeight, glyph.rowBytes(), fLoadGlyphFlags, err)); ERROR: memset(glyph.fImage, 0, glyph.rowBytes() * glyph.fHeight); return; } #ifdef SK_USE_COLOR_LUMINANCE SkColor lumColor = fRec.getLuminanceColor(); const uint8_t* tableR = getGammaTable(SkColorGetR(lumColor)); const uint8_t* tableG = getGammaTable(SkColorGetG(lumColor)); const uint8_t* tableB = getGammaTable(SkColorGetB(lumColor)); #else unsigned lum = fRec.getLuminanceByte(); const uint8_t* tableR; const uint8_t* tableG; const uint8_t* tableB; bool isWhite = lum >= WHITE_LUMINANCE_LIMIT; bool isBlack = lum <= BLACK_LUMINANCE_LIMIT; if ((gGammaTables[0] || gGammaTables[1]) && (isBlack || isWhite)) { tableR = tableG = tableB = gGammaTables[isBlack ? 0 : 1]; } else { tableR = tableG = tableB = getIdentityTable(); } #endif switch ( fFace->glyph->format ) { case FT_GLYPH_FORMAT_OUTLINE: { FT_Outline* outline = &fFace->glyph->outline; FT_BBox bbox; FT_Bitmap target; if ((fRec.fFlags & kEmbolden_Flag) && !(fFace->style_flags & FT_STYLE_FLAG_BOLD)) { emboldenOutline(outline); } int dx = 0, dy = 0; if (fRec.fFlags & SkScalerContext::kSubpixelPositioning_Flag) { dx = glyph.getSubXFixed() >> 10; dy = glyph.getSubYFixed() >> 10; // negate dy since freetype-y-goes-up and skia-y-goes-down dy = -dy; } FT_Outline_Get_CBox(outline, &bbox); /* what we really want to do for subpixel is offset(dx, dy) compute_bounds offset(bbox & !63) but that is two calls to offset, so we do the following, which achieves the same thing with only one offset call. */ FT_Outline_Translate(outline, dx - ((bbox.xMin + dx) & ~63), dy - ((bbox.yMin + dy) & ~63)); if (SkMask::kLCD16_Format == glyph.fMaskFormat) { FT_Render_Glyph(fFace->glyph, FT_RENDER_MODE_LCD); copyFT2LCD16(glyph, fFace->glyph->bitmap, fRec.fFlags & SkScalerContext::kLCD_BGROrder_Flag, tableR, tableG, tableB); } else { target.width = glyph.fWidth; target.rows = glyph.fHeight; target.pitch = glyph.rowBytes(); target.buffer = reinterpret_cast(glyph.fImage); target.pixel_mode = compute_pixel_mode( (SkMask::Format)fRec.fMaskFormat); target.num_grays = 256; memset(glyph.fImage, 0, glyph.rowBytes() * glyph.fHeight); FT_Outline_Get_Bitmap(gFTLibrary, outline, &target); } } break; case FT_GLYPH_FORMAT_BITMAP: { if ((fRec.fFlags & kEmbolden_Flag) && !(fFace->style_flags & FT_STYLE_FLAG_BOLD)) { FT_GlyphSlot_Own_Bitmap(fFace->glyph); FT_Bitmap_Embolden(gFTLibrary, &fFace->glyph->bitmap, kBitmapEmboldenStrength, 0); } SkASSERT_CONTINUE(glyph.fWidth == fFace->glyph->bitmap.width); SkASSERT_CONTINUE(glyph.fHeight == fFace->glyph->bitmap.rows); SkASSERT_CONTINUE(glyph.fTop == -fFace->glyph->bitmap_top); SkASSERT_CONTINUE(glyph.fLeft == fFace->glyph->bitmap_left); const uint8_t* src = (const uint8_t*)fFace->glyph->bitmap.buffer; uint8_t* dst = (uint8_t*)glyph.fImage; if (fFace->glyph->bitmap.pixel_mode == FT_PIXEL_MODE_GRAY || (fFace->glyph->bitmap.pixel_mode == FT_PIXEL_MODE_MONO && glyph.fMaskFormat == SkMask::kBW_Format)) { unsigned srcRowBytes = fFace->glyph->bitmap.pitch; unsigned dstRowBytes = glyph.rowBytes(); unsigned minRowBytes = SkMin32(srcRowBytes, dstRowBytes); unsigned extraRowBytes = dstRowBytes - minRowBytes; for (int y = fFace->glyph->bitmap.rows - 1; y >= 0; --y) { memcpy(dst, src, minRowBytes); memset(dst + minRowBytes, 0, extraRowBytes); src += srcRowBytes; dst += dstRowBytes; } } else if (fFace->glyph->bitmap.pixel_mode == FT_PIXEL_MODE_MONO && glyph.fMaskFormat == SkMask::kA8_Format) { for (int y = 0; y < fFace->glyph->bitmap.rows; ++y) { uint8_t byte = 0; int bits = 0; const uint8_t* src_row = src; uint8_t* dst_row = dst; for (int x = 0; x < fFace->glyph->bitmap.width; ++x) { if (!bits) { byte = *src_row++; bits = 8; } *dst_row++ = byte & 0x80 ? 0xff : 0; bits--; byte <<= 1; } src += fFace->glyph->bitmap.pitch; dst += glyph.rowBytes(); } } else if (SkMask::kLCD16_Format == glyph.fMaskFormat) { copyFT2LCD16(glyph, fFace->glyph->bitmap, fRec.fFlags & SkScalerContext::kLCD_BGROrder_Flag, tableR, tableG, tableB); } else { SkDEBUGFAIL("unknown glyph bitmap transform needed"); } } break; default: SkDEBUGFAIL("unknown glyph format"); goto ERROR; } // We used to always do this pre-USE_COLOR_LUMINANCE, but with colorlum, // it is optional #if defined(SK_GAMMA_APPLY_TO_A8) || !defined(SK_USE_COLOR_LUMINANCE) if (SkMask::kA8_Format == glyph.fMaskFormat) { SkASSERT(tableR == tableG && tableR == tableB); const uint8_t* table = tableR; uint8_t* SK_RESTRICT dst = (uint8_t*)glyph.fImage; unsigned rowBytes = glyph.rowBytes(); for (int y = glyph.fHeight - 1; y >= 0; --y) { for (int x = glyph.fWidth - 1; x >= 0; --x) { dst[x] = table[dst[x]]; } dst += rowBytes; } } #endif } /////////////////////////////////////////////////////////////////////////////// #define ft2sk(x) SkFixedToScalar((x) << 10) #if FREETYPE_MAJOR >= 2 && FREETYPE_MINOR >= 2 #define CONST_PARAM const #else // older freetype doesn't use const here #define CONST_PARAM #endif static int move_proc(CONST_PARAM FT_Vector* pt, void* ctx) { SkPath* path = (SkPath*)ctx; path->close(); // to close the previous contour (if any) path->moveTo(ft2sk(pt->x), -ft2sk(pt->y)); return 0; } static int line_proc(CONST_PARAM FT_Vector* pt, void* ctx) { SkPath* path = (SkPath*)ctx; path->lineTo(ft2sk(pt->x), -ft2sk(pt->y)); return 0; } static int quad_proc(CONST_PARAM FT_Vector* pt0, CONST_PARAM FT_Vector* pt1, void* ctx) { SkPath* path = (SkPath*)ctx; path->quadTo(ft2sk(pt0->x), -ft2sk(pt0->y), ft2sk(pt1->x), -ft2sk(pt1->y)); return 0; } static int cubic_proc(CONST_PARAM FT_Vector* pt0, CONST_PARAM FT_Vector* pt1, CONST_PARAM FT_Vector* pt2, void* ctx) { SkPath* path = (SkPath*)ctx; path->cubicTo(ft2sk(pt0->x), -ft2sk(pt0->y), ft2sk(pt1->x), -ft2sk(pt1->y), ft2sk(pt2->x), -ft2sk(pt2->y)); return 0; } void SkScalerContext_FreeType::generatePath(const SkGlyph& glyph, SkPath* path) { SkAutoMutexAcquire ac(gFTMutex); SkASSERT(&glyph && path); if (this->setupSize()) { path->reset(); return; } uint32_t flags = fLoadGlyphFlags; flags |= FT_LOAD_NO_BITMAP; // ignore embedded bitmaps so we're sure to get the outline flags &= ~FT_LOAD_RENDER; // don't scan convert (we just want the outline) FT_Error err = FT_Load_Glyph( fFace, glyph.getGlyphID(fBaseGlyphCount), flags); if (err != 0) { SkDEBUGF(("SkScalerContext_FreeType::generatePath: FT_Load_Glyph(glyph:%d flags:%d) returned 0x%x\n", glyph.getGlyphID(fBaseGlyphCount), flags, err)); path->reset(); return; } if ((fRec.fFlags & kEmbolden_Flag) && !(fFace->style_flags & FT_STYLE_FLAG_BOLD)) { emboldenOutline(&fFace->glyph->outline); } FT_Outline_Funcs funcs; funcs.move_to = move_proc; funcs.line_to = line_proc; funcs.conic_to = quad_proc; funcs.cubic_to = cubic_proc; funcs.shift = 0; funcs.delta = 0; err = FT_Outline_Decompose(&fFace->glyph->outline, &funcs, path); if (err != 0) { SkDEBUGF(("SkScalerContext_FreeType::generatePath: FT_Load_Glyph(glyph:%d flags:%d) returned 0x%x\n", glyph.getGlyphID(fBaseGlyphCount), flags, err)); path->reset(); return; } path->close(); } void SkScalerContext_FreeType::generateFontMetrics(SkPaint::FontMetrics* mx, SkPaint::FontMetrics* my) { if (NULL == mx && NULL == my) { return; } SkAutoMutexAcquire ac(gFTMutex); if (this->setupSize()) { ERROR: if (mx) { sk_bzero(mx, sizeof(SkPaint::FontMetrics)); } if (my) { sk_bzero(my, sizeof(SkPaint::FontMetrics)); } return; } FT_Face face = fFace; int upem = face->units_per_EM; if (upem <= 0) { goto ERROR; } SkPoint pts[6]; SkFixed ys[6]; SkFixed scaleY = fScaleY; SkFixed mxy = fMatrix22.xy; SkFixed myy = fMatrix22.yy; SkScalar xmin = SkIntToScalar(face->bbox.xMin) / upem; SkScalar xmax = SkIntToScalar(face->bbox.xMax) / upem; int leading = face->height - (face->ascender + -face->descender); if (leading < 0) { leading = 0; } // Try to get the OS/2 table from the font. This contains the specific // average font width metrics which Windows uses. TT_OS2* os2 = (TT_OS2*) FT_Get_Sfnt_Table(face, ft_sfnt_os2); ys[0] = -face->bbox.yMax; ys[1] = -face->ascender; ys[2] = -face->descender; ys[3] = -face->bbox.yMin; ys[4] = leading; ys[5] = os2 ? os2->xAvgCharWidth : 0; SkScalar x_height; if (os2 && os2->sxHeight) { x_height = SkFixedToScalar(SkMulDiv(fScaleX, os2->sxHeight, upem)); } else { const FT_UInt x_glyph = FT_Get_Char_Index(fFace, 'x'); if (x_glyph) { FT_BBox bbox; FT_Load_Glyph(fFace, x_glyph, fLoadGlyphFlags); if ((fRec.fFlags & kEmbolden_Flag) && !(fFace->style_flags & FT_STYLE_FLAG_BOLD)) { emboldenOutline(&fFace->glyph->outline); } FT_Outline_Get_CBox(&fFace->glyph->outline, &bbox); x_height = SkFixedToScalar(SkFDot6ToFixed(bbox.yMax)); } else { x_height = 0; } } // convert upem-y values into scalar points for (int i = 0; i < 6; i++) { SkFixed y = SkMulDiv(scaleY, ys[i], upem); SkFixed x = SkFixedMul(mxy, y); y = SkFixedMul(myy, y); pts[i].set(SkFixedToScalar(x), SkFixedToScalar(y)); } if (mx) { mx->fTop = pts[0].fX; mx->fAscent = pts[1].fX; mx->fDescent = pts[2].fX; mx->fBottom = pts[3].fX; mx->fLeading = pts[4].fX; mx->fAvgCharWidth = pts[5].fX; mx->fXMin = xmin; mx->fXMax = xmax; mx->fXHeight = x_height; } if (my) { my->fTop = pts[0].fY; my->fAscent = pts[1].fY; my->fDescent = pts[2].fY; my->fBottom = pts[3].fY; my->fLeading = pts[4].fY; my->fAvgCharWidth = pts[5].fY; my->fXMin = xmin; my->fXMax = xmax; my->fXHeight = x_height; } } //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// SkScalerContext* SkFontHost::CreateScalerContext(const SkDescriptor* desc) { SkScalerContext_FreeType* c = SkNEW_ARGS(SkScalerContext_FreeType, (desc)); if (!c->success()) { SkDELETE(c); c = NULL; } return c; } /////////////////////////////////////////////////////////////////////////////// /* Export this so that other parts of our FonttHost port can make use of our ability to extract the name+style from a stream, using FreeType's api. */ bool find_name_and_attributes(SkStream* stream, SkString* name, SkTypeface::Style* style, bool* isFixedWidth) { FT_Library library; if (FT_Init_FreeType(&library)) { return false; } FT_Open_Args args; memset(&args, 0, sizeof(args)); const void* memoryBase = stream->getMemoryBase(); FT_StreamRec streamRec; if (NULL != memoryBase) { args.flags = FT_OPEN_MEMORY; args.memory_base = (const FT_Byte*)memoryBase; args.memory_size = stream->getLength(); } else { memset(&streamRec, 0, sizeof(streamRec)); streamRec.size = stream->read(NULL, 0); streamRec.descriptor.pointer = stream; streamRec.read = sk_stream_read; streamRec.close = sk_stream_close; args.flags = FT_OPEN_STREAM; args.stream = &streamRec; } FT_Face face; if (FT_Open_Face(library, &args, 0, &face)) { FT_Done_FreeType(library); return false; } int tempStyle = SkTypeface::kNormal; if (face->style_flags & FT_STYLE_FLAG_BOLD) { tempStyle |= SkTypeface::kBold; } if (face->style_flags & FT_STYLE_FLAG_ITALIC) { tempStyle |= SkTypeface::kItalic; } if (name) { name->set(face->family_name); } if (style) { *style = (SkTypeface::Style) tempStyle; } if (isFixedWidth) { *isFixedWidth = FT_IS_FIXED_WIDTH(face); } FT_Done_Face(face); FT_Done_FreeType(library); return true; }