Merge Android 14 QPR2 to AOSP main
Bug: 319669529
Merged-In: I4216757468b9304fb354a44a9555b53d2e3ecb2c
Change-Id: I9f1ded871cfb0802d06be1d338ddc468a6f6600d
diff --git a/gralloc4/interfaces/libs/drmutils/Android.bp b/gralloc4/interfaces/libs/drmutils/Android.bp
index 82ba768..cff9a7e 100644
--- a/gralloc4/interfaces/libs/drmutils/Android.bp
+++ b/gralloc4/interfaces/libs/drmutils/Android.bp
@@ -21,6 +21,7 @@
cc_library_static {
name: "libgralloc_drmutils",
+ defaults: ["android.hardware.graphics.common-ndk_shared"],
cflags: [
"-Wall",
"-Werror",
@@ -33,7 +34,6 @@
"liblog",
"libdrm",
"libcutils",
- "android.hardware.graphics.common-V4-ndk",
],
header_libs: [
"libgralloc_headers",
diff --git a/gralloc4/service/aidl/Android.bp b/gralloc4/service/aidl/Android.bp
index a3d7a87..ea6e461 100644
--- a/gralloc4/service/aidl/Android.bp
+++ b/gralloc4/service/aidl/Android.bp
@@ -3,7 +3,7 @@
}
cc_binary {
- name: "android.hardware.graphics.allocator-V1-service",
+ name: "android.hardware.graphics.allocator-V2-service",
proprietary: true,
relative_install_path: "hw",
srcs: [
@@ -17,7 +17,7 @@
"libgralloc_headers",
],
shared_libs: [
- "android.hardware.graphics.allocator-V1-ndk",
+ "android.hardware.graphics.allocator-V2-ndk",
"android.hardware.graphics.allocator-aidl-impl",
"libbinder_ndk",
"liblog",
diff --git a/gralloc4/service/aidl/android.hardware.graphics.allocator-aidl-service.rc b/gralloc4/service/aidl/android.hardware.graphics.allocator-aidl-service.rc
index e86b68d..723fab6 100644
--- a/gralloc4/service/aidl/android.hardware.graphics.allocator-aidl-service.rc
+++ b/gralloc4/service/aidl/android.hardware.graphics.allocator-aidl-service.rc
@@ -1,4 +1,4 @@
-service vendor.graphics.allocator-default /vendor/bin/hw/android.hardware.graphics.allocator-V1-service
+service vendor.graphics.allocator-default /vendor/bin/hw/android.hardware.graphics.allocator-V2-service
class hal animation
user system
group graphics drmrpc
diff --git a/gralloc4/service/aidl/manifest_gralloc_aidl.xml b/gralloc4/service/aidl/manifest_gralloc_aidl.xml
index 6848a99..c29d370 100644
--- a/gralloc4/service/aidl/manifest_gralloc_aidl.xml
+++ b/gralloc4/service/aidl/manifest_gralloc_aidl.xml
@@ -1,6 +1,7 @@
<manifest version="1.0" type="device">
<hal format="aidl">
<name>android.hardware.graphics.allocator</name>
+ <version>2</version>
<fqname>IAllocator/default</fqname>
</hal>
</manifest>
diff --git a/gralloc4/src/4.x/Android.bp b/gralloc4/src/4.x/Android.bp
index 16eec6a..fb2363b 100644
--- a/gralloc4/src/4.x/Android.bp
+++ b/gralloc4/src/4.x/Android.bp
@@ -92,4 +92,7 @@
include_dirs: [
"hardware/google/gchips/include",
],
+ cflags: [
+ "-DGRALLOC_MAPPER_4=1",
+ ],
}
diff --git a/gralloc4/src/4.x/GrallocMapper.cpp b/gralloc4/src/4.x/GrallocMapper.cpp
index c0b5f5f..11ee90b 100644
--- a/gralloc4/src/4.x/GrallocMapper.cpp
+++ b/gralloc4/src/4.x/GrallocMapper.cpp
@@ -18,6 +18,7 @@
#include "GrallocMapper.h"
#include "hidl_common/BufferDescriptor.h"
#include "hidl_common/MapperMetadata.h"
+#include "hidl_common/Mapper.h"
#include "allocator/mali_gralloc_ion.h"
@@ -26,7 +27,9 @@
namespace mapper
{
+namespace hidl {
using android::hardware::graphics::mapper::V4_0::Error;
+} // namespace hidl
using android::hardware::graphics::mapper::V4_0::BufferDescriptor;
using android::hardware::graphics::mapper::V4_0::IMapper;
using android::hardware::Return;
@@ -34,7 +37,6 @@
using android::hardware::hidl_vec;
using android::hardware::Void;
-
GrallocMapper::GrallocMapper() {}
GrallocMapper::~GrallocMapper() {}
@@ -43,12 +45,12 @@
{
if (common::validateDescriptorInfo(descriptorInfo))
{
- hidl_cb(Error::NONE, common::grallocEncodeBufferDescriptor<uint8_t>(descriptorInfo));
+ hidl_cb(hidl::Error::NONE, common::grallocEncodeBufferDescriptor<uint8_t>(descriptorInfo));
}
else
{
MALI_GRALLOC_LOGE("Invalid attributes to create descriptor for Mapper 3.0");
- hidl_cb(Error::BAD_VALUE, BufferDescriptor());
+ hidl_cb(hidl::Error::BAD_VALUE, BufferDescriptor());
}
return Void();
@@ -56,73 +58,156 @@
Return<void> GrallocMapper::importBuffer(const hidl_handle &rawHandle, importBuffer_cb hidl_cb)
{
- common::importBuffer(rawHandle, hidl_cb);
+ if (!rawHandle.getNativeHandle()) {
+ hidl_cb(hidl::Error::BAD_BUFFER, nullptr);
+ return Void();
+ }
+
+ auto *inHandle = const_cast<native_handle_t *>(rawHandle.getNativeHandle());
+ buffer_handle_t outHandle = nullptr;
+
+ hidl::Error err = static_cast<hidl::Error>(
+ common::importBuffer(inHandle, &outHandle));
+
+ hidl_cb(err, static_cast<void*>(const_cast<native_handle_t*>(outHandle)));
return Void();
}
-Return<Error> GrallocMapper::freeBuffer(void *buffer)
+Return<hidl::Error> GrallocMapper::freeBuffer(void *buffer)
{
- return common::freeBuffer(buffer);
+ buffer_handle_t handle = common::getBuffer(buffer);
+ if (handle == nullptr) return hidl::Error::BAD_BUFFER;
+ return static_cast<hidl::Error>(common::freeBuffer(handle));
}
-Return<Error> GrallocMapper::validateBufferSize(void *buffer, const BufferDescriptorInfo &descriptorInfo,
+Return<hidl::Error> GrallocMapper::validateBufferSize(void *buffer, const BufferDescriptorInfo &descriptorInfo,
uint32_t in_stride)
{
/* All Gralloc allocated buffers must be conform to local descriptor validation */
if (!common::validateDescriptorInfo<BufferDescriptorInfo>(descriptorInfo))
{
MALI_GRALLOC_LOGE("Invalid descriptor attributes for validating buffer size");
- return Error::BAD_VALUE;
+ return hidl::Error::BAD_VALUE;
}
- return common::validateBufferSize(buffer, descriptorInfo, in_stride);
+ return static_cast<hidl::Error>(common::validateBufferSize(buffer, descriptorInfo, in_stride));
+}
+
+static bool getFenceFd(const hidl_handle &fenceHandle, int *outFenceFd) {
+ auto const handle = fenceHandle.getNativeHandle();
+ if (handle && handle->numFds > 1) {
+ MALI_GRALLOC_LOGE("Invalid fence handle with %d fds",
+ handle->numFds);
+ return false;
+ }
+
+ *outFenceFd = (handle && handle->numFds == 1) ? handle->data[0] : -1;
+ return true;
}
Return<void> GrallocMapper::lock(void *buffer, uint64_t cpuUsage, const IMapper::Rect &accessRegion,
const hidl_handle &acquireFence, lock_cb hidl_cb)
{
- common::lock(buffer, cpuUsage, accessRegion, acquireFence, hidl_cb);
+ void *outData = nullptr;
+ int fenceFd;
+ if (!getFenceFd(acquireFence, &fenceFd)) {
+ hidl_cb(hidl::Error::BAD_VALUE, nullptr);
+ return Void();
+ }
+
+ hidl::Error err = static_cast<hidl::Error>(
+ common::lock(static_cast<buffer_handle_t>(buffer), cpuUsage,
+ common::GrallocRect(accessRegion), fenceFd, &outData));
+ if (err != hidl::Error::NONE) outData = nullptr;
+ hidl_cb(err, outData);
return Void();
}
+/*
+ * Populates the HIDL fence handle for the given fence object
+ *
+ * @param fenceFd [in] Fence file descriptor
+ * @param handleStorage [in] HIDL handle storage for fence
+ *
+ * @return HIDL fence handle
+ */
+static hidl_handle buildFenceHandle(int fenceFd, char *handleStorage) {
+ native_handle_t *handle = nullptr;
+ if (fenceFd >= 0) {
+ handle = native_handle_init(handleStorage, 1, 0);
+ handle->data[0] = fenceFd;
+ }
+
+ return hidl_handle(handle);
+}
+
Return<void> GrallocMapper::unlock(void *buffer, unlock_cb hidl_cb)
{
- common::unlock(buffer, hidl_cb);
+ int fenceFd = -1;
+ const native_handle_t *handle = common::getBuffer(buffer);
+
+ if (handle == nullptr) {
+ hidl_cb(hidl::Error::BAD_BUFFER, nullptr);
+ }
+
+ hidl::Error err =
+ static_cast<hidl::Error>(common::unlock(handle, &fenceFd));
+ if (err == hidl::Error::NONE) {
+ NATIVE_HANDLE_DECLARE_STORAGE(fenceStorage, 1, 0);
+ hidl_cb(err, buildFenceHandle(fenceFd, fenceStorage));
+
+ if (fenceFd >= 0) {
+ close(fenceFd);
+ }
+ } else {
+ hidl_cb(err, nullptr);
+ }
return Void();
}
Return<void> GrallocMapper::flushLockedBuffer(void *buffer, flushLockedBuffer_cb hidl_cb)
{
- common::flushLockedBuffer(buffer, hidl_cb);
+ hidl::Error err = static_cast<hidl::Error>(common::flushLockedBuffer(static_cast<buffer_handle_t>(buffer)));
+ hidl_cb(err, hidl_handle{});
return Void();
}
-Return<Error> GrallocMapper::rereadLockedBuffer(void *buffer)
+Return<hidl::Error> GrallocMapper::rereadLockedBuffer(void *buffer)
{
- return common::rereadLockedBuffer(buffer);
+ return static_cast<hidl::Error>(common::rereadLockedBuffer(common::getBuffer(buffer)));
}
Return<void> GrallocMapper::get(void *buffer, const MetadataType &metadataType, IMapper::get_cb hidl_cb)
{
- common::get(buffer, metadataType, hidl_cb);
+ std::vector<uint8_t> vec;
+ hidl::Error err = static_cast<hidl::Error>(
+ common::get(common::getBuffer(buffer), common::MetadataType(metadataType), vec));
+ hidl_cb(err, hidl_vec(vec));
return Void();
}
-Return<Error> GrallocMapper::set(void *buffer, const MetadataType &metadataType, const hidl_vec<uint8_t> &metadata)
+Return<hidl::Error> GrallocMapper::set(void *buffer, const MetadataType &metadataType, const hidl_vec<uint8_t> &metadata)
{
- return common::set(buffer, metadataType, metadata);
+ buffer_handle_t bufferHandle = common::getBuffer(buffer);
+ return static_cast<hidl::Error>(common::set(bufferHandle, common::MetadataType(metadataType), metadata));
}
Return<void> GrallocMapper::getFromBufferDescriptorInfo(const BufferDescriptorInfo &description,
const MetadataType &metadataType,
getFromBufferDescriptorInfo_cb hidl_cb)
{
- common::getFromBufferDescriptorInfo(description, metadataType, hidl_cb);
+ std::vector<uint8_t> vec;
+ hidl::Error err = static_cast<hidl::Error>(common::getFromBufferDescriptorInfo(
+ description, common::MetadataType(metadataType), vec));
+ hidl_cb(err, vec);
return Void();
}
Return<void> GrallocMapper::getTransportSize(void *buffer, getTransportSize_cb hidl_cb)
{
- common::getTransportSize(buffer, hidl_cb);
+ uint32_t outNumFds = 0, outNumInts = 0;
+ buffer_handle_t bufferHandle = common::getBuffer(buffer);
+ hidl::Error err = static_cast<hidl::Error>(common::getTransportSize(bufferHandle, &outNumFds, &outNumInts));
+ hidl_cb(err, outNumFds, outNumInts);
return Void();
}
@@ -131,33 +216,52 @@
if (!common::validateDescriptorInfo<BufferDescriptorInfo>(description))
{
MALI_GRALLOC_LOGE("Invalid descriptor attributes for validating buffer size");
- hidl_cb(Error::BAD_VALUE, false);
+ hidl_cb(hidl::Error::BAD_VALUE, false);
}
- common::isSupported(description, hidl_cb);
+ hidl_cb(hidl::Error::NONE, common::isSupported(description));
return Void();
}
Return<void> GrallocMapper::listSupportedMetadataTypes(listSupportedMetadataTypes_cb hidl_cb)
{
- common::listSupportedMetadataTypes(hidl_cb);
+ std::vector<common::MetadataTypeDescription> desc = common::listSupportedMetadataTypes();
+ std::vector<IMapper::MetadataTypeDescription> hidl_description(desc.size());
+ std::copy(desc.begin(), desc.end(), hidl_description.begin());
+ hidl_cb(hidl::Error::NONE, hidl_vec(hidl_description));
return Void();
}
Return<void> GrallocMapper::dumpBuffer(void *buffer, dumpBuffer_cb hidl_cb)
{
- common::dumpBuffer(buffer, hidl_cb);
+ common::BufferDump out;
+ hidl::Error err = static_cast<hidl::Error>(common::dumpBuffer(common::getBuffer(buffer), out));
+ hidl_cb(err, static_cast<IMapper::BufferDump>(out));
return Void();
}
Return<void> GrallocMapper::dumpBuffers(dumpBuffers_cb hidl_cb)
{
- common::dumpBuffers(hidl_cb);
+ auto bufferDump = common::dumpBuffers();
+ std::vector<IMapper::BufferDump> outBufDump;
+ for (auto dump : bufferDump) {
+ outBufDump.push_back(static_cast<IMapper::BufferDump>(dump));
+ }
+ hidl_cb(hidl::Error::NONE, hidl_vec(outBufDump));
return Void();
}
Return<void> GrallocMapper::getReservedRegion(void *buffer, getReservedRegion_cb hidl_cb)
{
- common::getReservedRegion(buffer, hidl_cb);
+ void *reservedRegion = nullptr;
+ uint64_t reservedSize = 0;
+ hidl::Error err = static_cast<hidl::Error>(
+ common::getReservedRegion(static_cast<buffer_handle_t>(buffer),
+ &reservedRegion, reservedSize));
+ if (err != hidl::Error::NONE) {
+ reservedRegion = nullptr;
+ reservedSize = 0;
+ }
+ hidl_cb(err, reservedRegion, reservedSize);
return Void();
}
diff --git a/gralloc4/src/4.x/GrallocMapper.h b/gralloc4/src/4.x/GrallocMapper.h
index 959efa5..7c45199 100644
--- a/gralloc4/src/4.x/GrallocMapper.h
+++ b/gralloc4/src/4.x/GrallocMapper.h
@@ -50,9 +50,9 @@
Return<void> importBuffer(const hidl_handle &rawHandle, importBuffer_cb hidl_cb) override;
- Return<Error> freeBuffer(void *buffer) override;
+ Return<hidl::Error> freeBuffer(void *buffer) override;
- Return<Error> validateBufferSize(void *buffer, const IMapper::BufferDescriptorInfo &descriptorInfo,
+ Return<hidl::Error> validateBufferSize(void *buffer, const IMapper::BufferDescriptorInfo &descriptorInfo,
uint32_t stride) override;
Return<void> getTransportSize(void *buffer, getTransportSize_cb _hidl_cb) override;
@@ -64,13 +64,13 @@
Return<void> flushLockedBuffer(void *buffer, flushLockedBuffer_cb hidl_cb) override;
- Return<Error> rereadLockedBuffer(void *buffer) override;
+ Return<hidl::Error> rereadLockedBuffer(void *buffer) override;
Return<void> isSupported(const IMapper::BufferDescriptorInfo &description, isSupported_cb hidl_cb) override;
Return<void> get(void *buffer, const MetadataType &metadataType, IMapper::get_cb hidl_cb) override;
- Return<Error> set(void *buffer, const MetadataType &metadataType, const hidl_vec<uint8_t> &metadata) override;
+ Return<hidl::Error> set(void *buffer, const MetadataType &metadataType, const hidl_vec<uint8_t> &metadata) override;
Return<void> getFromBufferDescriptorInfo(BufferDescriptorInfo const &description, MetadataType const &metadataType,
getFromBufferDescriptorInfo_cb hidl_cb) override;
diff --git a/gralloc4/src/4.x/gralloc_mapper_hidl_header.h b/gralloc4/src/4.x/gralloc_mapper_hidl_header.h
deleted file mode 100644
index 6d3d549..0000000
--- a/gralloc4/src/4.x/gralloc_mapper_hidl_header.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright (C) 2020 Arm Limited. All rights reserved.
- *
- * Copyright 2016 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.
- */
-
-#ifndef GRALLOC_MAPPER_HIDL_HEADER_H
-#define GRALLOC_MAPPER_HIDL_HEADER_H
-
-#include <android/hardware/graphics/mapper/4.0/IMapper.h>
-#include "mali_fourcc.h"
-#include <gralloctypes/Gralloc4.h>
-
-using android::hardware::graphics::mapper::V4_0::Error;
-using android::hardware::graphics::mapper::V4_0::BufferDescriptor;
-using android::hardware::graphics::common::V1_2::PixelFormat;
-using android::hardware::graphics::common::V1_2::BufferUsage;
-using android::hardware::graphics::mapper::V4_0::IMapper;
-
-#endif
diff --git a/gralloc4/src/Android.bp b/gralloc4/src/Android.bp
index 5f89832..1f640ea 100644
--- a/gralloc4/src/Android.bp
+++ b/gralloc4/src/Android.bp
@@ -1,4 +1,3 @@
-
/*
* Copyright (C) 2020 Arm Limited.
* SPDX-License-Identifier: Apache-2.0
@@ -21,62 +20,16 @@
}
cc_library_headers {
- name: "libgralloc_headers",
- vendor: true,
- host_supported: true,
- export_include_dirs: [
- ".",
- ],
- header_libs: [
- "libsystem_headers",
- ],
- export_header_lib_headers: [
- "libsystem_headers",
- ],
-}
-
-cc_library_shared {
- name: "libGralloc4Wrapper",
- vendor: true,
- defaults: [
- "arm_gralloc_defaults",
- ],
- srcs: [
- "libGralloc4Wrapper/wrapper.cpp",
- "allocator/mali_gralloc_ion.cpp",
- "core/format_info.cpp",
- "core/mali_gralloc_formats.cpp",
- "core/mali_gralloc_bufferallocation.cpp",
- "core/mali_gralloc_bufferdescriptor.cpp",
- "core/mali_gralloc_reference.cpp",
- ":libgralloc_hidl_common_shared_metadata",
- ],
- cflags: [
- "-DGRALLOC_LIBRARY_BUILD=1",
- "-Wthread-safety",
- ],
- static_libs: [
- "libgralloc_capabilities",
- ],
- shared_libs: [
- "liblog",
- "libcutils",
- "libutils",
- "libsync",
- "libhardware",
- "libhidlbase",
- "libhidltransport",
- "libnativewindow",
- "android.hardware.graphics.common@1.2",
- "android.hardware.graphics.common-V4-ndk",
- "android.hardware.graphics.mapper@4.0",
- "libdmabufheap",
- "libgralloctypes",
- "libdrm",
- ],
- header_libs: [
- "google_hal_headers",
- "device_kernel_headers",
- ],
- export_include_dirs: ["libGralloc4Wrapper/include"]
+ name: "libgralloc_headers",
+ vendor: true,
+ export_include_dirs: [
+ ".",
+ ],
+ header_libs: [
+ "libsystem_headers",
+ "//hardware/google/graphics/common:pixel-gralloc-headers",
+ ],
+ export_header_lib_headers: [
+ "libsystem_headers",
+ ],
}
diff --git a/gralloc4/src/aidl/Android.bp b/gralloc4/src/aidl/Android.bp
index e2d9d04..3c0fc26 100644
--- a/gralloc4/src/aidl/Android.bp
+++ b/gralloc4/src/aidl/Android.bp
@@ -10,7 +10,7 @@
"arm_gralloc_api_4x_defaults",
],
shared_libs: [
- "android.hardware.graphics.allocator-V1-ndk",
+ "android.hardware.graphics.allocator-V2-ndk",
"android.hardware.graphics.allocator@4.0",
"android.hardware.graphics.mapper@4.0",
"libbinder_ndk",
diff --git a/gralloc4/src/aidl/GrallocAllocator.cpp b/gralloc4/src/aidl/GrallocAllocator.cpp
index 6945505..2b01b80 100644
--- a/gralloc4/src/aidl/GrallocAllocator.cpp
+++ b/gralloc4/src/aidl/GrallocAllocator.cpp
@@ -4,9 +4,9 @@
#include <aidlcommonsupport/NativeHandle.h>
#include <android/binder_ibinder.h>
#include <android/binder_status.h>
+#include <cutils/android_filesystem_config.h>
#include <hidl/HidlSupport.h>
-#include "allocator/mali_gralloc_ion.h"
#include "hidl_common/Allocator.h"
namespace pixel::allocator {
@@ -22,6 +22,10 @@
return static_cast<unsigned long>(AIBinder_getCallingPid());
}
+unsigned long callingUid() {
+ return static_cast<unsigned long>(AIBinder_getCallingUid());
+}
+
GrallocAllocator::GrallocAllocator() {}
GrallocAllocator::~GrallocAllocator() {}
@@ -83,4 +87,111 @@
return ndk::ScopedAStatus::ok();
}
+buffer_descriptor_t decodeBufferDescriptorInfo(
+ const AidlAllocator::BufferDescriptorInfo& descriptor) {
+ buffer_descriptor_t bufferDescriptor;
+ bufferDescriptor.width = descriptor.width;
+ bufferDescriptor.height = descriptor.height;
+ bufferDescriptor.layer_count = descriptor.layerCount;
+ bufferDescriptor.hal_format = static_cast<uint64_t>(descriptor.format);
+ bufferDescriptor.producer_usage = static_cast<uint64_t>(descriptor.usage);
+ bufferDescriptor.consumer_usage = bufferDescriptor.producer_usage;
+ bufferDescriptor.format_type = MALI_GRALLOC_FORMAT_TYPE_USAGE;
+ bufferDescriptor.signature = sizeof(buffer_descriptor_t);
+ bufferDescriptor.reserved_size = descriptor.reservedSize;
+ const char *str = (const char*) descriptor.name.data();
+ bufferDescriptor.name = std::string(str);
+ return bufferDescriptor;
+}
+
+ndk::ScopedAStatus GrallocAllocator::allocate2(
+ const AidlAllocator::BufferDescriptorInfo& descriptor, int32_t count,
+ AidlAllocator::AllocationResult* result) {
+ MALI_GRALLOC_LOGV("Allocation request from process: %lu", callingPid());
+
+ buffer_descriptor_t bufferDescriptor = decodeBufferDescriptorInfo(descriptor);
+
+ HidlError error = HidlError::NONE;
+ auto hidl_cb = [&](HidlError _error, int _stride, hidl_vec<hidl_handle> _buffers) {
+ if (_error != HidlError::NONE) {
+ error = _error;
+ return;
+ }
+
+ const uint32_t size = _buffers.size();
+
+ result->stride = _stride;
+ result->buffers.resize(size);
+ for (uint32_t i = 0; i < size; i++) {
+ // Dup here is necessary. After this callback returns common::allocate
+ // will free the buffer which will destroy the older fd.
+ result->buffers[i] = android::dupToAidl(static_cast<const native_handle*>(_buffers[i]));
+ }
+ };
+
+ arm::allocator::common::allocate(bufferDescriptor, count, hidl_cb);
+
+ switch (error) {
+ case HidlError::NONE:
+ break;
+
+ case HidlError::BAD_DESCRIPTOR:
+ return ndk::ScopedAStatus::fromServiceSpecificError(
+ static_cast<int32_t>(AidlAllocator::AllocationError::BAD_DESCRIPTOR));
+
+ case HidlError::NO_RESOURCES:
+ return ndk::ScopedAStatus::fromServiceSpecificError(
+ static_cast<int32_t>(AidlAllocator::AllocationError::NO_RESOURCES));
+
+ case HidlError::UNSUPPORTED:
+ return ndk::ScopedAStatus::fromServiceSpecificError(
+ static_cast<int32_t>(AidlAllocator::AllocationError::UNSUPPORTED));
+
+ default:
+ return ndk::ScopedAStatus::fromStatus(STATUS_UNKNOWN_ERROR);
+ }
+
+ return ndk::ScopedAStatus::ok();
+}
+
+// TODO(b/315883761): isSupported should return false for unknown-to-HAL usage
+ndk::ScopedAStatus GrallocAllocator::isSupported(
+ const AidlAllocator::BufferDescriptorInfo& descriptor, bool* result) {
+ buffer_descriptor_t bufferDescriptor = decodeBufferDescriptorInfo(descriptor);
+
+ int isBufferDescriptorSupported = arm::allocator::common::isSupported(&bufferDescriptor);
+ *result = (isBufferDescriptorSupported == 0);
+
+ if (isBufferDescriptorSupported) {
+ MALI_GRALLOC_LOGV("Allocation for the given description will not succeed. error %d",
+ isBufferDescriptorSupported);
+ return ndk::ScopedAStatus::fromServiceSpecificError(
+ static_cast<int32_t>(AidlAllocator::AllocationError::UNSUPPORTED));
+ }
+ return ndk::ScopedAStatus::ok();
+}
+
+ndk::ScopedAStatus GrallocAllocator::getIMapperLibrarySuffix(std::string* result) {
+ *result = "";
+ return ndk::ScopedAStatus::fromStatus(STATUS_UNKNOWN_ERROR);
+}
+
+binder_status_t GrallocAllocator::dump(int fd, const char** /* args */, uint32_t numArgs) {
+ if (callingUid() != AID_ROOT) {
+ const std::string permission_denied = "Permission Denied\n";
+ write(fd, permission_denied.c_str(), permission_denied.size());
+ return STATUS_PERMISSION_DENIED;
+ }
+
+ if (numArgs != 0) {
+ const std::string argument_error = "No argument expected\n";
+ write(fd, argument_error.c_str(), argument_error.size());
+ return STATUS_BAD_VALUE;
+ }
+
+ const std::string dump_info = arm::allocator::common::dump();
+ write(fd, dump_info.c_str(), dump_info.size());
+ return STATUS_OK;
+}
+
} // namespace pixel::allocator
diff --git a/gralloc4/src/aidl/GrallocAllocator.h b/gralloc4/src/aidl/GrallocAllocator.h
index 82d4657..91655a7 100644
--- a/gralloc4/src/aidl/GrallocAllocator.h
+++ b/gralloc4/src/aidl/GrallocAllocator.h
@@ -2,9 +2,11 @@
#include <aidl/android/hardware/graphics/allocator/AllocationResult.h>
#include <aidl/android/hardware/graphics/allocator/BnAllocator.h>
+#include <aidl/android/hardware/graphics/allocator/BufferDescriptorInfo.h>
#include <aidlcommonsupport/NativeHandle.h>
#include <cstdint>
+#include <string>
#include <vector>
namespace pixel {
@@ -20,6 +22,17 @@
virtual ndk::ScopedAStatus allocate(const std::vector<uint8_t>& descriptor, int32_t count,
AidlAllocator::AllocationResult* result) override;
+
+ virtual ndk::ScopedAStatus allocate2(const AidlAllocator::BufferDescriptorInfo& descriptor,
+ int32_t count,
+ AidlAllocator::AllocationResult* result) override;
+
+ virtual ndk::ScopedAStatus isSupported(const AidlAllocator::BufferDescriptorInfo& descriptor,
+ bool* result) override;
+
+ virtual ndk::ScopedAStatus getIMapperLibrarySuffix(std::string* result) override;
+
+ virtual binder_status_t dump(int fd, const char** args, uint32_t numArgs) override;
};
} // namespace allocator
diff --git a/gralloc4/src/allocator/Android.bp b/gralloc4/src/allocator/Android.bp
index 630735b..3170c38 100644
--- a/gralloc4/src/allocator/Android.bp
+++ b/gralloc4/src/allocator/Android.bp
@@ -51,6 +51,7 @@
name: "arm_gralloc_allocator_defaults",
defaults: [
"arm_gralloc_defaults",
+ "android.hardware.graphics.common-ndk_shared",
],
soong_config_variables: {
gralloc_use_ion_dma_heap: {
@@ -88,7 +89,6 @@
"libsync",
"libutils",
"libnativewindow",
- "android.hardware.graphics.common-V4-ndk",
],
header_libs: [
"libnativebase_headers",
diff --git a/gralloc4/src/allocator/mali_gralloc_ion.cpp b/gralloc4/src/allocator/mali_gralloc_ion.cpp
index 986af11..3a955d9 100644
--- a/gralloc4/src/allocator/mali_gralloc_ion.cpp
+++ b/gralloc4/src/allocator/mali_gralloc_ion.cpp
@@ -55,6 +55,7 @@
static const char kDmabufFaceauthTpuHeapName[] = "faceauth_tpu-secure";
static const char kDmabufFaceauthImgHeapName[] = "faimg-secure";
static const char kDmabufFaceauthRawImgHeapName[] = "farawimg-secure";
+static const char kDmabufFaceauthEvalHeapName[] = "faeval-secure";
static const char kDmabufFaceauthPrevHeapName[] = "faprev-secure";
static const char kDmabufFaceauthModelHeapName[] = "famodel-secure";
static const char kDmabufVframeSecureHeapName[] = "vframe-secure";
@@ -87,9 +88,14 @@
std::string name;
};
- static const std::array<HeapSpecifier, 7> exact_usage_heaps =
+ static const std::array<HeapSpecifier, 8> exact_usage_heaps =
{{
// Faceauth heaps
+ { // faceauth_evaluation_heap - used mostly on debug builds
+ GRALLOC_USAGE_PROTECTED | GRALLOC_USAGE_HW_CAMERA_WRITE | GRALLOC_USAGE_HW_CAMERA_READ |
+ GS101_GRALLOC_USAGE_FACEAUTH_RAW_EVAL,
+ kDmabufFaceauthEvalHeapName
+ },
{ // isp_image_heap
GRALLOC_USAGE_PROTECTED | GRALLOC_USAGE_HW_CAMERA_WRITE | GS101_GRALLOC_USAGE_TPU_INPUT,
kDmabufFaceauthImgHeapName
@@ -200,18 +206,22 @@
return "";
}
-int alloc_from_dmabuf_heap(uint64_t usage, size_t size, const std::string& buffer_name = "")
+int alloc_from_dmabuf_heap(uint64_t usage, size_t size, const std::string& buffer_name = "", bool use_placeholder = false)
{
ATRACE_CALL();
if (size == 0) { return -1; }
- auto heap_name = select_dmabuf_heap(usage);
+ auto heap_name = use_placeholder ? "system" : select_dmabuf_heap(usage);
+ if (use_placeholder) size = 1;
+
if (heap_name.empty()) {
MALI_GRALLOC_LOGW("No heap found for usage: %s (0x%" PRIx64 ")", describe_usage(usage).c_str(), usage);
return -EINVAL;
}
- ATRACE_NAME(("alloc_from_dmabuf_heap " + heap_name).c_str());
+ std::stringstream tag;
+ tag << "heap: " << heap_name << ", bytes: " << size;
+ ATRACE_NAME(tag.str().c_str());
int shared_fd = get_allocator().Alloc(heap_name, size, 0);
if (shared_fd < 0)
{
@@ -350,7 +360,7 @@
*/
int mali_gralloc_ion_allocate(const gralloc_buffer_descriptor_t *descriptors,
uint32_t numDescriptors, buffer_handle_t *pHandle,
- bool *shared_backend, int ion_fd)
+ bool *shared_backend, bool use_placeholder)
{
ATRACE_CALL();
GRALLOC_UNUSED(shared_backend);
@@ -394,11 +404,7 @@
{
int& fd = hnd->fds[fidx];
- if (ion_fd >= 0 && fidx == 0) {
- fd = ion_fd;
- } else {
- fd = alloc_from_dmabuf_heap(usage, bufDescriptor->alloc_sizes[fidx], bufDescriptor->name);
- }
+ fd = alloc_from_dmabuf_heap(usage, bufDescriptor->alloc_sizes[fidx], bufDescriptor->name, use_placeholder);
if (fd < 0)
{
@@ -411,6 +417,8 @@
}
}
+ if (use_placeholder) return 0;
+
#if defined(GRALLOC_INIT_AFBC) && (GRALLOC_INIT_AFBC == 1)
ATRACE_NAME("AFBC init block");
unsigned char *cpu_ptr = NULL;
diff --git a/gralloc4/src/allocator/mali_gralloc_ion.h b/gralloc4/src/allocator/mali_gralloc_ion.h
index d826650..06d240b 100644
--- a/gralloc4/src/allocator/mali_gralloc_ion.h
+++ b/gralloc4/src/allocator/mali_gralloc_ion.h
@@ -24,7 +24,7 @@
int mali_gralloc_ion_allocate_attr(private_handle_t *hnd);
int mali_gralloc_ion_allocate(const gralloc_buffer_descriptor_t *descriptors,
uint32_t numDescriptors, buffer_handle_t *pHandle, bool *alloc_from_backing_store,
- int ion_fd = -1);
+ bool use_placeholder = false);
void mali_gralloc_ion_free(private_handle_t * const hnd);
int mali_gralloc_ion_sync_start(const private_handle_t * const hnd,
const bool read, const bool write);
diff --git a/gralloc4/src/capabilities/Android.bp b/gralloc4/src/capabilities/Android.bp
index 2b25811..46d3376 100644
--- a/gralloc4/src/capabilities/Android.bp
+++ b/gralloc4/src/capabilities/Android.bp
@@ -67,6 +67,7 @@
name: "arm_gralloc_capabilities_defaults",
defaults: [
"arm_gralloc_defaults",
+ "android.hardware.graphics.common-ndk_shared",
],
soong_config_variables: {
mali_gpu_support_afbc_basic: {
@@ -119,7 +120,6 @@
"libcutils",
"libsync",
"libutils",
- "android.hardware.graphics.common-V4-ndk",
],
}
diff --git a/gralloc4/src/core/Android.bp b/gralloc4/src/core/Android.bp
index b2e5ca3..a6ee46e 100644
--- a/gralloc4/src/core/Android.bp
+++ b/gralloc4/src/core/Android.bp
@@ -39,6 +39,7 @@
name: "arm_gralloc_core_defaults",
defaults: [
"arm_gralloc_defaults",
+ "android.hardware.graphics.common-ndk_shared",
],
soong_config_variables: {
gralloc_ion_sync_on_lock: {
@@ -69,7 +70,6 @@
"libcutils",
"libutils",
"android.hardware.graphics.common@1.2",
- "android.hardware.graphics.common-V4-ndk",
],
target: {
android: {
diff --git a/gralloc4/src/core/format_info.cpp b/gralloc4/src/core/format_info.cpp
index 14a1d84..b9ddbf2 100644
--- a/gralloc4/src/core/format_info.cpp
+++ b/gralloc4/src/core/format_info.cpp
@@ -156,7 +156,7 @@
{ .id = MALI_GRALLOC_FORMAT_INTERNAL_Y410, .cpu_rd = F_LIN, .cpu_wr = F_LIN, .gpu_rd = F_LIN, .gpu_wr = F_LIN|F_AFBC, .dpu_rd = F_NONE, .dpu_wr = F_NONE, .dpu_aeu_wr = F_NONE, .vpu_rd = F_NONE, .vpu_wr = F_NONE, .cam_wr = F_NONE, },
/* Other */
{ .id = MALI_GRALLOC_FORMAT_INTERNAL_RAW16, .cpu_rd = F_LIN, .cpu_wr = F_LIN, .gpu_rd = F_LIN, .gpu_wr = F_NONE, .dpu_rd = F_NONE, .dpu_wr = F_NONE, .dpu_aeu_wr = F_NONE, .vpu_rd = F_NONE, .vpu_wr = F_NONE, .cam_wr = F_LIN, },
- { .id = MALI_GRALLOC_FORMAT_INTERNAL_RAW12, .cpu_rd = F_LIN, .cpu_wr = F_LIN, .gpu_rd = F_NONE, .gpu_wr = F_NONE, .dpu_rd = F_NONE, .dpu_wr = F_NONE, .dpu_aeu_wr = F_NONE, .vpu_rd = F_NONE, .vpu_wr = F_NONE, .cam_wr = F_LIN, },
+ { .id = MALI_GRALLOC_FORMAT_INTERNAL_RAW12, .cpu_rd = F_LIN, .cpu_wr = F_LIN, .gpu_rd = F_LIN, .gpu_wr = F_NONE, .dpu_rd = F_NONE, .dpu_wr = F_NONE, .dpu_aeu_wr = F_NONE, .vpu_rd = F_NONE, .vpu_wr = F_NONE, .cam_wr = F_LIN, },
{ .id = MALI_GRALLOC_FORMAT_INTERNAL_RAW10, .cpu_rd = F_LIN, .cpu_wr = F_LIN, .gpu_rd = F_LIN, .gpu_wr = F_NONE, .dpu_rd = F_NONE, .dpu_wr = F_NONE, .dpu_aeu_wr = F_NONE, .vpu_rd = F_NONE, .vpu_wr = F_NONE, .cam_wr = F_LIN, },
{ .id = MALI_GRALLOC_FORMAT_INTERNAL_BLOB, .cpu_rd = F_LIN, .cpu_wr = F_LIN, .gpu_rd = F_LIN, .gpu_wr = F_LIN, .dpu_rd = F_NONE, .dpu_wr = F_NONE, .dpu_aeu_wr = F_NONE, .vpu_rd = F_NONE, .vpu_wr = F_NONE, .cam_wr = F_LIN, },
/* Depth and Stencil */
@@ -238,7 +238,7 @@
{ HAL_PIXEL_FORMAT_BLOB, false, MALI_GRALLOC_FORMAT_INTERNAL_BLOB },
{ HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, true, MALI_GRALLOC_FORMAT_INTERNAL_NV12 },
{ HAL_PIXEL_FORMAT_YCbCr_420_888, true, MALI_GRALLOC_FORMAT_INTERNAL_NV12 },
- { HAL_PIXEL_FORMAT_RAW_OPAQUE, false, MALI_GRALLOC_FORMAT_INTERNAL_RAW10 },
+ { HAL_PIXEL_FORMAT_RAW_OPAQUE, false, MALI_GRALLOC_FORMAT_INTERNAL_UNDEFINED },
{ HAL_PIXEL_FORMAT_RAW10, false, MALI_GRALLOC_FORMAT_INTERNAL_RAW10 },
{ HAL_PIXEL_FORMAT_RAW12, false, MALI_GRALLOC_FORMAT_INTERNAL_RAW12 },
{ HAL_PIXEL_FORMAT_YCbCr_422_888, true, MALI_GRALLOC_FORMAT_INTERNAL_YUV422_8BIT },
diff --git a/gralloc4/src/core/format_info.h b/gralloc4/src/core/format_info.h
index ad2db6d..3742a38 100644
--- a/gralloc4/src/core/format_info.h
+++ b/gralloc4/src/core/format_info.h
@@ -35,8 +35,8 @@
typedef struct
{
- uint16_t width;
- uint16_t height;
+ uint64_t width;
+ uint64_t height;
} rect_t;
constexpr bool is_power2(uint8_t n)
diff --git a/gralloc4/src/core/mali_gralloc_bufferallocation.cpp b/gralloc4/src/core/mali_gralloc_bufferallocation.cpp
index d67eeb8..54e7f2f 100644
--- a/gralloc4/src/core/mali_gralloc_bufferallocation.cpp
+++ b/gralloc4/src/core/mali_gralloc_bufferallocation.cpp
@@ -82,11 +82,11 @@
return id | counter++;
}
-static void afbc_buffer_align(const bool is_tiled, int *size)
+template<typename T>
+static void afbc_buffer_align(const bool is_tiled, T *size)
{
- const uint16_t AFBC_BODY_BUFFER_BYTE_ALIGNMENT = 1024;
-
- int buffer_byte_alignment = AFBC_BODY_BUFFER_BYTE_ALIGNMENT;
+ constexpr T AFBC_BODY_BUFFER_BYTE_ALIGNMENT = 1024;
+ T buffer_byte_alignment = AFBC_BODY_BUFFER_BYTE_ALIGNMENT;
if (is_tiled)
{
@@ -244,13 +244,13 @@
*/
void init_afbc(uint8_t *buf, const uint64_t alloc_format,
const bool is_multi_plane,
- const int w, const int h)
+ const uint64_t w, const uint64_t h)
{
ATRACE_CALL();
const bool is_tiled = ((alloc_format & MALI_GRALLOC_INTFMT_AFBC_TILED_HEADERS)
== MALI_GRALLOC_INTFMT_AFBC_TILED_HEADERS);
const uint32_t n_headers = (w * h) / AFBC_PIXELS_PER_BLOCK;
- int body_offset = n_headers * AFBC_HEADER_BUFFER_BYTES_PER_BLOCKENTRY;
+ uint32_t body_offset = n_headers * AFBC_HEADER_BUFFER_BYTES_PER_BLOCKENTRY;
afbc_buffer_align(is_tiled, &body_offset);
@@ -266,7 +266,7 @@
if ((alloc_format & MALI_GRALLOC_INTFMT_AFBC_TILED_HEADERS))
{
/* Zero out body_offset for non-subsampled formats. */
- memset(headers[0], 0, sizeof(uint32_t) * 4);
+ memset(headers[0], 0, sizeof(size_t) * 4);
}
/* Map base format to AFBC header layout */
@@ -295,24 +295,14 @@
}
}
-static int max(int a, int b)
-{
- return a > b ? a : b;
-}
-
-static int max(int a, int b, int c)
-{
- return c > max(a, b) ? c : max(a, b);
-}
-
/*
* Obtain plane allocation dimensions (in pixels).
*
* NOTE: pixel stride, where defined for format, is
* incorporated into allocation dimensions.
*/
-static void get_pixel_w_h(uint32_t * const width,
- uint32_t * const height,
+static void get_pixel_w_h(uint64_t * const width,
+ uint64_t * const height,
const format_info_t format,
const alloc_type_t alloc_type,
const uint8_t plane,
@@ -345,14 +335,14 @@
* Pixel alignment (width),
* where format stride is stated in pixels.
*/
- int pixel_align_w = 1, pixel_align_h = 1;
+ uint32_t pixel_align_w = 1, pixel_align_h = 1;
if (has_cpu_usage && is_primary_plane)
{
pixel_align_w = format.align_w_cpu;
}
else if (alloc_type.is_afbc())
{
-#define HEADER_STRIDE_ALIGN_IN_SUPER_BLOCKS (0)
+ constexpr uint32_t HEADER_STRIDE_ALIGN_IN_SUPER_BLOCKS = 0;
uint32_t num_sb_align = 0;
if (alloc_type.is_padded && !format.is_yuv)
{
@@ -361,7 +351,7 @@
*/
num_sb_align = 4;
}
- pixel_align_w = max(HEADER_STRIDE_ALIGN_IN_SUPER_BLOCKS, num_sb_align) * sb.width;
+ pixel_align_w = std::max(HEADER_STRIDE_ALIGN_IN_SUPER_BLOCKS, num_sb_align) * sb.width;
/*
* Determine AFBC tile size when allocating tiled headers.
@@ -373,13 +363,13 @@
afbc_tile.height = format.bpp_afbc[plane] > 32 ? 4 * afbc_tile.height : 8 * afbc_tile.height;
}
- MALI_GRALLOC_LOGV("Plane[%hhu]: [SUB-SAMPLE] w:%d, h:%d\n", plane, *width, *height);
+ MALI_GRALLOC_LOGV("Plane[%hhu]: [SUB-SAMPLE] w:%" PRIu64 ", h:%" PRIu64 "\n", plane, *width, *height);
MALI_GRALLOC_LOGV("Plane[%hhu]: [PIXEL_ALIGN] w:%d\n", plane, pixel_align_w);
MALI_GRALLOC_LOGV("Plane[%hhu]: [LINEAR_TILE] w:%" PRIu16 "\n", plane, format.tile_size);
- MALI_GRALLOC_LOGV("Plane[%hhu]: [AFBC_TILE] w:%" PRIu16 ", h:%" PRIu16 "\n", plane, afbc_tile.width, afbc_tile.height);
+ MALI_GRALLOC_LOGV("Plane[%hhu]: [AFBC_TILE] w:%" PRIu64 ", h:%" PRIu64 "\n", plane, afbc_tile.width, afbc_tile.height);
- pixel_align_w = max(pixel_align_w, afbc_tile.width);
- pixel_align_h = max(pixel_align_h, afbc_tile.height);
+ pixel_align_w = std::max(static_cast<uint64_t>(pixel_align_w), afbc_tile.width);
+ pixel_align_h = std::max(static_cast<uint64_t>(pixel_align_h), afbc_tile.height);
if (AllocBaseType::AFBC_WIDEBLK == alloc_type.primary_type && !alloc_type.is_tiled)
{
@@ -391,18 +381,17 @@
* Note that this branch will not be taken for multi-plane AFBC
* since that requires tiled headers.
*/
- pixel_align_h = max(pixel_align_h, 16);
+ pixel_align_h = std::max(pixel_align_h, 16u);
}
}
- *width = GRALLOC_ALIGN(*width, max(1, pixel_align_w, format.tile_size));
- *height = GRALLOC_ALIGN(*height, max(1, pixel_align_h, format.tile_size));
+ *width = GRALLOC_ALIGN(*width, std::max({1u, pixel_align_w, static_cast<uint32_t>(format.tile_size)}));
+ *height = GRALLOC_ALIGN(*height, std::max({1u, pixel_align_h, static_cast<uint32_t>(format.tile_size)}));
}
-
-
-static uint32_t gcd(uint32_t a, uint32_t b)
+template<typename T>
+static T gcd(T a, T b)
{
- uint32_t r, t;
+ T r, t;
if (a == b)
{
@@ -425,14 +414,15 @@
return a;
}
-uint32_t lcm(uint32_t a, uint32_t b)
+template<typename T>
+T lcm(T a, T b)
{
if (a != 0 && b != 0)
{
return (a * b) / gcd(a, b);
}
- return max(a, b);
+ return std::max(a, b);
}
@@ -447,9 +437,9 @@
* constraints, the luma stride must be doubled.
*/
static void update_yv12_stride(int8_t plane,
- uint32_t luma_stride,
+ size_t luma_stride,
uint32_t stride_align,
- uint32_t * byte_stride)
+ uint64_t * byte_stride)
{
// https://developer.android.com/reference/android/graphics/ImageFormat#YV12
if (plane == 0) {
@@ -464,23 +454,66 @@
#endif
/*
- * Logs and returns true if deprecated usage bits are found
+ * Logs and returns false if deprecated usage bits are found
*
* At times, framework introduces new usage flags which are identical to what
* vendor has been using internally. This method logs those bits and returns
* true if there is any deprecated usage bit.
- *
- * TODO(layog@): This check is also performed again during format deduction. At
- * that point, the allocation is not aborted, just a log is printed to ALOGE
- * (matched against `VALID_USAGE`). These should be aligned.
*/
-static bool log_deprecated_usage_flags(uint64_t usage) {
+static bool log_obsolete_usage_flags(uint64_t usage) {
if (usage & DEPRECATED_MALI_GRALLOC_USAGE_FRONTBUFFER) {
MALI_GRALLOC_LOGW("Using deprecated FRONTBUFFER usage bit, please upgrade to BufferUsage::FRONT_BUFFER");
- return true;
+ return false;
+ }
+ if (usage & UNSUPPORTED_MALI_GRALLOC_USAGE_CUBE_MAP) {
+ MALI_GRALLOC_LOGW("BufferUsage::GPU_CUBE_MAP is unsupported");
+ return false;
+ }
+ if (usage & UNSUPPORTED_MALI_GRALLOC_USAGE_MIPMAP_COMPLETE) {
+ MALI_GRALLOC_LOGW("BufferUsage::GPU_MIPMAP_COMPLETE is unsupported");
+ return false;
}
- return false;
+ return true;
+}
+
+static bool validate_size(uint32_t layer_count, uint32_t width, uint32_t height) {
+ // The max size of an image can be from camera (50 Megapixels) and considering the max
+ // depth of 4 bytes per pixel, we get an image of size 200MB.
+ // We can keep twice the margin for a max size of 400MB.
+ uint64_t overflow_limit = 400 * (1 << 20);
+
+ // Maximum 4 bytes per pixel buffers are supported (RGBA). This does not take care of
+ // alignment, but 400MB is already very generous, so there should not be an issue.
+ overflow_limit /= 4;
+ overflow_limit /= layer_count;
+
+ if (width > overflow_limit) {
+ MALI_GRALLOC_LOGE("Parameters layer: %" PRIu32 ", width: %" PRIu32 ", height: %" PRIu32 " are too big", layer_count, width, height);
+ return false;
+ }
+ overflow_limit /= width;
+
+ if (height > overflow_limit) {
+ MALI_GRALLOC_LOGE("Parameters layer: %" PRIu32 ", width: %" PRIu32 ", height: %" PRIu32 " are too big", layer_count, width, height);
+ return false;
+ }
+
+ return true;
+}
+
+static bool validate_descriptor(buffer_descriptor_t * const bufDescriptor) {
+ if (!log_obsolete_usage_flags(bufDescriptor->producer_usage | bufDescriptor->consumer_usage)) {
+ return false;
+ }
+
+ // BLOB formats are used for some ML models whose size can be really large (up to 2GB)
+ if (bufDescriptor->hal_format != MALI_GRALLOC_FORMAT_INTERNAL_BLOB &&
+ !validate_size(bufDescriptor->layer_count, bufDescriptor->width, bufDescriptor->height)) {
+ return false;
+ }
+
+ return true;
}
/*
@@ -505,7 +538,7 @@
return usage;
}
-static void align_plane_stride(plane_info_t *plane_info, int plane, const format_info_t format, uint32_t stride_align)
+static void align_plane_stride(plane_info_t *plane_info, uint8_t plane, const format_info_t format, uint32_t stride_align)
{
plane_info[plane].byte_stride = GRALLOC_ALIGN(plane_info[plane].byte_stride * format.tile_size, stride_align) / format.tile_size;
plane_info[plane].alloc_width = plane_info[plane].byte_stride * 8 / format.bpp[plane];
@@ -540,8 +573,8 @@
const bool has_gpu_usage,
const bool has_BIG_usage,
const bool has_camera_usage,
- int * const pixel_stride,
- uint64_t * const size,
+ uint64_t * const pixel_stride,
+ uint64_t * const size,
plane_info_t plane_info[MAX_PLANES])
{
/* pixel_stride is set outside this function after this function is called */
@@ -563,7 +596,7 @@
alloc_type,
plane,
has_cpu_usage);
- MALI_GRALLOC_LOGV("Aligned w=%d, h=%d (in pixels)",
+ MALI_GRALLOC_LOGV("Aligned w=%" PRIu64 ", h=%" PRIu64 " (in pixels)",
plane_info[plane].alloc_width, plane_info[plane].alloc_height);
/*
@@ -577,7 +610,7 @@
else
{
assert((plane_info[plane].alloc_width * format.bpp[plane]) % 8 == 0);
- plane_info[plane].byte_stride = (static_cast<uint64_t>(plane_info[plane].alloc_width) * format.bpp[plane]) / 8;
+ plane_info[plane].byte_stride = (plane_info[plane].alloc_width * format.bpp[plane]) / 8;
/*
* Align byte stride (uncompressed allocations only).
@@ -588,7 +621,7 @@
*
* NOTE: Pixel stride is defined as multiple of 'align_w_cpu'.
*/
- uint16_t hw_align = 0;
+ uint32_t hw_align = 0;
if (has_hw_usage)
{
static_assert(is_power2(YUV_BYTE_ALIGN_DEFAULT),
@@ -609,7 +642,7 @@
/*
* The GPU requires stricter alignment on YUV and raw formats.
*/
- hw_align = std::max(hw_align, static_cast<uint16_t>(GPU_BYTE_ALIGN_DEFAULT));
+ hw_align = std::max(hw_align, static_cast<uint32_t>(GPU_BYTE_ALIGN_DEFAULT));
}
#ifdef SOC_ZUMA
@@ -619,13 +652,13 @@
/*
* Camera ISP requires RAW buffers to have 32-byte aligned stride
*/
- hw_align = std::max(hw_align, static_cast<uint16_t>(CAMERA_RAW_BUFFER_BYTE_ALIGN));
+ hw_align = std::max(hw_align, static_cast<uint32_t>(CAMERA_RAW_BUFFER_BYTE_ALIGN));
}
#endif
if (has_BIG_usage) {
assert(has_hw_usage);
- hw_align = lcm(hw_align, static_cast<uint16_t>(BIG_BYTE_ALIGN_DEFAULT));
+ hw_align = lcm(hw_align, static_cast<uint32_t>(BIG_BYTE_ALIGN_DEFAULT));
}
uint32_t cpu_align = 0;
@@ -661,7 +694,7 @@
}
#endif
}
- MALI_GRALLOC_LOGV("Byte stride: %d", plane_info[plane].byte_stride);
+ MALI_GRALLOC_LOGV("Byte stride: %" PRIu64, plane_info[plane].byte_stride);
const uint32_t sb_num = (plane_info[plane].alloc_width * plane_info[plane].alloc_height)
/ AFBC_PIXELS_PER_BLOCK;
@@ -669,11 +702,11 @@
/*
* Calculate body size (per plane).
*/
- int body_size = 0;
+ size_t body_size = 0;
if (alloc_type.is_afbc())
{
const rect_t sb = get_afbc_sb_size(alloc_type, plane);
- const int sb_bytes = GRALLOC_ALIGN((format.bpp_afbc[plane] * sb.width * sb.height) / 8, 128);
+ const size_t sb_bytes = GRALLOC_ALIGN((format.bpp_afbc[plane] * sb.width * sb.height) / 8, 128);
body_size = sb_num * sb_bytes;
/* When AFBC planes are stored in separate buffers and this is not the last plane,
@@ -685,7 +718,7 @@
if (alloc_type.is_frontbuffer_safe)
{
- int back_buffer_size = body_size;
+ size_t back_buffer_size = body_size;
afbc_buffer_align(alloc_type.is_tiled, &back_buffer_size);
body_size += back_buffer_size;
}
@@ -701,13 +734,13 @@
}
body_size = plane_info[plane].byte_stride * plane_info[plane].alloc_height;
}
- MALI_GRALLOC_LOGV("Body size: %d", body_size);
+ MALI_GRALLOC_LOGV("Body size: %zu", body_size);
/*
* Calculate header size (per plane).
*/
- int header_size = 0;
+ size_t header_size = 0;
if (alloc_type.is_afbc())
{
/* As this is AFBC, calculate header size for this plane.
@@ -716,7 +749,7 @@
header_size = sb_num * AFBC_HEADER_BUFFER_BYTES_PER_BLOCKENTRY;
afbc_buffer_align(alloc_type.is_tiled, &header_size);
}
- MALI_GRALLOC_LOGV("AFBC Header size: %d", header_size);
+ MALI_GRALLOC_LOGV("AFBC Header size: %zu", header_size);
/*
* Set offset for separate chroma planes.
@@ -942,7 +975,7 @@
{
MALI_GRALLOC_LOGE("buffer with format (%s %" PRIx64
") has size %" PRIu64
- " != byte_stride %" PRIu32 " * alloc_height %" PRIu32,
+ " != byte_stride %" PRIu64 " * alloc_height %" PRIu64,
format_name(bufDescriptor->alloc_format),
bufDescriptor->alloc_format,
plane[pidx].size, plane[pidx].byte_stride, plane[pidx].alloc_height);
@@ -987,10 +1020,14 @@
ATRACE_CALL();
alloc_type_t alloc_type{};
- int alloc_width = bufDescriptor->width;
- int alloc_height = bufDescriptor->height;
+ uint64_t alloc_width = bufDescriptor->width;
+ uint64_t alloc_height = bufDescriptor->height;
uint64_t usage = bufDescriptor->producer_usage | bufDescriptor->consumer_usage;
+ if (!validate_descriptor(bufDescriptor)) {
+ return -EINVAL;
+ }
+
/*
* Select optimal internal pixel format based upon
* usage and requested format.
@@ -1126,7 +1163,7 @@
int mali_gralloc_buffer_allocate(const gralloc_buffer_descriptor_t *descriptors,
uint32_t numDescriptors, buffer_handle_t *pHandle, bool *shared_backend,
- int fd)
+ bool use_placeholder)
{
std::string atrace_log = __FUNCTION__;
if (ATRACE_ENABLED()) {
@@ -1156,11 +1193,6 @@
bufDescriptor->consumer_usage = usage;
}
- if (log_deprecated_usage_flags(usage))
- {
- return -EINVAL;
- }
-
/* Derive the buffer size from descriptor parameters */
err = mali_gralloc_derive_format_and_size(bufDescriptor);
if (err != 0)
@@ -1170,7 +1202,7 @@
}
/* Allocate ION backing store memory */
- err = mali_gralloc_ion_allocate(descriptors, numDescriptors, pHandle, &shared, fd);
+ err = mali_gralloc_ion_allocate(descriptors, numDescriptors, pHandle, &shared, use_placeholder);
if (err < 0)
{
return err;
diff --git a/gralloc4/src/core/mali_gralloc_bufferallocation.h b/gralloc4/src/core/mali_gralloc_bufferallocation.h
index 3d759de..cc028ff 100644
--- a/gralloc4/src/core/mali_gralloc_bufferallocation.h
+++ b/gralloc4/src/core/mali_gralloc_bufferallocation.h
@@ -100,13 +100,11 @@
int mali_gralloc_buffer_allocate(const gralloc_buffer_descriptor_t *descriptors,
uint32_t numDescriptors, buffer_handle_t *pHandle, bool *shared_backend,
- int fd = -1);
+ bool use_placeholder = false);
int mali_gralloc_buffer_free(buffer_handle_t pHandle);
-void init_afbc(uint8_t *buf, uint64_t internal_format, const bool is_multi_plane, int w, int h);
-
-uint32_t lcm(uint32_t a, uint32_t b);
+void init_afbc(uint8_t *buf, uint64_t internal_format, const bool is_multi_plane, uint64_t w, uint64_t h);
bool get_alloc_type(const uint64_t format_ext,
const uint32_t format_idx,
diff --git a/gralloc4/src/core/mali_gralloc_bufferdescriptor.h b/gralloc4/src/core/mali_gralloc_bufferdescriptor.h
index 826af79..657b2af 100644
--- a/gralloc4/src/core/mali_gralloc_bufferdescriptor.h
+++ b/gralloc4/src/core/mali_gralloc_bufferdescriptor.h
@@ -51,7 +51,7 @@
* allocate the buffer.
*/
uint64_t alloc_sizes[MAX_PLANES];
- int pixel_stride;
+ uint64_t pixel_stride;
uint64_t alloc_format;
uint32_t fd_count;
uint32_t plane_count;
@@ -86,11 +86,11 @@
"name(%s)"
"reserved_size(%" PRIu64 ") "
"alloc_sizes(%" PRIu64 ", %" PRIu64 ", %" PRIu64 ")"
- "pixel_stride(%d) alloc_format(0x%" PRIx64 ") fd_count(%d) "
+ "pixel_stride(%" PRIu64 ") alloc_format(0x%" PRIx64 ") fd_count(%d) "
"plane_count(%u) "
- "plane[0](offset %" PRId64 ", idx %u, size %" PRIu64 " byte_stride %u, wh %u %u)"
- "plane[1](offset %" PRId64 ", idx %u, size %" PRIu64 " byte_stride %u, wh %u %u)"
- "plane[2](offset %" PRId64 ", idx %u, size %" PRIu64 " byte_stride %u, wh %u %u)"
+ "plane[0](offset %" PRId64 ", idx %u, size %" PRIu64 " byte_stride %" PRIu64 ", wh %" PRIu64 " %" PRIu64 ")"
+ "plane[1](offset %" PRId64 ", idx %u, size %" PRIu64 " byte_stride %" PRIu64 ", wh %" PRIu64 " %" PRIu64 ")"
+ "plane[2](offset %" PRId64 ", idx %u, size %" PRIu64 " byte_stride %" PRIu64 ", wh %" PRIu64 " %" PRIu64 ")"
"\n",
str.c_str(),
width, height,
diff --git a/gralloc4/src/core/mali_gralloc_formats.cpp b/gralloc4/src/core/mali_gralloc_formats.cpp
index 5048cac..e36e27d 100644
--- a/gralloc4/src/core/mali_gralloc_formats.cpp
+++ b/gralloc4/src/core/mali_gralloc_formats.cpp
@@ -408,8 +408,8 @@
*/
void mali_gralloc_adjust_dimensions(const uint64_t alloc_format,
const uint64_t usage,
- int* const width,
- int* const height)
+ uint64_t* const width,
+ uint64_t* const height)
{
/* Determine producers. */
const uint16_t producers = get_producers(usage);
@@ -444,7 +444,7 @@
}
MALI_GRALLOC_LOGV("%s: alloc_format=(%s 0x%" PRIx64 ") usage=(%s 0x%" PRIx64
- ") alloc_width=%u, alloc_height=%u",
+ ") alloc_width=%" PRIu64 ", alloc_height=%" PRIu64 "",
__FUNCTION__, format_name(alloc_format), alloc_format, describe_usage(usage).c_str(),
usage, *width, *height);
}
@@ -1502,7 +1502,7 @@
/* Reject if usage specified is outside white list of valid usages. */
if (type != MALI_GRALLOC_FORMAT_TYPE_INTERNAL && (usage & (~VALID_USAGE)) != 0)
{
- MALI_GRALLOC_LOGE("Invalid usage specified: %s 0x%" PRIx64, describe_usage(usage).c_str(), usage);
+ MALI_GRALLOC_LOGW("Invalid usage specified: %s 0x%" PRIx64, describe_usage(usage).c_str(), usage);
}
/* TODO: Make a function for finding formats that should be allocated as the request format */
diff --git a/gralloc4/src/core/mali_gralloc_reference.cpp b/gralloc4/src/core/mali_gralloc_reference.cpp
index 6726895..c685c13 100644
--- a/gralloc4/src/core/mali_gralloc_reference.cpp
+++ b/gralloc4/src/core/mali_gralloc_reference.cpp
@@ -20,6 +20,7 @@
#include <android-base/thread_annotations.h>
#include <hardware/gralloc1.h>
+#include <unistd.h>
#include <algorithm>
#include <map>
@@ -62,19 +63,25 @@
private_handle_t *hnd =
static_cast<private_handle_t *>(const_cast<native_handle_t *>(handle));
+ if (hnd->fd_count < 0 || hnd->fd_count > MAX_FDS) {
+ MALI_GRALLOC_LOGE("%s failed: invalid number of fds (%d)", __func__, hnd->fd_count);
+ return false;
+ }
+
int valid_fd_count = std::find(hnd->fds, hnd->fds + MAX_FDS, -1) - hnd->fds;
// One fd is reserved for metadata which is not accounted for in fd_count
- if (hnd->fd_count != valid_fd_count - 1) {
- MALI_GRALLOC_LOGE("%s failed: count of valid buffer fds does not match fd_count",
- __func__);
+ if (hnd->fd_count + 1 != valid_fd_count) {
+ MALI_GRALLOC_LOGE("%s failed: count of valid buffer fds does not match fd_count (%d != "
+ "%d)",
+ __func__, hnd->fd_count, valid_fd_count - 1);
return false;
}
auto check_pid = [&](int fd, uint64_t allocated_size) -> bool {
auto size = get_buffer_size(fd);
auto size_padding = size - (off_t)allocated_size;
- if ((size != -1) && ((size_padding < 0) || (size_padding > PAGE_SIZE))) {
- MALI_GRALLOC_LOGE("%s failed: fd (%d) size (%jd) is not within a PAGE_SIZE of "
+ if ((size != -1) && ((size_padding < 0) || (size_padding > getpagesize()))) {
+ MALI_GRALLOC_LOGE("%s failed: fd (%d) size (%jd) is not within a page of "
"expected size (%" PRIx64 ")",
__func__, fd, static_cast<intmax_t>(size), allocated_size);
return false;
diff --git a/gralloc4/src/gralloc_helper.h b/gralloc4/src/gralloc_helper.h
index ba31333..7add6a4 100644
--- a/gralloc4/src/gralloc_helper.h
+++ b/gralloc4/src/gralloc_helper.h
@@ -31,9 +31,4 @@
#define GRALLOC_UNUSED(x) ((void)x)
-static inline size_t round_up_to_page_size(size_t x)
-{
- return (x + (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);
-}
-
#endif /* GRALLOC_HELPER_H_ */
diff --git a/gralloc4/src/gralloc_priv.h b/gralloc4/src/gralloc_priv.h
index bbef1b6..1074e42 100644
--- a/gralloc4/src/gralloc_priv.h
+++ b/gralloc4/src/gralloc_priv.h
@@ -28,11 +28,6 @@
#include <sys/mman.h>
#include <cutils/native_handle.h>
-/* Allocator = 4.0, Mapper = 4.0 and Common = 1.2 */
-#define HIDL_ALLOCATOR_VERSION_SCALED 400
-#define HIDL_MAPPER_VERSION_SCALED 400
-#define HIDL_COMMON_VERSION_SCALED 120
-
#include "mali_gralloc_formats.h"
#include "mali_gralloc_usages.h"
#include "gralloc_helper.h"
diff --git a/gralloc4/src/hidl_common/Allocator.cpp b/gralloc4/src/hidl_common/Allocator.cpp
index 29cf3ca..08f2e8e 100644
--- a/gralloc4/src/hidl_common/Allocator.cpp
+++ b/gralloc4/src/hidl_common/Allocator.cpp
@@ -18,7 +18,13 @@
#define ATRACE_TAG ATRACE_TAG_GRAPHICS
+#include <array>
+#include <atomic>
+#include <chrono>
#include <utils/Trace.h>
+#include <shared_mutex>
+#include <sstream>
+#include <sys/stat.h>
#include "Allocator.h"
#include "core/mali_gralloc_bufferallocation.h"
@@ -35,6 +41,35 @@
namespace common
{
+struct BufferDetails {
+ std::string name;
+ uint64_t buffer_id;
+ std::vector<ino_t> inodes;
+ uint64_t format;
+ uint64_t usage;
+ uint32_t width;
+ uint32_t height;
+};
+
+uint64_t total_allocated = 0;
+std::atomic<uint16_t> next_idx = 0;
+
+// There is no atomic rounding off for atomics so next_idx can overflow. allocated_buffers should be
+// a power of 2.
+std::array<BufferDetails, 2048> allocated_buffers;
+std::shared_timed_mutex allocated_buffers_mutex;
+static_assert((allocated_buffers.size() & (allocated_buffers.size() - 1)) == 0);
+
+ino_t get_inode(int fd) {
+ struct stat fd_info;
+ int error = fstat(fd, &fd_info);
+ if (error != 0) {
+ return error;
+ }
+
+ return fd_info.st_ino;
+}
+
void allocate(const buffer_descriptor_t &bufferDescriptor, uint32_t count, IAllocator::allocate_cb hidl_cb,
std::function<int(const buffer_descriptor_t *, buffer_handle_t *)> fb_allocator)
{
@@ -45,6 +80,7 @@
Error error = Error::NONE;
int stride = 0;
+ bool use_placeholder = bufferDescriptor.producer_usage & GRALLOC_USAGE_PLACEHOLDER_BUFFER;
std::vector<hidl_handle> grallocBuffers;
gralloc_buffer_descriptor_t grallocBufferDescriptor[1];
@@ -66,7 +102,7 @@
else
#endif
{
- allocResult = mali_gralloc_buffer_allocate(grallocBufferDescriptor, 1, &tmpBuffer, nullptr);
+ allocResult = mali_gralloc_buffer_allocate(grallocBufferDescriptor, 1, &tmpBuffer, nullptr, use_placeholder);
if (allocResult != 0)
{
MALI_GRALLOC_LOGE("%s, buffer allocation failed with %d", __func__, allocResult);
@@ -118,6 +154,31 @@
(static_cast<shared_metadata*>(metadata_vaddr))->dataspace = aligned_optional(static_cast<Dataspace>(dataspace));
}
+ {
+ ATRACE_NAME("Update dump details");
+ const auto fd_count = hnd->fd_count + 1 /* metadata fd */;
+ std::vector<ino_t> inodes(fd_count);
+ for (size_t idx = 0; idx < fd_count; idx++) {
+ inodes[idx] = get_inode(hnd->fds[idx]);
+ }
+
+ auto idx = next_idx.fetch_add(1);
+ idx %= allocated_buffers.size();
+
+ allocated_buffers_mutex.lock_shared();
+ allocated_buffers[idx] =
+ BufferDetails{bufferDescriptor.name,
+ hnd->backing_store_id,
+ inodes,
+ bufferDescriptor.hal_format,
+ bufferDescriptor.producer_usage,
+ bufferDescriptor.width,
+ bufferDescriptor.height};
+ allocated_buffers_mutex.unlock_shared();
+
+ total_allocated++;
+ }
+
munmap(metadata_vaddr, hnd->attr_size);
}
@@ -157,6 +218,38 @@
}
}
+const std::string dump() {
+ using namespace std::chrono_literals;
+ if (!allocated_buffers_mutex.try_lock_for(100ms)) {
+ return "";
+ }
+
+ std::stringstream ss;
+ // TODO: Add logs to indicate overflow
+ for (int i = 0; i < std::min(total_allocated, static_cast<uint64_t>(allocated_buffers.size())); i++) {
+ const auto& [name, buffer_id, inodes, format, usage, width, height] = allocated_buffers[i];
+ ss << "buffer_id: " << buffer_id << ", inodes: ";
+ for (auto it = inodes.begin(); it != inodes.end(); it++) {
+ if (it != inodes.begin()) {
+ ss << ",";
+ }
+ ss << static_cast<int>(*it);
+ }
+ ss << ", format: 0x" << std::hex << format << std::dec;
+ ss << ", usage: 0x" << std::hex << usage << std::dec;
+ ss << ", width: " << width << ", height: " << height;
+ ss << ", name: " << name << std::endl;
+ }
+
+ allocated_buffers_mutex.unlock();
+ return ss.str();
+}
+
+int isSupported(buffer_descriptor_t *const bufDescriptor) {
+ // this is used as the criteria to determine which allocations succeed.
+ return mali_gralloc_derive_format_and_size(bufDescriptor);
+}
+
} // namespace common
} // namespace allocator
} // namespace arm
diff --git a/gralloc4/src/hidl_common/Allocator.h b/gralloc4/src/hidl_common/Allocator.h
index 8fdd5ba..e5ce174 100644
--- a/gralloc4/src/hidl_common/Allocator.h
+++ b/gralloc4/src/hidl_common/Allocator.h
@@ -54,6 +54,10 @@
void allocate(const buffer_descriptor_t &bufferDescriptor, uint32_t count, IAllocator::allocate_cb hidl_cb,
std::function<int(const buffer_descriptor_t *, buffer_handle_t *)> fb_allocator = nullptr);
+const std::string dump();
+
+int isSupported(buffer_descriptor_t *const bufDescriptor);
+
} // namespace common
} // namespace allocator
} // namespace arm
diff --git a/gralloc4/src/hidl_common/BufferDescriptor.h b/gralloc4/src/hidl_common/BufferDescriptor.h
index 0d93811..2c63b6f 100644
--- a/gralloc4/src/hidl_common/BufferDescriptor.h
+++ b/gralloc4/src/hidl_common/BufferDescriptor.h
@@ -19,8 +19,7 @@
#define _GRALLOC_BUFFER_DESCRIPTOR_H_
#include "core/mali_gralloc_bufferdescriptor.h"
-
-#include "4.x/gralloc_mapper_hidl_header.h"
+#include "hidl_common.h"
#include <assert.h>
#include <inttypes.h>
@@ -30,27 +29,25 @@
namespace mapper {
namespace common {
-using android::hardware::hidl_vec;
-
const size_t DESCRIPTOR_32BIT_FIELDS = 5;
const size_t DESCRIPTOR_64BIT_FIELDS = 2;
const uint64_t validUsageBits =
- BufferUsage::GPU_CUBE_MAP |
- BufferUsage::GPU_MIPMAP_COMPLETE |
- BufferUsage::CPU_READ_MASK | BufferUsage::CPU_WRITE_MASK |
- BufferUsage::GPU_TEXTURE | BufferUsage::GPU_RENDER_TARGET |
- BufferUsage::COMPOSER_OVERLAY | BufferUsage::COMPOSER_CLIENT_TARGET |
- BufferUsage::CAMERA_INPUT | BufferUsage::CAMERA_OUTPUT |
- BufferUsage::PROTECTED |
- BufferUsage::COMPOSER_CURSOR |
- BufferUsage::VIDEO_ENCODER |
- BufferUsage::RENDERSCRIPT |
- BufferUsage::VIDEO_DECODER |
- BufferUsage::SENSOR_DIRECT_DATA |
- BufferUsage::GPU_DATA_BUFFER |
- BufferUsage::VENDOR_MASK |
- BufferUsage::VENDOR_MASK_HI;
+ static_cast<uint64_t>(BufferUsage::GPU_CUBE_MAP) |
+ static_cast<uint64_t>(BufferUsage::GPU_MIPMAP_COMPLETE) |
+ static_cast<uint64_t>(BufferUsage::CPU_READ_MASK) | static_cast<uint64_t>(BufferUsage::CPU_WRITE_MASK) |
+ static_cast<uint64_t>(BufferUsage::GPU_TEXTURE) | static_cast<uint64_t>(BufferUsage::GPU_RENDER_TARGET) |
+ static_cast<uint64_t>(BufferUsage::COMPOSER_OVERLAY) | static_cast<uint64_t>(BufferUsage::COMPOSER_CLIENT_TARGET) |
+ static_cast<uint64_t>(BufferUsage::CAMERA_INPUT) | static_cast<uint64_t>(BufferUsage::CAMERA_OUTPUT) |
+ static_cast<uint64_t>(BufferUsage::PROTECTED) |
+ static_cast<uint64_t>(BufferUsage::COMPOSER_CURSOR) |
+ static_cast<uint64_t>(BufferUsage::VIDEO_ENCODER) |
+ static_cast<uint64_t>(BufferUsage::RENDERSCRIPT) |
+ static_cast<uint64_t>(BufferUsage::VIDEO_DECODER) |
+ static_cast<uint64_t>(BufferUsage::SENSOR_DIRECT_DATA) |
+ static_cast<uint64_t>(BufferUsage::GPU_DATA_BUFFER) |
+ static_cast<uint64_t>(BufferUsage::VENDOR_MASK) |
+ static_cast<uint64_t>(BufferUsage::VENDOR_MASK_HI);
template<typename BufferDescriptorInfoT>
static bool validateDescriptorInfo(const BufferDescriptorInfoT &descriptorInfo)
@@ -69,7 +66,7 @@
}
template <typename vecT>
-static void push_descriptor_uint32(hidl_vec<vecT> *vec, size_t *pos, uint32_t val)
+static void push_descriptor_uint32(frameworks_vec<vecT> *vec, size_t *pos, uint32_t val)
{
static_assert(sizeof(val) % sizeof(vecT) == 0, "Unsupported vector type");
memcpy(vec->data() + *pos, &val, sizeof(val));
@@ -77,7 +74,7 @@
}
template <typename vecT>
-static uint32_t pop_descriptor_uint32(const hidl_vec<vecT> &vec, size_t *pos)
+static uint32_t pop_descriptor_uint32(const frameworks_vec<vecT> &vec, size_t *pos)
{
uint32_t val;
static_assert(sizeof(val) % sizeof(vecT) == 0, "Unsupported vector type");
@@ -87,7 +84,7 @@
}
template <typename vecT>
-static void push_descriptor_uint64(hidl_vec<vecT> *vec, size_t *pos, uint64_t val)
+static void push_descriptor_uint64(frameworks_vec<vecT> *vec, size_t *pos, uint64_t val)
{
static_assert(sizeof(val) % sizeof(vecT) == 0, "Unsupported vector type");
memcpy(vec->data() + *pos, &val, sizeof(val));
@@ -95,7 +92,7 @@
}
template <typename vecT>
-static uint64_t pop_descriptor_uint64(const hidl_vec<vecT> &vec, size_t *pos)
+static uint64_t pop_descriptor_uint64(const frameworks_vec<vecT> &vec, size_t *pos)
{
uint64_t val;
static_assert(sizeof(val) % sizeof(vecT) == 0, "Unsupported vector type");
@@ -105,23 +102,25 @@
}
// There can only be one string at the end of the descriptor
-static void push_descriptor_string(hidl_vec<uint8_t> *vec, size_t *pos, const std::string &str)
+static void push_descriptor_string(frameworks_vec<uint8_t> *vec, size_t *pos, const std::string &str)
{
strcpy(reinterpret_cast<char *>(vec->data() + *pos), str.c_str());
*pos += strlen(str.c_str()) + 1;
}
-static std::string pop_descriptor_string(const hidl_vec<uint8_t> &vec, size_t *pos)
+static std::string pop_descriptor_string(const frameworks_vec<uint8_t> &vec, size_t *pos)
{
- std::string str(reinterpret_cast<const char *>(vec.data() + *pos));
- *pos += str.size() + 1;
+ const char* charstr = reinterpret_cast<const char *>(vec.data() + *pos);
+ charstr += '\0';
+ std::string str(charstr);
+ str.resize(strlen(charstr));
return str;
}
template <typename vecT, typename BufferDescriptorInfoT>
-static const hidl_vec<vecT> grallocEncodeBufferDescriptor(const BufferDescriptorInfoT &descriptorInfo)
+static const frameworks_vec<vecT> grallocEncodeBufferDescriptor(const BufferDescriptorInfoT &descriptorInfo)
{
- hidl_vec<vecT> descriptor;
+ frameworks_vec<vecT> descriptor;
static_assert(sizeof(uint32_t) % sizeof(vecT) == 0, "Unsupported vector type");
size_t dynamic_size = 0;
@@ -150,7 +149,7 @@
}
template <typename vecT>
-static bool grallocDecodeBufferDescriptor(const hidl_vec<vecT> &androidDescriptor, buffer_descriptor_t &grallocDescriptor)
+static bool grallocDecodeBufferDescriptor(const frameworks_vec<vecT> &androidDescriptor, buffer_descriptor_t &grallocDescriptor)
{
static_assert(sizeof(uint32_t) % sizeof(vecT) == 0, "Unsupported vector type");
size_t pos = 0;
diff --git a/gralloc4/src/hidl_common/Mapper.cpp b/gralloc4/src/hidl_common/Mapper.cpp
index 38d5377..62cac7c 100644
--- a/gralloc4/src/hidl_common/Mapper.cpp
+++ b/gralloc4/src/hidl_common/Mapper.cpp
@@ -18,6 +18,7 @@
#include <inttypes.h>
#include <sync/sync.h>
+#include <hardware/gralloc1.h>
#include "RegisteredHandlePool.h"
#include "Mapper.h"
#include "BufferDescriptor.h"
@@ -34,6 +35,8 @@
#include "MapperMetadata.h"
#include "SharedMetadata.h"
+#include <cstdio>
+
/* GraphicBufferMapper is expected to be valid (and leaked) during process
* termination. IMapper, and in turn, gRegisteredHandles must be valid as
* well. Create the registered handle pool on the heap, and let
@@ -49,6 +52,10 @@
namespace mapper {
namespace common {
+buffer_handle_t getBuffer(void *buffer) {
+ return gRegisteredHandles->get(buffer);
+}
+
/*
* Translates the register buffer API into existing gralloc implementation
*
@@ -101,45 +108,34 @@
}
/*
- * Retrieves the file descriptor referring to a sync fence object
+ * Converts a gralloc error code to a mapper error code
*
- * @param fenceHandle [in] HIDL fence handle
- * @param outFenceFd [out] Fence file descriptor. '-1' indicates no fence
+ * @param grallocError [in] Gralloc error as integer.
*
- * @return false, for an invalid HIDL fence handle
- * true, otherwise
+ * @return Corresponding Mapper error code
+ *
+ * @note There is no full 1:1 correspondence, several gralloc errors may map to Error::UNSUPPORTED.
+ * @note -EINVAL is mapped to Error::BAD_VALUE.
*/
-static bool getFenceFd(const hidl_handle& fenceHandle, int* outFenceFd)
+static Error grallocErrorToMapperError(int grallocError)
{
- auto const handle = fenceHandle.getNativeHandle();
- if (handle && handle->numFds > 1)
+ switch(grallocError)
{
- MALI_GRALLOC_LOGE("Invalid fence handle with %d fds", handle->numFds);
- return false;
+ case GRALLOC1_ERROR_NONE:
+ return Error::NONE;
+ case GRALLOC1_ERROR_BAD_DESCRIPTOR:
+ return Error::BAD_DESCRIPTOR;
+ case GRALLOC1_ERROR_BAD_HANDLE:
+ return Error::BAD_BUFFER;
+ case GRALLOC1_ERROR_BAD_VALUE:
+ case -EINVAL:
+ return Error::BAD_VALUE;
+ case GRALLOC1_ERROR_NO_RESOURCES:
+ return Error::NO_RESOURCES;
+ default:
+ /* Covers NOT_SHARED, UNDEFINED, UNSUPPORTED */
+ return Error::UNSUPPORTED;
}
-
- *outFenceFd = (handle && handle->numFds == 1) ? handle->data[0] : -1;
- return true;
-}
-
-/*
- * Populates the HIDL fence handle for the given fence object
- *
- * @param fenceFd [in] Fence file descriptor
- * @param handleStorage [in] HIDL handle storage for fence
- *
- * @return HIDL fence handle
- */
-static hidl_handle getFenceHandle(int fenceFd, char* handleStorage)
-{
- native_handle_t* handle = nullptr;
- if (fenceFd >= 0)
- {
- handle = native_handle_init(handleStorage, 1, 0);
- handle->data[0] = fenceFd;
- }
-
- return hidl_handle(handle);
}
/*
@@ -147,18 +143,20 @@
*
* @param bufferHandle [in] Buffer to lock.
* @param cpuUsage [in] Specifies one or more CPU usage flags to request
- * @param accessRegion [in] Portion of the buffer that the client intends to access.
+ * @param accessRegion [in] Portion of the buffer that the client intends to
+ * access.
* @param fenceFd [in] Fence file descriptor
* @param outData [out] CPU accessible buffer address
*
* @return Error::BAD_BUFFER for an invalid buffer
* Error::NO_RESOURCES when unable to duplicate fence
* Error::BAD_VALUE when locking fails
+ * Error::UNSUPPORTED when locking fails on unsupported image formats
* Error::NONE on successful buffer lock
*/
static Error lockBuffer(buffer_handle_t bufferHandle,
uint64_t cpuUsage,
- const IMapper::Rect& accessRegion, int fenceFd,
+ const GrallocRect& accessRegion, int fenceFd,
void** outData)
{
/* dup fenceFd as it is going to be owned by gralloc. Note that it is
@@ -195,7 +193,7 @@
}
auto private_handle = private_handle_t::dynamicCast(bufferHandle);
- if (private_handle->cpu_write != 0 && (cpuUsage & BufferUsage::CPU_WRITE_MASK))
+ if (private_handle->cpu_write != 0 && (cpuUsage & static_cast<uint64_t>(BufferUsage::CPU_WRITE_MASK)))
{
if (fenceFd >= 0)
{
@@ -214,15 +212,22 @@
}
void* data = nullptr;
- if (mali_gralloc_lock(bufferHandle, cpuUsage, accessRegion.left, accessRegion.top, accessRegion.width,
- accessRegion.height, &data) < 0)
+ const int gralloc_err =
+ mali_gralloc_lock(bufferHandle, cpuUsage, accessRegion.left, accessRegion.top,
+ accessRegion.right - accessRegion.left,
+ accessRegion.bottom - accessRegion.top, &data);
+ const Error lock_err = grallocErrorToMapperError(gralloc_err);
+
+ if(Error::NONE == lock_err)
{
- return Error::BAD_VALUE;
+ *outData = data;
+ }
+ else
+ {
+ MALI_GRALLOC_LOGE("Locking failed with error: %d", gralloc_err);
}
- *outData = data;
-
- return Error::NONE;
+ return lock_err;
}
/*
@@ -244,141 +249,95 @@
return Error::BAD_BUFFER;
}
- auto private_handle = private_handle_t::dynamicCast(bufferHandle);
+ const int gralloc_err = mali_gralloc_unlock(bufferHandle);
+ const Error unlock_err = grallocErrorToMapperError(gralloc_err);
- const int result = mali_gralloc_unlock(bufferHandle);
- if (result)
+ if (Error::NONE == unlock_err)
{
- MALI_GRALLOC_LOGE("Unlocking failed with error: %d", result);
- return Error::BAD_VALUE;
+ *outFenceFd = -1;
+ }
+ else
+ {
+ MALI_GRALLOC_LOGE("Unlocking failed with error: %d",
+ gralloc_err);
+ return Error::BAD_BUFFER;
}
- *outFenceFd = -1;
-
- return Error::NONE;
+ return unlock_err;
}
-void importBuffer(const hidl_handle& rawHandle, IMapper::importBuffer_cb hidl_cb)
+Error importBuffer(const native_handle_t *inBuffer, buffer_handle_t *outBuffer)
{
- if (!rawHandle.getNativeHandle())
- {
- MALI_GRALLOC_LOGE("Invalid buffer handle to import");
- hidl_cb(Error::BAD_BUFFER, nullptr);
- return;
- }
-
- native_handle_t* bufferHandle = native_handle_clone(rawHandle.getNativeHandle());
- if (!bufferHandle)
- {
- MALI_GRALLOC_LOGE("Failed to clone buffer handle");
- hidl_cb(Error::NO_RESOURCES, nullptr);
- return;
- }
-
- const Error error = registerBuffer(bufferHandle);
+ *outBuffer = const_cast<buffer_handle_t>(native_handle_clone(inBuffer));
+ const Error error = registerBuffer(*outBuffer);
if (error != Error::NONE)
{
- native_handle_close(bufferHandle);
- native_handle_delete(bufferHandle);
-
- hidl_cb(error, nullptr);
- return;
+ return error;
}
- auto *private_handle = static_cast<private_handle_t *>(bufferHandle);
-
- if (gRegisteredHandles->add(bufferHandle) == false)
+ if (gRegisteredHandles->add(*outBuffer) == false)
{
/* The newly cloned handle is already registered. This can only happen
* when a handle previously registered was native_handle_delete'd instead
* of freeBuffer'd.
*/
MALI_GRALLOC_LOGE("Handle %p has already been imported; potential fd leaking",
- bufferHandle);
- unregisterBuffer(bufferHandle);
- native_handle_close(bufferHandle);
- native_handle_delete(bufferHandle);
-
- hidl_cb(Error::NO_RESOURCES, nullptr);
- return;
+ outBuffer);
+ unregisterBuffer(*outBuffer);
+ return Error::NO_RESOURCES;
}
- hidl_cb(Error::NONE, bufferHandle);
+ return Error::NONE;
}
-Error freeBuffer(void* buffer)
+Error freeBuffer(buffer_handle_t bufferHandle)
{
- native_handle_t * const bufferHandle = gRegisteredHandles->remove(buffer);
- if (!bufferHandle)
+ native_handle_t *handle = gRegisteredHandles->remove(bufferHandle);
+ if (handle == nullptr)
{
- MALI_GRALLOC_LOGE("Invalid buffer handle %p to freeBuffer", buffer);
+ MALI_GRALLOC_LOGE("Invalid buffer handle %p to freeBuffer", bufferHandle);
return Error::BAD_BUFFER;
}
- const Error status = unregisterBuffer(bufferHandle);
+ const Error status = unregisterBuffer(handle);
if (status != Error::NONE)
{
return status;
}
- native_handle_close(bufferHandle);
- native_handle_delete(bufferHandle);
+ native_handle_close(handle);
+ native_handle_delete(handle);
return Error::NONE;
}
-void lock(void* buffer, uint64_t cpuUsage, const IMapper::Rect& accessRegion,
- const hidl_handle& acquireFence, IMapper::lock_cb hidl_cb)
+Error lock(buffer_handle_t bufferHandle, uint64_t cpuUsage, const GrallocRect &accessRegion, int acquireFence, void **outData)
{
- buffer_handle_t bufferHandle = gRegisteredHandles->get(buffer);
+ *outData = nullptr;
if (!bufferHandle || private_handle_t::validate(bufferHandle) < 0)
{
- MALI_GRALLOC_LOGE("Buffer to lock: %p is not valid", buffer);
- hidl_cb(Error::BAD_BUFFER, nullptr);
- return;
+ MALI_GRALLOC_LOGE("Buffer to lock: %p is not valid",
+ bufferHandle);
+ return Error::BAD_BUFFER;
}
- int fenceFd;
- if (!getFenceFd(acquireFence, &fenceFd))
- {
- hidl_cb(Error::BAD_VALUE, nullptr);
- return;
- }
-
- void* data = nullptr;
- const Error error = lockBuffer(bufferHandle, cpuUsage, accessRegion, fenceFd, &data);
-
- hidl_cb(error, data);
+ const Error error = lockBuffer(bufferHandle, cpuUsage, accessRegion,
+ acquireFence, outData);
+ return error;
}
-void unlock(void* buffer, IMapper::unlock_cb hidl_cb)
-{
- buffer_handle_t bufferHandle = gRegisteredHandles->get(buffer);
- if (!bufferHandle)
- {
- MALI_GRALLOC_LOGE("Buffer to unlock: %p has not been registered with Gralloc", buffer);
- hidl_cb(Error::BAD_BUFFER, nullptr);
- return;
+Error unlock(buffer_handle_t bufferHandle, int *releaseFence) {
+ if(bufferHandle == nullptr) return Error::BAD_BUFFER;
+ if(!gRegisteredHandles->isRegistered(bufferHandle)) {
+ MALI_GRALLOC_LOGE("Buffer to unlock: %p has not been registered with Gralloc",
+ bufferHandle);
+ return Error::BAD_BUFFER;
}
- int fenceFd;
- const Error error = unlockBuffer(bufferHandle, &fenceFd);
- if (error == Error::NONE)
- {
- NATIVE_HANDLE_DECLARE_STORAGE(fenceStorage, 1, 0);
- hidl_cb(error, getFenceHandle(fenceFd, fenceStorage));
-
- if (fenceFd >= 0)
- {
- close(fenceFd);
- }
- }
- else
- {
- hidl_cb(error, nullptr);
- }
+ const Error error = unlockBuffer(bufferHandle, releaseFence);
+ return error;
}
-
+#ifdef GRALLOC_MAPPER_4
Error validateBufferSize(void* buffer,
const IMapper::BufferDescriptorInfo& descriptorInfo,
uint32_t in_stride)
@@ -430,7 +389,7 @@
if (in_stride != 0 && (uint32_t)gralloc_buffer->stride != in_stride)
{
- MALI_GRALLOC_LOGE("Stride mismatch. Expected stride = %d, Buffer stride = %d",
+ MALI_GRALLOC_LOGE("Stride mismatch. Expected stride = %d, Buffer stride = %" PRIu64,
in_stride, gralloc_buffer->stride);
return Error::BAD_VALUE;
}
@@ -455,21 +414,21 @@
{
if (gralloc_buffer->plane_info[i].byte_stride != grallocDescriptor.plane_info[i].byte_stride)
{
- MALI_GRALLOC_LOGE("Buffer byte stride 0x%x mismatch with desc byte stride 0x%x in plane %d ",
+ MALI_GRALLOC_LOGE("Buffer byte stride %" PRIu64 " mismatch with desc byte stride %" PRIu64 " in plane %d ",
gralloc_buffer->plane_info[i].byte_stride, grallocDescriptor.plane_info[i].byte_stride, i);
return Error::BAD_VALUE;
}
if (gralloc_buffer->plane_info[i].alloc_width != grallocDescriptor.plane_info[i].alloc_width)
{
- MALI_GRALLOC_LOGE("Buffer alloc width 0x%x mismatch with desc alloc width 0x%x in plane %d ",
+ MALI_GRALLOC_LOGE("Buffer alloc width %" PRIu64 " mismatch with desc alloc width %" PRIu64 " in plane %d ",
gralloc_buffer->plane_info[i].alloc_width, grallocDescriptor.plane_info[i].alloc_width, i);
return Error::BAD_VALUE;
}
if (gralloc_buffer->plane_info[i].alloc_height != grallocDescriptor.plane_info[i].alloc_height)
{
- MALI_GRALLOC_LOGE("Buffer alloc height 0x%x mismatch with desc alloc height 0x%x in plane %d ",
+ MALI_GRALLOC_LOGE("Buffer alloc height %" PRIu64 " mismatch with desc alloc height %" PRIu64 " in plane %d ",
gralloc_buffer->plane_info[i].alloc_height, grallocDescriptor.plane_info[i].alloc_height, i);
return Error::BAD_VALUE;
}
@@ -499,28 +458,32 @@
return Error::NONE;
}
+#endif
-void getTransportSize(void* buffer, IMapper::getTransportSize_cb hidl_cb)
+Error getTransportSize(buffer_handle_t bufferHandle, uint32_t *outNumFds, uint32_t *outNumInts)
{
+ *outNumFds = 0;
+ *outNumInts = 0;
/* The buffer must have been allocated by Gralloc */
- buffer_handle_t bufferHandle = gRegisteredHandles->get(buffer);
if (!bufferHandle)
{
- MALI_GRALLOC_LOGE("Buffer %p is not registered with Gralloc", bufferHandle);
- hidl_cb(Error::BAD_BUFFER, -1, -1);
- return;
+ MALI_GRALLOC_LOGE("Buffer %p is not registered with Gralloc",
+ bufferHandle);
+ return Error::BAD_BUFFER;
}
if (private_handle_t::validate(bufferHandle) < 0)
{
- MALI_GRALLOC_LOGE("Buffer %p is corrupted", buffer);
- hidl_cb(Error::BAD_BUFFER, -1, -1);
- return;
+ MALI_GRALLOC_LOGE("Buffer %p is corrupted", bufferHandle);
+ return Error::BAD_BUFFER;
}
- hidl_cb(Error::NONE, bufferHandle->numFds, bufferHandle->numInts);
+ *outNumFds = bufferHandle->numFds;
+ *outNumInts = bufferHandle->numInts;
+ return Error::NONE;
}
-void isSupported(const IMapper::BufferDescriptorInfo& description, IMapper::isSupported_cb hidl_cb)
+#ifdef GRALLOC_MAPPER_4
+bool isSupported(const IMapper::BufferDescriptorInfo &description)
{
buffer_descriptor_t grallocDescriptor;
grallocDescriptor.width = description.width;
@@ -536,39 +499,36 @@
if (result != 0)
{
MALI_GRALLOC_LOGV("Allocation for the given description will not succeed. error: %d", result);
- hidl_cb(Error::NONE, false);
+ return false;
}
else
{
- hidl_cb(Error::NONE, true);
+ return true;
}
}
-void flushLockedBuffer(void *buffer, IMapper::flushLockedBuffer_cb hidl_cb)
+#endif
+Error flushLockedBuffer(buffer_handle_t handle)
{
- buffer_handle_t handle = gRegisteredHandles->get(buffer);
if (private_handle_t::validate(handle) < 0)
{
- MALI_GRALLOC_LOGE("Bandle: %p is corrupted", handle);
- hidl_cb(Error::BAD_BUFFER, hidl_handle{});
- return;
+ MALI_GRALLOC_LOGE("Handle: %p is corrupted", handle);
+ return Error::BAD_BUFFER;
}
auto private_handle = static_cast<const private_handle_t *>(handle);
if (!private_handle->cpu_write && !private_handle->cpu_read)
{
MALI_GRALLOC_LOGE("Attempt to call flushLockedBuffer() on an unlocked buffer (%p)", handle);
- hidl_cb(Error::BAD_BUFFER, hidl_handle{});
- return;
+ return Error::BAD_BUFFER;
}
mali_gralloc_ion_sync_end(private_handle, false, true);
- hidl_cb(Error::NONE, hidl_handle{});
+ return Error::NONE;
}
-Error rereadLockedBuffer(void *buffer)
+Error rereadLockedBuffer(buffer_handle_t handle)
{
- buffer_handle_t handle = gRegisteredHandles->get(buffer);
if (private_handle_t::validate(handle) < 0)
{
MALI_GRALLOC_LOGE("Buffer: %p is corrupted", handle);
@@ -586,31 +546,29 @@
return Error::NONE;
}
-void get(void *buffer, const IMapper::MetadataType &metadataType, IMapper::get_cb hidl_cb)
+Error get(buffer_handle_t buffer, const MetadataType &metadataType, std::vector<uint8_t> &vec)
{
/* The buffer must have been allocated by Gralloc */
- const private_handle_t *handle = static_cast<const private_handle_t *>(gRegisteredHandles->get(buffer));
+ const private_handle_t *handle = static_cast<const private_handle_t *>(buffer);
if (handle == nullptr)
{
MALI_GRALLOC_LOGE("Buffer: %p has not been registered with Gralloc", buffer);
- hidl_cb(Error::BAD_BUFFER, hidl_vec<uint8_t>());
- return;
+ return Error::BAD_BUFFER;
}
if (mali_gralloc_reference_validate((buffer_handle_t)handle) < 0)
{
MALI_GRALLOC_LOGE("Buffer: %p is not imported", handle);
- hidl_cb(Error::BAD_VALUE, hidl_vec<uint8_t>());
- return;
+ return Error::BAD_VALUE;
}
- get_metadata(handle, metadataType, hidl_cb);
+ return get_metadata(handle, metadataType, vec);
}
-Error set(void *buffer, const IMapper::MetadataType &metadataType, const hidl_vec<uint8_t> &metadata)
+Error set(buffer_handle_t buffer, const MetadataType &metadataType, const hidl_vec<uint8_t> &metadata)
{
/* The buffer must have been allocated by Gralloc */
- const private_handle_t *handle = static_cast<const private_handle_t *>(gRegisteredHandles->get(buffer));
+ const private_handle_t *handle = static_cast<const private_handle_t *>(buffer);
if (handle == nullptr)
{
MALI_GRALLOC_LOGE("Buffer: %p has not been registered with Gralloc", buffer);
@@ -626,135 +584,137 @@
return set_metadata(handle, metadataType, metadata);
}
-void listSupportedMetadataTypes(IMapper::listSupportedMetadataTypes_cb hidl_cb)
+MetadataTypeDescription describeStandard(StandardMetadataType meta, bool isGettable, bool isSettable)
+{
+ return MetadataTypeDescription(MetadataType(GRALLOC4_STANDARD_METADATA_TYPE,
+ static_cast<uint64_t>(meta)), "", isGettable, isSettable);
+}
+
+std::vector<MetadataTypeDescription> listSupportedMetadataTypes()
{
/* Returns a vector of {metadata type, description, isGettable, isSettable}
* Only non-standardMetadataTypes require a description.
*/
- hidl_vec<IMapper::MetadataTypeDescription> descriptions = {
- { android::gralloc4::MetadataType_BufferId, "", true, false },
- { android::gralloc4::MetadataType_Name, "", true, false },
- { android::gralloc4::MetadataType_Width, "", true, false },
- { android::gralloc4::MetadataType_Height, "", true, false },
- { android::gralloc4::MetadataType_LayerCount, "", true, false },
- { android::gralloc4::MetadataType_PixelFormatRequested, "", true, false },
- { android::gralloc4::MetadataType_PixelFormatFourCC, "", true, false },
- { android::gralloc4::MetadataType_PixelFormatModifier, "", true, false },
- { android::gralloc4::MetadataType_Usage, "", true, false },
- { android::gralloc4::MetadataType_AllocationSize, "", true, false },
- { android::gralloc4::MetadataType_ProtectedContent, "", true, false },
- { android::gralloc4::MetadataType_Compression, "", true, false },
- { android::gralloc4::MetadataType_Interlaced, "", true, false },
- { android::gralloc4::MetadataType_ChromaSiting, "", true, false },
- { android::gralloc4::MetadataType_PlaneLayouts, "", true, false },
- { android::gralloc4::MetadataType_Dataspace, "", true, true },
- { android::gralloc4::MetadataType_BlendMode, "", true, true },
- { android::gralloc4::MetadataType_Smpte2086, "", true, true },
- { android::gralloc4::MetadataType_Cta861_3, "", true, true },
- { android::gralloc4::MetadataType_Smpte2094_40, "", true, true },
- { android::gralloc4::MetadataType_Crop, "", true, true },
+ std::array<MetadataTypeDescription, 23> descriptions = {
+ describeStandard(StandardMetadataType::BUFFER_ID, true, false ),
+ describeStandard(StandardMetadataType::NAME, true, false ),
+ describeStandard(StandardMetadataType::WIDTH, true, false ),
+ describeStandard(StandardMetadataType::STRIDE, true, false ),
+ describeStandard(StandardMetadataType::HEIGHT, true, false ),
+ describeStandard(StandardMetadataType::LAYER_COUNT, true, false ),
+ describeStandard(StandardMetadataType::PIXEL_FORMAT_REQUESTED, true, false ),
+ describeStandard(StandardMetadataType::PIXEL_FORMAT_FOURCC, true, false ),
+ describeStandard(StandardMetadataType::PIXEL_FORMAT_MODIFIER, true, false ),
+ describeStandard(StandardMetadataType::USAGE, true, false ),
+ describeStandard(StandardMetadataType::ALLOCATION_SIZE, true, false ),
+ describeStandard(StandardMetadataType::PROTECTED_CONTENT, true, false ),
+ describeStandard(StandardMetadataType::COMPRESSION, true, false ),
+ describeStandard(StandardMetadataType::INTERLACED, true, false ),
+ describeStandard(StandardMetadataType::CHROMA_SITING, true, false ),
+ describeStandard(StandardMetadataType::PLANE_LAYOUTS, true, false ),
+ describeStandard(StandardMetadataType::DATASPACE, true, true ),
+ describeStandard(StandardMetadataType::BLEND_MODE, true, true ),
+ describeStandard(StandardMetadataType::SMPTE2086, true, true ),
+ describeStandard(StandardMetadataType::CTA861_3, true, true ),
+ describeStandard(StandardMetadataType::SMPTE2094_40, true, true ),
+ describeStandard(StandardMetadataType::CROP, true, true ),
/* Arm vendor metadata */
{ ArmMetadataType_PLANE_FDS,
- "Vector of file descriptors of each plane", true, false },
- };
- hidl_cb(Error::NONE, descriptions);
- return;
+ "Vector of file descriptors of each plane", true, false},
+ };
+ return std::vector<MetadataTypeDescription>(descriptions.begin(), descriptions.end());
}
-static hidl_vec<IMapper::MetadataDump> dumpBufferHelper(const private_handle_t* handle)
+static BufferDump dumpBufferHelper(const private_handle_t *handle)
{
- hidl_vec<IMapper::MetadataType> standardMetadataTypes = {
- android::gralloc4::MetadataType_BufferId,
- android::gralloc4::MetadataType_Name,
- android::gralloc4::MetadataType_Width,
- android::gralloc4::MetadataType_Height,
- android::gralloc4::MetadataType_LayerCount,
- android::gralloc4::MetadataType_PixelFormatRequested,
- android::gralloc4::MetadataType_PixelFormatFourCC,
- android::gralloc4::MetadataType_PixelFormatModifier,
- android::gralloc4::MetadataType_Usage,
- android::gralloc4::MetadataType_AllocationSize,
- android::gralloc4::MetadataType_ProtectedContent,
- android::gralloc4::MetadataType_Compression,
- android::gralloc4::MetadataType_Interlaced,
- android::gralloc4::MetadataType_ChromaSiting,
- android::gralloc4::MetadataType_PlaneLayouts,
- android::gralloc4::MetadataType_Dataspace,
- android::gralloc4::MetadataType_BlendMode,
- android::gralloc4::MetadataType_Smpte2086,
- android::gralloc4::MetadataType_Cta861_3,
- android::gralloc4::MetadataType_Smpte2094_40,
- android::gralloc4::MetadataType_Crop,
+ static std::array<MetadataType, 21> standardMetadataTypes = {
+ MetadataType(StandardMetadataType::BUFFER_ID),
+ MetadataType(StandardMetadataType::NAME),
+ MetadataType(StandardMetadataType::WIDTH),
+ MetadataType(StandardMetadataType::HEIGHT),
+ MetadataType(StandardMetadataType::LAYER_COUNT),
+ MetadataType(StandardMetadataType::PIXEL_FORMAT_REQUESTED),
+ MetadataType(StandardMetadataType::PIXEL_FORMAT_FOURCC),
+ MetadataType(StandardMetadataType::PIXEL_FORMAT_MODIFIER),
+ MetadataType(StandardMetadataType::USAGE),
+ MetadataType(StandardMetadataType::ALLOCATION_SIZE),
+ MetadataType(StandardMetadataType::PROTECTED_CONTENT),
+ MetadataType(StandardMetadataType::COMPRESSION),
+ MetadataType(StandardMetadataType::INTERLACED),
+ MetadataType(StandardMetadataType::CHROMA_SITING),
+ MetadataType(StandardMetadataType::PLANE_LAYOUTS),
+ MetadataType(StandardMetadataType::DATASPACE),
+ MetadataType(StandardMetadataType::BLEND_MODE),
+ MetadataType(StandardMetadataType::SMPTE2086),
+ MetadataType(StandardMetadataType::CTA861_3),
+ MetadataType(StandardMetadataType::SMPTE2094_40),
+ MetadataType(StandardMetadataType::CROP),
};
- std::vector<IMapper::MetadataDump> metadataDumps;
+ std::vector<MetadataDump> metadataDumps;
for (const auto& metadataType: standardMetadataTypes)
{
- get_metadata(handle, metadataType, [&metadataDumps, &metadataType](Error error, hidl_vec<uint8_t> metadata) {
- switch(error)
- {
- case Error::NONE:
- metadataDumps.push_back({metadataType, metadata});
- break;
- case Error::UNSUPPORTED:
- default:
- return;
- }
- });
+ std::vector<uint8_t> metadata;
+ Error error = get_metadata(handle, metadataType, metadata);
+ if (error == Error::NONE)
+ {
+ metadataDumps.push_back(MetadataDump(MetadataType(metadataType), metadata));
+ }
+ else
+ {
+ return BufferDump();
+ }
}
- return hidl_vec<IMapper::MetadataDump>(metadataDumps);
+ return BufferDump(metadataDumps);
}
-void dumpBuffer(void *buffer, IMapper::dumpBuffer_cb hidl_cb)
+Error dumpBuffer(buffer_handle_t buffer, BufferDump &bufferDump)
{
- IMapper::BufferDump bufferDump{};
- auto handle = static_cast<const private_handle_t *>(gRegisteredHandles->get(buffer));
+ auto handle = static_cast<const private_handle_t *>(buffer);
if (handle == nullptr)
{
MALI_GRALLOC_LOGE("Buffer: %p has not been registered with Gralloc", buffer);
- hidl_cb(Error::BAD_BUFFER, bufferDump);
- return;
+ return Error::BAD_BUFFER;
}
- bufferDump.metadataDump = dumpBufferHelper(handle);
- hidl_cb(Error::NONE, bufferDump);
+ bufferDump = dumpBufferHelper(handle);
+ return Error::NONE;
}
-void dumpBuffers(IMapper::dumpBuffers_cb hidl_cb)
+std::vector<BufferDump> dumpBuffers()
{
- std::vector<IMapper::BufferDump> bufferDumps;
+ std::vector<BufferDump> bufferDumps;
gRegisteredHandles->for_each([&bufferDumps](buffer_handle_t buffer) {
- IMapper::BufferDump bufferDump { dumpBufferHelper(static_cast<const private_handle_t *>(buffer)) };
+ BufferDump bufferDump { dumpBufferHelper(static_cast<const private_handle_t *>(buffer)) };
bufferDumps.push_back(bufferDump);
});
- hidl_cb(Error::NONE, hidl_vec<IMapper::BufferDump>(bufferDumps));
+ return bufferDumps;
}
-void getReservedRegion(void *buffer, IMapper::getReservedRegion_cb hidl_cb)
+Error getReservedRegion(buffer_handle_t buffer, void **outReservedRegion, uint64_t &outReservedSize)
{
- auto handle = static_cast<const private_handle_t *>(gRegisteredHandles->get(buffer));
+ auto handle = static_cast<const private_handle_t *>(buffer);
if (handle == nullptr)
{
MALI_GRALLOC_LOGE("Buffer: %p has not been registered with Gralloc", buffer);
- hidl_cb(Error::BAD_BUFFER, 0, 0);
- return;
+ return Error::BAD_BUFFER;
}
else if (handle->reserved_region_size == 0)
{
MALI_GRALLOC_LOGE("Buffer: %p has no reserved region", buffer);
- hidl_cb(Error::BAD_BUFFER, 0, 0);
- return;
+ return Error::BAD_BUFFER;
}
auto metadata_addr_oe = mali_gralloc_reference_get_metadata_addr(handle);
if (!metadata_addr_oe.has_value()) {
- hidl_cb(Error::BAD_BUFFER, 0, 0);
+ return Error::BAD_BUFFER;
}
- void *reserved_region = static_cast<std::byte *>(metadata_addr_oe.value())
+ *outReservedRegion = static_cast<std::byte *>(metadata_addr_oe.value())
+ mapper::common::shared_metadata_size();
- hidl_cb(Error::NONE, reserved_region, handle->reserved_region_size);
+ outReservedSize = handle->reserved_region_size;
+ return Error::NONE;
}
} // namespace common
diff --git a/gralloc4/src/hidl_common/Mapper.h b/gralloc4/src/hidl_common/Mapper.h
index 6d114cc..c77128c 100644
--- a/gralloc4/src/hidl_common/Mapper.h
+++ b/gralloc4/src/hidl_common/Mapper.h
@@ -23,7 +23,9 @@
#include "mali_gralloc_log.h"
#include "core/mali_gralloc_bufferdescriptor.h"
-#include "4.x/gralloc_mapper_hidl_header.h"
+#include "MapperMetadata.h"
+#include "hidl_common.h"
+#include "mali_gralloc_error.h"
namespace arm
{
@@ -32,24 +34,42 @@
namespace common
{
-using android::hardware::hidl_handle;
-using android::hardware::hidl_vec;
+
+using aidl::android::hardware::graphics::common::Rect;
+
using android::hardware::Void;
+class GrallocRect {
+ public:
+ int left;
+ int top;
+ int right;
+ int bottom;
+ GrallocRect(Rect rect) {
+ left = rect.left;
+ top = rect.top;
+ right = rect.right;
+ bottom = rect.bottom;
+ }
+#ifdef GRALLOC_MAPPER_4
+ GrallocRect(IMapper::Rect rect) {
+ left = rect.left;
+ top = rect.top;
+ right = rect.left + rect.width;
+ bottom = rect.top + rect.height;
+ }
+#endif
+};
+
/**
* Imports a raw buffer handle to create an imported buffer handle for use with
* the rest of the mapper or with other in-process libraries.
*
- * @param rawHandle [in] Raw buffer handle to import.
- * @param hidl_cb [in] HIDL Callback function to export output information
- * @param hidl_cb [in] HIDL callback function generating -
- * error : NONE upon success. Otherwise,
- * BAD_BUFFER for an invalid buffer
- * NO_RESOURCES when the raw handle cannot be imported
- * BAD_VALUE when any of the specified attributes are invalid
- * buffer : Imported buffer handle
+ * @param bufferHandle [in] Buffer handle to import.
+ * @param outBuffer [in] imported Buffer
*/
-void importBuffer(const hidl_handle &rawHandle, IMapper::importBuffer_cb hidl_cb);
+Error importBuffer(const native_handle_t *inBuffer, buffer_handle_t *outBuffer);
+
/**
* Frees a buffer handle and releases all the resources associated with it
@@ -59,7 +79,10 @@
* @return Error::BAD_BUFFER for an invalid buffer / when failed to free the buffer
* Error::NONE on successful free
*/
-Error freeBuffer(void *buffer);
+Error freeBuffer(buffer_handle_t buffer);
+
+buffer_handle_t getBuffer(void *buffer);
+native_handle_t* removeBuffer(void **buffer);
/**
* Locks the given buffer for the specified CPU usage.
@@ -76,8 +99,7 @@
* bytesPerPixel: v3.X Only. Number of bytes per pixel in the buffer
* bytesPerStride: v3.X Only. Bytes per stride of the buffer
*/
-void lock(void *buffer, uint64_t cpuUsage, const IMapper::Rect &accessRegion, const hidl_handle &acquireFence,
- IMapper::lock_cb hidl_cb);
+Error lock(buffer_handle_t buffer, uint64_t cpuUsage, const GrallocRect &accessRegion, int acquireFence, void **outData);
/**
* Unlocks a buffer to indicate all CPU accesses to the buffer have completed
@@ -88,7 +110,7 @@
* BAD_BUFFER for an invalid buffer
* releaseFence: Referrs to a sync fence object
*/
-void unlock(void *buffer, IMapper::unlock_cb hidl_cb);
+Error unlock(const native_handle_t *buffer, int *releaseFence);
/**
* Validates the buffer against specified descriptor attributes
@@ -102,7 +124,9 @@
* Error::BAD_BUFFER upon bad buffer input
* Error::BAD_VALUE when any of the specified attributes are invalid
*/
+#ifdef GRALLOC_MAPPER_4
Error validateBufferSize(void *buffer, const IMapper::BufferDescriptorInfo &descriptorInfo, uint32_t stride);
+#endif
/**
* Get the transport size of a buffer
@@ -114,7 +138,7 @@
* numFds: Number of file descriptors needed for transport
* numInts: Number of integers needed for transport
*/
-void getTransportSize(void *buffer, IMapper::getTransportSize_cb hidl_cb);
+Error getTransportSize(buffer_handle_t bufferHandle, uint32_t *outNumFds, uint32_t *outNumInts);
/**
* Test whether the given BufferDescriptorInfo is allocatable.
@@ -125,8 +149,9 @@
* BAD_VALUE, Otherwise,
* supported: Whether the description can be allocated
*/
-void isSupported(const IMapper::BufferDescriptorInfo &description, IMapper::isSupported_cb hidl_cb);
-
+#ifdef GRALLOC_MAPPER_4
+bool isSupported(const IMapper::BufferDescriptorInfo &description);
+#endif
/* TODO: implement this feature for exynos */
/**
* Flushes the CPU caches of a mapped buffer.
@@ -137,7 +162,7 @@
* has not been locked.
* releaseFence: Empty fence signaling completion as all work is completed within the call.
*/
-void flushLockedBuffer(void *buffer, IMapper::flushLockedBuffer_cb hidl_cb);
+Error flushLockedBuffer(buffer_handle_t buffer);
/* TODO: implement this feature for exynos */
/**
@@ -148,7 +173,7 @@
* @return Error::NONE upon success.
* Error::BAD_BUFFER for an invalid buffer or a buffer that has not been locked.
*/
-Error rereadLockedBuffer(void *buffer);
+Error rereadLockedBuffer(buffer_handle_t handle);
/**
* Retrieves a Buffer's metadata value.
@@ -161,7 +186,7 @@
* UNSUPPORTED on error when reading or unsupported metadata type.
* metadata: Vector of bytes representing the metadata value.
*/
-void get(void *buffer, const IMapper::MetadataType &metadataType, IMapper::get_cb hidl_cb);
+Error get(buffer_handle_t buffer, const MetadataType &metadataType, std::vector<uint8_t> &vec);
/**
* Sets a Buffer's metadata value.
@@ -174,7 +199,7 @@
* Error::BAD_BUFFER on invalid buffer argument.
* Error::UNSUPPORTED on error when writing or unsupported metadata type.
*/
-Error set(void *buffer, const IMapper::MetadataType &metadataType, const hidl_vec<uint8_t> &metadata);
+Error set(buffer_handle_t buffer, const MetadataType &metadataType, const frameworks_vec<uint8_t> &metadata);
/**
* Lists all the MetadataTypes supported by IMapper as well as a description
@@ -189,7 +214,7 @@
* descriptions: vector of MetadataTypeDescriptions that represent the
* MetadataTypes supported by the device.
*/
-void listSupportedMetadataTypes(IMapper::listSupportedMetadataTypes_cb hidl_cb);
+std::vector<MetadataTypeDescription> listSupportedMetadataTypes();
/**
* Dumps a buffer's metadata.
@@ -203,7 +228,7 @@
* resources.
* bufferDump: Struct representing the metadata being dumped
*/
-void dumpBuffer(void *buffer, IMapper::dumpBuffer_cb hidl_cb);
+Error dumpBuffer(buffer_handle_t buffer, BufferDump &out);
/**
* Dumps the metadata for all the buffers in the current process.
@@ -215,7 +240,7 @@
* resources.
* bufferDumps: Vector of structs representing the buffers being dumped
*/
-void dumpBuffers(IMapper::dumpBuffers_cb hidl_cb);
+std::vector<BufferDump> dumpBuffers();
/**
* Returns the region of shared memory associated with the buffer that is
@@ -243,7 +268,7 @@
* reservedSize: the size of the reservedRegion that was requested
* in the BufferDescriptorInfo.
*/
-void getReservedRegion(void *buffer, IMapper::getReservedRegion_cb _hidl_cb);
+Error getReservedRegion(buffer_handle_t buffer, void **outReservedRegion, uint64_t &outReservedSize);
} // namespace common
} // namespace mapper
diff --git a/gralloc4/src/hidl_common/MapperMetadata.cpp b/gralloc4/src/hidl_common/MapperMetadata.cpp
index 81835a3..76a9865 100644
--- a/gralloc4/src/hidl_common/MapperMetadata.cpp
+++ b/gralloc4/src/hidl_common/MapperMetadata.cpp
@@ -29,6 +29,7 @@
#include "mali_gralloc_formats.h"
#include <pixel-gralloc/metadata.h>
+#include <pixel-gralloc/utils.h>
#include <vector>
@@ -52,9 +53,13 @@
using aidl::arm::graphics::ArmMetadataType;
#endif
-using MetadataType = android::hardware::graphics::mapper::V4_0::IMapper::MetadataType;
+bool isStandardMetadataType(const MetadataType &metadataType) {
+ return !std::strncmp(metadataType.name.c_str(),
+ GRALLOC4_STANDARD_METADATA_TYPE,
+ metadataType.name.size());
+}
-static int get_num_planes(const private_handle_t *hnd)
+int get_num_planes(const private_handle_t *hnd)
{
if (is_exynos_format(hnd->get_alloc_format()))
{
@@ -282,7 +287,7 @@
return std::vector<std::vector<PlaneLayoutComponent>>(0);
}
-static android::status_t get_plane_layouts(const private_handle_t *handle, std::vector<PlaneLayout> *layouts)
+android::status_t get_plane_layouts(const private_handle_t *handle, std::vector<PlaneLayout> *layouts)
{
const int num_planes = get_num_planes(handle);
uint32_t base_format = handle->alloc_format & MALI_GRALLOC_INTFMT_FMT_MASK;
@@ -317,9 +322,9 @@
PlaneLayout layout = {.offsetInBytes = offset,
.sampleIncrementInBits = sample_increment_in_bits,
- .strideInBytes = handle->plane_info[plane_index].byte_stride,
- .widthInSamples = handle->plane_info[plane_index].alloc_width,
- .heightInSamples = handle->plane_info[plane_index].alloc_height,
+ .strideInBytes = static_cast<int64_t>(handle->plane_info[plane_index].byte_stride),
+ .widthInSamples = static_cast<int64_t>(handle->plane_info[plane_index].alloc_width),
+ .heightInSamples = static_cast<int64_t>(handle->plane_info[plane_index].alloc_height),
.totalSizeInBytes = plane_size,
.horizontalSubsampling = (plane_index == 0 ? 1 : format_info.hsub),
.verticalSubsampling = (plane_index == 0 ? 1 : format_info.vsub),
@@ -371,9 +376,9 @@
PlaneLayout layout = {.offsetInBytes = handle->plane_info[plane_index].offset,
.sampleIncrementInBits = sample_increment_in_bits,
- .strideInBytes = handle->plane_info[plane_index].byte_stride,
- .widthInSamples = handle->plane_info[plane_index].alloc_width,
- .heightInSamples = handle->plane_info[plane_index].alloc_height,
+ .strideInBytes = static_cast<int64_t>(handle->plane_info[plane_index].byte_stride),
+ .widthInSamples = static_cast<int64_t>(handle->plane_info[plane_index].alloc_width),
+ .heightInSamples = static_cast<int64_t>(handle->plane_info[plane_index].alloc_height),
.totalSizeInBytes = plane_size,
.horizontalSubsampling = (plane_index == 0 ? 1 : format_info.hsub),
.verticalSubsampling = (plane_index == 0 ? 1 : format_info.vsub),
@@ -386,23 +391,23 @@
return android::OK;
}
-static hidl_vec<uint8_t> encodePointer(void* ptr) {
+static frameworks_vec<uint8_t> encodePointer(void* ptr) {
constexpr uint8_t kPtrSize = sizeof(void*);
- hidl_vec<uint8_t> output(kPtrSize);
+ frameworks_vec<uint8_t> output(kPtrSize);
std::memcpy(output.data(), &ptr, kPtrSize);
return output;
}
-void get_metadata(const private_handle_t *handle, const IMapper::MetadataType &metadataType, IMapper::get_cb hidl_cb)
+Error get_metadata(const private_handle_t *handle, const MetadataType &metadataType, std::vector<uint8_t> &outVec)
{
android::status_t err = android::OK;
- hidl_vec<uint8_t> vec;
+ frameworks_vec<uint8_t> vec;
- if (android::gralloc4::isStandardMetadataType(metadataType))
+ if (isStandardMetadataType(metadataType))
{
- switch (android::gralloc4::getStandardMetadataTypeValue(metadataType))
+ switch (static_cast<StandardMetadataType>(metadataType.value))
{
case StandardMetadataType::BUFFER_ID:
err = android::gralloc4::encodeBufferId(handle->backing_store_id, &vec);
@@ -424,7 +429,7 @@
err = android::gralloc4::encodeLayerCount(handle->layer_count, &vec);
break;
case StandardMetadataType::PIXEL_FORMAT_REQUESTED:
- err = android::gralloc4::encodePixelFormatRequested(static_cast<PixelFormat>(handle->req_format), &vec);
+ err = android::gralloc4::encodePixelFormatRequested(static_cast<hidl::PixelFormat>(handle->req_format), &vec);
break;
case StandardMetadataType::PIXEL_FORMAT_FOURCC:
err = android::gralloc4::encodePixelFormatFourCC(drm_fourcc_from_handle(handle), &vec);
@@ -449,7 +454,7 @@
{
/* This is set to 1 if the buffer has protected content. */
const int is_protected =
- (((handle->consumer_usage | handle->producer_usage) & BufferUsage::PROTECTED) == 0) ? 0 : 1;
+ (((handle->consumer_usage | handle->producer_usage) & static_cast<uint64_t>(BufferUsage::PROTECTED)) == 0) ? 0 : 1;
err = android::gralloc4::encodeProtectedContent(is_protected, &vec);
break;
}
@@ -572,7 +577,7 @@
else if (metadataType.name == ::pixel::graphics::kPixelMetadataTypeName) {
switch (static_cast<::pixel::graphics::MetadataType>(metadataType.value)) {
case ::pixel::graphics::MetadataType::VIDEO_HDR:
- vec = encodePointer(get_video_hdr(handle));
+ vec = ::pixel::graphics::utils::encode(get_video_hdr(handle));
break;
case ::pixel::graphics::MetadataType::VIDEO_ROI:
{
@@ -580,10 +585,19 @@
if (roi == nullptr) {
err = android::BAD_VALUE;
} else {
- vec = encodePointer(roi);
+ vec = ::pixel::graphics::utils::encode(roi);
}
break;
}
+ case ::pixel::graphics::MetadataType::PLANE_DMA_BUFS:
+ {
+ std::vector<int> plane_fds(MAX_BUFFER_FDS, -1);
+ for (int i = 0; i < get_num_planes(handle); i++) {
+ plane_fds[i] = handle->fds[handle->plane_info[i].fd_idx];
+ }
+ vec = ::pixel::graphics::utils::encode(plane_fds);
+ break;
+ }
default:
err = android::BAD_VALUE;
}
@@ -593,16 +607,16 @@
err = android::BAD_VALUE;
}
- hidl_cb((err) ? Error::UNSUPPORTED : Error::NONE, vec);
+ outVec = std::vector<uint8_t>(vec);
+ return ((err) ? Error::UNSUPPORTED : Error::NONE);
}
-Error set_metadata(const private_handle_t *handle, const IMapper::MetadataType &metadataType,
- const hidl_vec<uint8_t> &metadata)
+Error set_metadata(const private_handle_t *handle, const MetadataType &metadataType, const frameworks_vec<uint8_t> &metadata)
{
- if (android::gralloc4::isStandardMetadataType(metadataType))
+ if (isStandardMetadataType(metadataType))
{
android::status_t err = android::OK;
- switch (android::gralloc4::getStandardMetadataTypeValue(metadataType))
+ switch (static_cast<StandardMetadataType>(metadataType.value))
{
case StandardMetadataType::DATASPACE:
{
@@ -695,12 +709,12 @@
}
}
-void getFromBufferDescriptorInfo(IMapper::BufferDescriptorInfo const &description,
- IMapper::MetadataType const &metadataType,
- IMapper::getFromBufferDescriptorInfo_cb hidl_cb)
+#ifdef GRALLOC_MAPPER_4
+Error getFromBufferDescriptorInfo(IMapper::BufferDescriptorInfo const &description,
+ MetadataType const &metadataType, std::vector<uint8_t> &outVec)
{
/* This will hold the metadata that is returned. */
- hidl_vec<uint8_t> vec;
+ frameworks_vec<uint8_t> vec;
buffer_descriptor_t descriptor;
descriptor.width = description.width;
@@ -716,8 +730,8 @@
if (alloc_result != 0)
{
MALI_GRALLOC_LOGV("Allocation for the given description will not succeed. error: %d", alloc_result);
- hidl_cb(Error::BAD_VALUE, vec);
- return;
+ outVec = vec;
+ return Error::BAD_VALUE;
}
/* Create buffer handle from the initialized descriptor without a backing store or shared metadata region.
* Used to share functionality with the normal metadata get function that can only use the allocated buffer handle
@@ -727,11 +741,11 @@
descriptor.hal_format, descriptor.alloc_format,
descriptor.width, descriptor.height, descriptor.pixel_stride,
descriptor.layer_count, descriptor.plane_info);
- if (android::gralloc4::isStandardMetadataType(metadataType))
+ if (isStandardMetadataType(metadataType))
{
android::status_t err = android::OK;
- switch (android::gralloc4::getStandardMetadataTypeValue(metadataType))
+ switch (static_cast<StandardMetadataType>(metadataType.value))
{
case StandardMetadataType::NAME:
err = android::gralloc4::encodeName(description.name, &vec);
@@ -746,7 +760,7 @@
err = android::gralloc4::encodeLayerCount(description.layerCount, &vec);
break;
case StandardMetadataType::PIXEL_FORMAT_REQUESTED:
- err = android::gralloc4::encodePixelFormatRequested(static_cast<PixelFormat>(description.format), &vec);
+ err = android::gralloc4::encodePixelFormatRequested(static_cast<hidl::PixelFormat>(description.format), &vec);
break;
case StandardMetadataType::USAGE:
err = android::gralloc4::encodeUsage(description.usage, &vec);
@@ -774,7 +788,7 @@
{
/* This is set to 1 if the buffer has protected content. */
const int is_protected =
- (((partial_handle.consumer_usage | partial_handle.producer_usage) & BufferUsage::PROTECTED)) ? 1 : 0;
+ (((partial_handle.consumer_usage | partial_handle.producer_usage) & static_cast<uint64_t>(BufferUsage::PROTECTED))) ? 1 : 0;
err = android::gralloc4::encodeProtectedContent(is_protected, &vec);
break;
}
@@ -876,14 +890,17 @@
default:
err = android::BAD_VALUE;
}
- hidl_cb((err) ? Error::UNSUPPORTED : Error::NONE, vec);
+ outVec = vec;
+ return ((err) ? Error::UNSUPPORTED : Error::NONE);
}
else
{
- hidl_cb(Error::UNSUPPORTED, vec);
+ outVec = vec;
+ return Error::UNSUPPORTED;
}
}
+#endif // GRALLOC_MAPPER_4
} // namespace common
} // namespace mapper
} // namespace arm
diff --git a/gralloc4/src/hidl_common/MapperMetadata.h b/gralloc4/src/hidl_common/MapperMetadata.h
index cbf9b47..7027487 100644
--- a/gralloc4/src/hidl_common/MapperMetadata.h
+++ b/gralloc4/src/hidl_common/MapperMetadata.h
@@ -23,13 +23,16 @@
#include "mali_gralloc_log.h"
#include "core/mali_gralloc_bufferdescriptor.h"
#include "mali_gralloc_buffer.h"
+#include "mali_gralloc_error.h"
+#include <cstring>
-#include "4.x/gralloc_mapper_hidl_header.h"
+#include "hidl_common/hidl_common.h"
+#include <algorithm>
+#include <iterator>
#include <aidl/arm/graphics/Compression.h>
#include <aidl/arm/graphics/ArmMetadataType.h>
-
namespace arm
{
namespace mapper
@@ -44,8 +47,116 @@
static_cast<int64_t>(aidl::arm::graphics::Compression::AFBC) };
#define GRALLOC_ARM_METADATA_TYPE_NAME "arm.graphics.ArmMetadataType"
-const static IMapper::MetadataType ArmMetadataType_PLANE_FDS{ GRALLOC_ARM_METADATA_TYPE_NAME,
- static_cast<int64_t>(aidl::arm::graphics::ArmMetadataType::PLANE_FDS) };
+
+
+class MetadataType {
+ public:
+ std::string name;
+ uint64_t value;
+#ifdef GRALLOC_MAPPER_4
+ MetadataType(const IMapper::MetadataType &meta) {
+ name = meta.name;
+ value = meta.value;
+ }
+ operator IMapper::MetadataType() const {
+ IMapper::MetadataType meta;
+ meta.name = name;
+ meta.value = value;
+ return meta;
+ }
+#endif
+ MetadataType() {}
+ MetadataType(std::string strname, uint64_t val) {
+ name = strname;
+ value = val;
+ }
+ MetadataType(StandardMetadataType meta) : MetadataType(GRALLOC4_STANDARD_METADATA_TYPE, static_cast<uint64_t>(meta)) {}
+};
+
+const static MetadataType ArmMetadataType_PLANE_FDS = MetadataType(GRALLOC_ARM_METADATA_TYPE_NAME, static_cast<int64_t>(aidl::arm::graphics::ArmMetadataType::PLANE_FDS));
+
+constexpr int RES_SIZE = 32;
+
+struct MetadataTypeDescription {
+ MetadataType metadataType;
+ const char* description;
+ bool isGettable;
+ bool isSettable;
+#ifdef GRALLOC_MAPPER_4
+ MetadataTypeDescription(const IMapper::MetadataTypeDescription &desc) {
+ metadataType = desc.metadataType;
+ description = (desc.description).c_str();
+ isGettable = desc.isGettable;
+ isSettable = desc.isSettable;
+ }
+ operator IMapper::MetadataTypeDescription() const {
+ IMapper::MetadataTypeDescription desc;
+ desc.metadataType = static_cast<IMapper::MetadataType>(metadataType);
+ desc.description = description;
+ desc.isGettable = isGettable;
+ desc.isSettable = isSettable;
+ return desc;
+ }
+#endif
+ MetadataTypeDescription(MetadataType meta, const char* desc, bool gettable, bool settable) {
+ metadataType = meta;
+ description = desc;
+ isGettable = gettable;
+ isSettable = settable;
+ }
+};
+
+struct MetadataDump {
+ MetadataType metadataType;
+ std::vector<uint8_t> metadata;
+#ifdef GRALLOC_MAPPER_4
+ MetadataDump(const IMapper::MetadataDump &meta) {
+ metadataType = MetadataType(meta.metadataType);
+ metadata = static_cast<std::vector<uint8_t> >(metadata);
+ }
+ operator IMapper::MetadataDump() const {
+ IMapper::MetadataDump dump;
+ dump.metadataType = static_cast<IMapper::MetadataType>(metadataType);
+ dump.metadata = hidl_vec(metadata);
+ return dump;
+ }
+#endif
+ MetadataDump() {}
+ MetadataDump(MetadataType metaType, std::vector<uint8_t> &meta) {
+ metadataType = metaType;
+ metadata = meta;
+ }
+};
+
+struct BufferDump {
+ std::vector<MetadataDump> metadataDump;
+#ifdef GRALLOC_MAPPER_4
+ BufferDump(const IMapper::BufferDump &dump) {
+ for (auto meta : dump.metadataDump)
+ metadataDump.push_back(MetadataDump(meta));
+ }
+ operator IMapper::BufferDump() const {
+ IMapper::BufferDump bufferdump;
+ std::vector<IMapper::MetadataDump> metaDump;
+ for (auto meta : metadataDump) {
+ metaDump.push_back(static_cast<IMapper::MetadataDump>(meta));
+ }
+ bufferdump.metadataDump = metaDump;
+ return bufferdump;
+ }
+#endif
+ BufferDump(std::vector<MetadataDump> &meta) { metadataDump = meta; }
+ BufferDump() {}
+};
+
+
+int get_num_planes(const private_handle_t *hnd);
+
+static std::vector<std::vector<PlaneLayoutComponent>> plane_layout_components_from_handle(const private_handle_t *hnd);
+
+android::status_t get_plane_layouts(const private_handle_t *handle, std::vector<PlaneLayout> *layouts);
+
+bool isStandardMetadataType(const MetadataType &metadataType);
/**
* Retrieves a Buffer's metadata value.
@@ -57,7 +168,7 @@
* UNSUPPORTED on error when reading or unsupported metadata type.
* metadata: Vector of bytes representing the metadata value.
*/
-void get_metadata(const private_handle_t *handle, const IMapper::MetadataType &metadataType, IMapper::get_cb hidl_cb);
+Error get_metadata(const private_handle_t *handle, const MetadataType &metadataType, std::vector<uint8_t> &outVec);
/**
* Sets a Buffer's metadata value.
@@ -69,8 +180,7 @@
* @return Error::NONE on success.
* Error::UNSUPPORTED on error when writing or unsupported metadata type.
*/
-Error set_metadata(const private_handle_t *handle, const IMapper::MetadataType &metadataType,
- const hidl_vec<uint8_t> &metadata);
+Error set_metadata(const private_handle_t *handle, const MetadataType &metadataType, const frameworks_vec<uint8_t> &metadata);
/**
* Query basic metadata information about a buffer form its descriptor before allocation.
@@ -82,9 +192,9 @@
* UNSUPPORTED on unsupported metadata type.
* metadata: Vector of bytes representing the metadata value.
*/
-void getFromBufferDescriptorInfo(IMapper::BufferDescriptorInfo const &description,
- IMapper::MetadataType const &metadataType,
- IMapper::getFromBufferDescriptorInfo_cb hidl_cb);
+#ifdef GRALLOC_MAPPER_4
+Error getFromBufferDescriptorInfo(IMapper::BufferDescriptorInfo const &description, MetadataType const &metadataType, std::vector<uint8_t> &outVec);
+#endif
} // namespace common
} // namespace mapper
diff --git a/gralloc4/src/hidl_common/RegisteredHandlePool.cpp b/gralloc4/src/hidl_common/RegisteredHandlePool.cpp
index b598d8a..3c99e4f 100644
--- a/gralloc4/src/hidl_common/RegisteredHandlePool.cpp
+++ b/gralloc4/src/hidl_common/RegisteredHandlePool.cpp
@@ -24,9 +24,9 @@
return bufPool.insert(bufferHandle).second;
}
-native_handle_t* RegisteredHandlePool::remove(void* buffer)
+native_handle_t* RegisteredHandlePool::remove(buffer_handle_t buffer)
{
- auto bufferHandle = static_cast<native_handle_t*>(buffer);
+ auto bufferHandle = const_cast<native_handle_t*>(buffer);
std::lock_guard<std::mutex> lock(mutex);
return bufPool.erase(bufferHandle) == 1 ? bufferHandle : nullptr;
@@ -40,8 +40,13 @@
return bufPool.count(bufferHandle) == 1 ? bufferHandle : nullptr;
}
+bool RegisteredHandlePool::isRegistered(buffer_handle_t buffer)
+{
+ return (bufPool.find(buffer) != bufPool.end());
+}
+
void RegisteredHandlePool::for_each(std::function<void(const buffer_handle_t &)> fn)
{
std::lock_guard<std::mutex> lock(mutex);
std::for_each(bufPool.begin(), bufPool.end(), fn);
-}
\ No newline at end of file
+}
diff --git a/gralloc4/src/hidl_common/RegisteredHandlePool.h b/gralloc4/src/hidl_common/RegisteredHandlePool.h
index d3fb9b0..b318e54 100644
--- a/gralloc4/src/hidl_common/RegisteredHandlePool.h
+++ b/gralloc4/src/hidl_common/RegisteredHandlePool.h
@@ -33,7 +33,7 @@
bool add(buffer_handle_t bufferHandle);
/* Retrieves and removes the buffer handle from internal list */
- native_handle_t* remove(void* buffer);
+ native_handle_t* remove(buffer_handle_t buffer);
/* Retrieves the buffer handle from internal list */
buffer_handle_t get(const void* buffer);
@@ -41,6 +41,8 @@
/* Applies a function to each buffer handle */
void for_each(std::function<void(const buffer_handle_t &)> fn);
+ bool isRegistered(buffer_handle_t handle);
+
private:
std::mutex mutex;
std::unordered_set<buffer_handle_t> bufPool;
diff --git a/gralloc4/src/hidl_common/SharedMetadata.h b/gralloc4/src/hidl_common/SharedMetadata.h
index f3aad7c..5e72b1c 100644
--- a/gralloc4/src/hidl_common/SharedMetadata.h
+++ b/gralloc4/src/hidl_common/SharedMetadata.h
@@ -26,8 +26,6 @@
#include "core/mali_gralloc_bufferdescriptor.h"
#include "gralloc_helper.h"
-#include "4.x/gralloc_mapper_hidl_header.h"
-
#include "SharedMetadata_struct.h"
namespace arm
diff --git a/gralloc4/src/hidl_common/hidl_common.h b/gralloc4/src/hidl_common/hidl_common.h
new file mode 100644
index 0000000..28850e9
--- /dev/null
+++ b/gralloc4/src/hidl_common/hidl_common.h
@@ -0,0 +1,42 @@
+#ifndef HIDL_COMMON
+#define HIDL_COMMON
+
+#include "mali_fourcc.h"
+#include <gralloctypes/Gralloc4.h>
+#include <aidl/android/hardware/graphics/common/BufferUsage.h>
+#include <aidl/android/hardware/graphics/common/PixelFormat.h>
+#include <aidl/android/hardware/graphics/common/StandardMetadataType.h>
+
+using aidl::android::hardware::graphics::common::BufferUsage;
+using aidl::android::hardware::graphics::common::PixelFormat;
+using aidl::android::hardware::graphics::common::StandardMetadataType;
+using aidl::android::hardware::graphics::common::ExtendableType;
+using aidl::android::hardware::graphics::common::PlaneLayout;
+using aidl::android::hardware::graphics::common::PlaneLayoutComponent;
+using aidl::android::hardware::graphics::common::Rect;
+using aidl::android::hardware::graphics::common::BlendMode;
+using aidl::android::hardware::graphics::common::Dataspace;
+
+namespace hidl {
+using PixelFormat = android::hardware::graphics::common::V1_2::PixelFormat;
+} // namespace hidl
+
+
+template <typename T>
+using frameworks_vec = android::hardware::hidl_vec<T>;
+
+#ifdef GRALLOC_MAPPER_4
+
+#include <android/hardware/graphics/mapper/4.0/IMapper.h>
+
+namespace hidl {
+using android::hardware::graphics::mapper::V4_0::Error;
+} // namespace hidl
+using android::hardware::graphics::mapper::V4_0::BufferDescriptor;
+using android::hardware::graphics::mapper::V4_0::IMapper;
+
+using frameworks_handle = android::hardware::hidl_handle;
+
+#endif // GRALLOC_MAPPER_4
+
+#endif // HIDL_COMMON
diff --git a/gralloc4/src/libGralloc4Wrapper/include/gralloc4/gralloc_vendor_interface.h b/gralloc4/src/libGralloc4Wrapper/include/gralloc4/gralloc_vendor_interface.h
deleted file mode 100644
index cbd98d9..0000000
--- a/gralloc4/src/libGralloc4Wrapper/include/gralloc4/gralloc_vendor_interface.h
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Copyright (C) 2020 Google LLC. All rights reserved.
- *
- * Copyright (C) 2008 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.
- */
-
-#ifndef GRALLOC_VENDOR_INTERFACE_H
-#define GRALLOC_VENDOR_INTERFACE_H
-
-#include <cutils/native_handle.h>
-#include <sys/types.h>
-#include <cstdint>
-#include <system/graphics-base-v1.0.h>
-#include <android/hardware/graphics/mapper/4.0/IMapper.h>
-
-
-namespace android::hardware::graphics::allocator::priv {
-
-struct Descriptor;
-Descriptor *createDescriptor();
-void deleteDescriptor(Descriptor *descriptor);
-
-void setProducerUsage(Descriptor &descriptor, uint64_t usage);
-void setConsumerUsage(Descriptor &descriptor, uint64_t usage);
-void setPlaneCount(Descriptor &descriptor, int count);
-void setPlane(Descriptor &descriptor, int index, int fd, size_t size, off_t offset, int stride_byte);
-void setWidth(Descriptor &descriptor, int width);
-void setHeight(Descriptor &descriptor, int height);
-void setStridePixel(Descriptor &descriptor, int stride_pixel);
-void setFormat(Descriptor &descriptor, int format);
-
-buffer_handle_t createNativeHandle(const Descriptor &descriptor);
-
-int freeImportedHandle(void *handle);
-
-} // namespace android::hardware::graphics::allocator::priv
-
-#endif
diff --git a/gralloc4/src/libGralloc4Wrapper/wrapper.cpp b/gralloc4/src/libGralloc4Wrapper/wrapper.cpp
deleted file mode 100644
index f9b1b9c..0000000
--- a/gralloc4/src/libGralloc4Wrapper/wrapper.cpp
+++ /dev/null
@@ -1,218 +0,0 @@
-#include "gralloc4/gralloc_vendor_interface.h"
-#include <vector>
-#include <sys/stat.h>
-
-#include "core/format_info.h"
-#include "core/mali_gralloc_bufferdescriptor.h"
-#include "core/mali_gralloc_bufferallocation.h"
-#include "allocator/mali_gralloc_ion.h"
-#include "hidl_common/SharedMetadata.h"
-#include "gralloc_priv.h"
-
-namespace android::hardware::graphics::allocator::priv {
-
-struct Descriptor {
- unsigned int size = 0;
- uint64_t producer_usage = 0;
- uint64_t consumer_usage = 0;
-
- struct PlaneDescriptor {
- int fd = -1;
- size_t size = 0;
- off_t offset = 0;
- int stride_byte = 0;
- };
- std::vector<PlaneDescriptor> planes;
-
- int width = 0;
- int height = 0;
- int stride_pixel = 0;
- int format = 0;
-};
-
-Descriptor *createDescriptor() { return new Descriptor(); }
-void deleteDescriptor(Descriptor *descriptor) { delete descriptor; }
-
-void setProducerUsage(Descriptor &descriptor, uint64_t usage) {
- descriptor.producer_usage = usage;
-}
-
-void setConsumerUsage(Descriptor &descriptor, uint64_t usage) {
- descriptor.consumer_usage = usage;
-}
-
-void setPlaneCount(Descriptor &descriptor, int count) {
- descriptor.planes.resize(count);
-}
-
-void setPlane(Descriptor &descriptor, int index, int fd, size_t size, off_t offset, int stride_byte) {
- descriptor.planes[index].fd = fd;
- descriptor.planes[index].size = size;
- descriptor.planes[index].offset = offset;
- descriptor.planes[index].stride_byte = stride_byte;
-}
-
-void setWidth(Descriptor &descriptor, int width) {
- descriptor.width = width;
-}
-
-void setHeight(Descriptor &descriptor, int height) {
- descriptor.height = height;
-}
-
-void setStridePixel(Descriptor &descriptor, int stride_pixel) {
- descriptor.stride_pixel = stride_pixel;
-}
-
-void setFormat(Descriptor &descriptor, int format) {
- descriptor.format = format;
-}
-
-buffer_handle_t createNativeHandle(const Descriptor &descriptor) {
- for (int i = 0; i < descriptor.planes.size(); ++i) {
- struct stat st;
- fstat(descriptor.planes[i].fd, &st);
- off64_t fd_size = st.st_size;
- if (fd_size < descriptor.planes[i].size) {
- ALOGE("libGralloc4Wrapper: createNativeHandle failed: plane[%d] requested size greater than fd size.",
- i);
- return nullptr;
- }
- }
-
- buffer_descriptor_t buffer_descriptor;
-
- buffer_descriptor.pixel_stride = descriptor.stride_pixel;
- buffer_descriptor.width = descriptor.width;
- buffer_descriptor.height = descriptor.height;
- buffer_descriptor.layer_count = 1;
- buffer_descriptor.hal_format = buffer_descriptor.alloc_format
- = descriptor.format;
- buffer_descriptor.producer_usage = descriptor.producer_usage;
- buffer_descriptor.consumer_usage = descriptor.consumer_usage;
- buffer_descriptor.format_type = MALI_GRALLOC_FORMAT_TYPE_USAGE;
- buffer_descriptor.signature = sizeof(buffer_descriptor_t);
-
- buffer_descriptor.fd_count = buffer_descriptor.plane_count
- = descriptor.planes.size();
- for (int i = 0; i < descriptor.planes.size(); ++i) {
- buffer_descriptor.alloc_sizes[i] = descriptor.planes[i].size;
- }
-
- auto format_index = get_format_index(descriptor.format);
- if (format_index == -1) {
- ALOGE("libGralloc4Wrapper: invalid format 0x%x",
- descriptor.format);
- return 0;
- }
- for (int i = 0; i < descriptor.planes.size(); ++i) {
- uint8_t bpp = formats[format_index].bpp[i];
- if (bpp == 0) {
- ALOGE("libGralloc4Wrapper: format 0x%x has bpp[%d]=0",
- descriptor.format, i);
- return nullptr;
- }
- buffer_descriptor.plane_info[i] = {
- .byte_stride = static_cast<uint32_t>((descriptor.planes[i].stride_byte * bpp) / 8),
- .alloc_width = buffer_descriptor.width,
- .alloc_height = buffer_descriptor.height,
- };
- }
-
- if (mali_gralloc_derive_format_and_size(&buffer_descriptor)) {
- ALOGE("libGralloc4Wrapper: mali_gralloc_derive_format_and_size failed");
- return nullptr;
- }
-
- const gralloc_buffer_descriptor_t gralloc_buffer_descriptor =
- reinterpret_cast<const gralloc_buffer_descriptor_t>(&buffer_descriptor);
-
- buffer_handle_t tmp_buffer;
- bool shared_backend;
- // TODO(modan@, make mali_gralloc_ion_allocate accept multiple fds)
- {
- int result = mali_gralloc_buffer_allocate(&gralloc_buffer_descriptor, 1, &tmp_buffer,
- &shared_backend, descriptor.planes[0].fd);
- if (result < 0) {
- ALOGE("mali_gralloc_buffer_allocate failed");
- return nullptr;
- }
- }
-
- private_handle_t *hnd = const_cast<private_handle_t *>(
- static_cast<const private_handle_t *>(tmp_buffer));
-
- hnd->imapper_version = HIDL_MAPPER_VERSION_SCALED;
-
- hnd->reserved_region_size = buffer_descriptor.reserved_size;
- hnd->attr_size = arm::mapper::common::shared_metadata_size() + hnd->reserved_region_size;
-
- {
- int result = mali_gralloc_ion_allocate_attr(hnd);
- if (result < 0) {
- ALOGE("mali_gralloc_ion_allocate_attr failed");
- mali_gralloc_buffer_free(tmp_buffer);
- return nullptr;
- }
- }
-
- {
- auto metadata_vaddr = mmap(nullptr, hnd->attr_size, PROT_READ | PROT_WRITE,
- MAP_SHARED, hnd->get_share_attr_fd(), 0);
- if (metadata_vaddr == MAP_FAILED) {
- ALOGE("mmap hnd->get_share_attr_fd() failed");
- mali_gralloc_buffer_free(tmp_buffer);
- return nullptr;
- }
-
- memset(metadata_vaddr, 0, hnd->attr_size);
-
- arm::mapper::common::shared_metadata_init(metadata_vaddr, buffer_descriptor.name);
-
- const uint32_t base_format = buffer_descriptor.alloc_format & MALI_GRALLOC_INTFMT_FMT_MASK;
- const uint64_t usage = buffer_descriptor.consumer_usage | buffer_descriptor.producer_usage;
- android_dataspace_t dataspace;
- get_format_dataspace(base_format, usage, hnd->width, hnd->height, &dataspace);
-
- {
- using arm::mapper::common::aligned_optional;
- using arm::mapper::common::Dataspace;
- using arm::mapper::common::shared_metadata;
- (static_cast<shared_metadata *>(metadata_vaddr))->dataspace =
- aligned_optional(static_cast<Dataspace>(dataspace));
- }
-
- munmap(metadata_vaddr, hnd->attr_size);
- }
-
- // TODO(modan@, handle all plane offsets)
- hnd->offset = hnd->plane_info[0].offset = descriptor.planes[0].offset;
- hnd->layer_count = 1;
-
- return tmp_buffer;
-}
-
-int freeImportedHandle(void *handle)
-{
- using android::hardware::graphics::mapper::V4_0::IMapper;
- using android::hardware::graphics::mapper::V4_0::Error;
-
- const private_handle_t *hnd = static_cast<private_handle_t *>(handle);
-
- static android::sp<IMapper> mapper = IMapper::getService();
- if (!mapper)
- {
- ALOGE("libGralloc4Wrapper: %s failed to get a mapper", __func__);
- return -1;
- }
-
- if (mapper->freeBuffer(handle) != Error::NONE)
- {
- ALOGE("libGralloc4Wrapper: %s couldn't freeBuffer(%p\n", __func__, handle);
- return -1;
- }
-
- return 0;
-}
-
-} // namespace android::hardware::graphics::allocator::priv
diff --git a/gralloc4/src/mali_gralloc_buffer.h b/gralloc4/src/mali_gralloc_buffer.h
index 09461d7..891c507 100644
--- a/gralloc4/src/mali_gralloc_buffer.h
+++ b/gralloc4/src/mali_gralloc_buffer.h
@@ -97,7 +97,7 @@
* For uncompressed allocations, byte_stride might contain additional
* padding beyond the alloc_width. For AFBC, alignment is zero.
*/
- uint32_t byte_stride;
+ uint64_t byte_stride;
/*
* Dimensions of plane (in pixels).
@@ -117,8 +117,8 @@
* be wholly within the allocation dimensions. The crop region top-left
* will be relative to the start of allocation.
*/
- uint32_t alloc_width;
- uint32_t alloc_height;
+ uint64_t alloc_width;
+ uint64_t alloc_height;
} plane_info_t;
struct private_handle_t;
@@ -210,7 +210,7 @@
*
* NOTE: 'stride' values sometimes vary significantly from plane_info[0].alloc_width.
*/
- int stride DEFAULT_INITIALIZER(0);
+ uint64_t stride DEFAULT_INITIALIZER(0);
/*
* Allocation properties.
@@ -264,7 +264,7 @@
uint64_t _consumer_usage, uint64_t _producer_usage,
int _fds[MAX_FDS], int _fd_count,
int _req_format, uint64_t _alloc_format,
- int _width, int _height, int _stride,
+ int _width, int _height, uint64_t _stride,
uint64_t _layer_count, plane_info_t _plane_info[MAX_PLANES])
: private_handle_t()
{
@@ -396,10 +396,10 @@
"wh(%d %d) "
"req_format(%#x) alloc_format(%#" PRIx64 ") "
"usage_pc(0x%" PRIx64 " 0x%" PRIx64 ") "
- "stride(%d) "
- "psize(%" PRIu64 ") byte_stride(%d) internal_wh(%d %d) "
- "psize1(%" PRIu64 ") byte_stride1(%d) internal_wh1(%d %d) "
- "psize2(%" PRIu64 ") byte_stride2(%d) internal_wh2(%d %d) "
+ "stride(%" PRIu64 ") "
+ "psize(%" PRIu64 ") byte_stride(%" PRIu64 ") internal_wh(%" PRIu64 " %" PRIu64 ") "
+ "psize1(%" PRIu64 ") byte_stride1(%" PRIu64 ") internal_wh1(%" PRIu64 " %" PRIu64 ") "
+ "psize2(%" PRIu64 ") byte_stride2(%" PRIu64 ") internal_wh2(%" PRIu64 " %" PRIu64 ") "
"alloc_format(0x%" PRIx64 ") "
"alloc_sizes(%" PRIu64 " %" PRIu64 " %" PRIu64 ") "
"layer_count(%d) "
@@ -442,4 +442,8 @@
#pragma GCC diagnostic pop
#endif
+// The size of private_handle_t is calculated manually. This check ensures that private_handle_t has
+// the same layout for 32-bit and 64-bit processes.
+static_assert(sizeof(private_handle_t) == 328);
+
#endif /* MALI_GRALLOC_BUFFER_H_ */
diff --git a/gralloc4/src/mali_gralloc_error.h b/gralloc4/src/mali_gralloc_error.h
new file mode 100644
index 0000000..6045b65
--- /dev/null
+++ b/gralloc4/src/mali_gralloc_error.h
@@ -0,0 +1,31 @@
+#ifndef MALI_GRALLOC_ERROR
+#define MALI_GRALLOC_ERROR
+
+enum class Error : int32_t {
+ /**
+ * No error.
+ */
+ NONE = 0,
+ /**
+ * Invalid BufferDescriptor.
+ */
+ BAD_DESCRIPTOR = 1,
+ /**
+ * Invalid buffer handle.
+ */
+ BAD_BUFFER = 2,
+ /**
+ * Invalid HardwareBufferDescription.
+ */
+ BAD_VALUE = 3,
+ /**
+ * Resource unavailable.
+ */
+ NO_RESOURCES = 5,
+ /**
+ * Permanent failure.
+ */
+ UNSUPPORTED = 7,
+};
+
+#endif
diff --git a/gralloc4/src/mali_gralloc_formats.h b/gralloc4/src/mali_gralloc_formats.h
index e4120fa..a4ada1c 100644
--- a/gralloc4/src/mali_gralloc_formats.h
+++ b/gralloc4/src/mali_gralloc_formats.h
@@ -359,8 +359,8 @@
void mali_gralloc_adjust_dimensions(const uint64_t internal_format,
const uint64_t usage,
- int* const width,
- int* const height);
+ uint64_t* const width,
+ uint64_t* const height);
uint64_t mali_gralloc_select_format(const uint64_t req_format,
const mali_gralloc_format_type type,
diff --git a/gralloc4/src/mali_gralloc_usages.h b/gralloc4/src/mali_gralloc_usages.h
index f20900d..f6559c4 100644
--- a/gralloc4/src/mali_gralloc_usages.h
+++ b/gralloc4/src/mali_gralloc_usages.h
@@ -27,12 +27,12 @@
* is not present.
*/
-
+#include <aidl/android/hardware/graphics/common/BufferUsage.h>
#include <android/hardware/graphics/common/1.2/types.h>
+#include <pixel-gralloc/usage.h>
+
/* BufferUsage is not defined in 1.2/types.h as there are no changes from previous version */
namespace hidl_common = android::hardware::graphics::common::V1_1;
-
-#include <aidl/android/hardware/graphics/common/BufferUsage.h>
namespace aidl_common = aidl::android::hardware::graphics::common;
/* Local macro definitions to emulate Gralloc 1.0 usage interface */
@@ -78,11 +78,14 @@
GRALLOC_USAGE_GOOGLE_IP_BW = GRALLOC_USAGE_PRIVATE_16, /* Alias to BO */
GRALLOC_USAGE_GOOGLE_IP_BIG = GRALLOC_USAGE_PRIVATE_16, /* Alias to BO/BW */
GRALLOC_USAGE_GOOGLE_IP_MFC = GRALLOC_USAGE_PRIVATE_17,
+ GRALLOC_USAGE_PLACEHOLDER_BUFFER = ::pixel::graphics::Usage::PLACEHOLDER_BUFFER,
/* FaceAuth specific usages. */
GS101_GRALLOC_USAGE_TPU_INPUT = GRALLOC_USAGE_PRIVATE_5,
GS101_GRALLOC_USAGE_TPU_OUTPUT = GRALLOC_USAGE_PRIVATE_3,
GS101_GRALLOC_USAGE_CAMERA_STATS = GRALLOC_USAGE_PRIVATE_2,
+
+ GS101_GRALLOC_USAGE_FACEAUTH_RAW_EVAL = ::pixel::graphics::Usage::FACEAUTH_RAW_EVAL,
} mali_gralloc_usage_type;
#define GRALLOC_USAGE_SW_WRITE_RARELY static_cast<uint64_t>(hidl_common::BufferUsage::CPU_WRITE_RARELY)
@@ -112,6 +115,9 @@
#define GRALLOC_USAGE_GPU_DATA_BUFFER static_cast<uint64_t>(hidl_common::BufferUsage::GPU_DATA_BUFFER)
#define GRALLOC_USAGE_FRONT_BUFFER static_cast<uint64_t>(aidl_common::BufferUsage::FRONT_BUFFER)
+#define UNSUPPORTED_MALI_GRALLOC_USAGE_CUBE_MAP static_cast<uint64_t>(aidl_common::BufferUsage::GPU_CUBE_MAP)
+#define UNSUPPORTED_MALI_GRALLOC_USAGE_MIPMAP_COMPLETE static_cast<uint64_t>(aidl_common::BufferUsage::GPU_MIPMAP_COMPLETE)
+
/* Originally (Gralloc 0.x), Android did not provide an explicit DECODER usage. This was rectified in Android N-MR1/7.1
* when Gralloc 1.0 defined GRALLOC1_PRODUCER_USAGE_VIDEO_DECODER. However, libstagefright continues
@@ -147,6 +153,7 @@
GS101_GRALLOC_USAGE_TPU_INPUT | /* 1U << 62 */
GS101_GRALLOC_USAGE_TPU_OUTPUT | /* 1U << 31 */
+ GS101_GRALLOC_USAGE_FACEAUTH_RAW_EVAL | /* 1U << 63 */
GS101_GRALLOC_USAGE_CAMERA_STATS | /* 1U << 30 */
GRALLOC_USAGE_ROIINFO | /* 1U << 52 */
diff --git a/libvendorgraphicbuffer/gralloc4/vendor_graphicbuffer_meta.cpp b/libvendorgraphicbuffer/gralloc4/vendor_graphicbuffer_meta.cpp
index eb8d663..a2bf1c4 100644
--- a/libvendorgraphicbuffer/gralloc4/vendor_graphicbuffer_meta.cpp
+++ b/libvendorgraphicbuffer/gralloc4/vendor_graphicbuffer_meta.cpp
@@ -25,9 +25,11 @@
#include "mali_gralloc_formats.h"
#include "hidl_common/SharedMetadata.h"
#include "hidl_common/SharedMetadata_struct.h"
+#include "hidl_common/hidl_common.h"
#include "exynos_format.h"
#include <pixel-gralloc/metadata.h>
+#include <pixel-gralloc/mapper.h>
using namespace android;
using namespace vendor::graphics;
@@ -244,30 +246,15 @@
return nullptr;
}
- MapperMetadataType metadata_type{
- .name = ::pixel::graphics::kPixelMetadataTypeName,
- .value = static_cast<int64_t>(::pixel::graphics::MetadataType::VIDEO_HDR),
- };
+ using namespace ::pixel::graphics;
+ auto out_oe = mapper::get<MetadataType::VIDEO_HDR>(handle);
- Error error = Error::NONE;
- void* output = nullptr;
-
- get_mapper()->get(handle, metadata_type,
- [&](const auto& tmpError, const android::hardware::hidl_vec<uint8_t>& tmpVec) {
- error = tmpError;
- if (error != Error::NONE) {
- return;
- }
- output = decodePointer(tmpVec);
- });
-
-
- if (error != Error::NONE) {
+ if (!out_oe.has_value()) {
ALOGE("Failed to get video HDR metadata");
return nullptr;
}
- return output;
+ return out_oe.value();
}
void* VendorGraphicBufferMeta::get_video_metadata_roiinfo(buffer_handle_t hnd)
@@ -277,30 +264,15 @@
return nullptr;
}
- MapperMetadataType metadata_type{
- .name = ::pixel::graphics::kPixelMetadataTypeName,
- .value = static_cast<int64_t>(::pixel::graphics::MetadataType::VIDEO_ROI),
- };
+ using namespace ::pixel::graphics;
+ auto out_oe = mapper::get<MetadataType::VIDEO_ROI>(handle);
- Error error = Error::NONE;
- void* output = nullptr;
-
- get_mapper()->get(handle, metadata_type,
- [&](const auto& tmpError, const android::hardware::hidl_vec<uint8_t>& tmpVec) {
- error = tmpError;
- if (error != Error::NONE) {
- return;
- }
- output = decodePointer(tmpVec);
- });
-
-
- if (error != Error::NONE) {
- ALOGE("Failed to get video HDR metadata");
+ if (!out_oe.has_value()) {
+ ALOGE("Failed to get video ROI metadata");
return nullptr;
}
- return output;
+ return out_oe.value();
}
uint32_t VendorGraphicBufferMeta::get_format_fourcc(buffer_handle_t hnd) {
