summaryrefslogtreecommitdiffstats
path: root/skia/ports
diff options
context:
space:
mode:
Diffstat (limited to 'skia/ports')
-rw-r--r--skia/ports/SkFontHost_FONTPATH.cpp415
-rw-r--r--skia/ports/SkFontHost_FreeType.cpp894
-rw-r--r--skia/ports/SkFontHost_android.cpp633
-rw-r--r--skia/ports/SkFontHost_ascender.cpp211
-rw-r--r--skia/ports/SkFontHost_fontconfig.cpp375
-rw-r--r--skia/ports/SkFontHost_gamma.cpp118
-rw-r--r--skia/ports/SkFontHost_gamma_none.cpp35
-rw-r--r--skia/ports/SkFontHost_linux.cpp604
-rw-r--r--skia/ports/SkFontHost_mac.cpp562
-rw-r--r--skia/ports/SkFontHost_none.cpp82
-rw-r--r--skia/ports/SkFontHost_tables.cpp183
-rw-r--r--skia/ports/SkFontHost_win.cpp1202
-rw-r--r--skia/ports/SkGlobals_global.cpp28
-rw-r--r--skia/ports/SkImageDecoder_Factory.cpp135
-rw-r--r--skia/ports/SkImageRef_ashmem.cpp203
-rw-r--r--skia/ports/SkImageRef_ashmem.h35
-rw-r--r--skia/ports/SkOSEvent_android.cpp155
-rw-r--r--skia/ports/SkOSEvent_dummy.cpp28
-rw-r--r--skia/ports/SkOSFile_stdio.cpp106
-rw-r--r--skia/ports/SkThread_none.cpp49
-rw-r--r--skia/ports/SkThread_pthread.cpp90
-rw-r--r--skia/ports/SkThread_win.cpp64
-rw-r--r--skia/ports/SkTime_Unix.cpp50
-rw-r--r--skia/ports/SkXMLParser_empty.cpp36
-rw-r--r--skia/ports/SkXMLParser_expat.cpp149
-rw-r--r--skia/ports/SkXMLParser_tinyxml.cpp96
-rw-r--r--skia/ports/SkXMLPullParser_expat.cpp222
-rw-r--r--skia/ports/sk_predefined_gamma.h44
28 files changed, 0 insertions, 6804 deletions
diff --git a/skia/ports/SkFontHost_FONTPATH.cpp b/skia/ports/SkFontHost_FONTPATH.cpp
deleted file mode 100644
index 3cbccaf..0000000
--- a/skia/ports/SkFontHost_FONTPATH.cpp
+++ /dev/null
@@ -1,415 +0,0 @@
-/* libs/graphics/ports/SkFontHost_android.cpp
-**
-** Copyright 2006, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
-**
-** http://www.apache.org/licenses/LICENSE-2.0
-**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
-** limitations under the License.
-*/
-
-#include "SkFontHost.h"
-#include "SkDescriptor.h"
-#include "SkString.h"
-#include "SkStream.h"
-#include <stdio.h>
-
-/* define this if we can use mmap() to access fonts from the filesystem */
-#define SK_CAN_USE_MMAP
-
-#ifndef SK_FONTPATH
- #define SK_FONTPATH "the complete path for a font file"
-#endif
-
-struct FontFaceRec {
- const char* fFileName;
- uint8_t fFamilyIndex;
- SkBool8 fBold;
- SkBool8 fItalic;
-
- static const FontFaceRec& FindFace(const FontFaceRec rec[], int count, int isBold, int isItalic);
-};
-
-struct FontFamilyRec {
- const FontFaceRec* fFaces;
- int fFaceCount;
-};
-
-const FontFaceRec& FontFaceRec::FindFace(const FontFaceRec rec[], int count, int isBold, int isItalic)
-{
- SkASSERT(count > 0);
-
- int i;
-
- // look for an exact match
- for (i = 0; i < count; i++) {
- if (rec[i].fBold == isBold && rec[i].fItalic == isItalic)
- return rec[i];
- }
- // look for a match in the bold field
- for (i = 0; i < count; i++) {
- if (rec[i].fBold == isBold)
- return rec[i];
- }
- // look for a normal/regular face
- for (i = 0; i < count; i++) {
- if (!rec[i].fBold && !rec[i].fItalic)
- return rec[i];
- }
- // give up
- return rec[0];
-}
-
-enum {
- DEFAULT_FAMILY_INDEX,
-
- FAMILY_INDEX_COUNT
-};
-
-static const FontFaceRec gDefaultFaces[] = {
- { SK_FONTPATH, DEFAULT_FAMILY_INDEX, 0, 0 }
-};
-
-// This table must be in the same order as the ..._FAMILY_INDEX enum specifies
-static const FontFamilyRec gFamilies[] = {
- { gDefaultFaces, SK_ARRAY_COUNT(gDefaultFaces) }
-};
-
-#define DEFAULT_FAMILY_INDEX DEFAULT_FAMILY_INDEX
-#define DEFAULT_FAMILY_FACE_INDEX 0
-
-////////////////////////////////////////////////////////////////////////////////////////
-
-/* map common "web" font names to our font list */
-
-struct FontFamilyMatchRec {
- const char* fLCName;
- int fFamilyIndex;
-};
-
-/* This is a table of synonyms for collapsing font names
- down to their pseudo-equivalents (i.e. in terms of fonts
- we actually have.)
- Keep this sorted by the first field so we can do a binary search.
- If this gets big, we could switch to a hash...
-*/
-static const FontFamilyMatchRec gMatches[] = {
-#if 0
- { "Ahem", Ahem_FAMILY_INDEX },
- { "arial", SANS_FAMILY_INDEX },
- { "courier", MONO_FAMILY_INDEX },
- { "courier new", MONO_FAMILY_INDEX },
- { "cursive", SERIF_FAMILY_INDEX },
- { "fantasy", SERIF_FAMILY_INDEX },
- { "georgia", SERIF_FAMILY_INDEX },
- { "goudy", SERIF_FAMILY_INDEX },
- { "helvetica", SANS_FAMILY_INDEX },
- { "palatino", SERIF_FAMILY_INDEX },
- { "tahoma", SANS_FAMILY_INDEX },
- { "sans-serif", SANS_FAMILY_INDEX },
- { "serif", SERIF_FAMILY_INDEX },
- { "times", SERIF_FAMILY_INDEX },
- { "times new roman", SERIF_FAMILY_INDEX },
- { "verdana", SANS_FAMILY_INDEX }
-#endif
-};
-
-////////////////////////////////////////////////////////////////////////////////////////
-
-#include "SkTSearch.h"
-
-static bool contains_only_ascii(const char s[])
-{
- for (;;)
- {
- int c = *s++;
- if (c == 0)
- break;
- if ((c >> 7) != 0)
- return false;
- }
- return true;
-}
-
-#define TRACE_FONT_NAME(code)
-//#define TRACE_FONT_NAME(code) code
-
-const FontFamilyRec* find_family_rec(const char target[])
-{
- int index;
-
- // If we're asked for a font name that contains non-ascii,
- // 1) SkStrLCSearch can't handle it
- // 2) All of our fonts are have ascii names, so...
-
-TRACE_FONT_NAME(printf("----------------- font request <%s>", target);)
-
- if (contains_only_ascii(target))
- {
- // Search for the font by matching the entire name
- index = SkStrLCSearch(&gMatches[0].fLCName, SK_ARRAY_COUNT(gMatches), target, sizeof(gMatches[0]));
- if (index >= 0)
- {
- TRACE_FONT_NAME(printf(" found %d\n", index);)
- return &gFamilies[gMatches[index].fFamilyIndex];
- }
- }
-
- // Sniff for key words...
-
-#if 0
- if (strstr(target, "sans") || strstr(target, "Sans"))
- {
- TRACE_FONT_NAME(printf(" found sans\n");)
- return &gFamilies[SANS_FAMILY_INDEX];
- }
- if (strstr(target, "serif") || strstr(target, "Serif"))
- {
- TRACE_FONT_NAME(printf(" found serif\n");)
- return &gFamilies[SERIF_FAMILY_INDEX];
- }
- if (strstr(target, "mono") || strstr(target, "Mono"))
- {
- TRACE_FONT_NAME(printf(" found mono\n");)
- return &gFamilies[MONO_FAMILY_INDEX];
- }
-#endif
-
- TRACE_FONT_NAME(printf(" use default\n");)
- // we give up, just give them the default font
- return &gFamilies[DEFAULT_FAMILY_INDEX];
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////
-
-static const FontFaceRec* get_default_face()
-{
- return &gFamilies[DEFAULT_FAMILY_INDEX].fFaces[DEFAULT_FAMILY_FACE_INDEX];
-}
-
-class FontFaceRec_Typeface : public SkTypeface {
-public:
- FontFaceRec_Typeface(const FontFaceRec& face) : fFace(face)
- {
- int style = 0;
- if (face.fBold)
- style |= SkTypeface::kBold;
- if (face.fItalic)
- style |= SkTypeface::kItalic;
- this->setStyle((SkTypeface::Style)style);
- }
-
- // This global const reference completely identifies the face
- const FontFaceRec& fFace;
-};
-
-static const FontFaceRec* get_typeface_rec(const SkTypeface* face)
-{
- const FontFaceRec_Typeface* f = (FontFaceRec_Typeface*)face;
- return f ? &f->fFace : get_default_face();
-}
-
-static uint32_t ptr2uint32(const void* p)
-{
- // cast so we avoid warnings on 64bit machines that a ptr difference
- // which might be 64bits is being trucated from 64 to 32
- return (uint32_t)((char*)p - (char*)0);
-}
-
-uint32_t SkFontHost::TypefaceHash(const SkTypeface* face)
-{
- // just use our address as the hash value
- return ptr2uint32(get_typeface_rec(face));
-}
-
-bool SkFontHost::TypefaceEqual(const SkTypeface* facea, const SkTypeface* faceb)
-{
- return get_typeface_rec(facea) == get_typeface_rec(faceb);
-}
-
-SkTypeface* SkFontHost::CreateTypeface(const SkTypeface* familyFace, const char familyName[], SkTypeface::Style style)
-{
- const FontFamilyRec* family;
-
- if (familyFace)
- family = &gFamilies[((FontFaceRec_Typeface*)familyFace)->fFace.fFamilyIndex];
- else if (familyName)
- family = find_family_rec(familyName);
- else
- family = &gFamilies[DEFAULT_FAMILY_INDEX];
-
- const FontFaceRec& face = FontFaceRec::FindFace(family->fFaces, family->fFaceCount,
- (style & SkTypeface::kBold) != 0,
- (style & SkTypeface::kItalic) != 0);
-
- // if we're returning our input parameter, no need to create a new instance
- if (familyFace != NULL && &((FontFaceRec_Typeface*)familyFace)->fFace == &face)
- {
- familyFace->ref();
- return (SkTypeface*)familyFace;
- }
- return SkNEW_ARGS(FontFaceRec_Typeface, (face));
-}
-
-uint32_t SkFontHost::FlattenTypeface(const SkTypeface* tface, void* buffer)
-{
- const FontFaceRec* face;
-
- if (tface)
- face = &((const FontFaceRec_Typeface*)tface)->fFace;
- else
- face = get_default_face();
-
- size_t size = sizeof(face);
- if (buffer)
- memcpy(buffer, &face, size);
- return size;
-}
-
-void SkFontHost::GetDescriptorKeyString(const SkDescriptor* desc, SkString* key)
-{
- key->set(SK_FONTPATH);
-}
-
-#ifdef SK_CAN_USE_MMAP
-#include <unistd.h>
-#include <sys/mman.h>
-#include <fcntl.h>
-#include <errno.h>
-
-class SkMMAPStream : public SkMemoryStream {
-public:
- SkMMAPStream(const char filename[]);
- virtual ~SkMMAPStream();
-
- virtual void setMemory(const void* data, size_t length);
-private:
- int fFildes;
- void* fAddr;
- size_t fSize;
-
- void closeMMap();
-
- typedef SkMemoryStream INHERITED;
-};
-
-SkMMAPStream::SkMMAPStream(const char filename[])
-{
- fFildes = -1; // initialize to failure case
-
- int fildes = open(filename, O_RDONLY);
- if (fildes < 0)
- {
- SkDEBUGF(("---- failed to open(%s) for mmap stream error=%d\n", filename, errno));
- return;
- }
-
- off_t size = lseek(fildes, 0, SEEK_END); // find the file size
- if (size == -1)
- {
- SkDEBUGF(("---- failed to lseek(%s) for mmap stream error=%d\n", filename, errno));
- close(fildes);
- return;
- }
- (void)lseek(fildes, 0, SEEK_SET); // restore file offset to beginning
-
- void* addr = mmap(NULL, size, PROT_READ, MAP_SHARED, fildes, 0);
- if (MAP_FAILED == addr)
- {
- SkDEBUGF(("---- failed to mmap(%s) for mmap stream error=%d\n", filename, errno));
- close(fildes);
- return;
- }
-
- this->INHERITED::setMemory(addr, size);
-
- fFildes = fildes;
- fAddr = addr;
- fSize = size;
-}
-
-SkMMAPStream::~SkMMAPStream()
-{
- this->closeMMap();
-}
-
-void SkMMAPStream::setMemory(const void* data, size_t length)
-{
- this->closeMMap();
- this->INHERITED::setMemory(data, length);
-}
-
-void SkMMAPStream::closeMMap()
-{
- if (fFildes >= 0)
- {
- munmap(fAddr, fSize);
- close(fFildes);
- fFildes = -1;
- }
-}
-
-#endif
-
-SkStream* SkFontHost::OpenDescriptorStream(const SkDescriptor* desc, const char keyString[])
-{
- // our key string IS our filename, so we can ignore desc
- SkStream* strm;
-
-#ifdef SK_CAN_USE_MMAP
- strm = new SkMMAPStream(keyString);
- if (strm->getLength() > 0)
- return strm;
-
- // strm not valid
- delete strm;
- // fall through to FILEStream attempt
-#endif
-
- strm = new SkFILEStream(keyString);
- if (strm->getLength() > 0)
- return strm;
-
- // strm not valid
- delete strm;
- return NULL;
-}
-
-SkScalerContext* SkFontHost::CreateFallbackScalerContext(const SkScalerContext::Rec& rec)
-{
- const FontFaceRec* face = get_default_face();
-
- SkAutoDescriptor ad(sizeof(rec) + sizeof(face) + SkDescriptor::ComputeOverhead(2));
- SkDescriptor* desc = ad.getDesc();
-
- desc->init();
- desc->addEntry(kRec_SkDescriptorTag, sizeof(rec), &rec);
- desc->addEntry(kTypeface_SkDescriptorTag, sizeof(face), &face);
- desc->computeChecksum();
-
- return SkFontHost::CreateScalerContext(desc);
-}
-
-size_t SkFontHost::ShouldPurgeFontCache(size_t sizeAllocatedSoFar)
-{
- return 0; // nothing to do (change me if you want to limit the font cache)
-}
-
-int SkFontHost::ComputeGammaFlag(const SkPaint& paint)
-{
- return 0;
-}
-
-void SkFontHost::GetGammaTables(const uint8_t* tables[2])
-{
- tables[0] = NULL; // black gamma (e.g. exp=1.4)
- tables[1] = NULL; // white gamma (e.g. exp= 1/1.4)
-}
-
diff --git a/skia/ports/SkFontHost_FreeType.cpp b/skia/ports/SkFontHost_FreeType.cpp
deleted file mode 100644
index 86efee1..0000000
--- a/skia/ports/SkFontHost_FreeType.cpp
+++ /dev/null
@@ -1,894 +0,0 @@
-/* libs/graphics/ports/SkFontHost_FreeType.cpp
-**
-** Copyright 2006, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
-**
-** http://www.apache.org/licenses/LICENSE-2.0
-**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
-** limitations under the License.
-*/
-
-#include "SkScalerContext.h"
-#include "SkBitmap.h"
-#include "SkCanvas.h"
-#include "SkDescriptor.h"
-#include "SkFDot6.h"
-#include "SkFontHost.h"
-#include "SkMask.h"
-#include "SkStream.h"
-#include "SkString.h"
-#include "SkThread.h"
-#include "SkTemplates.h"
-
-#include <ft2build.h>
-#include FT_FREETYPE_H
-#include FT_OUTLINE_H
-#include FT_SIZES_H
-#include FT_TRUETYPE_TABLES_H
-#ifdef FT_ADVANCES_H
-#include FT_ADVANCES_H
-#endif
-
-#if 0
-// Also include the files by name for build tools which require this.
-#include <freetype/freetype.h>
-#include <freetype/ftoutln.h>
-#include <freetype/ftsizes.h>
-#include <freetype/tttables.h>
-#include <freetype/ftadvanc.h>
-#endif
-
-//#define ENABLE_GLYPH_SPEW // for tracing calls
-//#define DUMP_STRIKE_CREATION
-
-#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
-
-//////////////////////////////////////////////////////////////////////////
-
-struct SkFaceRec;
-
-static SkMutex gFTMutex;
-static int gFTCount;
-static FT_Library gFTLibrary;
-static SkFaceRec* gFaceRecHead;
-
-/////////////////////////////////////////////////////////////////////////
-
-class SkScalerContext_FreeType : public SkScalerContext {
-public:
- SkScalerContext_FreeType(const SkDescriptor* desc);
- virtual ~SkScalerContext_FreeType();
-
- bool success() const {
- return fFaceRec != NULL && fFTSize != NULL;
- }
-
-protected:
- virtual unsigned generateGlyphCount() const;
- 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);
-
-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;
-
- FT_Error setupSize();
-};
-
-///////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////
-
-#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));
-
- 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;
- }
-
- FT_Error err = FT_Open_Face(gFTLibrary, &args, 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;
- }
- SkASSERT("shouldn't get here, face not in list");
-}
-
-///////////////////////////////////////////////////////////////////////////
-
-SkScalerContext_FreeType::SkScalerContext_FreeType(const SkDescriptor* desc)
- : SkScalerContext(desc) {
- SkAutoMutexAcquire ac(gFTMutex);
-
- FT_Error err;
-
- if (gFTCount == 0) {
- err = FT_Init_FreeType(&gFTLibrary);
-// SkDEBUGF(("FT_Init_FreeType returned %d\n", err));
- SkASSERT(err == 0);
- }
- ++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.fHints, 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
- {
- uint32_t flags = FT_LOAD_DEFAULT;
- uint32_t render_flags = FT_LOAD_TARGET_NORMAL;
-
- // we force autohinting at the moment
-
- switch (fRec.fHints) {
- case kNo_Hints:
- flags |= FT_LOAD_NO_HINTING;
- break;
- case kSubpixel_Hints:
- flags |= FT_LOAD_FORCE_AUTOHINT;
- render_flags = FT_LOAD_TARGET_LIGHT;
- break;
- case kNormal_Hints:
-#ifdef ANDROID
- // The following line disables the font's hinting tables. For
- // Chromium we want font hinting on so that we can generate
- // baselines that look at little like Firefox. It's expected that
- // Mike Reed will rework this code sometime soon so we don't wish
- // to make more extensive changes.
- flags |= FT_LOAD_FORCE_AUTOHINT;
- /* Switch to light hinting (vertical only) to address some chars
- that behaved poorly with NORMAL. In the future we could consider
- making this choice exposed at runtime to the caller.
- */
- render_flags = FT_LOAD_TARGET_LIGHT;
-#endif
- break;
- }
-
- if (SkMask::kBW_Format == fRec.fMaskFormat)
- render_flags = FT_LOAD_TARGET_MONO;
- else if (SkMask::kLCD_Format == fRec.fMaskFormat)
- render_flags = FT_LOAD_TARGET_LCD;
-
- fLoadGlyphFlags = flags | render_flags;
- }
-
- // 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() {
- if (SkFontHost::ResolveTypeface(fRec.fFontID) == NULL) {
- return (FT_Error)-1;
- }
-
- 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;
-}
-
-unsigned SkScalerContext_FreeType::generateGlyphCount() const {
- return fFace->num_glyphs;
-}
-
-uint16_t SkScalerContext_FreeType::generateCharToGlyph(SkUnichar uni) {
- return SkToU16(FT_Get_Char_Index( fFace, uni ));
-}
-
-static FT_Pixel_Mode compute_pixel_mode(SkMask::Format format) {
- switch (format) {
- case SkMask::kBW_Format:
- return FT_PIXEL_MODE_MONO;
- case SkMask::kLCD_Format:
- return FT_PIXEL_MODE_LCD;
- 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...
- */
- {
- 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 = advance; // advance *2/3; //DEBUG
- glyph->fAdvanceY = 0;
- return;
- }
- }
-#endif /* FT_ADVANCES_H */
- /* otherwise, we need to load/hint the glyph, which is slower */
- this->generateMetrics(glyph);
- return;
-}
-
-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;
- }
-
- switch ( fFace->glyph->format ) {
- case FT_GLYPH_FORMAT_OUTLINE:
- FT_BBox bbox;
-
- FT_Outline_Get_CBox(&fFace->glyph->outline, &bbox);
-
- if (kSubpixel_Hints == fRec.fHints) {
- int dx = glyph->getSubXFixed() >> 10;
- int dy = glyph->getSubYFixed() >> 10;
- // negate dy since freetype-y-goes-up and skia-y-goes-down
- bbox.xMin += dx;
- bbox.yMin -= dy;
- bbox.xMax += dx;
- bbox.yMax -= dy;
- }
-
- bbox.xMin &= ~63;
- bbox.yMin &= ~63;
- bbox.xMax = (bbox.xMax + 63) & ~63;
- bbox.yMax = (bbox.yMax + 63) & ~63;
-
- 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);
- break;
-
- case FT_GLYPH_FORMAT_BITMAP:
- 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:
- SkASSERT(!"unknown glyph format");
- goto ERROR;
- }
-
- if (kNormal_Hints == fRec.fHints) {
- 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);
- }
- } else {
- glyph->fAdvanceX = SkFixedMul(fMatrix22.xx, fFace->glyph->linearHoriAdvance);
- glyph->fAdvanceY = -SkFixedMul(fMatrix22.yx, fFace->glyph->linearHoriAdvance);
- }
-
-#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
-}
-
-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;
- }
-
- switch ( fFace->glyph->format ) {
- case FT_GLYPH_FORMAT_OUTLINE: {
- FT_Outline* outline = &fFace->glyph->outline;
- FT_BBox bbox;
- FT_Bitmap target;
-
- int dx = 0, dy = 0;
- if (kSubpixel_Hints == fRec.fHints) {
- 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));
-
- target.width = glyph.fWidth;
- target.rows = glyph.fHeight;
- target.pitch = glyph.rowBytes();
- target.buffer = reinterpret_cast<uint8_t*>(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: {
- 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) {
- 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) {
- 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();
- }
- }
- } break;
-
- default:
- SkASSERT(!"unknown glyph format");
- goto ERROR;
- }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-#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;
- }
-
- 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()) {
- if (mx) {
- bzero(mx, sizeof(SkPaint::FontMetrics));
- }
- if (my) {
- bzero(my, sizeof(SkPaint::FontMetrics));
- }
- return;
- }
-
- SkPoint pts[6];
- SkFixed ys[6];
- FT_Face face = fFace;
- int upem = face->units_per_EM;
- 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);
- FT_Outline_Get_CBox(&fFace->glyph->outline, &bbox);
- x_height = SkIntToScalar(bbox.yMax) / 64;
- } 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.
-*/
-SkTypeface::Style find_name_and_style(SkStream* stream, SkString* name) {
- FT_Library library;
- if (FT_Init_FreeType(&library)) {
- name->set(NULL);
- return SkTypeface::kNormal;
- }
-
- 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);
- name->set(NULL);
- return SkTypeface::kNormal;
- }
-
- name->set(face->family_name);
- int style = SkTypeface::kNormal;
-
- if (face->style_flags & FT_STYLE_FLAG_BOLD) {
- style |= SkTypeface::kBold;
- }
- if (face->style_flags & FT_STYLE_FLAG_ITALIC) {
- style |= SkTypeface::kItalic;
- }
-
- FT_Done_Face(face);
- FT_Done_FreeType(library);
- return (SkTypeface::Style)style;
-}
-
diff --git a/skia/ports/SkFontHost_android.cpp b/skia/ports/SkFontHost_android.cpp
deleted file mode 100644
index 665c788..0000000
--- a/skia/ports/SkFontHost_android.cpp
+++ /dev/null
@@ -1,633 +0,0 @@
-/* libs/graphics/ports/SkFontHost_android.cpp
-**
-** Copyright 2006, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
-**
-** http://www.apache.org/licenses/LICENSE-2.0
-**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
-** limitations under the License.
-*/
-
-#include "SkFontHost.h"
-#include "SkDescriptor.h"
-#include "SkMMapStream.h"
-#include "SkPaint.h"
-#include "SkString.h"
-#include "SkStream.h"
-#include "SkThread.h"
-#include "SkTSearch.h"
-#include <stdio.h>
-
-#define FONT_CACHE_MEMORY_BUDGET (768 * 1024)
-
-#ifndef SK_FONT_FILE_PREFIX
- #define SK_FONT_FILE_PREFIX "/fonts/"
-#endif
-
-SkTypeface::Style find_name_and_style(SkStream* stream, SkString* name);
-
-static void GetFullPathForSysFonts(SkString* full, const char name[])
-{
- full->set(getenv("ANDROID_ROOT"));
- full->append(SK_FONT_FILE_PREFIX);
- full->append(name);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-struct FamilyRec;
-
-/* This guy holds a mapping of a name -> family, used for looking up fonts.
- Since it is stored in a stretchy array that doesn't preserve object
- semantics, we don't use constructor/destructors, but just have explicit
- helpers to manage our internal bookkeeping.
-*/
-struct NameFamilyPair {
- const char* fName; // we own this
- FamilyRec* fFamily; // we don't own this, we just reference it
-
- void construct(const char name[], FamilyRec* family)
- {
- fName = strdup(name);
- fFamily = family; // we don't own this, so just record the referene
- }
- void destruct()
- {
- free((char*)fName);
- // we don't own family, so just ignore our reference
- }
-};
-
-// we use atomic_inc to grow this for each typeface we create
-static int32_t gUniqueFontID;
-
-// this is the mutex that protects these globals
-static SkMutex gFamilyMutex;
-static FamilyRec* gFamilyHead;
-static SkTDArray<NameFamilyPair> gNameList;
-
-struct FamilyRec {
- FamilyRec* fNext;
- SkTypeface* fFaces[4];
-
- FamilyRec()
- {
- fNext = gFamilyHead;
- memset(fFaces, 0, sizeof(fFaces));
- gFamilyHead = this;
- }
-};
-
-static SkTypeface* find_best_face(const FamilyRec* family,
- SkTypeface::Style style)
-{
- SkTypeface* const* faces = family->fFaces;
-
- if (faces[style] != NULL) { // exact match
- return faces[style];
- }
- // look for a matching bold
- style = (SkTypeface::Style)(style ^ SkTypeface::kItalic);
- if (faces[style] != NULL) {
- return faces[style];
- }
- // look for the plain
- if (faces[SkTypeface::kNormal] != NULL) {
- return faces[SkTypeface::kNormal];
- }
- // look for anything
- for (int i = 0; i < 4; i++) {
- if (faces[i] != NULL) {
- return faces[i];
- }
- }
- // should never get here, since the faces list should not be empty
- SkASSERT(!"faces list is empty");
- return NULL;
-}
-
-static FamilyRec* find_family(const SkTypeface* member)
-{
- FamilyRec* curr = gFamilyHead;
- while (curr != NULL) {
- for (int i = 0; i < 4; i++) {
- if (curr->fFaces[i] == member) {
- return curr;
- }
- }
- curr = curr->fNext;
- }
- return NULL;
-}
-
-static SkTypeface* resolve_uniqueID(uint32_t uniqueID)
-{
- FamilyRec* curr = gFamilyHead;
- while (curr != NULL) {
- for (int i = 0; i < 4; i++) {
- SkTypeface* face = curr->fFaces[i];
- if (face != NULL && face->uniqueID() == uniqueID) {
- return face;
- }
- }
- curr = curr->fNext;
- }
- return NULL;
-}
-
-/* Remove reference to this face from its family. If the resulting family
- is empty (has no faces), return that family, otherwise return NULL
-*/
-static FamilyRec* remove_from_family(const SkTypeface* face)
-{
- FamilyRec* family = find_family(face);
- SkASSERT(family->fFaces[face->style()] == face);
- family->fFaces[face->style()] = NULL;
-
- for (int i = 0; i < 4; i++) {
- if (family->fFaces[i] != NULL) { // family is non-empty
- return NULL;
- }
- }
- return family; // return the empty family
-}
-
-// maybe we should make FamilyRec be doubly-linked
-static void detach_and_delete_family(FamilyRec* family)
-{
- FamilyRec* curr = gFamilyHead;
- FamilyRec* prev = NULL;
-
- while (curr != NULL) {
- FamilyRec* next = curr->fNext;
- if (curr == family) {
- if (prev == NULL) {
- gFamilyHead = next;
- } else {
- prev->fNext = next;
- }
- SkDELETE(family);
- return;
- }
- prev = curr;
- curr = next;
- }
- SkASSERT(!"Yikes, couldn't find family in our list to remove/delete");
-}
-
-static SkTypeface* find_typeface(const char name[], SkTypeface::Style style)
-{
- NameFamilyPair* list = gNameList.begin();
- int count = gNameList.count();
-
- int index = SkStrLCSearch(&list[0].fName, count, name, sizeof(list[0]));
-
- if (index >= 0) {
- return find_best_face(list[index].fFamily, style);
- }
- return NULL;
-}
-
-static SkTypeface* find_typeface(const SkTypeface* familyMember,
- SkTypeface::Style style)
-{
- const FamilyRec* family = find_family(familyMember);
- return family ? find_best_face(family, style) : NULL;
-}
-
-static void add_name(const char name[], FamilyRec* family)
-{
- SkAutoAsciiToLC tolc(name);
- name = tolc.lc();
-
- NameFamilyPair* list = gNameList.begin();
- int count = gNameList.count();
-
- int index = SkStrLCSearch(&list[0].fName, count, name, sizeof(list[0]));
-
- if (index < 0) {
- list = gNameList.insert(~index);
- list->construct(name, family);
- }
-}
-
-static void remove_from_names(FamilyRec* emptyFamily)
-{
-#ifdef SK_DEBUG
- for (int i = 0; i < 4; i++) {
- SkASSERT(emptyFamily->fFaces[i] == NULL);
- }
-#endif
-
- SkTDArray<NameFamilyPair>& list = gNameList;
-
- // must go backwards when removing
- for (int i = list.count() - 1; i >= 0; --i) {
- NameFamilyPair* pair = &list[i];
- if (pair->fFamily == emptyFamily) {
- pair->destruct();
- list.remove(i);
- }
- }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-class FamilyTypeface : public SkTypeface {
-public:
- FamilyTypeface(Style style, bool sysFont, SkTypeface* familyMember)
- : SkTypeface(style, sk_atomic_inc(&gUniqueFontID) + 1)
- {
- fIsSysFont = sysFont;
-
- SkAutoMutexAcquire ac(gFamilyMutex);
-
- FamilyRec* rec = NULL;
- if (familyMember) {
- rec = find_family(familyMember);
- SkASSERT(rec);
- } else {
- rec = SkNEW(FamilyRec);
- }
- rec->fFaces[style] = this;
- }
-
- virtual ~FamilyTypeface()
- {
- SkAutoMutexAcquire ac(gFamilyMutex);
-
- // remove us from our family. If the family is now empty, we return
- // that and then remove that family from the name list
- FamilyRec* family = remove_from_family(this);
- if (NULL != family) {
- remove_from_names(family);
- detach_and_delete_family(family);
- }
- }
-
- bool isSysFont() const { return fIsSysFont; }
-
- virtual SkStream* openStream() = 0;
- virtual void closeStream(SkStream*) = 0;
- virtual const char* getUniqueString() const = 0;
-
-private:
- bool fIsSysFont;
-
- typedef SkTypeface INHERITED;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-
-class StreamTypeface : public FamilyTypeface {
-public:
- StreamTypeface(Style style, bool sysFont, SkTypeface* familyMember,
- SkStream* stream)
- : INHERITED(style, sysFont, familyMember)
- {
- fStream = stream;
- }
- virtual ~StreamTypeface()
- {
- SkDELETE(fStream);
- }
-
- // overrides
- virtual SkStream* openStream() { return fStream; }
- virtual void closeStream(SkStream*) {}
- virtual const char* getUniqueString() const { return NULL; }
-
-private:
- SkStream* fStream;
-
- typedef FamilyTypeface INHERITED;
-};
-
-class FileTypeface : public FamilyTypeface {
-public:
- FileTypeface(Style style, bool sysFont, SkTypeface* familyMember,
- const char path[])
- : INHERITED(style, sysFont, familyMember)
- {
- SkString fullpath;
-
- if (sysFont) {
- GetFullPathForSysFonts(&fullpath, path);
- path = fullpath.c_str();
- }
- fPath.set(path);
- }
-
- // overrides
- virtual SkStream* openStream()
- {
- SkStream* stream = SkNEW_ARGS(SkMMAPStream, (fPath.c_str()));
-
- // check for failure
- if (stream->getLength() <= 0) {
- SkDELETE(stream);
- // maybe MMAP isn't supported. try FILE
- stream = SkNEW_ARGS(SkFILEStream, (fPath.c_str()));
- if (stream->getLength() <= 0) {
- SkDELETE(stream);
- stream = NULL;
- }
- }
- return stream;
- }
- virtual void closeStream(SkStream* stream)
- {
- SkDELETE(stream);
- }
- virtual const char* getUniqueString() const {
- const char* str = strrchr(fPath.c_str(), '/');
- if (str) {
- str += 1; // skip the '/'
- }
- return str;
- }
-
-private:
- SkString fPath;
-
- typedef FamilyTypeface INHERITED;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-
-static bool get_name_and_style(const char path[], SkString* name,
- SkTypeface::Style* style)
-{
- SkString fullpath;
- GetFullPathForSysFonts(&fullpath, path);
-
- SkMMAPStream stream(fullpath.c_str());
- if (stream.getLength() > 0) {
- *style = find_name_and_style(&stream, name);
- return true;
- }
- else {
- SkFILEStream stream(fullpath.c_str());
- if (stream.getLength() > 0) {
- *style = find_name_and_style(&stream, name);
- return true;
- }
- }
-
- SkDebugf("---- failed to open <%s> as a font\n", fullpath.c_str());
- return false;
-}
-
-struct FontInitRec {
- const char* fFileName;
- const char* const* fNames; // null-terminated list
-};
-
-static const char* gSansNames[] = {
- "sans-serif", "arial", "helvetica", "tahoma", "verdana", NULL
-};
-
-static const char* gSerifNames[] = {
- "serif", "times", "times new roman", "palatino", "georgia", "baskerville",
- "goudy", "fantasy", "cursive", "ITC Stone Serif", NULL
-};
-
-static const char* gMonoNames[] = {
- "monospace", "courier", "courier new", "monaco", NULL
-};
-
-static const char* gFBNames[] = { NULL };
-
-/* Fonts must be grouped by family, with the first font in a family having the
- list of names (even if that list is empty), and the following members having
- null for the list. The names list must be NULL-terminated
-*/
-static const FontInitRec gSystemFonts[] = {
- { "DroidSans.ttf", gSansNames },
- { "DroidSans-Bold.ttf", NULL },
- { "DroidSerif-Regular.ttf", gSerifNames },
- { "DroidSerif-Bold.ttf", NULL },
- { "DroidSerif-Italic.ttf", NULL },
- { "DroidSerif-BoldItalic.ttf", NULL },
- { "DroidSansMono.ttf", gMonoNames },
- { "DroidSansFallback.ttf", gFBNames }
-};
-
-#define DEFAULT_NAMES gSansNames
-
-// these globals are assigned (once) by load_system_fonts()
-static SkTypeface* gFallBackTypeface;
-static FamilyRec* gDefaultFamily;
-static SkTypeface* gDefaultNormal;
-
-static void load_system_fonts()
-{
- // check if we've already be called
- if (NULL != gDefaultNormal) {
- return;
- }
-
- const FontInitRec* rec = gSystemFonts;
- SkTypeface* firstInFamily = NULL;
-
- for (size_t i = 0; i < SK_ARRAY_COUNT(gSystemFonts); i++) {
- // if we're the first in a new family, clear firstInFamily
- if (rec[i].fNames != NULL) {
- firstInFamily = NULL;
- }
-
- SkString name;
- SkTypeface::Style style;
-
- if (!get_name_and_style(rec[i].fFileName, &name, &style)) {
- SkDebugf("------ can't load <%s> as a font\n", rec[i].fFileName);
- continue;
- }
-
- SkTypeface* tf = SkNEW_ARGS(FileTypeface,
- (style,
- true, // system-font (cannot delete)
- firstInFamily, // what family to join
- rec[i].fFileName) // filename
- );
-
- if (rec[i].fNames != NULL) {
- firstInFamily = tf;
- const char* const* names = rec[i].fNames;
-
- // record the fallback if this is it
- if (names == gFBNames) {
- gFallBackTypeface = tf;
- }
- // record the default family if this is it
- if (names == DEFAULT_NAMES) {
- gDefaultFamily = find_family(tf);
- }
- // add the names to map to this family
- FamilyRec* family = find_family(tf);
- while (*names) {
- add_name(*names, family);
- names += 1;
- }
- }
-
- }
-
- // do this after all fonts are loaded. This is our default font, and it
- // acts as a sentinel so we only execute load_system_fonts() once
- gDefaultNormal = find_best_face(gDefaultFamily, SkTypeface::kNormal);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-void SkFontHost::Serialize(const SkTypeface* face, SkWStream* stream) {
- const char* name = ((FamilyTypeface*)face)->getUniqueString();
-
- stream->write8((uint8_t)face->getStyle());
-
- if (NULL == name || 0 == *name) {
- stream->writePackedUInt(0);
-// SkDebugf("--- fonthost serialize null\n");
- } else {
- uint32_t len = strlen(name);
- stream->writePackedUInt(len);
- stream->write(name, len);
-// SkDebugf("--- fonthost serialize <%s> %d\n", name, face->getStyle());
- }
-}
-
-SkTypeface* SkFontHost::Deserialize(SkStream* stream) {
- load_system_fonts();
-
- int style = stream->readU8();
-
- int len = stream->readPackedUInt();
- if (len > 0) {
- SkString str;
- str.resize(len);
- stream->read(str.writable_str(), len);
-
- const FontInitRec* rec = gSystemFonts;
- for (size_t i = 0; i < SK_ARRAY_COUNT(gSystemFonts); i++) {
- if (strcmp(rec[i].fFileName, str.c_str()) == 0) {
- // backup until we hit the fNames
- for (int j = i; j >= 0; --j) {
- if (rec[j].fNames != NULL) {
- return SkFontHost::FindTypeface(NULL, rec[j].fNames[0],
- (SkTypeface::Style)style);
- }
- }
- }
- }
- }
- return SkFontHost::FindTypeface(NULL, NULL, (SkTypeface::Style)style);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-SkTypeface* SkFontHost::FindTypeface(const SkTypeface* familyFace,
- const char familyName[],
- SkTypeface::Style style)
-{
- load_system_fonts();
-
- SkAutoMutexAcquire ac(gFamilyMutex);
-
- // clip to legal style bits
- style = (SkTypeface::Style)(style & SkTypeface::kBoldItalic);
-
- SkTypeface* tf = NULL;
-
- if (NULL != familyFace) {
- tf = find_typeface(familyFace, style);
- } else if (NULL != familyName) {
-// SkDebugf("======= familyName <%s>\n", familyName);
- tf = find_typeface(familyName, style);
- }
-
- if (NULL == tf) {
- tf = find_best_face(gDefaultFamily, style);
- }
-
- return tf;
-}
-
-SkTypeface* SkFontHost::ResolveTypeface(uint32_t fontID)
-{
- SkAutoMutexAcquire ac(gFamilyMutex);
-
- return resolve_uniqueID(fontID);
-}
-
-SkStream* SkFontHost::OpenStream(uint32_t fontID)
-{
-
- FamilyTypeface* tf = (FamilyTypeface*)SkFontHost::ResolveTypeface(fontID);
- SkStream* stream = tf ? tf->openStream() : NULL;
-
- if (NULL == stream || stream->getLength() == 0) {
- delete stream;
- stream = NULL;
- }
- return stream;
-}
-
-void SkFontHost::CloseStream(uint32_t fontID, SkStream* stream)
-{
- FamilyTypeface* tf = (FamilyTypeface*)SkFontHost::ResolveTypeface(fontID);
- if (NULL != tf) {
- tf->closeStream(stream);
- }
-}
-
-SkScalerContext* SkFontHost::CreateFallbackScalerContext(
- const SkScalerContext::Rec& rec)
-{
- load_system_fonts();
-
- SkAutoDescriptor ad(sizeof(rec) + SkDescriptor::ComputeOverhead(1));
- SkDescriptor* desc = ad.getDesc();
-
- desc->init();
- SkScalerContext::Rec* newRec =
- (SkScalerContext::Rec*)desc->addEntry(kRec_SkDescriptorTag,
- sizeof(rec), &rec);
- newRec->fFontID = gFallBackTypeface->uniqueID();
- desc->computeChecksum();
-
- return SkFontHost::CreateScalerContext(desc);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-SkTypeface* SkFontHost::CreateTypeface(SkStream* stream)
-{
- if (NULL == stream || stream->getLength() <= 0) {
- SkDELETE(stream);
- return NULL;
- }
-
- SkString name;
- SkTypeface::Style style = find_name_and_style(stream, &name);
-
- return SkNEW_ARGS(StreamTypeface, (style, false, NULL, stream));
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-size_t SkFontHost::ShouldPurgeFontCache(size_t sizeAllocatedSoFar)
-{
- if (sizeAllocatedSoFar > FONT_CACHE_MEMORY_BUDGET)
- return sizeAllocatedSoFar - FONT_CACHE_MEMORY_BUDGET;
- else
- return 0; // nothing to do
-}
-
diff --git a/skia/ports/SkFontHost_ascender.cpp b/skia/ports/SkFontHost_ascender.cpp
deleted file mode 100644
index 2148850..0000000
--- a/skia/ports/SkFontHost_ascender.cpp
+++ /dev/null
@@ -1,211 +0,0 @@
-#include "SkScalerContext.h"
-#include "SkBitmap.h"
-#include "SkCanvas.h"
-#include "SkDescriptor.h"
-#include "SkFDot6.h"
-#include "SkFontHost.h"
-#include "SkMask.h"
-#include "SkStream.h"
-#include "SkString.h"
-#include "SkThread.h"
-#include "SkTemplates.h"
-
-#include <acaapi.h>
-
-//////////////////////////////////////////////////////////////////////////
-
-#include "SkMMapStream.h"
-
-class SkScalerContext_Ascender : public SkScalerContext {
-public:
- SkScalerContext_Ascender(const SkDescriptor* desc);
- virtual ~SkScalerContext_Ascender();
-
-protected:
- virtual unsigned generateGlyphCount() const;
- virtual uint16_t generateCharToGlyph(SkUnichar uni);
- 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);
-
-private:
- aca_FontHandle fHandle;
- void* fWorkspace;
- void* fGlyphWorkspace;
- SkStream* fFontStream;
- SkStream* fHintStream;
-};
-
-///////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////
-
-SkScalerContext_Ascender::SkScalerContext_Ascender(const SkDescriptor* desc)
- : SkScalerContext(desc)
-{
- int size = aca_Get_FontHandleRec_Size();
- fHandle = (aca_FontHandle)sk_malloc_throw(size);
-
- // get the pointer to the font
-
- fFontStream = new SkMMAPStream("/UcsGB2312-Hei-H.FDL");
- fHintStream = new SkMMAPStream("/genv6-23.bin");
-
- void* hints = sk_malloc_throw(fHintStream->getLength());
- memcpy(hints, fHintStream->getMemoryBase(), fHintStream->getLength());
-
- aca_Create_Font_Handle(fHandle,
- (void*)fFontStream->getMemoryBase(), fFontStream->getLength(),
- "fred",
- hints, fHintStream->getLength());
-
- // compute our factors from the record
-
- SkMatrix m;
-
- fRec.getSingleMatrix(&m);
-
- // now compute our scale factors
- SkScalar sx = m.getScaleX();
- SkScalar sy = m.getScaleY();
-
- int ppemX = SkScalarRound(sx);
- int ppemY = SkScalarRound(sy);
-
- size = aca_Find_Font_Memory_Required(fHandle, ppemX, ppemY);
- size *= 8; // Jeff suggests this :)
- fWorkspace = sk_malloc_throw(size);
- aca_Set_Font_Memory(fHandle, (uint8_t*)fWorkspace, size);
-
- aca_GlyphAttribsRec rec;
-
- memset(&rec, 0, sizeof(rec));
- rec.xSize = ppemX;
- rec.ySize = ppemY;
- rec.doAdjust = true;
- rec.doExceptions = true;
- rec.doGlyphHints = true;
- rec.doInterpolate = true;
- rec.grayMode = 2;
- aca_Set_Font_Attributes(fHandle, &rec, &size);
-
- fGlyphWorkspace = sk_malloc_throw(size);
- aca_Set_Glyph_Memory(fHandle, fGlyphWorkspace);
-}
-
-SkScalerContext_Ascender::~SkScalerContext_Ascender()
-{
- delete fHintStream;
- delete fFontStream;
- sk_free(fGlyphWorkspace);
- sk_free(fWorkspace);
- sk_free(fHandle);
-}
-
-unsigned SkScalerContext_Ascender::generateGlyphCount() const
-{
- return 1000;
-}
-
-uint16_t SkScalerContext_Ascender::generateCharToGlyph(SkUnichar uni)
-{
- return (uint16_t)(uni & 0xFFFF);
-}
-
-void SkScalerContext_Ascender::generateMetrics(SkGlyph* glyph)
-{
- glyph->fRsbDelta = 0;
- glyph->fLsbDelta = 0;
-
- aca_GlyphImageRec rec;
- aca_Vector topLeft;
-
- int adv = aca_Get_Adv_Width(fHandle, glyph->getGlyphID());
- if (aca_GLYPH_NOT_PRESENT == adv)
- goto ERROR;
-
- aca_Rasterize(glyph->getGlyphID(), fHandle, &rec, &topLeft);
-
- if (false) // error
- {
-ERROR:
- glyph->fWidth = 0;
- glyph->fHeight = 0;
- glyph->fTop = 0;
- glyph->fLeft = 0;
- glyph->fAdvanceX = 0;
- glyph->fAdvanceY = 0;
- return;
- }
-
- glyph->fWidth = rec.width;
- glyph->fHeight = rec.rows;
- glyph->fRowBytes = rec.width;
- glyph->fTop = -topLeft.y;
- glyph->fLeft = topLeft.x;
- glyph->fAdvanceX = SkIntToFixed(adv);
- glyph->fAdvanceY = SkIntToFixed(0);
-}
-
-void SkScalerContext_Ascender::generateImage(const SkGlyph& glyph)
-{
- aca_GlyphImageRec rec;
- aca_Vector topLeft;
-
- aca_Rasterize(glyph.getGlyphID(), fHandle, &rec, &topLeft);
-
- const uint8_t* src = (const uint8_t*)rec.buffer;
- uint8_t* dst = (uint8_t*)glyph.fImage;
- int height = glyph.fHeight;
-
- src += rec.y0 * rec.pitch + rec.x0;
- while (--height >= 0)
- {
- memcpy(dst, src, glyph.fWidth);
- src += rec.pitch;
- dst += glyph.fRowBytes;
- }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////
-
-void SkScalerContext_Ascender::generatePath(const SkGlyph& glyph, SkPath* path)
-{
- SkRect r;
-
- r.set(0, 0, SkIntToScalar(4), SkIntToScalar(4));
- path->reset();
- path->addRect(r);
-}
-
-void SkScalerContext_Ascender::generateFontMetrics(SkPaint::FontMetrics* mx, SkPaint::FontMetrics* my)
-{
- if (NULL == mx && NULL == my)
- return;
-
- if (mx)
- {
- mx->fTop = SkIntToScalar(-16);
- mx->fAscent = SkIntToScalar(-16);
- mx->fDescent = SkIntToScalar(4);
- mx->fBottom = SkIntToScalar(4);
- mx->fLeading = 0;
- }
- if (my)
- {
- my->fTop = SkIntToScalar(-16);
- my->fAscent = SkIntToScalar(-16);
- my->fDescent = SkIntToScalar(4);
- my->fBottom = SkIntToScalar(4);
- my->fLeading = 0;
- }
-}
-
-////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////
-
-SkScalerContext* SkFontHost::CreateScalerContext(const SkDescriptor* desc)
-{
- return SkNEW_ARGS(SkScalerContext_Ascender, (desc));
-}
-
diff --git a/skia/ports/SkFontHost_fontconfig.cpp b/skia/ports/SkFontHost_fontconfig.cpp
deleted file mode 100644
index 9998a39..0000000
--- a/skia/ports/SkFontHost_fontconfig.cpp
+++ /dev/null
@@ -1,375 +0,0 @@
-/* libs/graphics/ports/SkFontHost_fontconfig.cpp
-**
-** Copyright 2008, Google Inc.
-**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
-**
-** http://www.apache.org/licenses/LICENSE-2.0
-**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
-** limitations under the License.
-*/
-
-// -----------------------------------------------------------------------------
-// This file provides implementations of the font resolution members of
-// SkFontHost by using the fontconfig[1] library. Fontconfig is usually found
-// on Linux systems and handles configuration, parsing and caching issues
-// involved with enumerating and matching fonts.
-//
-// [1] http://fontconfig.org
-// -----------------------------------------------------------------------------
-
-#include <map>
-#include <string>
-
-#include <fontconfig/fontconfig.h>
-
-#include "SkDescriptor.h"
-#include "SkFontHost.h"
-#include "SkMMapStream.h"
-#include "SkPaint.h"
-#include "SkStream.h"
-#include "SkString.h"
-#include "SkThread.h"
-#include "SkTSearch.h"
-
-// This is an extern from SkFontHost_FreeType
-SkTypeface::Style find_name_and_style(SkStream* stream, SkString* name);
-
-// -----------------------------------------------------------------------------
-// The rest of Skia requires that fonts be identified by a unique unsigned id
-// and that we be able to load them given the id. What we actually get from
-// fontconfig is the filename of the font so we keep a locked map from
-// filenames to fileid numbers and back.
-//
-// Note that there's also a unique id in the SkTypeface. This is unique over
-// both filename and style. Thus we encode that id as (fileid << 8) | style.
-// Although truetype fonts can support multiple faces in a single file, at the
-// moment Skia doesn't.
-// -----------------------------------------------------------------------------
-static SkMutex global_fc_map_lock;
-static std::map<std::string, unsigned> global_fc_map;
-static std::map<unsigned, std::string> global_fc_map_inverted;
-static std::map<uint32_t, SkTypeface *> global_fc_typefaces;
-static unsigned global_fc_map_next_id = 0;
-
-// This is the maximum size of the font cache.
-static const unsigned kFontCacheMemoryBudget = 2 * 1024 * 1024; // 2MB
-
-static unsigned UniqueIdToFileId(unsigned uniqueid)
-{
- return uniqueid >> 8;
-}
-
-static SkTypeface::Style UniqueIdToStyle(unsigned uniqueid)
-{
- return static_cast<SkTypeface::Style>(uniqueid & 0xff);
-}
-
-static unsigned FileIdAndStyleToUniqueId(unsigned fileid,
- SkTypeface::Style style)
-{
- SkASSERT(style & 0xff == style);
- return (fileid << 8) | static_cast<int>(style);
-}
-
-class FontConfigTypeface : public SkTypeface {
-public:
- FontConfigTypeface(Style style, uint32_t id)
- : SkTypeface(style, id)
- { }
-};
-
-// -----------------------------------------------------------------------------
-// Find a matching font where @type (one of FC_*) is equal to @value. For a
-// list of types, see http://fontconfig.org/fontconfig-devel/x19.html#AEN27.
-// The variable arguments are a list of triples, just like the first three
-// arguments, and must be NULL terminated.
-//
-// For example, FontMatchString(FC_FILE, FcTypeString,
-// "/usr/share/fonts/myfont.ttf", NULL);
-// -----------------------------------------------------------------------------
-static FcPattern* FontMatch(bool is_fallback,
- const char* type, FcType vtype, const void* value,
- ...)
-{
- va_list ap;
- va_start(ap, value);
-
- FcPattern* pattern = FcPatternCreate();
- bool family_requested = false;
-
- for (;;) {
- FcValue fcvalue;
- fcvalue.type = vtype;
- switch (vtype) {
- case FcTypeString:
- fcvalue.u.s = (FcChar8*) value;
- break;
- case FcTypeInteger:
- fcvalue.u.i = (int) value;
- break;
- default:
- SkASSERT(!"FontMatch unhandled type");
- }
- FcPatternAdd(pattern, type, fcvalue, 0);
-
- if (vtype == FcTypeString && strcmp(type, FC_FAMILY) == 0)
- family_requested = true;
-
- type = va_arg(ap, const char *);
- if (!type)
- break;
- // FcType is promoted to int when passed through ...
- vtype = static_cast<FcType>(va_arg(ap, int));
- value = va_arg(ap, const void *);
- };
- va_end(ap);
-
- FcConfigSubstitute(0, pattern, FcMatchPattern);
- FcDefaultSubstitute(pattern);
-
- // Font matching:
- // CSS often specifies a fallback list of families:
- // font-family: a, b, c, serif;
- // However, fontconfig will always do its best to find *a* font when asked
- // for something so we need a way to tell if the match which it has found is
- // "good enough" for us. Otherwise, we can return NULL which gets piped up
- // and lets WebKit know to try the next CSS family name. However, fontconfig
- // configs allow substitutions (mapping "Arial -> Helvetica" etc) and we
- // wish to support that.
- //
- // Thus, if a specific family is requested we set @family_requested. Then we
- // record two strings: the family name after config processing and the
- // family name after resolving. If the two are equal, it's a good match.
- //
- // So consider the case where a user has mapped Arial to Helvetica in their
- // config.
- // requested family: "Arial"
- // post_config_family: "Helvetica"
- // post_match_family: "Helvetica"
- // -> good match
- //
- // and for a missing font:
- // requested family: "Monaco"
- // post_config_family: "Monaco"
- // post_match_family: "Times New Roman"
- // -> BAD match
- FcChar8* post_config_family;
- FcPatternGetString(pattern, FC_FAMILY, 0, &post_config_family);
-
- FcResult result;
- FcPattern* match = FcFontMatch(0, pattern, &result);
- if (!match) {
- FcPatternDestroy(pattern);
- return NULL;
- }
-
- FcChar8* post_match_family;
- FcPatternGetString(match, FC_FAMILY, 0, &post_match_family);
- const bool family_names_match =
- !family_requested ?
- true :
- strcasecmp((char *) post_config_family, (char *) post_match_family) == 0;
-
- FcPatternDestroy(pattern);
-
- if (!family_names_match && !is_fallback) {
- FcPatternDestroy(match);
- return NULL;
- }
-
- return match;
-}
-
-// -----------------------------------------------------------------------------
-// Check to see if the filename has already been assigned a fileid and, if so,
-// use it. Otherwise, assign one. Return the resulting fileid.
-// -----------------------------------------------------------------------------
-static unsigned FileIdFromFilename(const char* filename)
-{
- SkAutoMutexAcquire ac(global_fc_map_lock);
-
- std::map<std::string, unsigned>::const_iterator i =
- global_fc_map.find(filename);
- if (i == global_fc_map.end()) {
- const unsigned fileid = global_fc_map_next_id++;
- global_fc_map[filename] = fileid;
- global_fc_map_inverted[fileid] = filename;
- return fileid;
- } else {
- return i->second;
- }
-}
-
-SkTypeface* SkFontHost::FindTypeface(const SkTypeface* familyFace,
- const char familyName[],
- SkTypeface::Style style)
-{
- const char* resolved_family_name = NULL;
- FcPattern* face_match = NULL;
-
- if (familyFace) {
- // Here we use the inverted global id map to find the filename from the
- // SkTypeface object. Given the filename we can ask fontconfig for the
- // familyname of the font.
- SkAutoMutexAcquire ac(global_fc_map_lock);
-
- const unsigned fileid = UniqueIdToFileId(familyFace->uniqueID());
- std::map<unsigned, std::string>::const_iterator i =
- global_fc_map_inverted.find(fileid);
- if (i == global_fc_map_inverted.end())
- return NULL;
-
- FcInit();
- face_match = FontMatch(false, FC_FILE, FcTypeString, i->second.c_str(),
- NULL);
-
- if (!face_match)
- return NULL;
- FcChar8* family;
- if (FcPatternGetString(face_match, FC_FAMILY, 0, &family)) {
- FcPatternDestroy(face_match);
- return NULL;
- }
- // At this point, @family is pointing into the @face_match object so we
- // cannot release it yet.
-
- resolved_family_name = reinterpret_cast<char*>(family);
- } else if (familyName) {
- resolved_family_name = familyName;
- } else {
- return NULL;
- }
-
- {
- SkAutoMutexAcquire ac(global_fc_map_lock);
- FcInit();
- }
-
- // At this point, we have a resolved_family_name from somewhere
- SkASSERT(resolved_family_name);
-
- const int bold = style & SkTypeface::kBold ?
- FC_WEIGHT_BOLD : FC_WEIGHT_NORMAL;
- const int italic = style & SkTypeface::kItalic ?
- FC_SLANT_ITALIC : FC_SLANT_ROMAN;
- FcPattern* match = FontMatch(false,
- FC_FAMILY, FcTypeString, resolved_family_name,
- FC_WEIGHT, FcTypeInteger, bold,
- FC_SLANT, FcTypeInteger, italic,
- NULL);
- if (face_match)
- FcPatternDestroy(face_match);
-
- if (!match)
- return NULL;
-
- FcChar8* filename;
- if (FcPatternGetString(match, FC_FILE, 0, &filename) != FcResultMatch) {
- FcPatternDestroy(match);
- return NULL;
- }
- // Now @filename is pointing into @match
-
- const unsigned fileid = FileIdFromFilename(reinterpret_cast<char*>(filename));
- const unsigned id = FileIdAndStyleToUniqueId(fileid, style);
- SkTypeface* typeface = SkNEW_ARGS(FontConfigTypeface, (style, id));
- FcPatternDestroy(match);
-
- {
- SkAutoMutexAcquire ac(global_fc_map_lock);
- global_fc_typefaces[id] = typeface;
- }
-
- return typeface;
-}
-
-SkTypeface* SkFontHost::ResolveTypeface(uint32_t id)
-{
- SkAutoMutexAcquire ac(global_fc_map_lock);
- const std::map<uint32_t, SkTypeface *>::iterator
- i = global_fc_typefaces.find(id);
-
- if (i == global_fc_typefaces.end())
- return NULL;
- return i->second;
-}
-
-SkStream* SkFontHost::OpenStream(uint32_t id)
-{
- SkAutoMutexAcquire ac(global_fc_map_lock);
- const unsigned fileid = UniqueIdToFileId(id);
-
- std::map<unsigned, std::string>::const_iterator i =
- global_fc_map_inverted.find(fileid);
- if (i == global_fc_map_inverted.end())
- return NULL;
-
- return SkNEW_ARGS(SkFILEStream, (i->second.c_str()));
-}
-
-void SkFontHost::CloseStream(uint32_t fontID, SkStream* stream)
-{
-}
-
-SkTypeface* SkFontHost::CreateTypeface(SkStream* stream)
-{
- SkASSERT(!"SkFontHost::CreateTypeface unimplemented");
- return NULL;
-}
-
-SkTypeface* SkFontHost::Deserialize(SkStream* stream) {
- SkASSERT(!"SkFontHost::Deserialize unimplemented");
- return NULL;
-}
-
-void SkFontHost::Serialize(const SkTypeface*, SkWStream*) {
- SkASSERT(!"SkFontHost::Serialize unimplemented");
-}
-
-SkScalerContext* SkFontHost::CreateFallbackScalerContext
- (const SkScalerContext::Rec& rec) {
- FcPattern* match = FontMatch(true, FC_FAMILY, FcTypeString, "serif",
- NULL);
-
- // This will fail when we have no fonts on the system.
- SkASSERT(match);
-
- FcChar8* filename;
- if (FcPatternGetString(match, FC_FILE, 0, &filename) != FcResultMatch) {
- FcPatternDestroy(match);
- return NULL;
- }
- // Now @filename is pointing into @match
-
- const unsigned id = FileIdFromFilename(reinterpret_cast<char*>(filename));
- FcPatternDestroy(match);
-
- SkAutoDescriptor ad(sizeof(rec) + SkDescriptor::ComputeOverhead(1));
- SkDescriptor* desc = ad.getDesc();
-
- desc->init();
- SkScalerContext::Rec* newRec =
- (SkScalerContext::Rec*)desc->addEntry(kRec_SkDescriptorTag,
- sizeof(rec), &rec);
- newRec->fFontID = id;
- desc->computeChecksum();
-
- return SkFontHost::CreateScalerContext(desc);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-size_t SkFontHost::ShouldPurgeFontCache(size_t sizeAllocatedSoFar)
-{
- if (sizeAllocatedSoFar > kFontCacheMemoryBudget)
- return sizeAllocatedSoFar - kFontCacheMemoryBudget;
- else
- return 0; // nothing to do
-}
diff --git a/skia/ports/SkFontHost_gamma.cpp b/skia/ports/SkFontHost_gamma.cpp
deleted file mode 100644
index 0b95bce..0000000
--- a/skia/ports/SkFontHost_gamma.cpp
+++ /dev/null
@@ -1,118 +0,0 @@
-#include "SkFontHost.h"
-#include <math.h>
-
-// define this to use pre-compiled tables for gamma. This is slightly faster,
-// and doesn't create any RW global memory, but means we cannot change the
-// gamma at runtime.
-#define USE_PREDEFINED_GAMMA_TABLES
-
-#ifndef USE_PREDEFINED_GAMMA_TABLES
- // define this if you want to spew out the "C" code for the tables, given
- // the current values for SK_BLACK_GAMMA and SK_WHITE_GAMMA.
- #define DUMP_GAMMA_TABLESx
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-
-#ifdef USE_PREDEFINED_GAMMA_TABLES
-
-#include "sk_predefined_gamma.h"
-
-#else // use writable globals for gamma tables
-
-static bool gGammaIsBuilt;
-static uint8_t gBlackGamma[256], gWhiteGamma[256];
-
-#define SK_BLACK_GAMMA (1.4f)
-#define SK_WHITE_GAMMA (1/1.4f)
-
-static void build_power_table(uint8_t table[], float ee)
-{
- // printf("------ build_power_table %g\n", ee);
- for (int i = 0; i < 256; i++)
- {
- float x = i / 255.f;
- // printf(" %d %g", i, x);
- x = powf(x, ee);
- // printf(" %g", x);
- int xx = SkScalarRound(SkFloatToScalar(x * 255));
- // printf(" %d\n", xx);
- table[i] = SkToU8(xx);
- }
-}
-
-#ifdef DUMP_GAMMA_TABLES
-
-#include "SkString.h"
-
-static void dump_a_table(const char name[], const uint8_t table[],
- float gamma) {
- SkDebugf("\n");
- SkDebugf("\/\/ Gamma table for %g\n", gamma);
- SkDebugf("static const uint8_t %s[] = {\n", name);
- for (int y = 0; y < 16; y++) {
- SkString line, tmp;
- for (int x = 0; x < 16; x++) {
- tmp.printf("0x%02X, ", *table++);
- line.append(tmp);
- }
- SkDebugf(" %s\n", line.c_str());
- }
- SkDebugf("};\n");
-}
-
-#endif
-
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-
-void SkFontHost::GetGammaTables(const uint8_t* tables[2])
-{
-#ifndef USE_PREDEFINED_GAMMA_TABLES
- if (!gGammaIsBuilt)
- {
- build_power_table(gBlackGamma, SK_BLACK_GAMMA);
- build_power_table(gWhiteGamma, SK_WHITE_GAMMA);
- gGammaIsBuilt = true;
-
-#ifdef DUMP_GAMMA_TABLES
- dump_a_table("gBlackGamma", gBlackGamma, SK_BLACK_GAMMA);
- dump_a_table("gWhiteGamma", gWhiteGamma, SK_WHITE_GAMMA);
-#endif
- }
-#endif
- tables[0] = gBlackGamma;
- tables[1] = gWhiteGamma;
-}
-
-// If the luminance is <= this value, then apply the black gamma table
-#define BLACK_GAMMA_THRESHOLD 0x40
-
-// If the luminance is >= this value, then apply the white gamma table
-#define WHITE_GAMMA_THRESHOLD 0xC0
-
-int SkFontHost::ComputeGammaFlag(const SkPaint& paint)
-{
- if (paint.getShader() == NULL)
- {
- SkColor c = paint.getColor();
- int r = SkColorGetR(c);
- int g = SkColorGetG(c);
- int b = SkColorGetB(c);
- int luminance = (r * 2 + g * 5 + b) >> 3;
-
- if (luminance <= BLACK_GAMMA_THRESHOLD)
- {
- // printf("------ black gamma for [%d %d %d]\n", r, g, b);
- return SkScalerContext::kGammaForBlack_Flag;
- }
- if (luminance >= WHITE_GAMMA_THRESHOLD)
- {
- // printf("------ white gamma for [%d %d %d]\n", r, g, b);
- return SkScalerContext::kGammaForWhite_Flag;
- }
- }
- return 0;
-}
-
diff --git a/skia/ports/SkFontHost_gamma_none.cpp b/skia/ports/SkFontHost_gamma_none.cpp
deleted file mode 100644
index cdc507a..0000000
--- a/skia/ports/SkFontHost_gamma_none.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-/* Copyright 2008, Google Inc.
-**
-** Licensed under the Apache License, Version 2.0 (the "License");·
-** you may not use this file except in compliance with the License.·
-** You may obtain a copy of the License at·
-**
-** http://www.apache.org/licenses/LICENSE-2.0·
-**
-** Unless required by applicable law or agreed to in writing, software·
-** distributed under the License is distributed on an "AS IS" BASIS,·
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.·
-** See the License for the specific language governing permissions and·
-** limitations under the License.
-*/
-
-// -----------------------------------------------------------------------------
-// This is a noop gamma implementation for systems where gamma is already
-// corrected, or dealt with in a system wide fashion. For example, on X windows
-// one uses the xgamma utility to set the server-wide gamma correction value.
-// -----------------------------------------------------------------------------
-
-#include "SkFontHost.h"
-#include <math.h>
-
-void SkFontHost::GetGammaTables(const uint8_t* tables[2])
-{
- tables[0] = NULL;
- tables[1] = NULL;
-}
-
-int SkFontHost::ComputeGammaFlag(const SkPaint& paint)
-{
- return 0;
-}
-
diff --git a/skia/ports/SkFontHost_linux.cpp b/skia/ports/SkFontHost_linux.cpp
deleted file mode 100644
index f75718d..0000000
--- a/skia/ports/SkFontHost_linux.cpp
+++ /dev/null
@@ -1,604 +0,0 @@
-/* libs/graphics/ports/SkFontHost_android.cpp
- **
- ** Copyright 2006, The Android Open Source Project
- **
- ** Licensed under the Apache License, Version 2.0 (the "License");
- ** you may not use this file except in compliance with the License.
- ** You may obtain a copy of the License at
- **
- ** http://www.apache.org/licenses/LICENSE-2.0
- **
- ** Unless required by applicable law or agreed to in writing, software
- ** distributed under the License is distributed on an "AS IS" BASIS,
- ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- ** See the License for the specific language governing permissions and
- ** limitations under the License.
- */
-
-#include "SkFontHost.h"
-#include "SkDescriptor.h"
-#include "SkMMapStream.h"
-#include "SkOSFile.h"
-#include "SkPaint.h"
-#include "SkString.h"
-#include "SkStream.h"
-#include "SkThread.h"
-#include "SkTSearch.h"
-#include <stdio.h>
-
-#define FONT_CACHE_MEMORY_BUDGET (1 * 1024 * 1024)
-
-#ifndef SK_FONT_FILE_PREFIX
- #define SK_FONT_FILE_PREFIX "/usr/share/fonts/truetype/msttcorefonts/"
-#endif
-
-SkTypeface::Style find_name_and_style(SkStream* stream, SkString* name);
-
-static void GetFullPathForSysFonts(SkString* full, const char name[])
-{
- full->append(SK_FONT_FILE_PREFIX);
- full->append(name);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-struct FamilyRec;
-
-/* This guy holds a mapping of a name -> family, used for looking up fonts.
- Since it is stored in a stretchy array that doesn't preserve object
- semantics, we don't use constructor/destructors, but just have explicit
- helpers to manage our internal bookkeeping.
- */
-struct NameFamilyPair {
- const char* fName; // we own this
- FamilyRec* fFamily; // we don't own this, we just reference it
-
- void construct(const char name[], FamilyRec* family)
- {
- fName = strdup(name);
- fFamily = family; // we don't own this, so just record the referene
- }
- void destruct()
- {
- free((char*)fName);
- // we don't own family, so just ignore our reference
- }
-};
-
-// we use atomic_inc to grow this for each typeface we create
-static int32_t gUniqueFontID;
-
-// this is the mutex that protects these globals
-static SkMutex gFamilyMutex;
-static FamilyRec* gFamilyHead;
-static SkTDArray<NameFamilyPair> gNameList;
-
-struct FamilyRec {
- FamilyRec* fNext;
- SkTypeface* fFaces[4];
-
- FamilyRec()
- {
- fNext = gFamilyHead;
- memset(fFaces, 0, sizeof(fFaces));
- gFamilyHead = this;
- }
-};
-
-static SkTypeface* find_best_face(const FamilyRec* family,
- SkTypeface::Style style)
-{
- SkTypeface* const* faces = family->fFaces;
-
- if (faces[style] != NULL) { // exact match
- return faces[style];
- }
- // look for a matching bold
- style = (SkTypeface::Style)(style ^ SkTypeface::kItalic);
- if (faces[style] != NULL) {
- return faces[style];
- }
- // look for the plain
- if (faces[SkTypeface::kNormal] != NULL) {
- return faces[SkTypeface::kNormal];
- }
- // look for anything
- for (int i = 0; i < 4; i++) {
- if (faces[i] != NULL) {
- return faces[i];
- }
- }
- // should never get here, since the faces list should not be empty
- SkASSERT(!"faces list is empty");
- return NULL;
-}
-
-static FamilyRec* find_family(const SkTypeface* member)
-{
- FamilyRec* curr = gFamilyHead;
- while (curr != NULL) {
- for (int i = 0; i < 4; i++) {
- if (curr->fFaces[i] == member) {
- return curr;
- }
- }
- curr = curr->fNext;
- }
- return NULL;
-}
-
-static SkTypeface* resolve_uniqueID(uint32_t uniqueID)
-{
- FamilyRec* curr = gFamilyHead;
- while (curr != NULL) {
- for (int i = 0; i < 4; i++) {
- SkTypeface* face = curr->fFaces[i];
- if (face != NULL && face->uniqueID() == uniqueID) {
- return face;
- }
- }
- curr = curr->fNext;
- }
- return NULL;
-}
-
-/* Remove reference to this face from its family. If the resulting family
- is empty (has no faces), return that family, otherwise return NULL
- */
-static FamilyRec* remove_from_family(const SkTypeface* face)
-{
- FamilyRec* family = find_family(face);
- SkASSERT(family->fFaces[face->style()] == face);
- family->fFaces[face->style()] = NULL;
-
- for (int i = 0; i < 4; i++) {
- if (family->fFaces[i] != NULL) { // family is non-empty
- return NULL;
- }
- }
- return family; // return the empty family
-}
-
-// maybe we should make FamilyRec be doubly-linked
-static void detach_and_delete_family(FamilyRec* family)
-{
- FamilyRec* curr = gFamilyHead;
- FamilyRec* prev = NULL;
-
- while (curr != NULL) {
- FamilyRec* next = curr->fNext;
- if (curr == family) {
- if (prev == NULL) {
- gFamilyHead = next;
- } else {
- prev->fNext = next;
- }
- SkDELETE(family);
- return;
- }
- prev = curr;
- curr = next;
- }
- SkASSERT(!"Yikes, couldn't find family in our list to remove/delete");
-}
-
-static FamilyRec* find_familyrec(const char name[]) {
- const NameFamilyPair* list = gNameList.begin();
- int index = SkStrLCSearch(&list[0].fName, gNameList.count(), name,
- sizeof(list[0]));
- return index >= 0 ? list[index].fFamily : NULL;
-}
-
-static SkTypeface* find_typeface(const char name[], SkTypeface::Style style) {
- FamilyRec* rec = find_familyrec(name);
- return rec ? find_best_face(rec, style) : NULL;
-}
-
-static SkTypeface* find_typeface(const SkTypeface* familyMember,
- SkTypeface::Style style)
-{
- const FamilyRec* family = find_family(familyMember);
- return family ? find_best_face(family, style) : NULL;
-}
-
-static void add_name(const char name[], FamilyRec* family)
-{
- SkAutoAsciiToLC tolc(name);
- name = tolc.lc();
-
- NameFamilyPair* list = gNameList.begin();
- int count = gNameList.count();
-
- int index = SkStrLCSearch(&list[0].fName, count, name, sizeof(list[0]));
-
- if (index < 0) {
- list = gNameList.insert(~index);
- list->construct(name, family);
- }
-}
-
-static void remove_from_names(FamilyRec* emptyFamily)
-{
-#ifdef SK_DEBUG
- for (int i = 0; i < 4; i++) {
- SkASSERT(emptyFamily->fFaces[i] == NULL);
- }
-#endif
-
- SkTDArray<NameFamilyPair>& list = gNameList;
-
- // must go backwards when removing
- for (int i = list.count() - 1; i >= 0; --i) {
- NameFamilyPair* pair = &list[i];
- if (pair->fFamily == emptyFamily) {
- pair->destruct();
- list.remove(i);
- }
- }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-class FamilyTypeface : public SkTypeface {
-public:
- FamilyTypeface(Style style, bool sysFont, FamilyRec* family)
- : SkTypeface(style, sk_atomic_inc(&gUniqueFontID) + 1)
- {
- fIsSysFont = sysFont;
-
- SkAutoMutexAcquire ac(gFamilyMutex);
-
- if (NULL == family) {
- family = SkNEW(FamilyRec);
- }
- family->fFaces[style] = this;
- fFamilyRec = family; // just record it so we can return it if asked
- }
-
- virtual ~FamilyTypeface()
- {
- SkAutoMutexAcquire ac(gFamilyMutex);
-
- // remove us from our family. If the family is now empty, we return
- // that and then remove that family from the name list
- FamilyRec* family = remove_from_family(this);
- if (NULL != family) {
- remove_from_names(family);
- detach_and_delete_family(family);
- }
- }
-
- bool isSysFont() const { return fIsSysFont; }
- FamilyRec* getFamily() const { return fFamilyRec; }
-
- virtual SkStream* openStream() = 0;
- virtual void closeStream(SkStream*) = 0;
- virtual const char* getUniqueString() const = 0;
-
-private:
- FamilyRec* fFamilyRec; // we don't own this, just point to it
- bool fIsSysFont;
-
- typedef SkTypeface INHERITED;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-
-class StreamTypeface : public FamilyTypeface {
-public:
- StreamTypeface(Style style, bool sysFont, FamilyRec* family,
- SkStream* stream)
- : INHERITED(style, sysFont, family)
- {
- fStream = stream;
- }
- virtual ~StreamTypeface()
- {
- SkDELETE(fStream);
- }
-
- // overrides
- virtual SkStream* openStream() { return fStream; }
- virtual void closeStream(SkStream*) {}
- virtual const char* getUniqueString() const { return NULL; }
-
-private:
- SkStream* fStream;
-
- typedef FamilyTypeface INHERITED;
-};
-
-class FileTypeface : public FamilyTypeface {
-public:
- FileTypeface(Style style, bool sysFont, FamilyRec* family,
- const char path[])
- : INHERITED(style, sysFont, family) {
- fPath.set(path);
- }
-
- // overrides
- virtual SkStream* openStream()
- {
- SkStream* stream = SkNEW_ARGS(SkMMAPStream, (fPath.c_str()));
-
- // check for failure
- if (stream->getLength() <= 0) {
- SkDELETE(stream);
- // maybe MMAP isn't supported. try FILE
- stream = SkNEW_ARGS(SkFILEStream, (fPath.c_str()));
- if (stream->getLength() <= 0) {
- SkDELETE(stream);
- stream = NULL;
- }
- }
- return stream;
- }
- virtual void closeStream(SkStream* stream)
- {
- SkDELETE(stream);
- }
- virtual const char* getUniqueString() const {
- const char* str = strrchr(fPath.c_str(), '/');
- if (str) {
- str += 1; // skip the '/'
- }
- return str;
- }
-
-private:
- SkString fPath;
-
- typedef FamilyTypeface INHERITED;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-
-static bool get_name_and_style(const char path[], SkString* name,
- SkTypeface::Style* style)
-{
- SkMMAPStream stream(path);
- if (stream.getLength() > 0) {
- *style = find_name_and_style(&stream, name);
- return true;
- }
- else {
- SkFILEStream stream(path);
- if (stream.getLength() > 0) {
- *style = find_name_and_style(&stream, name);
- return true;
- }
- }
-
- SkDebugf("---- failed to open <%s> as a font\n", path);
- return false;
-}
-
-// these globals are assigned (once) by load_system_fonts()
-static SkTypeface* gFallBackTypeface;
-static FamilyRec* gDefaultFamily;
-static SkTypeface* gDefaultNormal;
-
-static void load_system_fonts()
-{
- // check if we've already be called
- if (NULL != gDefaultNormal) {
- return;
- }
-
- SkOSFile::Iter iter(SK_FONT_FILE_PREFIX, ".ttf");
- SkString name;
-
- while (iter.next(&name, false)) {
- SkString filename;
- GetFullPathForSysFonts(&filename, name.c_str());
-// while (filename.size() == 0) { filename.set("/usr/share/fonts/truetype/msttcorefonts/Arial.ttf");
-
- SkString realname;
- SkTypeface::Style style;
-
- if (!get_name_and_style(filename.c_str(), &realname, &style)) {
- SkDebugf("------ can't load <%s> as a font\n", filename.c_str());
- continue;
- }
-
-// SkDebugf("font: <%s> %d <%s>\n", realname.c_str(), style, filename.c_str());
-
- FamilyRec* family = find_familyrec(realname.c_str());
- // this constructor puts us into the global gFamilyHead llist
- FamilyTypeface* tf = SkNEW_ARGS(FileTypeface,
- (style,
- true, // system-font (cannot delete)
- family, // what family to join
- filename.c_str()) // filename
- );
-
- if (NULL == family) {
- add_name(realname.c_str(), tf->getFamily());
- }
- }
-
- // do this after all fonts are loaded. This is our default font, and it
- // acts as a sentinel so we only execute load_system_fonts() once
- static const char* gDefaultNames[] = {
- "Arial", "Verdana", "Times New Roman", NULL
- };
- const char** names = gDefaultNames;
- while (*names) {
- SkTypeface* tf = find_typeface(*names++, SkTypeface::kNormal);
- if (tf) {
- gDefaultNormal = tf;
- break;
- }
- }
- // check if we found *something*
- if (NULL == gDefaultNormal) {
- if (NULL == gFamilyHead) {
- sk_throw();
- }
- for (int i = 0; i < 4; i++) {
- if ((gDefaultNormal = gFamilyHead->fFaces[i]) != NULL) {
- break;
- }
- }
- }
- if (NULL == gDefaultNormal) {
- sk_throw();
- }
- gFallBackTypeface = gDefaultNormal;
- gDefaultFamily = find_family(gDefaultNormal);
-
-// SkDebugf("---- default %p head %p family %p\n", gDefaultNormal, gFamilyHead, gDefaultFamily);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-void SkFontHost::Serialize(const SkTypeface* face, SkWStream* stream) {
-#if 0
- const char* name = ((FamilyTypeface*)face)->getUniqueString();
-
- stream->write8((uint8_t)face->getStyle());
-
- if (NULL == name || 0 == *name) {
- stream->writePackedUInt(0);
- // SkDebugf("--- fonthost serialize null\n");
- } else {
- uint32_t len = strlen(name);
- stream->writePackedUInt(len);
- stream->write(name, len);
- // SkDebugf("--- fonthost serialize <%s> %d\n", name, face->getStyle());
- }
-#endif
- sk_throw();
-}
-
-SkTypeface* SkFontHost::Deserialize(SkStream* stream) {
-#if 0
- load_system_fonts();
-
- int style = stream->readU8();
-
- int len = stream->readPackedUInt();
- if (len > 0) {
- SkString str;
- str.resize(len);
- stream->read(str.writable_str(), len);
-
- const FontInitRec* rec = gSystemFonts;
- for (size_t i = 0; i < SK_ARRAY_COUNT(gSystemFonts); i++) {
- if (strcmp(rec[i].fFileName, str.c_str()) == 0) {
- // backup until we hit the fNames
- for (int j = i; j >= 0; --j) {
- if (rec[j].fNames != NULL) {
- return SkFontHost::FindTypeface(NULL, rec[j].fNames[0],
- (SkTypeface::Style)style);
- }
- }
- }
- }
- }
- return SkFontHost::FindTypeface(NULL, NULL, (SkTypeface::Style)style);
-#endif
- sk_throw();
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-SkTypeface* SkFontHost::FindTypeface(const SkTypeface* familyFace,
- const char familyName[],
- SkTypeface::Style style)
-{
- load_system_fonts();
-
- SkAutoMutexAcquire ac(gFamilyMutex);
-
- // clip to legal style bits
- style = (SkTypeface::Style)(style & SkTypeface::kBoldItalic);
-
- SkTypeface* tf = NULL;
-
- if (NULL != familyFace) {
- tf = find_typeface(familyFace, style);
- } else if (NULL != familyName) {
- // SkDebugf("======= familyName <%s>\n", familyName);
- tf = find_typeface(familyName, style);
- }
-
- if (NULL == tf) {
- tf = find_best_face(gDefaultFamily, style);
- }
-
- return tf;
-}
-
-SkTypeface* SkFontHost::ResolveTypeface(uint32_t fontID)
-{
- SkAutoMutexAcquire ac(gFamilyMutex);
-
- return resolve_uniqueID(fontID);
-}
-
-SkStream* SkFontHost::OpenStream(uint32_t fontID)
-{
-
- FamilyTypeface* tf = (FamilyTypeface*)SkFontHost::ResolveTypeface(fontID);
- SkStream* stream = tf ? tf->openStream() : NULL;
-
- if (NULL == stream || stream->getLength() == 0) {
- delete stream;
- stream = NULL;
- }
- return stream;
-}
-
-void SkFontHost::CloseStream(uint32_t fontID, SkStream* stream)
-{
- FamilyTypeface* tf = (FamilyTypeface*)SkFontHost::ResolveTypeface(fontID);
- if (NULL != tf) {
- tf->closeStream(stream);
- }
-}
-
-SkScalerContext* SkFontHost::CreateFallbackScalerContext(
- const SkScalerContext::Rec& rec)
-{
- load_system_fonts();
-
- SkAutoDescriptor ad(sizeof(rec) + SkDescriptor::ComputeOverhead(1));
- SkDescriptor* desc = ad.getDesc();
-
- desc->init();
- SkScalerContext::Rec* newRec =
- (SkScalerContext::Rec*)desc->addEntry(kRec_SkDescriptorTag,
- sizeof(rec), &rec);
- newRec->fFontID = gFallBackTypeface->uniqueID();
- desc->computeChecksum();
-
- return SkFontHost::CreateScalerContext(desc);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-SkTypeface* SkFontHost::CreateTypeface(SkStream* stream)
-{
- if (NULL == stream || stream->getLength() <= 0) {
- SkDELETE(stream);
- return NULL;
- }
-
- SkString name;
- SkTypeface::Style style = find_name_and_style(stream, &name);
-
- return SkNEW_ARGS(StreamTypeface, (style, false, NULL, stream));
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-size_t SkFontHost::ShouldPurgeFontCache(size_t sizeAllocatedSoFar)
-{
- if (sizeAllocatedSoFar > FONT_CACHE_MEMORY_BUDGET)
- return sizeAllocatedSoFar - FONT_CACHE_MEMORY_BUDGET;
- else
- return 0; // nothing to do
-}
-
diff --git a/skia/ports/SkFontHost_mac.cpp b/skia/ports/SkFontHost_mac.cpp
deleted file mode 100644
index 9e1151c..0000000
--- a/skia/ports/SkFontHost_mac.cpp
+++ /dev/null
@@ -1,562 +0,0 @@
-/*
- ** Copyright 2006, The Android Open Source Project
- **
- ** Licensed under the Apache License, Version 2.0 (the "License");
- ** you may not use this file except in compliance with the License.
- ** You may obtain a copy of the License at
- **
- ** http://www.apache.org/licenses/LICENSE-2.0
- **
- ** Unless required by applicable law or agreed to in writing, software
- ** distributed under the License is distributed on an "AS IS" BASIS,
- ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- ** See the License for the specific language governing permissions and
- ** limitations under the License.
-*/
-
-#include "SkFontHost.h"
-#include "SkDescriptor.h"
-
-// Give 1MB font cache budget
-#define FONT_CACHE_MEMORY_BUDGET (1024 * 1024)
-
-const char* gDefaultfont = "Arial"; // hard code for now
-static SkMutex gFTMutex;
-
-inline SkPoint F32PtToSkPoint(const Float32Point p)
-{
- SkPoint sp = { SkFloatToFixed(p.x),SkFloatToFixed(p.y) };
- return sp;
-}
-
-static inline uint32_t _rotl(uint32_t v, uint32_t r)
-{
- return (v << r | v >> (32 - r));
-}
-
-// This will generate a unique ID based on the fontname + fontstyle
-// and also used by upper layer
-uint32_t FontFaceChecksum(const char *name,SkTypeface::Style style)
-{
- if (!name) return style;
-
- char* q = (char*)name;
-
- // From "Performance in Practice of String Hashing Functions"
- // Ramakrishna & Zobel
- const uint32_t L = 5;
- const uint32_t R = 2;
-
- uint32_t h = 0x12345678;
- while (*q) {
- uint32_t ql = tolower(*q);
- h ^= ((h << L) + (h >> R) + ql);
- q ++;
- }
-
- // add style
- h = _rotl(h, 3) ^ style;
-
- return h;
-}
-
-#pragma mark -
-struct SkFaceRec {
- SkFaceRec* fNext;
- uint32_t fRefCnt;
- ATSUFontID fFontID;
- ATSUStyle fStyle;
-
- SkFaceRec() : fFontID(0), fRefCnt(0), fStyle(NULL) {};
-
- ~SkFaceRec() {
- if (fStyle) {
- ::ATSUDisposeStyle(fStyle);
- fStyle = NULL;
- }
- }
-
- uint32_t ref() {
- return ++fRefCnt;
- }
-};
-
-// Font Face list
-static SkFaceRec* gFaceRecHead = NULL;
-
-static SkFaceRec* find_ft_face(const ATSUFontID fontID) {
- SkFaceRec* rec = gFaceRecHead;
- while (rec) {
- if (rec->fFontID == fontID) {
- return rec;
- }
- rec = rec->fNext;
- }
-
- return NULL;
-}
-
-static SkFaceRec* insert_ft_face(const ATSUFontID afontID, const ATSUStyle atsuStyle) {
- SkFaceRec* rec = find_ft_face(afontID);
- if (rec) {
- return rec; // found?
- }
-
- rec = SkNEW(SkFaceRec);
- rec->fFontID = afontID;
- rec->fStyle = atsuStyle;
- rec->fNext = gFaceRecHead;
- gFaceRecHead = rec;
-
- return rec;
-}
-
-static void unref_ft_face(const ATSUFontID fontID) {
-
- SkFaceRec* rec = gFaceRecHead;
- SkFaceRec* prev = NULL;
- while (rec) {
- SkFaceRec* next = rec->fNext;
- if (rec->fFontID == fontID) {
- if (--rec->fRefCnt == 0) {
- if (prev)
- prev->fNext = next;
- else
- gFaceRecHead = next;
-
- SkDELETE(rec);
- }
- return;
- }
- prev = rec;
- rec = next;
- }
- SkASSERT("shouldn't get here, face not in list");
-}
-
-#pragma mark -
-
-// have to do this because SkTypeface::SkTypeface() is protected
-class SkTypeface_Mac : public SkTypeface {
-public:
- SkTypeface_Mac(SkTypeface::Style style, uint32_t id) : SkTypeface(style, id) {}
-
- ~SkTypeface_Mac() {}
-};
-
-#pragma mark -
-
-static SkTypeface* CreateTypeface_(const char *name, const SkTypeface::Style style) {
-
- OSStatus err;
- ATSUStyle atsuStyle;
- ::ATSUCreateStyle(&atsuStyle);
- if (name != NULL) {
- static const ATSUAttributeTag fontTag = kATSUFontTag;
- static const ByteCount fontTagSize = sizeof(ATSUFontID);
-
- ATSUFontID fontID = 0;
-#if 1
- err = ::ATSUFindFontFromName(
- name,strlen(name),kFontNoNameCode, /* instead of regular, kFontFamilyName returns bold and/or italic sometimes, but why this works?? */
- kFontMacintoshPlatform,kFontNoScriptCode,kFontNoLanguageCode,&fontID);
-#else
- CFStringRef cfontName = CFStringCreateWithCString(NULL, name, kCFStringEncodingASCII);
- ATSFontRef fontRef = ::ATSFontFindFromName(cfontName,kATSOptionFlagsDefault);
- fontID = ::FMGetFontFromATSFontRef(fontRef);
- CFRelease(cfontName);
-#endif
- if (0 != fontID) {
- const ATSUAttributeValuePtr values[] = { &fontID };
- err = ::ATSUSetAttributes(atsuStyle,1,&fontTag,&fontTagSize,values);
- }
- else {
- }
- }
- if (style != SkTypeface::kNormal) {
- Boolean fontItalic = ((style & SkTypeface::kItalic) != 0);
- Boolean fontBold = ((style & SkTypeface::kBold) != 0);
- const ATSUAttributeTag tags[2] = { kATSUQDBoldfaceTag, kATSUQDItalicTag };
- const ATSUAttributeValuePtr values[2] = { &fontBold, &fontItalic };
- const ByteCount sizes[2] = { sizeof(Boolean), sizeof(Boolean) };
- err = ::ATSUSetAttributes(atsuStyle,2,tags,sizes,values);
- }
-
- uint32_t cs = FontFaceChecksum(name,style);
- SkTypeface_Mac* ptypeface = new SkTypeface_Mac(style,cs);
-
- if (NULL == ptypeface) {
- SkASSERT(false);
- return NULL;
- }
-
- SkFaceRec* rec = insert_ft_face(cs, atsuStyle);
- SkASSERT(rec);
-
- return ptypeface;
-}
-
-static SkTypeface* CreateTypeface_(const SkFaceRec* rec, const SkTypeface::Style style) {
-
- OSStatus err;
- ATSUStyle atsuStyle;
- err = ::ATSUCreateAndCopyStyle(rec->fStyle, &atsuStyle);
-
- Boolean fontItalic = ((style & SkTypeface::kItalic) != 0);
- Boolean fontBold = ((style & SkTypeface::kBold) != 0);
- const ATSUAttributeTag tags[2] = { kATSUQDBoldfaceTag, kATSUQDItalicTag };
- const ATSUAttributeValuePtr values[2] = { &fontBold, &fontItalic };
- const ByteCount sizes[2] = { sizeof(Boolean), sizeof(Boolean) };
- err = ::ATSUSetAttributes(atsuStyle,2,tags,sizes,values);
-
- // get old font id and name
- ATSUFontID fontID = 0;
- ByteCount actual = 0;
- err = ::ATSUGetAttribute(rec->fStyle,kATSUFontTag,sizeof(ATSUFontID),&fontID,&actual);
-
- ByteCount actualLength = 0;
- char *fontname = NULL;
- err = ::ATSUFindFontName(fontID , kFontFamilyName, kFontUnicodePlatform, kFontNoScriptCode,
- kFontNoLanguageCode , 0 , NULL , &actualLength , NULL );
- if ( err == noErr)
- {
- actualLength += 1 ;
- fontname = (char*)malloc( actualLength );
- err = ::ATSUFindFontName(fontID, kFontFamilyName, kFontUnicodePlatform, kFontNoScriptCode,
- kFontNoLanguageCode, actualLength, fontname , NULL, NULL);
- }
-
- SkTypeface_Mac* ptypeface = NULL;
- if (fontname == NULL) {
- ptypeface = new SkTypeface_Mac(style,rec->fFontID);
- return ptypeface;
- }
- else {
- uint32_t cs = FontFaceChecksum(fontname,style);
- ptypeface = new SkTypeface_Mac(style, cs);
-
- if (NULL == ptypeface) {
- SkASSERT(false);
- return NULL;
- }
-
- free(fontname);
-
- insert_ft_face(cs,atsuStyle);
- }
- return ptypeface;
-}
-
-#pragma mark -
-
-class SkScalerContext_Mac : public SkScalerContext {
-public:
- SkScalerContext_Mac(const SkDescriptor* desc);
- virtual ~SkScalerContext_Mac();
-
-protected:
- virtual unsigned generateGlyphCount() const;
- 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 generateLineHeight(SkPoint* ascent, SkPoint* descent);
- virtual void generateFontMetrics(SkPaint::FontMetrics* mX, SkPaint::FontMetrics* mY);
- virtual SkDeviceContext getDC() { return NULL; } // not implemented on Mac
-
-private:
- ATSUTextLayout fLayout;
- ATSUStyle fStyle;
-
- static OSStatus MoveTo(const Float32Point *pt, void *cb);
- static OSStatus Line(const Float32Point *pt, void *cb);
- static OSStatus Curve(const Float32Point *pt1, const Float32Point *pt2, const Float32Point *pt3, void *cb);
- static OSStatus Close(void *cb);
-};
-
-SkScalerContext_Mac::SkScalerContext_Mac(const SkDescriptor* desc)
- : SkScalerContext(desc), fLayout(0), fStyle(0)
-{
- SkAutoMutexAcquire ac(gFTMutex);
- OSStatus err;
-
- SkFaceRec* rec = find_ft_face(fRec.fFontID);
- if (rec) {
- rec->ref();
- err = ::ATSUCreateAndCopyStyle(rec->fStyle, &fStyle);
- }
- else {
- SkASSERT(false);
- // create a default
- err = ::ATSUCreateStyle(&fStyle);
- }
-
- uint32_t size = SkFixedFloor(fRec.fTextSize);
- Fixed fixedSize = IntToFixed(size);
- static const ATSUAttributeTag sizeTag = kATSUSizeTag;
- static const ByteCount sizeTagSize = sizeof(Fixed);
- const ATSUAttributeValuePtr values[] = { &fixedSize };
- err = ::ATSUSetAttributes(fStyle,1,&sizeTag,&sizeTagSize,values);
-
- err = ::ATSUCreateTextLayout(&fLayout);
-}
-
-SkScalerContext_Mac::~SkScalerContext_Mac()
-{
- unref_ft_face(fRec.fFontID);
-
- ::ATSUDisposeTextLayout(fLayout);
- ::ATSUDisposeStyle(fStyle);
-}
-
-unsigned SkScalerContext_Mac::generateGlyphCount() const
-{
- return 0xFFFF;
-}
-
-uint16_t SkScalerContext_Mac::generateCharToGlyph(SkUnichar uni)
-{
- SkAutoMutexAcquire ac(gFTMutex);
-
- OSStatus err;
- UniChar achar = uni;
- err = ::ATSUSetTextPointerLocation(fLayout,&achar,0,1,1);
- err = ::ATSUSetRunStyle(fLayout,fStyle,kATSUFromTextBeginning,kATSUToTextEnd);
-
- ATSLayoutRecord *layoutPtr;
- ItemCount count;
- ATSGlyphRef glyph;
-
- err = ::ATSUDirectGetLayoutDataArrayPtrFromTextLayout(fLayout,0,kATSUDirectDataLayoutRecordATSLayoutRecordCurrent,(void**)&layoutPtr,&count);
- glyph = layoutPtr->glyphID;
- ::ATSUDirectReleaseLayoutDataArrayPtr(NULL,kATSUDirectDataLayoutRecordATSLayoutRecordCurrent,(void**)&layoutPtr);
- return glyph;
-}
-
-void SkScalerContext_Mac::generateAdvance(SkGlyph* glyph) {
- this->generateMetrics(glyph);
-}
-
-void SkScalerContext_Mac::generateMetrics(SkGlyph* glyph)
-{
- GlyphID glyphID = glyph->fID;
- ATSGlyphScreenMetrics metrics= { 0 };
-
- glyph->fRsbDelta = 0;
- glyph->fLsbDelta = 0;
-
- OSStatus err = ATSUGlyphGetScreenMetrics(fStyle,1,&glyphID,0,true,true,&metrics);
- if (err == noErr) {
- glyph->fAdvanceX = SkFloatToFixed(metrics.deviceAdvance.x);
- glyph->fAdvanceY = SkFloatToFixed(metrics.deviceAdvance.y);
- //glyph->fWidth = metrics.width;
- //glyph->fHeight = metrics.height;
- glyph->fWidth = metrics.width + ceil(metrics.sideBearing.x - metrics.otherSideBearing.x);
- glyph->fHeight = metrics.height + ceil(metrics.sideBearing.y - metrics.otherSideBearing.y) + 1;
-
- glyph->fTop = -metrics.topLeft.y;
- glyph->fLeft = metrics.topLeft.x;
- }
-}
-
-void SkScalerContext_Mac::generateFontMetrics(SkPaint::FontMetrics* mx, SkPaint::FontMetrics* my) {
- //SkASSERT(false);
- if (mx)
- memset(mx, 0, sizeof(SkPaint::FontMetrics));
- if (my)
- memset(my, 0, sizeof(SkPaint::FontMetrics));
- return;
-}
-
-void SkScalerContext_Mac::generateImage(const SkGlyph& glyph)
-{
- SkAutoMutexAcquire ac(gFTMutex);
-
- GlyphID glyphID = glyph.fID;
- ATSGlyphScreenMetrics metrics= { 0 };
-
- SkASSERT(fLayout);
- OSStatus err = ::ATSUGlyphGetScreenMetrics(fStyle,1,&glyphID,0,true,true,&metrics);
-
-// uint32_t w = metrics.width;
-// uint32_t h = metrics.height;
-// uint32_t pitch = (w + 3) & ~0x3;
-// if (pitch != glyph.rowBytes()) {
-// SkASSERT(false); // it's different from previously cacluated in generateMetrics(), so the size of glyph.fImage buffer is incorrect!
-// }
-
- CGColorSpaceRef greyColorSpace = ::CGColorSpaceCreateWithName(kCGColorSpaceGenericGray);
- CGContextRef contextRef = ::CGBitmapContextCreate((uint8_t*)glyph.fImage, glyph.fWidth, glyph.fHeight, 8, glyph.rowBytes(), greyColorSpace, kCGImageAlphaNone);
- if (!contextRef) {
- SkASSERT(false);
- return;
- }
-
- ::CGContextSetFillColorSpace(contextRef, greyColorSpace);
- ::CGContextSetStrokeColorSpace(contextRef, greyColorSpace);
-
- ::CGContextSetGrayFillColor(contextRef, 0.0, 1.0);
- ::CGContextFillRect(contextRef, ::CGRectMake(0, 0, glyph.fWidth, glyph.fHeight));
-
- ::CGContextSetGrayFillColor(contextRef, 1.0, 1.0);
- ::CGContextSetGrayStrokeColor(contextRef, 1.0, 1.0);
- ::CGContextSetTextDrawingMode(contextRef, kCGTextFill);
-
- ATSUAttributeTag tag = kATSUCGContextTag;
- ByteCount size = sizeof(CGContextRef);
- ATSUAttributeValuePtr value = &contextRef;
- err = ::ATSUSetLayoutControls(fLayout,1,&tag,&size,&value);
- err = ::ATSUDrawText(fLayout,kATSUFromTextBeginning,kATSUToTextEnd,FloatToFixed(-metrics.topLeft.x),FloatToFixed(glyph.fHeight-metrics.topLeft.y));
- ::CGContextRelease(contextRef);
-}
-
-void SkScalerContext_Mac::generatePath(const SkGlyph& glyph, SkPath* path)
-{
- SkAutoMutexAcquire ac(gFTMutex);
- OSStatus err,result;
-
- err = ::ATSUGlyphGetCubicPaths(
- fStyle,glyph.fID,
- &SkScalerContext_Mac::MoveTo,
- &SkScalerContext_Mac::Line,
- &SkScalerContext_Mac::Curve,
- &SkScalerContext_Mac::Close,
- path,&result);
- SkASSERT(err == noErr);
-}
-
-void SkScalerContext_Mac::generateLineHeight(SkPoint* ascent, SkPoint* descent)
-{
- ATSUTextMeasurement textAscent, textDescent;
- ByteCount actual = 0;
- OSStatus err = ::ATSUGetAttribute(fStyle,kATSULineAscentTag,sizeof(ATSUTextMeasurement),&textAscent,&actual);
- ascent->set(0,textAscent);
- err = ::ATSUGetAttribute(fStyle,kATSULineDescentTag,sizeof(ATSUTextMeasurement),&textDescent,&actual);
- descent->set(0,textDescent);
-}
-
-OSStatus SkScalerContext_Mac::MoveTo(const Float32Point *pt, void *cb)
-{
- reinterpret_cast<SkPath*>(cb)->moveTo(F32PtToSkPoint(*pt));
- return noErr;
-}
-
-OSStatus SkScalerContext_Mac::Line(const Float32Point *pt, void *cb)
-{
- reinterpret_cast<SkPath*>(cb)->lineTo(F32PtToSkPoint(*pt));
- return noErr;
-}
-
-OSStatus SkScalerContext_Mac::Curve(const Float32Point *pt1, const Float32Point *pt2, const Float32Point *pt3, void *cb)
-{
- reinterpret_cast<SkPath*>(cb)->cubicTo(F32PtToSkPoint(*pt1),F32PtToSkPoint(*pt2),F32PtToSkPoint(*pt3));
- return noErr;
-}
-
-OSStatus SkScalerContext_Mac::Close(void *cb)
-{
- reinterpret_cast<SkPath*>(cb)->close();
- return noErr;
-}
-
-#pragma mark -
-
-void SkFontHost::Serialize(const SkTypeface* face, SkWStream* stream) {
- SkASSERT(!"SkFontHost::Serialize unimplemented");
-}
-
-SkTypeface* SkFontHost::Deserialize(SkStream* stream) {
- SkASSERT(!"SkFontHost::Deserialize unimplemented");
- return NULL;
-}
-
-SkTypeface* SkFontHost::CreateTypeface(SkStream* stream) {
-
- //Should not be used on Mac, keep linker happy
- SkASSERT(false);
- return CreateTypeface_(gDefaultfont,SkTypeface::kNormal);
-}
-
-SkScalerContext* SkFontHost::CreateScalerContext(const SkDescriptor* desc)
-{
- return new SkScalerContext_Mac(desc);
-}
-
-SkScalerContext* SkFontHost::CreateFallbackScalerContext(const SkScalerContext::Rec& rec)
-{
- SkAutoDescriptor ad(sizeof(rec) + sizeof(gDefaultfont) + SkDescriptor::ComputeOverhead(2));
- SkDescriptor* desc = ad.getDesc();
-
- desc->init();
- SkScalerContext::Rec* newRec =
- (SkScalerContext::Rec*)desc->addEntry(kRec_SkDescriptorTag, sizeof(rec), &rec);
-
- CreateTypeface_(gDefaultfont,SkTypeface::kNormal);
- newRec->fFontID = FontFaceChecksum(gDefaultfont,SkTypeface::kNormal);
- desc->computeChecksum();
-
- return SkFontHost::CreateScalerContext(desc);
-}
-
-
- /** Return the closest matching typeface given either an existing family
- (specified by a typeface in that family) or by a familyName, and a
- requested style.
- 1) If familyFace is null, use famillyName.
- 2) If famillyName is null, use familyFace.
- 3) If both are null, return the default font that best matches style
- This MUST not return NULL.
- */
-
-SkTypeface* SkFontHost::FindTypeface(const SkTypeface* familyFace, const char familyName[], SkTypeface::Style style) {
-
- SkAutoMutexAcquire ac(gFTMutex);
-
- // clip to legal style bits
- style = (SkTypeface::Style)(style & SkTypeface::kBoldItalic);
-
- SkTypeface* tf = NULL;
-
- if (NULL == familyFace && NULL == familyName) {
- tf = CreateTypeface_(gDefaultfont,style);
- }
- else {
- if (NULL != familyFace) {
- uint32_t id = familyFace->uniqueID();
- SkFaceRec* rec = find_ft_face(id);
- if (!rec) {
- SkASSERT(false);
- tf = CreateTypeface_(gDefaultfont,style);
- }
- else {
- tf = CreateTypeface_(rec,style);
- }
- }
- else {
- tf = CreateTypeface_(familyName,style);
- }
- }
-
- if (NULL == tf) {
- tf = CreateTypeface_(gDefaultfont,style);
- }
- return tf;
-
-}
-
-size_t SkFontHost::ShouldPurgeFontCache(size_t sizeAllocatedSoFar) {
- if (sizeAllocatedSoFar > FONT_CACHE_MEMORY_BUDGET)
- return sizeAllocatedSoFar - FONT_CACHE_MEMORY_BUDGET;
- else
- return 0; // nothing to do
-}
-
-int SkFontHost::ComputeGammaFlag(const SkPaint& paint) {
- return 0;
-}
-
-void SkFontHost::GetGammaTables(const uint8_t* tables[2]) {
- tables[0] = NULL; // black gamma (e.g. exp=1.4)
- tables[1] = NULL; // white gamma (e.g. exp= 1/1.4)
-}
diff --git a/skia/ports/SkFontHost_none.cpp b/skia/ports/SkFontHost_none.cpp
deleted file mode 100644
index b45cf16..0000000
--- a/skia/ports/SkFontHost_none.cpp
+++ /dev/null
@@ -1,82 +0,0 @@
-/* Copyright 2006-2008, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
-**
-** http://www.apache.org/licenses/LICENSE-2.0
-**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
-** limitations under the License.
-*/
-
-#include "SkFontHost.h"
-
-SkTypeface* SkFontHost::FindTypeface(const SkTypeface* familyFace,
- const char famillyName[],
- SkTypeface::Style style) {
- SkASSERT(!"SkFontHost::FindTypeface unimplemented");
- return NULL;
-}
-
-SkTypeface* SkFontHost::ResolveTypeface(uint32_t uniqueID) {
- SkASSERT(!"SkFontHost::ResolveTypeface unimplemented");
- return NULL;
-}
-
-SkStream* SkFontHost::OpenStream(uint32_t uniqueID) {
- SkASSERT(!"SkFontHost::OpenStream unimplemented");
- return NULL;
-}
-
-void SkFontHost::CloseStream(uint32_t uniqueID, SkStream*) {
- SkASSERT(!"SkFontHost::CloseStream unimplemented");
-}
-
-SkTypeface* SkFontHost::CreateTypeface(SkStream*) {
- SkASSERT(!"SkFontHost::CreateTypeface unimplemented");
- return NULL;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-void SkFontHost::Serialize(const SkTypeface* face, SkWStream* stream) {
- SkASSERT(!"SkFontHost::Serialize unimplemented");
-}
-
-SkTypeface* SkFontHost::Deserialize(SkStream* stream) {
- SkASSERT(!"SkFontHost::Deserialize unimplemented");
- return NULL;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-SkScalerContext* SkFontHost::CreateScalerContext(const SkDescriptor* desc) {
- SkASSERT(!"SkFontHost::CreateScalarContext unimplemented");
- return NULL;
-}
-
-SkScalerContext* SkFontHost::CreateFallbackScalerContext(
- const SkScalerContext::Rec&) {
- SkASSERT(!"SkFontHost::CreateFallbackScalerContext unimplemented");
- return NULL;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-size_t SkFontHost::ShouldPurgeFontCache(size_t sizeAllocatedSoFar) {
- return 0; // nothing to do (change me if you want to limit the font cache)
-}
-
-int SkFontHost::ComputeGammaFlag(const SkPaint& paint) {
- return 0;
-}
-
-void SkFontHost::GetGammaTables(const uint8_t* tables[2]) {
- tables[0] = NULL; // black gamma (e.g. exp=1.4)
- tables[1] = NULL; // white gamma (e.g. exp= 1/1.4)
-}
-
diff --git a/skia/ports/SkFontHost_tables.cpp b/skia/ports/SkFontHost_tables.cpp
deleted file mode 100644
index fdf0b06..0000000
--- a/skia/ports/SkFontHost_tables.cpp
+++ /dev/null
@@ -1,183 +0,0 @@
-#include "SkEndian.h"
-#include "SkFontHost.h"
-#include "SkStream.h"
-
-struct SkSFNTHeader {
- uint32_t fVersion;
- uint16_t fNumTables;
- uint16_t fSearchRange;
- uint16_t fEntrySelector;
- uint16_t fRangeShift;
-};
-
-struct SkTTCFHeader {
- uint32_t fTag;
- uint32_t fVersion;
- uint32_t fNumOffsets;
- uint32_t fOffset0; // the first of N (fNumOffsets)
-};
-
-union SkSharedTTHeader {
- SkSFNTHeader fSingle;
- SkTTCFHeader fCollection;
-};
-
-struct SkSFNTDirEntry {
- uint32_t fTag;
- uint32_t fChecksum;
- uint32_t fOffset;
- uint32_t fLength;
-};
-
-static int count_tables(SkStream* stream, size_t* offsetToDir = NULL) {
- SkSharedTTHeader shared;
- if (stream->read(&shared, sizeof(shared)) != sizeof(shared)) {
- return 0;
- }
-
- uint32_t tag = SkEndian_SwapBE32(shared.fCollection.fTag);
- if (SkSetFourByteTag('t', 't', 'c', 'f') == tag) {
- if (shared.fCollection.fNumOffsets == 0) {
- return 0;
- }
- size_t offset = SkEndian_SwapBE32(shared.fCollection.fOffset0);
- stream->rewind();
- if (stream->skip(offset) != offset) {
- return 0;
- }
- if (stream->read(&shared, sizeof(shared)) != sizeof(shared)) {
- return 0;
- }
- if (offsetToDir) {
- *offsetToDir = offset;
- }
- } else {
- *offsetToDir = 0;
- }
-
- return SkEndian_SwapBE16(shared.fSingle.fNumTables);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-struct SfntHeader {
- SfntHeader() : fCount(0), fDir(NULL) {}
- ~SfntHeader() { sk_free(fDir); }
-
- bool init(SkStream* stream) {
- size_t offsetToDir;
- fCount = count_tables(stream, &offsetToDir);
- if (0 == fCount) {
- return false;
- }
-
- stream->rewind();
- const size_t tableRecordOffset = offsetToDir + sizeof(SkSFNTHeader);
- if (stream->skip(tableRecordOffset) != tableRecordOffset) {
- return false;
- }
-
- size_t size = fCount * sizeof(SkSFNTDirEntry);
- fDir = reinterpret_cast<SkSFNTDirEntry*>(sk_malloc_throw(size));
- return stream->read(fDir, size) == size;
- }
-
- int fCount;
- SkSFNTDirEntry* fDir;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-
-int SkFontHost::CountTables(SkFontID fontID) {
- SkStream* stream = SkFontHost::OpenStream(fontID);
- if (NULL == stream) {
- return 0;
- }
-
- SkAutoUnref au(stream);
- return count_tables(stream);
-}
-
-int SkFontHost::GetTableTags(SkFontID fontID, SkFontTableTag tags[]) {
- SkStream* stream = SkFontHost::OpenStream(fontID);
- if (NULL == stream) {
- return 0;
- }
-
- SkAutoUnref au(stream);
- SfntHeader header;
- if (!header.init(stream)) {
- return 0;
- }
-
- for (int i = 0; i < header.fCount; i++) {
- tags[i] = SkEndian_SwapBE32(header.fDir[i].fTag);
- }
- return header.fCount;
-}
-
-size_t SkFontHost::GetTableSize(SkFontID fontID, SkFontTableTag tag) {
- SkStream* stream = SkFontHost::OpenStream(fontID);
- if (NULL == stream) {
- return 0;
- }
-
- SkAutoUnref au(stream);
- SfntHeader header;
- if (!header.init(stream)) {
- return 0;
- }
-
- for (int i = 0; i < header.fCount; i++) {
- if (SkEndian_SwapBE32(header.fDir[i].fTag) == tag) {
- return SkEndian_SwapBE32(header.fDir[i].fLength);
- }
- }
- return 0;
-}
-
-size_t SkFontHost::GetTableData(SkFontID fontID, SkFontTableTag tag,
- size_t offset, size_t length, void* data) {
- SkStream* stream = SkFontHost::OpenStream(fontID);
- if (NULL == stream) {
- return 0;
- }
-
- SkAutoUnref au(stream);
- SfntHeader header;
- if (!header.init(stream)) {
- return 0;
- }
-
- for (int i = 0; i < header.fCount; i++) {
- if (SkEndian_SwapBE32(header.fDir[i].fTag) == tag) {
- size_t realOffset = SkEndian_SwapBE32(header.fDir[i].fOffset);
- size_t realLength = SkEndian_SwapBE32(header.fDir[i].fLength);
- // now sanity check the caller's offset/length
- if (offset >= realLength) {
- return 0;
- }
- // if the caller is trusting the length from the file, then a
- // hostile file might choose a value which would overflow offset +
- // length.
- if (offset + length < offset) {
- return 0;
- }
- if (offset + length > realLength) {
- length = realLength - offset;
- }
- // skip the stream to the part of the table we want to copy from
- stream->rewind();
- size_t bytesToSkip = realOffset + offset;
- if (stream->skip(bytesToSkip) != bytesToSkip) {
- return 0;
- }
- if (stream->read(data, length) != length) {
- return 0;
- }
- return length;
- }
- }
- return 0;
-}
-
diff --git a/skia/ports/SkFontHost_win.cpp b/skia/ports/SkFontHost_win.cpp
deleted file mode 100644
index 4df55c9..0000000
--- a/skia/ports/SkFontHost_win.cpp
+++ /dev/null
@@ -1,1202 +0,0 @@
-/*
-
- ** Copyright 2006, The Android Open Source Project
-
- **
-
- ** Licensed under the Apache License, Version 2.0 (the "License");
-
- ** you may not use this file except in compliance with the License.
-
- ** You may obtain a copy of the License at
-
- **
-
- ** http://www.apache.org/licenses/LICENSE-2.0
-
- **
-
- ** Unless required by applicable law or agreed to in writing, software
-
- ** distributed under the License is distributed on an "AS IS" BASIS,
-
- ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-
- ** See the License for the specific language governing permissions and
-
- ** limitations under the License.
-
- */
-
-
-
-#include "SkString.h"
-
-//#include "SkStream.h"
-
-
-
-#include "SkFontHost.h"
-
-#include "SkDescriptor.h"
-
-#include "SkThread.h"
-
-
-
-#ifdef WIN32
-
-#include "windows.h"
-
-#include "tchar.h"
-
-
-
-// client3d has to undefine this for now
-
-#define CAN_USE_LOGFONT_NAME
-
-
-
-static SkMutex gFTMutex;
-
-
-
-// these globals are loaded (once) by get_default_font()
-
-static LOGFONT gDefaultFont = {0};
-
-
-
-static const uint16_t BUFFERSIZE = (16384 - 32);
-
-static uint8_t glyphbuf[BUFFERSIZE];
-
-
-
-// Give 1MB font cache budget
-
-#define FONT_CACHE_MEMORY_BUDGET (1024 * 1024)
-
-
-
-static inline FIXED SkFixedToFIXED(SkFixed x) {
-
- return *(FIXED*)(&x);
-
-}
-
-
-
-static inline FIXED SkScalarToFIXED(SkScalar x) {
-
- return SkFixedToFIXED(SkScalarToFixed(x));
-
-}
-
-
-
-// This will generate a unique ID based on the fontname + fontstyle
-
-// and also used by upper layer
-
-uint32_t FontFaceChecksum(const TCHAR *q, SkTypeface::Style style)
-
-{
-
- if (!q) return style;
-
-
-
- // From "Performance in Practice of String Hashing Functions"
-
- // Ramakrishna & Zobel
-
- const uint32_t L = 5;
-
- const uint32_t R = 2;
-
-
-
- uint32_t h = 0x12345678;
-
- while (*q) {
-
- //uint32_t ql = tolower(*q);
-
- h ^= ((h << L) + (h >> R) + *q);
-
- q ++;
-
- }
-
-
-
- // add style
-
- h = _rotl(h, 3) ^ style;
-
-
-
- return h;
-
-}
-
-
-
-static SkTypeface::Style GetFontStyle(const LOGFONT& lf) {
-
- int style = SkTypeface::kNormal;
-
- if (lf.lfWeight == FW_SEMIBOLD || lf.lfWeight == FW_DEMIBOLD || lf.lfWeight == FW_BOLD)
-
- style |= SkTypeface::kBold;
-
- if (lf.lfItalic)
-
- style |= SkTypeface::kItalic;
-
-
-
- return (SkTypeface::Style)style;
-
-}
-
-
-
-struct SkFaceRec {
-
- SkFaceRec* fNext;
-
- uint32_t fRefCnt;
-
- uint32_t fFontID; // checksum of fFace
-
- LOGFONT fFace;
-
-
-
- SkFaceRec() : fFontID(-1), fRefCnt(0) {
-
- memset(&fFace, 0, sizeof(LOGFONT));
-
- }
-
- ~SkFaceRec() {}
-
-
-
- uint32_t ref() {
-
- return ++fRefCnt;
-
- }
-
-};
-
-
-
-// Font Face list
-
-static SkFaceRec* gFaceRecHead = NULL;
-
-
-
-static SkFaceRec* find_ft_face(uint32_t fontID) {
-
- SkFaceRec* rec = gFaceRecHead;
-
- while (rec) {
-
- if (rec->fFontID == fontID) {
-
- return rec;
-
- }
-
- rec = rec->fNext;
-
- }
-
-
-
- return NULL;
-
-}
-
-
-
-static SkFaceRec* insert_ft_face(const LOGFONT& lf) {
-
- // need a const char*
-
- uint32_t id = FontFaceChecksum(&(lf.lfFaceName[0]), GetFontStyle(lf));
-
- SkFaceRec* rec = find_ft_face(id);
-
- if (rec) {
-
- return rec; // found?
-
- }
-
-
-
- rec = SkNEW(SkFaceRec);
-
- rec->fFontID = id;
-
- memcpy(&(rec->fFace), &lf, sizeof(LOGFONT));
-
- rec->fNext = gFaceRecHead;
-
- gFaceRecHead = rec;
-
-
-
- return rec;
-
-}
-
-
-
-static void unref_ft_face(uint32_t fontID) {
-
-
-
- SkFaceRec* rec = gFaceRecHead;
-
- SkFaceRec* prev = NULL;
-
- while (rec) {
-
- SkFaceRec* next = rec->fNext;
-
- if (rec->fFontID == fontID) {
-
- if (--rec->fRefCnt == 0) {
-
- if (prev)
-
- prev->fNext = next;
-
- else
-
- gFaceRecHead = next;
-
-
-
- SkDELETE(rec);
-
- }
-
- return;
-
- }
-
- prev = rec;
-
- rec = next;
-
- }
-
- SkASSERT("shouldn't get here, face not in list");
-
-}
-
-
-
-// have to do this because SkTypeface::SkTypeface() is protected
-
-class FontFaceRec_Typeface : public SkTypeface {
-
-public:
-
-
-
- FontFaceRec_Typeface(Style style, uint32_t id) : SkTypeface(style, id) {};
-
-
-
- virtual ~FontFaceRec_Typeface() {};
-
-};
-
-
-
-static const LOGFONT* get_default_font() {
-
- // don't hardcode on Windows, Win2000, XP, Vista, and international all have different default
-
- // and the user could change too
-
-
-
- if (gDefaultFont.lfFaceName[0] != 0) {
-
- return &gDefaultFont;
-
- }
-
-
-
- NONCLIENTMETRICS ncm;
-
- ncm.cbSize = sizeof(NONCLIENTMETRICS);
-
- SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(ncm), &ncm, 0);
-
-
-
- memcpy(&gDefaultFont, &(ncm.lfMessageFont), sizeof(LOGFONT));
-
-
-
- return &gDefaultFont;
-
-}
-
-
-
-static SkTypeface* CreateTypeface_(const LOGFONT& lf) {
-
-
-
- SkTypeface::Style style = GetFontStyle(lf);
-
- FontFaceRec_Typeface* ptypeface = new FontFaceRec_Typeface(style, FontFaceChecksum(lf.lfFaceName, style));
-
-
-
- if (NULL == ptypeface) {
-
- SkASSERT(false);
-
- return NULL;
-
- }
-
-
-
- SkFaceRec* rec = insert_ft_face(lf);
-
- SkASSERT(rec);
-
-
-
- return ptypeface;
-
-}
-
-
-
-class SkScalerContext_Windows : public SkScalerContext {
-
-public:
-
- SkScalerContext_Windows(const SkDescriptor* desc);
-
- virtual ~SkScalerContext_Windows();
-
-
-
-protected:
-
- virtual unsigned generateGlyphCount() const;
-
- 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 generateLineHeight(SkPoint* ascent, SkPoint* descent);
-
- virtual void generateFontMetrics(SkPaint::FontMetrics* mX, SkPaint::FontMetrics* mY);
-
- //virtual SkDeviceContext getDC() {return ddc;}
-
-private:
-
- uint32_t fFontID;
-
- LOGFONT lf;
-
- MAT2 mat22;
-
- HDC ddc;
-
- HFONT savefont;
-
- HFONT font;
-
-};
-
-
-
-SkScalerContext_Windows::SkScalerContext_Windows(const SkDescriptor* desc) : SkScalerContext(desc), ddc(0), font(0), savefont(0) {
-
- SkAutoMutexAcquire ac(gFTMutex);
-
-
-
- fFontID = fRec.fFontID;
-
- SkFaceRec* rec = find_ft_face(fRec.fFontID);
-
- if (rec) {
-
- rec->ref();
-
- memcpy(&lf, &(rec->fFace), sizeof(LOGFONT));
-
- }
-
- else {
-
- SkASSERT(false);
-
- memcpy(&lf, &gDefaultFont, sizeof(LOGFONT));
-
- }
-
-
-
- mat22.eM11 = SkScalarToFIXED(fRec.fPost2x2[0][0]);
-
- mat22.eM12 = SkScalarToFIXED(-fRec.fPost2x2[0][1]);
-
- mat22.eM21 = SkScalarToFIXED(fRec.fPost2x2[1][0]);
-
- mat22.eM22 = SkScalarToFIXED(-fRec.fPost2x2[1][1]);
-
-
-
- ddc = ::CreateCompatibleDC(NULL);
-
- SetBkMode(ddc, TRANSPARENT);
-
-
-
- lf.lfHeight = SkScalarFloor(fRec.fTextSize);
-
- font = CreateFontIndirect(&lf);
-
- savefont = (HFONT)SelectObject(ddc, font);
-
-}
-
-
-
-SkScalerContext_Windows::~SkScalerContext_Windows() {
-
- unref_ft_face(fFontID);
-
-
-
- if (ddc) {
-
- ::SelectObject(ddc, savefont);
-
- ::DeleteDC(ddc);
-
- ddc = NULL;
-
- }
-
- if (font) {
-
- ::DeleteObject(font);
-
- }
-
-}
-
-
-
-unsigned SkScalerContext_Windows::generateGlyphCount() const {
-
- return 0xFFFF;
-
- // return fFace->num_glyphs;
-
-}
-
-
-
-uint16_t SkScalerContext_Windows::generateCharToGlyph(SkUnichar uni) {
-
-
-
- //uint16_t index = 0;
-
- //GetGlyphIndicesW(ddc, &(uint16_t&)uni, 1, &index, 0);
-
- //return index;
-
-
-
- // let's just use the uni as index on Windows
-
- return SkToU16(uni);
-
-}
-
-
-
-void SkScalerContext_Windows::generateAdvance(SkGlyph* glyph) {
-
- this->generateMetrics(glyph);
-
-}
-
-
-
-void SkScalerContext_Windows::generateMetrics(SkGlyph* glyph) {
-
-
-
- SkASSERT(ddc);
-
-
-
- GLYPHMETRICS gm;
-
- memset(&gm, 0, sizeof(gm));
-
-
-
- glyph->fRsbDelta = 0;
-
- glyph->fLsbDelta = 0;
-
-
-
- UINT glyphIndexFlag = 0; //glyph->fIsCodePoint ? 0 : GGO_GLYPH_INDEX;
-
- // UINT glyphIndexFlag = GGO_GLYPH_INDEX;
-
- // Note: need to use GGO_GRAY8_BITMAP instead of GGO_METRICS because GGO_METRICS returns a smaller
-
- // BlackBlox; we need the bigger one in case we need the image. fAdvance is the same.
-
- uint32_t ret = GetGlyphOutlineW(ddc, glyph->getGlyphID(0), GGO_GRAY8_BITMAP | glyphIndexFlag, &gm, 0, NULL, &mat22);
-
-
-
- if (GDI_ERROR != ret) {
-
- if (ret == 0) {
-
- // for white space, ret is zero and gmBlackBoxX, gmBlackBoxY are 1 incorrectly!
-
- gm.gmBlackBoxX = gm.gmBlackBoxY = 0;
-
- }
-
- glyph->fWidth = gm.gmBlackBoxX;
-
- glyph->fHeight = gm.gmBlackBoxY;
-
- glyph->fTop = SkToS16(gm.gmptGlyphOrigin.y - gm.gmBlackBoxY);
-
- glyph->fLeft = SkToS16(gm.gmptGlyphOrigin.x);
-
- glyph->fAdvanceX = SkIntToFixed(gm.gmCellIncX);
-
- glyph->fAdvanceY = -SkIntToFixed(gm.gmCellIncY);
-
- } else {
-
- glyph->fWidth = 0;
-
- }
-
-
-
-#if 0
-
- char buf[1024];
-
- sprintf(buf, "generateMetrics: id:%d, w=%d, h=%d, font:%s, fh:%d\n", glyph->fID, glyph->fWidth, glyph->fHeight, lf.lfFaceName, lf.lfHeight);
-
- OutputDebugString(buf);
-
-#endif
-
-}
-
-
-
-void SkScalerContext_Windows::generateFontMetrics(SkPaint::FontMetrics* mx, SkPaint::FontMetrics* my) {
-
- //SkASSERT(false);
-
- if (mx)
-
- memset(mx, 0, sizeof(SkPaint::FontMetrics));
-
- if (my)
-
- memset(my, 0, sizeof(SkPaint::FontMetrics));
-
- return;
-
-}
-
-
-
-void SkScalerContext_Windows::generateImage(const SkGlyph& glyph) {
-
-
-
- SkAutoMutexAcquire ac(gFTMutex);
-
-
-
- SkASSERT(ddc);
-
-
-
- GLYPHMETRICS gm;
-
- memset(&gm, 0, sizeof(gm));
-
-
-
-#if 0
-
- char buf[1024];
-
- sprintf(buf, "generateImage: id:%d, w=%d, h=%d, font:%s,fh:%d\n", glyph.fID, glyph.fWidth, glyph.fHeight, lf.lfFaceName, lf.lfHeight);
-
- OutputDebugString(buf);
-
-#endif
-
-
-
- uint32_t bytecount = 0;
-
- UINT glyphIndexFlag = 0; //glyph.fIsCodePoint ? 0 : GGO_GLYPH_INDEX;
-
- // UINT glyphIndexFlag = GGO_GLYPH_INDEX;
-
- uint32_t total_size = GetGlyphOutlineW(ddc, glyph.fID, GGO_GRAY8_BITMAP | glyphIndexFlag, &gm, 0, NULL, &mat22);
-
- if (GDI_ERROR != total_size && total_size > 0) {
-
- uint8_t *pBuff = new uint8_t[total_size];
-
- if (NULL != pBuff) {
-
- total_size = GetGlyphOutlineW(ddc, glyph.fID, GGO_GRAY8_BITMAP | glyphIndexFlag, &gm, total_size, pBuff, &mat22);
-
-
-
- SkASSERT(total_size != GDI_ERROR);
-
-
-
- SkASSERT(glyph.fWidth == gm.gmBlackBoxX);
-
- SkASSERT(glyph.fHeight == gm.gmBlackBoxY);
-
-
-
- uint8_t* dst = (uint8_t*)glyph.fImage;
-
- uint32_t pitch = (gm.gmBlackBoxX + 3) & ~0x3;
-
- if (pitch != glyph.rowBytes()) {
-
- SkASSERT(false); // glyph.fImage has different rowsize!?
-
- }
-
-
-
- for (int32_t y = gm.gmBlackBoxY - 1; y >= 0; y--) {
-
- uint8_t* src = pBuff + pitch * y;
-
-
-
- for (uint32_t x = 0; x < gm.gmBlackBoxX; x++) {
-
- if (*src > 63) {
-
- *dst = 0xFF;
-
- }
-
- else {
-
- *dst = *src << 2; // scale to 0-255
-
- }
-
- dst++;
-
- src++;
-
- bytecount++;
-
- }
-
- memset(dst, 0, glyph.rowBytes() - glyph.fWidth);
-
- dst += glyph.rowBytes() - glyph.fWidth;
-
- }
-
-
-
- delete[] pBuff;
-
- }
-
- }
-
-
-
- SkASSERT(GDI_ERROR != total_size && total_size >= 0);
-
-
-
-}
-
-
-
-void SkScalerContext_Windows::generatePath(const SkGlyph& glyph, SkPath* path) {
-
-
-
- SkAutoMutexAcquire ac(gFTMutex);
-
-
-
- SkASSERT(&glyph && path);
-
- SkASSERT(ddc);
-
-
-
- path->reset();
-
-
-
-#if 0
-
- char buf[1024];
-
- sprintf(buf, "generatePath: id:%d, w=%d, h=%d, font:%s,fh:%d\n", glyph.fID, glyph.fWidth, glyph.fHeight, lf.lfFaceName, lf.lfHeight);
-
- OutputDebugString(buf);
-
-#endif
-
-
-
- GLYPHMETRICS gm;
-
- UINT glyphIndexFlag = 0; //glyph.fIsCodePoint ? 0 : GGO_GLYPH_INDEX;
-
- uint32_t total_size = GetGlyphOutlineW(ddc, glyph.fID, GGO_NATIVE | glyphIndexFlag, &gm, BUFFERSIZE, glyphbuf, &mat22);
-
-
-
- if (GDI_ERROR != total_size) {
-
-
-
- const uint8_t* cur_glyph = glyphbuf;
-
- const uint8_t* end_glyph = glyphbuf + total_size;
-
-
-
- while(cur_glyph < end_glyph) {
-
- const TTPOLYGONHEADER* th = (TTPOLYGONHEADER*)cur_glyph;
-
-
-
- const uint8_t* end_poly = cur_glyph + th->cb;
-
- const uint8_t* cur_poly = cur_glyph + sizeof(TTPOLYGONHEADER);
-
-
-
- path->moveTo(SkFixedToScalar(*(SkFixed*)(&th->pfxStart.x)), SkFixedToScalar(*(SkFixed*)(&th->pfxStart.y)));
-
-
-
- while(cur_poly < end_poly) {
-
- const TTPOLYCURVE* pc = (const TTPOLYCURVE*)cur_poly;
-
-
-
- if (pc->wType == TT_PRIM_LINE) {
-
- for (uint16_t i = 0; i < pc->cpfx; i++) {
-
- path->lineTo(SkFixedToScalar(*(SkFixed*)(&pc->apfx[i].x)), SkFixedToScalar(*(SkFixed*)(&pc->apfx[i].y)));
-
- }
-
- }
-
-
-
- if (pc->wType == TT_PRIM_QSPLINE) {
-
- for (uint16_t u = 0; u < pc->cpfx - 1; u++) { // Walk through points in spline
-
- POINTFX pnt_b = pc->apfx[u]; // B is always the current point
-
- POINTFX pnt_c = pc->apfx[u+1];
-
-
-
- if (u < pc->cpfx - 2) { // If not on last spline, compute C
-
- pnt_c.x = SkFixedToFIXED(SkFixedAve(*(SkFixed*)(&pnt_b.x), *(SkFixed*)(&pnt_c.x)));
-
- pnt_c.y = SkFixedToFIXED(SkFixedAve(*(SkFixed*)(&pnt_b.y), *(SkFixed*)(&pnt_c.y)));
-
- }
-
-
-
- path->quadTo(SkFixedToScalar(*(SkFixed*)(&pnt_b.x)), SkFixedToScalar(*(SkFixed*)(&pnt_b.y)), SkFixedToScalar(*(SkFixed*)(&pnt_c.x)), SkFixedToScalar(*(SkFixed*)(&pnt_c.y)));
-
- }
-
- }
-
- cur_poly += sizeof(uint16_t) * 2 + sizeof(POINTFX) * pc->cpfx;
-
- }
-
- cur_glyph += th->cb;
-
- path->close();
-
- }
-
- }
-
- else {
-
- SkASSERT(false);
-
- }
-
- //char buf[1024];
-
- //sprintf(buf, "generatePath: count:%d\n", count);
-
- //OutputDebugString(buf);
-
-}
-
-
-
-
-
-// Note: not sure this is the correct implementation
-
-void SkScalerContext_Windows::generateLineHeight(SkPoint* ascent, SkPoint* descent) {
-
-
-
- SkASSERT(ddc);
-
-
-
- OUTLINETEXTMETRIC otm;
-
-
-
- uint32_t ret = GetOutlineTextMetrics(ddc, sizeof(otm), &otm);
-
-
-
- if (sizeof(otm) == ret) {
-
- if (ascent)
-
- ascent->iset(0, otm.otmAscent);
-
- if (descent)
-
- descent->iset(0, otm.otmDescent);
-
- }
-
-
-
- return;
-
-}
-
-
-
-void SkFontHost::Serialize(const SkTypeface* face, SkWStream* stream) {
-
- SkASSERT(!"SkFontHost::Serialize unimplemented");
-
-}
-
-
-
-SkTypeface* SkFontHost::Deserialize(SkStream* stream) {
-
- SkASSERT(!"SkFontHost::Deserialize unimplemented");
-
- return NULL;
-
-}
-
-
-
-SkTypeface* SkFontHost::CreateTypeface(SkStream* stream) {
-
-
-
- //Should not be used on Windows, keep linker happy
-
- SkASSERT(false);
-
- get_default_font();
-
- return CreateTypeface_(gDefaultFont);
-
-}
-
-
-
-SkScalerContext* SkFontHost::CreateScalerContext(const SkDescriptor* desc) {
-
- return SkNEW_ARGS(SkScalerContext_Windows, (desc));
-
-}
-
-
-
-SkScalerContext* SkFontHost::CreateFallbackScalerContext(const SkScalerContext::Rec& rec) {
-
- get_default_font();
-
-
-
- SkAutoDescriptor ad(sizeof(rec) + sizeof(gDefaultFont) + SkDescriptor::ComputeOverhead(2));
-
- SkDescriptor* desc = ad.getDesc();
-
-
-
- desc->init();
-
- SkScalerContext::Rec* newRec =
-
- (SkScalerContext::Rec*)desc->addEntry(kRec_SkDescriptorTag, sizeof(rec), &rec);
-
-
-
- get_default_font();
-
- CreateTypeface_(gDefaultFont);
-
- newRec->fFontID = FontFaceChecksum(gDefaultFont.lfFaceName, GetFontStyle(gDefaultFont));
-
- desc->computeChecksum();
-
-
-
- return SkFontHost::CreateScalerContext(desc);
-
-}
-
-
-
-/** Return the closest matching typeface given either an existing family
-
- (specified by a typeface in that family) or by a familyName, and a
-
- requested style.
-
- 1) If familyFace is null, use famillyName.
-
- 2) If famillyName is null, use familyFace.
-
- 3) If both are null, return the default font that best matches style
-
- This MUST not return NULL.
-
- */
-
-
-
-SkTypeface* SkFontHost::FindTypeface(const SkTypeface* familyFace, const char familyName[], SkTypeface::Style style) {
-
-
-
- SkAutoMutexAcquire ac(gFTMutex);
-
-
-
-#ifndef CAN_USE_LOGFONT_NAME
-
- familyName = NULL;
-
- familyFace = NULL;
-
-#endif
-
-
-
- // clip to legal style bits
-
- style = (SkTypeface::Style)(style & SkTypeface::kBoldItalic);
-
-
-
- SkTypeface* tf = NULL;
-
- if (NULL == familyFace && NULL == familyName) {
-
- LOGFONT lf;
-
- get_default_font();
-
- memcpy(&lf, &gDefaultFont, sizeof(LOGFONT));
-
- lf.lfWeight = (style & SkTypeface::kBold) != 0 ? FW_BOLD : FW_NORMAL ;
-
- lf.lfItalic = ((style & SkTypeface::kItalic) != 0);
-
- tf = CreateTypeface_(lf);
-
- } else {
-
-#ifdef CAN_USE_LOGFONT_NAME
-
- LOGFONT lf;
-
- if (NULL != familyFace) {
-
- uint32_t id = familyFace->uniqueID();
-
- SkFaceRec* rec = find_ft_face(id);
-
- if (!rec) {
-
- SkASSERT(false);
-
- get_default_font();
-
- memcpy(&lf, &gDefaultFont, sizeof(LOGFONT));
-
- }
-
- else {
-
- memcpy(&lf, &(rec->fFace), sizeof(LOGFONT));
-
- }
-
- }
-
- else {
-
- memset(&lf, 0, sizeof(LOGFONT));
-
-
-
- lf.lfHeight = -11; // default
-
- lf.lfQuality = PROOF_QUALITY;
-
- lf.lfCharSet = DEFAULT_CHARSET;
-
-
-
- _tcsncpy(lf.lfFaceName, familyName, LF_FACESIZE);
-
- lf.lfFaceName[LF_FACESIZE-1] = '\0';
-
- }
-
-
-
- // use the style desired
-
- lf.lfWeight = (style & SkTypeface::kBold) != 0 ? FW_BOLD : FW_NORMAL ;
-
- lf.lfItalic = ((style & SkTypeface::kItalic) != 0);
-
- tf = CreateTypeface_(lf);
-
-#endif
-
- }
-
-
-
- if (NULL == tf) {
-
- get_default_font();
-
- tf = CreateTypeface_(gDefaultFont);
-
- }
-
- return tf;
-
-}
-
-
-
-size_t SkFontHost::ShouldPurgeFontCache(size_t sizeAllocatedSoFar) {
-
- if (sizeAllocatedSoFar > FONT_CACHE_MEMORY_BUDGET)
-
- return sizeAllocatedSoFar - FONT_CACHE_MEMORY_BUDGET;
-
- else
-
- return 0; // nothing to do
-
-}
-
-
-
-int SkFontHost::ComputeGammaFlag(const SkPaint& paint) {
-
- return 0;
-
-}
-
-
-
-void SkFontHost::GetGammaTables(const uint8_t* tables[2]) {
-
- tables[0] = NULL; // black gamma (e.g. exp=1.4)
-
- tables[1] = NULL; // white gamma (e.g. exp= 1/1.4)
-
-}
-
-
-
-#endif // WIN32
-
-
-
diff --git a/skia/ports/SkGlobals_global.cpp b/skia/ports/SkGlobals_global.cpp
deleted file mode 100644
index d87568b..0000000
--- a/skia/ports/SkGlobals_global.cpp
+++ /dev/null
@@ -1,28 +0,0 @@
-/* libs/graphics/ports/SkGlobals_global.cpp
-**
-** Copyright 2006, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
-**
-** http://www.apache.org/licenses/LICENSE-2.0
-**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
-** limitations under the License.
-*/
-
-#include "SkGlobals.h"
-#include "SkThread.h"
-
-static SkGlobals::BootStrap gBootStrap;
-
-SkGlobals::BootStrap& SkGlobals::GetBootStrap()
-{
- return gBootStrap;
-}
-
-
diff --git a/skia/ports/SkImageDecoder_Factory.cpp b/skia/ports/SkImageDecoder_Factory.cpp
deleted file mode 100644
index bc4e7b2..0000000
--- a/skia/ports/SkImageDecoder_Factory.cpp
+++ /dev/null
@@ -1,135 +0,0 @@
-/* libs/graphics/ports/SkImageDecoder_Factory.cpp
-**
-** Copyright 2006, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
-**
-** http://www.apache.org/licenses/LICENSE-2.0
-**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
-** limitations under the License.
-*/
-
-#include "SkImageDecoder.h"
-#include "SkMovie.h"
-#include "SkStream.h"
-
-extern SkImageDecoder* SkImageDecoder_GIF_Factory(SkStream*);
-extern SkImageDecoder* SkImageDecoder_BMP_Factory(SkStream*);
-extern SkImageDecoder* SkImageDecoder_ICO_Factory(SkStream*);
-extern SkImageDecoder* SkImageDecoder_PNG_Factory(SkStream*);
-extern SkImageDecoder* SkImageDecoder_WBMP_Factory(SkStream*);
-extern SkImageDecoder* SkImageDecoder_JPEG_Factory(SkStream*);
-
-typedef SkImageDecoder* (*SkImageDecoderFactoryProc)(SkStream*);
-
-struct CodecFormat {
- SkImageDecoderFactoryProc fProc;
- SkImageDecoder::Format fFormat;
-};
-
-#ifdef SK_SUPPORT_IMAGE_DECODE
-static const CodecFormat gPairs[] = {
- { SkImageDecoder_GIF_Factory, SkImageDecoder::kGIF_Format },
- { SkImageDecoder_PNG_Factory, SkImageDecoder::kPNG_Format },
- { SkImageDecoder_ICO_Factory, SkImageDecoder::kICO_Format },
- { SkImageDecoder_WBMP_Factory, SkImageDecoder::kWBMP_Format },
- { SkImageDecoder_BMP_Factory, SkImageDecoder::kBMP_Format },
- { SkImageDecoder_JPEG_Factory, SkImageDecoder::kJPEG_Format }
-};
-#endif
-
-SkImageDecoder* SkImageDecoder::Factory(SkStream* stream) {
-#ifdef SK_SUPPORT_IMAGE_DECODE
- for (size_t i = 0; i < SK_ARRAY_COUNT(gPairs); i++) {
- SkImageDecoder* codec = gPairs[i].fProc(stream);
- stream->rewind();
- if (NULL != codec) {
- return codec;
- }
- }
-#endif
- return NULL;
-}
-
-bool SkImageDecoder::SupportsFormat(Format format) {
-#ifdef SK_SUPPORT_IMAGE_DECODE
- for (size_t i = 0; i < SK_ARRAY_COUNT(gPairs); i++) {
- if (gPairs[i].fFormat == format) {
- return true;
- }
- }
-#endif
- return false;
-}
-
-/////////////////////////////////////////////////////////////////////////
-
-// the movie may hold onto the stream (by calling ref())
-typedef SkMovie* (*SkMovieStreamProc)(SkStream*);
-// the movie may NOT hold onto the pointer
-typedef SkMovie* (*SkMovieMemoryProc)(const void*, size_t);
-
-extern SkMovie* SkMovie_GIF_StreamFactory(SkStream*);
-extern SkMovie* SkMovie_GIF_MemoryFactory(const void*, size_t);
-
-#ifdef SK_SUPPORT_IMAGE_DECODE
-static const SkMovieStreamProc gStreamProc[] = {
- SkMovie_GIF_StreamFactory
-};
-
-static const SkMovieMemoryProc gMemoryProc[] = {
- SkMovie_GIF_MemoryFactory
-};
-#endif
-
-SkMovie* SkMovie::DecodeStream(SkStream* stream) {
-#ifdef SK_SUPPORT_IMAGE_DECODE
- for (unsigned i = 0; i < SK_ARRAY_COUNT(gStreamProc); i++) {
- SkMovie* movie = gStreamProc[i](stream);
- if (NULL != movie) {
- return movie;
- }
- stream->rewind();
- }
-#endif
- return NULL;
-}
-
-SkMovie* SkMovie::DecodeMemory(const void* data, size_t length)
-{
-#ifdef SK_SUPPORT_IMAGE_DECODE
- for (unsigned i = 0; i < SK_ARRAY_COUNT(gMemoryProc); i++) {
- SkMovie* movie = gMemoryProc[i](data, length);
- if (NULL != movie) {
- return movie;
- }
- }
-#endif
- return NULL;
-}
-
-/////////////////////////////////////////////////////////////////////////
-
-#ifdef SK_SUPPORT_IMAGE_ENCODE
-
-extern SkImageEncoder* SkImageEncoder_JPEG_Factory();
-extern SkImageEncoder* SkImageEncoder_PNG_Factory();
-
-SkImageEncoder* SkImageEncoder::Create(Type t) {
- switch (t) {
- case kJPEG_Type:
- return SkImageEncoder_JPEG_Factory();
- case kPNG_Type:
- return SkImageEncoder_PNG_Factory();
- default:
- return NULL;
- }
-}
-
-#endif
diff --git a/skia/ports/SkImageRef_ashmem.cpp b/skia/ports/SkImageRef_ashmem.cpp
deleted file mode 100644
index 1bb65c4..0000000
--- a/skia/ports/SkImageRef_ashmem.cpp
+++ /dev/null
@@ -1,203 +0,0 @@
-#include "SkImageRef_ashmem.h"
-#include "SkImageDecoder.h"
-#include "SkThread.h"
-
-#include <sys/mman.h>
-#include <unistd.h>
-#include <cutils/ashmem.h>
-
-//#define TRACE_ASH_PURGE // just trace purges
-
-#ifdef DUMP_IMAGEREF_LIFECYCLE
- #define DUMP_ASHMEM_LIFECYCLE
-#else
-// #define DUMP_ASHMEM_LIFECYCLE
-#endif
-
-// ashmem likes lengths on page boundaries
-static size_t roundToPageSize(size_t size) {
- const size_t mask = getpagesize() - 1;
- size_t newsize = (size + mask) & ~mask;
-// SkDebugf("---- oldsize %d newsize %d\n", size, newsize);
- return newsize;
-}
-
-SkImageRef_ashmem::SkImageRef_ashmem(SkStream* stream,
- SkBitmap::Config config,
- int sampleSize)
- : SkImageRef(stream, config, sampleSize) {
-
- fRec.fFD = -1;
- fRec.fAddr = NULL;
- fRec.fSize = 0;
- fRec.fPinned = false;
-
- fCT = NULL;
-}
-
-SkImageRef_ashmem::~SkImageRef_ashmem() {
- fCT->safeUnref();
- this->closeFD();
-}
-
-void SkImageRef_ashmem::closeFD() {
- if (-1 != fRec.fFD) {
-#ifdef DUMP_ASHMEM_LIFECYCLE
- SkDebugf("=== ashmem close %d\n", fRec.fFD);
-#endif
- SkASSERT(fRec.fAddr);
- SkASSERT(fRec.fSize);
- munmap(fRec.fAddr, fRec.fSize);
- close(fRec.fFD);
- fRec.fFD = -1;
- }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-class AshmemAllocator : public SkBitmap::Allocator {
-public:
- AshmemAllocator(SkAshmemRec* rec, const char name[])
- : fRec(rec), fName(name) {}
-
- virtual bool allocPixelRef(SkBitmap* bm, SkColorTable* ct) {
- const size_t size = roundToPageSize(bm->getSize());
- int fd = fRec->fFD;
- void* addr = fRec->fAddr;
-
- SkASSERT(!fRec->fPinned);
-
- if (-1 == fd) {
- SkASSERT(NULL == addr);
- SkASSERT(0 == fRec->fSize);
-
- fd = ashmem_create_region(fName, size);
-#ifdef DUMP_ASHMEM_LIFECYCLE
- SkDebugf("=== ashmem_create_region %s size=%d fd=%d\n", fName, size, fd);
-#endif
- if (-1 == fd) {
- SkDebugf("------- imageref_ashmem create failed <%s> %d\n",
- fName, size);
- return false;
- }
-
- int err = ashmem_set_prot_region(fd, PROT_READ | PROT_WRITE);
- if (err) {
- SkDebugf("------ ashmem_set_prot_region(%d) failed %d %d\n",
- fd, err, errno);
- return false;
- }
-
- addr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
- if (-1 == (long)addr) {
- SkDebugf("---------- mmap failed for imageref_ashmem size=%d err=%d\n",
- size, errno);
- return false;
- }
-
- fRec->fFD = fd;
- fRec->fAddr = addr;
- fRec->fSize = size;
- } else {
- SkASSERT(addr);
- SkASSERT(size == fRec->fSize);
- (void)ashmem_pin_region(fd, 0, 0);
- }
-
- bm->setPixels(addr, ct);
- fRec->fPinned = true;
- return true;
- }
-
-private:
- // we just point to our caller's memory, these are not copies
- SkAshmemRec* fRec;
- const char* fName;
-};
-
-bool SkImageRef_ashmem::onDecode(SkImageDecoder* codec, SkStream* stream,
- SkBitmap* bitmap, SkBitmap::Config config,
- SkImageDecoder::Mode mode) {
-
- if (SkImageDecoder::kDecodeBounds_Mode == mode) {
- return this->INHERITED::onDecode(codec, stream, bitmap, config, mode);
- }
-
- AshmemAllocator alloc(&fRec, this->getName());
-
- codec->setAllocator(&alloc);
- bool success = this->INHERITED::onDecode(codec, stream, bitmap, config,
- mode);
- // remove the allocator, since its on the stack
- codec->setAllocator(NULL);
-
- if (success) {
- // remember the colortable (if any)
- SkRefCnt_SafeAssign(fCT, bitmap->getColorTable());
- return true;
- } else {
- if (fRec.fPinned) {
- ashmem_unpin_region(fRec.fFD, 0, 0);
- fRec.fPinned = false;
- }
- this->closeFD();
- return false;
- }
-}
-
-void* SkImageRef_ashmem::onLockPixels(SkColorTable** ct) {
- SkASSERT(fBitmap.getPixels() == NULL);
- SkASSERT(fBitmap.getColorTable() == NULL);
-
- // fast case: check if we can just pin and get the cached data
- if (-1 != fRec.fFD) {
- SkASSERT(fRec.fAddr);
- SkASSERT(!fRec.fPinned);
- int pin = ashmem_pin_region(fRec.fFD, 0, 0);
-
- if (ASHMEM_NOT_PURGED == pin) { // yea, fast case!
- fBitmap.setPixels(fRec.fAddr, fCT);
- fRec.fPinned = true;
- } else if (ASHMEM_WAS_PURGED == pin) {
- ashmem_unpin_region(fRec.fFD, 0, 0);
- // let go of our colortable if we lost the pixels. Well get it back
- // again when we re-decode
- if (fCT) {
- fCT->unref();
- fCT = NULL;
- }
-#if defined(DUMP_ASHMEM_LIFECYCLE) || defined(TRACE_ASH_PURGE)
- SkDebugf("===== ashmem purged %d\n", fBitmap.getSize());
-#endif
- } else {
- SkDebugf("===== ashmem pin_region(%d) returned %d, treating as error %d\n",
- fRec.fFD, pin, errno);
- // return null result for failure
- if (ct) {
- *ct = NULL;
- }
- return NULL;
- }
- } else {
- // no FD, will create an ashmem region in allocator
- }
-
- return this->INHERITED::onLockPixels(ct);
-}
-
-void SkImageRef_ashmem::onUnlockPixels() {
- this->INHERITED::onUnlockPixels();
-
- if (-1 != fRec.fFD) {
- SkASSERT(fRec.fAddr);
- SkASSERT(fRec.fPinned);
-
- ashmem_unpin_region(fRec.fFD, 0, 0);
- fRec.fPinned = false;
- }
-
- // we clear this with or without an error, since we've either closed or
- // unpinned the region
- fBitmap.setPixels(NULL, NULL);
-}
-
diff --git a/skia/ports/SkImageRef_ashmem.h b/skia/ports/SkImageRef_ashmem.h
deleted file mode 100644
index 193a01d..0000000
--- a/skia/ports/SkImageRef_ashmem.h
+++ /dev/null
@@ -1,35 +0,0 @@
-#ifndef SkImageRef_ashmem_DEFINED
-#define SkImageRef_ashmem_DEFINED
-
-#include "SkImageRef.h"
-
-struct SkAshmemRec {
- int fFD;
- void* fAddr;
- size_t fSize;
- bool fPinned;
-};
-
-class SkImageRef_ashmem : public SkImageRef {
-public:
- SkImageRef_ashmem(SkStream*, SkBitmap::Config, int sampleSize = 1);
- virtual ~SkImageRef_ashmem();
-
-protected:
- virtual bool onDecode(SkImageDecoder* codec, SkStream* stream,
- SkBitmap* bitmap, SkBitmap::Config config,
- SkImageDecoder::Mode mode);
-
- virtual void* onLockPixels(SkColorTable**);
- virtual void onUnlockPixels();
-
-private:
- void closeFD();
-
- SkColorTable* fCT;
- SkAshmemRec fRec;
-
- typedef SkImageRef INHERITED;
-};
-
-#endif
diff --git a/skia/ports/SkOSEvent_android.cpp b/skia/ports/SkOSEvent_android.cpp
deleted file mode 100644
index 59d6191..0000000
--- a/skia/ports/SkOSEvent_android.cpp
+++ /dev/null
@@ -1,155 +0,0 @@
-/* libs/graphics/ports/SkOSEvent_android.cpp
-**
-** Copyright 2006, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
-**
-** http://www.apache.org/licenses/LICENSE-2.0
-**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
-** limitations under the License.
-*/
-
-#include "SkEvent.h"
-#include "utils/threads.h"
-#include <stdio.h>
-
-using namespace android;
-
-Mutex gEventQMutex;
-Condition gEventQCondition;
-
-void SkEvent::SignalNonEmptyQueue()
-{
- gEventQCondition.broadcast();
-}
-
-///////////////////////////////////////////////////////////////////
-
-#ifdef FMS_ARCH_ANDROID_ARM
-
-// don't have pthreads.h, and therefore no timedwait(), so we punt for the demo
-
-void SkEvent::SignalQueueTimer(SkMSec delay)
-{
-}
-
-void SkEvent_start_timer_thread()
-{
-}
-
-void SkEvent_stop_timer_thread()
-{
-}
-
-#else
-
-#include <pthread.h>
-#include <errno.h>
-
-static pthread_t gTimerThread;
-static pthread_mutex_t gTimerMutex;
-static pthread_cond_t gTimerCond;
-static timespec gTimeSpec;
-
-static void* timer_event_thread_proc(void*)
-{
- for (;;)
- {
- int status;
-
- pthread_mutex_lock(&gTimerMutex);
-
- timespec spec = gTimeSpec;
- // mark our global to be zero
- // so we don't call timedwait again on a stale value
- gTimeSpec.tv_sec = 0;
- gTimeSpec.tv_nsec = 0;
-
- if (spec.tv_sec == 0 && spec.tv_nsec == 0)
- status = pthread_cond_wait(&gTimerCond, &gTimerMutex);
- else
- status = pthread_cond_timedwait(&gTimerCond, &gTimerMutex, &spec);
-
- if (status == 0) // someone signaled us with a new time
- {
- pthread_mutex_unlock(&gTimerMutex);
- }
- else
- {
- SkASSERT(status == ETIMEDOUT); // no need to unlock the mutex (its unlocked)
- // this is the payoff. Signal the event queue to wake up
- // and also check the delay-queue
- gEventQCondition.broadcast();
- }
- }
- return 0;
-}
-
-#define kThousand (1000)
-#define kMillion (kThousand * kThousand)
-#define kBillion (kThousand * kThousand * kThousand)
-
-void SkEvent::SignalQueueTimer(SkMSec delay)
-{
- pthread_mutex_lock(&gTimerMutex);
-
- if (delay)
- {
- struct timeval tv;
- gettimeofday(&tv, NULL);
-
- // normalize tv
- if (tv.tv_usec >= kMillion)
- {
- tv.tv_sec += tv.tv_usec / kMillion;
- tv.tv_usec %= kMillion;
- }
-
- // add tv + delay, scale each up to land on nanoseconds
- gTimeSpec.tv_nsec = (tv.tv_usec + (delay % kThousand) * kThousand) * kThousand;
- gTimeSpec.tv_sec = (tv.tv_sec + (delay / kThousand) * kThousand) * kThousand;
-
- // check for overflow in nsec
- if ((unsigned long)gTimeSpec.tv_nsec >= kBillion)
- {
- gTimeSpec.tv_nsec -= kBillion;
- gTimeSpec.tv_sec += 1;
- SkASSERT((unsigned long)gTimeSpec.tv_nsec < kBillion);
- }
-
- // printf("SignalQueueTimer(%d) timespec(%d %d)\n", delay, gTimeSpec.tv_sec, gTimeSpec.tv_nsec);
- }
- else // cancel the timer
- {
- gTimeSpec.tv_nsec = 0;
- gTimeSpec.tv_sec = 0;
- }
-
- pthread_mutex_unlock(&gTimerMutex);
- pthread_cond_signal(&gTimerCond);
-}
-
-void SkEvent_start_timer_thread()
-{
- int status;
- pthread_attr_t attr;
-
- status = pthread_attr_init(&attr);
- SkASSERT(status == 0);
- status = pthread_create(&gTimerThread, &attr, timer_event_thread_proc, 0);
- SkASSERT(status == 0);
-}
-
-void SkEvent_stop_timer_thread()
-{
- int status = pthread_cancel(gTimerThread);
- SkASSERT(status == 0);
-}
-
-#endif
diff --git a/skia/ports/SkOSEvent_dummy.cpp b/skia/ports/SkOSEvent_dummy.cpp
deleted file mode 100644
index f061b6e..0000000
--- a/skia/ports/SkOSEvent_dummy.cpp
+++ /dev/null
@@ -1,28 +0,0 @@
-/* libs/graphics/ports/SkOSEvent_dummy.cpp
-**
-** Copyright 2006, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
-**
-** http://www.apache.org/licenses/LICENSE-2.0
-**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
-** limitations under the License.
-*/
-
-#include "SkEvent.h"
-
-void SkEvent::SignalNonEmptyQueue()
-{
-
-}
-
-void SkEvent::SignalQueueTimer(SkMSec delay)
-{
-
-}
diff --git a/skia/ports/SkOSFile_stdio.cpp b/skia/ports/SkOSFile_stdio.cpp
deleted file mode 100644
index 7438f7b..0000000
--- a/skia/ports/SkOSFile_stdio.cpp
+++ /dev/null
@@ -1,106 +0,0 @@
-/* libs/graphics/ports/SkOSFile_stdio.cpp
-**
-** Copyright 2006, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
-**
-** http://www.apache.org/licenses/LICENSE-2.0
-**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
-** limitations under the License.
-*/
-
-#include "SkOSFile.h"
-
-#ifndef SK_BUILD_FOR_BREW
-
-#include <stdio.h>
-#include <errno.h>
-
-SkFILE* sk_fopen(const char path[], SkFILE_Flags flags)
-{
- char perm[4];
- char* p = perm;
-
- if (flags & kRead_SkFILE_Flag)
- *p++ = 'r';
- if (flags & kWrite_SkFILE_Flag)
- *p++ = 'w';
- *p++ = 'b';
- *p = 0;
-
- SkFILE* f = (SkFILE*)::fopen(path, perm);
-#if 0
- if (NULL == f)
- SkDebugf("sk_fopen failed for %s (%s), errno=%s\n", path, perm, strerror(errno));
-#endif
- return f;
-}
-
-size_t sk_fgetsize(SkFILE* f)
-{
- SkASSERT(f);
-
- size_t curr = ::ftell((FILE*)f); // remember where we are
- ::fseek((FILE*)f, 0, SEEK_END); // go to the end
- size_t size = ::ftell((FILE*)f); // record the size
- ::fseek((FILE*)f, (long)curr, SEEK_SET); // go back to our prev loc
- return size;
-}
-
-bool sk_frewind(SkFILE* f)
-{
- SkASSERT(f);
- ::rewind((FILE*)f);
-// ::fseek((FILE*)f, 0, SEEK_SET);
- return true;
-}
-
-size_t sk_fread(void* buffer, size_t byteCount, SkFILE* f)
-{
- SkASSERT(f);
- if (buffer == NULL)
- {
- size_t curr = ::ftell((FILE*)f);
- if ((long)curr == -1) {
- SkDEBUGF(("sk_fread: ftell(%p) returned -1 feof:%d ferror:%d\n", f, feof((FILE*)f), ferror((FILE*)f)));
- return 0;
- }
- // ::fseek((FILE*)f, (long)(curr + byteCount), SEEK_SET);
- int err = ::fseek((FILE*)f, (long)byteCount, SEEK_CUR);
- if (err != 0) {
- SkDEBUGF(("sk_fread: fseek(%d) tell:%d failed with feof:%d ferror:%d returned:%d\n",
- byteCount, curr, feof((FILE*)f), ferror((FILE*)f), err));
- return 0;
- }
- return byteCount;
- }
- else
- return ::fread(buffer, 1, byteCount, (FILE*)f);
-}
-
-size_t sk_fwrite(const void* buffer, size_t byteCount, SkFILE* f)
-{
- SkASSERT(f);
- return ::fwrite(buffer, 1, byteCount, (FILE*)f);
-}
-
-void sk_fflush(SkFILE* f)
-{
- SkASSERT(f);
- ::fflush((FILE*)f);
-}
-
-void sk_fclose(SkFILE* f)
-{
- SkASSERT(f);
- ::fclose((FILE*)f);
-}
-
-#endif
-
diff --git a/skia/ports/SkThread_none.cpp b/skia/ports/SkThread_none.cpp
deleted file mode 100644
index 37a3834..0000000
--- a/skia/ports/SkThread_none.cpp
+++ /dev/null
@@ -1,49 +0,0 @@
-/* libs/graphics/ports/SkThread_none.cpp
-**
-** Copyright 2006, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
-**
-** http://www.apache.org/licenses/LICENSE-2.0
-**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
-** limitations under the License.
-*/
-
-#include "SkThread.h"
-
-int32_t sk_atomic_inc(int32_t* addr)
-{
- int32_t value = *addr;
- *addr = value + 1;
- return value;
-}
-
-int32_t sk_atomic_dec(int32_t* addr)
-{
- int32_t value = *addr;
- *addr = value - 1;
- return value;
-}
-
-SkMutex::SkMutex(bool /* isGlobal */)
-{
-}
-
-SkMutex::~SkMutex()
-{
-}
-
-void SkMutex::acquire()
-{
-}
-
-void SkMutex::release()
-{
-}
-
diff --git a/skia/ports/SkThread_pthread.cpp b/skia/ports/SkThread_pthread.cpp
deleted file mode 100644
index 4ee857d..0000000
--- a/skia/ports/SkThread_pthread.cpp
+++ /dev/null
@@ -1,90 +0,0 @@
-#include "SkThread.h"
-
-#include <pthread.h>
-#include <errno.h>
-
-SkMutex gAtomicMutex;
-
-int32_t sk_atomic_inc(int32_t* addr)
-{
- SkAutoMutexAcquire ac(gAtomicMutex);
-
- int32_t value = *addr;
- *addr = value + 1;
- return value;
-}
-
-int32_t sk_atomic_dec(int32_t* addr)
-{
- SkAutoMutexAcquire ac(gAtomicMutex);
-
- int32_t value = *addr;
- *addr = value - 1;
- return value;
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-static void print_pthread_error(int status)
-{
- switch (status) {
- case 0: // success
- break;
- case EINVAL:
- printf("pthread error [%d] EINVAL\n", status);
- break;
- case EBUSY:
- printf("pthread error [%d] EBUSY\n", status);
- break;
- default:
- printf("pthread error [%d] unknown\n", status);
- break;
- }
-}
-
-SkMutex::SkMutex(bool isGlobal) : fIsGlobal(isGlobal)
-{
- if (sizeof(pthread_mutex_t) > sizeof(fStorage))
- {
- SkDEBUGF(("pthread mutex size = %d\n", sizeof(pthread_mutex_t)));
- SkASSERT(!"mutex storage is too small");
- }
-
- int status;
- pthread_mutexattr_t attr;
-
- status = pthread_mutexattr_init(&attr);
- print_pthread_error(status);
- SkASSERT(0 == status);
-
- status = pthread_mutex_init((pthread_mutex_t*)fStorage, &attr);
- print_pthread_error(status);
- SkASSERT(0 == status);
-}
-
-SkMutex::~SkMutex()
-{
- int status = pthread_mutex_destroy((pthread_mutex_t*)fStorage);
-
- // only report errors on non-global mutexes
- if (!fIsGlobal)
- {
- print_pthread_error(status);
- SkASSERT(0 == status);
- }
-}
-
-void SkMutex::acquire()
-{
- int status = pthread_mutex_lock((pthread_mutex_t*)fStorage);
- print_pthread_error(status);
- SkASSERT(0 == status);
-}
-
-void SkMutex::release()
-{
- int status = pthread_mutex_unlock((pthread_mutex_t*)fStorage);
- print_pthread_error(status);
- SkASSERT(0 == status);
-}
-
diff --git a/skia/ports/SkThread_win.cpp b/skia/ports/SkThread_win.cpp
deleted file mode 100644
index d3f3e21..0000000
--- a/skia/ports/SkThread_win.cpp
+++ /dev/null
@@ -1,64 +0,0 @@
-/* libs/graphics/ports/SkThread_none.cpp
-**
-** Copyright 2008, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
-**
-** http://www.apache.org/licenses/LICENSE-2.0
-**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
-** limitations under the License.
-*/
-
-#include <windows.h>
-#include "SkThread.h"
-
-namespace {
-
-template <bool>
-struct CompileAssert {
-};
-
-} // namespace
-
-#define COMPILE_ASSERT(expr, msg) \
- typedef CompileAssert<(bool(expr))> msg[bool(expr) ? 1 : -1]
-
-int32_t sk_atomic_inc(int32_t* addr)
-{
- // InterlockedIncrement returns the new value, we want to return the old.
- return InterlockedIncrement(reinterpret_cast<LONG*>(addr)) - 1;
-}
-
-int32_t sk_atomic_dec(int32_t* addr)
-{
- return InterlockedDecrement(reinterpret_cast<LONG*>(addr)) + 1;
-}
-
-SkMutex::SkMutex(bool /* isGlobal */)
-{
- COMPILE_ASSERT(sizeof(fStorage) > sizeof(CRITICAL_SECTION),
- NotEnoughSizeForCriticalSection);
- InitializeCriticalSection(reinterpret_cast<CRITICAL_SECTION*>(&fStorage));
-}
-
-SkMutex::~SkMutex()
-{
- DeleteCriticalSection(reinterpret_cast<CRITICAL_SECTION*>(&fStorage));
-}
-
-void SkMutex::acquire()
-{
- EnterCriticalSection(reinterpret_cast<CRITICAL_SECTION*>(&fStorage));
-}
-
-void SkMutex::release()
-{
- LeaveCriticalSection(reinterpret_cast<CRITICAL_SECTION*>(&fStorage));
-}
-
diff --git a/skia/ports/SkTime_Unix.cpp b/skia/ports/SkTime_Unix.cpp
deleted file mode 100644
index 1bf3a76..0000000
--- a/skia/ports/SkTime_Unix.cpp
+++ /dev/null
@@ -1,50 +0,0 @@
-/* libs/graphics/ports/SkTime_Unix.cpp
-**
-** Copyright 2006, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
-**
-** http://www.apache.org/licenses/LICENSE-2.0
-**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
-** limitations under the License.
-*/
-
-#include "SkTime.h"
-
-#if defined(SK_BUILD_FOR_UNIX) || defined(SK_BUILD_FOR_MAC)
-#include <sys/time.h>
-#include <time.h>
-
-void SkTime::GetDateTime(DateTime* dt)
-{
- if (dt)
- {
- time_t m_time;
- time(&m_time);
- struct tm* tstruct;
- tstruct = localtime(&m_time);
-
- dt->fYear = tstruct->tm_year;
- dt->fMonth = SkToU8(tstruct->tm_mon + 1);
- dt->fDayOfWeek = SkToU8(tstruct->tm_wday);
- dt->fDay = SkToU8(tstruct->tm_mday);
- dt->fHour = SkToU8(tstruct->tm_hour);
- dt->fMinute = SkToU8(tstruct->tm_min);
- dt->fSecond = SkToU8(tstruct->tm_sec);
- }
-}
-
-SkMSec SkTime::GetMSecs()
-{
- struct timeval tv;
- gettimeofday(&tv, NULL);
- return (SkMSec) (tv.tv_sec * 1000 + tv.tv_usec / 1000 ); // microseconds to milliseconds
-}
-
-#endif
diff --git a/skia/ports/SkXMLParser_empty.cpp b/skia/ports/SkXMLParser_empty.cpp
deleted file mode 100644
index 9a27306..0000000
--- a/skia/ports/SkXMLParser_empty.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-/* libs/graphics/ports/SkXMLParser_empty.cpp
-**
-** Copyright 2006, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
-**
-** http://www.apache.org/licenses/LICENSE-2.0
-**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
-** limitations under the License.
-*/
-
-// Copyright Skia Inc. 2004 - 2005
-//
-#include "SkXMLParser.h"
-
-bool SkXMLParser::parse(SkStream& docStream)
-{
- return false;
-}
-
-bool SkXMLParser::parse(const char doc[], size_t len)
-{
- return false;
-}
-
-void SkXMLParser::GetNativeErrorString(int error, SkString* str)
-{
-
-}
-
diff --git a/skia/ports/SkXMLParser_expat.cpp b/skia/ports/SkXMLParser_expat.cpp
deleted file mode 100644
index 7694d50..0000000
--- a/skia/ports/SkXMLParser_expat.cpp
+++ /dev/null
@@ -1,149 +0,0 @@
-/* libs/graphics/ports/SkXMLParser_expat.cpp
-**
-** Copyright 2006, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
-**
-** http://www.apache.org/licenses/LICENSE-2.0
-**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
-** limitations under the License.
-*/
-
-#include "SkXMLParser.h"
-#include "SkString.h"
-#include "SkStream.h"
-
-#include "expat.h"
-
-#ifdef SK_BUILD_FOR_PPI
-#define CHAR_16_TO_9
-#endif
-
-#if defined CHAR_16_TO_9
-inline size_t sk_wcslen(const short* char16) {
- const short* start = char16;
- while (*char16)
- char16++;
- return char16 - start;
-}
-
-inline const char* ConvertUnicodeToChar(const short* ch16, size_t len, SkAutoMalloc& ch8Malloc) {
- char* ch8 = (char*) ch8Malloc.get();
- int index;
- for (index = 0; index < len; index++)
- ch8[index] = (char) ch16[index];
- ch8[index] = '\0';
- return ch8;
-}
-#endif
-
-static void XMLCALL start_proc(void *data, const char *el, const char **attr)
-{
-#if defined CHAR_16_TO_9
- size_t len = sk_wcslen((const short*) el);
- SkAutoMalloc el8(len + 1);
- el = ConvertUnicodeToChar((const short*) el, len, el8);
-#endif
- if (((SkXMLParser*)data)->startElement(el)) {
- XML_StopParser((XML_Parser) ((SkXMLParser*)data)->fParser, false);
- return;
- }
- while (*attr)
- {
- const char* attr0 = attr[0];
- const char* attr1 = attr[1];
-#if defined CHAR_16_TO_9
- size_t len0 = sk_wcslen((const short*) attr0);
- SkAutoMalloc attr0_8(len0 + 1);
- attr0 = ConvertUnicodeToChar((const short*) attr0, len0, attr0_8);
- size_t len1 = sk_wcslen((const short*) attr1);
- SkAutoMalloc attr1_8(len1 + 1);
- attr1 = ConvertUnicodeToChar((const short*) attr1, len1, attr1_8);
-#endif
- if (((SkXMLParser*)data)->addAttribute(attr0, attr1)) {
- XML_StopParser((XML_Parser) ((SkXMLParser*)data)->fParser, false);
- return;
- }
- attr += 2;
- }
-}
-
-static void XMLCALL end_proc(void *data, const char *el)
-{
-#if defined CHAR_16_TO_9
- size_t len = sk_wcslen((const short*) el);
- SkAutoMalloc el8(len + 1);
- el = ConvertUnicodeToChar((const short*) el, len, el8);
-#endif
- if (((SkXMLParser*)data)->endElement(el))
- XML_StopParser((XML_Parser) ((SkXMLParser*)data)->fParser, false);
-}
-
-static void XMLCALL text_proc(void* data, const char* text, int len)
-{
-#if defined CHAR_16_TO_9
- SkAutoMalloc text8(len + 1);
- text = ConvertUnicodeToChar((const short*) text, len, text8);
-#endif
- if (((SkXMLParser*)data)->text(text, len))
- XML_StopParser((XML_Parser) ((SkXMLParser*)data)->fParser, false);
-}
-
-bool SkXMLParser::parse(const char doc[], size_t len)
-{
- if (len == 0) {
- fError->fCode = SkXMLParserError::kEmptyFile;
- reportError(NULL);
- return false;
- }
- XML_Parser p = XML_ParserCreate(NULL);
- SkASSERT(p);
- fParser = p;
- XML_SetElementHandler(p, start_proc, end_proc);
- XML_SetCharacterDataHandler(p, text_proc);
- XML_SetUserData(p, this);
-
- bool success = true;
- int error = XML_Parse(p, doc, len, true);
- if (error == XML_STATUS_ERROR) {
- reportError(p);
- success = false;
- }
- XML_ParserFree(p);
- return success;
-}
-
-bool SkXMLParser::parse(SkStream& input)
-{
- size_t len = input.read(NULL, 0);
- SkAutoMalloc am(len);
- char* doc = (char*)am.get();
-
- input.rewind();
- size_t len2 = input.read(doc, len);
- SkASSERT(len2 == len);
-
- return this->parse(doc, len2);
-}
-
-void SkXMLParser::reportError(void* p)
-{
- XML_Parser parser = (XML_Parser) p;
- if (fError && parser) {
- fError->fNativeCode = XML_GetErrorCode(parser);
- fError->fLineNumber = XML_GetCurrentLineNumber(parser);
- }
-}
-
-void SkXMLParser::GetNativeErrorString(int error, SkString* str)
-{
- if (str)
- str->set(XML_ErrorString((XML_Error) error));
-}
-
diff --git a/skia/ports/SkXMLParser_tinyxml.cpp b/skia/ports/SkXMLParser_tinyxml.cpp
deleted file mode 100644
index 7f57b80..0000000
--- a/skia/ports/SkXMLParser_tinyxml.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-/* libs/graphics/ports/SkXMLParser_tinyxml.cpp
-**
-** Copyright 2006, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
-**
-** http://www.apache.org/licenses/LICENSE-2.0
-**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
-** limitations under the License.
-*/
-
-#include "SkXMLParser.h"
-#include "SkStream.h"
-#include "SkTemplates.h"
-#include "tinyxml.h"
-
-static void walk_elem(SkXMLParser* parser, const TiXmlElement* elem)
-{
- //printf("walk_elem(%s) ", elem->Value());
-
- parser->startElement(elem->Value());
-
- const TiXmlAttribute* attr = elem->FirstAttribute();
- while (attr)
- {
- //printf("walk_elem_attr(%s=\"%s\") ", attr->Name(), attr->Value());
-
- parser->addAttribute(attr->Name(), attr->Value());
- attr = attr->Next();
- }
- //printf("\n");
-
- const TiXmlNode* node = elem->FirstChild();
- while (node)
- {
- if (node->ToElement())
- walk_elem(parser, node->ToElement());
- else if (node->ToText())
- parser->text(node->Value(), strlen(node->Value()));
- node = node->NextSibling();
- }
-
- parser->endElement(elem->Value());
-}
-
-static bool load_buf(SkXMLParser* parser, const char buf[])
-{
- TiXmlDocument doc;
-
- (void)doc.Parse(buf);
- if (doc.Error())
- {
- printf("tinyxml error: <%s> row[%d] col[%d]\n", doc.ErrorDesc(), doc.ErrorRow(), doc.ErrorCol());
- return false;
- }
-
- walk_elem(parser, doc.RootElement());
- return true;
-}
-
-bool SkXMLParser::parse(SkStream& stream)
-{
- size_t size = stream.read(NULL, 0);
-
- SkAutoMalloc buffer(size + 1);
- char* buf = (char*)buffer.get();
-
- stream.read(buf, size);
- buf[size] = 0;
-
- return load_buf(this, buf);
-}
-
-bool SkXMLParser::parse(const char doc[], size_t len)
-{
- SkAutoMalloc buffer(len + 1);
- char* buf = (char*)buffer.get();
-
- memcpy(buf, doc, len);
- buf[len] = 0;
-
- return load_buf(this, buf);
-}
-
-void SkXMLParser::GetNativeErrorString(int error, SkString* str)
-{
- if (str)
- str->set("GetNativeErrorString not implemented for TinyXml");
-}
-
diff --git a/skia/ports/SkXMLPullParser_expat.cpp b/skia/ports/SkXMLPullParser_expat.cpp
deleted file mode 100644
index 949c7a9..0000000
--- a/skia/ports/SkXMLPullParser_expat.cpp
+++ /dev/null
@@ -1,222 +0,0 @@
-/* libs/graphics/ports/SkXMLParser_expat.cpp
-**
-** Copyright 2006, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
-**
-** http://www.apache.org/licenses/LICENSE-2.0
-**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
-** limitations under the License.
-*/
-
-#include "SkXMLParser.h"
-#include "SkChunkAlloc.h"
-#include "SkString.h"
-#include "SkStream.h"
-
-#include "expat.h"
-
-static inline char* dupstr(SkChunkAlloc& chunk, const char src[], size_t len)
-{
- SkASSERT(src);
- char* dst = (char*)chunk.alloc(len + 1, SkChunkAlloc::kThrow_AllocFailType);
-
- memcpy(dst, src, len);
- dst[len] = 0;
- return dst;
-}
-
-static inline int count_pairs(const char** p)
-{
- const char** start = p;
- while (*p)
- {
- SkASSERT(p[1] != NULL);
- p += 2;
- }
- return (p - start) >> 1;
-}
-
-struct Data {
- Data() : fAlloc(2048), fState(NORMAL) {}
-
- XML_Parser fParser;
- SkXMLPullParser::Curr* fCurr;
- SkChunkAlloc fAlloc;
-
- enum State {
- NORMAL,
- MISSED_START_TAG,
- RETURN_END_TAG
- };
- State fState;
- const char* fEndTag; // if state is RETURN_END_TAG
-};
-
-static void XMLCALL start_proc(void *data, const char *el, const char **attr)
-{
- Data* p = (Data*)data;
- SkXMLPullParser::Curr* c = p->fCurr;
- SkChunkAlloc& alloc = p->fAlloc;
-
- c->fName = dupstr(alloc, el, strlen(el));
-
- int n = count_pairs(attr);
- SkXMLPullParser::AttrInfo* info = (SkXMLPullParser::AttrInfo*)alloc.alloc(n * sizeof(SkXMLPullParser::AttrInfo),
- SkChunkAlloc::kThrow_AllocFailType);
- c->fAttrInfoCount = n;
- c->fAttrInfos = info;
-
- for (int i = 0; i < n; i++)
- {
- info[i].fName = dupstr(alloc, attr[0], strlen(attr[0]));
- info[i].fValue = dupstr(alloc, attr[1], strlen(attr[1]));
- attr += 2;
- }
-
- c->fEventType = SkXMLPullParser::START_TAG;
- XML_StopParser(p->fParser, true);
-}
-
-static void XMLCALL end_proc(void *data, const char *el)
-{
- Data* p = (Data*)data;
- SkXMLPullParser::Curr* c = p->fCurr;
-
- if (c->fEventType == SkXMLPullParser::START_TAG)
- {
- /* if we get here, we were called with a start_tag immediately
- followed by this end_tag. The caller will only see the end_tag,
- so we set a flag to notify them of the missed start_tag
- */
- p->fState = Data::MISSED_START_TAG;
-
- SkASSERT(c->fName != NULL);
- SkASSERT(strcmp(c->fName, el) == 0);
- }
- else
- c->fName = dupstr(p->fAlloc, el, strlen(el));
-
- c->fEventType = SkXMLPullParser::END_TAG;
- XML_StopParser(p->fParser, true);
-}
-
-#include <ctype.h>
-
-static bool isws(const char s[])
-{
- for (; *s; s++)
- if (!isspace(*s))
- return false;
- return true;
-}
-
-static void XMLCALL text_proc(void* data, const char* text, int len)
-{
- Data* p = (Data*)data;
- SkXMLPullParser::Curr* c = p->fCurr;
-
- c->fName = dupstr(p->fAlloc, text, len);
- c->fIsWhitespace = isws(c->fName);
-
- c->fEventType = SkXMLPullParser::TEXT;
- XML_StopParser(p->fParser, true);
-}
-
-//////////////////////////////////////////////////////////////////////////
-
-struct SkXMLPullParser::Impl {
- Data fData;
- void* fBuffer;
- size_t fBufferLen;
-};
-
-static void reportError(XML_Parser parser)
-{
- XML_Error code = XML_GetErrorCode(parser);
- int lineNumber = XML_GetCurrentLineNumber(parser);
- const char* msg = XML_ErrorString(code);
-
- printf("-------- XML error [%d] on line %d, %s\n", code, lineNumber, msg);
-}
-
-bool SkXMLPullParser::onInit()
-{
- fImpl = new Impl;
-
- XML_Parser p = XML_ParserCreate(NULL);
- SkASSERT(p);
-
- fImpl->fData.fParser = p;
- fImpl->fData.fCurr = &fCurr;
-
- XML_SetElementHandler(p, start_proc, end_proc);
- XML_SetCharacterDataHandler(p, text_proc);
- XML_SetUserData(p, &fImpl->fData);
-
- size_t len = fStream->read(NULL, 0);
- fImpl->fBufferLen = len;
- fImpl->fBuffer = sk_malloc_throw(len);
- fStream->rewind();
- size_t len2 = fStream->read(fImpl->fBuffer, len);
- return len2 == len;
-}
-
-void SkXMLPullParser::onExit()
-{
- sk_free(fImpl->fBuffer);
- XML_ParserFree(fImpl->fData.fParser);
- delete fImpl;
- fImpl = NULL;
-}
-
-SkXMLPullParser::EventType SkXMLPullParser::onNextToken()
-{
- if (Data::RETURN_END_TAG == fImpl->fData.fState)
- {
- fImpl->fData.fState = Data::NORMAL;
- fCurr.fName = fImpl->fData.fEndTag; // restore name from (below) save
- return SkXMLPullParser::END_TAG;
- }
-
- fImpl->fData.fAlloc.reuse();
-
- XML_Parser p = fImpl->fData.fParser;
- XML_Status status;
-
- status = XML_ResumeParser(p);
-
-CHECK_STATUS:
- switch (status) {
- case XML_STATUS_OK:
- return SkXMLPullParser::END_DOCUMENT;
-
- case XML_STATUS_ERROR:
- if (XML_GetErrorCode(p) != XML_ERROR_NOT_SUSPENDED)
- {
- reportError(p);
- return SkXMLPullParser::ERROR;
- }
- status = XML_Parse(p, (const char*)fImpl->fBuffer, fImpl->fBufferLen, true);
- goto CHECK_STATUS;
-
- case XML_STATUS_SUSPENDED:
- if (Data::MISSED_START_TAG == fImpl->fData.fState)
- {
- // return a start_tag, and clear the flag so we return end_tag next
- SkASSERT(SkXMLPullParser::END_TAG == fCurr.fEventType);
- fImpl->fData.fState = Data::RETURN_END_TAG;
- fImpl->fData.fEndTag = fCurr.fName; // save this pointer
- return SkXMLPullParser::START_TAG;
- }
- break;
- }
- return fCurr.fEventType;
-}
-
diff --git a/skia/ports/sk_predefined_gamma.h b/skia/ports/sk_predefined_gamma.h
deleted file mode 100644
index 0818b30..0000000
--- a/skia/ports/sk_predefined_gamma.h
+++ /dev/null
@@ -1,44 +0,0 @@
-#ifndef SK_PREDEFINED_GAMMA_H
-#define SK_PREDEFINED_GAMMA_H
-
-// Gamma table for 1.4
-static const uint8_t gBlackGamma[] = {
- 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, 0x04, 0x05,
- 0x05, 0x06, 0x06, 0x07, 0x07, 0x08, 0x08, 0x09, 0x09, 0x0A, 0x0A, 0x0B, 0x0C, 0x0C, 0x0D, 0x0D,
- 0x0E, 0x0F, 0x0F, 0x10, 0x10, 0x11, 0x12, 0x12, 0x13, 0x14, 0x14, 0x15, 0x16, 0x16, 0x17, 0x18,
- 0x19, 0x19, 0x1A, 0x1B, 0x1C, 0x1C, 0x1D, 0x1E, 0x1F, 0x1F, 0x20, 0x21, 0x22, 0x22, 0x23, 0x24,
- 0x25, 0x26, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x31,
- 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40,
- 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50,
- 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60,
- 0x61, 0x62, 0x63, 0x64, 0x65, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71,
- 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7C, 0x7D, 0x7E, 0x7F, 0x80, 0x81, 0x82, 0x84,
- 0x85, 0x86, 0x87, 0x88, 0x89, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x91, 0x92, 0x93, 0x94, 0x95, 0x97,
- 0x98, 0x99, 0x9A, 0x9B, 0x9D, 0x9E, 0x9F, 0xA0, 0xA1, 0xA3, 0xA4, 0xA5, 0xA6, 0xA8, 0xA9, 0xAA,
- 0xAB, 0xAD, 0xAE, 0xAF, 0xB0, 0xB2, 0xB3, 0xB4, 0xB5, 0xB7, 0xB8, 0xB9, 0xBB, 0xBC, 0xBD, 0xBE,
- 0xC0, 0xC1, 0xC2, 0xC4, 0xC5, 0xC6, 0xC8, 0xC9, 0xCA, 0xCB, 0xCD, 0xCE, 0xCF, 0xD1, 0xD2, 0xD3,
- 0xD5, 0xD6, 0xD7, 0xD9, 0xDA, 0xDB, 0xDD, 0xDE, 0xDF, 0xE1, 0xE2, 0xE3, 0xE5, 0xE6, 0xE8, 0xE9,
- 0xEA, 0xEC, 0xED, 0xEE, 0xF0, 0xF1, 0xF2, 0xF4, 0xF5, 0xF7, 0xF8, 0xF9, 0xFB, 0xFC, 0xFE, 0xFF,
-};
-
-// Gamma table for 0.714286
-static const uint8_t gWhiteGamma[] = {
- 0x00, 0x05, 0x08, 0x0B, 0x0D, 0x0F, 0x12, 0x14, 0x16, 0x17, 0x19, 0x1B, 0x1D, 0x1E, 0x20, 0x22,
- 0x23, 0x25, 0x26, 0x28, 0x29, 0x2B, 0x2C, 0x2E, 0x2F, 0x31, 0x32, 0x33, 0x35, 0x36, 0x37, 0x39,
- 0x3A, 0x3B, 0x3C, 0x3E, 0x3F, 0x40, 0x41, 0x43, 0x44, 0x45, 0x46, 0x48, 0x49, 0x4A, 0x4B, 0x4C,
- 0x4D, 0x4E, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E,
- 0x5F, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E,
- 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E,
- 0x7F, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D,
- 0x8E, 0x8F, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x97, 0x98, 0x99, 0x9A, 0x9B,
- 0x9C, 0x9D, 0x9E, 0x9E, 0x9F, 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9,
- 0xAA, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB4, 0xB5, 0xB6,
- 0xB7, 0xB8, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC0, 0xC1, 0xC2, 0xC3,
- 0xC4, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCC, 0xCD, 0xCE, 0xCF, 0xCF,
- 0xD0, 0xD1, 0xD2, 0xD3, 0xD3, 0xD4, 0xD5, 0xD6, 0xD6, 0xD7, 0xD8, 0xD9, 0xD9, 0xDA, 0xDB, 0xDC,
- 0xDC, 0xDD, 0xDE, 0xDF, 0xDF, 0xE0, 0xE1, 0xE2, 0xE2, 0xE3, 0xE4, 0xE5, 0xE5, 0xE6, 0xE7, 0xE8,
- 0xE8, 0xE9, 0xEA, 0xEB, 0xEB, 0xEC, 0xED, 0xEE, 0xEE, 0xEF, 0xF0, 0xF1, 0xF1, 0xF2, 0xF3, 0xF3,
- 0xF4, 0xF5, 0xF6, 0xF6, 0xF7, 0xF8, 0xF9, 0xF9, 0xFA, 0xFB, 0xFB, 0xFC, 0xFD, 0xFE, 0xFE, 0xFF,
-};
-
-#endif