blob: 967b788cd6f0f4c74c23cbcedabca491bc1b0903 [file] [log] [blame]
/*
* Copyright 2020 Google LLC
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef ManagedBackendTexture_DEFINED
#define ManagedBackendTexture_DEFINED
#include "include/core/SkRefCnt.h"
#include "include/core/SkYUVAInfo.h"
#ifdef SK_GANESH
#include "include/gpu/GrBackendSurface.h"
#include "include/gpu/GrDirectContext.h"
#endif
#ifdef SK_GRAPHITE
#include "include/gpu/graphite/BackendTexture.h"
#include "include/gpu/graphite/Context.h"
#include "src/gpu/graphite/RecorderPriv.h"
#endif
namespace skgpu {
class RefCntedCallback;
}
namespace skgpu::graphite {
class Recorder;
}
class SkBitmap;
struct SkImageInfo;
#ifdef SK_GRAPHITE
using Recorder = skgpu::graphite::Recorder;
#endif
namespace sk_gpu_test {
#ifdef SK_GANESH
class ManagedBackendTexture : public SkNVRefCnt<ManagedBackendTexture> {
public:
/**
* Make a managed backend texture with initial pixmap/color data. The 'Args' are any valid set
* of arguments to GrDirectContext::createBackendTexture that takes data but with the release
* proc/context omitted as the ManagedBackendTexture will provide them.
*/
template <typename... Args>
static sk_sp<ManagedBackendTexture> MakeWithData(GrDirectContext*, Args&&...);
/**
* Make a managed backend texture without initial data. The 'Args' are any valid set of
* arguments to GrDirectContext::createBackendTexture that does not take data. Because our
* createBackendTexture methods that *do* take data also use default args for the proc/context
* this can be used to make a texture with data but then the MBET won't be able to ensure that
* the upload has completed before the texture is deleted. Use the WithData variant instead to
* avoid this issue.
*/
template <typename... Args>
static sk_sp<ManagedBackendTexture> MakeWithoutData(GrDirectContext*, Args&&...);
static sk_sp<ManagedBackendTexture> MakeFromInfo(GrDirectContext* dContext,
const SkImageInfo&,
skgpu::Mipmapped = skgpu::Mipmapped::kNo,
skgpu::Renderable = skgpu::Renderable::kNo,
skgpu::Protected = skgpu::Protected::kNo);
static sk_sp<ManagedBackendTexture> MakeFromBitmap(GrDirectContext*,
const SkBitmap&,
skgpu::Mipmapped,
skgpu::Renderable,
skgpu::Protected = skgpu::Protected::kNo);
static sk_sp<ManagedBackendTexture> MakeFromPixmap(GrDirectContext*,
const SkPixmap&,
skgpu::Mipmapped,
skgpu::Renderable,
skgpu::Protected = skgpu::Protected::kNo);
/** GrGpuFinishedProc or image/surface release proc. */
static void ReleaseProc(void* context);
~ManagedBackendTexture();
/**
* The context to use with ReleaseProc. This adds a ref so it *must* be balanced by a call to
* ReleaseProc. If a wrappedProc is provided then it will be called by ReleaseProc.
*/
void* releaseContext(GrGpuFinishedProc wrappedProc = nullptr,
GrGpuFinishedContext wrappedContext = nullptr) const;
sk_sp<skgpu::RefCntedCallback> refCountedCallback() const;
/**
* Call if the underlying GrBackendTexture was adopted by a GrContext. This clears this out the
* MBET without deleting the texture.
*/
void wasAdopted();
/**
* SkImages::TextureFromYUVATextures takes a single release proc that is called once for all the
* textures. This makes a single release context for the group of textures. It's used with the
* standard ReleaseProc. Like releaseContext(), it must be balanced by a ReleaseProc call for
* proper ref counting.
*/
static void* MakeYUVAReleaseContext(const sk_sp<ManagedBackendTexture>[SkYUVAInfo::kMaxPlanes]);
const GrBackendTexture& texture() { return fTexture; }
private:
ManagedBackendTexture() = default;
ManagedBackendTexture(const ManagedBackendTexture&) = delete;
ManagedBackendTexture(ManagedBackendTexture&&) = delete;
sk_sp<GrDirectContext> fDContext;
GrBackendTexture fTexture;
};
template <typename... Args>
inline sk_sp<ManagedBackendTexture> ManagedBackendTexture::MakeWithData(GrDirectContext* dContext,
Args&&... args) {
sk_sp<ManagedBackendTexture> mbet(new ManagedBackendTexture);
mbet->fDContext = sk_ref_sp(dContext);
mbet->fTexture = dContext->createBackendTexture(std::forward<Args>(args)...,
ReleaseProc,
mbet->releaseContext());
if (!mbet->fTexture.isValid()) {
return nullptr;
}
return mbet;
}
template <typename... Args>
inline sk_sp<ManagedBackendTexture> ManagedBackendTexture::MakeWithoutData(
GrDirectContext* dContext,
Args&&... args) {
GrBackendTexture texture =
dContext->createBackendTexture(std::forward<Args>(args)...);
if (!texture.isValid()) {
return nullptr;
}
sk_sp<ManagedBackendTexture> mbet(new ManagedBackendTexture);
mbet->fDContext = sk_ref_sp(dContext);
mbet->fTexture = std::move(texture);
return mbet;
}
#endif // SK_GANESH
#ifdef SK_GRAPHITE
/*
* Graphite version of ManagedBackendTexture
*/
class ManagedGraphiteTexture : public SkNVRefCnt<ManagedGraphiteTexture> {
public:
static sk_sp<ManagedGraphiteTexture> MakeUnInit(Recorder*,
const SkImageInfo&,
skgpu::Mipmapped,
skgpu::Renderable,
skgpu::Protected = skgpu::Protected::kNo);
static sk_sp<ManagedGraphiteTexture> MakeFromPixmap(Recorder*,
const SkPixmap&,
skgpu::Mipmapped,
skgpu::Renderable,
skgpu::Protected = skgpu::Protected::kNo);
/** finished and image/surface release procs */
static void FinishedProc(void* context, skgpu::CallbackResult);
static void ReleaseProc(void* context);
static void ImageReleaseProc(void* context);
~ManagedGraphiteTexture();
/**
* The context to use with the ReleaseProcs. This adds a ref so it *must* be balanced by a call
* to TextureReleaseProc or ImageReleaseProc.
*/
void* releaseContext() const;
sk_sp<skgpu::RefCntedCallback> refCountedCallback() const;
/**
* SkImage::MakeGraphiteFromYUVABackendTextures takes a single release proc that is called once
* for all the textures. This makes a single release context for the group of textures. It's
* used with the standard ReleaseProc. Like releaseContext(), it must be balanced by a
* ReleaseProc call for proper ref counting.
*/
static void* MakeYUVAReleaseContext(const sk_sp<ManagedGraphiteTexture>[SkYUVAInfo::kMaxPlanes]);
const skgpu::graphite::BackendTexture& texture() { return fTexture; }
private:
ManagedGraphiteTexture() = default;
ManagedGraphiteTexture(const ManagedGraphiteTexture&) = delete;
ManagedGraphiteTexture(ManagedGraphiteTexture&&) = delete;
skgpu::graphite::Context* fContext;
skgpu::graphite::BackendTexture fTexture;
};
#endif // SK_GRAPHITE
} // namespace sk_gpu_test
#endif // ManagedBackendTexture_DEFINED