Shared image generator

src/core/SkImageCacherator.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 "SkBitmap.h"
 #include "SkBitmapCache.h"
 #include "SkImage_Base.h"
 #include "SkImageCacherator.h"
 #include "SkMallocPixelRef.h"
+#include "SkMutex.h"
 #include "SkNextID.h"
 #include "SkPixelRef.h"
 #include "SkResourceCache.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "GrGpuResourcePriv.h"
 #include "GrImageIDTextureAdjuster.h"
 #include "GrResourceKey.h"
 #include "GrTextureParams.h"
 #include "GrYUVProvider.h"
 #include "SkGr.h"
 #include "SkGrPriv.h"
 #endif
 
 // Until we actually have codecs/etc. that can contain/support a GPU texture format
 // skip this step, since for some generators, returning their encoded data as a SkData
 // can be somewhat expensive, and this call doesn't indicate to the generator that we're
 // only interested in GPU datas...
 // see skbug.com/ 4971, 5128, ...
 //#define SK_SUPPORT_COMPRESSED_TEXTURES_IN_CACHERATOR
 
+// Ref-counted tuple(SkImageGenerator, SkMutex) which allows sharing of one generator
+// among several cacherators.
+class SkImageCacherator::SharedGenerator final : public SkNVRefCnt<SharedGenerator> {
+public:
+    static sk_sp<SharedGenerator> Make(SkImageGenerator* gen) {
+        return gen ? sk_sp<SharedGenerator>(new SharedGenerator(gen)) : nullptr;
+    }
+
+private:
+    explicit SharedGenerator(SkImageGenerator* gen) : fGenerator(gen) { SkASSERT(gen); }
+
+    friend class ScopedGenerator;
+
+    std::unique_ptr<SkImageGenerator> fGenerator;
+    SkMutex                           fMutex;
+};
+
+
+// Helper for exclusive access to a shared generator.
+class SkImageCacherator::ScopedGenerator {
+public:
+    ScopedGenerator(const sk_sp<SharedGenerator>& gen)
+      : fSharedGenerator(gen)
+      , fAutoAquire(gen->fMutex) {}
+
+    SkImageGenerator* operator->() const {
+        fSharedGenerator->fMutex.assertHeld();
+        return fSharedGenerator->fGenerator.get();
+    }
+
+    operator SkImageGenerator*() const {
+        fSharedGenerator->fMutex.assertHeld();
+        return fSharedGenerator->fGenerator.get();
+    }
+
+private:
+    const sk_sp<SharedGenerator>& fSharedGenerator;
+    SkAutoExclusive               fAutoAquire;
+};
+
 SkImageCacherator::Validator::Validator(SkImageGenerator* gen, const SkIRect* subset)
     // We are required to take ownership of gen, regardless of whether we instantiate a cacherator
     // or not.  On instantiation, the client is responsible for transferring ownership.
