blob: 6a2a1a2d00f09090235c200e4d6a4c8e5a0aeb00 [file] [log] [blame]
/*
* Copyright 2021 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "modules/jetski/src/Surface.h"
#include <android/bitmap.h>
#include <android/log.h>
#include "tools/window/SkDisplayParams.h"
#include "tools/window/android/SkWindowContextFactory_android.h"
WindowSurface::WindowSurface(ANativeWindow* win, std::unique_ptr<SkWindowContext> wctx)
: fWindow(win)
, fWindowContext(std::move(wctx))
{
SkASSERT(fWindow);
SkASSERT(fWindowContext);
fSurface = fWindowContext->getBackbufferSurface();
}
void WindowSurface::release(JNIEnv* env) {
fWindowContext.reset();
ANativeWindow_release(fWindow);
}
SkCanvas* WindowSurface::getCanvas() {
if (fSurface) {
return fSurface->getCanvas();
}
return nullptr;
}
void WindowSurface::flushAndSubmit() {
fSurface->flushAndSubmit();
fWindowContext->swapBuffers();
fSurface = fWindowContext->getBackbufferSurface();
}
// SkSurface created from being passed an android.view.Surface
// For now, assume we are always rendering with OpenGL
// TODO: add option of choose backing
ThreadedSurface::ThreadedSurface(JNIEnv* env, jobject surface)
: fThread(std::make_unique<SurfaceThread>()) {
ANativeWindow* window = ANativeWindow_fromSurface(env, surface);
fWidth = ANativeWindow_getWidth(window);
fHeight = ANativeWindow_getHeight(window);
Message message(kInitialize);
message.fNativeWindow = window;
message.fWindowSurface = &fWindowSurface;
fThread->postMessage(message);
}
void ThreadedSurface::release(JNIEnv* env) {
Message message(kDestroy);
message.fWindowSurface = &fWindowSurface;
fThread->postMessage(message);
fThread->release();
}
SkCanvas* ThreadedSurface::getCanvas() {
return fRecorder.beginRecording(fWidth,
fHeight);
}
void ThreadedSurface::flushAndSubmit() {
Message message(kRenderPicture);
message.fWindowSurface = &fWindowSurface;
message.fPicture = fRecorder.finishRecordingAsPicture().release();
fThread->postMessage(message);
}
namespace {
class BitmapSurface final : public Surface {
public:
BitmapSurface(JNIEnv* env, jobject bitmap) {
AndroidBitmapInfo bm_info;
if (AndroidBitmap_getInfo(env, bitmap, &bm_info) != ANDROID_BITMAP_RESULT_SUCCESS) {
return;
}
const auto info = SkImageInfo::Make(bm_info.width, bm_info.height,
color_type(bm_info.format), alpha_type(bm_info.flags));
void* pixels;
if (AndroidBitmap_lockPixels(env, bitmap, &pixels) != ANDROID_BITMAP_RESULT_SUCCESS) {
return;
}
fSurface = SkSurface::MakeRasterDirect(info, pixels, bm_info.stride);
if (!fSurface) {
AndroidBitmap_unlockPixels(env, bitmap);
return;
}
fBitmap = env->NewGlobalRef(bitmap);
}
private:
void release(JNIEnv* env) override {
if (fSurface) {
AndroidBitmap_unlockPixels(env, fBitmap);
fSurface.reset();
env->DeleteGlobalRef(fBitmap);
}
}
SkCanvas* getCanvas() override {
if (fSurface) {
return fSurface->getCanvas();
}
return nullptr;
}
void flushAndSubmit() override {
// Nothing to do.
}
static SkColorType color_type(int32_t format) {
switch (format) {
case ANDROID_BITMAP_FORMAT_RGBA_8888: return kRGBA_8888_SkColorType;
case ANDROID_BITMAP_FORMAT_RGB_565: return kRGB_565_SkColorType;
case ANDROID_BITMAP_FORMAT_RGBA_4444: return kARGB_4444_SkColorType;
case ANDROID_BITMAP_FORMAT_RGBA_F16: return kRGBA_F16_SkColorType;
case ANDROID_BITMAP_FORMAT_A_8: return kAlpha_8_SkColorType;
default: break;
}
return kUnknown_SkColorType;
}
static SkAlphaType alpha_type(int32_t flags) {
switch ((flags >> ANDROID_BITMAP_FLAGS_ALPHA_SHIFT) & ANDROID_BITMAP_FLAGS_ALPHA_MASK) {
case ANDROID_BITMAP_FLAGS_ALPHA_OPAQUE: return kOpaque_SkAlphaType;
case ANDROID_BITMAP_FLAGS_ALPHA_PREMUL: return kPremul_SkAlphaType;
case ANDROID_BITMAP_FLAGS_ALPHA_UNPREMUL: return kUnpremul_SkAlphaType;
default: break;
}
return kUnknown_SkAlphaType;
}
jobject fBitmap;
};
// *** JNI methods ***
static jlong Surface_CreateBitmap(JNIEnv* env, jobject, jobject bitmap) {
return reinterpret_cast<jlong>(new BitmapSurface(env, bitmap));
}
static jlong Surface_CreateThreadedSurface(JNIEnv* env, jobject, jobject surface) {
return reinterpret_cast<jlong>(new ThreadedSurface(env, surface));
}
static jlong Surface_CreateVK(JNIEnv* env, jobject, jobject jsurface) {
#ifdef SK_VULKAN
auto* win = ANativeWindow_fromSurface(env, jsurface);
if (!win) {
return 0;
}
// TODO: match window params?
SkDisplayParams params;
auto winctx = window_context_factory::MakeVulkanForAndroid(win, params);
if (!winctx) {
return 0;
}
return reinterpret_cast<jlong>(sk_make_sp<WindowSurface>(win, std::move(winctx)).release());
#else
return 0;
#endif // SK_VULKAN
}
static jlong Surface_CreateGL(JNIEnv* env, jobject, jobject jsurface) {
#ifdef SK_GL
auto* win = ANativeWindow_fromSurface(env, jsurface);
if (!win) {
return 0;
}
// TODO: match window params?
SkDisplayParams params;
auto winctx = window_context_factory::MakeGLForAndroid(win, params);
if (!winctx) {
return 0;
}
return reinterpret_cast<jlong>(sk_make_sp<WindowSurface>(win, std::move(winctx)).release());
#else // SK_GL
return 0;
#endif
}
static void Surface_Release(JNIEnv* env, jobject, jlong native_surface) {
if (auto* surface = reinterpret_cast<Surface*>(native_surface)) {
surface->release(env);
SkSafeUnref(surface);
}
}
static jlong Surface_GetNativeCanvas(JNIEnv* env, jobject, jlong native_surface) {
auto* surface = reinterpret_cast<Surface*>(native_surface);
return surface
? reinterpret_cast<jlong>(surface->getCanvas())
: 0;
}
static void Surface_FlushAndSubmit(JNIEnv* env, jobject, jlong native_surface) {
if (auto* surface = reinterpret_cast<Surface*>(native_surface)) {
surface->flushAndSubmit();
}
}
static jint Surface_GetWidth(JNIEnv* env, jobject, jlong native_surface) {
const auto* surface = reinterpret_cast<Surface*>(native_surface);
return surface ? surface->width() : 0;
}
static jint Surface_GetHeight(JNIEnv* env, jobject, jlong native_surface) {
const auto* surface = reinterpret_cast<Surface*>(native_surface);
return surface ? surface->height() : 0;
}
static jlong Surface_MakeSnapshot(JNIEnv* env, jobject, jlong native_surface) {
if (const auto* surface = reinterpret_cast<Surface*>(native_surface)) {
auto snapshot = surface->makeImageSnapshot();
return reinterpret_cast<jlong>(snapshot.release());
}
return 0;
}
// *** End of JNI methods ***
} // namespace
int register_jetski_Surface(JNIEnv* env) {
static const JNINativeMethod methods[] = {
{"nCreateBitmap" , "(Landroid/graphics/Bitmap;)J",
reinterpret_cast<void*>(Surface_CreateBitmap) },
{"nCreateThreadedSurface" , "(Landroid/view/Surface;)J",
reinterpret_cast<void*>(Surface_CreateThreadedSurface) },
{"nCreateVKSurface" , "(Landroid/view/Surface;)J",
reinterpret_cast<void*>(Surface_CreateVK) },
{"nCreateGLSurface" , "(Landroid/view/Surface;)J",
reinterpret_cast<void*>(Surface_CreateGL) },
{"nRelease" , "(J)V", reinterpret_cast<void*>(Surface_Release) },
{"nGetNativeCanvas" , "(J)J", reinterpret_cast<void*>(Surface_GetNativeCanvas)},
{"nFlushAndSubmit" , "(J)V", reinterpret_cast<void*>(Surface_FlushAndSubmit) },
{"nGetWidth" , "(J)I", reinterpret_cast<void*>(Surface_GetWidth) },
{"nGetHeight" , "(J)I", reinterpret_cast<void*>(Surface_GetHeight) },
{"nMakeImageSnapshot", "(J)J", reinterpret_cast<void*>(Surface_MakeSnapshot) },
};
const auto clazz = env->FindClass("org/skia/jetski/Surface");
return clazz
? env->RegisterNatives(clazz, methods, std::size(methods))
: JNI_ERR;
}