blob: b7d646db961d9c5e1246d7d2b7cbe668c79e122c [file] [log] [blame]
// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <lib/ddk/debug.h>
#include <lib/driver-unit-test/utils.h>
#include <lib/fit/function.h>
#include <lib/fzl/vmo-mapper.h>
#include <lib/image-format/image_format.h>
#include <lib/sync/completion.h>
#include <memory>
#include <vector>
#include <safemath/safe_conversions.h>
#include <zxtest/zxtest.h>
#include "src/camera/drivers/hw_accel/ge2d/ge2d.h"
#include "src/camera/drivers/hw_accel/ge2d/ge2d_regs.h"
#include "src/camera/drivers/test_utils/fake_buffer_collection.h"
namespace ge2d {
namespace {
constexpr uint32_t kImageFormatTableSize = 3;
constexpr uint32_t kWidth = 1024;
constexpr uint32_t kHeight = 1024;
constexpr uint32_t kWatermarkVerticalOffset = 10;
constexpr uint32_t kWatermarkHorizontalOffset = 10;
constexpr uint32_t kWatermarkWidth = 65;
constexpr uint32_t kWatermarkHeight = 64;
class Ge2dDeviceTest : public zxtest::Test {
public:
void SetUp() override {
zx_status_t status = ge2d::Ge2dDevice::Setup(driver_unit_test::GetParent(), &ge2d_device_);
ZX_ASSERT(status == ZX_OK);
}
void TearDown() override {
EXPECT_OK(camera::DestroyContiguousBufferCollection(input_buffer_collection_));
EXPECT_OK(camera::DestroyContiguousBufferCollection(output_buffer_collection_));
}
void SetupInput(uint32_t input_format = fuchsia_sysmem_PixelFormatType_NV12,
uint32_t output_format = fuchsia_sysmem_PixelFormatType_NV12) {
uint32_t buffer_collection_count = 2;
ASSERT_OK(
camera::GetImageFormat(output_image_format_table_[0], output_format, kWidth, kHeight));
ASSERT_OK(camera::GetImageFormat(output_image_format_table_[1], output_format, kWidth / 2,
kHeight / 2));
ASSERT_OK(camera::GetImageFormat(output_image_format_table_[2], output_format, kWidth / 4,
kHeight / 4));
// Set up fake Resize info
resize_info_.crop.x = 0;
resize_info_.crop.y = 0;
resize_info_.crop.width = kWidth;
resize_info_.crop.height = kHeight;
resize_info_.output_rotation = GE2D_ROTATION_ROTATION_0;
image_format_2_t input_image_format;
ASSERT_OK(camera::GetImageFormat(input_image_format, input_format, kWidth, kHeight));
zx_status_t status = camera::CreateContiguousBufferCollectionInfo(
input_buffer_collection_, input_image_format, ge2d_device_->bti().get(),
buffer_collection_count);
ASSERT_OK(status);
status = camera::CreateContiguousBufferCollectionInfo(
output_buffer_collection_, output_image_format_table_[0], ge2d_device_->bti().get(),
buffer_collection_count);
ASSERT_OK(status);
for (uint32_t i = 0; i < output_buffer_collection_.buffer_count; i++) {
size_t size;
ASSERT_OK(zx_vmo_get_size(output_buffer_collection_.buffers[i].vmo, &size));
ASSERT_OK(zx_vmo_op_range(output_buffer_collection_.buffers[i].vmo, ZX_VMO_OP_CACHE_CLEAN, 0,
size, nullptr, 0));
}
}
void SetupCallbacks() {
res_callback_.frame_resolution_changed = [](void* ctx, const frame_available_info* info) {
static_cast<Ge2dDeviceTest*>(ctx)->RunResolutionChangedCallback(info);
};
res_callback_.ctx = this;
remove_task_callback_.task_removed = [](void* ctx, task_remove_status_t status) {
static_cast<Ge2dDeviceTest*>(ctx)->RunTaskRemovedCallback(status);
};
remove_task_callback_.ctx = this;
frame_callback_.frame_ready = [](void* ctx, const frame_available_info* info) {
static_cast<Ge2dDeviceTest*>(ctx)->RunFrameCallback(info);
};
frame_callback_.ctx = this;
}
void SetFrameCallback(fit::function<void(const frame_available_info* info)> callback) {
client_frame_callback_ = std::move(callback);
}
void RunFrameCallback(const frame_available_info* info) { client_frame_callback_(info); }
void SetTaskRemovedCallback(fit::function<void(task_remove_status_t status)> callback) {
task_removed_callback_ = std::move(callback);
}
void RunTaskRemovedCallback(task_remove_status_t status) { task_removed_callback_(status); }
void RunResolutionChangedCallback(const frame_available_info* info) {
resolution_changed_callback_(info);
}
void SetResolutionChangedCallback(
fit::function<void(const frame_available_info* info)> callback) {
resolution_changed_callback_ = std::move(callback);
}
protected:
void CompareCroppedOutput(const frame_available_info* info, float tolerance = 0.0f);
void SetupWatermarkInfo() {
image_format_2_t watermark_image_format;
ASSERT_OK(camera::GetImageFormat(watermark_image_format,
fuchsia_sysmem_PixelFormatType_R8G8B8A8, kWatermarkWidth,
kWatermarkHeight));
watermark_info_.wm_image_format = watermark_image_format;
watermark_info_.loc_x = kWatermarkHorizontalOffset;
watermark_info_.loc_y = kWatermarkVerticalOffset;
watermark_info_.global_alpha = 1.f;
}
zx::vmo CreateWatermarkVmo() {
zx::vmo watermark_vmo;
EXPECT_OK(zx::vmo::create(watermark_info_.wm_image_format.bytes_per_row *
watermark_info_.wm_image_format.coded_height,
0, &watermark_vmo));
return watermark_vmo;
}
std::unique_ptr<Ge2dDevice> ge2d_device_;
hw_accel_frame_callback_t frame_callback_;
hw_accel_res_change_callback_t res_callback_;
hw_accel_remove_task_callback_t remove_task_callback_;
fit::function<void(const frame_available_info* info)> client_frame_callback_;
fit::function<void(task_remove_status_t status)> task_removed_callback_;
fit::function<void(const frame_available_info* info)> resolution_changed_callback_;
buffer_collection_info_2_t input_buffer_collection_;
buffer_collection_info_2_t output_buffer_collection_;
image_format_2_t output_image_format_table_[kImageFormatTableSize];
sync_completion_t completion_;
resize_info_t resize_info_;
water_mark_info_t watermark_info_;
uint32_t input_format_index_ = 0;
};
void WriteDataToVmo(zx_handle_t vmo, const image_format_2_t& format) {
uint32_t size = format.bytes_per_row * format.coded_height * 3 / 2;
std::vector<uint8_t> input_data(size);
constexpr uint32_t kRunLength = 230;
// 230 should not by a divisor of the stride or height, to ensure adjacent lines have different
// contents.
static_assert(kWidth % kRunLength != 0, "kRunLength is a bad choice");
for (uint32_t i = 0; i < size; i++) {
input_data[i] = i % kRunLength;
}
ASSERT_OK(zx_vmo_write(vmo, input_data.data(), 0, size));
ASSERT_OK(zx_vmo_op_range(vmo, ZX_VMO_OP_CACHE_CLEAN, 0, size, nullptr, 0));
}
void WriteConstantColorToVmo(zx_handle_t vmo, uint8_t y, uint8_t u, uint8_t v,
const image_format_2_t& format) {
uint32_t size = format.bytes_per_row * format.coded_height * 3 / 2;
std::vector<uint8_t> input_data(format.coded_width);
memset(input_data.data(), y, input_data.size());
uint32_t offset = 0;
for (uint32_t y = 0; y < format.coded_height; ++y) {
ASSERT_OK(zx_vmo_write(vmo, input_data.data(), offset, input_data.size()));
offset += format.bytes_per_row;
}
for (uint32_t x = 0; x < format.coded_width / 2; ++x) {
input_data[x * 2] = u;
input_data[x * 2 + 1] = v;
}
for (uint32_t y = 0; y < format.coded_height / 2; ++y) {
ASSERT_OK(zx_vmo_write(vmo, input_data.data(), offset, input_data.size()));
offset += format.bytes_per_row;
}
ASSERT_OK(zx_vmo_op_range(vmo, ZX_VMO_OP_CACHE_CLEAN, 0, size, nullptr, 0));
}
void WriteConstantRgbaToVmo(zx_handle_t vmo, uint8_t r, uint8_t g, uint8_t b, uint8_t a,
const image_format_2_t& format) {
uint32_t size = format.bytes_per_row * format.coded_height;
std::vector<uint8_t> input_data(format.coded_width * 4);
for (uint32_t x = 0; x < format.coded_width; x++) {
input_data[4 * x] = r;
input_data[4 * x + 1] = g;
input_data[4 * x + 2] = b;
input_data[4 * x + 3] = a;
}
uint32_t offset = 0;
for (uint32_t y = 0; y < format.coded_height; ++y) {
ASSERT_OK(zx_vmo_write(vmo, input_data.data(), offset, input_data.size()));
offset += format.bytes_per_row;
}
ASSERT_OK(zx_vmo_op_range(vmo, ZX_VMO_OP_CACHE_CLEAN, 0, size, nullptr, 0));
}
// Write out data without large jumps so it's easier to do a comparison using a
// tolerance.
void WriteScalingDataToVmo(zx_handle_t vmo, const image_format_2_t& format) {
std::vector<uint8_t> input_data(format.coded_width);
// Write to both Y and UV planes in this loop.
for (uint32_t y = 0; y < format.coded_height * 3 / 2; y++) {
for (uint32_t x = 0; x < format.coded_width; ++x) {
// Multiply by 2 so we can see interpolated values in the output.
uint32_t start_val = 2 * x + 4 * y;
// Ensure U and V values are very different, because we don't want to mix
// them up.
if (y >= format.coded_height && ((x & 1) == 1)) {
start_val += 63;
}
// Limit result to [0..255]
constexpr uint32_t kMaxPlus1 = 256;
// Output should go 0-255,255-0,0-255 etc. This is a smooth function so there aren't large
// jumps in output that could cause pixels near the jump to be outside the tolerance.
start_val %= kMaxPlus1 * 2;
if (start_val >= kMaxPlus1)
start_val = (kMaxPlus1 * 2 - 1) - start_val;
input_data[x] = safemath::checked_cast<uint8_t>(start_val);
}
ASSERT_OK(zx_vmo_write(vmo, input_data.data(), y * format.bytes_per_row, format.coded_width));
}
uint32_t size = format.bytes_per_row * format.coded_height * 3 / 2;
ASSERT_OK(zx_vmo_op_range(vmo, ZX_VMO_OP_CACHE_CLEAN, 0, size, nullptr, 0));
}
float lerp(float x, float y, float a) { return x + (y - x) * a; }
float BilinearInterp(fit::function<float(const uint32_t, const uint32_t)> load, float x, float y) {
auto checked_x = safemath::checked_cast<int32_t>(x);
auto checked_y = safemath::checked_cast<int32_t>(y);
auto low_x = std::max(0, checked_x);
auto low_y = std::max(0, checked_y);
// If the input is on a pixel center then read from that both times, to avoid
// reading out of bounds.
auto upper_x = low_x == checked_x ? low_x : low_x + 1;
auto upper_y = low_y == checked_y ? low_y : low_y + 1;
auto a_0_0 = load(low_x, low_y);
auto a_0_1 = load(low_x, upper_y);
auto a_1_0 = load(upper_x, low_y);
auto a_1_1 = load(upper_x, upper_y);
auto row_1 = lerp(a_0_0, a_1_0, x - static_cast<float>(low_x));
auto row_2 = lerp(a_0_1, a_1_1, x - static_cast<float>(low_x));
return lerp(row_1, row_2, y - static_cast<float>(low_y));
}
// Compare a rectangular region of |addr_a| with a rectangular region of |addr_b|.
void CheckSubPlaneEqual(void* addr_a, void* addr_b, uint32_t offset_a, uint32_t offset_b,
uint32_t stride_a, uint32_t stride_b, uint32_t width,
uint32_t bytes_per_pixel, uint32_t height, float x_scale, float y_scale,
float tolerance, const char* error_type) {
uint32_t error_count = 0;
uint8_t* region_start_a = reinterpret_cast<uint8_t*>(addr_a) + offset_a;
uint8_t* region_start_b = reinterpret_cast<uint8_t*>(addr_b) + offset_b;
for (uint32_t y = 0; y < height; y++) {
for (uint32_t x = 0; x < width / bytes_per_pixel; x++) {
uint8_t output_value[4] = {};
memcpy(&output_value, region_start_b + stride_b * y + x * bytes_per_pixel, bytes_per_pixel);
constexpr float kHalfPixel = 0.5f;
// Add and subtract half a pixel to try to account for the pixel center
// location.
float input_x = ((safemath::checked_cast<float>(x) + kHalfPixel) * x_scale - kHalfPixel);
float input_y = ((safemath::checked_cast<float>(y) + kHalfPixel) * y_scale - kHalfPixel);
for (uint32_t c = 0; c < bytes_per_pixel; c++) {
float input_value = BilinearInterp(
[&](uint32_t x, uint32_t y) {
return (region_start_a + stride_a * y + x * bytes_per_pixel)[c];
},
input_x, input_y);
EXPECT_GE(tolerance, std::abs(output_value[c] - input_value),
"%s component %d input %f vs output %d at output (%d, %d), input (%f, %f)",
error_type, c, input_value, output_value[c], x, y, input_x, input_y);
if (tolerance < std::abs(output_value[c] - input_value)) {
if (++error_count >= 10)
return;
}
}
}
}
}
void CacheInvalidateVmo(zx_handle_t vmo) {
uint64_t size;
ASSERT_OK(zx_vmo_get_size(vmo, &size));
ASSERT_OK(zx_vmo_op_range(vmo, ZX_VMO_OP_CACHE_CLEAN_INVALIDATE, 0, size, nullptr, 0));
}
void CheckEqual(zx_handle_t vmo_a, zx_handle_t vmo_b, const image_format_2_t& format) {
CacheInvalidateVmo(vmo_a);
CacheInvalidateVmo(vmo_b);
fzl::VmoMapper mapper_a;
ASSERT_OK(mapper_a.Map(*zx::unowned_vmo(vmo_a), 0, 0, ZX_VM_PERM_READ));
fzl::VmoMapper mapper_b;
ASSERT_OK(mapper_b.Map(*zx::unowned_vmo(vmo_b), 0, 0, ZX_VM_PERM_READ));
CheckSubPlaneEqual(mapper_a.start(), mapper_b.start(), 0, 0, format.bytes_per_row,
format.bytes_per_row, format.coded_width, 1, format.coded_height, 1.0f, 1.0f,
0, "Y");
uint32_t uv_offset = format.bytes_per_row * format.coded_height;
CheckSubPlaneEqual(mapper_a.start(), mapper_b.start(), uv_offset, uv_offset, format.bytes_per_row,
format.bytes_per_row, format.coded_width, 2, format.coded_height / 2, 1.0f,
1.0f, 0, "UV");
}
uint8_t* GetPointerToPixel(void* base, const image_format_2_t& format, uint32_t x, uint32_t y,
uint32_t plane = 0) {
if (format.pixel_format.type == fuchsia_sysmem_PixelFormatType_NV12) {
if (plane == 0) {
return static_cast<uint8_t*>(base) + format.bytes_per_row * y + x;
} else {
return static_cast<uint8_t*>(base) + format.bytes_per_row * (format.coded_height + y / 2) +
(x / 2) * 2;
}
} else {
return static_cast<uint8_t*>(base) + format.bytes_per_row * y + 4 * x;
}
}
// Check that a region is a YUV solid color
void CheckYUVRegion(void* data, const image_format_2_t& format, uint8_t y_component, uint8_t u,
uint8_t v, uint32_t x_start, uint32_t width, uint32_t y_start,
uint32_t height) {
uint32_t error_count = 0;
for (uint32_t y = 0; y < height; y++) {
for (uint32_t x = 0; x < width; x++) {
uint32_t value = *GetPointerToPixel(data, format, x_start + x, y_start + y, 0);
EXPECT_EQ(y_component, value, "(%d, %d)", x, y);
if (y_component != value) {
error_count++;
}
if (error_count > 10)
return;
}
}
for (uint32_t y = 0; y < height / 2; y++) {
for (uint32_t x = 0; x < width / 2; x++) {
uint32_t uv_value = *reinterpret_cast<volatile uint16_t*>(
GetPointerToPixel(data, format, x_start + x, y_start + y, 1));
EXPECT_EQ(u, uv_value & 0xff, "(%d, %d)", x, y);
EXPECT_EQ(v, uv_value >> 8, "(%d, %d)", x, y);
if (u != (uv_value & 0xff) || (v != uv_value >> 8)) {
error_count++;
}
if (error_count > 10)
return;
}
}
}
void Ge2dDeviceTest::CompareCroppedOutput(const frame_available_info* info, float tolerance) {
fprintf(stderr, "Got frame_ready, id %d\n", info->buffer_id);
zx_handle_t vmo_a = input_buffer_collection_.buffers[0].vmo;
zx_handle_t vmo_b = output_buffer_collection_.buffers[info->buffer_id].vmo;
image_format_2_t input_format = output_image_format_table_[input_format_index_];
image_format_2_t output_format = output_image_format_table_[info->metadata.image_format_index];
CacheInvalidateVmo(vmo_a);
CacheInvalidateVmo(vmo_b);
fzl::VmoMapper mapper_a;
ASSERT_OK(mapper_a.Map(*zx::unowned_vmo(vmo_a), 0, 0, ZX_VM_PERM_READ));
fzl::VmoMapper mapper_b;
ASSERT_OK(mapper_b.Map(*zx::unowned_vmo(vmo_b), 0, 0, ZX_VM_PERM_READ));
uint32_t a_start_offset = input_format.bytes_per_row * resize_info_.crop.y + resize_info_.crop.x;
float width_scale = safemath::checked_cast<float>(resize_info_.crop.width) /
safemath::checked_cast<float>(output_format.coded_width);
float height_scale = safemath::checked_cast<float>(resize_info_.crop.height) /
safemath::checked_cast<float>(output_format.coded_height);
// Account for rounding and other minor issues.
if (width_scale != 1.0f || height_scale != 1.0f)
tolerance += 0.7f;
// Pre-scaler may cause minor changes.
if (width_scale > 2.0f)
tolerance += 1;
if (height_scale > 2.0f)
tolerance += 2;
uint32_t height_to_check = output_format.coded_height;
if (height_scale < 1.0f) {
// Last row may be blended with default color, due to the fact that its pixel center
// location is greater than the largest input pixel center location.
height_to_check--;
}
uint32_t width_to_check = output_format.coded_height;
if (width_scale < 1.0f) {
// Same as height above.
width_to_check--;
}
CheckSubPlaneEqual(mapper_a.start(), mapper_b.start(), a_start_offset, 0,
input_format.bytes_per_row, output_format.bytes_per_row, width_to_check, 1,
height_to_check, width_scale, height_scale, tolerance, "Y");
// When scaling is a disabled we currently repeat the input U and V data instead of
// interpolating, so the output UV should just be a shifted version of the input.
uint32_t a_uv_offset = input_format.bytes_per_row * input_format.coded_height;
uint32_t a_uv_start_offset = a_uv_offset +
input_format.bytes_per_row * (resize_info_.crop.y / 2) +
(resize_info_.crop.x / 2) * 2;
uint32_t b_uv_offset = output_format.bytes_per_row * output_format.coded_height;
// Because subsampling reduces the precision of everything, we need to
// increase the tolerance here.
if (tolerance > 0)
tolerance = tolerance * 2 + 1;
if (width_scale < 1.0f || height_scale < 1.0f)
tolerance += 2.0f;
CheckSubPlaneEqual(mapper_a.start(), mapper_b.start(), a_uv_start_offset, b_uv_offset,
input_format.bytes_per_row, output_format.bytes_per_row, width_to_check, 2,
height_to_check / 2, width_scale, height_scale, tolerance, "UV");
}
TEST_F(Ge2dDeviceTest, SameSize) {
SetupCallbacks();
SetupInput();
WriteDataToVmo(input_buffer_collection_.buffers[0].vmo, output_image_format_table_[0]);
SetFrameCallback([this](const frame_available_info* info) {
fprintf(stderr, "Got frame_ready, id %d\n", info->buffer_id);
CheckEqual(input_buffer_collection_.buffers[0].vmo,
output_buffer_collection_.buffers[info->buffer_id].vmo,
output_image_format_table_[0]);
sync_completion_signal(&completion_);
});
uint32_t resize_task;
zx_status_t status = ge2d_device_->Ge2dInitTaskResize(
&input_buffer_collection_, &output_buffer_collection_, &resize_info_,
&output_image_format_table_[0], output_image_format_table_, kImageFormatTableSize, 0,
&frame_callback_, &res_callback_, &remove_task_callback_, &resize_task);
EXPECT_OK(status);
status = ge2d_device_->Ge2dProcessFrame(resize_task, 0, 0);
EXPECT_OK(status);
EXPECT_EQ(ZX_OK, sync_completion_wait(&completion_, ZX_TIME_INFINITE));
}
TEST_F(Ge2dDeviceTest, Crop) {
SetupCallbacks();
SetupInput();
WriteDataToVmo(input_buffer_collection_.buffers[0].vmo, output_image_format_table_[0]);
resize_info_.crop.x = kWidth / 2;
resize_info_.crop.y = kHeight / 2;
resize_info_.crop.width = kWidth / 2;
resize_info_.crop.height = kHeight / 2;
SetFrameCallback([this](const frame_available_info* info) {
CompareCroppedOutput(info);
sync_completion_signal(&completion_);
});
uint32_t resize_task;
zx_status_t status = ge2d_device_->Ge2dInitTaskResize(
&input_buffer_collection_, &output_buffer_collection_, &resize_info_,
&output_image_format_table_[0], output_image_format_table_, kImageFormatTableSize, 1,
&frame_callback_, &res_callback_, &remove_task_callback_, &resize_task);
EXPECT_OK(status);
status = ge2d_device_->Ge2dProcessFrame(resize_task, 0, 0);
EXPECT_OK(status);
EXPECT_EQ(ZX_OK, sync_completion_wait(&completion_, ZX_TIME_INFINITE));
}
TEST_F(Ge2dDeviceTest, CropOddOffset) {
SetupCallbacks();
SetupInput();
WriteDataToVmo(input_buffer_collection_.buffers[0].vmo, output_image_format_table_[0]);
resize_info_.crop.x = 1;
resize_info_.crop.y = 1;
resize_info_.crop.width = kWidth / 2;
resize_info_.crop.height = kHeight / 2;
SetFrameCallback([this](const frame_available_info* info) {
CompareCroppedOutput(info);
sync_completion_signal(&completion_);
});
uint32_t resize_task;
zx_status_t status = ge2d_device_->Ge2dInitTaskResize(
&input_buffer_collection_, &output_buffer_collection_, &resize_info_,
&output_image_format_table_[0], output_image_format_table_, kImageFormatTableSize, 1,
&frame_callback_, &res_callback_, &remove_task_callback_, &resize_task);
EXPECT_OK(status);
status = ge2d_device_->Ge2dProcessFrame(resize_task, 0, 0);
EXPECT_OK(status);
EXPECT_EQ(ZX_OK, sync_completion_wait(&completion_, ZX_TIME_INFINITE));
}
// Scale width down to 50%, but don't scale height.
TEST_F(Ge2dDeviceTest, Scale) {
SetupCallbacks();
SetupInput();
WriteScalingDataToVmo(input_buffer_collection_.buffers[0].vmo, output_image_format_table_[0]);
resize_info_.crop.x = 0;
resize_info_.crop.y = 0;
resize_info_.crop.width = kWidth;
resize_info_.crop.height = kHeight / 2;
SetFrameCallback([this](const frame_available_info* info) {
CompareCroppedOutput(info);
sync_completion_signal(&completion_);
});
uint32_t resize_task;
zx_status_t status = ge2d_device_->Ge2dInitTaskResize(
&input_buffer_collection_, &output_buffer_collection_, &resize_info_,
&output_image_format_table_[0], output_image_format_table_, kImageFormatTableSize, 1,
&frame_callback_, &res_callback_, &remove_task_callback_, &resize_task);
EXPECT_OK(status);
status = ge2d_device_->Ge2dProcessFrame(resize_task, 0, 0);
EXPECT_OK(status);
EXPECT_EQ(ZX_OK, sync_completion_wait(&completion_, ZX_TIME_INFINITE));
}
// Scale width down to 25%, but don't scale height.
TEST_F(Ge2dDeviceTest, ScaleQuarter) {
SetupCallbacks();
SetupInput();
WriteScalingDataToVmo(input_buffer_collection_.buffers[0].vmo, output_image_format_table_[0]);
resize_info_.crop.x = 0;
resize_info_.crop.y = 0;
resize_info_.crop.width = kWidth;
resize_info_.crop.height = kHeight / 4;
SetFrameCallback([this](const frame_available_info* info) {
CompareCroppedOutput(info);
sync_completion_signal(&completion_);
});
uint32_t resize_task;
zx_status_t status = ge2d_device_->Ge2dInitTaskResize(
&input_buffer_collection_, &output_buffer_collection_, &resize_info_,
&output_image_format_table_[0], output_image_format_table_, kImageFormatTableSize, 2,
&frame_callback_, &res_callback_, &remove_task_callback_, &resize_task);
EXPECT_OK(status);
status = ge2d_device_->Ge2dProcessFrame(resize_task, 0, 0);
EXPECT_OK(status);
EXPECT_EQ(ZX_OK, sync_completion_wait(&completion_, ZX_TIME_INFINITE));
}
// Scale height down to 25%, but don't scale width.
TEST_F(Ge2dDeviceTest, ScaleHeightQuarter) {
SetupCallbacks();
SetupInput();
WriteScalingDataToVmo(input_buffer_collection_.buffers[0].vmo, output_image_format_table_[0]);
resize_info_.crop.x = 0;
resize_info_.crop.y = 0;
resize_info_.crop.width = kWidth / 4;
resize_info_.crop.height = kHeight;
SetFrameCallback([this](const frame_available_info* info) {
CompareCroppedOutput(info);
sync_completion_signal(&completion_);
});
uint32_t resize_task;
zx_status_t status = ge2d_device_->Ge2dInitTaskResize(
&input_buffer_collection_, &output_buffer_collection_, &resize_info_,
&output_image_format_table_[0], output_image_format_table_, kImageFormatTableSize, 2,
&frame_callback_, &res_callback_, &remove_task_callback_, &resize_task);
EXPECT_OK(status);
status = ge2d_device_->Ge2dProcessFrame(resize_task, 0, 0);
EXPECT_OK(status);
EXPECT_EQ(ZX_OK, sync_completion_wait(&completion_, ZX_TIME_INFINITE));
}
// Scale width down to 33%, but don't scale height.
TEST_F(Ge2dDeviceTest, ScaleThird) {
SetupCallbacks();
SetupInput();
WriteScalingDataToVmo(input_buffer_collection_.buffers[0].vmo, output_image_format_table_[0]);
resize_info_.crop.x = 0;
resize_info_.crop.y = 0;
resize_info_.crop.width = kWidth / 4 * 3;
resize_info_.crop.height = kHeight / 4;
SetFrameCallback([this](const frame_available_info* info) {
CompareCroppedOutput(info);
sync_completion_signal(&completion_);
});
uint32_t resize_task;
zx_status_t status = ge2d_device_->Ge2dInitTaskResize(
&input_buffer_collection_, &output_buffer_collection_, &resize_info_,
&output_image_format_table_[0], output_image_format_table_, kImageFormatTableSize, 2,
&frame_callback_, &res_callback_, &remove_task_callback_, &resize_task);
EXPECT_OK(status);
status = ge2d_device_->Ge2dProcessFrame(resize_task, 0, 0);
EXPECT_OK(status);
EXPECT_EQ(ZX_OK, sync_completion_wait(&completion_, ZX_TIME_INFINITE));
}
// Scale width and height to 2x.
TEST_F(Ge2dDeviceTest, Scale2x) {
SetupCallbacks();
SetupInput();
WriteScalingDataToVmo(input_buffer_collection_.buffers[0].vmo, output_image_format_table_[1]);
resize_info_.crop.x = 0;
resize_info_.crop.y = 0;
resize_info_.crop.width = kWidth / 2;
resize_info_.crop.height = kHeight / 2;
SetFrameCallback([this](const frame_available_info* info) {
CompareCroppedOutput(info);
sync_completion_signal(&completion_);
});
input_format_index_ = 1;
uint32_t resize_task;
zx_status_t status = ge2d_device_->Ge2dInitTaskResize(
&input_buffer_collection_, &output_buffer_collection_, &resize_info_,
&output_image_format_table_[1], output_image_format_table_, kImageFormatTableSize, 0,
&frame_callback_, &res_callback_, &remove_task_callback_, &resize_task);
EXPECT_OK(status);
status = ge2d_device_->Ge2dProcessFrame(resize_task, 0, 0);
EXPECT_OK(status);
EXPECT_EQ(ZX_OK, sync_completion_wait(&completion_, ZX_TIME_INFINITE));
}
TEST_F(Ge2dDeviceTest, NV12ToRgba) {
SetupCallbacks();
SetupInput(fuchsia_sysmem_PixelFormatType_NV12, fuchsia_sysmem_PixelFormatType_R8G8B8A8);
image_format_2_t input_image_format;
ASSERT_OK(camera::GetImageFormat(input_image_format, fuchsia_sysmem_PixelFormatType_NV12, kWidth,
kHeight));
// Pure red in YUV.
WriteConstantColorToVmo(input_buffer_collection_.buffers[0].vmo, 82, 90, 240, input_image_format);
resize_info_.crop.x = 0;
resize_info_.crop.y = 0;
resize_info_.crop.width = kWidth;
resize_info_.crop.height = kHeight;
SetFrameCallback([this](const frame_available_info* info) {
fprintf(stderr, "Got completed conversion\n");
zx_handle_t vmo_b = output_buffer_collection_.buffers[info->buffer_id].vmo;
CacheInvalidateVmo(vmo_b);
fzl::VmoMapper mapper_b;
ASSERT_OK(mapper_b.Map(*zx::unowned_vmo(vmo_b), 0, 0, ZX_VM_PERM_READ));
uint8_t* output = static_cast<uint8_t*>(mapper_b.start());
// R
EXPECT_EQ(0xff, output[0]);
// G (minor rounding issues)
EXPECT_EQ(0x01, output[1]);
// B
EXPECT_EQ(0x00, output[2]);
// A
EXPECT_EQ(0xff, output[3]);
sync_completion_signal(&completion_);
});
uint32_t resize_task;
zx_status_t status = ge2d_device_->Ge2dInitTaskResize(
&input_buffer_collection_, &output_buffer_collection_, &resize_info_, &input_image_format,
output_image_format_table_, kImageFormatTableSize, 0, &frame_callback_, &res_callback_,
&remove_task_callback_, &resize_task);
EXPECT_OK(status);
status = ge2d_device_->Ge2dProcessFrame(resize_task, 0, 0);
EXPECT_OK(status);
EXPECT_EQ(ZX_OK, sync_completion_wait(&completion_, ZX_TIME_INFINITE));
}
// Test using SetCropRect.
TEST_F(Ge2dDeviceTest, ChangeScale) {
SetupCallbacks();
SetupInput();
WriteScalingDataToVmo(input_buffer_collection_.buffers[0].vmo, output_image_format_table_[0]);
resize_info_.crop.x = 0;
resize_info_.crop.y = kHeight / 4;
resize_info_.crop.width = kWidth / 2;
resize_info_.crop.height = kHeight / 4;
rect_t new_crop_rect = {.x = 0, .y = 0, .width = kWidth, .height = kHeight};
uint32_t frame_count = 0;
SetFrameCallback([this, new_crop_rect, &frame_count](const frame_available_info* info) {
CompareCroppedOutput(info);
resize_info_.crop = new_crop_rect;
if (++frame_count == 2)
sync_completion_signal(&completion_);
});
uint32_t resize_task;
zx_status_t status = ge2d_device_->Ge2dInitTaskResize(
&input_buffer_collection_, &output_buffer_collection_, &resize_info_,
&output_image_format_table_[0], output_image_format_table_, kImageFormatTableSize, 2,
&frame_callback_, &res_callback_, &remove_task_callback_, &resize_task);
EXPECT_OK(status);
status = ge2d_device_->Ge2dProcessFrame(resize_task, 0, 0);
EXPECT_OK(status);
ge2d_device_->Ge2dSetCropRect(resize_task, &new_crop_rect);
status = ge2d_device_->Ge2dProcessFrame(resize_task, 0, 0);
EXPECT_OK(status);
EXPECT_EQ(ZX_OK, sync_completion_wait(&completion_, ZX_TIME_INFINITE));
}
TEST_F(Ge2dDeviceTest, RemoveTask) {
SetupCallbacks();
SetupInput();
WriteScalingDataToVmo(input_buffer_collection_.buffers[0].vmo, output_image_format_table_[1]);
resize_info_.crop.x = 0;
resize_info_.crop.y = 0;
resize_info_.crop.width = kWidth / 2;
resize_info_.crop.height = kHeight / 2;
bool got_frame_callback = false;
SetFrameCallback([this, &got_frame_callback](const frame_available_info* info) {
CompareCroppedOutput(info);
got_frame_callback = true;
});
SetTaskRemovedCallback([this](const task_remove_status_t status) {
EXPECT_EQ(TASK_REMOVE_STATUS_OK, status);
sync_completion_signal(&completion_);
});
input_format_index_ = 1;
uint32_t resize_task;
zx_status_t status = ge2d_device_->Ge2dInitTaskResize(
&input_buffer_collection_, &output_buffer_collection_, &resize_info_,
&output_image_format_table_[1], output_image_format_table_, kImageFormatTableSize, 0,
&frame_callback_, &res_callback_, &remove_task_callback_, &resize_task);
EXPECT_OK(status);
status = ge2d_device_->Ge2dProcessFrame(resize_task, 0, 0);
EXPECT_OK(status);
ge2d_device_->Ge2dRemoveTask(resize_task);
EXPECT_EQ(ZX_OK, sync_completion_wait(&completion_, ZX_TIME_INFINITE));
EXPECT_TRUE(got_frame_callback);
status = ge2d_device_->Ge2dProcessFrame(resize_task, 0, 0);
EXPECT_NOT_OK(status);
}
// Test that a resize from an RGBA image to an RGBA image keeps everything
// except for setting alpha to 0xff.
TEST_F(Ge2dDeviceTest, RgbaToRgba) {
SetupCallbacks();
SetupInput(fuchsia_sysmem_PixelFormatType_R8G8B8A8, fuchsia_sysmem_PixelFormatType_R8G8B8A8);
WriteConstantRgbaToVmo(input_buffer_collection_.buffers[0].vmo, 1, 2, 3, 4,
output_image_format_table_[0]);
SetFrameCallback([this](const frame_available_info* info) {
fprintf(stderr, "Got completed conversion\n");
zx_handle_t vmo_b = output_buffer_collection_.buffers[info->buffer_id].vmo;
CacheInvalidateVmo(vmo_b);
fzl::VmoMapper mapper_b;
ASSERT_OK(mapper_b.Map(*zx::unowned_vmo(vmo_b), 0, 0, ZX_VM_PERM_READ));
uint8_t* output = static_cast<uint8_t*>(mapper_b.start());
// R
EXPECT_EQ(1, output[0]);
// G
EXPECT_EQ(2, output[1]);
// B
EXPECT_EQ(3, output[2]);
// A is forced to be 0xff.
EXPECT_EQ(0xff, output[3]);
sync_completion_signal(&completion_);
});
uint32_t resize_task;
zx_status_t status = ge2d_device_->Ge2dInitTaskResize(
&input_buffer_collection_, &output_buffer_collection_, &resize_info_,
&output_image_format_table_[0], output_image_format_table_, kImageFormatTableSize, 0,
&frame_callback_, &res_callback_, &remove_task_callback_, &resize_task);
EXPECT_OK(status);
status = ge2d_device_->Ge2dProcessFrame(resize_task, 0, 0);
EXPECT_OK(status);
EXPECT_EQ(ZX_OK, sync_completion_wait(&completion_, ZX_TIME_INFINITE));
}
static void DuplicateWatermarkInfo(const water_mark_info_t& input, const zx::vmo& vmo,
uint32_t count, std::vector<water_mark_info_t>* output) {
for (uint32_t i = 0; i < count; i++) {
output->push_back(input);
output->back().watermark_vmo = vmo.get();
}
}
// Test that a watermark with 0 alpha doesn't change the input (when copying RGBA to RGBA)
TEST_F(Ge2dDeviceTest, RGBABlankWatermark) {
SetupCallbacks();
SetupInput(fuchsia_sysmem_PixelFormatType_R8G8B8A8, fuchsia_sysmem_PixelFormatType_R8G8B8A8);
SetupWatermarkInfo();
WriteConstantRgbaToVmo(input_buffer_collection_.buffers[0].vmo, 0x00, 0xff, 0x00, 0xff,
output_image_format_table_[0]);
SetFrameCallback([this](const frame_available_info* info) {
zx_handle_t vmo_b = output_buffer_collection_.buffers[info->buffer_id].vmo;
CacheInvalidateVmo(vmo_b);
fzl::VmoMapper mapper_b;
ASSERT_OK(mapper_b.Map(*zx::unowned_vmo(vmo_b), 0, 0, ZX_VM_PERM_READ));
uint8_t* output = GetPointerToPixel(mapper_b.start(), output_image_format_table_[0],
kWatermarkHorizontalOffset, kWatermarkVerticalOffset);
// Should match the background color from above.
// R
EXPECT_EQ(0x0, output[0]);
// G
EXPECT_EQ(0xff, output[1]);
// B
EXPECT_EQ(0x00, output[2]);
// A
EXPECT_EQ(0xff, output[3]);
sync_completion_signal(&completion_);
});
// Set red to > alpha, to ensure we don't add it in.
zx::vmo watermark_vmo = CreateWatermarkVmo();
WriteConstantRgbaToVmo(watermark_vmo.get(), 0xff, 0, 0, 0x00, watermark_info_.wm_image_format);
std::vector<water_mark_info_t> duplicated;
DuplicateWatermarkInfo(watermark_info_, watermark_vmo, kImageFormatTableSize, &duplicated);
uint32_t watermark_task;
zx_status_t status = ge2d_device_->Ge2dInitTaskWaterMark(
&input_buffer_collection_, &output_buffer_collection_, duplicated.data(), duplicated.size(),
output_image_format_table_, kImageFormatTableSize, 0, &frame_callback_, &res_callback_,
&remove_task_callback_, &watermark_task);
EXPECT_OK(status);
status = ge2d_device_->Ge2dProcessFrame(watermark_task, 0, 0);
EXPECT_OK(status);
EXPECT_EQ(ZX_OK, sync_completion_wait(&completion_, ZX_TIME_INFINITE));
}
// Test that a semi-transparent changes colors in the expected way (when copying RGBA to RGBA).
TEST_F(Ge2dDeviceTest, RGBARedWatermark) {
SetupCallbacks();
SetupInput(fuchsia_sysmem_PixelFormatType_R8G8B8A8, fuchsia_sysmem_PixelFormatType_R8G8B8A8);
SetupWatermarkInfo();
WriteConstantRgbaToVmo(input_buffer_collection_.buffers[0].vmo, 0, 0xff, 0, 0,
output_image_format_table_[0]);
SetFrameCallback([this](const frame_available_info* info) {
zx_handle_t vmo_b = output_buffer_collection_.buffers[info->buffer_id].vmo;
CacheInvalidateVmo(vmo_b);
fzl::VmoMapper mapper_b;
ASSERT_OK(mapper_b.Map(*zx::unowned_vmo(vmo_b), 0, 0, ZX_VM_PERM_READ));
uint8_t* output = GetPointerToPixel(mapper_b.start(), output_image_format_table_[0],
kWatermarkHorizontalOffset, kWatermarkVerticalOffset);
// Should be an alpha-blended version of both images.
// R
EXPECT_EQ(0x7f, output[0]);
// G
EXPECT_EQ(0x80, output[1]);
// B
EXPECT_EQ(0x00, output[2]);
// A
EXPECT_EQ(0xff, output[3]);
sync_completion_signal(&completion_);
});
zx::vmo watermark_vmo = CreateWatermarkVmo();
WriteConstantRgbaToVmo(watermark_vmo.get(), 0xff, 0, 0, 0x7f, watermark_info_.wm_image_format);
std::vector<water_mark_info_t> duplicated;
DuplicateWatermarkInfo(watermark_info_, watermark_vmo, kImageFormatTableSize, &duplicated);
uint32_t watermark_task;
zx_status_t status = ge2d_device_->Ge2dInitTaskWaterMark(
&input_buffer_collection_, &output_buffer_collection_, duplicated.data(), duplicated.size(),
output_image_format_table_, kImageFormatTableSize, 0, &frame_callback_, &res_callback_,
&remove_task_callback_, &watermark_task);
EXPECT_OK(status);
status = ge2d_device_->Ge2dProcessFrame(watermark_task, 0, 0);
EXPECT_OK(status);
EXPECT_EQ(ZX_OK, sync_completion_wait(&completion_, ZX_TIME_INFINITE));
}
// Simple test that a watermark the same color as the input keeps the output color the same.
TEST_F(Ge2dDeviceTest, SameColorWatermark) {
SetupCallbacks();
SetupInput();
SetupWatermarkInfo();
// Pure red in YUV.
WriteConstantColorToVmo(input_buffer_collection_.buffers[0].vmo, 82, 90, 240,
output_image_format_table_[0]);
SetFrameCallback([this](const frame_available_info* info) {
// Red in input and output may be slightly different.
CompareCroppedOutput(info, 1.0f);
sync_completion_signal(&completion_);
});
zx::vmo watermark_vmo = CreateWatermarkVmo();
WriteConstantRgbaToVmo(watermark_vmo.get(), 0xff, 0, 0, 0xff, watermark_info_.wm_image_format);
std::vector<water_mark_info_t> duplicated;
DuplicateWatermarkInfo(watermark_info_, watermark_vmo, kImageFormatTableSize, &duplicated);
uint32_t watermark_task;
zx_status_t status = ge2d_device_->Ge2dInitTaskWaterMark(
&input_buffer_collection_, &output_buffer_collection_, duplicated.data(), duplicated.size(),
output_image_format_table_, kImageFormatTableSize, 0, &frame_callback_, &res_callback_,
&remove_task_callback_, &watermark_task);
EXPECT_OK(status);
status = ge2d_device_->Ge2dProcessFrame(watermark_task, 0, 0);
EXPECT_OK(status);
EXPECT_EQ(ZX_OK, sync_completion_wait(&completion_, ZX_TIME_INFINITE));
}
TEST_F(Ge2dDeviceTest, NewColorWatermark) {
SetupCallbacks();
SetupInput();
SetupWatermarkInfo();
// Pure red in YUV.
WriteConstantColorToVmo(input_buffer_collection_.buffers[0].vmo, 82, 90, 240,
output_image_format_table_[0]);
SetFrameCallback([this](const frame_available_info* info) {
zx_handle_t vmo_a = input_buffer_collection_.buffers[0].vmo;
zx_handle_t vmo_b = output_buffer_collection_.buffers[info->buffer_id].vmo;
image_format_2_t& format = output_image_format_table_[0];
CacheInvalidateVmo(vmo_a);
CacheInvalidateVmo(vmo_b);
fzl::VmoMapper mapper_a;
ASSERT_OK(mapper_a.Map(*zx::unowned_vmo(vmo_a), 0, 0, ZX_VM_PERM_READ));
fzl::VmoMapper mapper_b;
ASSERT_OK(mapper_b.Map(*zx::unowned_vmo(vmo_b), 0, 0, ZX_VM_PERM_READ));
// Just check the area above the watermark to make sure it's the same.
CheckSubPlaneEqual(mapper_a.start(), mapper_b.start(), 0, 0, format.bytes_per_row,
format.bytes_per_row, format.coded_width, 1, kWatermarkVerticalOffset, 1.0f,
1.0f, 0, "Y");
uint32_t uv_offset = format.bytes_per_row * format.coded_height;
CheckSubPlaneEqual(mapper_a.start(), mapper_b.start(), uv_offset, uv_offset,
format.bytes_per_row, format.bytes_per_row, format.coded_width, 2,
kWatermarkVerticalOffset / 2, 1.0f, 1.0f, 0, "UV");
CheckYUVRegion(mapper_b.start(), format, 144, 54, 34, kWatermarkHorizontalOffset,
kWatermarkWidth, kWatermarkVerticalOffset, kWatermarkHeight);
sync_completion_signal(&completion_);
});
zx::vmo watermark_vmo = CreateWatermarkVmo();
WriteConstantRgbaToVmo(watermark_vmo.get(), 0, 0xff, 0, 0xff, watermark_info_.wm_image_format);
std::vector<water_mark_info_t> duplicated;
DuplicateWatermarkInfo(watermark_info_, watermark_vmo, kImageFormatTableSize, &duplicated);
uint32_t watermark_task;
zx_status_t status = ge2d_device_->Ge2dInitTaskWaterMark(
&input_buffer_collection_, &output_buffer_collection_, duplicated.data(), duplicated.size(),
output_image_format_table_, kImageFormatTableSize, 0, &frame_callback_, &res_callback_,
&remove_task_callback_, &watermark_task);
EXPECT_OK(status);
status = ge2d_device_->Ge2dProcessFrame(watermark_task, 0, 0);
EXPECT_OK(status);
EXPECT_EQ(ZX_OK, sync_completion_wait(&completion_, ZX_TIME_INFINITE));
}
// Test that a watermark with 0 alpha doesn't change the input (when copying YUV to YUV)
TEST_F(Ge2dDeviceTest, YUVBlankWatermark) {
SetupCallbacks();
SetupInput();
SetupWatermarkInfo();
// Pure red in YUV.
WriteConstantColorToVmo(input_buffer_collection_.buffers[0].vmo, 82, 90, 240,
output_image_format_table_[0]);
SetFrameCallback([this](const frame_available_info* info) {
zx_handle_t vmo_b = output_buffer_collection_.buffers[info->buffer_id].vmo;
image_format_2_t& format = output_image_format_table_[0];
CacheInvalidateVmo(vmo_b);
fzl::VmoMapper mapper_b;
ASSERT_OK(mapper_b.Map(*zx::unowned_vmo(vmo_b), 0, 0, ZX_VM_PERM_READ));
CheckYUVRegion(mapper_b.start(), format, 82, 90, 240, kWatermarkHorizontalOffset,
kWatermarkWidth, kWatermarkVerticalOffset, kWatermarkHeight);
sync_completion_signal(&completion_);
});
// Set red to > alpha, to ensure we don't add it in.
zx::vmo watermark_vmo = CreateWatermarkVmo();
WriteConstantRgbaToVmo(watermark_vmo.get(), 0xff, 0, 0, 0x00, watermark_info_.wm_image_format);
std::vector<water_mark_info_t> duplicated;
DuplicateWatermarkInfo(watermark_info_, watermark_vmo, kImageFormatTableSize, &duplicated);
uint32_t watermark_task;
zx_status_t status = ge2d_device_->Ge2dInitTaskWaterMark(
&input_buffer_collection_, &output_buffer_collection_, duplicated.data(), duplicated.size(),
output_image_format_table_, kImageFormatTableSize, 0, &frame_callback_, &res_callback_,
&remove_task_callback_, &watermark_task);
EXPECT_OK(status);
status = ge2d_device_->Ge2dProcessFrame(watermark_task, 0, 0);
EXPECT_OK(status);
EXPECT_EQ(ZX_OK, sync_completion_wait(&completion_, ZX_TIME_INFINITE));
}
// Try switching to size 1 and ensuring the watermark is used correctly.
TEST_F(Ge2dDeviceTest, WatermarkOutputSize) {
SetupCallbacks();
SetupInput();
SetupWatermarkInfo();
uint32_t resolution_changed_count = 0;
SetResolutionChangedCallback([&resolution_changed_count](const frame_available_info* info) {
++resolution_changed_count;
});
// Pure red in YUV.
WriteConstantColorToVmo(input_buffer_collection_.buffers[0].vmo, 82, 90, 240,
output_image_format_table_[1]);
static constexpr uint32_t kSecondWatermarkOffset = 4;
SetFrameCallback([this](const frame_available_info* info) {
zx_handle_t vmo_a = input_buffer_collection_.buffers[0].vmo;
zx_handle_t vmo_b = output_buffer_collection_.buffers[info->buffer_id].vmo;
image_format_2_t& format = output_image_format_table_[1];
CacheInvalidateVmo(vmo_a);
CacheInvalidateVmo(vmo_b);
fzl::VmoMapper mapper_a;
ASSERT_OK(mapper_a.Map(*zx::unowned_vmo(vmo_a), 0, 0, ZX_VM_PERM_READ));
fzl::VmoMapper mapper_b;
ASSERT_OK(mapper_b.Map(*zx::unowned_vmo(vmo_b), 0, 0, ZX_VM_PERM_READ));
// Just check the area above the watermark to make sure it's the same.
CheckSubPlaneEqual(mapper_a.start(), mapper_b.start(), 0, 0, format.bytes_per_row,
format.bytes_per_row, format.coded_width, 1, kSecondWatermarkOffset, 1.0f,
1.0f, 0, "Y");
uint32_t uv_offset = format.bytes_per_row * format.coded_height;
CheckSubPlaneEqual(mapper_a.start(), mapper_b.start(), uv_offset, uv_offset,
format.bytes_per_row, format.bytes_per_row, format.coded_width, 2,
kSecondWatermarkOffset / 2, 1.0f, 1.0f, 0, "UV");
CheckYUVRegion(mapper_b.start(), format, 144, 54, 34, kSecondWatermarkOffset, kWatermarkWidth,
kSecondWatermarkOffset, kWatermarkHeight);
sync_completion_signal(&completion_);
});
zx::vmo watermark_vmo = CreateWatermarkVmo();
WriteConstantRgbaToVmo(watermark_vmo.get(), 0, 0xff, 0, 0xff, watermark_info_.wm_image_format);
std::vector<water_mark_info_t> duplicated;
DuplicateWatermarkInfo(watermark_info_, watermark_vmo, kImageFormatTableSize, &duplicated);
duplicated[1].loc_x = kSecondWatermarkOffset;
duplicated[1].loc_y = kSecondWatermarkOffset;
uint32_t watermark_task;
zx_status_t status = ge2d_device_->Ge2dInitTaskWaterMark(
&input_buffer_collection_, &output_buffer_collection_, duplicated.data(), duplicated.size(),
output_image_format_table_, kImageFormatTableSize, 0, &frame_callback_, &res_callback_,
&remove_task_callback_, &watermark_task);
EXPECT_OK(status);
status = ge2d_device_->Ge2dSetInputAndOutputResolution(watermark_task, 1);
EXPECT_OK(status);
status = ge2d_device_->Ge2dProcessFrame(watermark_task, 0, 0);
EXPECT_OK(status);
EXPECT_EQ(ZX_OK, sync_completion_wait(&completion_, ZX_TIME_INFINITE));
EXPECT_EQ(1u, resolution_changed_count);
}
TEST_F(Ge2dDeviceTest, GlobalAlphaWatermark) {
SetupCallbacks();
SetupInput();
SetupWatermarkInfo();
watermark_info_.global_alpha = 0.5f;
// Pure red in YUV.
WriteConstantColorToVmo(input_buffer_collection_.buffers[0].vmo, 82, 90, 240,
output_image_format_table_[0]);
SetFrameCallback([this](const frame_available_info* info) {
zx_handle_t vmo_b = output_buffer_collection_.buffers[info->buffer_id].vmo;
image_format_2_t& format = output_image_format_table_[0];
CacheInvalidateVmo(vmo_b);
fzl::VmoMapper mapper_b;
ASSERT_OK(mapper_b.Map(*zx::unowned_vmo(vmo_b), 0, 0, ZX_VM_PERM_READ));
// Blend of 50% red and 50% green.
CheckYUVRegion(mapper_b.start(), format, 113, 72, 137, kWatermarkHorizontalOffset,
kWatermarkWidth, kWatermarkVerticalOffset, kWatermarkHeight);
sync_completion_signal(&completion_);
});
zx::vmo watermark_vmo = CreateWatermarkVmo();
WriteConstantRgbaToVmo(watermark_vmo.get(), 0, 0xff, 0, 0xff, watermark_info_.wm_image_format);
std::vector<water_mark_info_t> duplicated;
DuplicateWatermarkInfo(watermark_info_, watermark_vmo, kImageFormatTableSize, &duplicated);
uint32_t watermark_task;
zx_status_t status = ge2d_device_->Ge2dInitTaskWaterMark(
&input_buffer_collection_, &output_buffer_collection_, duplicated.data(), duplicated.size(),
output_image_format_table_, kImageFormatTableSize, 0, &frame_callback_, &res_callback_,
&remove_task_callback_, &watermark_task);
EXPECT_OK(status);
status = ge2d_device_->Ge2dProcessFrame(watermark_task, 0, 0);
EXPECT_OK(status);
EXPECT_EQ(ZX_OK, sync_completion_wait(&completion_, ZX_TIME_INFINITE));
}
// Try switching the in-place watermark to size 1 and ensuring the watermark is used correctly.
TEST_F(Ge2dDeviceTest, InPlaceWatermarkOutputSize) {
SetupCallbacks();
SetupInput();
SetupWatermarkInfo();
uint32_t resolution_changed_count = 0;
SetResolutionChangedCallback([&resolution_changed_count](const frame_available_info* info) {
++resolution_changed_count;
});
// Pure red in YUV.
WriteConstantColorToVmo(input_buffer_collection_.buffers[1].vmo, 82, 90, 240,
output_image_format_table_[1]);
static constexpr uint32_t kSecondWatermarkOffset = 4;
SetFrameCallback([this](const frame_available_info* info) {
EXPECT_EQ(1u, info->buffer_id);
zx_handle_t vmo_a = input_buffer_collection_.buffers[info->buffer_id].vmo;
image_format_2_t& format = output_image_format_table_[1];
CacheInvalidateVmo(vmo_a);
fzl::VmoMapper mapper_a;
ASSERT_OK(mapper_a.Map(*zx::unowned_vmo(vmo_a), 0, 0, ZX_VM_PERM_READ));
// Check region above the watermark to ensure it hasn't changed.
CheckYUVRegion(mapper_a.start(), format, 82, 90, 240, 0, format.coded_width, 0,
kSecondWatermarkOffset);
CheckYUVRegion(mapper_a.start(), format, 144, 54, 34, kSecondWatermarkOffset, kWatermarkWidth,
kSecondWatermarkOffset, kWatermarkHeight);
sync_completion_signal(&completion_);
});
zx::vmo watermark_vmo = CreateWatermarkVmo();
WriteConstantRgbaToVmo(watermark_vmo.get(), 0, 0xff, 0, 0xff, watermark_info_.wm_image_format);
std::vector<water_mark_info_t> duplicated;
DuplicateWatermarkInfo(watermark_info_, watermark_vmo, kImageFormatTableSize, &duplicated);
duplicated[1].loc_x = kSecondWatermarkOffset;
duplicated[1].loc_y = kSecondWatermarkOffset;
uint32_t watermark_task;
zx_status_t status = ge2d_device_->Ge2dInitTaskInPlaceWaterMark(
&input_buffer_collection_, duplicated.data(), duplicated.size(), output_image_format_table_,
kImageFormatTableSize, 0, &frame_callback_, &res_callback_, &remove_task_callback_,
&watermark_task);
EXPECT_OK(status);
status = ge2d_device_->Ge2dSetInputAndOutputResolution(watermark_task, 1);
EXPECT_OK(status);
status = ge2d_device_->Ge2dProcessFrame(watermark_task, 1, 0);
EXPECT_OK(status);
EXPECT_EQ(ZX_OK, sync_completion_wait(&completion_, ZX_TIME_INFINITE));
EXPECT_EQ(1u, resolution_changed_count);
}
} // namespace
} // namespace ge2d