More threading of GrProcessorDataManager

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"
 
@@ skipping 364 matching lines @@
         return false;
     }
 
     SkAutoTUnref<const GrFragmentProcessor> fp;
     SkMatrix textureMatrix;
     textureMatrix.setIDiv(texture->width(), texture->height());
 
     // allocate a tmp buffer and sw convert the pixels to premul
     SkAutoSTMalloc<128 * 128, uint32_t> tmpPixels(0);
 
+    GrPaint paint;
     if (kUnpremul_PixelOpsFlag & pixelOpsFlags) {
         if (!GrPixelConfigIs8888(srcConfig)) {
             return false;
         }
-        fp.reset(this->createUPMToPMEffect(texture, swapRAndB, textureMatrix));
+        fp.reset(this->createUPMToPMEffect(paint.getProcessorDataManager(), texture, swapRAndB,
+                                           textureMatrix));
         // handle the unpremul step on the CPU if we couldn't create an effect to do it.
         if (!fp) {
             size_t tmpRowBytes = 4 * width;
             tmpPixels.reset(width * height);
             if (!sw_convert_to_premul(srcConfig, width, height, rowBytes, buffer, tmpRowBytes,
                                       tmpPixels.get())) {
                 return false;
             }
             rowBytes = tmpRowBytes;
             buffer = tmpPixels.get();
         }
     }
