blob: b48305479eee343752da4f91b82e469e40fcde3f [file] [log] [blame]
/*
* Copyright 2017 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "include/core/SkTypes.h"
#if defined(SK_BUILD_FOR_ANDROID) && __ANDROID_API__ >= 26
#define GL_GLEXT_PROTOTYPES
#define EGL_EGLEXT_PROTOTYPES
#include "src/gpu/GrAHardwareBufferImageGenerator.h"
#include <android/hardware_buffer.h>
#include "include/gpu/GrBackendSurface.h"
#include "include/gpu/GrDirectContext.h"
#include "include/gpu/GrRecordingContext.h"
#include "include/gpu/gl/GrGLTypes.h"
#include "src/core/SkMessageBus.h"
#include "src/gpu/GrAHardwareBufferUtils.h"
#include "src/gpu/GrDirectContextPriv.h"
#include "src/gpu/GrProxyProvider.h"
#include "src/gpu/GrRecordingContextPriv.h"
#include "src/gpu/GrResourceCache.h"
#include "src/gpu/GrResourceProvider.h"
#include "src/gpu/GrResourceProviderPriv.h"
#include "src/gpu/GrTexture.h"
#include "src/gpu/GrTextureProxy.h"
#include "src/gpu/SkGr.h"
#include "src/gpu/gl/GrGLDefines.h"
#include <EGL/egl.h>
#include <EGL/eglext.h>
#include <GLES/gl.h>
#include <GLES/glext.h>
#ifdef SK_VULKAN
#include "include/gpu/vk/GrVkExtensions.h"
#include "src/gpu/vk/GrVkGpu.h"
#endif
#define PROT_CONTENT_EXT_STR "EGL_EXT_protected_content"
#define EGL_PROTECTED_CONTENT_EXT 0x32C0
std::unique_ptr<SkImageGenerator> GrAHardwareBufferImageGenerator::Make(
AHardwareBuffer* graphicBuffer, SkAlphaType alphaType, sk_sp<SkColorSpace> colorSpace,
GrSurfaceOrigin surfaceOrigin) {
AHardwareBuffer_Desc bufferDesc;
AHardwareBuffer_describe(graphicBuffer, &bufferDesc);
SkColorType colorType =
GrAHardwareBufferUtils::GetSkColorTypeFromBufferFormat(bufferDesc.format);
SkImageInfo info = SkImageInfo::Make(bufferDesc.width, bufferDesc.height, colorType,
alphaType, std::move(colorSpace));
bool createProtectedImage = 0 != (bufferDesc.usage & AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT);
return std::unique_ptr<SkImageGenerator>(new GrAHardwareBufferImageGenerator(
info, graphicBuffer, alphaType, createProtectedImage,
bufferDesc.format, surfaceOrigin));
}
GrAHardwareBufferImageGenerator::GrAHardwareBufferImageGenerator(const SkImageInfo& info,
AHardwareBuffer* hardwareBuffer, SkAlphaType alphaType, bool isProtectedContent,
uint32_t bufferFormat, GrSurfaceOrigin surfaceOrigin)
: INHERITED(info)
, fHardwareBuffer(hardwareBuffer)
, fBufferFormat(bufferFormat)
, fIsProtectedContent(isProtectedContent)
, fSurfaceOrigin(surfaceOrigin) {
AHardwareBuffer_acquire(fHardwareBuffer);
}
GrAHardwareBufferImageGenerator::~GrAHardwareBufferImageGenerator() {
AHardwareBuffer_release(fHardwareBuffer);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
GrSurfaceProxyView GrAHardwareBufferImageGenerator::makeView(GrRecordingContext* context) {
if (context->abandoned()) {
return {};
}
auto direct = context->asDirectContext();
if (!direct) {
return {};
}
GrBackendFormat backendFormat = GrAHardwareBufferUtils::GetBackendFormat(direct,
fHardwareBuffer,
fBufferFormat,
false);
GrColorType grColorType = SkColorTypeToGrColorType(this->getInfo().colorType());
int width = this->getInfo().width();
int height = this->getInfo().height();
GrTextureType textureType = GrTextureType::k2D;
if (context->backend() == GrBackendApi::kOpenGL) {
textureType = GrTextureType::kExternal;
} else if (context->backend() == GrBackendApi::kVulkan) {
VkFormat format;
SkAssertResult(backendFormat.asVkFormat(&format));
if (format == VK_FORMAT_UNDEFINED) {
textureType = GrTextureType::kExternal;
}
}
auto proxyProvider = context->priv().proxyProvider();
AHardwareBuffer* hardwareBuffer = fHardwareBuffer;
AHardwareBuffer_acquire(hardwareBuffer);
class AutoAHBRelease {
public:
AutoAHBRelease(AHardwareBuffer* ahb) : fAhb(ahb) {}
// std::function() must be CopyConstructible, but ours should never actually be copied.
AutoAHBRelease(const AutoAHBRelease&) { SkASSERT(0); }
AutoAHBRelease(AutoAHBRelease&& that) : fAhb(that.fAhb) { that.fAhb = nullptr; }
~AutoAHBRelease() { fAhb ? AHardwareBuffer_release(fAhb) : void(); }
AutoAHBRelease& operator=(AutoAHBRelease&& that) {
fAhb = std::exchange(that.fAhb, nullptr);
return *this;
}
AutoAHBRelease& operator=(const AutoAHBRelease&) = delete;
AHardwareBuffer* get() const { return fAhb; }
private:
AHardwareBuffer* fAhb;
};
sk_sp<GrTextureProxy> texProxy = proxyProvider->createLazyProxy(
[direct, buffer = AutoAHBRelease(hardwareBuffer)](
GrResourceProvider* resourceProvider,
const GrSurfaceProxy::LazySurfaceDesc& desc)
-> GrSurfaceProxy::LazyCallbackResult {
GrAHardwareBufferUtils::DeleteImageProc deleteImageProc = nullptr;
GrAHardwareBufferUtils::UpdateImageProc updateImageProc = nullptr;
GrAHardwareBufferUtils::TexImageCtx texImageCtx = nullptr;
bool isProtected = desc.fProtected == GrProtected::kYes;
GrBackendTexture backendTex =
GrAHardwareBufferUtils::MakeBackendTexture(direct,
buffer.get(),
desc.fDimensions.width(),
desc.fDimensions.height(),
&deleteImageProc,
&updateImageProc,
&texImageCtx,
isProtected,
desc.fFormat,
false);
if (!backendTex.isValid()) {
return {};
}
SkASSERT(deleteImageProc && texImageCtx);
// We make this texture cacheable to avoid recreating a GrTexture every time this
// is invoked. We know the owning SkImage will send an invalidation message when the
// image is destroyed, so the texture will be removed at that time. Note that the
// proxy will be keyed in GrProxyProvider but that cache just allows extant proxies
// to be reused. It does not retain them. After a flush the proxy will be deleted
// and a subsequent use of the image will recreate a new proxy around the GrTexture
// found in the GrResourceCache.
// This is the last use of GrWrapCacheable::kYes so if we actually cached the proxy
// we could remove wrapped GrGpuResource caching.
sk_sp<GrTexture> tex = resourceProvider->wrapBackendTexture(
backendTex, kBorrow_GrWrapOwnership, GrWrapCacheable::kYes, kRead_GrIOType);
if (!tex) {
deleteImageProc(texImageCtx);
return {};
}
if (deleteImageProc) {
tex->setRelease(deleteImageProc, texImageCtx);
}
return tex;
},
backendFormat, {width, height}, GrMipmapped::kNo, GrMipmapStatus::kNotAllocated,
GrInternalSurfaceFlags::kReadOnly, SkBackingFit::kExact, SkBudgeted::kNo,
GrProtected(fIsProtectedContent), GrSurfaceProxy::UseAllocator::kYes);
GrSwizzle readSwizzle = context->priv().caps()->getReadSwizzle(backendFormat, grColorType);
return GrSurfaceProxyView(std::move(texProxy), fSurfaceOrigin, readSwizzle);
}
GrSurfaceProxyView GrAHardwareBufferImageGenerator::onGenerateTexture(
GrRecordingContext* context,
const SkImageInfo& info,
const SkIPoint& origin,
GrMipmapped mipMapped,
GrImageTexGenPolicy texGenPolicy) {
GrSurfaceProxyView texProxyView = this->makeView(context);
if (!texProxyView.proxy()) {
return {};
}
SkASSERT(texProxyView.asTextureProxy());
if (texGenPolicy == GrImageTexGenPolicy::kDraw && origin.isZero() &&
info.dimensions() == this->getInfo().dimensions() && mipMapped == GrMipmapped::kNo) {
// If the caller wants the full non-MIP mapped texture we're done.
return texProxyView;
}
// Otherwise, make a copy for the requested subset and/or MIP maps.
SkIRect subset = SkIRect::MakeXYWH(origin.fX, origin.fY, info.width(), info.height());
SkBudgeted budgeted = texGenPolicy == GrImageTexGenPolicy::kNew_Uncached_Unbudgeted
? SkBudgeted::kNo
: SkBudgeted::kYes;
return GrSurfaceProxyView::Copy(context, std::move(texProxyView), mipMapped, subset,
SkBackingFit::kExact, budgeted);
}
bool GrAHardwareBufferImageGenerator::onIsValid(GrRecordingContext* context) const {
if (nullptr == context) {
return false; //CPU backend is not supported, because hardware buffer can be swizzled
}
return GrBackendApi::kOpenGL == context->backend() ||
GrBackendApi::kVulkan == context->backend();
}
#endif //SK_BUILD_FOR_ANDROID_FRAMEWORK