Join non-overlapping Xfer barriers

src/gpu/GrTargetCommands.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 "GrTargetCommands.h"
 
 #include "GrColor.h"
@@ skipping 173 matching lines @@
         return NULL;
     }
 
     char* savedIndices;
     float* savedTransforms;
     
     iodb->appendIndicesAndTransforms(indexValues, indexType,
                                      transformValues, transformType,
                                      count, &savedIndices, &savedTransforms);
 
-    if (Cmd::kDrawPaths_CmdType == fCmdBuffer.back().type()) {
-        // The previous command was also DrawPaths. Try to collapse this call into the one
-        // before. Note that stenciling all the paths at once, then covering, may not be
-        // equivalent to two separate draw calls if there is overlap. Blending won't work,
-        // and the combined calls may also cancel each other's winding numbers in some
-        // places. For now the winding numbers are only an issue if the fill is even/odd,
-        // because DrawPaths is currently only used for glyphs, and glyphs in the same
-        // font tend to all wind in the same direction.
-        DrawPaths* previous = static_cast<DrawPaths*>(&fCmdBuffer.back());
+    CmdBuffer::ReverseIter reverseIter(fCmdBuffer);
+    if (Cmd::kXferBarrier_CmdType == reverseIter->type()) {
+        // We can combine instanced path commands through Xfer barriers because they are implemented
+        // by a single (non-overlapping) cover operation and they use fullscreen barriers.
+        reverseIter.previous();
+    }
+
+    if (Cmd::kDrawPaths_CmdType == reverseIter->type()) {
+        // The previous command was also DrawPaths. Try to combine this call with the one before.
+        // Note that when there is overlap, this is not equivalent to two separate draw calls. We
+        // don't worry about that case because instanced path commands are only used for text.
+        DrawPaths* previous = static_cast<DrawPaths*>(reverseIter.get());
         if (pathRange == previous->pathRange() &&
             indexType == previous->fIndexType &&
             transformType == previous->fTransformType &&
             stencilSettings == previous->fStencilSettings &&
-            path_fill_type_is_winding(stencilSettings) &&
-            !pipelineInfo.willBlendWithDst(pathProc)) {
-                const int indexBytes = GrPathRange::PathIndexSizeInBytes(indexType);
-                const int xformSize = GrPathRendering::PathTransformSize(transformType);
-                if (&previous->fIndices[previous->fCount*indexBytes] == savedIndices &&
-                    (0 == xformSize ||
-                     &previous->fTransforms[previous->fCount*xformSize] == savedTransforms)) {
-                    // Fold this DrawPaths call into the one previous.
-                    previous->fCount += count;
-                    return NULL;
+            path_fill_type_is_winding(stencilSettings)) {
+            const int indexBytes = GrPathRange::PathIndexSizeInBytes(indexType);
+            const int xformSize = GrPathRendering::PathTransformSize(transformType);
+            if (&previous->fIndices[previous->fCount*indexBytes] == savedIndices &&
+                (0 == xformSize ||
+                 &previous->fTransforms[previous->fCount*xformSize] == savedTransforms)) {
+                // Fold this DrawPaths call into the one previous.
+                previous->fCount += count;
+                if (Cmd::kXferBarrier_CmdType == fCmdBuffer.back().type()) {
+                    // Drop the barrier we fell through.
+                    fCmdBuffer.pop_back();
+                    SkASSERT(!fXferBarrier); // The Xfer barrier should have been fullscreen.
                 }
+                SkASSERT(previous == &fCmdBuffer.back());
+                return NULL;
+            }
         }
     }
 
     DrawPaths* dp = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, DrawPaths, (pathRange));
     dp->fIndices = savedIndices;
     dp->fIndexType = indexType;
     dp->fTransforms = savedTransforms;
     dp->fTransformType = transformType;
     dp->fCount = count;
     dp->fStencilSettings = stencilSettings;
@@ skipping 44 matching lines @@
 
     Clear* clr = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, Clear, (renderTarget));
     clr->fColor = GrColor_ILLEGAL;
     return clr;
 }
 
 void GrTargetCommands::reset() {
     fCmdBuffer.reset();
     fPrevState = NULL;
     fDrawBatch = NULL;
+    fXferBarrier = NULL;
 }
 
 void GrTargetCommands::flush(GrInOrderDrawBuffer* iodb) {
     if (fCmdBuffer.empty()) {
         return;
     }
 
     // TODO this is temporary while batch is being rolled out
     this->closeBatch();
     iodb->getVertexAllocPool()->unmap();
@@ skipping 105 matching lines @@
 void GrTargetCommands::ClearStencilClip::execute(GrGpu* gpu, const SetState*) {
     gpu->clearStencilClip(fRect, fInsideClip, this->renderTarget());
 }
 
 void GrTargetCommands::CopySurface::execute(GrGpu* gpu, const SetState*) {
     gpu->copySurface(this->dst(), this->src(), fSrcRect, fDstPoint);
 }
 
 void GrTargetCommands::XferBarrier::execute(GrGpu* gpu, const SetState* state) {
     SkASSERT(state);
+    SkASSERT(fRenderTarget == state->getRenderTarget());
     if (kDstCopy_GrXferBarrierType == fType) {
         GrDeviceCoordTexture dstCopy;
-        gpu->setXferBarrier(fType, state->getRenderTarget(), fBounds, &dstCopy);
-        state->getXferProcessor()->updateDstCopy(dstCopy);
+        gpu->setXferBarrier(fType, fRenderTarget, fReadBounds, &dstCopy);
+        for (int i = 0; i < fXferProcessors.count(); i++) {
+            fXferProcessors[i]->updateDstCopy(dstCopy);
+        }
     } else {
-        SkAssertResult(gpu->setXferBarrier(fType, state->getRenderTarget(), fBounds));
+        SkAssertResult(gpu->setXferBarrier(fType, fRenderTarget, fReadBounds));
     }
 }
 
 GrTargetCommands::Cmd* GrTargetCommands::recordCopySurface(GrInOrderDrawBuffer* iodb,
                                                            GrSurface* dst,
                                                            GrSurface* src,
                                                            const SkIRect& srcRect,
                                                            const SkIPoint& dstPoint) {
     if (iodb->getGpu()->canCopySurface(dst, src, srcRect, dstPoint)) {
         this->closeBatch();
@@ skipping 57 matching lines @@
         iodb->recordTraceMarkersIfNecessary(ss);
     }
 
     return this->recordXferBarrierIfNecessary(iodb, pipelineInfo);
 }
 
 bool GrTargetCommands::recordXferBarrierIfNecessary(GrInOrderDrawBuffer* iodb,
                                                     const GrDrawTarget::PipelineInfo& info) {
     SkASSERT(fPrevState);
     const GrXferProcessor& xp = *fPrevState->getXferProcessor();
+    GrRenderTarget* rt = fPrevState->getRenderTarget();
 
     GrXferBarrierType xbType = xp.setupDstReadIfNecessary(*iodb->caps(), info.getCustomDstCopy());
 
     if (kNone_GrXferBarrierType == xbType) {
-        return true;
+        // The XP doesn't need a barrier, but the draw may still affect one.
+        if (!fXferBarrier || rt != fXferBarrier->fRenderTarget) {
+            return true;
+        }
+        SkIRect drawBounds;
+        info.getQuickDrawBounds(&drawBounds);
+        fXferBarrier->fInvalidBounds.join(drawBounds);
+    } else {
+        SkIRect xferBounds;
+        if (!info.getConservativeDrawBounds(&xferBounds)) {
+            // Early reject was detected.
+            return false;
+        }
+
+        if (fXferBarrier && xbType == fXferBarrier->fType && rt == fXferBarrier->fRenderTarget &&
+            !SkIRect::IntersectsNoEmptyCheck(xferBounds, fXferBarrier->fInvalidBounds)) {
+            // We can join with the previous barrier since they match and there is no overlap.
+            fXferBarrier->fReadBounds.join(xferBounds);
+            fXferBarrier->fInvalidBounds.join(xferBounds);
+            if (fXferBarrier->fXferProcessors.back() != &xp) {
+                fXferBarrier->fXferProcessors.push_back(&xp);
+            }
+        } else {
+            // We need to set a new barrier for this draw.
+            this->closeBatch();
+
+            fXferBarrier = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, XferBarrier, (xbType, rt));
+            fXferBarrier->fReadBounds = xferBounds;
+            fXferBarrier->fInvalidBounds = xferBounds;
+            fXferBarrier->fXferProcessors.push_back(&xp);
+
+            iodb->recordTraceMarkersIfNecessary(fXferBarrier);
+        }
     }
 
-    SkIRect xferBounds;
-    if (!info.getConservativeDrawBounds(&xferBounds)) {
-        // Early reject was detected.
-        return false;
+    if (fXferBarrier->fInvalidBounds.contains(0, 0, rt->width(), rt->height())) {
+        // Close out the barrier since there is no valid area left.
+        fXferBarrier = NULL;
     }
 
-    this->closeBatch();
-
-    XferBarrier* xb = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, XferBarrier, (xbType));
-    xb->fBounds = xferBounds;
-
-    iodb->recordTraceMarkersIfNecessary(xb);
-
     return true;
 }