mirror of
https://github.com/Evolution-X/hardware_interfaces
synced 2026-02-01 22:04:26 +00:00
b2b747ffd4
We used "default" value for the allocator in the test and this value was used as is for the AIDL allocator. This caused the test to fail because we were not able to acquire the appropriate allocator as AIDL allocator instance is not named "default". Update the test to use the correct instance name for AIDL allocator, if available. Test: atest VtsHalGraphicsComposerV2_1TargetTest atest VtsHalGraphicsComposerV2_2TargetTest atest VtsHalGraphicsComposerV2_3TargetTest atest VtsHalGraphicsComposerV2_4TargetTest atest VtsHalGraphicsComposer3_TargetTest BUG: 234671596 test results after updates: VTS 2.1 : http://ab/I84600010058657636 VTS 2.2 : http://ab/I51800010058498973 VTS 2.3 : http://ab/I87700010058914863 VTS 2.4 : http://ab/I88900010058592031 VTS 3.0 : http://ab/I96200010058838905 Change-Id: I04ae1a18d757cfd941d4929ad08f6bb2c8643f76
396 lines
14 KiB
C++
396 lines
14 KiB
C++
/*
|
|
* Copyright 2019 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 <aidlcommonsupport/NativeHandle.h>
|
|
#include <android-base/properties.h>
|
|
#include <android/binder_manager.h>
|
|
#include <gralloctypes/Gralloc4.h>
|
|
#include <mapper-vts/4.0/MapperVts.h>
|
|
|
|
namespace android {
|
|
namespace hardware {
|
|
namespace graphics {
|
|
namespace mapper {
|
|
namespace V4_0 {
|
|
namespace vts {
|
|
|
|
Gralloc::Gralloc(const std::string& aidlAllocatorServiceName,
|
|
const std::string& hidlAllocatorServiceName, const std::string& mapperServiceName,
|
|
bool errOnFailure) {
|
|
if (errOnFailure) {
|
|
init(aidlAllocatorServiceName, hidlAllocatorServiceName, mapperServiceName);
|
|
} else {
|
|
initNoErr(aidlAllocatorServiceName, hidlAllocatorServiceName, mapperServiceName);
|
|
}
|
|
}
|
|
|
|
void Gralloc::init(const std::string& aidlAllocatorServiceName,
|
|
const std::string& hidlAllocatorServiceName,
|
|
const std::string& mapperServiceName) {
|
|
mAidlAllocator = aidl::android::hardware::graphics::allocator::IAllocator::fromBinder(
|
|
ndk::SpAIBinder(AServiceManager_checkService(aidlAllocatorServiceName.c_str())));
|
|
|
|
if (mAidlAllocator == nullptr) {
|
|
mHidlAllocator = IAllocator::getService(hidlAllocatorServiceName);
|
|
}
|
|
ASSERT_TRUE(nullptr != mAidlAllocator || mHidlAllocator != nullptr)
|
|
<< "failed to get allocator service";
|
|
|
|
mMapper = IMapper::getService(mapperServiceName);
|
|
ASSERT_NE(nullptr, mMapper.get()) << "failed to get mapper service";
|
|
ASSERT_FALSE(mMapper->isRemote()) << "mapper is not in passthrough mode";
|
|
}
|
|
|
|
void Gralloc::initNoErr(const std::string& aidlAllocatorServiceName,
|
|
const std::string& hidlAllocatorServiceName,
|
|
const std::string& mapperServiceName) {
|
|
mAidlAllocator = aidl::android::hardware::graphics::allocator::IAllocator::fromBinder(
|
|
ndk::SpAIBinder(AServiceManager_checkService(aidlAllocatorServiceName.c_str())));
|
|
|
|
if (mAidlAllocator == nullptr) {
|
|
mHidlAllocator = IAllocator::getService(hidlAllocatorServiceName);
|
|
}
|
|
|
|
mMapper = IMapper::getService(mapperServiceName);
|
|
if (mMapper.get()) {
|
|
ASSERT_FALSE(mMapper->isRemote()) << "mapper is not in passthrough mode";
|
|
}
|
|
}
|
|
|
|
Gralloc::~Gralloc() {
|
|
for (auto bufferHandle : mClonedBuffers) {
|
|
auto buffer = const_cast<native_handle_t*>(bufferHandle);
|
|
native_handle_close(buffer);
|
|
native_handle_delete(buffer);
|
|
}
|
|
mClonedBuffers.clear();
|
|
|
|
for (auto bufferHandle : mImportedBuffers) {
|
|
auto buffer = const_cast<native_handle_t*>(bufferHandle);
|
|
EXPECT_EQ(Error::NONE, mMapper->freeBuffer(buffer)) << "failed to free buffer " << buffer;
|
|
}
|
|
mImportedBuffers.clear();
|
|
}
|
|
|
|
const native_handle_t* Gralloc::cloneBuffer(const hidl_handle& rawHandle,
|
|
enum Tolerance /*tolerance*/) {
|
|
const native_handle_t* bufferHandle = native_handle_clone(rawHandle.getNativeHandle());
|
|
EXPECT_NE(nullptr, bufferHandle);
|
|
|
|
if (bufferHandle) {
|
|
mClonedBuffers.insert(bufferHandle);
|
|
}
|
|
|
|
return bufferHandle;
|
|
}
|
|
|
|
std::vector<const native_handle_t*> Gralloc::allocate(const BufferDescriptor& descriptor,
|
|
uint32_t count, bool import,
|
|
enum Tolerance tolerance,
|
|
uint32_t* outStride) {
|
|
std::vector<const native_handle_t*> bufferHandles;
|
|
bufferHandles.reserve(count);
|
|
|
|
auto callback = [&](Error error, uint32_t stride,
|
|
const hidl_vec<hidl_handle>& buffers) -> void {
|
|
if (canTolerate(tolerance, error)) {
|
|
return;
|
|
}
|
|
|
|
if (error != Error::NONE) {
|
|
if (base::GetIntProperty("ro.vendor.build.version.sdk", 0, 0, INT_MAX) < 33) {
|
|
GTEST_SKIP() << "Old vendor grallocs may not support P010";
|
|
} else {
|
|
GTEST_FAIL() << "failed to allocate buffers";
|
|
}
|
|
}
|
|
ASSERT_EQ(count, buffers.size()) << "invalid buffer array";
|
|
|
|
for (uint32_t i = 0; i < count; i++) {
|
|
const native_handle_t* bufferHandle = nullptr;
|
|
if (import) {
|
|
ASSERT_NO_FATAL_FAILURE(bufferHandle = importBuffer(buffers[i], tolerance));
|
|
} else {
|
|
ASSERT_NO_FATAL_FAILURE(bufferHandle = cloneBuffer(buffers[i], tolerance));
|
|
}
|
|
if (bufferHandle) {
|
|
bufferHandles.push_back(bufferHandle);
|
|
}
|
|
}
|
|
|
|
if (outStride) {
|
|
*outStride = stride;
|
|
}
|
|
};
|
|
|
|
rawAllocate(descriptor, count, callback);
|
|
|
|
if (::testing::Test::HasFatalFailure()) {
|
|
bufferHandles.clear();
|
|
}
|
|
|
|
return bufferHandles;
|
|
}
|
|
|
|
const native_handle_t* Gralloc::allocate(const IMapper::BufferDescriptorInfo& descriptorInfo,
|
|
bool import, enum Tolerance tolerance,
|
|
uint32_t* outStride) {
|
|
BufferDescriptor descriptor = createDescriptor(descriptorInfo);
|
|
if (::testing::Test::HasFatalFailure()) {
|
|
return nullptr;
|
|
}
|
|
|
|
auto buffers = allocate(descriptor, 1, import, tolerance, outStride);
|
|
if (::testing::Test::HasFatalFailure() || ::testing::Test::IsSkipped() || buffers.size() != 1) {
|
|
return nullptr;
|
|
}
|
|
return buffers[0];
|
|
}
|
|
|
|
void Gralloc::rawAllocate(
|
|
const BufferDescriptor& descriptor, uint32_t count,
|
|
std::function<void(Error, uint32_t, const hidl_vec<hidl_handle>&)> callback) {
|
|
if (mAidlAllocator) {
|
|
aidl::android::hardware::graphics::allocator::AllocationResult result;
|
|
auto status = mAidlAllocator->allocate(descriptor, count, &result);
|
|
const Error error = toHidlError(status);
|
|
std::vector<hidl_handle> handles;
|
|
for (const auto& aidlHandle : result.buffers) {
|
|
handles.push_back(hidl_handle(makeFromAidl(aidlHandle)));
|
|
}
|
|
callback(error, result.stride, handles);
|
|
} else {
|
|
mHidlAllocator->allocate(descriptor, count, callback);
|
|
}
|
|
}
|
|
|
|
sp<IMapper> Gralloc::getMapper() const {
|
|
return mMapper;
|
|
}
|
|
|
|
BufferDescriptor Gralloc::createDescriptor(const IMapper::BufferDescriptorInfo& descriptorInfo) {
|
|
BufferDescriptor descriptor;
|
|
mMapper->createDescriptor(descriptorInfo, [&](const auto& tmpError, const auto& tmpDescriptor) {
|
|
ASSERT_EQ(Error::NONE, tmpError) << "failed to create descriptor";
|
|
descriptor = tmpDescriptor;
|
|
});
|
|
|
|
return descriptor;
|
|
}
|
|
|
|
const native_handle_t* Gralloc::importBuffer(const hidl_handle& rawHandle,
|
|
enum Tolerance tolerance) {
|
|
const native_handle_t* bufferHandle = nullptr;
|
|
mMapper->importBuffer(rawHandle, [&](const auto& tmpError, const auto& tmpBuffer) {
|
|
if (!canTolerate(tolerance, tmpError)) {
|
|
ASSERT_EQ(Error::NONE, tmpError)
|
|
<< "failed to import buffer %p" << rawHandle.getNativeHandle();
|
|
}
|
|
bufferHandle = static_cast<const native_handle_t*>(tmpBuffer);
|
|
});
|
|
|
|
if (bufferHandle) {
|
|
mImportedBuffers.insert(bufferHandle);
|
|
}
|
|
|
|
return bufferHandle;
|
|
}
|
|
|
|
void Gralloc::freeBuffer(const native_handle_t* bufferHandle) {
|
|
if (bufferHandle == nullptr) {
|
|
return;
|
|
}
|
|
|
|
auto buffer = const_cast<native_handle_t*>(bufferHandle);
|
|
|
|
if (mImportedBuffers.erase(bufferHandle)) {
|
|
Error error = mMapper->freeBuffer(buffer);
|
|
ASSERT_EQ(Error::NONE, error) << "failed to free buffer " << buffer;
|
|
} else {
|
|
mClonedBuffers.erase(bufferHandle);
|
|
native_handle_close(buffer);
|
|
native_handle_delete(buffer);
|
|
}
|
|
}
|
|
|
|
void* Gralloc::lock(const native_handle_t* bufferHandle, uint64_t cpuUsage,
|
|
const IMapper::Rect& accessRegion, int acquireFence) {
|
|
auto buffer = const_cast<native_handle_t*>(bufferHandle);
|
|
|
|
NATIVE_HANDLE_DECLARE_STORAGE(acquireFenceStorage, 1, 0);
|
|
hidl_handle acquireFenceHandle;
|
|
if (acquireFence >= 0) {
|
|
auto h = native_handle_init(acquireFenceStorage, 1, 0);
|
|
h->data[0] = acquireFence;
|
|
acquireFenceHandle = h;
|
|
}
|
|
|
|
void* data = nullptr;
|
|
mMapper->lock(buffer, cpuUsage, accessRegion, acquireFenceHandle,
|
|
[&](const auto& tmpError, const auto& tmpData) {
|
|
ASSERT_EQ(Error::NONE, tmpError) << "failed to lock buffer " << buffer;
|
|
data = tmpData;
|
|
});
|
|
|
|
if (acquireFence >= 0) {
|
|
close(acquireFence);
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
int Gralloc::unlock(const native_handle_t* bufferHandle) {
|
|
auto buffer = const_cast<native_handle_t*>(bufferHandle);
|
|
|
|
int releaseFence = -1;
|
|
mMapper->unlock(buffer, [&](const auto& tmpError, const auto& tmpReleaseFence) {
|
|
ASSERT_EQ(Error::NONE, tmpError) << "failed to unlock buffer " << buffer;
|
|
|
|
auto fenceHandle = tmpReleaseFence.getNativeHandle();
|
|
if (fenceHandle) {
|
|
ASSERT_EQ(0, fenceHandle->numInts) << "invalid fence handle " << fenceHandle;
|
|
if (fenceHandle->numFds == 1) {
|
|
releaseFence = dup(fenceHandle->data[0]);
|
|
ASSERT_LT(0, releaseFence) << "failed to dup fence fd";
|
|
} else {
|
|
ASSERT_EQ(0, fenceHandle->numFds) << " invalid fence handle " << fenceHandle;
|
|
}
|
|
}
|
|
});
|
|
|
|
return releaseFence;
|
|
}
|
|
|
|
int Gralloc::flushLockedBuffer(const native_handle_t* bufferHandle) {
|
|
auto buffer = const_cast<native_handle_t*>(bufferHandle);
|
|
|
|
int releaseFence = -1;
|
|
mMapper->flushLockedBuffer(buffer, [&](const auto& tmpError, const auto& tmpReleaseFence) {
|
|
ASSERT_EQ(Error::NONE, tmpError) << "failed to flush locked buffer " << buffer;
|
|
|
|
auto fenceHandle = tmpReleaseFence.getNativeHandle();
|
|
if (fenceHandle) {
|
|
ASSERT_EQ(0, fenceHandle->numInts) << "invalid fence handle " << fenceHandle;
|
|
if (fenceHandle->numFds == 1) {
|
|
releaseFence = dup(fenceHandle->data[0]);
|
|
ASSERT_LT(0, releaseFence) << "failed to dup fence fd";
|
|
} else {
|
|
ASSERT_EQ(0, fenceHandle->numFds) << " invalid fence handle " << fenceHandle;
|
|
}
|
|
}
|
|
});
|
|
|
|
return releaseFence;
|
|
}
|
|
|
|
void Gralloc::rereadLockedBuffer(const native_handle_t* bufferHandle) {
|
|
auto buffer = const_cast<native_handle_t*>(bufferHandle);
|
|
|
|
ASSERT_EQ(Error::NONE, mMapper->rereadLockedBuffer(buffer));
|
|
}
|
|
|
|
bool Gralloc::validateBufferSize(const native_handle_t* bufferHandle,
|
|
const IMapper::BufferDescriptorInfo& descriptorInfo,
|
|
uint32_t stride) {
|
|
auto buffer = const_cast<native_handle_t*>(bufferHandle);
|
|
|
|
Error error = mMapper->validateBufferSize(buffer, descriptorInfo, stride);
|
|
return error == Error::NONE;
|
|
}
|
|
|
|
void Gralloc::getTransportSize(const native_handle_t* bufferHandle, uint32_t* outNumFds,
|
|
uint32_t* outNumInts) {
|
|
auto buffer = const_cast<native_handle_t*>(bufferHandle);
|
|
|
|
*outNumFds = 0;
|
|
*outNumInts = 0;
|
|
mMapper->getTransportSize(buffer, [&](const auto& tmpError, const auto& tmpNumFds,
|
|
const auto& tmpNumInts) {
|
|
ASSERT_EQ(Error::NONE, tmpError) << "failed to get transport size";
|
|
ASSERT_GE(bufferHandle->numFds, int(tmpNumFds)) << "invalid numFds " << tmpNumFds;
|
|
ASSERT_GE(bufferHandle->numInts, int(tmpNumInts)) << "invalid numInts " << tmpNumInts;
|
|
|
|
*outNumFds = tmpNumFds;
|
|
*outNumInts = tmpNumInts;
|
|
});
|
|
}
|
|
|
|
bool Gralloc::isSupported(const IMapper::BufferDescriptorInfo& descriptorInfo) {
|
|
bool supported = false;
|
|
mMapper->isSupported(descriptorInfo, [&](const auto& tmpError, const auto& tmpSupported) {
|
|
ASSERT_EQ(Error::NONE, tmpError) << "failed to check is supported";
|
|
supported = tmpSupported;
|
|
});
|
|
return supported;
|
|
}
|
|
|
|
bool Gralloc::isSupportedNoFailure(const IMapper::BufferDescriptorInfo& descriptorInfo) {
|
|
bool supported = false;
|
|
mMapper->isSupported(descriptorInfo, [&](const auto& tmpError, const auto& tmpSupported) {
|
|
supported = tmpSupported && tmpError == Error::NONE;
|
|
});
|
|
return supported;
|
|
}
|
|
|
|
Error Gralloc::get(const native_handle_t* bufferHandle, const IMapper::MetadataType& metadataType,
|
|
hidl_vec<uint8_t>* outVec) {
|
|
Error err;
|
|
mMapper->get(const_cast<native_handle_t*>(bufferHandle), metadataType,
|
|
[&](const auto& tmpError, const hidl_vec<uint8_t>& tmpVec) {
|
|
err = tmpError;
|
|
*outVec = tmpVec;
|
|
});
|
|
return err;
|
|
}
|
|
|
|
Error Gralloc::set(const native_handle_t* bufferHandle, const IMapper::MetadataType& metadataType,
|
|
const hidl_vec<uint8_t>& vec) {
|
|
return mMapper->set(const_cast<native_handle_t*>(bufferHandle), metadataType, vec);
|
|
}
|
|
|
|
Error Gralloc::getFromBufferDescriptorInfo(const IMapper::BufferDescriptorInfo& descriptorInfo,
|
|
const IMapper::MetadataType& metadataType,
|
|
hidl_vec<uint8_t>* outVec) {
|
|
Error err;
|
|
mMapper->getFromBufferDescriptorInfo(
|
|
descriptorInfo, metadataType,
|
|
[&](const auto& tmpError, const hidl_vec<uint8_t>& tmpVec) {
|
|
err = tmpError;
|
|
*outVec = tmpVec;
|
|
});
|
|
return err;
|
|
}
|
|
|
|
Error Gralloc::getReservedRegion(const native_handle_t* bufferHandle, void** outReservedRegion,
|
|
uint64_t* outReservedSize) {
|
|
Error err;
|
|
mMapper->getReservedRegion(
|
|
const_cast<native_handle_t*>(bufferHandle),
|
|
[&](const auto& tmpError, const auto& tmpReservedRegion, const auto& tmpReservedSize) {
|
|
err = tmpError;
|
|
*outReservedRegion = tmpReservedRegion;
|
|
*outReservedSize = tmpReservedSize;
|
|
});
|
|
return err;
|
|
}
|
|
|
|
} // namespace vts
|
|
} // namespace V4_0
|
|
} // namespace mapper
|
|
} // namespace graphics
|
|
} // namespace hardware
|
|
} // namespace android
|