Make GrGpu read/write pixels take GrSurface

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 398 matching lines @@
                 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();
                 applyPremulToSrc = false;
             }
-            if (!fGpu->writeTexturePixels(tempTexture, 0, 0, width, height,
-                                          tempDrawInfo.fTempSurfaceDesc.fConfig, buffer,
-                                          rowBytes)) {
+            if (!fGpu->writePixels(tempTexture, 0, 0, width, height,
+                                   tempDrawInfo.fTempSurfaceDesc.fConfig, buffer,
+                                   rowBytes)) {
                 return false;
             }
             SkMatrix matrix;
             matrix.setTranslate(SkIntToScalar(left), SkIntToScalar(top));
             GrDrawContext* drawContext = this->drawContext();
             if (!drawContext) {
                 return false;
             }
             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);
             }
         }
     }
     if (!tempTexture) {
-        SkASSERT(surface->asTexture());
         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;
             }
             rowBytes = tmpRowBytes;
             buffer = tmpPixels.get();
             applyPremulToSrc = false;
         }
-        return fGpu->writeTexturePixels(surface->asTexture(), left, top, width, height, srcConfig,
-                                        buffer, rowBytes);
+        return fGpu->writePixels(surface, left, top, width, height, srcConfig, buffer, rowBytes);
     }
     return true;
 }
 
 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);
@@ skipping 23 matching lines @@
     if (unpremul && !this->didFailPMUPMConversionTest()) {
         drawPreference = GrGpu::kCallerPrefersDraw_DrawPreference;
     }
 
     GrGpu::ReadPixelTempDrawInfo tempDrawInfo;
     if (!fGpu->getReadPixelsInfo(src, width, height, rowBytes, dstConfig, &drawPreference,
                                  &tempDrawInfo)) {
         return false;
     }
 
-    SkAutoTUnref<GrRenderTarget> rtToRead(SkSafeRef(src->asRenderTarget()));
+    SkAutoTUnref<GrSurface> surfaceToRead(SkRef(src));
     bool didTempDraw = false;
     if (GrGpu::kNoDraw_DrawPreference != drawPreference) {
         GrTextureProvider::ScratchTexMatch match = GrTextureProvider::kApprox_ScratchTexMatch;
         if (tempDrawInfo.fUseExactScratch) {
             // We only respect this when the entire src is being read. Otherwise we can trigger too
             // many odd ball texture sizes and trash the cache.
             if (width == src->width() && height == src->height()) {
                 match = GrTextureProvider::kExact_ScratchTexMatch;
             }
         }
@@ skipping 22 matching lines @@
                 fp.reset(GrConfigConversionEffect::Create(
                     paint.getProcessorDataManager(), src->asTexture(), tempDrawInfo.fSwapRAndB,
                     GrConfigConversionEffect::kNone_PMConversion, textureMatrix));
             }
             if (fp) {
                 paint.addColorProcessor(fp);
                 SkRect rect = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
                 GrDrawContext* drawContext = this->drawContext();
                 drawContext->drawRect(temp->asRenderTarget(), GrClip::WideOpen(), paint,
                                       SkMatrix::I(), rect, NULL);
-                rtToRead.reset(SkRef(temp->asRenderTarget()));
+                surfaceToRead.reset(SkRef(temp.get()));
                 left = 0;
                 top = 0;
                 didTempDraw = true;
             }
         }
     }
 
     if (GrGpu::kRequireDraw_DrawPreference == drawPreference && !didTempDraw) {
         return false;
     }
     GrPixelConfig configToRead = dstConfig;
     if (didTempDraw) {
-        this->flushSurfaceWrites(rtToRead);
+        this->flushSurfaceWrites(surfaceToRead);
         // We swapped R and B while doing the temp draw. Swap back on the read.
         if (tempDrawInfo.fSwapRAndB) {
             configToRead = GrPixelConfigSwapRAndB(dstConfig);
         }
     }
-    if (!fGpu->readPixels(rtToRead, left, top, width, height, configToRead, buffer, rowBytes)) {
+    if (!fGpu->readPixels(surfaceToRead, left, top, width, height, configToRead, buffer,
+                           rowBytes)) {
         return false;
     }
 
     // Perform umpremul conversion if we weren't able to perform it as a draw.
     if (unpremul) {
         SkDstPixelInfo dstPI;
         if (!GrPixelConfig2ColorAndProfileType(dstConfig, &dstPI.fColorType, NULL)) {
             return false;
         }
         dstPI.fAlphaType = kUnpremul_SkAlphaType;
@@ skipping 183 matching lines @@
 //////////////////////////////////////////////////////////////////////////////
 
 void GrContext::addGpuTraceMarker(const GrGpuTraceMarker* marker) {
     fGpu->addGpuTraceMarker(marker);
 }
 
 void GrContext::removeGpuTraceMarker(const GrGpuTraceMarker* marker) {
     fGpu->removeGpuTraceMarker(marker);
 }