Creating functions for uploading a mipmapped texture.

src/gpu/GrContext.cpp

-
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrContext.h"
 
 #include "GrBatchFontCache.h"
 #include "GrBatchFlushState.h"
 #include "GrBatchTest.h"
 #include "GrCaps.h"
 #include "GrContextOptions.h"
 #include "GrDefaultGeoProcFactory.h"
 #include "GrDrawContext.h"
 #include "GrDrawTarget.h"
 #include "GrGpuResource.h"
 #include "GrGpuResourcePriv.h"
 #include "GrGpu.h"
 #include "GrIndexBuffer.h"
 #include "GrLayerCache.h"
 #include "GrOvalRenderer.h"
 #include "GrPathRenderer.h"
 #include "GrPathUtils.h"
 #include "GrRenderTargetPriv.h"
 #include "GrResourceCache.h"
 #include "GrResourceProvider.h"
 #include "GrSoftwarePathRenderer.h"
+#include "GrStencilAndCoverTextContext.h"
 #include "GrStrokeInfo.h"
 #include "GrSurfacePriv.h"
 #include "GrTextBlobCache.h"
 #include "GrTexturePriv.h"
 #include "GrTracing.h"
 #include "GrVertices.h"
 #include "SkDashPathPriv.h"
 #include "SkConfig8888.h"
-#include "SkGr.h"
+#include "SkGrPriv.h"
 #include "SkRRect.h"
 #include "SkStrokeRec.h"
 #include "SkSurfacePriv.h"
 #include "SkTLazy.h"
 #include "SkTLS.h"
 #include "SkTraceEvent.h"
+#include "SkTypes.h"
 
 #include "batches/GrBatch.h"
 
 #include "effects/GrConfigConversionEffect.h"
 #include "effects/GrDashingEffect.h"
 #include "effects/GrSingleTextureEffect.h"
 
 #define ASSERT_OWNED_RESOURCE(R) SkASSERT(!(R) || (R)->getContext() == this)
 #define RETURN_IF_ABANDONED if (fDrawingMgr.abandoned()) { return; }
 #define RETURN_FALSE_IF_ABANDONED if (fDrawingMgr.abandoned()) { return false; }
 #define RETURN_NULL_IF_ABANDONED if (fDrawingMgr.abandoned()) { return nullptr; }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrContext::DrawingMgr::init(GrContext* context) {
     fContext = context;
     fDrawTarget = new GrDrawTarget(context->getGpu(), context->resourceProvider());
 }
 
 void GrContext::DrawingMgr::cleanup() {
     SkSafeSetNull(fDrawTarget);
+    delete fNVPRTextContext;
+    fNVPRTextContext = nullptr;
     for (int i = 0; i < kNumPixelGeometries; ++i) {
-        SkSafeSetNull(fDrawContext[i][0]);
-        SkSafeSetNull(fDrawContext[i][1]);
+        delete fTextContexts[i][0];
+        fTextContexts[i][0] = nullptr;
+        delete fTextContexts[i][1];
+        fTextContexts[i][1] = nullptr;
     }
 }
 
 GrContext::DrawingMgr::~DrawingMgr() {
     this->cleanup();
 }
 
 void GrContext::DrawingMgr::abandon() {
-    SkSafeSetNull(fDrawTarget);
-    for (int i = 0; i < kNumPixelGeometries; ++i) {
-        for (int j = 0; j < kNumDFTOptions; ++j) {
-            if (fDrawContext[i][j]) {
-                SkSafeSetNull(fDrawContext[i][j]->fDrawTarget);
-                SkSafeSetNull(fDrawContext[i][j]);
-            }
-        }
-    }
-}
-
-void GrContext::DrawingMgr::purgeResources() {
-    if (fDrawTarget) {
-        fDrawTarget->purgeResources();
-    }
+    this->cleanup();
 }
 
 void GrContext::DrawingMgr::reset() {
     if (fDrawTarget) {
         fDrawTarget->reset();
     }
 }
 
 void GrContext::DrawingMgr::flush() {
     if (fDrawTarget) {
         fDrawTarget->flush();
     }
 }
 
