refactor parts of SkGr.cpp for use by SkImages

src/gpu/SkGr.cpp

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkGr.h"
 
 #include "GrCaps.h"
 #include "GrDrawContext.h"
 #include "GrXferProcessor.h"
+#include "GrYUVProvider.h"
+
 #include "SkColorFilter.h"
 #include "SkConfig8888.h"
 #include "SkCanvas.h"
 #include "SkData.h"
 #include "SkErrorInternals.h"
 #include "SkGrPixelRef.h"
 #include "SkMessageBus.h"
 #include "SkPixelRef.h"
 #include "SkResourceCache.h"
 #include "SkTextureCompressor.h"
@@ skipping 207 matching lines @@
     GrUniqueKeyInvalidatedMessage fMsg;
 
     void onChange() override {
         SkMessageBus<GrUniqueKeyInvalidatedMessage>::Post(fMsg);
     }
 };
 
 }  // namespace
 
 
-static GrTexture* create_texture_for_bmp(GrContext* ctx,
-                                         const GrUniqueKey& optionalKey,
-                                         GrSurfaceDesc desc,
-                                         SkPixelRef* pixelRefForInvalidationNotification,
-                                         const void* pixels,
-                                         size_t rowBytes) {
+GrTexture* GrCreateTextureForPixels(GrContext* ctx,
+                                    const GrUniqueKey& optionalKey,
+                                    GrSurfaceDesc desc,
+                                    SkPixelRef* pixelRefForInvalidationNotification,
+                                    const void* pixels,
+                                    size_t rowBytes) {
     GrTexture* result = ctx->textureProvider()->createTexture(desc, true, pixels, rowBytes);
     if (result && optionalKey.isValid()) {
-        BitmapInvalidator* listener = new BitmapInvalidator(optionalKey);
-        pixelRefForInvalidationNotification->addGenIDChangeListener(listener);
+        if (pixelRefForInvalidationNotification) {
+            BitmapInvalidator* listener = new BitmapInvalidator(optionalKey);
+            pixelRefForInvalidationNotification->addGenIDChangeListener(listener);
+        }
         ctx->textureProvider()->assignUniqueKeyToTexture(optionalKey, result);
     }
     return result;
 }
 
 // creates a new texture that is the input texture scaled up. If optionalKey is valid it will be
 // set on the new texture. stretch controls whether the scaling is done using nearest or bilerp
 // filtering and the size to stretch the texture to.
 GrTexture* stretch_texture(GrTexture* inputTexture, const Stretch& stretch,
                            SkPixelRef* pixelRef,
@@ skipping 27 matching lines @@
             if (caps->isConfigRenderable(kSkia8888_GrPixelConfig, false)) {
                 rtDesc.fConfig = kSkia8888_GrPixelConfig;
             } else {
                 return nullptr;
             }
         } else {
             return nullptr;
         }
     }
 
-    GrTexture* stretched = create_texture_for_bmp(context, optionalKey, rtDesc, pixelRef, nullptr, 0);
-
+    SkAutoTUnref<GrTexture> stretched(GrCreateTextureForPixels(context, optionalKey, rtDesc,
+                                                               pixelRef, nullptr,0));
     if (!stretched) {
         return nullptr;
     }
     GrPaint paint;
 
     // If filtering is not desired then we want to ensure all texels in the resampled image are
     // copies of texels from the original.
     GrTextureParams params(SkShader::kClamp_TileMode,
                            Stretch::kBilerp_Type == stretch.fType ?
                               GrTextureParams::kBilerp_FilterMode :
                               GrTextureParams::kNone_FilterMode);
     paint.addColorTextureProcessor(inputTexture, SkMatrix::I(), params);
 
     SkRect rect = SkRect::MakeWH(SkIntToScalar(rtDesc.fWidth), SkIntToScalar(rtDesc.fHeight));
     SkRect localRect = SkRect::MakeWH(1.f, 1.f);
 
     SkAutoTUnref<GrDrawContext> drawContext(context->drawContext());
     if (!drawContext) {
         return nullptr;
     }
 
     drawContext->drawNonAARectToRect(stretched->asRenderTarget(), GrClip::WideOpen(), paint,
                                      SkMatrix::I(), rect, localRect);
 
