exynos4: android.hardware.graphics.allocator@2.0 for Exynos4
* Buffer got corrupt because of the mNumFlexPlanes member. Use fixed value of 4 instead and exclude the member. * Usage bits were not filtered properly Change-Id: I7ee9fa73f896c505403447ae118a76d9f53e00a8
This commit is contained in:
Dominggoes Isakh
Shilin Victor
parent
79932c733a
commit
3cacced179
|
|
@ -0,0 +1,3 @@
|
|||
subdirs = [
|
||||
"exynos4",
|
||||
]
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
subdirs = [
|
||||
"interfaces",
|
||||
]
|
||||
|
|
@ -49,7 +49,7 @@ LOCAL_CFLAGS += -DSAMSUNG_EXYNOS
|
|||
LOCAL_CFLAGS += -DSAMSUNG_EXYNOS_CACHE_UMP
|
||||
LOCAL_CFLAGS += -DUSE_PARTIAL_FLUSH
|
||||
|
||||
LOCAL_STATIC_LIBRARIES := libgralloc1-adapter
|
||||
LOCAL_STATIC_LIBRARIES := libgralloc1-adapter-exynos4
|
||||
LOCAL_SHARED_LIBRARIES += libsync
|
||||
|
||||
ifeq ($(TARGET_SOC),exynos4210)
|
||||
|
|
|
|||
|
|
@ -0,0 +1,3 @@
|
|||
subdirs = [
|
||||
"gralloc",
|
||||
]
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
cc_library_shared {
|
||||
name: "android.hardware.graphics.allocator@2.0-impl-exynos4",
|
||||
defaults: ["hidl_defaults"],
|
||||
proprietary: true,
|
||||
relative_install_path: "hw",
|
||||
srcs: ["Gralloc.cpp", "Gralloc0Allocator.cpp", "Gralloc1Allocator.cpp"],
|
||||
include_dirs: ["system/core/libgrallocusage/include"],
|
||||
cppflags: ["-Wall", "-Wextra"],
|
||||
shared_libs: [
|
||||
"android.hardware.graphics.allocator@2.0",
|
||||
"libbase",
|
||||
"libcutils",
|
||||
"libhardware",
|
||||
"libhidlbase",
|
||||
"libhidltransport",
|
||||
"liblog",
|
||||
"libutils",
|
||||
],
|
||||
header_libs: [
|
||||
"libgrallocmapperincludes",
|
||||
],
|
||||
whole_static_libs: ["libgrallocusage"],
|
||||
}
|
||||
|
||||
cc_library_static {
|
||||
name: "libgralloc1-adapter-exynos4",
|
||||
defaults: ["hidl_defaults"],
|
||||
srcs: ["gralloc1-adapter.cpp", "Gralloc1On0Adapter.cpp"],
|
||||
include_dirs: ["system/core/libsync/include"],
|
||||
cflags: ["-Wall", "-Wextra"],
|
||||
export_include_dirs: ["."],
|
||||
whole_static_libs: ["libgrallocusage"],
|
||||
}
|
||||
|
|
@ -0,0 +1,57 @@
|
|||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#define LOG_TAG "GrallocPassthrough"
|
||||
|
||||
#include "Gralloc.h"
|
||||
#include "Gralloc0Allocator.h"
|
||||
#include "Gralloc1Allocator.h"
|
||||
|
||||
#include <log/log.h>
|
||||
|
||||
namespace android {
|
||||
namespace hardware {
|
||||
namespace graphics {
|
||||
namespace allocator {
|
||||
namespace V2_0 {
|
||||
namespace implementation {
|
||||
|
||||
IAllocator* HIDL_FETCH_IAllocator(const char* /* name */) {
|
||||
const hw_module_t* module = nullptr;
|
||||
int err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module);
|
||||
if (err) {
|
||||
ALOGE("failed to get gralloc module");
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
uint8_t major = (module->module_api_version >> 8) & 0xff;
|
||||
switch (major) {
|
||||
case 1:
|
||||
return new Gralloc1Allocator(module);
|
||||
case 0:
|
||||
return new Gralloc0Allocator(module);
|
||||
default:
|
||||
ALOGE("unknown gralloc module major version %d", major);
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace implementation
|
||||
} // namespace V2_0
|
||||
} // namespace allocator
|
||||
} // namespace graphics
|
||||
} // namespace hardware
|
||||
} // namespace android
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
/*
|
||||
* 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 ANDROID_HARDWARE_GRAPHICS_ALLOCATOR_V2_0_GRALLOC_H
|
||||
#define ANDROID_HARDWARE_GRAPHICS_ALLOCATOR_V2_0_GRALLOC_H
|
||||
|
||||
#include <android/hardware/graphics/allocator/2.0/IAllocator.h>
|
||||
|
||||
namespace android {
|
||||
namespace hardware {
|
||||
namespace graphics {
|
||||
namespace allocator {
|
||||
namespace V2_0 {
|
||||
namespace implementation {
|
||||
|
||||
extern "C" IAllocator* HIDL_FETCH_IAllocator(const char* name);
|
||||
|
||||
} // namespace implementation
|
||||
} // namespace V2_0
|
||||
} // namespace allocator
|
||||
} // namespace graphics
|
||||
} // namespace hardware
|
||||
} // namespace android
|
||||
|
||||
#endif // ANDROID_HARDWARE_GRAPHICS_ALLOCATOR_V2_0_GRALLOC_H
|
||||
|
|
@ -0,0 +1,144 @@
|
|||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#define LOG_TAG "Gralloc0Allocator"
|
||||
|
||||
#include "Gralloc0Allocator.h"
|
||||
#include "GrallocBufferDescriptor.h"
|
||||
|
||||
#include <vector>
|
||||
|
||||
#include <string.h>
|
||||
|
||||
#include <log/log.h>
|
||||
|
||||
namespace android {
|
||||
namespace hardware {
|
||||
namespace graphics {
|
||||
namespace allocator {
|
||||
namespace V2_0 {
|
||||
namespace implementation {
|
||||
|
||||
using android::hardware::graphics::mapper::V2_0::implementation::
|
||||
grallocDecodeBufferDescriptor;
|
||||
|
||||
Gralloc0Allocator::Gralloc0Allocator(const hw_module_t* module) {
|
||||
int result = gralloc_open(module, &mDevice);
|
||||
if (result) {
|
||||
LOG_ALWAYS_FATAL("failed to open gralloc0 device: %s",
|
||||
strerror(-result));
|
||||
}
|
||||
}
|
||||
|
||||
Gralloc0Allocator::~Gralloc0Allocator() {
|
||||
gralloc_close(mDevice);
|
||||
}
|
||||
|
||||
Return<void> Gralloc0Allocator::dumpDebugInfo(dumpDebugInfo_cb hidl_cb) {
|
||||
char buf[4096] = {};
|
||||
if (mDevice->dump) {
|
||||
mDevice->dump(mDevice, buf, sizeof(buf));
|
||||
buf[sizeof(buf) - 1] = '\0';
|
||||
}
|
||||
|
||||
hidl_cb(hidl_string(buf));
|
||||
|
||||
return Void();
|
||||
}
|
||||
|
||||
Return<void> Gralloc0Allocator::allocate(const BufferDescriptor& descriptor,
|
||||
uint32_t count, allocate_cb hidl_cb) {
|
||||
IMapper::BufferDescriptorInfo descriptorInfo;
|
||||
if (!grallocDecodeBufferDescriptor(descriptor, &descriptorInfo)) {
|
||||
hidl_cb(Error::BAD_DESCRIPTOR, 0, hidl_vec<hidl_handle>());
|
||||
return Void();
|
||||
}
|
||||
|
||||
Error error = Error::NONE;
|
||||
uint32_t stride = 0;
|
||||
std::vector<hidl_handle> buffers;
|
||||
buffers.reserve(count);
|
||||
|
||||
// allocate the buffers
|
||||
for (uint32_t i = 0; i < count; i++) {
|
||||
buffer_handle_t tmpBuffer;
|
||||
uint32_t tmpStride;
|
||||
error = allocateOne(descriptorInfo, &tmpBuffer, &tmpStride);
|
||||
if (error != Error::NONE) {
|
||||
break;
|
||||
}
|
||||
|
||||
if (stride == 0) {
|
||||
stride = tmpStride;
|
||||
} else if (stride != tmpStride) {
|
||||
// non-uniform strides
|
||||
mDevice->free(mDevice, tmpBuffer);
|
||||
stride = 0;
|
||||
error = Error::UNSUPPORTED;
|
||||
break;
|
||||
}
|
||||
|
||||
buffers.emplace_back(hidl_handle(tmpBuffer));
|
||||
}
|
||||
|
||||
// return the buffers
|
||||
hidl_vec<hidl_handle> hidl_buffers;
|
||||
if (error == Error::NONE) {
|
||||
hidl_buffers.setToExternal(buffers.data(), buffers.size());
|
||||
}
|
||||
hidl_cb(error, stride, hidl_buffers);
|
||||
|
||||
// free the buffers
|
||||
for (const auto& buffer : buffers) {
|
||||
mDevice->free(mDevice, buffer.getNativeHandle());
|
||||
}
|
||||
|
||||
return Void();
|
||||
}
|
||||
|
||||
Error Gralloc0Allocator::allocateOne(const IMapper::BufferDescriptorInfo& info,
|
||||
buffer_handle_t* outBuffer,
|
||||
uint32_t* outStride) {
|
||||
if (info.layerCount > 1 || (info.usage >> 32) != 0) {
|
||||
return Error::BAD_VALUE;
|
||||
}
|
||||
|
||||
buffer_handle_t buffer = nullptr;
|
||||
int stride = 0;
|
||||
int result = mDevice->alloc(mDevice, info.width, info.height,
|
||||
static_cast<int>(info.format), info.usage,
|
||||
&buffer, &stride);
|
||||
if (result) {
|
||||
switch (result) {
|
||||
case -EINVAL:
|
||||
return Error::BAD_VALUE;
|
||||
default:
|
||||
return Error::NO_RESOURCES;
|
||||
}
|
||||
}
|
||||
|
||||
*outBuffer = buffer;
|
||||
*outStride = stride;
|
||||
|
||||
return Error::NONE;
|
||||
}
|
||||
|
||||
} // namespace implementation
|
||||
} // namespace V2_0
|
||||
} // namespace allocator
|
||||
} // namespace graphics
|
||||
} // namespace hardware
|
||||
} // namespace android
|
||||
|
|
@ -0,0 +1,59 @@
|
|||
/*
|
||||
* 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 ANDROID_HARDWARE_GRAPHICS_ALLOCATOR_V2_0_GRALLOC0ALLOCATOR_H
|
||||
#define ANDROID_HARDWARE_GRAPHICS_ALLOCATOR_V2_0_GRALLOC0ALLOCATOR_H
|
||||
|
||||
#include <android/hardware/graphics/allocator/2.0/IAllocator.h>
|
||||
#include <android/hardware/graphics/mapper/2.0/IMapper.h>
|
||||
#include <hardware/gralloc.h>
|
||||
|
||||
namespace android {
|
||||
namespace hardware {
|
||||
namespace graphics {
|
||||
namespace allocator {
|
||||
namespace V2_0 {
|
||||
namespace implementation {
|
||||
|
||||
using android::hardware::graphics::mapper::V2_0::IMapper;
|
||||
using android::hardware::graphics::mapper::V2_0::BufferDescriptor;
|
||||
using android::hardware::graphics::mapper::V2_0::Error;
|
||||
|
||||
class Gralloc0Allocator : public IAllocator {
|
||||
public:
|
||||
Gralloc0Allocator(const hw_module_t* module);
|
||||
virtual ~Gralloc0Allocator();
|
||||
|
||||
// IAllocator interface
|
||||
Return<void> dumpDebugInfo(dumpDebugInfo_cb hidl_cb) override;
|
||||
Return<void> allocate(const BufferDescriptor& descriptor, uint32_t count,
|
||||
allocate_cb hidl_cb) override;
|
||||
|
||||
private:
|
||||
Error allocateOne(const IMapper::BufferDescriptorInfo& info,
|
||||
buffer_handle_t* outBuffer, uint32_t* outStride);
|
||||
|
||||
alloc_device_t* mDevice;
|
||||
};
|
||||
|
||||
} // namespace implementation
|
||||
} // namespace V2_0
|
||||
} // namespace allocator
|
||||
} // namespace graphics
|
||||
} // namespace hardware
|
||||
} // namespace android
|
||||
|
||||
#endif // ANDROID_HARDWARE_GRAPHICS_ALLOCATOR_V2_0_GRALLOC0ALLOCATOR_H
|
||||
|
|
@ -0,0 +1,337 @@
|
|||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#define LOG_TAG "Gralloc1Allocator"
|
||||
|
||||
#include "Gralloc1Allocator.h"
|
||||
#include "GrallocBufferDescriptor.h"
|
||||
|
||||
#include <vector>
|
||||
|
||||
#include <string.h>
|
||||
|
||||
#include <log/log.h>
|
||||
|
||||
#include <grallocusage/GrallocUsageConversion.h>
|
||||
|
||||
namespace android {
|
||||
namespace hardware {
|
||||
namespace graphics {
|
||||
namespace allocator {
|
||||
namespace V2_0 {
|
||||
namespace implementation {
|
||||
|
||||
using android::hardware::graphics::common::V1_0::BufferUsage;
|
||||
using android::hardware::graphics::mapper::V2_0::implementation::
|
||||
grallocDecodeBufferDescriptor;
|
||||
|
||||
Gralloc1Allocator::Gralloc1Allocator(const hw_module_t* module)
|
||||
: mDevice(nullptr), mCapabilities(), mDispatch() {
|
||||
int result = gralloc1_open(module, &mDevice);
|
||||
if (result) {
|
||||
LOG_ALWAYS_FATAL("failed to open gralloc1 device: %s",
|
||||
strerror(-result));
|
||||
}
|
||||
|
||||
initCapabilities();
|
||||
initDispatch();
|
||||
}
|
||||
|
||||
Gralloc1Allocator::~Gralloc1Allocator() {
|
||||
gralloc1_close(mDevice);
|
||||
}
|
||||
|
||||
void Gralloc1Allocator::initCapabilities() {
|
||||
uint32_t count = 0;
|
||||
mDevice->getCapabilities(mDevice, &count, nullptr);
|
||||
|
||||
std::vector<int32_t> capabilities(count);
|
||||
mDevice->getCapabilities(mDevice, &count, capabilities.data());
|
||||
capabilities.resize(count);
|
||||
|
||||
for (auto capability : capabilities) {
|
||||
if (capability == GRALLOC1_CAPABILITY_LAYERED_BUFFERS) {
|
||||
mCapabilities.layeredBuffers = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void Gralloc1Allocator::initDispatch(gralloc1_function_descriptor_t desc,
|
||||
T* outPfn) {
|
||||
auto pfn = mDevice->getFunction(mDevice, desc);
|
||||
if (!pfn) {
|
||||
LOG_ALWAYS_FATAL("failed to get gralloc1 function %d", desc);
|
||||
}
|
||||
|
||||
*outPfn = reinterpret_cast<T>(pfn);
|
||||
}
|
||||
|
||||
void Gralloc1Allocator::initDispatch() {
|
||||
initDispatch(GRALLOC1_FUNCTION_DUMP, &mDispatch.dump);
|
||||
initDispatch(GRALLOC1_FUNCTION_CREATE_DESCRIPTOR,
|
||||
&mDispatch.createDescriptor);
|
||||
initDispatch(GRALLOC1_FUNCTION_DESTROY_DESCRIPTOR,
|
||||
&mDispatch.destroyDescriptor);
|
||||
initDispatch(GRALLOC1_FUNCTION_SET_DIMENSIONS, &mDispatch.setDimensions);
|
||||
initDispatch(GRALLOC1_FUNCTION_SET_FORMAT, &mDispatch.setFormat);
|
||||
if (mCapabilities.layeredBuffers) {
|
||||
initDispatch(GRALLOC1_FUNCTION_SET_LAYER_COUNT,
|
||||
&mDispatch.setLayerCount);
|
||||
}
|
||||
initDispatch(GRALLOC1_FUNCTION_SET_CONSUMER_USAGE,
|
||||
&mDispatch.setConsumerUsage);
|
||||
initDispatch(GRALLOC1_FUNCTION_SET_PRODUCER_USAGE,
|
||||
&mDispatch.setProducerUsage);
|
||||
initDispatch(GRALLOC1_FUNCTION_GET_STRIDE, &mDispatch.getStride);
|
||||
initDispatch(GRALLOC1_FUNCTION_ALLOCATE, &mDispatch.allocate);
|
||||
initDispatch(GRALLOC1_FUNCTION_RELEASE, &mDispatch.release);
|
||||
}
|
||||
|
||||
Return<void> Gralloc1Allocator::dumpDebugInfo(dumpDebugInfo_cb hidl_cb) {
|
||||
uint32_t len = 0;
|
||||
mDispatch.dump(mDevice, &len, nullptr);
|
||||
|
||||
std::vector<char> buf(len + 1);
|
||||
mDispatch.dump(mDevice, &len, buf.data());
|
||||
buf.resize(len + 1);
|
||||
buf[len] = '\0';
|
||||
|
||||
hidl_string reply;
|
||||
reply.setToExternal(buf.data(), len);
|
||||
hidl_cb(reply);
|
||||
|
||||
return Void();
|
||||
}
|
||||
|
||||
Return<void> Gralloc1Allocator::allocate(const BufferDescriptor& descriptor,
|
||||
uint32_t count, allocate_cb hidl_cb) {
|
||||
IMapper::BufferDescriptorInfo descriptorInfo;
|
||||
if (!grallocDecodeBufferDescriptor(descriptor, &descriptorInfo)) {
|
||||
hidl_cb(Error::BAD_DESCRIPTOR, 0, hidl_vec<hidl_handle>());
|
||||
return Void();
|
||||
}
|
||||
|
||||
gralloc1_buffer_descriptor_t desc;
|
||||
Error error = createDescriptor(descriptorInfo, &desc);
|
||||
if (error != Error::NONE) {
|
||||
hidl_cb(error, 0, hidl_vec<hidl_handle>());
|
||||
return Void();
|
||||
}
|
||||
|
||||
uint32_t stride = 0;
|
||||
std::vector<hidl_handle> buffers;
|
||||
buffers.reserve(count);
|
||||
|
||||
// allocate the buffers
|
||||
for (uint32_t i = 0; i < count; i++) {
|
||||
buffer_handle_t tmpBuffer;
|
||||
uint32_t tmpStride;
|
||||
error = allocateOne(desc, &tmpBuffer, &tmpStride);
|
||||
if (error != Error::NONE) {
|
||||
break;
|
||||
}
|
||||
|
||||
if (stride == 0) {
|
||||
stride = tmpStride;
|
||||
} else if (stride != tmpStride) {
|
||||
// non-uniform strides
|
||||
mDispatch.release(mDevice, tmpBuffer);
|
||||
stride = 0;
|
||||
error = Error::UNSUPPORTED;
|
||||
break;
|
||||
}
|
||||
|
||||
buffers.emplace_back(hidl_handle(tmpBuffer));
|
||||
}
|
||||
|
||||
mDispatch.destroyDescriptor(mDevice, desc);
|
||||
|
||||
// return the buffers
|
||||
hidl_vec<hidl_handle> hidl_buffers;
|
||||
if (error == Error::NONE) {
|
||||
hidl_buffers.setToExternal(buffers.data(), buffers.size());
|
||||
}
|
||||
hidl_cb(error, stride, hidl_buffers);
|
||||
|
||||
// free the buffers
|
||||
for (const auto& buffer : buffers) {
|
||||
mDispatch.release(mDevice, buffer.getNativeHandle());
|
||||
}
|
||||
|
||||
return Void();
|
||||
}
|
||||
|
||||
Error Gralloc1Allocator::toError(int32_t error) {
|
||||
switch (error) {
|
||||
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:
|
||||
return Error::BAD_VALUE;
|
||||
case GRALLOC1_ERROR_NOT_SHARED:
|
||||
return Error::NONE; // this is fine
|
||||
case GRALLOC1_ERROR_NO_RESOURCES:
|
||||
return Error::NO_RESOURCES;
|
||||
case GRALLOC1_ERROR_UNDEFINED:
|
||||
case GRALLOC1_ERROR_UNSUPPORTED:
|
||||
default:
|
||||
return Error::UNSUPPORTED;
|
||||
}
|
||||
}
|
||||
|
||||
uint64_t Gralloc1Allocator::toProducerUsage(uint64_t usage) {
|
||||
// this is potentially broken as we have no idea which private flags
|
||||
// should be filtered out
|
||||
uint64_t producerUsage =
|
||||
usage &
|
||||
~static_cast<uint64_t>(BufferUsage::CPU_READ_MASK | BufferUsage::CPU_WRITE_MASK |
|
||||
BufferUsage::GPU_DATA_BUFFER);
|
||||
|
||||
switch (usage & BufferUsage::CPU_WRITE_MASK) {
|
||||
case static_cast<uint64_t>(BufferUsage::CPU_WRITE_RARELY):
|
||||
producerUsage |= GRALLOC1_PRODUCER_USAGE_CPU_WRITE;
|
||||
break;
|
||||
case static_cast<uint64_t>(BufferUsage::CPU_WRITE_OFTEN):
|
||||
producerUsage |= GRALLOC1_PRODUCER_USAGE_CPU_WRITE_OFTEN;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
switch (usage & BufferUsage::CPU_READ_MASK) {
|
||||
case static_cast<uint64_t>(BufferUsage::CPU_READ_RARELY):
|
||||
producerUsage |= GRALLOC1_PRODUCER_USAGE_CPU_READ;
|
||||
break;
|
||||
case static_cast<uint64_t>(BufferUsage::CPU_READ_OFTEN):
|
||||
producerUsage |= GRALLOC1_PRODUCER_USAGE_CPU_READ_OFTEN;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
// BufferUsage::GPU_DATA_BUFFER is always filtered out
|
||||
|
||||
return producerUsage;
|
||||
}
|
||||
|
||||
uint64_t Gralloc1Allocator::toConsumerUsage(uint64_t usage) {
|
||||
// this is potentially broken as we have no idea which private flags
|
||||
// should be filtered out
|
||||
uint64_t consumerUsage =
|
||||
usage &
|
||||
~static_cast<uint64_t>(BufferUsage::CPU_READ_MASK | BufferUsage::CPU_WRITE_MASK |
|
||||
BufferUsage::SENSOR_DIRECT_DATA | BufferUsage::GPU_DATA_BUFFER);
|
||||
|
||||
switch (usage & BufferUsage::CPU_READ_MASK) {
|
||||
case static_cast<uint64_t>(BufferUsage::CPU_READ_RARELY):
|
||||
consumerUsage |= GRALLOC1_CONSUMER_USAGE_CPU_READ;
|
||||
break;
|
||||
case static_cast<uint64_t>(BufferUsage::CPU_READ_OFTEN):
|
||||
consumerUsage |= GRALLOC1_CONSUMER_USAGE_CPU_READ_OFTEN;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
// BufferUsage::SENSOR_DIRECT_DATA is always filtered out
|
||||
|
||||
if (usage & BufferUsage::GPU_DATA_BUFFER) {
|
||||
consumerUsage |= GRALLOC1_CONSUMER_USAGE_GPU_DATA_BUFFER;
|
||||
}
|
||||
|
||||
return consumerUsage;
|
||||
}
|
||||
|
||||
Error Gralloc1Allocator::createDescriptor(
|
||||
const IMapper::BufferDescriptorInfo& info,
|
||||
gralloc1_buffer_descriptor_t* outDescriptor) {
|
||||
gralloc1_buffer_descriptor_t descriptor;
|
||||
|
||||
int32_t error = mDispatch.createDescriptor(mDevice, &descriptor);
|
||||
|
||||
if (error == GRALLOC1_ERROR_NONE) {
|
||||
error = mDispatch.setDimensions(mDevice, descriptor, info.width,
|
||||
info.height);
|
||||
}
|
||||
if (error == GRALLOC1_ERROR_NONE) {
|
||||
error = mDispatch.setFormat(mDevice, descriptor,
|
||||
static_cast<int32_t>(info.format));
|
||||
}
|
||||
if (error == GRALLOC1_ERROR_NONE) {
|
||||
if (mCapabilities.layeredBuffers) {
|
||||
error =
|
||||
mDispatch.setLayerCount(mDevice, descriptor, info.layerCount);
|
||||
} else if (info.layerCount > 1) {
|
||||
error = GRALLOC1_ERROR_UNSUPPORTED;
|
||||
}
|
||||
}
|
||||
uint64_t producerUsage = 0;
|
||||
uint64_t consumerUsage = 0;
|
||||
|
||||
android_convertGralloc0To1Usage(static_cast<uint32_t>(info.usage),
|
||||
&producerUsage, &consumerUsage);
|
||||
|
||||
if (error == GRALLOC1_ERROR_NONE) {
|
||||
error = mDispatch.setProducerUsage(mDevice, descriptor,
|
||||
producerUsage);
|
||||
}
|
||||
if (error == GRALLOC1_ERROR_NONE) {
|
||||
error = mDispatch.setConsumerUsage(mDevice, descriptor,
|
||||
consumerUsage);
|
||||
}
|
||||
|
||||
if (error == GRALLOC1_ERROR_NONE) {
|
||||
*outDescriptor = descriptor;
|
||||
} else {
|
||||
mDispatch.destroyDescriptor(mDevice, descriptor);
|
||||
}
|
||||
|
||||
return toError(error);
|
||||
}
|
||||
|
||||
Error Gralloc1Allocator::allocateOne(gralloc1_buffer_descriptor_t descriptor,
|
||||
buffer_handle_t* outBuffer,
|
||||
uint32_t* outStride) {
|
||||
buffer_handle_t buffer = nullptr;
|
||||
int32_t error = mDispatch.allocate(mDevice, 1, &descriptor, &buffer);
|
||||
if (error != GRALLOC1_ERROR_NONE && error != GRALLOC1_ERROR_NOT_SHARED) {
|
||||
return toError(error);
|
||||
}
|
||||
|
||||
uint32_t stride = 0;
|
||||
error = mDispatch.getStride(mDevice, buffer, &stride);
|
||||
if (error != GRALLOC1_ERROR_NONE && error != GRALLOC1_ERROR_UNDEFINED) {
|
||||
mDispatch.release(mDevice, buffer);
|
||||
return toError(error);
|
||||
}
|
||||
|
||||
*outBuffer = buffer;
|
||||
*outStride = stride;
|
||||
|
||||
return Error::NONE;
|
||||
}
|
||||
|
||||
} // namespace implementation
|
||||
} // namespace V2_0
|
||||
} // namespace allocator
|
||||
} // namespace graphics
|
||||
} // namespace hardware
|
||||
} // namespace android
|
||||
|
|
@ -0,0 +1,89 @@
|
|||
/*
|
||||
* 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 ANDROID_HARDWARE_GRAPHICS_ALLOCATOR_V2_0_GRALLOC1ALLOCATOR_H
|
||||
#define ANDROID_HARDWARE_GRAPHICS_ALLOCATOR_V2_0_GRALLOC1ALLOCATOR_H
|
||||
|
||||
#include <android/hardware/graphics/allocator/2.0/IAllocator.h>
|
||||
#include <android/hardware/graphics/mapper/2.0/IMapper.h>
|
||||
#include <hardware/gralloc1.h>
|
||||
|
||||
namespace android {
|
||||
namespace hardware {
|
||||
namespace graphics {
|
||||
namespace allocator {
|
||||
namespace V2_0 {
|
||||
namespace implementation {
|
||||
|
||||
using android::hardware::graphics::mapper::V2_0::IMapper;
|
||||
using android::hardware::graphics::mapper::V2_0::BufferDescriptor;
|
||||
using android::hardware::graphics::mapper::V2_0::Error;
|
||||
|
||||
class Gralloc1Allocator : public IAllocator {
|
||||
public:
|
||||
Gralloc1Allocator(const hw_module_t* module);
|
||||
virtual ~Gralloc1Allocator();
|
||||
|
||||
// IAllocator interface
|
||||
Return<void> dumpDebugInfo(dumpDebugInfo_cb hidl_cb) override;
|
||||
Return<void> allocate(const BufferDescriptor& descriptor, uint32_t count,
|
||||
allocate_cb hidl_cb) override;
|
||||
|
||||
private:
|
||||
void initCapabilities();
|
||||
|
||||
template <typename T>
|
||||
void initDispatch(gralloc1_function_descriptor_t desc, T* outPfn);
|
||||
void initDispatch();
|
||||
|
||||
static Error toError(int32_t error);
|
||||
static uint64_t toProducerUsage(uint64_t usage);
|
||||
static uint64_t toConsumerUsage(uint64_t usage);
|
||||
|
||||
Error createDescriptor(const IMapper::BufferDescriptorInfo& info,
|
||||
gralloc1_buffer_descriptor_t* outDescriptor);
|
||||
Error allocateOne(gralloc1_buffer_descriptor_t descriptor,
|
||||
buffer_handle_t* outBuffer, uint32_t* outStride);
|
||||
|
||||
gralloc1_device_t* mDevice;
|
||||
|
||||
struct {
|
||||
bool layeredBuffers;
|
||||
} mCapabilities;
|
||||
|
||||
struct {
|
||||
GRALLOC1_PFN_DUMP dump;
|
||||
GRALLOC1_PFN_CREATE_DESCRIPTOR createDescriptor;
|
||||
GRALLOC1_PFN_DESTROY_DESCRIPTOR destroyDescriptor;
|
||||
GRALLOC1_PFN_SET_DIMENSIONS setDimensions;
|
||||
GRALLOC1_PFN_SET_FORMAT setFormat;
|
||||
GRALLOC1_PFN_SET_LAYER_COUNT setLayerCount;
|
||||
GRALLOC1_PFN_SET_CONSUMER_USAGE setConsumerUsage;
|
||||
GRALLOC1_PFN_SET_PRODUCER_USAGE setProducerUsage;
|
||||
GRALLOC1_PFN_GET_STRIDE getStride;
|
||||
GRALLOC1_PFN_ALLOCATE allocate;
|
||||
GRALLOC1_PFN_RELEASE release;
|
||||
} mDispatch;
|
||||
};
|
||||
|
||||
} // namespace implementation
|
||||
} // namespace V2_0
|
||||
} // namespace allocator
|
||||
} // namespace graphics
|
||||
} // namespace hardware
|
||||
} // namespace android
|
||||
|
||||
#endif // ANDROID_HARDWARE_GRAPHICS_ALLOCATOR_V2_0_GRALLOC1ALLOCATOR_H
|
||||
|
|
@ -0,0 +1,560 @@
|
|||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#undef LOG_TAG
|
||||
#define LOG_TAG "Gralloc1On0Adapter"
|
||||
//#define LOG_NDEBUG 0
|
||||
|
||||
#include "Gralloc1On0Adapter.h"
|
||||
#include "gralloc1-adapter.h"
|
||||
|
||||
#include <grallocusage/GrallocUsageConversion.h>
|
||||
|
||||
#include <hardware/gralloc.h>
|
||||
|
||||
#include <log/log.h>
|
||||
#include <sync/sync.h>
|
||||
|
||||
#include <inttypes.h>
|
||||
|
||||
template <typename PFN, typename T>
|
||||
static gralloc1_function_pointer_t asFP(T function)
|
||||
{
|
||||
static_assert(std::is_same<PFN, T>::value, "Incompatible function pointer");
|
||||
return reinterpret_cast<gralloc1_function_pointer_t>(function);
|
||||
}
|
||||
|
||||
namespace android {
|
||||
namespace hardware {
|
||||
|
||||
Gralloc1On0Adapter::Gralloc1On0Adapter(const hw_module_t* module)
|
||||
: gralloc1_device_t(),
|
||||
mModule(reinterpret_cast<const gralloc_module_t*>(module)),
|
||||
mDevice(nullptr)
|
||||
{
|
||||
ALOGV("Constructing");
|
||||
|
||||
int minor = 0;
|
||||
mModule->perform(mModule,
|
||||
GRALLOC1_ADAPTER_PERFORM_GET_REAL_MODULE_API_VERSION_MINOR,
|
||||
&minor);
|
||||
mMinorVersion = minor;
|
||||
|
||||
common.tag = HARDWARE_DEVICE_TAG,
|
||||
common.version = HARDWARE_DEVICE_API_VERSION(0, 0),
|
||||
common.module = const_cast<struct hw_module_t*>(module),
|
||||
common.close = closeHook,
|
||||
|
||||
getCapabilities = getCapabilitiesHook;
|
||||
getFunction = getFunctionHook;
|
||||
int error = ::gralloc_open(&(mModule->common), &mDevice);
|
||||
if (error) {
|
||||
ALOGE("Failed to open gralloc0 module: %d", error);
|
||||
}
|
||||
ALOGV("Opened gralloc0 device %p", mDevice);
|
||||
}
|
||||
|
||||
Gralloc1On0Adapter::~Gralloc1On0Adapter()
|
||||
{
|
||||
ALOGV("Destructing");
|
||||
if (mDevice) {
|
||||
ALOGV("Closing gralloc0 device %p", mDevice);
|
||||
::gralloc_close(mDevice);
|
||||
}
|
||||
}
|
||||
|
||||
void Gralloc1On0Adapter::doGetCapabilities(uint32_t* outCount,
|
||||
int32_t* /*outCapabilities*/) {
|
||||
*outCount = 0;
|
||||
}
|
||||
|
||||
gralloc1_function_pointer_t Gralloc1On0Adapter::doGetFunction(
|
||||
int32_t intDescriptor)
|
||||
{
|
||||
constexpr auto lastDescriptor =
|
||||
static_cast<int32_t>(GRALLOC1_LAST_FUNCTION);
|
||||
if (intDescriptor < 0 || intDescriptor > lastDescriptor) {
|
||||
ALOGE("Invalid function descriptor");
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
auto descriptor =
|
||||
static_cast<gralloc1_function_descriptor_t>(intDescriptor);
|
||||
switch (descriptor) {
|
||||
case GRALLOC1_FUNCTION_DUMP:
|
||||
return asFP<GRALLOC1_PFN_DUMP>(dumpHook);
|
||||
case GRALLOC1_FUNCTION_CREATE_DESCRIPTOR:
|
||||
return asFP<GRALLOC1_PFN_CREATE_DESCRIPTOR>(createDescriptorHook);
|
||||
case GRALLOC1_FUNCTION_DESTROY_DESCRIPTOR:
|
||||
return asFP<GRALLOC1_PFN_DESTROY_DESCRIPTOR>(destroyDescriptorHook);
|
||||
case GRALLOC1_FUNCTION_SET_CONSUMER_USAGE:
|
||||
return asFP<GRALLOC1_PFN_SET_CONSUMER_USAGE>(setConsumerUsageHook);
|
||||
case GRALLOC1_FUNCTION_SET_DIMENSIONS:
|
||||
return asFP<GRALLOC1_PFN_SET_DIMENSIONS>(setDimensionsHook);
|
||||
case GRALLOC1_FUNCTION_SET_FORMAT:
|
||||
return asFP<GRALLOC1_PFN_SET_FORMAT>(setFormatHook);
|
||||
case GRALLOC1_FUNCTION_SET_LAYER_COUNT:
|
||||
return asFP<GRALLOC1_PFN_SET_LAYER_COUNT>(setLayerCountHook);
|
||||
case GRALLOC1_FUNCTION_SET_PRODUCER_USAGE:
|
||||
return asFP<GRALLOC1_PFN_SET_PRODUCER_USAGE>(setProducerUsageHook);
|
||||
case GRALLOC1_FUNCTION_GET_BACKING_STORE:
|
||||
return asFP<GRALLOC1_PFN_GET_BACKING_STORE>(
|
||||
bufferHook<decltype(&Buffer::getBackingStore),
|
||||
&Buffer::getBackingStore, gralloc1_backing_store_t*>);
|
||||
case GRALLOC1_FUNCTION_GET_CONSUMER_USAGE:
|
||||
return asFP<GRALLOC1_PFN_GET_CONSUMER_USAGE>(getConsumerUsageHook);
|
||||
case GRALLOC1_FUNCTION_GET_DIMENSIONS:
|
||||
return asFP<GRALLOC1_PFN_GET_DIMENSIONS>(
|
||||
bufferHook<decltype(&Buffer::getDimensions),
|
||||
&Buffer::getDimensions, uint32_t*, uint32_t*>);
|
||||
case GRALLOC1_FUNCTION_GET_FORMAT:
|
||||
return asFP<GRALLOC1_PFN_GET_FORMAT>(
|
||||
bufferHook<decltype(&Buffer::getFormat),
|
||||
&Buffer::getFormat, int32_t*>);
|
||||
case GRALLOC1_FUNCTION_GET_LAYER_COUNT:
|
||||
return asFP<GRALLOC1_PFN_GET_LAYER_COUNT>(
|
||||
bufferHook<decltype(&Buffer::getLayerCount),
|
||||
&Buffer::getLayerCount, uint32_t*>);
|
||||
case GRALLOC1_FUNCTION_GET_PRODUCER_USAGE:
|
||||
return asFP<GRALLOC1_PFN_GET_PRODUCER_USAGE>(getProducerUsageHook);
|
||||
case GRALLOC1_FUNCTION_GET_STRIDE:
|
||||
return asFP<GRALLOC1_PFN_GET_STRIDE>(
|
||||
bufferHook<decltype(&Buffer::getStride),
|
||||
&Buffer::getStride, uint32_t*>);
|
||||
case GRALLOC1_FUNCTION_ALLOCATE:
|
||||
if (mDevice != nullptr) {
|
||||
return asFP<GRALLOC1_PFN_ALLOCATE>(allocateHook);
|
||||
} else {
|
||||
return nullptr;
|
||||
}
|
||||
case GRALLOC1_FUNCTION_RETAIN:
|
||||
return asFP<GRALLOC1_PFN_RETAIN>(retainHook);
|
||||
case GRALLOC1_FUNCTION_RELEASE:
|
||||
return asFP<GRALLOC1_PFN_RELEASE>(releaseHook);
|
||||
case GRALLOC1_FUNCTION_GET_NUM_FLEX_PLANES:
|
||||
return asFP<GRALLOC1_PFN_GET_NUM_FLEX_PLANES>(
|
||||
bufferHook<decltype(&Buffer::getNumFlexPlanes),
|
||||
&Buffer::getNumFlexPlanes, uint32_t*>);
|
||||
case GRALLOC1_FUNCTION_LOCK:
|
||||
return asFP<GRALLOC1_PFN_LOCK>(
|
||||
lockHook<void*, &Gralloc1On0Adapter::lock>);
|
||||
case GRALLOC1_FUNCTION_LOCK_FLEX:
|
||||
return asFP<GRALLOC1_PFN_LOCK_FLEX>(
|
||||
lockHook<struct android_flex_layout,
|
||||
&Gralloc1On0Adapter::lockFlex>);
|
||||
case GRALLOC1_FUNCTION_UNLOCK:
|
||||
return asFP<GRALLOC1_PFN_UNLOCK>(unlockHook);
|
||||
case GRALLOC1_FUNCTION_INVALID:
|
||||
ALOGE("Invalid function descriptor");
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
ALOGE("Unknown function descriptor: %d", intDescriptor);
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
void Gralloc1On0Adapter::dump(uint32_t* outSize, char* outBuffer)
|
||||
{
|
||||
ALOGV("dump(%u (%p), %p", outSize ? *outSize : 0, outSize, outBuffer);
|
||||
|
||||
if (!mDevice->dump) {
|
||||
// dump is optional on gralloc0 implementations
|
||||
*outSize = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
if (!outBuffer) {
|
||||
constexpr int32_t BUFFER_LENGTH = 4096;
|
||||
char buffer[BUFFER_LENGTH] = {};
|
||||
mDevice->dump(mDevice, buffer, BUFFER_LENGTH);
|
||||
buffer[BUFFER_LENGTH - 1] = 0; // Ensure the buffer is null-terminated
|
||||
size_t actualLength = std::strlen(buffer);
|
||||
mCachedDump.resize(actualLength);
|
||||
std::copy_n(buffer, actualLength, mCachedDump.begin());
|
||||
*outSize = static_cast<uint32_t>(actualLength);
|
||||
} else {
|
||||
*outSize = std::min(*outSize,
|
||||
static_cast<uint32_t>(mCachedDump.size()));
|
||||
outBuffer = std::copy_n(mCachedDump.cbegin(), *outSize, outBuffer);
|
||||
}
|
||||
}
|
||||
|
||||
gralloc1_error_t Gralloc1On0Adapter::createDescriptor(
|
||||
gralloc1_buffer_descriptor_t* outDescriptor)
|
||||
{
|
||||
auto descriptorId = sNextBufferDescriptorId++;
|
||||
std::lock_guard<std::mutex> lock(mDescriptorMutex);
|
||||
mDescriptors.emplace(descriptorId, std::make_shared<Descriptor>());
|
||||
|
||||
ALOGV("Created descriptor %" PRIu64, descriptorId);
|
||||
|
||||
*outDescriptor = descriptorId;
|
||||
return GRALLOC1_ERROR_NONE;
|
||||
}
|
||||
|
||||
gralloc1_error_t Gralloc1On0Adapter::destroyDescriptor(
|
||||
gralloc1_buffer_descriptor_t descriptor)
|
||||
{
|
||||
ALOGV("Destroying descriptor %" PRIu64, descriptor);
|
||||
|
||||
std::lock_guard<std::mutex> lock(mDescriptorMutex);
|
||||
if (mDescriptors.count(descriptor) == 0) {
|
||||
return GRALLOC1_ERROR_BAD_DESCRIPTOR;
|
||||
}
|
||||
|
||||
mDescriptors.erase(descriptor);
|
||||
return GRALLOC1_ERROR_NONE;
|
||||
}
|
||||
|
||||
Gralloc1On0Adapter::Buffer::Buffer(buffer_handle_t handle,
|
||||
gralloc1_backing_store_t store, const Descriptor& descriptor,
|
||||
uint32_t stride, uint32_t /* numFlexPlanes */, bool wasAllocated)
|
||||
: mHandle(handle),
|
||||
mReferenceCount(1),
|
||||
mStore(store),
|
||||
mDescriptor(descriptor),
|
||||
mStride(stride),
|
||||
mWasAllocated(wasAllocated) {}
|
||||
|
||||
gralloc1_error_t Gralloc1On0Adapter::allocate(
|
||||
gralloc1_buffer_descriptor_t id,
|
||||
const std::shared_ptr<Descriptor>& descriptor,
|
||||
buffer_handle_t* outBufferHandle)
|
||||
{
|
||||
ALOGV("allocate(%" PRIu64 ")", id);
|
||||
|
||||
// If this function is being called, it's because we handed out its function
|
||||
// pointer, which only occurs when mDevice has been loaded successfully and
|
||||
// we are permitted to allocate
|
||||
|
||||
int usage = android_convertGralloc1To0Usage(
|
||||
descriptor->producerUsage, descriptor->consumerUsage);
|
||||
buffer_handle_t handle = nullptr;
|
||||
int stride = 0;
|
||||
ALOGV("Calling alloc(%p, %u, %u, %i, %u)", mDevice, descriptor->width,
|
||||
descriptor->height, descriptor->format, usage);
|
||||
auto error = mDevice->alloc(mDevice,
|
||||
static_cast<int>(descriptor->width),
|
||||
static_cast<int>(descriptor->height), descriptor->format,
|
||||
usage, &handle, &stride);
|
||||
if (error != 0) {
|
||||
ALOGE("gralloc0 allocation failed: %d (%s)", error,
|
||||
strerror(-error));
|
||||
return GRALLOC1_ERROR_NO_RESOURCES;
|
||||
}
|
||||
|
||||
mModule->perform(mModule, GRALLOC1_ADAPTER_PERFORM_SET_USAGES,
|
||||
handle,
|
||||
static_cast<int>(descriptor->producerUsage),
|
||||
static_cast<int>(descriptor->consumerUsage));
|
||||
|
||||
uint64_t backingStore = 0;
|
||||
mModule->perform(mModule, GRALLOC1_ADAPTER_PERFORM_GET_BACKING_STORE,
|
||||
handle, &backingStore);
|
||||
int numFlexPlanes = 0;
|
||||
mModule->perform(mModule, GRALLOC1_ADAPTER_PERFORM_GET_NUM_FLEX_PLANES,
|
||||
handle, &numFlexPlanes);
|
||||
|
||||
*outBufferHandle = handle;
|
||||
auto buffer = std::make_shared<Buffer>(handle, backingStore,
|
||||
*descriptor, stride, numFlexPlanes, true);
|
||||
|
||||
std::lock_guard<std::mutex> lock(mBufferMutex);
|
||||
mBuffers.emplace(handle, std::move(buffer));
|
||||
|
||||
return GRALLOC1_ERROR_NONE;
|
||||
}
|
||||
|
||||
int32_t Gralloc1On0Adapter::allocateHook(gralloc1_device* device,
|
||||
uint32_t numDescriptors,
|
||||
const gralloc1_buffer_descriptor_t* descriptors,
|
||||
buffer_handle_t* outBuffers)
|
||||
{
|
||||
if (!outBuffers) {
|
||||
return GRALLOC1_ERROR_UNDEFINED;
|
||||
}
|
||||
|
||||
auto adapter = getAdapter(device);
|
||||
|
||||
gralloc1_error_t error = GRALLOC1_ERROR_NONE;
|
||||
uint32_t i;
|
||||
for (i = 0; i < numDescriptors; i++) {
|
||||
auto descriptor = adapter->getDescriptor(descriptors[i]);
|
||||
if (!descriptor) {
|
||||
error = GRALLOC1_ERROR_BAD_DESCRIPTOR;
|
||||
break;
|
||||
}
|
||||
|
||||
buffer_handle_t bufferHandle = nullptr;
|
||||
error = adapter->allocate(descriptors[i], descriptor, &bufferHandle);
|
||||
if (error != GRALLOC1_ERROR_NONE) {
|
||||
break;
|
||||
}
|
||||
|
||||
outBuffers[i] = bufferHandle;
|
||||
}
|
||||
|
||||
if (error == GRALLOC1_ERROR_NONE) {
|
||||
if (numDescriptors > 1) {
|
||||
error = GRALLOC1_ERROR_NOT_SHARED;
|
||||
}
|
||||
} else {
|
||||
for (uint32_t j = 0; j < i; j++) {
|
||||
adapter->release(adapter->getBuffer(outBuffers[j]));
|
||||
outBuffers[j] = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
gralloc1_error_t Gralloc1On0Adapter::retain(
|
||||
const std::shared_ptr<Buffer>& buffer)
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(mBufferMutex);
|
||||
buffer->retain();
|
||||
return GRALLOC1_ERROR_NONE;
|
||||
}
|
||||
|
||||
gralloc1_error_t Gralloc1On0Adapter::release(
|
||||
const std::shared_ptr<Buffer>& buffer)
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(mBufferMutex);
|
||||
if (!buffer->release()) {
|
||||
return GRALLOC1_ERROR_NONE;
|
||||
}
|
||||
|
||||
buffer_handle_t handle = buffer->getHandle();
|
||||
if (buffer->wasAllocated()) {
|
||||
ALOGV("Calling free(%p)", handle);
|
||||
int result = mDevice->free(mDevice, handle);
|
||||
if (result != 0) {
|
||||
ALOGE("gralloc0 free failed: %d", result);
|
||||
}
|
||||
} else {
|
||||
ALOGV("Calling unregisterBuffer(%p)", handle);
|
||||
int result = mModule->unregisterBuffer(mModule, handle);
|
||||
if (result != 0) {
|
||||
ALOGE("gralloc0 unregister failed: %d", result);
|
||||
}
|
||||
}
|
||||
|
||||
mBuffers.erase(handle);
|
||||
return GRALLOC1_ERROR_NONE;
|
||||
}
|
||||
|
||||
gralloc1_error_t Gralloc1On0Adapter::retain(buffer_handle_t bufferHandle)
|
||||
{
|
||||
ALOGV("retain(%p)", bufferHandle);
|
||||
|
||||
std::lock_guard<std::mutex> lock(mBufferMutex);
|
||||
|
||||
if (mBuffers.count(bufferHandle) != 0) {
|
||||
mBuffers[bufferHandle]->retain();
|
||||
return GRALLOC1_ERROR_NONE;
|
||||
}
|
||||
|
||||
ALOGV("Calling registerBuffer(%p)", bufferHandle);
|
||||
int result = mModule->registerBuffer(mModule, bufferHandle);
|
||||
if (result != 0) {
|
||||
ALOGE("gralloc0 register failed: %d", result);
|
||||
return GRALLOC1_ERROR_NO_RESOURCES;
|
||||
}
|
||||
|
||||
uint64_t backingStore = 0;
|
||||
mModule->perform(mModule, GRALLOC1_ADAPTER_PERFORM_GET_BACKING_STORE,
|
||||
bufferHandle, &backingStore);
|
||||
|
||||
int numFlexPlanes = 0;
|
||||
mModule->perform(mModule, GRALLOC1_ADAPTER_PERFORM_GET_NUM_FLEX_PLANES,
|
||||
bufferHandle, &numFlexPlanes);
|
||||
|
||||
int stride = 0;
|
||||
mModule->perform(mModule, GRALLOC1_ADAPTER_PERFORM_GET_STRIDE,
|
||||
bufferHandle, &stride);
|
||||
|
||||
int width = 0;
|
||||
int height = 0;
|
||||
int format = HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED;
|
||||
int producerUsage = 0;
|
||||
int consumerUsage = 0;
|
||||
mModule->perform(mModule, GRALLOC1_ADAPTER_PERFORM_GET_DIMENSIONS,
|
||||
bufferHandle, &width, &height);
|
||||
mModule->perform(mModule, GRALLOC1_ADAPTER_PERFORM_GET_FORMAT,
|
||||
bufferHandle, &format);
|
||||
mModule->perform(mModule, GRALLOC1_ADAPTER_PERFORM_GET_PRODUCER_USAGE,
|
||||
bufferHandle, &producerUsage);
|
||||
mModule->perform(mModule, GRALLOC1_ADAPTER_PERFORM_GET_CONSUMER_USAGE,
|
||||
bufferHandle, &consumerUsage);
|
||||
|
||||
Descriptor descriptor;
|
||||
descriptor.setDimensions(width, height);
|
||||
descriptor.setFormat(format);
|
||||
descriptor.setProducerUsage(
|
||||
static_cast<gralloc1_producer_usage_t>(producerUsage));
|
||||
descriptor.setConsumerUsage(
|
||||
static_cast<gralloc1_consumer_usage_t>(consumerUsage));
|
||||
|
||||
auto buffer = std::make_shared<Buffer>(bufferHandle, backingStore,
|
||||
descriptor, stride, numFlexPlanes, false);
|
||||
mBuffers.emplace(bufferHandle, std::move(buffer));
|
||||
return GRALLOC1_ERROR_NONE;
|
||||
}
|
||||
|
||||
static void syncWaitForever(int fd, const char* logname)
|
||||
{
|
||||
if (fd < 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
const int warningTimeout = 3500;
|
||||
const int error = sync_wait(fd, warningTimeout);
|
||||
if (error < 0 && errno == ETIME) {
|
||||
ALOGE("%s: fence %d didn't signal in %u ms", logname, fd,
|
||||
warningTimeout);
|
||||
sync_wait(fd, -1);
|
||||
}
|
||||
}
|
||||
|
||||
gralloc1_error_t Gralloc1On0Adapter::lock(
|
||||
const std::shared_ptr<Buffer>& buffer,
|
||||
gralloc1_producer_usage_t producerUsage,
|
||||
gralloc1_consumer_usage_t consumerUsage,
|
||||
const gralloc1_rect_t& accessRegion, void** outData,
|
||||
int acquireFence)
|
||||
{
|
||||
if (mMinorVersion >= 3) {
|
||||
int result = mModule->lockAsync(mModule, buffer->getHandle(),
|
||||
android_convertGralloc1To0Usage(producerUsage, consumerUsage),
|
||||
accessRegion.left, accessRegion.top, accessRegion.width,
|
||||
accessRegion.height, outData, acquireFence);
|
||||
if (result != 0) {
|
||||
return GRALLOC1_ERROR_UNSUPPORTED;
|
||||
}
|
||||
} else {
|
||||
syncWaitForever(acquireFence, "Gralloc1On0Adapter::lock");
|
||||
|
||||
int result = mModule->lock(mModule, buffer->getHandle(),
|
||||
android_convertGralloc1To0Usage(producerUsage, consumerUsage),
|
||||
accessRegion.left, accessRegion.top, accessRegion.width,
|
||||
accessRegion.height, outData);
|
||||
ALOGV("gralloc0 lock returned %d", result);
|
||||
if (result != 0) {
|
||||
return GRALLOC1_ERROR_UNSUPPORTED;
|
||||
} else if (acquireFence >= 0) {
|
||||
close(acquireFence);
|
||||
}
|
||||
}
|
||||
return GRALLOC1_ERROR_NONE;
|
||||
}
|
||||
|
||||
gralloc1_error_t Gralloc1On0Adapter::lockFlex(
|
||||
const std::shared_ptr<Buffer>& buffer,
|
||||
gralloc1_producer_usage_t producerUsage,
|
||||
gralloc1_consumer_usage_t consumerUsage,
|
||||
const gralloc1_rect_t& accessRegion,
|
||||
struct android_flex_layout* outFlex,
|
||||
int acquireFence)
|
||||
{
|
||||
if (mMinorVersion >= 3) {
|
||||
int result = mModule->perform(mModule,
|
||||
GRALLOC1_ADAPTER_PERFORM_LOCK_FLEX,
|
||||
buffer->getHandle(),
|
||||
static_cast<int>(producerUsage),
|
||||
static_cast<int>(consumerUsage),
|
||||
accessRegion.left,
|
||||
accessRegion.top,
|
||||
accessRegion.width,
|
||||
accessRegion.height,
|
||||
outFlex, acquireFence);
|
||||
if (result != 0) {
|
||||
return GRALLOC1_ERROR_UNSUPPORTED;
|
||||
}
|
||||
} else {
|
||||
syncWaitForever(acquireFence, "Gralloc1On0Adapter::lockFlex");
|
||||
|
||||
int result = mModule->perform(mModule,
|
||||
GRALLOC1_ADAPTER_PERFORM_LOCK_FLEX,
|
||||
buffer->getHandle(),
|
||||
static_cast<int>(producerUsage),
|
||||
static_cast<int>(consumerUsage),
|
||||
accessRegion.left,
|
||||
accessRegion.top,
|
||||
accessRegion.width,
|
||||
accessRegion.height,
|
||||
outFlex, -1);
|
||||
if (result != 0) {
|
||||
return GRALLOC1_ERROR_UNSUPPORTED;
|
||||
} else if (acquireFence >= 0) {
|
||||
close(acquireFence);
|
||||
}
|
||||
}
|
||||
|
||||
return GRALLOC1_ERROR_NONE;
|
||||
}
|
||||
|
||||
gralloc1_error_t Gralloc1On0Adapter::unlock(
|
||||
const std::shared_ptr<Buffer>& buffer,
|
||||
int* outReleaseFence)
|
||||
{
|
||||
if (mMinorVersion >= 3) {
|
||||
int fenceFd = -1;
|
||||
int result = mModule->unlockAsync(mModule, buffer->getHandle(),
|
||||
&fenceFd);
|
||||
if (result != 0) {
|
||||
close(fenceFd);
|
||||
ALOGE("gralloc0 unlockAsync failed: %d", result);
|
||||
} else {
|
||||
*outReleaseFence = fenceFd;
|
||||
}
|
||||
} else {
|
||||
int result = mModule->unlock(mModule, buffer->getHandle());
|
||||
if (result != 0) {
|
||||
ALOGE("gralloc0 unlock failed: %d", result);
|
||||
} else {
|
||||
*outReleaseFence = -1;
|
||||
}
|
||||
}
|
||||
return GRALLOC1_ERROR_NONE;
|
||||
}
|
||||
|
||||
std::shared_ptr<Gralloc1On0Adapter::Descriptor>
|
||||
Gralloc1On0Adapter::getDescriptor(gralloc1_buffer_descriptor_t descriptorId)
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(mDescriptorMutex);
|
||||
if (mDescriptors.count(descriptorId) == 0) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
return mDescriptors[descriptorId];
|
||||
}
|
||||
|
||||
std::shared_ptr<Gralloc1On0Adapter::Buffer> Gralloc1On0Adapter::getBuffer(
|
||||
buffer_handle_t bufferHandle)
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(mBufferMutex);
|
||||
if (mBuffers.count(bufferHandle) == 0) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
return mBuffers[bufferHandle];
|
||||
}
|
||||
|
||||
std::atomic<gralloc1_buffer_descriptor_t>
|
||||
Gralloc1On0Adapter::sNextBufferDescriptorId(1);
|
||||
|
||||
} // namespace hardware
|
||||
} // namespace android
|
||||
|
|
@ -0,0 +1,456 @@
|
|||
/*
|
||||
* 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 ANDROID_HARDWARE_GRALLOC_1_ON_0_ADAPTER_H
|
||||
#define ANDROID_HARDWARE_GRALLOC_1_ON_0_ADAPTER_H
|
||||
|
||||
#include <hardware/gralloc1.h>
|
||||
#include <log/log.h>
|
||||
|
||||
#include <atomic>
|
||||
#include <memory>
|
||||
#include <mutex>
|
||||
#include <string>
|
||||
#include <unordered_map>
|
||||
#include <utility>
|
||||
|
||||
struct gralloc_module_t;
|
||||
struct alloc_device_t;
|
||||
|
||||
namespace android {
|
||||
namespace hardware {
|
||||
|
||||
class Gralloc1On0Adapter : public gralloc1_device_t
|
||||
{
|
||||
public:
|
||||
Gralloc1On0Adapter(const hw_module_t* module);
|
||||
~Gralloc1On0Adapter();
|
||||
|
||||
gralloc1_device_t* getDevice() {
|
||||
return static_cast<gralloc1_device_t*>(this);
|
||||
}
|
||||
|
||||
private:
|
||||
static inline Gralloc1On0Adapter* getAdapter(gralloc1_device_t* device) {
|
||||
return static_cast<Gralloc1On0Adapter*>(device);
|
||||
}
|
||||
|
||||
static int closeHook(struct hw_device_t* device) {
|
||||
delete getAdapter(reinterpret_cast<gralloc1_device_t*>(device));
|
||||
return 0;
|
||||
}
|
||||
|
||||
// getCapabilities
|
||||
|
||||
void doGetCapabilities(uint32_t* outCount,
|
||||
int32_t* /*gralloc1_capability_t*/ outCapabilities);
|
||||
static void getCapabilitiesHook(gralloc1_device_t* device,
|
||||
uint32_t* outCount,
|
||||
int32_t* /*gralloc1_capability_t*/ outCapabilities) {
|
||||
getAdapter(device)->doGetCapabilities(outCount, outCapabilities);
|
||||
}
|
||||
|
||||
// getFunction
|
||||
|
||||
gralloc1_function_pointer_t doGetFunction(
|
||||
int32_t /*gralloc1_function_descriptor_t*/ descriptor);
|
||||
static gralloc1_function_pointer_t getFunctionHook(
|
||||
gralloc1_device_t* device,
|
||||
int32_t /*gralloc1_function_descriptor_t*/ descriptor) {
|
||||
return getAdapter(device)->doGetFunction(descriptor);
|
||||
}
|
||||
|
||||
// dump
|
||||
|
||||
void dump(uint32_t* outSize, char* outBuffer);
|
||||
static void dumpHook(gralloc1_device_t* device, uint32_t* outSize,
|
||||
char* outBuffer) {
|
||||
return getAdapter(device)->dump(outSize, outBuffer);
|
||||
}
|
||||
std::string mCachedDump;
|
||||
|
||||
// Buffer descriptor lifecycle functions
|
||||
|
||||
struct Descriptor;
|
||||
|
||||
gralloc1_error_t createDescriptor(
|
||||
gralloc1_buffer_descriptor_t* outDescriptor);
|
||||
static int32_t createDescriptorHook(gralloc1_device_t* device,
|
||||
gralloc1_buffer_descriptor_t* outDescriptor) {
|
||||
auto error = getAdapter(device)->createDescriptor(outDescriptor);
|
||||
return static_cast<int32_t>(error);
|
||||
}
|
||||
|
||||
gralloc1_error_t destroyDescriptor(gralloc1_buffer_descriptor_t descriptor);
|
||||
static int32_t destroyDescriptorHook(gralloc1_device_t* device,
|
||||
gralloc1_buffer_descriptor_t descriptor) {
|
||||
auto error = getAdapter(device)->destroyDescriptor(descriptor);
|
||||
return static_cast<int32_t>(error);
|
||||
}
|
||||
|
||||
// Buffer descriptor modification functions
|
||||
|
||||
struct Descriptor : public std::enable_shared_from_this<Descriptor> {
|
||||
Descriptor()
|
||||
: width(0),
|
||||
height(0),
|
||||
format(HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED),
|
||||
layerCount(1),
|
||||
producerUsage(GRALLOC1_PRODUCER_USAGE_NONE),
|
||||
consumerUsage(GRALLOC1_CONSUMER_USAGE_NONE) {}
|
||||
|
||||
gralloc1_error_t setDimensions(uint32_t w, uint32_t h) {
|
||||
width = w;
|
||||
height = h;
|
||||
return GRALLOC1_ERROR_NONE;
|
||||
}
|
||||
|
||||
gralloc1_error_t setFormat(int32_t f) {
|
||||
format = f;
|
||||
return GRALLOC1_ERROR_NONE;
|
||||
}
|
||||
|
||||
gralloc1_error_t setLayerCount(uint32_t lc) {
|
||||
layerCount = lc;
|
||||
return GRALLOC1_ERROR_NONE;
|
||||
}
|
||||
|
||||
gralloc1_error_t setProducerUsage(gralloc1_producer_usage_t usage) {
|
||||
producerUsage = usage;
|
||||
return GRALLOC1_ERROR_NONE;
|
||||
}
|
||||
|
||||
gralloc1_error_t setConsumerUsage(gralloc1_consumer_usage_t usage) {
|
||||
consumerUsage = usage;
|
||||
return GRALLOC1_ERROR_NONE;
|
||||
}
|
||||
|
||||
uint32_t width;
|
||||
uint32_t height;
|
||||
int32_t format;
|
||||
uint32_t layerCount;
|
||||
gralloc1_producer_usage_t producerUsage;
|
||||
gralloc1_consumer_usage_t consumerUsage;
|
||||
};
|
||||
|
||||
template <typename ...Args>
|
||||
static int32_t callDescriptorFunction(gralloc1_device_t* device,
|
||||
gralloc1_buffer_descriptor_t descriptorId,
|
||||
gralloc1_error_t (Descriptor::*member)(Args...), Args... args) {
|
||||
auto descriptor = getAdapter(device)->getDescriptor(descriptorId);
|
||||
if (!descriptor) {
|
||||
return static_cast<int32_t>(GRALLOC1_ERROR_BAD_DESCRIPTOR);
|
||||
}
|
||||
auto error = ((*descriptor).*member)(std::forward<Args>(args)...);
|
||||
return static_cast<int32_t>(error);
|
||||
}
|
||||
|
||||
static int32_t setConsumerUsageHook(gralloc1_device_t* device,
|
||||
gralloc1_buffer_descriptor_t descriptorId, uint64_t intUsage) {
|
||||
auto usage = static_cast<gralloc1_consumer_usage_t>(intUsage);
|
||||
return callDescriptorFunction(device, descriptorId,
|
||||
&Descriptor::setConsumerUsage, usage);
|
||||
}
|
||||
|
||||
static int32_t setDimensionsHook(gralloc1_device_t* device,
|
||||
gralloc1_buffer_descriptor_t descriptorId, uint32_t width,
|
||||
uint32_t height) {
|
||||
return callDescriptorFunction(device, descriptorId,
|
||||
&Descriptor::setDimensions, width, height);
|
||||
}
|
||||
|
||||
static int32_t setFormatHook(gralloc1_device_t* device,
|
||||
gralloc1_buffer_descriptor_t descriptorId, int32_t format) {
|
||||
return callDescriptorFunction(device, descriptorId,
|
||||
&Descriptor::setFormat, format);
|
||||
}
|
||||
|
||||
static int32_t setLayerCountHook(gralloc1_device_t* device,
|
||||
gralloc1_buffer_descriptor_t descriptorId, uint32_t layerCount) {
|
||||
return callDescriptorFunction(device, descriptorId,
|
||||
&Descriptor::setLayerCount, layerCount);
|
||||
}
|
||||
|
||||
static int32_t setProducerUsageHook(gralloc1_device_t* device,
|
||||
gralloc1_buffer_descriptor_t descriptorId, uint64_t intUsage) {
|
||||
auto usage = static_cast<gralloc1_producer_usage_t>(intUsage);
|
||||
return callDescriptorFunction(device, descriptorId,
|
||||
&Descriptor::setProducerUsage, usage);
|
||||
}
|
||||
|
||||
// Buffer handle query functions
|
||||
class Buffer {
|
||||
public:
|
||||
Buffer(buffer_handle_t handle, gralloc1_backing_store_t store,
|
||||
const Descriptor& descriptor, uint32_t stride,
|
||||
uint32_t numFlexPlanes, bool wasAllocated);
|
||||
|
||||
buffer_handle_t getHandle() const { return mHandle; }
|
||||
|
||||
void retain() { ++mReferenceCount; }
|
||||
|
||||
// Returns true if the reference count has dropped to 0, indicating that
|
||||
// the buffer needs to be released
|
||||
bool release() { return --mReferenceCount == 0; }
|
||||
|
||||
bool wasAllocated() const { return mWasAllocated; }
|
||||
|
||||
gralloc1_error_t getBackingStore(
|
||||
gralloc1_backing_store_t* outStore) const {
|
||||
*outStore = mStore;
|
||||
return GRALLOC1_ERROR_NONE;
|
||||
}
|
||||
|
||||
gralloc1_error_t getConsumerUsage(
|
||||
gralloc1_consumer_usage_t* outUsage) const {
|
||||
*outUsage = mDescriptor.consumerUsage;
|
||||
return GRALLOC1_ERROR_NONE;
|
||||
}
|
||||
|
||||
gralloc1_error_t getDimensions(uint32_t* outWidth,
|
||||
uint32_t* outHeight) const {
|
||||
*outWidth = mDescriptor.width;
|
||||
*outHeight = mDescriptor.height;
|
||||
return GRALLOC1_ERROR_NONE;
|
||||
}
|
||||
|
||||
gralloc1_error_t getFormat(int32_t* outFormat) const {
|
||||
*outFormat = mDescriptor.format;
|
||||
return GRALLOC1_ERROR_NONE;
|
||||
}
|
||||
|
||||
gralloc1_error_t getLayerCount(uint32_t* outLayerCount) const {
|
||||
*outLayerCount = mDescriptor.layerCount;
|
||||
return GRALLOC1_ERROR_NONE;
|
||||
}
|
||||
|
||||
gralloc1_error_t getNumFlexPlanes(uint32_t* outNumPlanes) const {
|
||||
*outNumPlanes = 4;
|
||||
return GRALLOC1_ERROR_NONE;
|
||||
}
|
||||
|
||||
gralloc1_error_t getProducerUsage(
|
||||
gralloc1_producer_usage_t* outUsage) const {
|
||||
*outUsage = mDescriptor.producerUsage;
|
||||
return GRALLOC1_ERROR_NONE;
|
||||
}
|
||||
|
||||
gralloc1_error_t getStride(uint32_t* outStride) const {
|
||||
*outStride = mStride;
|
||||
return GRALLOC1_ERROR_NONE;
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
const buffer_handle_t mHandle;
|
||||
size_t mReferenceCount;
|
||||
|
||||
const gralloc1_backing_store_t mStore;
|
||||
const Descriptor mDescriptor;
|
||||
const uint32_t mStride;
|
||||
|
||||
// Whether this buffer allocated in this process (as opposed to just
|
||||
// being retained here), which determines whether to free or unregister
|
||||
// the buffer when this Buffer is released
|
||||
const bool mWasAllocated;
|
||||
};
|
||||
|
||||
template <typename ...Args>
|
||||
static int32_t callBufferFunction(gralloc1_device_t* device,
|
||||
buffer_handle_t bufferHandle,
|
||||
gralloc1_error_t (Buffer::*member)(Args...) const, Args... args) {
|
||||
auto buffer = getAdapter(device)->getBuffer(bufferHandle);
|
||||
if (!buffer) {
|
||||
return static_cast<int32_t>(GRALLOC1_ERROR_BAD_HANDLE);
|
||||
}
|
||||
auto error = ((*buffer).*member)(std::forward<Args>(args)...);
|
||||
return static_cast<int32_t>(error);
|
||||
}
|
||||
|
||||
template <typename MF, MF memFunc, typename ...Args>
|
||||
static int32_t bufferHook(gralloc1_device_t* device,
|
||||
buffer_handle_t bufferHandle, Args... args) {
|
||||
return Gralloc1On0Adapter::callBufferFunction(device, bufferHandle,
|
||||
memFunc, std::forward<Args>(args)...);
|
||||
}
|
||||
|
||||
static int32_t getConsumerUsageHook(gralloc1_device_t* device,
|
||||
buffer_handle_t bufferHandle, uint64_t* outUsage) {
|
||||
auto usage = GRALLOC1_CONSUMER_USAGE_NONE;
|
||||
auto error = callBufferFunction(device, bufferHandle,
|
||||
&Buffer::getConsumerUsage, &usage);
|
||||
if (error == GRALLOC1_ERROR_NONE) {
|
||||
*outUsage = static_cast<uint64_t>(usage);
|
||||
}
|
||||
return error;
|
||||
}
|
||||
|
||||
static int32_t getProducerUsageHook(gralloc1_device_t* device,
|
||||
buffer_handle_t bufferHandle, uint64_t* outUsage) {
|
||||
auto usage = GRALLOC1_PRODUCER_USAGE_NONE;
|
||||
auto error = callBufferFunction(device, bufferHandle,
|
||||
&Buffer::getProducerUsage, &usage);
|
||||
if (error == GRALLOC1_ERROR_NONE) {
|
||||
*outUsage = static_cast<uint64_t>(usage);
|
||||
}
|
||||
return error;
|
||||
}
|
||||
|
||||
// Buffer management functions
|
||||
|
||||
gralloc1_error_t allocate(
|
||||
gralloc1_buffer_descriptor_t id,
|
||||
const std::shared_ptr<Descriptor>& descriptor,
|
||||
buffer_handle_t* outBufferHandle);
|
||||
static int32_t allocateHook(gralloc1_device* device,
|
||||
uint32_t numDescriptors,
|
||||
const gralloc1_buffer_descriptor_t* descriptors,
|
||||
buffer_handle_t* outBuffers);
|
||||
|
||||
gralloc1_error_t retain(const std::shared_ptr<Buffer>& buffer);
|
||||
gralloc1_error_t retain(buffer_handle_t bufferHandle);
|
||||
static int32_t retainHook(gralloc1_device_t* device,
|
||||
buffer_handle_t bufferHandle)
|
||||
{
|
||||
auto adapter = getAdapter(device);
|
||||
return adapter->retain(bufferHandle);
|
||||
}
|
||||
|
||||
gralloc1_error_t release(const std::shared_ptr<Buffer>& buffer);
|
||||
static int32_t releaseHook(gralloc1_device_t* device,
|
||||
buffer_handle_t bufferHandle) {
|
||||
auto adapter = getAdapter(device);
|
||||
|
||||
auto buffer = adapter->getBuffer(bufferHandle);
|
||||
if (!buffer) {
|
||||
return static_cast<int32_t>(GRALLOC1_ERROR_BAD_HANDLE);
|
||||
}
|
||||
|
||||
auto error = adapter->release(buffer);
|
||||
return static_cast<int32_t>(error);
|
||||
}
|
||||
|
||||
// Buffer access functions
|
||||
|
||||
gralloc1_error_t lock(const std::shared_ptr<Buffer>& buffer,
|
||||
gralloc1_producer_usage_t producerUsage,
|
||||
gralloc1_consumer_usage_t consumerUsage,
|
||||
const gralloc1_rect_t& accessRegion, void** outData,
|
||||
int acquireFence);
|
||||
gralloc1_error_t lockFlex(const std::shared_ptr<Buffer>& buffer,
|
||||
gralloc1_producer_usage_t producerUsage,
|
||||
gralloc1_consumer_usage_t consumerUsage,
|
||||
const gralloc1_rect_t& accessRegion,
|
||||
struct android_flex_layout* outFlex,
|
||||
int acquireFence);
|
||||
|
||||
template <typename OUT, gralloc1_error_t (Gralloc1On0Adapter::*member)(
|
||||
const std::shared_ptr<Buffer>&, gralloc1_producer_usage_t,
|
||||
gralloc1_consumer_usage_t, const gralloc1_rect_t&, OUT*,
|
||||
int)>
|
||||
static int32_t lockHook(gralloc1_device_t* device,
|
||||
buffer_handle_t bufferHandle,
|
||||
uint64_t /*gralloc1_producer_usage_t*/ uintProducerUsage,
|
||||
uint64_t /*gralloc1_consumer_usage_t*/ uintConsumerUsage,
|
||||
const gralloc1_rect_t* accessRegion, OUT* outData,
|
||||
int32_t acquireFenceFd) {
|
||||
auto adapter = getAdapter(device);
|
||||
|
||||
// Exactly one of producer and consumer usage must be *_USAGE_NONE,
|
||||
// but we can't check this until the upper levels of the framework
|
||||
// correctly distinguish between producer and consumer usage
|
||||
/*
|
||||
bool hasProducerUsage =
|
||||
uintProducerUsage != GRALLOC1_PRODUCER_USAGE_NONE;
|
||||
bool hasConsumerUsage =
|
||||
uintConsumerUsage != GRALLOC1_CONSUMER_USAGE_NONE;
|
||||
if (hasProducerUsage && hasConsumerUsage ||
|
||||
!hasProducerUsage && !hasConsumerUsage) {
|
||||
return static_cast<int32_t>(GRALLOC1_ERROR_BAD_VALUE);
|
||||
}
|
||||
*/
|
||||
|
||||
auto producerUsage =
|
||||
static_cast<gralloc1_producer_usage_t>(uintProducerUsage);
|
||||
auto consumerUsage =
|
||||
static_cast<gralloc1_consumer_usage_t>(uintConsumerUsage);
|
||||
|
||||
if (!outData) {
|
||||
const auto producerCpuUsage = GRALLOC1_PRODUCER_USAGE_CPU_READ |
|
||||
GRALLOC1_PRODUCER_USAGE_CPU_WRITE;
|
||||
if ((producerUsage & producerCpuUsage) != 0) {
|
||||
return static_cast<int32_t>(GRALLOC1_ERROR_BAD_VALUE);
|
||||
}
|
||||
if ((consumerUsage & GRALLOC1_CONSUMER_USAGE_CPU_READ) != 0) {
|
||||
return static_cast<int32_t>(GRALLOC1_ERROR_BAD_VALUE);
|
||||
}
|
||||
}
|
||||
|
||||
auto buffer = adapter->getBuffer(bufferHandle);
|
||||
if (!buffer) {
|
||||
return static_cast<int32_t>(GRALLOC1_ERROR_BAD_HANDLE);
|
||||
}
|
||||
|
||||
if (!accessRegion) {
|
||||
ALOGE("accessRegion is null");
|
||||
return static_cast<int32_t>(GRALLOC1_ERROR_BAD_VALUE);
|
||||
}
|
||||
|
||||
auto error = ((*adapter).*member)(buffer, producerUsage, consumerUsage,
|
||||
*accessRegion, outData, acquireFenceFd);
|
||||
return static_cast<int32_t>(error);
|
||||
}
|
||||
|
||||
gralloc1_error_t unlock(const std::shared_ptr<Buffer>& buffer,
|
||||
int* outReleaseFence);
|
||||
static int32_t unlockHook(gralloc1_device_t* device,
|
||||
buffer_handle_t bufferHandle, int32_t* outReleaseFenceFd) {
|
||||
auto adapter = getAdapter(device);
|
||||
|
||||
auto buffer = adapter->getBuffer(bufferHandle);
|
||||
if (!buffer) {
|
||||
return static_cast<int32_t>(GRALLOC1_ERROR_BAD_HANDLE);
|
||||
}
|
||||
|
||||
int releaseFence = -1;
|
||||
auto error = adapter->unlock(buffer, &releaseFence);
|
||||
if (error == GRALLOC1_ERROR_NONE) {
|
||||
*outReleaseFenceFd = releaseFence;
|
||||
}
|
||||
return static_cast<int32_t>(error);
|
||||
}
|
||||
|
||||
// Adapter internals
|
||||
const gralloc_module_t* mModule;
|
||||
uint8_t mMinorVersion;
|
||||
alloc_device_t* mDevice;
|
||||
|
||||
std::shared_ptr<Descriptor> getDescriptor(
|
||||
gralloc1_buffer_descriptor_t descriptorId);
|
||||
std::shared_ptr<Buffer> getBuffer(buffer_handle_t bufferHandle);
|
||||
|
||||
static std::atomic<gralloc1_buffer_descriptor_t> sNextBufferDescriptorId;
|
||||
std::mutex mDescriptorMutex;
|
||||
std::unordered_map<gralloc1_buffer_descriptor_t,
|
||||
std::shared_ptr<Descriptor>> mDescriptors;
|
||||
std::mutex mBufferMutex;
|
||||
std::unordered_map<buffer_handle_t, std::shared_ptr<Buffer>> mBuffers;
|
||||
};
|
||||
|
||||
} // namespace hardware
|
||||
} // namespace android
|
||||
|
||||
#endif // ANDROID_HARDWARE_GRALLOC_1_ON_0_ADAPTER_H
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#include "Gralloc1On0Adapter.h"
|
||||
#include "gralloc1-adapter.h"
|
||||
|
||||
int gralloc1_adapter_device_open(const struct hw_module_t* module,
|
||||
const char* id, struct hw_device_t** device)
|
||||
{
|
||||
if (strcmp(id, GRALLOC_HARDWARE_MODULE_ID) != 0) {
|
||||
ALOGE("unknown gralloc1 device id: %s", id);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
auto adapter_device = new android::hardware::Gralloc1On0Adapter(module);
|
||||
*device = &adapter_device->common;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,89 @@
|
|||
/*
|
||||
* 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 ANDROID_HARDWARE_GRALLOC1_ADAPTER_H
|
||||
#define ANDROID_HARDWARE_GRALLOC1_ADAPTER_H
|
||||
|
||||
#include <hardware/hardware.h>
|
||||
|
||||
__BEGIN_DECLS
|
||||
|
||||
#define GRALLOC1_ADAPTER_MODULE_API_VERSION_1_0 \
|
||||
HARDWARE_MODULE_API_VERSION(1, 0)
|
||||
|
||||
enum {
|
||||
GRALLOC1_ADAPTER_PERFORM_FIRST = 10000,
|
||||
|
||||
// void getRealModuleApiVersionMinor(..., int* outMinorVersion);
|
||||
GRALLOC1_ADAPTER_PERFORM_GET_REAL_MODULE_API_VERSION_MINOR =
|
||||
GRALLOC1_ADAPTER_PERFORM_FIRST,
|
||||
|
||||
// void setUsages(..., buffer_handle_t buffer,
|
||||
// int producerUsage,
|
||||
// int consumerUsage);
|
||||
GRALLOC1_ADAPTER_PERFORM_SET_USAGES =
|
||||
GRALLOC1_ADAPTER_PERFORM_FIRST + 1,
|
||||
|
||||
// void getDimensions(..., buffer_handle_t buffer,
|
||||
// int* outWidth,
|
||||
// int* outHeight);
|
||||
GRALLOC1_ADAPTER_PERFORM_GET_DIMENSIONS =
|
||||
GRALLOC1_ADAPTER_PERFORM_FIRST + 2,
|
||||
|
||||
// void getFormat(..., buffer_handle_t buffer, int* outFormat);
|
||||
GRALLOC1_ADAPTER_PERFORM_GET_FORMAT =
|
||||
GRALLOC1_ADAPTER_PERFORM_FIRST + 3,
|
||||
|
||||
// void getProducerUsage(..., buffer_handle_t buffer, int* outUsage);
|
||||
GRALLOC1_ADAPTER_PERFORM_GET_PRODUCER_USAGE =
|
||||
GRALLOC1_ADAPTER_PERFORM_FIRST + 4,
|
||||
|
||||
// void getConsumerUsage(..., buffer_handle_t buffer, int* outUsage);
|
||||
GRALLOC1_ADAPTER_PERFORM_GET_CONSUMER_USAGE =
|
||||
GRALLOC1_ADAPTER_PERFORM_FIRST + 5,
|
||||
|
||||
// void getBackingStore(..., buffer_handle_t buffer,
|
||||
// uint64_t* outBackingStore);
|
||||
GRALLOC1_ADAPTER_PERFORM_GET_BACKING_STORE =
|
||||
GRALLOC1_ADAPTER_PERFORM_FIRST + 6,
|
||||
|
||||
// void getNumFlexPlanes(..., buffer_handle_t buffer,
|
||||
// int* outNumFlexPlanes);
|
||||
GRALLOC1_ADAPTER_PERFORM_GET_NUM_FLEX_PLANES =
|
||||
GRALLOC1_ADAPTER_PERFORM_FIRST + 7,
|
||||
|
||||
// void getStride(..., buffer_handle_t buffer, int* outStride);
|
||||
GRALLOC1_ADAPTER_PERFORM_GET_STRIDE =
|
||||
GRALLOC1_ADAPTER_PERFORM_FIRST + 8,
|
||||
|
||||
// void lockFlex(..., buffer_handle_t buffer,
|
||||
// int producerUsage,
|
||||
// int consumerUsage,
|
||||
// int left,
|
||||
// int top,
|
||||
// int width,
|
||||
// int height,
|
||||
// android_flex_layout* outLayout,
|
||||
// int acquireFence);
|
||||
GRALLOC1_ADAPTER_PERFORM_LOCK_FLEX =
|
||||
GRALLOC1_ADAPTER_PERFORM_FIRST + 9,
|
||||
};
|
||||
|
||||
int gralloc1_adapter_device_open(const struct hw_module_t* module,
|
||||
const char* id, struct hw_device_t** device);
|
||||
|
||||
__END_DECLS
|
||||
|
||||
#endif /* ANDROID_HARDWARE_GRALLOC1_ADAPTER_H */
|
||||
Loading…
Reference in New Issue