-GrDrawContext* GrContext::DrawingMgr::drawContext(const SkSurfaceProps* surfaceProps) {
+GrTextContext* GrContext::DrawingMgr::textContext(const SkSurfaceProps& props,
+                                                  GrRenderTarget* rt) {
     if (this->abandoned()) {
         return nullptr;
     }
 
-    const SkSurfaceProps props(SkSurfacePropsCopyOrDefault(surfaceProps));
+    SkASSERT(props.pixelGeometry() < kNumPixelGeometries);
+    bool useDIF = props.isUseDeviceIndependentFonts();
 
-    SkASSERT(props.pixelGeometry() < kNumPixelGeometries);
-    if (!fDrawContext[props.pixelGeometry()][props.isUseDeviceIndependentFonts()]) {
-        fDrawContext[props.pixelGeometry()][props.isUseDeviceIndependentFonts()] =
-                new GrDrawContext(fContext, fDrawTarget, props);
+    if (useDIF && fContext->caps()->shaderCaps()->pathRenderingSupport() &&
+        rt->isStencilBufferMultisampled()) {
+        GrStencilAttachment* sb = fContext->resourceProvider()->attachStencilAttachment(rt);
+        if (sb) {
+            if (!fNVPRTextContext) {
+                fNVPRTextContext = GrStencilAndCoverTextContext::Create(fContext, props);
+            }
+
+            return fNVPRTextContext;
+        }
     }
 
-    // For now, everyone gets a faux creation ref
-    return SkRef(fDrawContext[props.pixelGeometry()][props.isUseDeviceIndependentFonts()]);
+    if (!fTextContexts[props.pixelGeometry()][useDIF]) {
+        fTextContexts[props.pixelGeometry()][useDIF] = GrAtlasTextContext::Create(fContext, props);
+    }
+
+    return fTextContexts[props.pixelGeometry()][useDIF];
+}
+
+GrDrawContext* GrContext::DrawingMgr::drawContext(GrRenderTarget* rt,
+                                                  const SkSurfaceProps* surfaceProps) {
+    if (this->abandoned()) {
+        return nullptr;
+    }
+
+    return new GrDrawContext(fContext, rt, fDrawTarget, surfaceProps);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 
 GrContext* GrContext::Create(GrBackend backend, GrBackendContext backendContext) {
     GrContextOptions defaultOptions;
     return Create(backend, backendContext, defaultOptions);
 }
 
@@ skipping 103 matching lines @@
     fTextBlobCache->freeAll();
 }
 
 void GrContext::resetContext(uint32_t state) {
     fGpu->markContextDirty(state);
 }
 
 void GrContext::freeGpuResources() {
     this->flush();
 
-    fDrawingMgr.purgeResources();
-
     fBatchFontCache->freeAll();
     fLayerCache->freeAll();
     // a path renderer may be holding onto resources
     SkSafeSetNull(fPathRendererChain);
     SkSafeSetNull(fSoftwarePathRenderer);
 
     fResourceCache->purgeAllUnlocked();
 }
 
 void GrContext::getResourceCacheUsage(int* resourceCount, size_t* resourceBytes) const {
@@ skipping 55 matching lines @@
     dstPI.fColorType = srcPI.fColorType;
     dstPI.fAlphaType = kPremul_SkAlphaType;
     dstPI.fPixels = outPixels;
     dstPI.fRowBytes = outRowBytes;
 
     return srcPI.convertPixelsTo(&dstPI, width, height);
 }
 
 bool GrContext::writeSurfacePixels(GrSurface* surface,
                                    int left, int top, int width, int height,
-                                   GrPixelConfig srcConfig, const void* buffer, size_t rowBytes,
+                                   GrPixelConfig srcConfig, const SkTArray<SkMipMapLevel>& texels,
                                    uint32_t pixelOpsFlags) {
     RETURN_FALSE_IF_ABANDONED
     ASSERT_OWNED_RESOURCE(surface);
     SkASSERT(surface);
 
+    SkTArray<SkMipMapLevel> texelsCopy(texels);
+
     this->testPMConversionsIfNecessary(pixelOpsFlags);
 
     // Trim the params here so that if we wind up making a temporary surface it can be as small as
     // necessary and because GrGpu::getWritePixelsInfo requires it.
-    if (!GrSurfacePriv::AdjustWritePixelParams(surface->width(), surface->height(),
-                                               GrBytesPerPixel(srcConfig), &left, &top, &width,
-                                               &height, &buffer, &rowBytes)) {
-        return false;
+    for (int currentMipLevel = texelsCopy.count() - 1; currentMipLevel >= 0; currentMipLevel--) {
+        // make sure the texelmap's size range is within int range
+        if (texelsCopy[currentMipLevel].fWidth > SK_MaxS32
+            || texelsCopy[currentMipLevel].fHeight > SK_MaxS32) {
+            return false;
+        }
+        int currentMipWidth = texelsCopy[currentMipLevel].fWidth;
+        int currentMipHeight = texelsCopy[currentMipLevel].fHeight;
+
+        SkMipMapLevel& currentMipMap = texelsCopy[currentMipLevel];
+        if (!GrSurfacePriv::AdjustWritePixelParams(surface->width(), surface->height(),
+                                                   GrBytesPerPixel(srcConfig), &left, &top,
+                                                   &currentMipWidth, &currentMipHeight,
+                                                   &currentMipMap.fTexels,
+                                                   &currentMipMap.fRowBytes)) {
+            return false;
+        }
+
+        // make sure the size range is within the texelmap's size range
+        if (currentMipWidth < 0 || currentMipHeight < 0) {
+            return false;
+        }
+        texelsCopy[currentMipLevel].fWidth = currentMipWidth;
+        texelsCopy[currentMipLevel].fHeight = currentMipHeight;
     }
 
     bool applyPremulToSrc = false;
     if (kUnpremul_PixelOpsFlag & pixelOpsFlags) {
         if (!GrPixelConfigIs8888(srcConfig)) {
             return false;
         }
         applyPremulToSrc = true;
     }
 
     GrGpu::DrawPreference drawPreference = GrGpu::kNoDraw_DrawPreference;
     // Don't prefer to draw for the conversion (and thereby access a texture from the cache) when
     // we've already determined that there isn't a roundtrip preserving conversion processor pair.
     if (applyPremulToSrc && !this->didFailPMUPMConversionTest()) {
         drawPreference = GrGpu::kCallerPrefersDraw_DrawPreference;
     }
 
     GrGpu::WritePixelTempDrawInfo tempDrawInfo;
-    if (!fGpu->getWritePixelsInfo(surface, width, height, rowBytes, srcConfig, &drawPreference,
+    if (!fGpu->getWritePixelsInfo(surface, width, height, srcConfig, &drawPreference,
                                   &tempDrawInfo)) {
         return false;
     }
 
     if (!(kDontFlush_PixelOpsFlag & pixelOpsFlags) && surface->surfacePriv().hasPendingIO()) {
         this->flush();
     }
 
     SkAutoTUnref<GrTexture> tempTexture;
     if (GrGpu::kNoDraw_DrawPreference != drawPreference) {
         tempTexture.reset(
             this->textureProvider()->createApproxTexture(tempDrawInfo.fTempSurfaceDesc));
         if (!tempTexture && GrGpu::kRequireDraw_DrawPreference == drawPreference) {
             return false;
         }
     }
 
     // temp buffer for doing sw premul conversion, if needed.
     SkAutoSTMalloc<128 * 128, uint32_t> tmpPixels(0);
     if (tempTexture) {
         SkAutoTUnref<const GrFragmentProcessor> fp;
         SkMatrix textureMatrix;
         textureMatrix.setIDiv(tempTexture->width(), tempTexture->height());
         GrPaint paint;
         if (applyPremulToSrc) {
-            fp.reset(this->createUPMToPMEffect(paint.getProcessorDataManager(), tempTexture,
-                                               tempDrawInfo.fSwapRAndB, textureMatrix));
+            fp.reset(this->createUPMToPMEffect(tempTexture, tempDrawInfo.fSwapRAndB,
+                                               textureMatrix));
             // If premultiplying was the only reason for the draw, fall back to a straight write.
             if (!fp) {
                 if (GrGpu::kCallerPrefersDraw_DrawPreference == drawPreference) {
                     tempTexture.reset(nullptr);
                 }
             } else {
                 applyPremulToSrc = false;
             }
         }
         if (tempTexture) {
             if (!fp) {
-                fp.reset(GrConfigConversionEffect::Create(
-                    paint.getProcessorDataManager(), tempTexture, tempDrawInfo.fSwapRAndB,
+                fp.reset(GrConfigConversionEffect::Create(tempTexture, tempDrawInfo.fSwapRAndB,
                     GrConfigConversionEffect::kNone_PMConversion, textureMatrix));
                 if (!fp) {
                     return false;
                 }
             }
             GrRenderTarget* renderTarget = surface->asRenderTarget();
             SkASSERT(renderTarget);
             if (tempTexture->surfacePriv().hasPendingIO()) {
                 this->flush();
             }
             if (applyPremulToSrc) {
-                size_t tmpRowBytes = 4 * width;
-                tmpPixels.reset(width * height);
-                if (!sw_convert_to_premul(srcConfig, width, height, rowBytes, buffer, tmpRowBytes,
-                                          tmpPixels.get())) {
-                    return false;
+                for (int currentMipLevel = texelsCopy.count() - 1; currentMipLevel >= 0;
+                     currentMipLevel--) {
+                    SkMipMapLevel& currentMipMap = texelsCopy[currentMipLevel];
+                    int currentWidth = currentMipMap.fWidth;
+                    int currentHeight = currentMipMap.fHeight;
+                    size_t tmpRowBytes = 4 * currentWidth;
+                    tmpPixels.reset(currentWidth * currentHeight);
+                    if (!sw_convert_to_premul(srcConfig, currentWidth, currentHeight,
+                                              currentMipMap.fRowBytes,
+                                              currentMipMap.fTexels, tmpRowBytes,
+                                              tmpPixels.get())) {
+                        return false;
+                    }
+                    currentMipMap.fRowBytes = tmpRowBytes;
+                    currentMipMap.fTexels = tmpPixels.get();
                 }
-                rowBytes = tmpRowBytes;
-                buffer = tmpPixels.get();
                 applyPremulToSrc = false;
             }
             if (!fGpu->writePixels(tempTexture, 0, 0, width, height,
-                                   tempDrawInfo.fTempSurfaceDesc.fConfig, buffer,
-                                   rowBytes)) {
+                                   tempDrawInfo.fTempSurfaceDesc.fConfig, texelsCopy)) {
                 return false;
             }
             SkMatrix matrix;
             matrix.setTranslate(SkIntToScalar(left), SkIntToScalar(top));
-            SkAutoTUnref<GrDrawContext> drawContext(this->drawContext());
+            SkAutoTUnref<GrDrawContext> drawContext(this->drawContext(renderTarget));
             if (!drawContext) {
                 return false;
             }
             paint.addColorFragmentProcessor(fp);
             SkRect rect = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
-            drawContext->drawRect(renderTarget, GrClip::WideOpen(), paint, matrix, rect, nullptr);
+            drawContext->drawRect(GrClip::WideOpen(), paint, matrix, rect, nullptr);
 
             if (kFlushWrites_PixelOp & pixelOpsFlags) {
                 this->flushSurfaceWrites(surface);
             }
         }
     }
     if (!tempTexture) {
         if (applyPremulToSrc) {
-            size_t tmpRowBytes = 4 * width;
-            tmpPixels.reset(width * height);
-            if (!sw_convert_to_premul(srcConfig, width, height, rowBytes, buffer, tmpRowBytes,
-                                      tmpPixels.get())) {
-                return false;
+            for (int currentMipLevel = texelsCopy.count() - 1; currentMipLevel >= 0;
+                 currentMipLevel--) {
+                SkMipMapLevel& currentMipMap = texelsCopy[currentMipLevel];
+                int currentMipWidth = currentMipMap.fWidth;
+                int currentMipHeight = currentMipMap.fHeight;
+                size_t tmpRowBytes = 4 * currentMipWidth;
+                tmpPixels.reset(currentMipWidth * currentMipHeight);
+                if (!sw_convert_to_premul(srcConfig, currentMipWidth, currentMipHeight,
+                                          currentMipMap.fRowBytes, currentMipMap.fTexels,
+                                          tmpRowBytes, tmpPixels.get())) {
+                    return false;
+                }
+                currentMipMap.fRowBytes = tmpRowBytes;
+                currentMipMap.fTexels = tmpPixels.get();
             }
-            rowBytes = tmpRowBytes;
-            buffer = tmpPixels.get();
             applyPremulToSrc = false;
         }
-        return fGpu->writePixels(surface, left, top, width, height, srcConfig, buffer, rowBytes);
+        return fGpu->writePixels(surface, left, top, width, height, srcConfig, texelsCopy);
     }
     return true;
 }
 
+bool GrContext::writeSurfacePixels(GrSurface* surface,
+                                   int left, int top, int width, int height,
+                                   GrPixelConfig srcConfig, const void* buffer, size_t rowBytes,
+                                   uint32_t pixelOpsFlags) {
+    if (width <= 0 || height <= 0) {
+        return false;
+    }
+    const uint32_t baseLevelWidth = width;
+    const uint32_t baseLevelHeight = height;
+
+    SkMipMapLevel level(buffer, rowBytes, baseLevelWidth, baseLevelHeight);
+    const int mipLevelCount = 1;
+    SkTArray<SkMipMapLevel> texels(mipLevelCount);
+    texels.push_back(level);
+
+    return this->writeSurfacePixels(surface, left, top, width, height, srcConfig, texels,
+                                    pixelOpsFlags);
+}
+
 bool GrContext::readSurfacePixels(GrSurface* src,
                                   int left, int top, int width, int height,
                                   GrPixelConfig dstConfig, void* buffer, size_t rowBytes,
                                   uint32_t flags) {
     RETURN_FALSE_IF_ABANDONED
     ASSERT_OWNED_RESOURCE(src);
     SkASSERT(src);
 
     this->testPMConversionsIfNecessary(flags);
     SkAutoMutexAcquire ama(fReadPixelsMutex);
@@ skipping 45 matching lines @@
         } else {
             temp.reset(this->textureProvider()->createApproxTexture(tempDrawInfo.fTempSurfaceDesc));
         }
         if (temp) {
             SkMatrix textureMatrix;
             textureMatrix.setTranslate(SkIntToScalar(left), SkIntToScalar(top));
             textureMatrix.postIDiv(src->width(), src->height());
             GrPaint paint;
             SkAutoTUnref<const GrFragmentProcessor> fp;
             if (unpremul) {
-                fp.reset(this->createPMToUPMEffect(
-                    paint.getProcessorDataManager(), src->asTexture(), tempDrawInfo.fSwapRAndB,
+                fp.reset(this->createPMToUPMEffect(src->asTexture(), tempDrawInfo.fSwapRAndB,
                     textureMatrix));
                 if (fp) {
                     unpremul = false; // we no longer need to do this on CPU after the read back.
                 } else if (GrGpu::kCallerPrefersDraw_DrawPreference == drawPreference) {
                     // We only wanted to do the draw in order to perform the unpremul so don't
                     // bother.
                     temp.reset(nullptr);
                 }
             }
             if (!fp && temp) {
-                fp.reset(GrConfigConversionEffect::Create(
-                    paint.getProcessorDataManager(), src->asTexture(), tempDrawInfo.fSwapRAndB,
+                fp.reset(GrConfigConversionEffect::Create(src->asTexture(), tempDrawInfo.fSwapRAndB,
                     GrConfigConversionEffect::kNone_PMConversion, textureMatrix));
             }
             if (fp) {
                 paint.addColorFragmentProcessor(fp);
                 SkRect rect = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
-                SkAutoTUnref<GrDrawContext> drawContext(this->drawContext());
-                drawContext->drawRect(temp->asRenderTarget(), GrClip::WideOpen(), paint,
-                                      SkMatrix::I(), rect, nullptr);
+                SkAutoTUnref<GrDrawContext> drawContext(this->drawContext(temp->asRenderTarget()));
+                drawContext->drawRect(GrClip::WideOpen(), paint, SkMatrix::I(), rect, nullptr);
                 surfaceToRead.reset(SkRef(temp.get()));
                 left = 0;
                 top = 0;
                 didTempDraw = true;
             }
         }
     }
 
     if (GrGpu::kRequireDraw_DrawPreference == drawPreference && !didTempDraw) {
         return false;
@@ skipping 53 matching lines @@
     }
     ASSERT_OWNED_RESOURCE(src);
     ASSERT_OWNED_RESOURCE(dst);
 
     // Since we're going to the draw target and not GPU, no need to check kNoFlush
     // here.
     if (!dst->asRenderTarget()) {
         return;
     }
 
-    SkAutoTUnref<GrDrawContext> drawContext(this->drawContext());
+    SkAutoTUnref<GrDrawContext> drawContext(this->drawContext(dst->asRenderTarget()));
     if (!drawContext) {
         return;
     }
 
-    drawContext->copySurface(dst->asRenderTarget(), src, srcRect, dstPoint);
+    drawContext->copySurface(src, srcRect, dstPoint);
 
     if (kFlushWrites_PixelOp & pixelOpsFlags) {
         this->flush();
     }
 }
 
 void GrContext::flushSurfaceWrites(GrSurface* surface) {
     RETURN_IF_ABANDONED
     if (surface->surfacePriv().hasPendingWrite()) {
         this->flush();
@@ skipping 68 matching lines @@
 void GrContext::testPMConversionsIfNecessary(uint32_t flags) {
     if (SkToBool(kUnpremul_PixelOpsFlag & flags)) {
         SkAutoMutexAcquire ama(fTestPMConversionsMutex);
         if (!fDidTestPMConversions) {
             test_pm_conversions(this, &fPMToUPMConversion, &fUPMToPMConversion);
             fDidTestPMConversions = true;
         }
     }
 }
 
-const GrFragmentProcessor* GrContext::createPMToUPMEffect(GrProcessorDataManager* procDataManager,
-                                                          GrTexture* texture,
+const GrFragmentProcessor* GrContext::createPMToUPMEffect(GrTexture* texture,
                                                           bool swapRAndB,
                                                           const SkMatrix& matrix) const {
     // We should have already called this->testPMConversionsIfNecessary().
     SkASSERT(fDidTestPMConversions);
     GrConfigConversionEffect::PMConversion pmToUPM =
         static_cast<GrConfigConversionEffect::PMConversion>(fPMToUPMConversion);
     if (GrConfigConversionEffect::kNone_PMConversion != pmToUPM) {
-        return GrConfigConversionEffect::Create(procDataManager, texture, swapRAndB, pmToUPM,
-                                                matrix);
+        return GrConfigConversionEffect::Create(texture, swapRAndB, pmToUPM, matrix);
     } else {
         return nullptr;
     }
 }
 
-const GrFragmentProcessor* GrContext::createUPMToPMEffect(GrProcessorDataManager* procDataManager,
-                                                          GrTexture* texture,
+const GrFragmentProcessor* GrContext::createUPMToPMEffect(GrTexture* texture,
                                                           bool swapRAndB,
                                                           const SkMatrix& matrix) const {
     // We should have already called this->testPMConversionsIfNecessary().
     SkASSERT(fDidTestPMConversions);
     GrConfigConversionEffect::PMConversion upmToPM =
         static_cast<GrConfigConversionEffect::PMConversion>(fUPMToPMConversion);
     if (GrConfigConversionEffect::kNone_PMConversion != upmToPM) {
-        return GrConfigConversionEffect::Create(procDataManager, texture, swapRAndB, upmToPM,
-                                                matrix);
+        return GrConfigConversionEffect::Create(texture, swapRAndB, upmToPM, matrix);
     } else {
         return nullptr;
     }
 }
 
 bool GrContext::didFailPMUPMConversionTest() const {
     // We should have already called this->testPMConversionsIfNecessary().
     SkASSERT(fDidTestPMConversions);
     // The PM<->UPM tests fail or succeed together so we only need to check one.
     return GrConfigConversionEffect::kNone_PMConversion == fPMToUPMConversion;
@@ skipping 12 matching lines @@
 
 void GrContext::setResourceCacheLimits(int maxTextures, size_t maxTextureBytes) {
     fResourceCache->setLimits(maxTextures, maxTextureBytes);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 void GrContext::dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const {
     fResourceCache->dumpMemoryStatistics(traceMemoryDump);
 }