145 lines
4.0 KiB
C++
145 lines
4.0 KiB
C++
/*
|
|
* 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
|