-    return stretched;
+    return stretched.detach();
 }
 
+GrPixelConfig GrIsCompressedTextureDataSupported(GrContext* ctx, SkData* data,
+                                                 int expectedW, int expectedH,
+                                                 const void** outStartOfDataToUpload) {
+    *outStartOfDataToUpload = nullptr;
 #ifndef SK_IGNORE_ETC1_SUPPORT
-static GrTexture *load_etc1_texture(GrContext* ctx, const GrUniqueKey& optionalKey,
-                                    const SkBitmap &bm, GrSurfaceDesc desc) {
-    SkAutoTUnref<SkData> data(bm.pixelRef()->refEncodedData());
-
-    // Is this even encoded data?
-    if (nullptr == data) {
-        return nullptr;
+    if (!ctx->caps()->isConfigTexturable(kETC1_GrPixelConfig)) {
+        return kUnknown_GrPixelConfig;
     }
 
-    // Is this a valid PKM encoded data?
-    const uint8_t *bytes = data->bytes();
-    if (etc1_pkm_is_valid(bytes)) {
-        uint32_t encodedWidth = etc1_pkm_get_width(bytes);
-        uint32_t encodedHeight = etc1_pkm_get_height(bytes);
-
+    const uint8_t* bytes = data->bytes();
+    if (data->size() > ETC_PKM_HEADER_SIZE && etc1_pkm_is_valid(bytes)) {
         // Does the data match the dimensions of the bitmap? If not,
         // then we don't know how to scale the image to match it...
-        if (encodedWidth != static_cast<uint32_t>(bm.width()) ||
-            encodedHeight != static_cast<uint32_t>(bm.height())) {
-            return nullptr;
+        if (etc1_pkm_get_width(bytes) != (unsigned)expectedW ||
+            etc1_pkm_get_height(bytes) != (unsigned)expectedH)
+        {
+            return kUnknown_GrPixelConfig;
         }
 
-        // Everything seems good... skip ahead to the data.
-        bytes += ETC_PKM_HEADER_SIZE;
-        desc.fConfig = kETC1_GrPixelConfig;
+        *outStartOfDataToUpload = bytes + ETC_PKM_HEADER_SIZE;
+        return kETC1_GrPixelConfig;
     } else if (SkKTXFile::is_ktx(bytes)) {
         SkKTXFile ktx(data);
 
         // Is it actually an ETC1 texture?
         if (!ktx.isCompressedFormat(SkTextureCompressor::kETC1_Format)) {
-            return nullptr;
+            return kUnknown_GrPixelConfig;
         }
 
         // Does the data match the dimensions of the bitmap? If not,
         // then we don't know how to scale the image to match it...
-        if (ktx.width() != bm.width() || ktx.height() != bm.height()) {
-            return nullptr;
+        if (ktx.width() != expectedW || ktx.height() != expectedH) {
+            return kUnknown_GrPixelConfig;
         }
 
-        bytes = ktx.pixelData();
-        desc.fConfig = kETC1_GrPixelConfig;
-    } else {
+        *outStartOfDataToUpload = ktx.pixelData();
+        return kETC1_GrPixelConfig;
+    }
+#endif
+    return kUnknown_GrPixelConfig;
+}
+
+static GrTexture* load_etc1_texture(GrContext* ctx, const GrUniqueKey& optionalKey,
+                                    const SkBitmap &bm, GrSurfaceDesc desc) {
+    SkAutoTUnref<SkData> data(bm.pixelRef()->refEncodedData());
+    if (!data) {
         return nullptr;
     }
 
-    return create_texture_for_bmp(ctx, optionalKey, desc, bm.pixelRef(), bytes, 0);
+    const void* startOfTexData;
+    desc.fConfig = GrIsCompressedTextureDataSupported(ctx, data, bm.width(), bm.height(),
+                                                      &startOfTexData);
+    if (kUnknown_GrPixelConfig == desc.fConfig) {
+        return nullptr;
+    }
+
+    return GrCreateTextureForPixels(ctx, optionalKey, desc, bm.pixelRef(), startOfTexData, 0);
 }
-#endif   // SK_IGNORE_ETC1_SUPPORT
+
+/*
+ *  Once we have made SkImages handle all lazy/deferred/generated content, the YUV apis will
+ *  be gone from SkPixelRef, and we can remove this subclass entirely.
+ */
+class PixelRef_GrYUVProvider : public GrYUVProvider {
+    SkPixelRef* fPR;
+
+public:
+    PixelRef_GrYUVProvider(SkPixelRef* pr) : fPR(pr) {}
+
+    uint32_t onGetID() override { return fPR->getGenerationID(); }
+    bool onGetYUVSizes(SkISize sizes[3]) override {
+        return fPR->getYUV8Planes(sizes, nullptr, nullptr, nullptr);
+    }
+    bool onGetYUVPlanes(SkISize sizes[3], void* planes[3], size_t rowBytes[3],
+                        SkYUVColorSpace* space) override {
+        return fPR->getYUV8Planes(sizes, planes, rowBytes, space);
+    }
+};
 
 static GrTexture* load_yuv_texture(GrContext* ctx, const GrUniqueKey& optionalKey,
                                    const SkBitmap& bm, const GrSurfaceDesc& desc) {
     // Subsets are not supported, the whole pixelRef is loaded when using YUV decoding
     SkPixelRef* pixelRef = bm.pixelRef();
-    if ((nullptr == pixelRef) || 
+    if ((nullptr == pixelRef) ||
         (pixelRef->info().width()  != bm.info().width()) ||
         (pixelRef->info().height() != bm.info().height())) {
         return nullptr;
     }
 
     const bool useCache = optionalKey.isValid();
-    SkYUVPlanesCache::Info yuvInfo;
-    SkAutoTUnref<SkCachedData> cachedData;
-    SkAutoMalloc storage;
-    if (useCache) {
-        cachedData.reset(SkYUVPlanesCache::FindAndRef(pixelRef->getGenerationID(), &yuvInfo));
-    }
-
-    void* planes[3];
-    if (cachedData.get()) {
-        planes[0] = (void*)cachedData->data();
-        planes[1] = (uint8_t*)planes[0] + yuvInfo.fSizeInMemory[0];
-        planes[2] = (uint8_t*)planes[1] + yuvInfo.fSizeInMemory[1];
-    } else {
-        // Fetch yuv plane sizes for memory allocation. Here, width and height can be
-        // rounded up to JPEG block size and be larger than the image's width and height.
-        if (!pixelRef->getYUV8Planes(yuvInfo.fSize, nullptr, nullptr, nullptr)) {
-            return nullptr;
-        }
-
-        // Allocate the memory for YUV
-        size_t totalSize(0);
-        for (int i = 0; i < 3; ++i) {
-            yuvInfo.fRowBytes[i] = yuvInfo.fSize[i].fWidth;
-            yuvInfo.fSizeInMemory[i] = yuvInfo.fRowBytes[i] * yuvInfo.fSize[i].fHeight;
-            totalSize += yuvInfo.fSizeInMemory[i];
-        }
-        if (useCache) {
-            cachedData.reset(SkResourceCache::NewCachedData(totalSize));
-            planes[0] = cachedData->writable_data();
-        } else {
-            storage.reset(totalSize);
-            planes[0] = storage.get();
-        }
-        planes[1] = (uint8_t*)planes[0] + yuvInfo.fSizeInMemory[0];
-        planes[2] = (uint8_t*)planes[1] + yuvInfo.fSizeInMemory[1];
-
-        // Get the YUV planes and update plane sizes to actual image size
-        if (!pixelRef->getYUV8Planes(yuvInfo.fSize, planes, yuvInfo.fRowBytes,
-                                     &yuvInfo.fColorSpace)) {
-            return nullptr;
-        }
-
-        if (useCache) {
-            // Decoding is done, cache the resulting YUV planes
-            SkYUVPlanesCache::Add(pixelRef->getGenerationID(), cachedData, &yuvInfo);
-        }
-    }
-
-    GrSurfaceDesc yuvDesc;
-    yuvDesc.fConfig = kAlpha_8_GrPixelConfig;
-    SkAutoTUnref<GrTexture> yuvTextures[3];
-    for (int i = 0; i < 3; ++i) {
-        yuvDesc.fWidth  = yuvInfo.fSize[i].fWidth;
-        yuvDesc.fHeight = yuvInfo.fSize[i].fHeight;
-        bool needsExactTexture =
-            (yuvDesc.fWidth  != yuvInfo.fSize[0].fWidth) ||
-            (yuvDesc.fHeight != yuvInfo.fSize[0].fHeight);
-        if (needsExactTexture) {
-            yuvTextures[i].reset(ctx->textureProvider()->createTexture(yuvDesc, true));
-        } else {
-            yuvTextures[i].reset(ctx->textureProvider()->createApproxTexture(yuvDesc));
-        }
-        if (!yuvTextures[i] ||
-            !yuvTextures[i]->writePixels(0, 0, yuvDesc.fWidth, yuvDesc.fHeight,
-                                         yuvDesc.fConfig, planes[i], yuvInfo.fRowBytes[i])) {
-            return nullptr;
-        }
-    }
-
-    GrSurfaceDesc rtDesc = desc;
-    rtDesc.fFlags = rtDesc.fFlags | kRenderTarget_GrSurfaceFlag;
-
-    GrTexture* result = create_texture_for_bmp(ctx, optionalKey, rtDesc, pixelRef, nullptr, 0);
-    if (!result) {
+    PixelRef_GrYUVProvider provider(pixelRef);
+    GrTexture* texture = provider.refAsTexture(ctx, desc, useCache);
+    if (!texture) {
         return nullptr;
     }
 
-    GrRenderTarget* renderTarget = result->asRenderTarget();
-    SkASSERT(renderTarget);
-
-    GrPaint paint;
-    SkAutoTUnref<GrFragmentProcessor>
-        yuvToRgbProcessor(GrYUVtoRGBEffect::Create(paint.getProcessorDataManager(), yuvTextures[0],
-                                                   yuvTextures[1], yuvTextures[2],
-                                                   yuvInfo.fSize, yuvInfo.fColorSpace));
-    paint.addColorFragmentProcessor(yuvToRgbProcessor);
-    SkRect r = SkRect::MakeWH(SkIntToScalar(yuvInfo.fSize[0].fWidth),
-                              SkIntToScalar(yuvInfo.fSize[0].fHeight));
-
-    SkAutoTUnref<GrDrawContext> drawContext(ctx->drawContext());
-    if (!drawContext) {
-        return nullptr;
+    if (useCache) {
+        BitmapInvalidator* listener = new BitmapInvalidator(optionalKey);
+        pixelRef->addGenIDChangeListener(listener);
+        ctx->textureProvider()->assignUniqueKeyToTexture(optionalKey, texture);
     }
-
-    drawContext->drawRect(renderTarget, GrClip::WideOpen(), paint, SkMatrix::I(), r);
-
-    return result;
+    return texture;
 }
 
 static GrTexture* create_unstretched_bitmap_texture(GrContext* ctx,
                                                     const SkBitmap& origBitmap,
                                                     const GrUniqueKey& optionalKey) {
     if (origBitmap.width() < ctx->caps()->minTextureSize() ||
         origBitmap.height() < ctx->caps()->minTextureSize()) {
         return nullptr;
     }
     SkBitmap tmpBitmap;
 
     const SkBitmap* bitmap = &origBitmap;
 
     GrSurfaceDesc desc;
     generate_bitmap_texture_desc(*bitmap, &desc);
     const GrCaps* caps = ctx->caps();
 
     if (kIndex_8_SkColorType == bitmap->colorType()) {
         if (caps->isConfigTexturable(kIndex_8_GrPixelConfig)) {
             size_t imageSize = GrCompressedFormatDataSize(kIndex_8_GrPixelConfig,
                                                           bitmap->width(), bitmap->height());
             SkAutoMalloc storage(imageSize);
             build_index8_data(storage.get(), origBitmap);
 
             // our compressed data will be trimmed, so pass width() for its
             // "rowBytes", since they are the same now.
-            return create_texture_for_bmp(ctx, optionalKey, desc, origBitmap.pixelRef(),
-                                          storage.get(), bitmap->width());
+            return GrCreateTextureForPixels(ctx, optionalKey, desc, origBitmap.pixelRef(),
+                                            storage.get(), bitmap->width());
         } else {
             origBitmap.copyTo(&tmpBitmap, kN32_SkColorType);
             // now bitmap points to our temp, which has been promoted to 32bits
             bitmap = &tmpBitmap;
             desc.fConfig = SkImageInfo2GrPixelConfig(bitmap->info());
         }
-    }
-
-    // Is this an ETC1 encoded texture?
-#ifndef SK_IGNORE_ETC1_SUPPORT
-    // Make sure that the underlying device supports ETC1 textures before we go ahead
-    // and check the data.
-    else if (caps->isConfigTexturable(kETC1_GrPixelConfig)
-            // If the bitmap had compressed data and was then uncompressed, it'll still return
-            // compressed data on 'refEncodedData' and upload it. Probably not good, since if
-            // the bitmap has available pixels, then they might not be what the decompressed
-            // data is.
-            && !(bitmap->readyToDraw())) {
+    } else if (!bitmap->readyToDraw()) {
+        // If the bitmap had compressed data and was then uncompressed, it'll still return
+        // compressed data on 'refEncodedData' and upload it. Probably not good, since if
+        // the bitmap has available pixels, then they might not be what the decompressed
+        // data is.
         GrTexture *texture = load_etc1_texture(ctx, optionalKey, *bitmap, desc);
         if (texture) {
             return texture;
         }
     }
-#endif   // SK_IGNORE_ETC1_SUPPORT
 
     GrTexture *texture = load_yuv_texture(ctx, optionalKey, *bitmap, desc);
     if (texture) {
         return texture;
     }
 
     SkAutoLockPixels alp(*bitmap);
     if (!bitmap->readyToDraw()) {
         return nullptr;
     }
 
-    return create_texture_for_bmp(ctx, optionalKey, desc, origBitmap.pixelRef(),
-                                  bitmap->getPixels(), bitmap->rowBytes());
+    return GrCreateTextureForPixels(ctx, optionalKey, desc, origBitmap.pixelRef(),
+                                    bitmap->getPixels(), bitmap->rowBytes());
 }
 
 static SkBitmap stretch_on_cpu(const SkBitmap& bmp, const Stretch& stretch) {
     SkBitmap stretched;
     stretched.allocN32Pixels(stretch.fWidth, stretch.fHeight);
     SkCanvas canvas(stretched);
     SkPaint paint;
     switch (stretch.fType) {
         case Stretch::kNearest_Type:
             paint.setFilterQuality(kNone_SkFilterQuality);
@@ skipping 361 matching lines @@
             SkErrorInternals::SetError( kInvalidPaint_SkError,
                                         "Sorry, I don't understand the filtering "
                                         "mode you asked for.  Falling back to "
                                         "MIPMaps.");
             textureFilterMode = GrTextureParams::kMipMap_FilterMode;
             break;
 
     }
     return textureFilterMode;
 }