+
     if (!fp) {
-        fp.reset(GrConfigConversionEffect::Create(texture,
+        fp.reset(GrConfigConversionEffect::Create(paint.getProcessorDataManager(),
+                                                  texture,
                                                   swapRAndB,
                                                   GrConfigConversionEffect::kNone_PMConversion,
                                                   textureMatrix));
     }
 
     // Even if the client told us not to flush, we still flush here. The client may have known that
     // writes to the original surface caused no data hazards, but they can't know that the scratch
     // we just got is safe.
     if (texture->surfacePriv().hasPendingIO()) {
         this->flush();
     }
     if (!fGpu->writeTexturePixels(texture, 0, 0, width, height,
                                   writeConfig, buffer, rowBytes)) {
         return false;
     }
 
     SkMatrix matrix;
     matrix.setTranslate(SkIntToScalar(left), SkIntToScalar(top));
 
     GrDrawContext* drawContext = this->drawContext();
     if (!drawContext) {
         return false;
     }
 
-    GrPaint paint;
     paint.addColorProcessor(fp);
 
     SkRect rect = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
 
     drawContext->drawRect(renderTarget, GrClip::WideOpen(), paint, matrix, rect, NULL);
 
     if (kFlushWrites_PixelOp & pixelOpsFlags) {
         this->flushSurfaceWrites(surface);
     }
 
@@ skipping 77 matching lines @@
             fGpu->fullReadPixelsIsFasterThanPartial()) {
             match = GrTextureProvider::kExact_ScratchTexMatch;
         }
         tempTexture.reset(this->textureProvider()->refScratchTexture(desc, match));
         if (tempTexture) {
             // compute a matrix to perform the draw
             SkMatrix textureMatrix;
             textureMatrix.setTranslate(SK_Scalar1 *left, SK_Scalar1 *top);
             textureMatrix.postIDiv(src->width(), src->height());
 
+            GrPaint paint;
             SkAutoTUnref<const GrFragmentProcessor> fp;
             if (unpremul) {
-                fp.reset(this->createPMToUPMEffect(src, swapRAndB, textureMatrix));
+                fp.reset(this->createPMToUPMEffect(paint.getProcessorDataManager(), src, swapRAndB,
+                                                   textureMatrix));
                 if (fp) {
                     unpremul = false; // we no longer need to do this on CPU after the read back.
                 }
             }
             // If we failed to create a PM->UPM effect and have no other conversions to perform then
             // there is no longer any point to using the scratch.
             if (fp || flipY || swapRAndB) {
                 if (!fp) {
-                    fp.reset(GrConfigConversionEffect::Create(
+                    fp.reset(GrConfigConversionEffect::Create(paint.getProcessorDataManager(),
                             src, swapRAndB, GrConfigConversionEffect::kNone_PMConversion,
                             textureMatrix));
                 }
                 swapRAndB = false; // we will handle the swap in the draw.
 
                 // We protect the existing geometry here since it may not be
                 // clear to the caller that a draw operation (i.e., drawSimpleRect)
                 // can be invoked in this method
                 {
                     GrDrawContext* drawContext = this->drawContext();
                     if (!drawContext) {
                         return false;
                     }
 
-                    GrPaint paint;
                     paint.addColorProcessor(fp);
 
                     SkRect rect = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
 
                     drawContext->drawRect(tempTexture->asRenderTarget(), GrClip::WideOpen(), paint,
                                           SkMatrix::I(), rect, NULL);                    
 
                     // we want to read back from the scratch's origin
                     left = 0;
                     top = 0;
@@ skipping 135 matching lines @@
 namespace {
 void test_pm_conversions(GrContext* ctx, int* pmToUPMValue, int* upmToPMValue) {
     GrConfigConversionEffect::PMConversion pmToUPM;
     GrConfigConversionEffect::PMConversion upmToPM;
     GrConfigConversionEffect::TestForPreservingPMConversions(ctx, &pmToUPM, &upmToPM);
     *pmToUPMValue = pmToUPM;
     *upmToPMValue = upmToPM;
 }
 }
 
-const GrFragmentProcessor* GrContext::createPMToUPMEffect(GrTexture* texture,
+const GrFragmentProcessor* GrContext::createPMToUPMEffect(GrProcessorDataManager* procDataManager,
+                                                          GrTexture* texture,
                                                           bool swapRAndB,
                                                           const SkMatrix& matrix) {
     if (!fDidTestPMConversions) {
         test_pm_conversions(this, &fPMToUPMConversion, &fUPMToPMConversion);
         fDidTestPMConversions = true;
     }
     GrConfigConversionEffect::PMConversion pmToUPM =
         static_cast<GrConfigConversionEffect::PMConversion>(fPMToUPMConversion);
     if (GrConfigConversionEffect::kNone_PMConversion != pmToUPM) {
-        return GrConfigConversionEffect::Create(texture, swapRAndB, pmToUPM, matrix);
+        return GrConfigConversionEffect::Create(procDataManager, texture, swapRAndB, pmToUPM,
+                                                matrix);
     } else {
         return NULL;
     }
 }
 
-const GrFragmentProcessor* GrContext::createUPMToPMEffect(GrTexture* texture,
+const GrFragmentProcessor* GrContext::createUPMToPMEffect(GrProcessorDataManager* procDataManager,
+                                                          GrTexture* texture,
                                                           bool swapRAndB,
                                                           const SkMatrix& matrix) {
     if (!fDidTestPMConversions) {
         test_pm_conversions(this, &fPMToUPMConversion, &fUPMToPMConversion);
         fDidTestPMConversions = true;
     }
     GrConfigConversionEffect::PMConversion upmToPM =
         static_cast<GrConfigConversionEffect::PMConversion>(fUPMToPMConversion);
     if (GrConfigConversionEffect::kNone_PMConversion != upmToPM) {
-        return GrConfigConversionEffect::Create(texture, swapRAndB, upmToPM, matrix);
+        return GrConfigConversionEffect::Create(procDataManager, texture, swapRAndB, upmToPM,
+                                                matrix);
     } else {
         return NULL;
     }
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 void GrContext::getResourceCacheLimits(int* maxTextures, size_t* maxTextureBytes) const {
     if (maxTextures) {
         *maxTextures = fResourceCache->getMaxResourceCount();
@@ skipping 10 matching lines @@
 //////////////////////////////////////////////////////////////////////////////
 
 void GrContext::addGpuTraceMarker(const GrGpuTraceMarker* marker) {
     fGpu->addGpuTraceMarker(marker);
 }
 
 void GrContext::removeGpuTraceMarker(const GrGpuTraceMarker* marker) {
     fGpu->removeGpuTraceMarker(marker);
 }