src/gpu/batches/GrAtlasTextBatch.cpp - platform/external/skqp - Gitiles

 /*
  * 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 "GrAtlasTextBatch.h"

 #include "GrBatchFlushState.h"
 #include "GrResourceProvider.h"

 #include "SkGlyphCache.h"
 #include "SkMathPriv.h"

 #include "effects/GrBitmapTextGeoProc.h"
 #include "effects/GrDistanceFieldGeoProc.h"
 #include "text/GrBatchFontCache.h"

 ///////////////////////////////////////////////////////////////////////////////////////////////////

 static inline GrColor skcolor_to_grcolor_nopremultiply(SkColor c) {
     unsigned r = SkColorGetR(c);
     unsigned g = SkColorGetG(c);
     unsigned b = SkColorGetB(c);
     return GrColorPackRGBA(r, g, b, 0xff);
 }

 static const int kDistanceAdjustLumShift = 5;

 SkString GrAtlasTextBatch::dumpInfo() const {
     SkString str;

     for (int i = 0; i < fGeoCount; ++i) {
         str.appendf("%d: Color: 0x%08x Trans: %.2f,%.2f Runs: %d\n",
                     i,
                     fGeoData[i].fColor,
                     fGeoData[i].fX,
                     fGeoData[i].fY,
                     fGeoData[i].fBlob->runCount());
     }

     str.append(INHERITED::dumpInfo());
     return str;
 }

 void GrAtlasTextBatch::computePipelineOptimizations(GrInitInvariantOutput* color,
                                                     GrInitInvariantOutput* coverage,
                                                     GrBatchToXPOverrides* overrides) const {
     if (kColorBitmapMask_MaskType == fMaskType) {
         color->setUnknownFourComponents();
     } else {
         color->setKnownFourComponents(fBatch.fColor);
     }
     switch (fMaskType) {
         case kGrayscaleDistanceField_MaskType:
         case kGrayscaleCoverageMask_MaskType:
             coverage->setUnknownSingleComponent();
             break;
         case kLCDCoverageMask_MaskType:
         case kLCDDistanceField_MaskType:
             coverage->setUnknownOpaqueFourComponents();
             coverage->setUsingLCDCoverage();
             break;
         case kColorBitmapMask_MaskType:
             coverage->setKnownSingleComponent(0xff);
     }
 }

 void GrAtlasTextBatch::initBatchTracker(const GrXPOverridesForBatch& overrides) {
     // Handle any color overrides
     if (!overrides.readsColor()) {
         fGeoData[0].fColor = GrColor_ILLEGAL;
     }
     overrides.getOverrideColorIfSet(&fGeoData[0].fColor);

     // setup batch properties
     fBatch.fColorIgnored = !overrides.readsColor();
     fBatch.fColor = fGeoData[0].fColor;
     fBatch.fUsesLocalCoords = overrides.readsLocalCoords();
     fBatch.fCoverageIgnored = !overrides.readsCoverage();
 }

 void GrAtlasTextBatch::onPrepareDraws(Target* target) const {
     // if we have RGB, then we won't have any SkShaders so no need to use a localmatrix.
     // TODO actually only invert if we don't have RGBA
     SkMatrix localMatrix;
     if (this->usesLocalCoords() && !this->viewMatrix().invert(&localMatrix)) {
         SkDebugf("Cannot invert viewmatrix\n");
         return;
     }

     GrTexture* texture = fFontCache->getTexture(this->maskFormat());
     if (!texture) {
         SkDebugf("Could not allocate backing texture for atlas\n");
         return;
     }

     GrMaskFormat maskFormat = this->maskFormat();

     FlushInfo flushInfo;
     if (this->usesDistanceFields()) {
         flushInfo.fGeometryProcessor =
             this->setupDfProcessor(this->viewMatrix(), fFilteredColor, this->color(), texture);
     } else {
         GrTextureParams params(SkShader::kClamp_TileMode, GrTextureParams::kNone_FilterMode);
         flushInfo.fGeometryProcessor = GrBitmapTextGeoProc::Make(this->color(),
                                                                  texture,
                                                                  params,
                                                                  maskFormat,
                                                                  localMatrix,
                                                                  this->usesLocalCoords());
     }

     flushInfo.fGlyphsToFlush = 0;
     size_t vertexStride = flushInfo.fGeometryProcessor->getVertexStride();
     SkASSERT(vertexStride == GrAtlasTextBlob::GetVertexStride(maskFormat));

     int glyphCount = this->numGlyphs();
     const GrBuffer* vertexBuffer;

     void* vertices = target->makeVertexSpace(vertexStride,
                                              glyphCount * kVerticesPerGlyph,
                                              &vertexBuffer,
                                              &flushInfo.fVertexOffset);
     flushInfo.fVertexBuffer.reset(SkRef(vertexBuffer));
     flushInfo.fIndexBuffer.reset(target->resourceProvider()->refQuadIndexBuffer());
     if (!vertices || !flushInfo.fVertexBuffer) {
         SkDebugf("Could not allocate vertices\n");
         return;
     }

     unsigned char* currVertex = reinterpret_cast<unsigned char*>(vertices);

     GrBlobRegenHelper helper(this, target, &flushInfo);
     SkAutoGlyphCache glyphCache;
     for (int i = 0; i < fGeoCount; i++) {
         const Geometry& args = fGeoData[i];
         Blob* blob = args.fBlob;
         size_t byteCount;
         void* blobVertices;
         int subRunGlyphCount;
         blob->regenInBatch(target, fFontCache, &helper, args.fRun, args.fSubRun, &glyphCache,
                            vertexStride, args.fViewMatrix, args.fX, args.fY, args.fColor,
                            &blobVertices, &byteCount, &subRunGlyphCount);

         // now copy all vertices
         memcpy(currVertex, blobVertices, byteCount);

 #ifdef SK_DEBUG
         // bounds sanity check
         SkRect rect;
         rect.setLargestInverted();
         SkPoint* vertex = (SkPoint*) ((char*)blobVertices);
         rect.growToInclude(vertex, vertexStride, kVerticesPerGlyph * subRunGlyphCount);

         if (this->usesDistanceFields()) {
             args.fViewMatrix.mapRect(&rect);
         }
         // Allow for small numerical error in the bounds.
         SkRect bounds = this->bounds();
         bounds.outset(0.001f, 0.001f);
         SkASSERT(bounds.contains(rect));
 #endif

         currVertex += byteCount;
     }

     this->flush(target, &flushInfo);
 }

 void GrAtlasTextBatch::flush(GrVertexBatch::Target* target, FlushInfo* flushInfo) const {
     GrMesh mesh;
     int maxGlyphsPerDraw =
         static_cast<int>(flushInfo->fIndexBuffer->gpuMemorySize() / sizeof(uint16_t) / 6);
     mesh.initInstanced(kTriangles_GrPrimitiveType, flushInfo->fVertexBuffer,
                        flushInfo->fIndexBuffer, flushInfo->fVertexOffset,
                        kVerticesPerGlyph, kIndicesPerGlyph, flushInfo->fGlyphsToFlush,
                        maxGlyphsPerDraw);
     target->draw(flushInfo->fGeometryProcessor.get(), mesh);
     flushInfo->fVertexOffset += kVerticesPerGlyph * flushInfo->fGlyphsToFlush;
     flushInfo->fGlyphsToFlush = 0;
 }

 bool GrAtlasTextBatch::onCombineIfPossible(GrBatch* t, const GrCaps& caps) {
     GrAtlasTextBatch* that = t->cast<GrAtlasTextBatch>();
     if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *that->pipeline(),
                                 that->bounds(), caps)) {
         return false;
     }

     if (fMaskType != that->fMaskType) {
         return false;
     }

     if (!this->usesDistanceFields()) {
         if (kColorBitmapMask_MaskType == fMaskType && this->color() != that->color()) {
             return false;
         }
         if (this->usesLocalCoords() && !this->viewMatrix().cheapEqualTo(that->viewMatrix())) {
             return false;
         }
     } else {
         if (!this->viewMatrix().cheapEqualTo(that->viewMatrix())) {
             return false;
         }

         if (fFilteredColor != that->fFilteredColor) {
             return false;
         }

         if (fUseBGR != that->fUseBGR) {
             return false;
         }
     }

     fBatch.fNumGlyphs += that->numGlyphs();

     // Reallocate space for geo data if necessary and then import that's geo data.
     int newGeoCount = that->fGeoCount + fGeoCount;
     // We assume (and here enforce) that the allocation size is the smallest power of two that
     // is greater than or equal to the number of geometries (and at least
     // kMinGeometryAllocated).
     int newAllocSize = GrNextPow2(newGeoCount);
     int currAllocSize = SkTMax<int>(kMinGeometryAllocated, GrNextPow2(fGeoCount));

     if (newGeoCount > currAllocSize) {
         fGeoData.realloc(newAllocSize);
     }

     memcpy(&fGeoData[fGeoCount], that->fGeoData.get(), that->fGeoCount * sizeof(Geometry));
     // We steal the ref on the blobs from the other TextBatch and set its count to 0 so that
     // it doesn't try to unref them.
 #ifdef SK_DEBUG
     for (int i = 0; i < that->fGeoCount; ++i) {
         that->fGeoData.get()[i].fBlob = (Blob*)0x1;
     }
 #endif
     that->fGeoCount = 0;
     fGeoCount = newGeoCount;

     this->joinBounds(*that);
     return true;
 }

 // TODO just use class params
 // TODO trying to figure out why lcd is so whack
 sk_sp<GrGeometryProcessor> GrAtlasTextBatch::setupDfProcessor(const SkMatrix& viewMatrix,
                                                               SkColor filteredColor,
                                                               GrColor color,
                                                               GrTexture* texture) const {
     GrTextureParams params(SkShader::kClamp_TileMode, GrTextureParams::kBilerp_FilterMode);
     bool isLCD = this->isLCD();
     // set up any flags
     uint32_t flags = viewMatrix.isSimilarity() ? kSimilarity_DistanceFieldEffectFlag : 0;
     flags |= viewMatrix.isScaleTranslate() ? kScaleOnly_DistanceFieldEffectFlag : 0;
     flags |= fUseGammaCorrectDistanceTable ? kGammaCorrect_DistanceFieldEffectFlag : 0;

     // see if we need to create a new effect
     if (isLCD) {
         flags |= kUseLCD_DistanceFieldEffectFlag;
         flags |= fUseBGR ? kBGR_DistanceFieldEffectFlag : 0;

         GrColor colorNoPreMul = skcolor_to_grcolor_nopremultiply(filteredColor);

         float redCorrection = fDistanceAdjustTable->getAdjustment(
             GrColorUnpackR(colorNoPreMul) >> kDistanceAdjustLumShift,
             fUseGammaCorrectDistanceTable);
         float greenCorrection = fDistanceAdjustTable->getAdjustment(
             GrColorUnpackG(colorNoPreMul) >> kDistanceAdjustLumShift,
             fUseGammaCorrectDistanceTable);
         float blueCorrection = fDistanceAdjustTable->getAdjustment(
             GrColorUnpackB(colorNoPreMul) >> kDistanceAdjustLumShift,
             fUseGammaCorrectDistanceTable);
         GrDistanceFieldLCDTextGeoProc::DistanceAdjust widthAdjust =
             GrDistanceFieldLCDTextGeoProc::DistanceAdjust::Make(redCorrection,
                                                                 greenCorrection,
                                                                 blueCorrection);

         return GrDistanceFieldLCDTextGeoProc::Make(color,
                                                    viewMatrix,
                                                    texture,
                                                    params,
                                                    widthAdjust,
                                                    flags,
                                                    this->usesLocalCoords());
     } else {
 #ifdef SK_GAMMA_APPLY_TO_A8
         U8CPU lum = SkColorSpaceLuminance::computeLuminance(SK_GAMMA_EXPONENT, filteredColor);
         float correction = fDistanceAdjustTable->getAdjustment(
             lum >> kDistanceAdjustLumShift, fUseGammaCorrectDistanceTable);
         return GrDistanceFieldA8TextGeoProc::Make(color,
                                                   viewMatrix,
                                                   texture,
                                                   params,
                                                   correction,
                                                   flags,
                                                   this->usesLocalCoords());
 #else
         return GrDistanceFieldA8TextGeoProc::Make(color,
                                                   viewMatrix,
                                                   texture,
                                                   params,
                                                   flags,
                                                   this->usesLocalCoords());
 #endif
     }

 }

 void GrBlobRegenHelper::flush() {
     fBatch->flush(fTarget, fFlushInfo);
 }
	/*
	* 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 "GrAtlasTextBatch.h"

	#include "GrBatchFlushState.h"
	#include "GrResourceProvider.h"

	#include "SkGlyphCache.h"
	#include "SkMathPriv.h"

	#include "effects/GrBitmapTextGeoProc.h"
	#include "effects/GrDistanceFieldGeoProc.h"
	#include "text/GrBatchFontCache.h"

	///////////////////////////////////////////////////////////////////////////////////////////////////

	static inline GrColor skcolor_to_grcolor_nopremultiply(SkColor c) {
	unsigned r = SkColorGetR(c);
	unsigned g = SkColorGetG(c);
	unsigned b = SkColorGetB(c);
	return GrColorPackRGBA(r, g, b, 0xff);
	}

	static const int kDistanceAdjustLumShift = 5;

	SkString GrAtlasTextBatch::dumpInfo() const {
	SkString str;

	for (int i = 0; i < fGeoCount; ++i) {
	str.appendf("%d: Color: 0x%08x Trans: %.2f,%.2f Runs: %d\n",
	i,
	fGeoData[i].fColor,
	fGeoData[i].fX,
	fGeoData[i].fY,
	fGeoData[i].fBlob->runCount());
	}

	str.append(INHERITED::dumpInfo());
	return str;
	}

	void GrAtlasTextBatch::computePipelineOptimizations(GrInitInvariantOutput* color,
	GrInitInvariantOutput* coverage,
	GrBatchToXPOverrides* overrides) const {
	if (kColorBitmapMask_MaskType == fMaskType) {
	color->setUnknownFourComponents();
	} else {
	color->setKnownFourComponents(fBatch.fColor);
	}
	switch (fMaskType) {
	case kGrayscaleDistanceField_MaskType:
	case kGrayscaleCoverageMask_MaskType:
	coverage->setUnknownSingleComponent();
	break;
	case kLCDCoverageMask_MaskType:
	case kLCDDistanceField_MaskType:
	coverage->setUnknownOpaqueFourComponents();
	coverage->setUsingLCDCoverage();
	break;
	case kColorBitmapMask_MaskType:
	coverage->setKnownSingleComponent(0xff);
	}
	}

	void GrAtlasTextBatch::initBatchTracker(const GrXPOverridesForBatch& overrides) {
	// Handle any color overrides
	if (!overrides.readsColor()) {
	fGeoData[0].fColor = GrColor_ILLEGAL;
	}
	overrides.getOverrideColorIfSet(&fGeoData[0].fColor);

	// setup batch properties
	fBatch.fColorIgnored = !overrides.readsColor();
	fBatch.fColor = fGeoData[0].fColor;
	fBatch.fUsesLocalCoords = overrides.readsLocalCoords();
	fBatch.fCoverageIgnored = !overrides.readsCoverage();
	}

	void GrAtlasTextBatch::onPrepareDraws(Target* target) const {
	// if we have RGB, then we won't have any SkShaders so no need to use a localmatrix.
	// TODO actually only invert if we don't have RGBA
	SkMatrix localMatrix;
	if (this->usesLocalCoords() && !this->viewMatrix().invert(&localMatrix)) {
	SkDebugf("Cannot invert viewmatrix\n");
	return;
	}

	GrTexture* texture = fFontCache->getTexture(this->maskFormat());
	if (!texture) {
	SkDebugf("Could not allocate backing texture for atlas\n");
	return;
	}

	GrMaskFormat maskFormat = this->maskFormat();

	FlushInfo flushInfo;
	if (this->usesDistanceFields()) {
	flushInfo.fGeometryProcessor =
	this->setupDfProcessor(this->viewMatrix(), fFilteredColor, this->color(), texture);
	} else {
	GrTextureParams params(SkShader::kClamp_TileMode, GrTextureParams::kNone_FilterMode);
	flushInfo.fGeometryProcessor = GrBitmapTextGeoProc::Make(this->color(),
	texture,
	params,
	maskFormat,
	localMatrix,
	this->usesLocalCoords());
	}

	flushInfo.fGlyphsToFlush = 0;
	size_t vertexStride = flushInfo.fGeometryProcessor->getVertexStride();
	SkASSERT(vertexStride == GrAtlasTextBlob::GetVertexStride(maskFormat));

	int glyphCount = this->numGlyphs();
	const GrBuffer* vertexBuffer;

	void* vertices = target->makeVertexSpace(vertexStride,
	glyphCount * kVerticesPerGlyph,
	&vertexBuffer,
	&flushInfo.fVertexOffset);
	flushInfo.fVertexBuffer.reset(SkRef(vertexBuffer));
	flushInfo.fIndexBuffer.reset(target->resourceProvider()->refQuadIndexBuffer());
	if (!vertices \|\| !flushInfo.fVertexBuffer) {
	SkDebugf("Could not allocate vertices\n");
	return;
	}

	unsigned char* currVertex = reinterpret_cast<unsigned char*>(vertices);

	GrBlobRegenHelper helper(this, target, &flushInfo);
	SkAutoGlyphCache glyphCache;
	for (int i = 0; i < fGeoCount; i++) {
	const Geometry& args = fGeoData[i];
	Blob* blob = args.fBlob;
	size_t byteCount;
	void* blobVertices;
	int subRunGlyphCount;
	blob->regenInBatch(target, fFontCache, &helper, args.fRun, args.fSubRun, &glyphCache,
	vertexStride, args.fViewMatrix, args.fX, args.fY, args.fColor,
	&blobVertices, &byteCount, &subRunGlyphCount);

	// now copy all vertices
	memcpy(currVertex, blobVertices, byteCount);

	#ifdef SK_DEBUG
	// bounds sanity check
	SkRect rect;
	rect.setLargestInverted();
	SkPoint* vertex = (SkPoint) ((char)blobVertices);
	rect.growToInclude(vertex, vertexStride, kVerticesPerGlyph * subRunGlyphCount);

	if (this->usesDistanceFields()) {
	args.fViewMatrix.mapRect(&rect);
	}
	// Allow for small numerical error in the bounds.
	SkRect bounds = this->bounds();
	bounds.outset(0.001f, 0.001f);
	SkASSERT(bounds.contains(rect));
	#endif

	currVertex += byteCount;
	}

	this->flush(target, &flushInfo);
	}

	void GrAtlasTextBatch::flush(GrVertexBatch::Target* target, FlushInfo* flushInfo) const {
	GrMesh mesh;
	int maxGlyphsPerDraw =
	static_cast<int>(flushInfo->fIndexBuffer->gpuMemorySize() / sizeof(uint16_t) / 6);
	mesh.initInstanced(kTriangles_GrPrimitiveType, flushInfo->fVertexBuffer,
	flushInfo->fIndexBuffer, flushInfo->fVertexOffset,
	kVerticesPerGlyph, kIndicesPerGlyph, flushInfo->fGlyphsToFlush,
	maxGlyphsPerDraw);
	target->draw(flushInfo->fGeometryProcessor.get(), mesh);
	flushInfo->fVertexOffset += kVerticesPerGlyph * flushInfo->fGlyphsToFlush;
	flushInfo->fGlyphsToFlush = 0;
	}

	bool GrAtlasTextBatch::onCombineIfPossible(GrBatch* t, const GrCaps& caps) {
	GrAtlasTextBatch* that = t->cast<GrAtlasTextBatch>();
	if (!GrPipeline::CanCombine(this->pipeline(), this->bounds(), that->pipeline(),
	that->bounds(), caps)) {
	return false;
	}

	if (fMaskType != that->fMaskType) {
	return false;
	}

	if (!this->usesDistanceFields()) {
	if (kColorBitmapMask_MaskType == fMaskType && this->color() != that->color()) {
	return false;
	}
	if (this->usesLocalCoords() && !this->viewMatrix().cheapEqualTo(that->viewMatrix())) {
	return false;
	}
	} else {
	if (!this->viewMatrix().cheapEqualTo(that->viewMatrix())) {
	return false;
	}

	if (fFilteredColor != that->fFilteredColor) {
	return false;
	}

	if (fUseBGR != that->fUseBGR) {
	return false;
	}
	}

	fBatch.fNumGlyphs += that->numGlyphs();

	// Reallocate space for geo data if necessary and then import that's geo data.
	int newGeoCount = that->fGeoCount + fGeoCount;
	// We assume (and here enforce) that the allocation size is the smallest power of two that
	// is greater than or equal to the number of geometries (and at least
	// kMinGeometryAllocated).
	int newAllocSize = GrNextPow2(newGeoCount);
	int currAllocSize = SkTMax<int>(kMinGeometryAllocated, GrNextPow2(fGeoCount));

	if (newGeoCount > currAllocSize) {
	fGeoData.realloc(newAllocSize);
	}

	memcpy(&fGeoData[fGeoCount], that->fGeoData.get(), that->fGeoCount * sizeof(Geometry));
	// We steal the ref on the blobs from the other TextBatch and set its count to 0 so that
	// it doesn't try to unref them.
	#ifdef SK_DEBUG
	for (int i = 0; i < that->fGeoCount; ++i) {
	that->fGeoData.get()[i].fBlob = (Blob*)0x1;
	}
	#endif
	that->fGeoCount = 0;
	fGeoCount = newGeoCount;

	this->joinBounds(*that);
	return true;
	}

	// TODO just use class params
	// TODO trying to figure out why lcd is so whack
	sk_sp<GrGeometryProcessor> GrAtlasTextBatch::setupDfProcessor(const SkMatrix& viewMatrix,
	SkColor filteredColor,
	GrColor color,
	GrTexture* texture) const {
	GrTextureParams params(SkShader::kClamp_TileMode, GrTextureParams::kBilerp_FilterMode);
	bool isLCD = this->isLCD();
	// set up any flags
	uint32_t flags = viewMatrix.isSimilarity() ? kSimilarity_DistanceFieldEffectFlag : 0;
	flags \|= viewMatrix.isScaleTranslate() ? kScaleOnly_DistanceFieldEffectFlag : 0;
	flags \|= fUseGammaCorrectDistanceTable ? kGammaCorrect_DistanceFieldEffectFlag : 0;

	// see if we need to create a new effect
	if (isLCD) {
	flags \|= kUseLCD_DistanceFieldEffectFlag;
	flags \|= fUseBGR ? kBGR_DistanceFieldEffectFlag : 0;

	GrColor colorNoPreMul = skcolor_to_grcolor_nopremultiply(filteredColor);

	float redCorrection = fDistanceAdjustTable->getAdjustment(
	GrColorUnpackR(colorNoPreMul) >> kDistanceAdjustLumShift,
	fUseGammaCorrectDistanceTable);
	float greenCorrection = fDistanceAdjustTable->getAdjustment(
	GrColorUnpackG(colorNoPreMul) >> kDistanceAdjustLumShift,
	fUseGammaCorrectDistanceTable);
	float blueCorrection = fDistanceAdjustTable->getAdjustment(
	GrColorUnpackB(colorNoPreMul) >> kDistanceAdjustLumShift,
	fUseGammaCorrectDistanceTable);
	GrDistanceFieldLCDTextGeoProc::DistanceAdjust widthAdjust =
	GrDistanceFieldLCDTextGeoProc::DistanceAdjust::Make(redCorrection,
	greenCorrection,
	blueCorrection);

	return GrDistanceFieldLCDTextGeoProc::Make(color,
	viewMatrix,
	texture,
	params,
	widthAdjust,
	flags,
	this->usesLocalCoords());
	} else {
	#ifdef SK_GAMMA_APPLY_TO_A8
	U8CPU lum = SkColorSpaceLuminance::computeLuminance(SK_GAMMA_EXPONENT, filteredColor);
	float correction = fDistanceAdjustTable->getAdjustment(
	lum >> kDistanceAdjustLumShift, fUseGammaCorrectDistanceTable);
	return GrDistanceFieldA8TextGeoProc::Make(color,
	viewMatrix,
	texture,
	params,
	correction,
	flags,
	this->usesLocalCoords());
	#else
	return GrDistanceFieldA8TextGeoProc::Make(color,
	viewMatrix,
	texture,
	params,
	flags,
	this->usesLocalCoords());
	#endif
	}

	}

	void GrBlobRegenHelper::flush() {
	fBatch->flush(fTarget, fFlushInfo);
	}