/*
* Copyright 2017 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <gtest/gtest.h>
#include <C2AllocatorIon.h>
#include <C2AllocatorGralloc.h>
#include <C2Buffer.h>
#include <C2BufferPriv.h>
#include <C2ParamDef.h>
#include <system/graphics.h>
namespace android {
class C2BufferUtilsTest : public ::testing::Test {
static void StaticSegmentTest() {
// constructor
static_assert(C2Segment(123u, 456u).offset == 123, "");
static_assert(C2Segment(123u, 456u).size == 456, "");
// empty
static_assert(!C2Segment(123u, 456u).isEmpty(), "");
static_assert(C2Segment(123u, 0u).isEmpty(), "");
// valid
static_assert(C2Segment(123u, 456u).isValid(), "");
static_assert(C2Segment(123u, ~123u).isValid(), "");
static_assert(!C2Segment(123u, 1 + ~123u).isValid(), "");
// bool()
static_assert(C2Segment(123u, 456u), "");
static_assert((bool)C2Segment(123u, ~123u), "");
static_assert(!bool(C2Segment(123u, 1 + ~123u)), "");
static_assert(!bool(C2Segment(123u, 0)), "");
// !
static_assert(!!C2Segment(123u, 456u), "");
static_assert(!!C2Segment(123u, ~123u), "");
static_assert(!C2Segment(123u, 1 + ~123u), "");
static_assert(!C2Segment(123u, 0), "");
// contains
static_assert(C2Segment(123u, ~123u).contains(C2Segment(123u, 0)), "");
static_assert(!C2Segment(123u, 1 + ~123u).contains(C2Segment(123u, 0)), "");
static_assert(C2Segment(123u, ~123u).contains(C2Segment(123u, ~123u)), "");
static_assert(!C2Segment(123u, ~123u).contains(C2Segment(123u, 1 + ~123u)), "");
static_assert(!C2Segment(123u, 1 + ~123u).contains(C2Segment(123u, 1 + ~123u)), "");
static_assert(!C2Segment(123u, ~123u).contains(C2Segment(122u, 2u)), "");
static_assert(C2Segment(123u, ~123u).contains(C2Segment(123u, 2u)), "");
static_assert(C2Segment(123u, 3u).contains(C2Segment(124u, 2u)), "");
static_assert(!C2Segment(123u, 3u).contains(C2Segment(125u, 2u)), "");
// ==
static_assert(C2Segment(123u, 456u) == C2Segment(123u, 456u), "");
static_assert(!(C2Segment(123u, 456u) == C2Segment(123u, 457u)), "");
static_assert(!(C2Segment(123u, 456u) == C2Segment(123u, 455u)), "");
static_assert(!(C2Segment(123u, 456u) == C2Segment(122u, 456u)), "");
static_assert(!(C2Segment(123u, 456u) == C2Segment(124u, 456u)), "");
static_assert(!(C2Segment(123u, 0u) == C2Segment(124u, 0u)), "");
static_assert(C2Segment(123u, 0u) == C2Segment(123u, 0u), "");
static_assert(C2Segment(123u, 1 + ~123u) == C2Segment(124u, 1 + ~124u), "");
// !=
static_assert(!(C2Segment(123u, 456u) != C2Segment(123u, 456u)), "");
static_assert(C2Segment(123u, 456u) != C2Segment(123u, 457u), "");
static_assert(C2Segment(123u, 456u) != C2Segment(123u, 455u), "");
static_assert(C2Segment(123u, 456u) != C2Segment(122u, 456u), "");
static_assert(C2Segment(123u, 456u) != C2Segment(124u, 456u), "");
static_assert(C2Segment(123u, 0u) != C2Segment(124u, 0u), "");
static_assert(!(C2Segment(123u, 0u) != C2Segment(123u, 0u)), "");
static_assert(!(C2Segment(123u, 1 + ~123u) != C2Segment(124u, 1 + ~124u)), "");
// <=
static_assert(C2Segment(123u, 456u) <= C2Segment(123u, 456u), "");
static_assert(C2Segment(123u, 456u) <= C2Segment(123u, 457u), "");
static_assert(C2Segment(123u, 456u) <= C2Segment(122u, 457u), "");
static_assert(!(C2Segment(123u, 457u) <= C2Segment(123u, 456u)), "");
static_assert(!(C2Segment(122u, 457u) <= C2Segment(123u, 456u)), "");
static_assert(!(C2Segment(123u, 457u) <= C2Segment(124u, 457u)), "");
static_assert(!(C2Segment(122u, 457u) <= C2Segment(123u, 457u)), "");
static_assert(!(C2Segment(122u, 0u) <= C2Segment(123u, 0u)), "");
static_assert(C2Segment(123u, 0u) <= C2Segment(122u, 1u), "");
static_assert(C2Segment(122u, 0u) <= C2Segment(122u, 1u), "");
static_assert(!(C2Segment(122u, ~122u) <= C2Segment(122u, 1 + ~122u)), "");
static_assert(!(C2Segment(122u, 1 + ~122u) <= C2Segment(122u, ~122u)), "");
static_assert(!(C2Segment(122u, 1 + ~122u) <= C2Segment(122u, 1 + ~122u)), "");
// <
static_assert(!(C2Segment(123u, 456u) < C2Segment(123u, 456u)), "");
static_assert(C2Segment(123u, 456u) < C2Segment(123u, 457u), "");
static_assert(C2Segment(123u, 456u) < C2Segment(122u, 457u), "");
static_assert(!(C2Segment(123u, 457u) < C2Segment(123u, 456u)), "");
static_assert(!(C2Segment(122u, 457u) < C2Segment(123u, 456u)), "");
static_assert(!(C2Segment(123u, 457u) < C2Segment(124u, 457u)), "");
static_assert(!(C2Segment(122u, 457u) < C2Segment(123u, 457u)), "");
static_assert(!(C2Segment(122u, 0u) < C2Segment(123u, 0u)), "");
static_assert(C2Segment(123u, 0u) < C2Segment(122u, 1u), "");
static_assert(C2Segment(122u, 0u) < C2Segment(122u, 1u), "");
static_assert(!(C2Segment(122u, ~122u) < C2Segment(122u, 1 + ~122u)), "");
static_assert(!(C2Segment(122u, 1 + ~122u) < C2Segment(122u, ~122u)), "");
static_assert(!(C2Segment(122u, 1 + ~122u) < C2Segment(122u, 1 + ~122u)), "");
// <=
static_assert(C2Segment(123u, 456u) >= C2Segment(123u, 456u), "");
static_assert(C2Segment(123u, 457u) >= C2Segment(123u, 456u), "");
static_assert(C2Segment(122u, 457u) >= C2Segment(123u, 456u), "");
static_assert(!(C2Segment(123u, 456u) >= C2Segment(123u, 457u)), "");
static_assert(!(C2Segment(123u, 456u) >= C2Segment(122u, 457u)), "");
static_assert(!(C2Segment(124u, 457u) >= C2Segment(123u, 457u)), "");
static_assert(!(C2Segment(123u, 457u) >= C2Segment(122u, 457u)), "");
static_assert(!(C2Segment(123u, 0u) >= C2Segment(122u, 0u)), "");
static_assert(C2Segment(122u, 1u) >= C2Segment(123u, 0u), "");
static_assert(C2Segment(122u, 1u) >= C2Segment(122u, 0u), "");
static_assert(!(C2Segment(122u, 1 + ~122u) >= C2Segment(122u, ~122u)), "");
static_assert(!(C2Segment(122u, ~122u) >= C2Segment(122u, 1 + ~122u)), "");
static_assert(!(C2Segment(122u, 1 + ~122u) >= C2Segment(122u, 1 + ~122u)), "");
// <
static_assert(!(C2Segment(123u, 456u) > C2Segment(123u, 456u)), "");
static_assert(C2Segment(123u, 457u) > C2Segment(123u, 456u), "");
static_assert(C2Segment(122u, 457u) > C2Segment(123u, 456u), "");
static_assert(!(C2Segment(123u, 456u) > C2Segment(123u, 457u)), "");
static_assert(!(C2Segment(123u, 456u) > C2Segment(122u, 457u)), "");
static_assert(!(C2Segment(124u, 457u) > C2Segment(123u, 457u)), "");
static_assert(!(C2Segment(123u, 457u) > C2Segment(122u, 457u)), "");
static_assert(!(C2Segment(123u, 0u) > C2Segment(122u, 0u)), "");
static_assert(C2Segment(122u, 1u) > C2Segment(123u, 0u), "");
static_assert(C2Segment(122u, 1u) > C2Segment(122u, 0u), "");
static_assert(!(C2Segment(122u, 1 + ~122u) > C2Segment(122u, ~122u)), "");
static_assert(!(C2Segment(122u, ~122u) > C2Segment(122u, 1 + ~122u)), "");
static_assert(!(C2Segment(122u, 1 + ~122u) > C2Segment(122u, 1 + ~122u)), "");
// end
static_assert(C2Segment(123u, 456u).end() == 579u, "");
static_assert(C2Segment(123u, 0u).end() == 123u, "");
static_assert(C2Segment(123u, ~123u).end() == 0xffffffffu, "");
static_assert(C2Segment(123u, 1 + ~123u).end() == 0u, "");
// intersect
static_assert(C2Segment(123u, 456u).intersect(C2Segment(123u, 456u)) == C2Segment(123u, 456u), "");
static_assert(C2Segment(123u, 456u).intersect(C2Segment(123u, 460u)) == C2Segment(123u, 456u), "");
static_assert(C2Segment(123u, 456u).intersect(C2Segment(124u, 460u)) == C2Segment(124u, 455u), "");
static_assert(C2Segment(123u, 456u).intersect(C2Segment(579u, 460u)) == C2Segment(579u, 0u), "");
static_assert(C2Segment(123u, 456u).intersect(C2Segment(589u, 460u)) == C2Segment(589u, ~9u /* -10 */), "");
static_assert(C2Segment(123u, 456u).intersect(C2Segment(123u, 455u)) == C2Segment(123u, 455u), "");
static_assert(C2Segment(123u, 456u).intersect(C2Segment(122u, 456u)) == C2Segment(123u, 455u), "");
static_assert(C2Segment(123u, 456u).intersect(C2Segment(0u, 123u)) == C2Segment(123u, 0u), "");
static_assert(C2Segment(123u, 456u).intersect(C2Segment(0u, 0u)) == C2Segment(123u, ~122u /* -123 */), "");
// normalize (change invalid segments to empty segments)
static_assert(C2Segment(123u, 456u).normalize() == C2Segment(123u, 456u), "");
static_assert(C2Segment(123u, ~123u).normalize() == C2Segment(123u, ~123u), "");
static_assert(C2Segment(123u, 1 + ~123u).normalize() == C2Segment(123u, 0u), "");
// note: normalize cannot be used to make this work
static_assert(C2Segment(123u, 456u).intersect(C2Segment(150u, ~150u)).normalize() == C2Segment(150u, 429u), "");
static_assert(C2Segment(123u, 456u).intersect(C2Segment(150u, 1 + ~150u)).normalize() != C2Segment(150u, 429u), "");
static_assert(C2Segment(123u, 456u).intersect(C2Segment(150u, 1 + ~150u)).normalize() == C2Segment(150u, 0u), "");
// saturate (change invalid segments to full segments up to max)
static_assert(C2Segment(123u, 456u).saturate() == C2Segment(123u, 456u), "");
static_assert(C2Segment(123u, ~123u).saturate() == C2Segment(123u, ~123u), "");
static_assert(C2Segment(123u, 1 + ~123u).saturate() == C2Segment(123u, ~123u), "");
// note: saturate can be used to make this work but only partially
static_assert(C2Segment(123u, 456u).intersect(C2Segment(150u, 1 + ~150u).saturate()).normalize() == C2Segment(150u, 429u), "");
static_assert(C2Segment(123u, 456u).intersect(C2Segment(0u, 100u).saturate()).normalize() == C2Segment(123u, 0u), "");
static_assert(C2Segment(123u, 456u).intersect(C2Segment(1000u, 100u).saturate()).normalize() != C2Segment(579u, 0u), "");
static_assert(C2Segment(123u, 456u).intersect(C2Segment(1000u, 100u).saturate()).normalize() == C2Segment(1000u, 0u), "");
}
static void StaticLinearRangeAndCapacityTest() {
class TestCapacity : public _C2LinearCapacityAspect {
using _C2LinearCapacityAspect::_C2LinearCapacityAspect;
friend class C2BufferUtilsTest;
};
class TestRange : public _C2LinearRangeAspect {
using _C2LinearRangeAspect::_C2LinearRangeAspect;
friend class C2BufferUtilsTest;
};
// _C2LinearCapacityAspect
static_assert(TestCapacity(0u).capacity() == 0u, "");
constexpr TestCapacity cap(123u);
static_assert(TestCapacity(&cap).capacity() == 123u, "");
static_assert(TestCapacity(nullptr).capacity() == 0u, "");
// _C2LinearCapacityRange
static_assert(TestRange(&cap).capacity() == 123u, "");
static_assert(TestRange(&cap).offset() == 0u, "");
static_assert(TestRange(&cap).size() == 123u, "");
static_assert(TestRange(&cap).endOffset() == 123u, "");
constexpr TestRange range(&cap, 50u, 100u);
static_assert(range.capacity() == 123u, "");
static_assert(range.offset() == 50u, "");
static_assert(range.size() == 73u, "");
static_assert(range.endOffset() == 123u, "");
static_assert(TestRange(&cap, 20u, 30u).capacity() == 123u, "");
static_assert(TestRange(&cap, 20u, 30u).offset() == 20u, "");
static_assert(TestRange(&cap, 20u, 30u).size() == 30u, "");
static_assert(TestRange(&cap, 20u, 30u).endOffset() == 50u, "");
static_assert(TestRange(&cap, 200u, 30u).capacity() == 123u, "");
static_assert(TestRange(&cap, 200u, 30u).offset() == 123u, "");
static_assert(TestRange(&cap, 200u, 30u).size() == 0u, "");
static_assert(TestRange(&cap, 200u, 30u).endOffset() == 123u, "");
}
};
class C2BufferTest : public ::testing::Test {
public:
C2BufferTest()
: mBlockPoolId(C2BlockPool::PLATFORM_START),
mLinearAllocator(std::make_shared<C2AllocatorIon>('i')),
mSize(0u),
mAddr(nullptr),
mGraphicAllocator(std::make_shared<C2AllocatorGralloc>('g')) {
}
~C2BufferTest() = default;
void allocateLinear(size_t capacity) {
c2_status_t err = mLinearAllocator->newLinearAllocation(
capacity,
{ C2MemoryUsage::CPU_READ, C2MemoryUsage::CPU_WRITE },
&mLinearAllocation);
if (err != C2_OK) {
mLinearAllocation.reset();
FAIL() << "C2Allocator::newLinearAllocation() failed: " << err;
}
}
void mapLinear(size_t offset, size_t size, uint8_t **addr) {
ASSERT_TRUE(mLinearAllocation);
c2_status_t err = mLinearAllocation->map(
offset,
size,
{ C2MemoryUsage::CPU_READ, C2MemoryUsage::CPU_WRITE },
// TODO: fence
nullptr,
&mAddr);
if (err != C2_OK) {
mAddr = nullptr;
FAIL() << "C2LinearAllocation::map() failed: " << err;
}
ASSERT_NE(nullptr, mAddr);
mSize = size;
*addr = (uint8_t *)mAddr;
}
void unmapLinear() {
ASSERT_TRUE(mLinearAllocation);
ASSERT_NE(nullptr, mAddr);
ASSERT_NE(0u, mSize);
// TODO: fence
ASSERT_EQ(C2_OK, mLinearAllocation->unmap(mAddr, mSize, nullptr));
mSize = 0u;
mAddr = nullptr;
}
std::shared_ptr<C2BlockPool> makeLinearBlockPool() {
return std::make_shared<C2PooledBlockPool>(mLinearAllocator, mBlockPoolId++);
}
void allocateGraphic(uint32_t width, uint32_t height) {
c2_status_t err = mGraphicAllocator->newGraphicAllocation(
width,
height,
HAL_PIXEL_FORMAT_YCBCR_420_888,
{ C2MemoryUsage::CPU_READ, C2MemoryUsage::CPU_WRITE },
&mGraphicAllocation);
if (err != C2_OK) {
mGraphicAllocation.reset();
FAIL() << "C2Allocator::newGraphicAllocation() failed: " << err;
}
}
void mapGraphic(C2Rect rect, C2PlanarLayout *layout, uint8_t **addr) {
ASSERT_TRUE(mGraphicAllocation);
c2_status_t err = mGraphicAllocation->map(
rect,
{ C2MemoryUsage::CPU_READ, C2MemoryUsage::CPU_WRITE },
// TODO: fence
nullptr,
layout,
addr);
if (err != C2_OK) {
addr[C2PlanarLayout::PLANE_Y] = nullptr;
addr[C2PlanarLayout::PLANE_U] = nullptr;
addr[C2PlanarLayout::PLANE_V] = nullptr;
FAIL() << "C2GraphicAllocation::map() failed: " << err;
}
mMappedRect = rect;
memcpy(mAddrGraphic, addr, sizeof(uint8_t*) * C2PlanarLayout::MAX_NUM_PLANES);
}
void unmapGraphic() {
ASSERT_TRUE(mGraphicAllocation);
// TODO: fence
ASSERT_EQ(C2_OK, mGraphicAllocation->unmap(mAddrGraphic, mMappedRect, nullptr));
}
std::shared_ptr<C2BlockPool> makeGraphicBlockPool() {
return std::make_shared<C2BasicGraphicBlockPool>(mGraphicAllocator);
}
private:
C2BlockPool::local_id_t mBlockPoolId;
std::shared_ptr<C2Allocator> mLinearAllocator;
std::shared_ptr<C2LinearAllocation> mLinearAllocation;
size_t mSize;
void *mAddr;
C2Rect mMappedRect;
uint8_t* mAddrGraphic[C2PlanarLayout::MAX_NUM_PLANES];
std::shared_ptr<C2Allocator> mGraphicAllocator;
std::shared_ptr<C2GraphicAllocation> mGraphicAllocation;
};
TEST_F(C2BufferTest, LinearAllocationTest) {
constexpr size_t kCapacity = 1024u * 1024u;
allocateLinear(kCapacity);
uint8_t *addr = nullptr;
mapLinear(0u, kCapacity, &addr);
ASSERT_NE(nullptr, addr);
for (size_t i = 0; i < kCapacity; ++i) {
addr[i] = i % 100u;
}
unmapLinear();
addr = nullptr;
mapLinear(kCapacity / 3, kCapacity / 3, &addr);
ASSERT_NE(nullptr, addr);
for (size_t i = 0; i < kCapacity / 3; ++i) {
ASSERT_EQ((i + kCapacity / 3) % 100, addr[i]) << " at i = " << i;
}
}
TEST_F(C2BufferTest, BlockPoolTest) {
constexpr size_t kCapacity = 1024u * 1024u;
std::shared_ptr<C2BlockPool> blockPool(makeLinearBlockPool());
std::shared_ptr<C2LinearBlock> block;
ASSERT_EQ(C2_OK, blockPool->fetchLinearBlock(
kCapacity,
{ C2MemoryUsage::CPU_READ, C2MemoryUsage::CPU_WRITE },
&block));
ASSERT_TRUE(block);
C2Acquirable<C2WriteView> writeViewHolder = block->map();
C2WriteView writeView = writeViewHolder.get();
ASSERT_EQ(C2_OK, writeView.error());
ASSERT_EQ(kCapacity, writeView.capacity());
ASSERT_EQ(0u, writeView.offset());
ASSERT_EQ(kCapacity, writeView.size());
uint8_t *data = writeView.data();
ASSERT_NE(nullptr, data);
for (size_t i = 0; i < writeView.size(); ++i) {
data[i] = i % 100u;
}
writeView.setOffset(kCapacity / 3);
data = writeView.data();
ASSERT_NE(nullptr, data);
for (size_t i = 0; i < writeView.size(); ++i) {
ASSERT_EQ((i + kCapacity / 3) % 100u, data[i]) << " at i = " << i
<< "; data = " << static_cast<void *>(data);
}
C2Fence fence;
C2ConstLinearBlock constBlock = block->share(
kCapacity / 3, kCapacity / 3, fence);
C2Acquirable<C2ReadView> readViewHolder = constBlock.map();
C2ReadView readView = readViewHolder.get();
ASSERT_EQ(C2_OK, readView.error());
ASSERT_EQ(kCapacity / 3, readView.capacity());
// TODO: fence
const uint8_t *constData = readView.data();
ASSERT_NE(nullptr, constData);
for (size_t i = 0; i < readView.capacity(); ++i) {
ASSERT_EQ((i + kCapacity / 3) % 100u, constData[i]) << " at i = " << i
<< "; data = " << static_cast<void *>(data)
<< "; constData = " << static_cast<const void *>(constData);
}
readView = readView.subView(333u, 100u);
ASSERT_EQ(C2_OK, readView.error());
ASSERT_EQ(100u, readView.capacity());
constData = readView.data();
ASSERT_NE(nullptr, constData);
for (size_t i = 0; i < readView.capacity(); ++i) {
ASSERT_EQ((i + 333u + kCapacity / 3) % 100u, constData[i]) << " at i = " << i;
}
}
void fillPlane(const C2Rect rect, const C2PlaneInfo info, uint8_t *addr, uint8_t value) {
for (uint32_t row = 0; row < rect.height / info.rowSampling; ++row) {
int32_t rowOffset = (row + rect.top / info.rowSampling) * info.rowInc;
for (uint32_t col = 0; col < rect.width / info.colSampling; ++col) {
int32_t colOffset = (col + rect.left / info.colSampling) * info.colInc;
addr[rowOffset + colOffset] = value;
}
}
}
bool verifyPlane(const C2Rect rect, const C2PlaneInfo info, const uint8_t *addr, uint8_t value) {
for (uint32_t row = 0; row < rect.height / info.rowSampling; ++row) {
int32_t rowOffset = (row + rect.top / info.rowSampling) * info.rowInc;
for (uint32_t col = 0; col < rect.width / info.colSampling; ++col) {
int32_t colOffset = (col + rect.left / info.colSampling) * info.colInc;
if (addr[rowOffset + colOffset] != value) {
return false;
}
}
}
return true;
}
TEST_F(C2BufferTest, GraphicAllocationTest) {
constexpr uint32_t kWidth = 320;
constexpr uint32_t kHeight = 240;
allocateGraphic(kWidth, kHeight);
uint8_t *addr[C2PlanarLayout::MAX_NUM_PLANES];
C2Rect rect(kWidth, kHeight);
C2PlanarLayout layout;
mapGraphic(rect, &layout, addr);
ASSERT_NE(nullptr, addr[C2PlanarLayout::PLANE_Y]);
ASSERT_NE(nullptr, addr[C2PlanarLayout::PLANE_U]);
ASSERT_NE(nullptr, addr[C2PlanarLayout::PLANE_V]);
uint8_t *y = addr[C2PlanarLayout::PLANE_Y];
C2PlaneInfo yInfo = layout.planes[C2PlanarLayout::PLANE_Y];
uint8_t *u = addr[C2PlanarLayout::PLANE_U];
C2PlaneInfo uInfo = layout.planes[C2PlanarLayout::PLANE_U];
uint8_t *v = addr[C2PlanarLayout::PLANE_V];
C2PlaneInfo vInfo = layout.planes[C2PlanarLayout::PLANE_V];
fillPlane(rect, yInfo, y, 0);
fillPlane(rect, uInfo, u, 0);
fillPlane(rect, vInfo, v, 0);
fillPlane(C2Rect(kWidth / 2, kHeight / 2).at(kWidth / 4, kHeight / 4), yInfo, y, 0x12);
fillPlane(C2Rect(kWidth / 2, kHeight / 2).at(kWidth / 4, kHeight / 4), uInfo, u, 0x34);
fillPlane(C2Rect(kWidth / 2, kHeight / 2).at(kWidth / 4, kHeight / 4), vInfo, v, 0x56);
unmapGraphic();
mapGraphic(rect, &layout, addr);
ASSERT_NE(nullptr, addr[C2PlanarLayout::PLANE_Y]);
ASSERT_NE(nullptr, addr[C2PlanarLayout::PLANE_U]);
ASSERT_NE(nullptr, addr[C2PlanarLayout::PLANE_V]);
y = addr[C2PlanarLayout::PLANE_Y];
yInfo = layout.planes[C2PlanarLayout::PLANE_Y];
u = addr[C2PlanarLayout::PLANE_U];
uInfo = layout.planes[C2PlanarLayout::PLANE_U];
v = addr[C2PlanarLayout::PLANE_V];
vInfo = layout.planes[C2PlanarLayout::PLANE_V];
ASSERT_TRUE(verifyPlane(C2Rect(kWidth / 2, kHeight / 2).at(kWidth / 4, kHeight / 4), yInfo, y, 0x12));
ASSERT_TRUE(verifyPlane(C2Rect(kWidth / 2, kHeight / 2).at(kWidth / 4, kHeight / 4), uInfo, u, 0x34));
ASSERT_TRUE(verifyPlane(C2Rect(kWidth / 2, kHeight / 2).at(kWidth / 4, kHeight / 4), vInfo, v, 0x56));
ASSERT_TRUE(verifyPlane({ kWidth, kHeight / 4 }, yInfo, y, 0));
ASSERT_TRUE(verifyPlane({ kWidth, kHeight / 4 }, uInfo, u, 0));
ASSERT_TRUE(verifyPlane({ kWidth, kHeight / 4 }, vInfo, v, 0));
ASSERT_TRUE(verifyPlane({ kWidth / 4, kHeight }, yInfo, y, 0));
ASSERT_TRUE(verifyPlane({ kWidth / 4, kHeight }, uInfo, u, 0));
ASSERT_TRUE(verifyPlane({ kWidth / 4, kHeight }, vInfo, v, 0));
}
TEST_F(C2BufferTest, GraphicBlockPoolTest) {
constexpr uint32_t kWidth = 320;
constexpr uint32_t kHeight = 240;
std::shared_ptr<C2BlockPool> blockPool(makeGraphicBlockPool());
std::shared_ptr<C2GraphicBlock> block;
ASSERT_EQ(C2_OK, blockPool->fetchGraphicBlock(
kWidth,
kHeight,
HAL_PIXEL_FORMAT_YCBCR_420_888,
{ C2MemoryUsage::CPU_READ, C2MemoryUsage::CPU_WRITE },
&block));
ASSERT_TRUE(block);
C2Acquirable<C2GraphicView> graphicViewHolder = block->map();
C2GraphicView graphicView = graphicViewHolder.get();
ASSERT_EQ(C2_OK, graphicView.error());
ASSERT_EQ(kWidth, graphicView.width());
ASSERT_EQ(kHeight, graphicView.height());
uint8_t *const *data = graphicView.data();
C2PlanarLayout layout = graphicView.layout();
ASSERT_NE(nullptr, data);
uint8_t *y = data[C2PlanarLayout::PLANE_Y];
C2PlaneInfo yInfo = layout.planes[C2PlanarLayout::PLANE_Y];
uint8_t *u = data[C2PlanarLayout::PLANE_U];
C2PlaneInfo uInfo = layout.planes[C2PlanarLayout::PLANE_U];
uint8_t *v = data[C2PlanarLayout::PLANE_V];
C2PlaneInfo vInfo = layout.planes[C2PlanarLayout::PLANE_V];
fillPlane({ kWidth, kHeight }, yInfo, y, 0);
fillPlane({ kWidth, kHeight }, uInfo, u, 0);
fillPlane({ kWidth, kHeight }, vInfo, v, 0);
fillPlane(C2Rect(kWidth / 2, kHeight / 2).at(kWidth / 4, kHeight / 4), yInfo, y, 0x12);
fillPlane(C2Rect(kWidth / 2, kHeight / 2).at(kWidth / 4, kHeight / 4), uInfo, u, 0x34);
fillPlane(C2Rect(kWidth / 2, kHeight / 2).at(kWidth / 4, kHeight / 4), vInfo, v, 0x56);
C2Fence fence;
C2ConstGraphicBlock constBlock = block->share(C2Rect(kWidth, kHeight), fence);
block.reset();
C2Acquirable<const C2GraphicView> constViewHolder = constBlock.map();
const C2GraphicView constGraphicView = constViewHolder.get();
ASSERT_EQ(C2_OK, constGraphicView.error());
ASSERT_EQ(kWidth, constGraphicView.width());
ASSERT_EQ(kHeight, constGraphicView.height());
const uint8_t *const *constData = constGraphicView.data();
layout = graphicView.layout();
ASSERT_NE(nullptr, constData);
const uint8_t *cy = constData[C2PlanarLayout::PLANE_Y];
yInfo = layout.planes[C2PlanarLayout::PLANE_Y];
const uint8_t *cu = constData[C2PlanarLayout::PLANE_U];
uInfo = layout.planes[C2PlanarLayout::PLANE_U];
const uint8_t *cv = constData[C2PlanarLayout::PLANE_V];
vInfo = layout.planes[C2PlanarLayout::PLANE_V];
ASSERT_TRUE(verifyPlane(C2Rect(kWidth / 2, kHeight / 2).at(kWidth / 4, kHeight / 4), yInfo, cy, 0x12));
ASSERT_TRUE(verifyPlane(C2Rect(kWidth / 2, kHeight / 2).at(kWidth / 4, kHeight / 4), uInfo, cu, 0x34));
ASSERT_TRUE(verifyPlane(C2Rect(kWidth / 2, kHeight / 2).at(kWidth / 4, kHeight / 4), vInfo, cv, 0x56));
ASSERT_TRUE(verifyPlane({ kWidth, kHeight / 4 }, yInfo, cy, 0));
ASSERT_TRUE(verifyPlane({ kWidth, kHeight / 4 }, uInfo, cu, 0));
ASSERT_TRUE(verifyPlane({ kWidth, kHeight / 4 }, vInfo, cv, 0));
ASSERT_TRUE(verifyPlane({ kWidth / 4, kHeight }, yInfo, cy, 0));
ASSERT_TRUE(verifyPlane({ kWidth / 4, kHeight }, uInfo, cu, 0));
ASSERT_TRUE(verifyPlane({ kWidth / 4, kHeight }, vInfo, cv, 0));
}
class BufferData : public C2BufferData {
public:
explicit BufferData(const std::vector<C2ConstLinearBlock> &blocks) : C2BufferData(blocks) {}
explicit BufferData(const std::vector<C2ConstGraphicBlock> &blocks) : C2BufferData(blocks) {}
};
class Buffer : public C2Buffer {
public:
explicit Buffer(const std::vector<C2ConstLinearBlock> &blocks) : C2Buffer(blocks) {}
explicit Buffer(const std::vector<C2ConstGraphicBlock> &blocks) : C2Buffer(blocks) {}
};
TEST_F(C2BufferTest, BufferDataTest) {
std::shared_ptr<C2BlockPool> linearBlockPool(makeLinearBlockPool());
std::shared_ptr<C2BlockPool> graphicBlockPool(makeGraphicBlockPool());
constexpr uint32_t kWidth1 = 320;
constexpr uint32_t kHeight1 = 240;
constexpr C2Rect kCrop1(kWidth1, kHeight1);
constexpr uint32_t kWidth2 = 176;
constexpr uint32_t kHeight2 = 144;
constexpr C2Rect kCrop2(kWidth2, kHeight2);
constexpr size_t kCapacity1 = 1024u;
constexpr size_t kCapacity2 = 2048u;
std::shared_ptr<C2LinearBlock> linearBlock1;
std::shared_ptr<C2LinearBlock> linearBlock2;
ASSERT_EQ(C2_OK, linearBlockPool->fetchLinearBlock(
kCapacity1,
{ C2MemoryUsage::CPU_READ, C2MemoryUsage::CPU_WRITE },
&linearBlock1));
ASSERT_EQ(C2_OK, linearBlockPool->fetchLinearBlock(
kCapacity2,
{ C2MemoryUsage::CPU_READ, C2MemoryUsage::CPU_WRITE },
&linearBlock2));
std::shared_ptr<C2GraphicBlock> graphicBlock1;
std::shared_ptr<C2GraphicBlock> graphicBlock2;
ASSERT_EQ(C2_OK, graphicBlockPool->fetchGraphicBlock(
kWidth1,
kHeight1,
HAL_PIXEL_FORMAT_YCBCR_420_888,
{ C2MemoryUsage::CPU_READ, C2MemoryUsage::CPU_WRITE },
&graphicBlock1));
ASSERT_EQ(C2_OK, graphicBlockPool->fetchGraphicBlock(
kWidth2,
kHeight2,
HAL_PIXEL_FORMAT_YCBCR_420_888,
{ C2MemoryUsage::CPU_READ, C2MemoryUsage::CPU_WRITE },
&graphicBlock2));
std::shared_ptr<C2BufferData> data(new BufferData({ linearBlock1->share(0, kCapacity1, C2Fence()) }));
EXPECT_EQ(C2BufferData::LINEAR, data->type());
ASSERT_EQ(1u, data->linearBlocks().size());
EXPECT_EQ(linearBlock1->handle(), data->linearBlocks().front().handle());
EXPECT_TRUE(data->graphicBlocks().empty());
data.reset(new BufferData({
linearBlock1->share(0, kCapacity1, C2Fence()),
linearBlock2->share(0, kCapacity2, C2Fence()),
}));
EXPECT_EQ(C2BufferData::LINEAR_CHUNKS, data->type());
ASSERT_EQ(2u, data->linearBlocks().size());
EXPECT_EQ(linearBlock1->handle(), data->linearBlocks().front().handle());
EXPECT_EQ(linearBlock2->handle(), data->linearBlocks().back().handle());
EXPECT_TRUE(data->graphicBlocks().empty());
data.reset(new BufferData({ graphicBlock1->share(kCrop1, C2Fence()) }));
EXPECT_EQ(C2BufferData::GRAPHIC, data->type());
ASSERT_EQ(1u, data->graphicBlocks().size());
EXPECT_EQ(graphicBlock1->handle(), data->graphicBlocks().front().handle());
EXPECT_TRUE(data->linearBlocks().empty());
data.reset(new BufferData({
graphicBlock1->share(kCrop1, C2Fence()),
graphicBlock2->share(kCrop2, C2Fence()),
}));
EXPECT_EQ(C2BufferData::GRAPHIC_CHUNKS, data->type());
ASSERT_EQ(2u, data->graphicBlocks().size());
EXPECT_EQ(graphicBlock1->handle(), data->graphicBlocks().front().handle());
EXPECT_EQ(graphicBlock2->handle(), data->graphicBlocks().back().handle());
EXPECT_TRUE(data->linearBlocks().empty());
}
void DestroyCallback(const C2Buffer * /* buf */, void *arg) {
std::function<void(void)> *cb = (std::function<void(void)> *)arg;
(*cb)();
}
enum : uint32_t {
kParamIndexNumber1,
kParamIndexNumber2,
};
typedef C2GlobalParam<C2Info, C2Int32Value, kParamIndexNumber1> C2Number1Info;
typedef C2GlobalParam<C2Info, C2Int32Value, kParamIndexNumber2> C2Number2Info;
TEST_F(C2BufferTest, BufferTest) {
std::shared_ptr<C2BlockPool> alloc(makeLinearBlockPool());
constexpr size_t kCapacity = 1024u;
std::shared_ptr<C2LinearBlock> block;
ASSERT_EQ(C2_OK, alloc->fetchLinearBlock(
kCapacity,
{ C2MemoryUsage::CPU_READ, C2MemoryUsage::CPU_WRITE },
&block));
std::atomic_bool destroyed(false);
std::function<void(void)> arg = [&destroyed](){ destroyed = true; };
std::shared_ptr<C2Buffer> buffer(new Buffer( { block->share(0, kCapacity, C2Fence()) }));
ASSERT_EQ(C2_OK, buffer->registerOnDestroyNotify(&DestroyCallback, &arg));
EXPECT_FALSE(destroyed);
ASSERT_EQ(C2_DUPLICATE, buffer->registerOnDestroyNotify(&DestroyCallback, &arg));
buffer.reset();
EXPECT_TRUE(destroyed);
buffer.reset(new Buffer( { block->share(0, kCapacity, C2Fence()) }));
destroyed = false;
ASSERT_EQ(C2_OK, buffer->registerOnDestroyNotify(&DestroyCallback, &arg));
EXPECT_FALSE(destroyed);
ASSERT_EQ(C2_NOT_FOUND, buffer->unregisterOnDestroyNotify(&DestroyCallback, nullptr));
ASSERT_EQ(C2_OK, buffer->unregisterOnDestroyNotify(&DestroyCallback, &arg));
EXPECT_FALSE(destroyed);
ASSERT_EQ(C2_NOT_FOUND, buffer->unregisterOnDestroyNotify(&DestroyCallback, &arg));
buffer.reset();
EXPECT_FALSE(destroyed);
std::shared_ptr<C2Info> info1(new C2Number1Info(1));
std::shared_ptr<C2Info> info2(new C2Number2Info(2));
buffer.reset(new Buffer( { block->share(0, kCapacity, C2Fence()) }));
EXPECT_TRUE(buffer->info().empty());
EXPECT_FALSE(buffer->hasInfo(info1->type()));
EXPECT_FALSE(buffer->hasInfo(info2->type()));
ASSERT_EQ(C2_OK, buffer->setInfo(info1));
EXPECT_EQ(1u, buffer->info().size());
EXPECT_EQ(*info1, *buffer->info().front());
EXPECT_TRUE(buffer->hasInfo(info1->type()));
EXPECT_FALSE(buffer->hasInfo(info2->type()));
ASSERT_EQ(C2_OK, buffer->setInfo(info2));
EXPECT_EQ(2u, buffer->info().size());
EXPECT_TRUE(buffer->hasInfo(info1->type()));
EXPECT_TRUE(buffer->hasInfo(info2->type()));
std::shared_ptr<C2Info> removed = buffer->removeInfo(info1->type());
ASSERT_TRUE(removed);
EXPECT_EQ(*removed, *info1);
EXPECT_EQ(1u, buffer->info().size());
EXPECT_EQ(*info2, *buffer->info().front());
EXPECT_FALSE(buffer->hasInfo(info1->type()));
EXPECT_TRUE(buffer->hasInfo(info2->type()));
removed = buffer->removeInfo(info1->type());
ASSERT_FALSE(removed);
EXPECT_EQ(1u, buffer->info().size());
EXPECT_FALSE(buffer->hasInfo(info1->type()));
EXPECT_TRUE(buffer->hasInfo(info2->type()));
std::shared_ptr<C2Info> info3(new C2Number2Info(3));
ASSERT_EQ(C2_OK, buffer->setInfo(info3));
EXPECT_EQ(1u, buffer->info().size());
EXPECT_FALSE(buffer->hasInfo(info1->type()));
EXPECT_TRUE(buffer->hasInfo(info2->type()));
removed = buffer->removeInfo(info2->type());
ASSERT_TRUE(removed);
EXPECT_EQ(*info3, *removed);
EXPECT_TRUE(buffer->info().empty());
EXPECT_FALSE(buffer->hasInfo(info1->type()));
EXPECT_FALSE(buffer->hasInfo(info2->type()));
}
TEST_F(C2BufferTest, MultipleLinearMapTest) {
std::shared_ptr<C2BlockPool> pool(makeLinearBlockPool());
constexpr size_t kCapacity = 524288u;
for (int i = 0; i < 100; ++i) {
std::vector<C2WriteView> wViews;
std::vector<C2ReadView> rViews;
for (int j = 0; j < 16; ++j) {
std::shared_ptr<C2LinearBlock> block;
ASSERT_EQ(C2_OK, pool->fetchLinearBlock(
kCapacity,
{ C2MemoryUsage::CPU_READ, C2MemoryUsage::CPU_WRITE },
&block));
wViews.push_back(block->map().get());
C2ConstLinearBlock cBlock = block->share(0, kCapacity / 2, C2Fence());
rViews.push_back(cBlock.map().get());
}
}
}
} // namespace android