BitmapTextBatch and BitmapTextBlob

src/gpu/GrBatchFontCache.cpp

+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "GrBatchFontCache.h"
+#include "GrFontAtlasSizes.h"
+#include "GrGpu.h"
+#include "GrRectanizer.h"
+#include "GrSurfacePriv.h"
+#include "SkString.h"
+
+#include "SkDistanceFieldGen.h"
+
+///////////////////////////////////////////////////////////////////////////////
+
+static GrBatchAtlas* make_atlas(GrContext* context, GrPixelConfig config,
+                                int textureWidth, int textureHeight,
+                                int numPlotsX, int numPlotsY) {
+    GrSurfaceDesc desc;
+    desc.fFlags = kNone_GrSurfaceFlags;
+    desc.fWidth = textureWidth;
+    desc.fHeight = textureHeight;
+    desc.fConfig = config;
+
+    // We don't want to flush the context so we claim we're in the middle of flushing so as to
+    // guarantee we do not recieve a texture with pending IO
+    GrTexture* texture = context->refScratchTexture(desc, GrContext::kApprox_ScratchTexMatch, true);
+    return SkNEW_ARGS(GrBatchAtlas, (texture, numPlotsX, numPlotsY));
+}
+
+int GrBatchFontCache::MaskFormatToAtlasIndex(GrMaskFormat format) {
+    static const int sAtlasIndices[] = {

[bsalomon, 2015/03/26 17:06:55]

If these are one to one why have two enums? I was expecting that k8888_AtlasType
might have a mix of color bitmap glyphs and lcd glyphs. But if that's not true
then this seems unnecessary.\

nit: We usually prefix these "g" or "k". There is some internal variation on
whether "k" means "kompile time konstant" and g means a "non-const global" or
whether "k" means "integral konstant" and "g" means "any global that's non-const
or non-integral". I dunno that we need more variation :) 

[joshualitt, 2015/03/26 18:21:43]

Acknowledged.

+        GrBatchFontCache::kA8_AtlasType,
+        GrBatchFontCache::k565_AtlasType,
+        GrBatchFontCache::k8888_AtlasType
+    };
+    SK_COMPILE_ASSERT(SK_ARRAY_COUNT(sAtlasIndices) == kMaskFormatCount, array_size_mismatch);
+
+    SkASSERT(sAtlasIndices[format] < GrBatchFontCache::kAtlasCount);
+    return sAtlasIndices[format];
+}
+
+GrMaskFormat GrBatchFontCache::AtlasIndexToMaskFormat(int atlasIndex) {
+    static GrMaskFormat sMaskFormats[] = {
+        kA8_GrMaskFormat,
+        kA565_GrMaskFormat,
+        kARGB_GrMaskFormat,
+    };
+    SK_COMPILE_ASSERT(SK_ARRAY_COUNT(sMaskFormats) == kMaskFormatCount, array_size_mismatch);
+
+    SkASSERT(sMaskFormats[atlasIndex] < GrBatchFontCache::kAtlasCount);
+    return sMaskFormats[atlasIndex];
+}
+
+GrBatchFontCache::GrBatchFontCache(GrContext* context)
+    : fPreserveStrike(NULL) {
+    for (int i = 0; i < kAtlasCount; i++) {
+        GrMaskFormat format = AtlasIndexToMaskFormat(i);
+        GrPixelConfig config = this->getPixelConfig(format);
+
+        if (kA8_GrMaskFormat == format) {
+            fAtlases[i] = make_atlas(context, config,
+                                     GR_FONT_ATLAS_A8_TEXTURE_WIDTH,
+                                     GR_FONT_ATLAS_TEXTURE_HEIGHT,
+                                     GR_FONT_ATLAS_A8_NUM_PLOTS_X,
+                                     GR_FONT_ATLAS_NUM_PLOTS_Y);
+        } else {
+            fAtlases[i] = make_atlas(context, config,
+                                     GR_FONT_ATLAS_TEXTURE_WIDTH,
+                                     GR_FONT_ATLAS_TEXTURE_HEIGHT,
+                                     GR_FONT_ATLAS_NUM_PLOTS_X,
+                                     GR_FONT_ATLAS_NUM_PLOTS_Y);
+        }
+
+        fAtlases[i]->registerEvictionCallback(&GrBatchFontCache::HandleEviction, (void*)this);
+    }
+}
+
+GrBatchFontCache::~GrBatchFontCache() {
+    SkTDynamicHash<GrBatchTextStrike, GrFontDescKey>::Iter iter(&fCache);
+    while (!iter.done()) {
+        SkDELETE(&(*iter));
+        ++iter;
+    }
+    for (int i = 0; i < kAtlasCount; ++i) {
+        SkDELETE(fAtlases[i]);
+    }
+}
+
+GrBatchTextStrike* GrBatchFontCache::generateStrike(GrFontScaler* scaler) {
+    GrBatchTextStrike* strike = SkNEW_ARGS(GrBatchTextStrike, (this, scaler->getKey()));
+    fCache.add(strike);
+    fStrikeList.addToHead(strike);
+    return strike;
+}
+
+void GrBatchFontCache::freeAll() {
+    SkTDynamicHash<GrBatchTextStrike, GrFontDescKey>::Iter iter(&fCache);
+    while (!iter.done()) {
+        SkDELETE(&(*iter));
+        ++iter;
+    }
+    fCache.rewind();
+    for (int i = 0; i < kAtlasCount; ++i) {
+        SkDELETE(fAtlases[i]);
+        fAtlases[i] = NULL;
+    }
+}
+
+void GrBatchFontCache::purgeStrike(GrBatchTextStrike* strike) {
+    fCache.remove(*(strike->fFontScalerKey));
+    fStrikeList.remove(strike);
+    SkDELETE(strike);
+}
+
+inline GrBatchAtlas* GrBatchFontCache::getAtlas(GrMaskFormat format) const {
+    int atlasIndex = MaskFormatToAtlasIndex(format);
+    SkASSERT(fAtlases[atlasIndex]);
+    return fAtlases[atlasIndex];
+}
+
+bool GrBatchFontCache::hasGlyph(GrGlyph* glyph) {
+    SkASSERT(glyph);
+    return this->getAtlas(glyph->fMaskFormat)->hasID(glyph->fID);
+}
+
+void GrBatchFontCache::refGlyph(GrGlyph* glyph, GrBatchAtlas::BatchToken batchToken) {
+    SkASSERT(glyph);
+    SkASSERT(this->getAtlas(glyph->fMaskFormat)->hasID(glyph->fID));
+    this->getAtlas(glyph->fMaskFormat)->setLastRefToken(glyph->fID, batchToken);
+}
+
+bool GrBatchFontCache::addToAtlas(GrBatchTextStrike* strike, GrBatchAtlas::AtlasID* id,
+                                  GrBatchTarget* batchTarget,
+                                  GrMaskFormat format, int width, int height, const void* image,
+                                  SkIPoint16* loc) {
+    fPreserveStrike = strike;
+    return this->getAtlas(format)->addToAtlas(id, batchTarget, width, height, image, loc);
+}
+
+uint32_t GrBatchFontCache::atlasGeneration(GrMaskFormat format) const {
+    return this->getAtlas(format)->atlasGeneration();
+}
+
+GrTexture* GrBatchFontCache::getTexture(GrMaskFormat format) {
+    int atlasIndex = MaskFormatToAtlasIndex(format);
+    SkASSERT(fAtlases[atlasIndex]);
+    return fAtlases[atlasIndex]->getTexture();
+}
+
+GrPixelConfig GrBatchFontCache::getPixelConfig(GrMaskFormat format) const {
+    static const GrPixelConfig sPixelConfigs[] = {
+        kAlpha_8_GrPixelConfig,
+        kRGB_565_GrPixelConfig,
+        kSkia8888_GrPixelConfig
+    };
+    SK_COMPILE_ASSERT(SK_ARRAY_COUNT(sPixelConfigs) == kMaskFormatCount, array_size_mismatch);
+
+    return sPixelConfigs[format];
+}
+
+void GrBatchFontCache::HandleEviction(GrBatchAtlas::AtlasID id, void* ptr) {
+    GrBatchFontCache* fontCache = reinterpret_cast<GrBatchFontCache*>(ptr);
+
+    GrBatchStrikeList::Iter plotIter;
+    plotIter.init(fontCache->fStrikeList, GrBatchStrikeList::Iter::kHead_IterStart);
+
+    GrBatchTextStrike* strike;
+    while ((strike = plotIter.get())) {
+        // We advance the pointer here because we might delete the strike
+        plotIter.next();
+        strike->removeID(id);
+
+        // clear out any empty strikes.  We will preserve the strike whose call to addToAtlas
+        // triggered the eviction
+        if (strike != fontCache->fPreserveStrike && 0 == strike->fAtlasedGlyphs) {
+            fontCache->purgeStrike(strike);
+        }
+    }
+}
+
+#ifdef SK_DEBUG
+void GrBatchFontCache::validate() const {
+    SkASSERT(fCache.count() == fStrikeList.countEntries());
+}
+#endif
+
+void GrBatchFontCache::dump() const {
+    static int gDumpCount = 0;
+    for (int i = 0; i < kAtlasCount; ++i) {
+        if (fAtlases[i]) {
+            GrTexture* texture = fAtlases[i]->getTexture();
+            if (texture) {
+                SkString filename;
+#ifdef SK_BUILD_FOR_ANDROID
+                filename.printf("/sdcard/fontcache_%d%d.png", gDumpCount, i);
+#else
+                filename.printf("fontcache_%d%d.png", gDumpCount, i);
+#endif
+                texture->surfacePriv().savePixels(filename.c_str());
+            }
+        }
+    }
+    ++gDumpCount;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+/*
+    The text strike is specific to a given font/style/matrix setup, which is
+    represented by the GrHostFontScaler object we are given in getGlyph().
+
+    We map a 32bit glyphID to a GrGlyph record, which in turn points to a
+    atlas and a position within that texture.
+ */
+
+GrBatchTextStrike::GrBatchTextStrike(GrBatchFontCache* cache, const GrFontDescKey* key)
+    : fFontScalerKey(SkRef(key))
+    , fPool(9/*start allocations at 512 bytes*/)
+    , fAtlasedGlyphs(0) {
+
+    fBatchFontCache = cache;     // no need to ref, it won't go away before we do
+}
+
+GrBatchTextStrike::~GrBatchTextStrike() {
+    SkTDynamicHash<GrGlyph, GrGlyph::PackedID>::Iter iter(&fCache);
+    while (!iter.done()) {
+        (*iter).free();
+        ++iter;
+    }
+}
+
+GrGlyph* GrBatchTextStrike::generateGlyph(GrGlyph::PackedID packed,
+                                          GrFontScaler* scaler) {
+    SkIRect bounds;
+    if (GrGlyph::kDistance_MaskStyle == GrGlyph::UnpackMaskStyle(packed)) {
+        if (!scaler->getPackedGlyphDFBounds(packed, &bounds)) {
+            return NULL;
+        }
+    } else {
+        if (!scaler->getPackedGlyphBounds(packed, &bounds)) {
+            return NULL;
+        }
+    }
+    GrMaskFormat format = scaler->getPackedGlyphMaskFormat(packed);
+    
+    GrGlyph* glyph = (GrGlyph*)fPool.alloc(sizeof(GrGlyph), SK_MALLOC_THROW);
+    glyph->init(packed, bounds, format);
+    fCache.add(glyph);
+    return glyph;
+}
+
+void GrBatchTextStrike::removeID(GrBatchAtlas::AtlasID id) {
+    SkTDynamicHash<GrGlyph, GrGlyph::PackedID>::Iter iter(&fCache);
+    while (!iter.done()) {
+        if (id == (*iter).fID) {
+            (*iter).fID = GrBatchAtlas::kInvalidAtlasID;
+            fAtlasedGlyphs--;
+            SkASSERT(fAtlasedGlyphs >= 0);
+        }
+        ++iter;
+    }
+}
+
+bool GrBatchTextStrike::glyphTooLargeForAtlas(GrGlyph* glyph) {
+    int width = glyph->fBounds.width();
+    int height = glyph->fBounds.height();
+    bool useDistanceField =
+            (GrGlyph::kDistance_MaskStyle == GrGlyph::UnpackMaskStyle(glyph->fPackedID));
+    int pad = useDistanceField ? 2 * SK_DistanceFieldPad : 0;
+    int plotWidth = (kA8_GrMaskFormat == glyph->fMaskFormat) ? GR_FONT_ATLAS_A8_PLOT_WIDTH
+                                                             : GR_FONT_ATLAS_PLOT_WIDTH;
+    if (width + pad > plotWidth) {
+        return true;
+    }
+    if (height + pad > GR_FONT_ATLAS_PLOT_HEIGHT) {
+        return true;
+    }
+
+    return false;
+}
+
+bool GrBatchTextStrike::addGlyphToAtlas(GrBatchTarget* batchTarget, GrGlyph* glyph,
+                                        GrFontScaler* scaler) {
+    SkASSERT(glyph);
+    SkASSERT(scaler);
+    SkASSERT(fCache.find(glyph->fPackedID));
+    SkASSERT(NULL == glyph->fPlot);
+
+    SkAutoUnref ar(SkSafeRef(scaler));
+
+    int bytesPerPixel = GrMaskFormatBytesPerPixel(glyph->fMaskFormat);
+
+    size_t size = glyph->fBounds.area() * bytesPerPixel;
+    GrAutoMalloc<1024> storage(size);
+
+    if (GrGlyph::kDistance_MaskStyle == GrGlyph::UnpackMaskStyle(glyph->fPackedID)) {
+        if (!scaler->getPackedGlyphDFImage(glyph->fPackedID, glyph->width(),
+                                           glyph->height(),
+                                           storage.get())) {
+            return false;
+        }
+    } else {
+        if (!scaler->getPackedGlyphImage(glyph->fPackedID, glyph->width(),
+                                         glyph->height(),
+                                         glyph->width() * bytesPerPixel,
+                                         storage.get())) {
+            return false;
+        }
+    }
+
+    bool success = fBatchFontCache->addToAtlas(this, &glyph->fID, batchTarget, glyph->fMaskFormat,
+                                               glyph->width(), glyph->height(),
+                                               storage.get(), &glyph->fAtlasLocation);
+    if (success) {
+        fAtlasedGlyphs++;
+    }
+    return success;
+}