You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
303 lines
11 KiB
303 lines
11 KiB
/*
|
|
* Copyright (C) 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 "GrallocWrapper.h"
|
|
|
|
#include <android/hardware/graphics/allocator/2.0/IAllocator.h>
|
|
#include <android/hardware/graphics/allocator/3.0/IAllocator.h>
|
|
#include <android/hardware/graphics/allocator/4.0/IAllocator.h>
|
|
#include <android/hardware/graphics/mapper/2.0/IMapper.h>
|
|
#include <android/hardware/graphics/mapper/2.1/IMapper.h>
|
|
#include <android/hardware/graphics/mapper/3.0/IMapper.h>
|
|
#include <android/hardware/graphics/mapper/4.0/IMapper.h>
|
|
|
|
#include <utils/Log.h>
|
|
|
|
#include <cinttypes>
|
|
#include <type_traits>
|
|
|
|
using IAllocator2 = ::android::hardware::graphics::allocator::V2_0::IAllocator;
|
|
using IAllocator3 = ::android::hardware::graphics::allocator::V3_0::IAllocator;
|
|
using IAllocator4 = ::android::hardware::graphics::allocator::V4_0::IAllocator;
|
|
using IMapper2 = ::android::hardware::graphics::mapper::V2_0::IMapper;
|
|
using IMapper2_1 = ::android::hardware::graphics::mapper::V2_1::IMapper;
|
|
using IMapper3 = ::android::hardware::graphics::mapper::V3_0::IMapper;
|
|
using IMapper4 = ::android::hardware::graphics::mapper::V4_0::IMapper;
|
|
|
|
using Error2 = ::android::hardware::graphics::mapper::V2_0::Error;
|
|
using Error3 = ::android::hardware::graphics::mapper::V3_0::Error;
|
|
using Error4 = ::android::hardware::graphics::mapper::V4_0::Error;
|
|
|
|
using ::android::hardware::graphics::common::V1_0::BufferUsage;
|
|
using ::android::hardware::graphics::common::V1_0::PixelFormat;
|
|
|
|
using ::android::hardware::hidl_handle;
|
|
using ::android::hardware::hidl_string;
|
|
using ::android::hardware::hidl_vec;
|
|
|
|
namespace android {
|
|
|
|
// Since we use the same APIs across allocator/mapper HALs but they have major
|
|
// version differences (meaning they are not related through inheritance), we
|
|
// create a common interface abstraction for the IAllocator + IMapper combination
|
|
// (major versions need to match in the current HALs, e.g. IAllocator 3.0 needs to
|
|
// be paired with IMapper 3.0, so these are tied together)
|
|
class IGrallocHalWrapper {
|
|
public:
|
|
virtual ~IGrallocHalWrapper() = default;
|
|
|
|
// IAllocator
|
|
virtual native_handle_t* allocate(uint32_t size) = 0;
|
|
virtual void freeBuffer(native_handle_t* bufferHandle) = 0;
|
|
|
|
// IMapper
|
|
virtual void* lock(native_handle_t* bufferHandle) = 0;
|
|
virtual void unlock(native_handle_t* bufferHandle) = 0;
|
|
};
|
|
|
|
namespace {
|
|
|
|
bool failed(Error2 error) {
|
|
return (error != Error2::NONE);
|
|
}
|
|
bool failed(Error3 error) {
|
|
return (error != Error3::NONE);
|
|
}
|
|
bool failed(Error4 error) {
|
|
return (error != Error4::NONE);
|
|
}
|
|
|
|
template <typename>
|
|
struct FirstArg;
|
|
|
|
// Template specialization for pointer to a non-static member function, which exposes
|
|
// the type of the first argument given to said function
|
|
template <typename ReturnType, typename ClassT, typename Arg1, typename... OtherArgs>
|
|
struct FirstArg<ReturnType (ClassT::*)(Arg1, OtherArgs...)> {
|
|
using type = Arg1;
|
|
};
|
|
|
|
// Alias to FirstArg which also removes any reference type and const associated
|
|
template <typename T>
|
|
using BaseTypeOfFirstArg = typename std::remove_const<
|
|
typename std::remove_reference<typename FirstArg<T>::type>::type>::type;
|
|
|
|
// Since all the type and function names are the same for the things we use across the major HAL
|
|
// versions, we use template magic to avoid repeating ourselves.
|
|
template <typename AllocatorT, typename MapperT>
|
|
class GrallocHalWrapper : public IGrallocHalWrapper {
|
|
public:
|
|
GrallocHalWrapper(const sp<AllocatorT>& allocator, const sp<MapperT>& mapper)
|
|
: mAllocator(allocator), mMapper(mapper) {
|
|
if (mapper->isRemote()) {
|
|
ALOGE("Mapper is in passthrough mode");
|
|
}
|
|
}
|
|
|
|
virtual native_handle_t* allocate(uint32_t size) override;
|
|
virtual void freeBuffer(native_handle_t* bufferHandle) override;
|
|
|
|
virtual void* lock(native_handle_t* bufferHandle) override;
|
|
virtual void unlock(native_handle_t* bufferHandle) override;
|
|
|
|
private:
|
|
static constexpr uint64_t kBufferUsage =
|
|
static_cast<uint64_t>(BufferUsage::SENSOR_DIRECT_DATA | BufferUsage::CPU_READ_OFTEN);
|
|
sp<AllocatorT> mAllocator;
|
|
sp<MapperT> mMapper;
|
|
|
|
// v2.0 and v3.0 use vec<uint32_t> for BufferDescriptor, but v4.0 uses vec<uint8_t>, so use
|
|
// some template magic to deduce the right type based off of the first argument to allocate(),
|
|
// which is always the version-specific BufferDescriptor type
|
|
typedef BaseTypeOfFirstArg<decltype(&AllocatorT::allocate)> BufferDescriptorT;
|
|
|
|
BufferDescriptorT getDescriptor(uint32_t size);
|
|
native_handle_t* importBuffer(const hidl_handle& rawHandle);
|
|
};
|
|
|
|
template <typename AllocatorT, typename MapperT>
|
|
native_handle_t* GrallocHalWrapper<AllocatorT, MapperT>::allocate(uint32_t size) {
|
|
constexpr uint32_t kBufferCount = 1;
|
|
BufferDescriptorT descriptor = getDescriptor(size);
|
|
native_handle_t* bufferHandle = nullptr;
|
|
|
|
auto callback = [&](auto error, uint32_t /*stride*/, const hidl_vec<hidl_handle>& buffers) {
|
|
if (failed(error)) {
|
|
ALOGE("Failed to allocate buffer: %" PRId32, static_cast<int32_t>(error));
|
|
} else if (buffers.size() != kBufferCount) {
|
|
ALOGE("Invalid buffer array size (got %zu, expected %" PRIu32 ")", buffers.size(),
|
|
kBufferCount);
|
|
} else {
|
|
bufferHandle = importBuffer(buffers[0]);
|
|
}
|
|
};
|
|
|
|
mAllocator->allocate(descriptor, kBufferCount, callback);
|
|
return bufferHandle;
|
|
}
|
|
|
|
template <typename AllocatorT, typename MapperT>
|
|
void GrallocHalWrapper<AllocatorT, MapperT>::freeBuffer(native_handle_t* bufferHandle) {
|
|
auto error = mMapper->freeBuffer(bufferHandle);
|
|
if (!error.isOk() || failed(error)) {
|
|
ALOGE("Failed to free buffer %p", bufferHandle);
|
|
}
|
|
}
|
|
|
|
template <typename AllocatorT, typename MapperT>
|
|
typename GrallocHalWrapper<AllocatorT, MapperT>::BufferDescriptorT
|
|
GrallocHalWrapper<AllocatorT, MapperT>::getDescriptor(uint32_t size) {
|
|
typename MapperT::BufferDescriptorInfo descriptorInfo = {
|
|
.width = size,
|
|
.height = 1,
|
|
.layerCount = 1,
|
|
.format = static_cast<decltype(descriptorInfo.format)>(PixelFormat::BLOB),
|
|
.usage = kBufferUsage,
|
|
};
|
|
|
|
BufferDescriptorT descriptor;
|
|
auto callback = [&](auto error, const BufferDescriptorT& tmpDescriptor) {
|
|
if (failed(error)) {
|
|
ALOGE("Failed to create descriptor: %" PRId32, static_cast<int32_t>(error));
|
|
} else {
|
|
descriptor = tmpDescriptor;
|
|
}
|
|
};
|
|
|
|
mMapper->createDescriptor(descriptorInfo, callback);
|
|
return descriptor;
|
|
}
|
|
|
|
template <typename AllocatorT, typename MapperT>
|
|
native_handle_t* GrallocHalWrapper<AllocatorT, MapperT>::importBuffer(
|
|
const hidl_handle& rawHandle) {
|
|
native_handle_t* bufferHandle = nullptr;
|
|
|
|
mMapper->importBuffer(rawHandle, [&](auto error, void* tmpBuffer) {
|
|
if (failed(error)) {
|
|
ALOGE("Failed to import buffer %p: %" PRId32, rawHandle.getNativeHandle(),
|
|
static_cast<int32_t>(error));
|
|
} else {
|
|
bufferHandle = static_cast<native_handle_t*>(tmpBuffer);
|
|
}
|
|
});
|
|
|
|
return bufferHandle;
|
|
}
|
|
|
|
template <typename AllocatorT, typename MapperT>
|
|
void* GrallocHalWrapper<AllocatorT, MapperT>::lock(native_handle_t* bufferHandle) {
|
|
// Per the HAL, all-zeros Rect means the entire buffer
|
|
typename MapperT::Rect accessRegion = {};
|
|
hidl_handle acquireFenceHandle; // No fence needed, already safe to lock
|
|
|
|
void* data = nullptr;
|
|
mMapper->lock(bufferHandle, kBufferUsage, accessRegion, acquireFenceHandle,
|
|
[&](auto error, void* tmpData, ...) { // V3/4 pass extra args we don't use
|
|
if (failed(error)) {
|
|
ALOGE("Failed to lock buffer %p: %" PRId32, bufferHandle,
|
|
static_cast<int32_t>(error));
|
|
} else {
|
|
data = tmpData;
|
|
}
|
|
});
|
|
|
|
return data;
|
|
}
|
|
|
|
template <typename AllocatorT, typename MapperT>
|
|
void GrallocHalWrapper<AllocatorT, MapperT>::unlock(native_handle_t* bufferHandle) {
|
|
mMapper->unlock(bufferHandle, [&](auto error, const hidl_handle& /*releaseFence*/) {
|
|
if (failed(error)) {
|
|
ALOGE("Failed to unlock buffer %p: %" PRId32, bufferHandle,
|
|
static_cast<int32_t>(error));
|
|
}
|
|
});
|
|
}
|
|
|
|
} // anonymous namespace
|
|
|
|
GrallocWrapper::GrallocWrapper() {
|
|
sp<IAllocator4> allocator4 = IAllocator4::getService();
|
|
sp<IMapper4> mapper4 = IMapper4::getService();
|
|
|
|
if (allocator4 != nullptr && mapper4 != nullptr) {
|
|
ALOGD("Using IAllocator/IMapper v4.0");
|
|
mGrallocHal = std::unique_ptr<IGrallocHalWrapper>(
|
|
new GrallocHalWrapper<IAllocator4, IMapper4>(allocator4, mapper4));
|
|
} else {
|
|
ALOGD("Graphics HALs 4.0 not found (allocator %d mapper %d), falling back to 3.0",
|
|
(allocator4 != nullptr), (mapper4 != nullptr));
|
|
|
|
sp<IAllocator3> allocator3 = IAllocator3::getService();
|
|
sp<IMapper3> mapper3 = IMapper3::getService();
|
|
|
|
if (allocator3 != nullptr && mapper3 != nullptr) {
|
|
mGrallocHal = std::unique_ptr<IGrallocHalWrapper>(
|
|
new GrallocHalWrapper<IAllocator3, IMapper3>(allocator3, mapper3));
|
|
} else {
|
|
ALOGD("Graphics HALs 3.0 not found (allocator %d mapper %d), falling back to 2.x",
|
|
(allocator3 != nullptr), (mapper3 != nullptr));
|
|
|
|
sp<IAllocator2> allocator2 = IAllocator2::getService();
|
|
sp<IMapper2> mapper2 = IMapper2_1::getService();
|
|
if (mapper2 == nullptr) {
|
|
mapper2 = IMapper2::getService();
|
|
}
|
|
|
|
if (allocator2 != nullptr && mapper2 != nullptr) {
|
|
mGrallocHal = std::unique_ptr<IGrallocHalWrapper>(
|
|
new GrallocHalWrapper<IAllocator2, IMapper2>(allocator2, mapper2));
|
|
} else {
|
|
ALOGE("Couldn't open graphics HALs (2.x allocator %d mapper %d)",
|
|
(allocator2 != nullptr), (mapper2 != nullptr));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
GrallocWrapper::~GrallocWrapper() {
|
|
for (auto bufferHandle : mAllocatedBuffers) {
|
|
mGrallocHal->unlock(bufferHandle);
|
|
mGrallocHal->freeBuffer(bufferHandle);
|
|
}
|
|
mAllocatedBuffers.clear();
|
|
}
|
|
|
|
std::pair<native_handle_t*, void*> GrallocWrapper::allocate(uint32_t size) {
|
|
native_handle_t* bufferHandle = mGrallocHal->allocate(size);
|
|
void* buffer = nullptr;
|
|
if (bufferHandle) {
|
|
buffer = mGrallocHal->lock(bufferHandle);
|
|
if (buffer) {
|
|
mAllocatedBuffers.insert(bufferHandle);
|
|
} else {
|
|
mGrallocHal->freeBuffer(bufferHandle);
|
|
bufferHandle = nullptr;
|
|
}
|
|
}
|
|
return std::make_pair<>(bufferHandle, buffer);
|
|
}
|
|
|
|
void GrallocWrapper::freeBuffer(native_handle_t* bufferHandle) {
|
|
if (mAllocatedBuffers.erase(bufferHandle)) {
|
|
mGrallocHal->unlock(bufferHandle);
|
|
mGrallocHal->freeBuffer(bufferHandle);
|
|
}
|
|
}
|
|
|
|
} // namespace android
|