Add SkSpecialImage & SkSpecialSurface classes

src/core/SkSpecialSurface.cpp

+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file
+ */
+
+#include "SkCanvas.h"
+#include "SkSpecialImage.h"
+#include "SkSpecialSurface.h"
+#include "SkSurfacePriv.h"
+
+ ///////////////////////////////////////////////////////////////////////////////
+class SkSpecialSurface_Base : public SkSpecialSurface {
+public:
+    SkSpecialSurface_Base(const SkIRect& activeRect, const SkSurfaceProps* props)
+        : INHERITED(activeRect, props)
+        , fCanvas(nullptr) {
+    }
+
+    virtual ~SkSpecialSurface_Base() { }
+
+    // reset is called after an SkSpecialImage has been snapped
+    void reset() { fCanvas.reset(); }
+
+    // This can return nullptr if reset has already been called or something when wrong in the ctor
+    SkCanvas* onGetCanvas() { return fCanvas; }
+
+    virtual SkSpecialImage* onNewImageSnapshot() = 0;
+
+protected:
+    SkAutoTUnref<SkCanvas> fCanvas;   // initialized by derived classes in ctors
+
+private:
+    typedef SkSpecialSurface INHERITED;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+static SkSpecialSurface_Base* as_SB(SkSpecialSurface* surface) {
+    return static_cast<SkSpecialSurface_Base*>(surface);
+}
+
+SkSpecialSurface::SkSpecialSurface(const SkIRect& activeRect, const SkSurfaceProps* props)
+    : fProps(SkSurfacePropsCopyOrDefault(props))
+    , fActiveRect(activeRect) {
+    SkASSERT(fActiveRect.width() > 0);
+    SkASSERT(fActiveRect.height() > 0);
+}
+
+SkCanvas* SkSpecialSurface::getCanvas() {
+    return as_SB(this)->onGetCanvas();
+}
+
+SkSpecialImage* SkSpecialSurface::newImageSnapshot() {
+    SkSpecialImage* image = as_SB(this)->onNewImageSnapshot();
+    as_SB(this)->reset();
+    return SkSafeRef(image);   // the caller will call unref() to balance this
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#include "SkMallocPixelRef.h"
+
+class SkSpecialSurface_Raster : public SkSpecialSurface_Base {
+public:
+    SkSpecialSurface_Raster(SkPixelRef* pr, const SkSurfaceProps* props)
+        : INHERITED(SkIRect::MakeWH(pr->info().width(), pr->info().height()), props) {   
+        const SkImageInfo& info = pr->info();
+
+        fBitmap.setInfo(info, info.minRowBytes());
+        fBitmap.setPixelRef(pr);
+
+        fCanvas.reset(new SkCanvas(fBitmap));
+    }
+
+    ~SkSpecialSurface_Raster() override { }
+
+    SkSpecialImage* onNewImageSnapshot() override {
+        return SkSpecialImage::NewRaster(this->activeRect(), fBitmap);
+    }
+
+private:
+    SkBitmap fBitmap;
+
+    typedef SkSpecialSurface_Base INHERITED;
+};
+
+SkSpecialSurface* SkSpecialSurface::NewRaster(const SkImageInfo& info,
+                                              const SkSurfaceProps* props) {
+    SkAutoTUnref<SkPixelRef> pr(SkMallocPixelRef::NewZeroed(info, 0, nullptr));
+    if (nullptr == pr.get()) {
+        return nullptr;
+    }
+
+    return new SkSpecialSurface_Raster(pr, props);
+}
+
+#if SK_SUPPORT_GPU
+///////////////////////////////////////////////////////////////////////////////
+#include "GrContext.h"
+#include "SkGpuDevice.h"
+
+class SkSpecialSurface_Gpu : public SkSpecialSurface_Base {
+public:
+    SkSpecialSurface_Gpu(GrTexture* texture, const SkIRect& activeRect, const SkSurfaceProps* props)
+        : INHERITED(activeRect, props)
+        , fTexture(texture) {
+
+        SkASSERT(fTexture->asRenderTarget());
+
+        SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(fTexture->asRenderTarget(), props,
+                                                             SkGpuDevice::kUninit_InitContents));
+        if (!device) {
+            return;
+        }
+
+        fCanvas.reset(new SkCanvas(device));
+    }
+
+    ~SkSpecialSurface_Gpu() override { }
+
+    SkSpecialImage* onNewImageSnapshot() override {
+        return SkSpecialImage::NewGpu(this->activeRect(), fTexture);
+    }
+
+private:
+    SkAutoTUnref<GrTexture> fTexture;
+
+    typedef SkSpecialSurface_Base INHERITED;
+};
+
+SkSpecialSurface* SkSpecialSurface::NewGpu(const SkIRect& activeRect, GrTexture* texture,
+                                           const SkSurfaceProps* props) {
+    if (!texture->asRenderTarget()) {
+        return nullptr;
+    }
+
+    return new SkSpecialSurface_Gpu(texture, activeRect, props);
+}
+
+SkSpecialSurface* SkSpecialSurface::NewGpu(GrContext* context,
+                                           const GrSurfaceDesc& desc,
+                                           const SkSurfaceProps* props) {
+    if (!context || !SkToBool(desc.fFlags & kRenderTarget_GrSurfaceFlag)) {
+        return nullptr;
+    }
+
+    GrTexture* temp = context->textureProvider()->createApproxTexture(desc);
+    if (!temp) {
+        return nullptr;
+    }
+
+    const SkIRect activeRect = SkIRect::MakeWH(desc.fWidth, desc.fHeight);
+
+    return new SkSpecialSurface_Gpu(temp, activeRect, props);
+}
+
+#else
+
+SkSpecialSurface* SkSpecialSurface::NewGpu(GrTexture*, const SkIRect& activeRect) {
+    return nullptr;
+}
+
+SkSpecialSurface* SkSpecialSurface::NewGpu(GrContext* context,
+                                           const GrSurfaceDesc& desc,
+                                           const SkSurfaceProps* props) {
+    return nullptr;
+}
+
+#endif