src/gpu/GrFlushToGpuDrawTarget.cpp - skia - Git at Google

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */

 #include "GrFlushToGpuDrawTarget.h"
 #include "GrContext.h"
 #include "GrFontCache.h"
 #include "GrGpu.h"
 #include "GrBufferAllocPool.h"

 GrFlushToGpuDrawTarget::GrFlushToGpuDrawTarget(GrGpu* gpu,
                                                GrVertexBufferAllocPool* vertexPool,
                                                GrIndexBufferAllocPool* indexPool)
     : INHERITED(gpu->getContext())
     , fGpu(SkRef(gpu))
     , fVertexPool(vertexPool)
     , fIndexPool(indexPool)
     , fFlushing(false) {

     fCaps.reset(SkRef(fGpu->caps()));

     SkASSERT(vertexPool);
     SkASSERT(indexPool);

     GeometryPoolState& poolState = fGeoPoolStateStack.push_back();
     poolState.fUsedPoolVertexBytes = 0;
     poolState.fUsedPoolIndexBytes = 0;
 #ifdef SK_DEBUG
     poolState.fPoolVertexBuffer = (GrVertexBuffer*)~0;
     poolState.fPoolStartVertex = ~0;
     poolState.fPoolIndexBuffer = (GrIndexBuffer*)~0;
     poolState.fPoolStartIndex = ~0;
 #endif
 }

 GrFlushToGpuDrawTarget::~GrFlushToGpuDrawTarget() {
     // This must be called by before the GrDrawTarget destructor
     this->releaseGeometry();
 }

 void GrFlushToGpuDrawTarget::setDrawBuffers(DrawInfo* info, size_t vertexStride) {
     GeometryPoolState& poolState = fGeoPoolStateStack.back();
     if (kBuffer_GeometrySrcType == this->getGeomSrc().fVertexSrc) {
         info->setVertexBuffer(this->getGeomSrc().fVertexBuffer);
     } else {
         // Update the bytes used since the last reserve-geom request.
         size_t bytes = (info->vertexCount() + info->startVertex()) * vertexStride;
         poolState.fUsedPoolVertexBytes = SkTMax(poolState.fUsedPoolVertexBytes, bytes);
         info->setVertexBuffer(poolState.fPoolVertexBuffer);
         info->adjustStartVertex(poolState.fPoolStartVertex);
     }

     if (info->isIndexed()) {
         if (kBuffer_GeometrySrcType == this->getGeomSrc().fIndexSrc) {
             info->setIndexBuffer(this->getGeomSrc().fIndexBuffer);
         } else {
             // Update the bytes used since the last reserve-geom request.
             size_t bytes = (info->indexCount() + info->startIndex()) * sizeof(uint16_t);
             poolState.fUsedPoolIndexBytes = SkTMax(poolState.fUsedPoolIndexBytes, bytes);
             info->setIndexBuffer(poolState.fPoolIndexBuffer);
             info->adjustStartIndex(poolState.fPoolStartIndex);
         }
     }
 }

 void GrFlushToGpuDrawTarget::reset() {
     SkASSERT(1 == fGeoPoolStateStack.count());
     this->resetVertexSource();
     this->resetIndexSource();

     fVertexPool->reset();
     fIndexPool->reset();

     this->onReset();
 }

 void GrFlushToGpuDrawTarget::flush() {
     SkASSERT(kReserved_GeometrySrcType != this->getGeomSrc().fVertexSrc);
     SkASSERT(kReserved_GeometrySrcType != this->getGeomSrc().fIndexSrc);

     if (fFlushing) {
         return;
     }
     fFlushing = true;

     fGpu->getContext()->getFontCache()->updateTextures();

     fGpu->saveActiveTraceMarkers();

     this->onFlush();

     fGpu->restoreActiveTraceMarkers();

     fFlushing = false;
     this->reset();
 }

 void GrFlushToGpuDrawTarget::willReserveVertexAndIndexSpace(int vertexCount,
                                                             size_t vertexStride,
                                                             int indexCount) {
     // We use geometryHints() to know whether to flush the draw buffer. We
     // can't flush if we are inside an unbalanced pushGeometrySource.
     // Moreover, flushing blows away vertex and index data that was
     // previously reserved. So if the vertex or index data is pulled from
     // reserved space and won't be released by this request then we can't
     // flush.
     bool insideGeoPush = fGeoPoolStateStack.count() > 1;

     bool unreleasedVertexSpace =
         !vertexCount &&
         kReserved_GeometrySrcType == this->getGeomSrc().fVertexSrc;

     bool unreleasedIndexSpace =
         !indexCount &&
         kReserved_GeometrySrcType == this->getGeomSrc().fIndexSrc;

     int vcount = vertexCount;
     int icount = indexCount;

     if (!insideGeoPush &&
         !unreleasedVertexSpace &&
         !unreleasedIndexSpace &&
         this->geometryHints(vertexStride, &vcount, &icount)) {
         this->flush();
     }
 }

 bool GrFlushToGpuDrawTarget::geometryHints(size_t vertexStride,
                                            int* vertexCount,
                                            int* indexCount) const {
     // we will recommend a flush if the data could fit in a single
     // preallocated buffer but none are left and it can't fit
     // in the current buffer (which may not be prealloced).
     bool flush = false;
     if (indexCount) {
         int32_t currIndices = fIndexPool->currentBufferIndices();
         if (*indexCount > currIndices &&
             (!fIndexPool->preallocatedBuffersRemaining() &&
              *indexCount <= fIndexPool->preallocatedBufferIndices())) {

             flush = true;
         }
         *indexCount = currIndices;
     }
     if (vertexCount) {
         int32_t currVertices = fVertexPool->currentBufferVertices(vertexStride);
         if (*vertexCount > currVertices &&
             (!fVertexPool->preallocatedBuffersRemaining() &&
              *vertexCount <= fVertexPool->preallocatedBufferVertices(vertexStride))) {

             flush = true;
         }
         *vertexCount = currVertices;
     }
     return flush;
 }

 bool GrFlushToGpuDrawTarget::onReserveVertexSpace(size_t vertexSize,
                                                   int vertexCount,
                                                   void** vertices) {
     GeometryPoolState& poolState = fGeoPoolStateStack.back();
     SkASSERT(vertexCount > 0);
     SkASSERT(vertices);
     SkASSERT(0 == poolState.fUsedPoolVertexBytes);

     *vertices = fVertexPool->makeSpace(vertexSize,
                                        vertexCount,
                                        &poolState.fPoolVertexBuffer,
                                        &poolState.fPoolStartVertex);
     return SkToBool(*vertices);
 }

 bool GrFlushToGpuDrawTarget::onReserveIndexSpace(int indexCount, void** indices) {
     GeometryPoolState& poolState = fGeoPoolStateStack.back();
     SkASSERT(indexCount > 0);
     SkASSERT(indices);
     SkASSERT(0 == poolState.fUsedPoolIndexBytes);

     *indices = fIndexPool->makeSpace(indexCount,
                                      &poolState.fPoolIndexBuffer,
                                      &poolState.fPoolStartIndex);
     return SkToBool(*indices);
 }

 void GrFlushToGpuDrawTarget::releaseReservedVertexSpace() {
     GeometryPoolState& poolState = fGeoPoolStateStack.back();
     const GeometrySrcState& geoSrc = this->getGeomSrc();

     // If we get a release vertex space call then our current source should either be reserved
     // or array (which we copied into reserved space).
     SkASSERT(kReserved_GeometrySrcType == geoSrc.fVertexSrc);

     // When the caller reserved vertex buffer space we gave it back a pointer
     // provided by the vertex buffer pool. At each draw we tracked the largest
     // offset into the pool's pointer that was referenced. Now we return to the
     // pool any portion at the tail of the allocation that no draw referenced.
     size_t reservedVertexBytes = geoSrc.fVertexSize * geoSrc.fVertexCount;
     fVertexPool->putBack(reservedVertexBytes - poolState.fUsedPoolVertexBytes);
     poolState.fUsedPoolVertexBytes = 0;
     poolState.fPoolVertexBuffer = NULL;
     poolState.fPoolStartVertex = 0;
 }

 void GrFlushToGpuDrawTarget::releaseReservedIndexSpace() {
     GeometryPoolState& poolState = fGeoPoolStateStack.back();
     const GeometrySrcState& geoSrc = this->getGeomSrc();

     // If we get a release index space call then our current source should either be reserved
     // or array (which we copied into reserved space).
     SkASSERT(kReserved_GeometrySrcType == geoSrc.fIndexSrc);

     // Similar to releaseReservedVertexSpace we return any unused portion at
     // the tail
     size_t reservedIndexBytes = sizeof(uint16_t) * geoSrc.fIndexCount;
     fIndexPool->putBack(reservedIndexBytes - poolState.fUsedPoolIndexBytes);
     poolState.fUsedPoolIndexBytes = 0;
     poolState.fPoolIndexBuffer = NULL;
     poolState.fPoolStartIndex = 0;
 }

 void GrFlushToGpuDrawTarget::geometrySourceWillPush() {
     GeometryPoolState& poolState = fGeoPoolStateStack.push_back();
     poolState.fUsedPoolVertexBytes = 0;
     poolState.fUsedPoolIndexBytes = 0;
 #ifdef SK_DEBUG
     poolState.fPoolVertexBuffer = (GrVertexBuffer*)~0;
     poolState.fPoolStartVertex = ~0;
     poolState.fPoolIndexBuffer = (GrIndexBuffer*)~0;
     poolState.fPoolStartIndex = ~0;
 #endif
 }

 void GrFlushToGpuDrawTarget::geometrySourceWillPop(const GeometrySrcState& restoredState) {
     SkASSERT(fGeoPoolStateStack.count() > 1);
     fGeoPoolStateStack.pop_back();
     GeometryPoolState& poolState = fGeoPoolStateStack.back();
     // we have to assume that any slack we had in our vertex/index data
     // is now unreleasable because data may have been appended later in the
     // pool.
     if (kReserved_GeometrySrcType == restoredState.fVertexSrc) {
         poolState.fUsedPoolVertexBytes = restoredState.fVertexSize * restoredState.fVertexCount;
     }
     if (kReserved_GeometrySrcType == restoredState.fIndexSrc) {
         poolState.fUsedPoolIndexBytes = sizeof(uint16_t) * restoredState.fIndexCount;
     }
 }

 bool GrFlushToGpuDrawTarget::onCanCopySurface(const GrSurface* dst,
                                               const GrSurface* src,
                                               const SkIRect& srcRect,
                                               const SkIPoint& dstPoint) {
     return getGpu()->canCopySurface(dst, src, srcRect, dstPoint);
 }

 bool GrFlushToGpuDrawTarget::onInitCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* desc) {
     return getGpu()->initCopySurfaceDstDesc(src, desc);
 }
	/*
	* Copyright 2014 Google Inc.
	*
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/

	#include "GrFlushToGpuDrawTarget.h"
	#include "GrContext.h"
	#include "GrFontCache.h"
	#include "GrGpu.h"
	#include "GrBufferAllocPool.h"

	GrFlushToGpuDrawTarget::GrFlushToGpuDrawTarget(GrGpu* gpu,
	GrVertexBufferAllocPool* vertexPool,
	GrIndexBufferAllocPool* indexPool)
	: INHERITED(gpu->getContext())
	, fGpu(SkRef(gpu))
	, fVertexPool(vertexPool)
	, fIndexPool(indexPool)
	, fFlushing(false) {

	fCaps.reset(SkRef(fGpu->caps()));

	SkASSERT(vertexPool);
	SkASSERT(indexPool);

	GeometryPoolState& poolState = fGeoPoolStateStack.push_back();
	poolState.fUsedPoolVertexBytes = 0;
	poolState.fUsedPoolIndexBytes = 0;
	#ifdef SK_DEBUG
	poolState.fPoolVertexBuffer = (GrVertexBuffer*)~0;
	poolState.fPoolStartVertex = ~0;
	poolState.fPoolIndexBuffer = (GrIndexBuffer*)~0;
	poolState.fPoolStartIndex = ~0;
	#endif
	}

	GrFlushToGpuDrawTarget::~GrFlushToGpuDrawTarget() {
	// This must be called by before the GrDrawTarget destructor
	this->releaseGeometry();
	}

	void GrFlushToGpuDrawTarget::setDrawBuffers(DrawInfo* info, size_t vertexStride) {
	GeometryPoolState& poolState = fGeoPoolStateStack.back();
	if (kBuffer_GeometrySrcType == this->getGeomSrc().fVertexSrc) {
	info->setVertexBuffer(this->getGeomSrc().fVertexBuffer);
	} else {
	// Update the bytes used since the last reserve-geom request.
	size_t bytes = (info->vertexCount() + info->startVertex()) * vertexStride;
	poolState.fUsedPoolVertexBytes = SkTMax(poolState.fUsedPoolVertexBytes, bytes);
	info->setVertexBuffer(poolState.fPoolVertexBuffer);
	info->adjustStartVertex(poolState.fPoolStartVertex);
	}

	if (info->isIndexed()) {
	if (kBuffer_GeometrySrcType == this->getGeomSrc().fIndexSrc) {
	info->setIndexBuffer(this->getGeomSrc().fIndexBuffer);
	} else {
	// Update the bytes used since the last reserve-geom request.
	size_t bytes = (info->indexCount() + info->startIndex()) * sizeof(uint16_t);
	poolState.fUsedPoolIndexBytes = SkTMax(poolState.fUsedPoolIndexBytes, bytes);
	info->setIndexBuffer(poolState.fPoolIndexBuffer);
	info->adjustStartIndex(poolState.fPoolStartIndex);
	}
	}
	}

	void GrFlushToGpuDrawTarget::reset() {
	SkASSERT(1 == fGeoPoolStateStack.count());
	this->resetVertexSource();
	this->resetIndexSource();

	fVertexPool->reset();
	fIndexPool->reset();

	this->onReset();
	}

	void GrFlushToGpuDrawTarget::flush() {
	SkASSERT(kReserved_GeometrySrcType != this->getGeomSrc().fVertexSrc);
	SkASSERT(kReserved_GeometrySrcType != this->getGeomSrc().fIndexSrc);

	if (fFlushing) {
	return;
	}
	fFlushing = true;

	fGpu->getContext()->getFontCache()->updateTextures();

	fGpu->saveActiveTraceMarkers();

	this->onFlush();

	fGpu->restoreActiveTraceMarkers();

	fFlushing = false;
	this->reset();
	}

	void GrFlushToGpuDrawTarget::willReserveVertexAndIndexSpace(int vertexCount,
	size_t vertexStride,
	int indexCount) {
	// We use geometryHints() to know whether to flush the draw buffer. We
	// can't flush if we are inside an unbalanced pushGeometrySource.
	// Moreover, flushing blows away vertex and index data that was
	// previously reserved. So if the vertex or index data is pulled from
	// reserved space and won't be released by this request then we can't
	// flush.
	bool insideGeoPush = fGeoPoolStateStack.count() > 1;

	bool unreleasedVertexSpace =
	!vertexCount &&
	kReserved_GeometrySrcType == this->getGeomSrc().fVertexSrc;

	bool unreleasedIndexSpace =
	!indexCount &&
	kReserved_GeometrySrcType == this->getGeomSrc().fIndexSrc;

	int vcount = vertexCount;
	int icount = indexCount;

	if (!insideGeoPush &&
	!unreleasedVertexSpace &&
	!unreleasedIndexSpace &&
	this->geometryHints(vertexStride, &vcount, &icount)) {
	this->flush();
	}
	}

	bool GrFlushToGpuDrawTarget::geometryHints(size_t vertexStride,
	int* vertexCount,
	int* indexCount) const {
	// we will recommend a flush if the data could fit in a single
	// preallocated buffer but none are left and it can't fit
	// in the current buffer (which may not be prealloced).
	bool flush = false;
	if (indexCount) {
	int32_t currIndices = fIndexPool->currentBufferIndices();
	if (*indexCount > currIndices &&
	(!fIndexPool->preallocatedBuffersRemaining() &&
	*indexCount <= fIndexPool->preallocatedBufferIndices())) {

	flush = true;
	}
	*indexCount = currIndices;
	}
	if (vertexCount) {
	int32_t currVertices = fVertexPool->currentBufferVertices(vertexStride);
	if (*vertexCount > currVertices &&
	(!fVertexPool->preallocatedBuffersRemaining() &&
	*vertexCount <= fVertexPool->preallocatedBufferVertices(vertexStride))) {

	flush = true;
	}
	*vertexCount = currVertices;
	}
	return flush;
	}

	bool GrFlushToGpuDrawTarget::onReserveVertexSpace(size_t vertexSize,
	int vertexCount,
	void** vertices) {
	GeometryPoolState& poolState = fGeoPoolStateStack.back();
	SkASSERT(vertexCount > 0);
	SkASSERT(vertices);
	SkASSERT(0 == poolState.fUsedPoolVertexBytes);

	*vertices = fVertexPool->makeSpace(vertexSize,
	vertexCount,
	&poolState.fPoolVertexBuffer,
	&poolState.fPoolStartVertex);
	return SkToBool(*vertices);
	}

	bool GrFlushToGpuDrawTarget::onReserveIndexSpace(int indexCount, void** indices) {
	GeometryPoolState& poolState = fGeoPoolStateStack.back();
	SkASSERT(indexCount > 0);
	SkASSERT(indices);
	SkASSERT(0 == poolState.fUsedPoolIndexBytes);

	*indices = fIndexPool->makeSpace(indexCount,
	&poolState.fPoolIndexBuffer,
	&poolState.fPoolStartIndex);
	return SkToBool(*indices);
	}

	void GrFlushToGpuDrawTarget::releaseReservedVertexSpace() {
	GeometryPoolState& poolState = fGeoPoolStateStack.back();
	const GeometrySrcState& geoSrc = this->getGeomSrc();

	// If we get a release vertex space call then our current source should either be reserved
	// or array (which we copied into reserved space).
	SkASSERT(kReserved_GeometrySrcType == geoSrc.fVertexSrc);

	// When the caller reserved vertex buffer space we gave it back a pointer
	// provided by the vertex buffer pool. At each draw we tracked the largest
	// offset into the pool's pointer that was referenced. Now we return to the
	// pool any portion at the tail of the allocation that no draw referenced.
	size_t reservedVertexBytes = geoSrc.fVertexSize * geoSrc.fVertexCount;
	fVertexPool->putBack(reservedVertexBytes - poolState.fUsedPoolVertexBytes);
	poolState.fUsedPoolVertexBytes = 0;
	poolState.fPoolVertexBuffer = NULL;
	poolState.fPoolStartVertex = 0;
	}

	void GrFlushToGpuDrawTarget::releaseReservedIndexSpace() {
	GeometryPoolState& poolState = fGeoPoolStateStack.back();
	const GeometrySrcState& geoSrc = this->getGeomSrc();

	// If we get a release index space call then our current source should either be reserved
	// or array (which we copied into reserved space).
	SkASSERT(kReserved_GeometrySrcType == geoSrc.fIndexSrc);

	// Similar to releaseReservedVertexSpace we return any unused portion at
	// the tail
	size_t reservedIndexBytes = sizeof(uint16_t) * geoSrc.fIndexCount;
	fIndexPool->putBack(reservedIndexBytes - poolState.fUsedPoolIndexBytes);
	poolState.fUsedPoolIndexBytes = 0;
	poolState.fPoolIndexBuffer = NULL;
	poolState.fPoolStartIndex = 0;
	}

	void GrFlushToGpuDrawTarget::geometrySourceWillPush() {
	GeometryPoolState& poolState = fGeoPoolStateStack.push_back();
	poolState.fUsedPoolVertexBytes = 0;
	poolState.fUsedPoolIndexBytes = 0;
	#ifdef SK_DEBUG
	poolState.fPoolVertexBuffer = (GrVertexBuffer*)~0;
	poolState.fPoolStartVertex = ~0;
	poolState.fPoolIndexBuffer = (GrIndexBuffer*)~0;
	poolState.fPoolStartIndex = ~0;
	#endif
	}

	void GrFlushToGpuDrawTarget::geometrySourceWillPop(const GeometrySrcState& restoredState) {
	SkASSERT(fGeoPoolStateStack.count() > 1);
	fGeoPoolStateStack.pop_back();
	GeometryPoolState& poolState = fGeoPoolStateStack.back();
	// we have to assume that any slack we had in our vertex/index data
	// is now unreleasable because data may have been appended later in the
	// pool.
	if (kReserved_GeometrySrcType == restoredState.fVertexSrc) {
	poolState.fUsedPoolVertexBytes = restoredState.fVertexSize * restoredState.fVertexCount;
	}
	if (kReserved_GeometrySrcType == restoredState.fIndexSrc) {
	poolState.fUsedPoolIndexBytes = sizeof(uint16_t) * restoredState.fIndexCount;
	}
	}

	bool GrFlushToGpuDrawTarget::onCanCopySurface(const GrSurface* dst,
	const GrSurface* src,
	const SkIRect& srcRect,
	const SkIPoint& dstPoint) {
	return getGpu()->canCopySurface(dst, src, srcRect, dstPoint);
	}

	bool GrFlushToGpuDrawTarget::onInitCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* desc) {
	return getGpu()->initCopySurfaceDstDesc(src, desc);
	}