-    : fGenerator(gen) {
+    : fSharedGenerator(SkImageCacherator::SharedGenerator::Make(gen)) {
 
-    if (!gen) {
+    if (!fSharedGenerator) {
         return;
     }
 
     const SkImageInfo& info = gen->getInfo();
     if (info.isEmpty()) {
-        fGenerator.reset();
+        fSharedGenerator.reset();
         return;
     }
 
     fUniqueID = gen->uniqueID();
     const SkIRect bounds = SkIRect::MakeWH(info.width(), info.height());
     if (subset) {
         if (!bounds.contains(*subset)) {
-            fGenerator.reset();
+            fSharedGenerator.reset();
             return;
         }
         if (*subset != bounds) {
             // we need a different uniqueID since we really are a subset of the raw generator
             fUniqueID = SkNextID::ImageID();
         }
     } else {
         subset = &bounds;
     }
 
     fInfo   = info.makeWH(subset->width(), subset->height());
     fOrigin = SkIPoint::Make(subset->x(), subset->y());
 }
 
+SkImageCacherator::Validator::~Validator() {}
+
 SkImageCacherator* SkImageCacherator::NewFromGenerator(SkImageGenerator* gen,
                                                        const SkIRect* subset) {
     Validator validator(gen, subset);
 
     return validator ? new SkImageCacherator(&validator) : nullptr;
 }
 
 SkImageCacherator::SkImageCacherator(Validator* validator)
-    : fNotThreadSafeGenerator(validator->fGenerator.release()) // we take ownership
+    : fSharedGenerator(std::move(validator->fSharedGenerator)) // we take ownership
     , fInfo(validator->fInfo)
     , fOrigin(validator->fOrigin)
     , fUniqueID(validator->fUniqueID)
 {
-    SkASSERT(fNotThreadSafeGenerator);
+    SkASSERT(fSharedGenerator);
 }
 
+SkImageCacherator::~SkImageCacherator() {}
+
 SkData* SkImageCacherator::refEncoded(GrContext* ctx) {
-    ScopedGenerator generator(this);
+    ScopedGenerator generator(fSharedGenerator);
     return generator->refEncodedData(ctx);
 }
 
 static bool check_output_bitmap(const SkBitmap& bitmap, uint32_t expectedID) {
     SkASSERT(bitmap.getGenerationID() == expectedID);
     SkASSERT(bitmap.isImmutable());
     SkASSERT(bitmap.getPixels());
     return true;
 }
 
 // Note, this returns a new, mutable, bitmap, with a new genID.
 // If you want the immutable bitmap with the same ID as our cacherator, call tryLockAsBitmap()
 //
 bool SkImageCacherator::generateBitmap(SkBitmap* bitmap) {
     SkBitmap::Allocator* allocator = SkResourceCache::GetAllocator();
 
-    ScopedGenerator generator(this);
+    ScopedGenerator generator(fSharedGenerator);
     const SkImageInfo& genInfo = generator->getInfo();
     if (fInfo.dimensions() == genInfo.dimensions()) {
         SkASSERT(fOrigin.x() == 0 && fOrigin.y() == 0);
         // fast-case, no copy needed
         return generator->tryGenerateBitmap(bitmap, fInfo, allocator);
     } else {
         // need to handle subsetting, so we first generate the full size version, and then
         // "read" from it to get our subset. See https://bug.skia.org/4213
 
         SkBitmap full;
         if (!generator->tryGenerateBitmap(&full, genInfo, allocator)) {
             return false;
         }
         if (!bitmap->tryAllocPixels(fInfo, nullptr, full.getColorTable())) {
             return false;
         }
         return full.readPixels(bitmap->info(), bitmap->getPixels(), bitmap->rowBytes(),
                                fOrigin.x(), fOrigin.y());
     }
 }
 
 bool SkImageCacherator::directGeneratePixels(const SkImageInfo& info, void* pixels, size_t rb,
                                              int srcX, int srcY) {
-    ScopedGenerator generator(this);
+    ScopedGenerator generator(fSharedGenerator);
     const SkImageInfo& genInfo = generator->getInfo();
     // Currently generators do not natively handle subsets, so check that first.
     if (srcX || srcY || genInfo.width() != info.width() || genInfo.height() != info.height()) {
         return false;
     }
     return generator->getPixels(info, pixels, rb);
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ skipping 24 matching lines @@
                                      SkImage::CachingHint chint) {
     if (this->tryLockAsBitmap(bitmap, client, chint)) {
         return check_output_bitmap(*bitmap, fUniqueID);
     }
 
 #if SK_SUPPORT_GPU
     // Try to get a texture and read it back to raster (and then cache that with our ID)
     SkAutoTUnref<GrTexture> tex;
 
     {
-        ScopedGenerator generator(this);
+        ScopedGenerator generator(fSharedGenerator);
         SkIRect subset = SkIRect::MakeXYWH(fOrigin.x(), fOrigin.y(), fInfo.width(), fInfo.height());
         tex.reset(generator->generateTexture(nullptr, &subset));
     }
     if (!tex) {
         bitmap->reset();
         return false;
     }
 
     if (!bitmap->tryAllocPixels(fInfo)) {
         bitmap->reset();
@@ skipping 91 matching lines @@
     if (key.isValid()) {
         if (GrTexture* tex = ctx->textureProvider()->findAndRefTextureByUniqueKey(key)) {
             SK_HISTOGRAM_ENUMERATION("LockTexturePath", kPreExisting_LockTexturePath,
                                      kLockTexturePathCount);
             return tex;
         }
     }
 
     // 2. Ask the generator to natively create one
     {
-        ScopedGenerator generator(this);
+        ScopedGenerator generator(fSharedGenerator);
         SkIRect subset = SkIRect::MakeXYWH(fOrigin.x(), fOrigin.y(), fInfo.width(), fInfo.height());
         if (GrTexture* tex = generator->generateTexture(ctx, &subset)) {
             SK_HISTOGRAM_ENUMERATION("LockTexturePath", kNative_LockTexturePath,
                                      kLockTexturePathCount);
             return set_key_and_return(tex, key);
         }
     }
 
     const GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(fInfo, *ctx->caps());
 
 #ifdef SK_SUPPORT_COMPRESSED_TEXTURES_IN_CACHERATOR
     // 3. Ask the generator to return a compressed form that the GPU might support
     sk_sp<SkData> data(this->refEncoded(ctx));
     if (data) {
         GrTexture* tex = load_compressed_into_texture(ctx, data, desc);
         if (tex) {
             SK_HISTOGRAM_ENUMERATION("LockTexturePath", kCompressed_LockTexturePath,
                                      kLockTexturePathCount);
             return set_key_and_return(tex, key);
         }
     }
 #endif
 
     // 4. Ask the generator to return YUV planes, which the GPU can convert
     {
-        ScopedGenerator generator(this);
+        ScopedGenerator generator(fSharedGenerator);
         Generator_GrYUVProvider provider(generator);
         sk_sp<GrTexture> tex = provider.refAsTexture(ctx, desc, true);
         if (tex) {
             SK_HISTOGRAM_ENUMERATION("LockTexturePath", kYUV_LockTexturePath,
                                      kLockTexturePathCount);
             return set_key_and_return(tex.release(), key);
         }
     }
 
     // 5. Ask the generator to return RGB(A) data, which the GPU can convert
@@ skipping 32 matching lines @@
 
 #else
 
 GrTexture* SkImageCacherator::lockAsTexture(GrContext* ctx, const GrTextureParams&,
                                             SkSourceGammaTreatment gammaTreatment,
                                             const SkImage* client, SkImage::CachingHint) {
     return nullptr;
 }
 
 #endif