blob: 5e5d4eded5cf49f864bef391ef648d515bf5653e [file] [log] [blame]
/*
* Copyright 2018 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
// This is a GPU-backend specific test. It relies on static intializers to work
#include "SkTypes.h"
#if SK_SUPPORT_GPU && defined(SK_BUILD_FOR_ANDROID) && __ANDROID_API__ >= 26
#include "GrAHardwareBufferImageGenerator.h"
#include "GrContext.h"
#include "GrContextFactory.h"
#include "GrContextPriv.h"
#include "GrGpu.h"
#include "SkImage.h"
#include "SkSurface.h"
#include "Test.h"
#include <android/hardware_buffer.h>
#include <cinttypes>
static const int DEV_W = 16, DEV_H = 16;
static SkPMColor get_src_color(int x, int y) {
SkASSERT(x >= 0 && x < DEV_W);
SkASSERT(y >= 0 && y < DEV_H);
U8CPU r = x;
U8CPU g = y;
U8CPU b = 0xc;
U8CPU a = 0xff;
switch ((x+y) % 5) {
case 0:
a = 0xff;
break;
case 1:
a = 0x80;
break;
case 2:
a = 0xCC;
break;
case 4:
a = 0x01;
break;
case 3:
a = 0x00;
break;
}
a = 0xff;
return SkPremultiplyARGBInline(a, r, g, b);
}
static SkBitmap make_src_bitmap() {
static SkBitmap bmp;
if (bmp.isNull()) {
bmp.allocN32Pixels(DEV_W, DEV_H);
intptr_t pixels = reinterpret_cast<intptr_t>(bmp.getPixels());
for (int y = 0; y < DEV_H; ++y) {
for (int x = 0; x < DEV_W; ++x) {
SkPMColor* pixel = reinterpret_cast<SkPMColor*>(
pixels + y * bmp.rowBytes() + x * bmp.bytesPerPixel());
*pixel = get_src_color(x, y);
}
}
}
return bmp;
}
static bool check_read(skiatest::Reporter* reporter, const SkBitmap& expectedBitmap,
const SkBitmap& actualBitmap) {
bool result = true;
for (int y = 0; y < DEV_H && result; ++y) {
for (int x = 0; x < DEV_W && result; ++x) {
const uint32_t srcPixel = *expectedBitmap.getAddr32(x, y);
const uint32_t dstPixel = *actualBitmap.getAddr32(x, y);
if (srcPixel != dstPixel) {
ERRORF(reporter, "Expected readback pixel (%d, %d) value 0x%08x, got 0x%08x.",
x, y, srcPixel, dstPixel);
result = false;
}/* else {
SkDebugf("Got good pixel (%d, %d) value 0x%08x, got 0x%08x.\n",
x, y, srcPixel, dstPixel);
}*/
}
}
return result;
}
static void cleanup_resources(AHardwareBuffer* buffer) {
if (buffer) {
AHardwareBuffer_release(buffer);
}
}
static void basic_draw_test_helper(skiatest::Reporter* reporter,
const sk_gpu_test::ContextInfo& info,
GrSurfaceOrigin surfaceOrigin) {
GrContext* context = info.grContext();
if (!context->contextPriv().caps()->supportsAHardwareBufferImages()) {
return;
}
///////////////////////////////////////////////////////////////////////////
// Setup SkBitmaps
///////////////////////////////////////////////////////////////////////////
const SkBitmap srcBitmap = make_src_bitmap();
///////////////////////////////////////////////////////////////////////////
// Setup AHardwareBuffer
///////////////////////////////////////////////////////////////////////////
AHardwareBuffer* buffer = nullptr;
AHardwareBuffer_Desc hwbDesc;
hwbDesc.width = DEV_W;
hwbDesc.height = DEV_H;
hwbDesc.layers = 1;
hwbDesc.usage = AHARDWAREBUFFER_USAGE_CPU_READ_NEVER |
AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN |
AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
hwbDesc.format = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
// The following three are not used in the allocate
hwbDesc.stride = 0;
hwbDesc.rfu0= 0;
hwbDesc.rfu1= 0;
if (int error = AHardwareBuffer_allocate(&hwbDesc, &buffer)) {
ERRORF(reporter, "Failed to allocated hardware buffer, error: %d", error);
cleanup_resources(buffer);
return;
}
// Get actual desc for allocated buffer so we know the stride for uploading cpu data.
AHardwareBuffer_describe(buffer, &hwbDesc);
uint32_t* bufferAddr;
if (AHardwareBuffer_lock(buffer, AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN, -1, nullptr,
reinterpret_cast<void**>(&bufferAddr))) {
ERRORF(reporter, "Failed to lock hardware buffer");
cleanup_resources(buffer);
return;
}
int bbp = srcBitmap.bytesPerPixel();
uint32_t* src = (uint32_t*)srcBitmap.getPixels();
int nextLineStep = DEV_W;
if (surfaceOrigin == kBottomLeft_GrSurfaceOrigin) {
nextLineStep = -nextLineStep;
src += (DEV_H-1)*DEV_W;
}
uint32_t* dst = bufferAddr;
for (int y = 0; y < DEV_H; ++y) {
memcpy(dst, src, DEV_W * bbp);
src += nextLineStep;
dst += hwbDesc.stride;
}
AHardwareBuffer_unlock(buffer, nullptr);
///////////////////////////////////////////////////////////////////////////
// Wrap AHardwareBuffer in SkImage
///////////////////////////////////////////////////////////////////////////
sk_sp<SkImage> image = SkImage::MakeFromAHardwareBuffer(buffer, kPremul_SkAlphaType,
nullptr, surfaceOrigin);
REPORTER_ASSERT(reporter, image);
///////////////////////////////////////////////////////////////////////////
// Make a surface to draw into
///////////////////////////////////////////////////////////////////////////
SkImageInfo imageInfo = SkImageInfo::Make(DEV_W, DEV_H, kRGBA_8888_SkColorType,
kPremul_SkAlphaType);
sk_sp<SkSurface> surface = SkSurface::MakeRenderTarget(context, SkBudgeted::kNo,
imageInfo);
REPORTER_ASSERT(reporter, surface);
///////////////////////////////////////////////////////////////////////////
// Draw the AHardwareBuffer SkImage into surface
///////////////////////////////////////////////////////////////////////////
surface->getCanvas()->drawImage(image, 0, 0);
SkBitmap readbackBitmap;
readbackBitmap.allocN32Pixels(DEV_W, DEV_H);
REPORTER_ASSERT(reporter, surface->readPixels(readbackBitmap, 0, 0));
REPORTER_ASSERT(reporter, check_read(reporter, srcBitmap, readbackBitmap));
image.reset();
cleanup_resources(buffer);
}
// Basic test to make sure we can import an AHardwareBuffer into an SkImage and draw it into a
// surface.
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(GrAHardwareBuffer_BasicDrawTest,
reporter, context_info) {
basic_draw_test_helper(reporter, context_info, kTopLeft_GrSurfaceOrigin);
basic_draw_test_helper(reporter, context_info, kBottomLeft_GrSurfaceOrigin);
}
#endif