You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
507 lines
17 KiB
507 lines
17 KiB
/*
|
|
* Copyright 2019 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
//#define LOG_NDEBUG 0
|
|
#define LOG_TAG "H2BGraphicBufferProducer@2.0"
|
|
|
|
#include <android-base/logging.h>
|
|
|
|
#include <android/hardware/graphics/common/1.2/types.h>
|
|
#include <gui/bufferqueue/2.0/B2HProducerListener.h>
|
|
#include <gui/bufferqueue/2.0/H2BGraphicBufferProducer.h>
|
|
#include <gui/bufferqueue/2.0/types.h>
|
|
#include <ui/GraphicBuffer.h>
|
|
#include <ui/Rect.h>
|
|
#include <ui/Region.h>
|
|
#include <vndk/hardware_buffer.h>
|
|
|
|
namespace android {
|
|
namespace hardware {
|
|
namespace graphics {
|
|
namespace bufferqueue {
|
|
namespace V2_0 {
|
|
namespace utils {
|
|
|
|
namespace /* unnamed */ {
|
|
|
|
using BQueueBufferInput = ::android::
|
|
IGraphicBufferProducer::QueueBufferInput;
|
|
using HQueueBufferInput = ::android::hardware::graphics::bufferqueue::V2_0::
|
|
IGraphicBufferProducer::QueueBufferInput;
|
|
using BQueueBufferOutput = ::android::
|
|
IGraphicBufferProducer::QueueBufferOutput;
|
|
using HQueueBufferOutput = ::android::hardware::graphics::bufferqueue::V2_0::
|
|
IGraphicBufferProducer::QueueBufferOutput;
|
|
|
|
using ::android::hardware::graphics::bufferqueue::V2_0::utils::b2h;
|
|
using ::android::hardware::graphics::bufferqueue::V2_0::utils::h2b;
|
|
|
|
bool b2h(BQueueBufferInput const& from, HQueueBufferInput* to,
|
|
HFenceWrapper* hFenceWrapper) {
|
|
to->timestamp = from.timestamp;
|
|
to->isAutoTimestamp = static_cast<bool>(from.isAutoTimestamp);
|
|
to->dataSpace = static_cast<int32_t>(from.dataSpace);
|
|
to->transform = static_cast<int32_t>(from.transform);
|
|
to->stickyTransform = static_cast<int32_t>(from.stickyTransform);
|
|
if (!b2h(from.crop, &to->crop) ||
|
|
!b2h(from.surfaceDamage, &to->surfaceDamage) ||
|
|
!b2h(from.fence, hFenceWrapper)) {
|
|
return false;
|
|
}
|
|
to->fence = hFenceWrapper->getHandle();
|
|
return true;
|
|
}
|
|
|
|
bool h2b(HQueueBufferOutput const& from, BQueueBufferOutput* to) {
|
|
to->width = from.width;
|
|
to->height = from.height;
|
|
to->transformHint = static_cast<uint32_t>(from.transformHint);
|
|
to->numPendingBuffers = from.numPendingBuffers;
|
|
to->nextFrameNumber = from.nextFrameNumber;
|
|
to->bufferReplaced = from.bufferReplaced;
|
|
return true;
|
|
}
|
|
|
|
} // unnamed namespace
|
|
|
|
// H2BGraphicBufferProducer
|
|
// ========================
|
|
|
|
status_t H2BGraphicBufferProducer::requestBuffer(int slot,
|
|
sp<GraphicBuffer>* bBuffer) {
|
|
bool converted{};
|
|
status_t bStatus{};
|
|
Return<void> transResult = mBase->requestBuffer(slot,
|
|
[&converted, &bStatus, bBuffer](
|
|
HStatus hStatus,
|
|
HardwareBuffer const& hBuffer,
|
|
uint32_t generationNumber) {
|
|
converted =
|
|
h2b(hStatus, &bStatus) &&
|
|
h2b(hBuffer, bBuffer);
|
|
if (*bBuffer) {
|
|
(*bBuffer)->setGenerationNumber(generationNumber);
|
|
}
|
|
});
|
|
if (!transResult.isOk()) {
|
|
LOG(ERROR) << "requestBuffer: transaction failed.";
|
|
return FAILED_TRANSACTION;
|
|
}
|
|
if (!converted) {
|
|
LOG(ERROR) << "requestBuffer: corrupted transaction.";
|
|
return FAILED_TRANSACTION;
|
|
}
|
|
return bStatus;
|
|
}
|
|
|
|
status_t H2BGraphicBufferProducer::setMaxDequeuedBufferCount(
|
|
int maxDequeuedBuffers) {
|
|
status_t bStatus{};
|
|
Return<HStatus> transResult = mBase->setMaxDequeuedBufferCount(
|
|
static_cast<int32_t>(maxDequeuedBuffers));
|
|
if (!transResult.isOk()) {
|
|
LOG(ERROR) << "setMaxDequeuedBufferCount: transaction failed.";
|
|
return FAILED_TRANSACTION;
|
|
}
|
|
if (!h2b(static_cast<HStatus>(transResult), &bStatus)) {
|
|
LOG(ERROR) << "setMaxDequeuedBufferCount: corrupted transaction.";
|
|
return FAILED_TRANSACTION;
|
|
}
|
|
return bStatus;
|
|
}
|
|
|
|
status_t H2BGraphicBufferProducer::setAsyncMode(bool async) {
|
|
status_t bStatus{};
|
|
Return<HStatus> transResult = mBase->setAsyncMode(async);
|
|
if (!transResult.isOk()) {
|
|
LOG(ERROR) << "setAsyncMode: transaction failed.";
|
|
return FAILED_TRANSACTION;
|
|
}
|
|
if (!h2b(static_cast<HStatus>(transResult), &bStatus)) {
|
|
LOG(ERROR) << "setAsyncMode: corrupted transaction.";
|
|
return FAILED_TRANSACTION;
|
|
}
|
|
return bStatus;
|
|
}
|
|
|
|
status_t H2BGraphicBufferProducer::dequeueBuffer(
|
|
int* slot, sp<BFence>* fence,
|
|
uint32_t w, uint32_t h,
|
|
PixelFormat format, uint64_t usage,
|
|
uint64_t* outBufferAge, FrameEventHistoryDelta* /* outTimestamps */) {
|
|
|
|
using HInput = HGraphicBufferProducer::DequeueBufferInput;
|
|
HInput input{w, h, static_cast<uint32_t>(format), usage};
|
|
|
|
using HOutput = HGraphicBufferProducer::DequeueBufferOutput;
|
|
bool converted{};
|
|
status_t bStatus{};
|
|
Return<void> transResult = mBase->dequeueBuffer(input,
|
|
[&converted, &bStatus, slot, fence, outBufferAge] (
|
|
HStatus hStatus, int32_t hSlot, HOutput const& hOutput) {
|
|
converted = h2b(hStatus, &bStatus);
|
|
if (!converted || bStatus != OK) {
|
|
return;
|
|
}
|
|
*slot = hSlot;
|
|
*outBufferAge = hOutput.bufferAge;
|
|
bStatus =
|
|
(hOutput.bufferNeedsReallocation ?
|
|
BUFFER_NEEDS_REALLOCATION : 0) |
|
|
(hOutput.releaseAllBuffers ?
|
|
RELEASE_ALL_BUFFERS : 0);
|
|
converted = h2b(hOutput.fence, fence);
|
|
});
|
|
if (!transResult.isOk()) {
|
|
LOG(ERROR) << "dequeueBuffer: transaction failed.";
|
|
return FAILED_TRANSACTION;
|
|
}
|
|
if (!converted) {
|
|
LOG(ERROR) << "dequeueBuffer: corrupted transaction.";
|
|
return FAILED_TRANSACTION;
|
|
}
|
|
return bStatus;
|
|
}
|
|
|
|
status_t H2BGraphicBufferProducer::detachBuffer(int slot) {
|
|
status_t bStatus{};
|
|
Return<HStatus> transResult = mBase->detachBuffer(
|
|
static_cast<int32_t>(slot));
|
|
if (!transResult.isOk()) {
|
|
LOG(ERROR) << "detachBuffer: transaction failed.";
|
|
return FAILED_TRANSACTION;
|
|
}
|
|
if (!h2b(static_cast<HStatus>(transResult), &bStatus)) {
|
|
LOG(ERROR) << "detachBuffer: corrupted transaction.";
|
|
return FAILED_TRANSACTION;
|
|
}
|
|
return bStatus;
|
|
}
|
|
|
|
status_t H2BGraphicBufferProducer::detachNextBuffer(
|
|
sp<GraphicBuffer>* outBuffer, sp<BFence>* outFence) {
|
|
bool converted{};
|
|
status_t bStatus{};
|
|
Return<void> transResult = mBase->detachNextBuffer(
|
|
[&converted, &bStatus, outBuffer, outFence] (
|
|
HStatus hStatus,
|
|
HardwareBuffer const& hBuffer,
|
|
hidl_handle const& hFence) {
|
|
converted = h2b(hStatus, &bStatus) &&
|
|
h2b(hBuffer, outBuffer) &&
|
|
h2b(hFence, outFence);
|
|
});
|
|
if (!transResult.isOk()) {
|
|
LOG(ERROR) << "detachNextBuffer: transaction failed.";
|
|
return FAILED_TRANSACTION;
|
|
}
|
|
if (!converted) {
|
|
LOG(ERROR) << "detachNextBuffer: corrupted transaction.";
|
|
return FAILED_TRANSACTION;
|
|
}
|
|
return bStatus;
|
|
}
|
|
|
|
status_t H2BGraphicBufferProducer::attachBuffer(
|
|
int* outSlot, sp<GraphicBuffer> const& buffer) {
|
|
HardwareBuffer hBuffer{};
|
|
uint32_t hGenerationNumber{};
|
|
if (!b2h(buffer, &hBuffer, &hGenerationNumber)) {
|
|
LOG(ERROR) << "attachBuffer: invalid input buffer.";
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
bool converted{};
|
|
status_t bStatus{};
|
|
Return<void> transResult = mBase->attachBuffer(hBuffer, hGenerationNumber,
|
|
[&converted, &bStatus, outSlot](
|
|
HStatus hStatus, int32_t hSlot, bool releaseAllBuffers) {
|
|
converted = h2b(hStatus, &bStatus);
|
|
*outSlot = static_cast<int>(hSlot);
|
|
if (converted && releaseAllBuffers && bStatus == OK) {
|
|
bStatus = IGraphicBufferProducer::RELEASE_ALL_BUFFERS;
|
|
}
|
|
});
|
|
if (!transResult.isOk()) {
|
|
LOG(ERROR) << "attachBuffer: transaction failed.";
|
|
return FAILED_TRANSACTION;
|
|
}
|
|
if (!converted) {
|
|
LOG(ERROR) << "attachBuffer: corrupted transaction.";
|
|
return FAILED_TRANSACTION;
|
|
}
|
|
return bStatus;
|
|
}
|
|
|
|
status_t H2BGraphicBufferProducer::queueBuffer(
|
|
int slot,
|
|
QueueBufferInput const& input,
|
|
QueueBufferOutput* output) {
|
|
HQueueBufferInput hInput{};
|
|
HFenceWrapper hFenceWrapper;
|
|
if (!b2h(input, &hInput, &hFenceWrapper)) {
|
|
LOG(ERROR) << "queueBuffer: corrupted input.";
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
|
|
bool converted{};
|
|
status_t bStatus{};
|
|
Return<void> transResult = mBase->queueBuffer(
|
|
static_cast<int32_t>(slot),
|
|
hInput,
|
|
[&converted, &bStatus, output](
|
|
HStatus hStatus,
|
|
HQueueBufferOutput const& hOutput) {
|
|
converted = h2b(hStatus, &bStatus) && h2b(hOutput, output);
|
|
});
|
|
|
|
if (!transResult.isOk()) {
|
|
LOG(ERROR) << "queueBuffer: transaction failed.";
|
|
return FAILED_TRANSACTION;
|
|
}
|
|
if (!converted) {
|
|
LOG(ERROR) << "queueBuffer: corrupted transaction.";
|
|
return FAILED_TRANSACTION;
|
|
}
|
|
return bStatus;
|
|
}
|
|
|
|
status_t H2BGraphicBufferProducer::cancelBuffer(int slot, sp<BFence> const& fence) {
|
|
HFenceWrapper hFenceWrapper;
|
|
if (!b2h(fence, &hFenceWrapper)) {
|
|
LOG(ERROR) << "cancelBuffer: corrupted input fence.";
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
status_t bStatus{};
|
|
Return<HStatus> transResult = mBase->cancelBuffer(
|
|
static_cast<int32_t>(slot),
|
|
hFenceWrapper.getHandle());
|
|
if (!transResult.isOk()) {
|
|
LOG(ERROR) << "cancelBuffer: transaction failed.";
|
|
return FAILED_TRANSACTION;
|
|
}
|
|
if (!h2b(static_cast<HStatus>(transResult), &bStatus)) {
|
|
LOG(ERROR) << "cancelBuffer: corrupted transaction.";
|
|
return FAILED_TRANSACTION;
|
|
}
|
|
return bStatus;
|
|
}
|
|
|
|
int H2BGraphicBufferProducer::query(int what, int* value) {
|
|
int result{};
|
|
Return<void> transResult = mBase->query(
|
|
static_cast<int32_t>(what),
|
|
[&result, value](int32_t r, int32_t v) {
|
|
result = static_cast<int>(r);
|
|
*value = static_cast<int>(v);
|
|
});
|
|
if (!transResult.isOk()) {
|
|
LOG(ERROR) << "query: transaction failed.";
|
|
return FAILED_TRANSACTION;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
status_t H2BGraphicBufferProducer::connect(
|
|
sp<IProducerListener> const& listener, int api,
|
|
bool producerControlledByApp, QueueBufferOutput* output) {
|
|
HConnectionType hConnectionType;
|
|
if (!b2h(api, &hConnectionType)) {
|
|
LOG(ERROR) << "connect: corrupted input connection type.";
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
sp<HProducerListener> hListener = nullptr;
|
|
if (listener && listener->needsReleaseNotify()) {
|
|
hListener = new B2HProducerListener(listener);
|
|
if (!hListener) {
|
|
LOG(ERROR) << "connect: failed to wrap listener.";
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
}
|
|
|
|
bool converted{};
|
|
status_t bStatus{};
|
|
Return<void> transResult = mBase->connect(
|
|
hListener,
|
|
hConnectionType,
|
|
producerControlledByApp,
|
|
[&converted, &bStatus, output](
|
|
HStatus hStatus,
|
|
HQueueBufferOutput const& hOutput) {
|
|
converted = h2b(hStatus, &bStatus) && h2b(hOutput, output);
|
|
});
|
|
if (!transResult.isOk()) {
|
|
LOG(ERROR) << "connect: transaction failed.";
|
|
return FAILED_TRANSACTION;
|
|
}
|
|
if (!converted) {
|
|
LOG(ERROR) << "connect: corrupted transaction.";
|
|
return FAILED_TRANSACTION;
|
|
}
|
|
return bStatus;
|
|
|
|
}
|
|
|
|
status_t H2BGraphicBufferProducer::disconnect(int api, DisconnectMode mode) {
|
|
HConnectionType hConnectionType;
|
|
if (mode == DisconnectMode::AllLocal) {
|
|
hConnectionType = HConnectionType::CURRENTLY_CONNECTED;
|
|
} else if (!b2h(api, &hConnectionType)) {
|
|
LOG(ERROR) << "connect: corrupted input connection type.";
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
|
|
status_t bStatus{};
|
|
Return<HStatus> transResult = mBase->disconnect(hConnectionType);
|
|
if (!transResult.isOk()) {
|
|
LOG(ERROR) << "disconnect: transaction failed.";
|
|
return FAILED_TRANSACTION;
|
|
}
|
|
if (!h2b(static_cast<HStatus>(transResult), &bStatus)) {
|
|
LOG(ERROR) << "disconnect: corrupted transaction.";
|
|
return FAILED_TRANSACTION;
|
|
}
|
|
return bStatus;
|
|
}
|
|
|
|
status_t H2BGraphicBufferProducer::setSidebandStream(
|
|
sp<NativeHandle> const& stream) {
|
|
if (stream) {
|
|
LOG(INFO) << "setSidebandStream: not supported.";
|
|
return INVALID_OPERATION;
|
|
}
|
|
return OK;
|
|
}
|
|
|
|
void H2BGraphicBufferProducer::allocateBuffers(
|
|
uint32_t width, uint32_t height,
|
|
PixelFormat format, uint64_t usage) {
|
|
status_t bStatus{};
|
|
Return<HStatus> transResult = mBase->allocateBuffers(
|
|
width, height, static_cast<uint32_t>(format), usage);
|
|
if (!transResult.isOk()) {
|
|
LOG(ERROR) << "allocateBuffer: transaction failed.";
|
|
return;
|
|
}
|
|
if (!h2b(static_cast<HStatus>(transResult), &bStatus)) {
|
|
LOG(ERROR) << "allocateBuffer: corrupted transaction.";
|
|
return;
|
|
}
|
|
}
|
|
|
|
status_t H2BGraphicBufferProducer::allowAllocation(bool allow) {
|
|
status_t bStatus{};
|
|
Return<HStatus> transResult = mBase->allowAllocation(allow);
|
|
if (!transResult.isOk()) {
|
|
LOG(ERROR) << "allowAllocation: transaction failed.";
|
|
return FAILED_TRANSACTION;
|
|
}
|
|
if (!h2b(static_cast<HStatus>(transResult), &bStatus)) {
|
|
LOG(ERROR) << "allowAllocation: corrupted transaction.";
|
|
return FAILED_TRANSACTION;
|
|
}
|
|
return bStatus;
|
|
}
|
|
|
|
status_t H2BGraphicBufferProducer::setGenerationNumber(
|
|
uint32_t generationNumber) {
|
|
status_t bStatus{};
|
|
Return<HStatus> transResult = mBase->setGenerationNumber(generationNumber);
|
|
if (!transResult.isOk()) {
|
|
LOG(ERROR) << "setGenerationNumber: transaction failed.";
|
|
return FAILED_TRANSACTION;
|
|
}
|
|
if (!h2b(static_cast<HStatus>(transResult), &bStatus)) {
|
|
LOG(ERROR) << "setGenerationNumber: corrupted transaction.";
|
|
return FAILED_TRANSACTION;
|
|
}
|
|
return bStatus;
|
|
}
|
|
|
|
String8 H2BGraphicBufferProducer::getConsumerName() const {
|
|
String8 bName;
|
|
Return<void> transResult = mBase->getConsumerName(
|
|
[&bName](hidl_string const& name) {
|
|
bName = name.c_str();
|
|
});
|
|
return bName;
|
|
}
|
|
|
|
status_t H2BGraphicBufferProducer::setSharedBufferMode(bool sharedBufferMode) {
|
|
if (sharedBufferMode) {
|
|
LOG(INFO) << "setSharedBufferMode: not supported.";
|
|
return INVALID_OPERATION;
|
|
}
|
|
return OK;
|
|
}
|
|
|
|
status_t H2BGraphicBufferProducer::setAutoRefresh(bool autoRefresh) {
|
|
if (autoRefresh) {
|
|
LOG(INFO) << "setAutoRefresh: not supported.";
|
|
return INVALID_OPERATION;
|
|
}
|
|
return OK;
|
|
}
|
|
|
|
status_t H2BGraphicBufferProducer::setDequeueTimeout(nsecs_t timeout) {
|
|
status_t bStatus{};
|
|
Return<HStatus> transResult = mBase->setDequeueTimeout(
|
|
static_cast<int64_t>(timeout));
|
|
if (!transResult.isOk()) {
|
|
LOG(ERROR) << "setDequeueTimeout: transaction failed.";
|
|
return FAILED_TRANSACTION;
|
|
}
|
|
if (!h2b(static_cast<HStatus>(transResult), &bStatus)) {
|
|
LOG(ERROR) << "setDequeueTimeout: corrupted transaction.";
|
|
return FAILED_TRANSACTION;
|
|
}
|
|
return bStatus;
|
|
}
|
|
|
|
status_t H2BGraphicBufferProducer::getLastQueuedBuffer(
|
|
sp<GraphicBuffer>*,
|
|
sp<BFence>*,
|
|
float[16]) {
|
|
LOG(INFO) << "getLastQueuedBuffer: not supported.";
|
|
return INVALID_OPERATION;
|
|
}
|
|
|
|
void H2BGraphicBufferProducer::getFrameTimestamps(FrameEventHistoryDelta*) {
|
|
LOG(INFO) << "getFrameTimestamps: not supported.";
|
|
}
|
|
|
|
status_t H2BGraphicBufferProducer::getUniqueId(uint64_t* outId) const {
|
|
Return<uint64_t> transResult = mBase->getUniqueId();
|
|
if (!transResult.isOk()) {
|
|
LOG(ERROR) << "getUniqueId: transaction failed.";
|
|
return FAILED_TRANSACTION;
|
|
}
|
|
*outId = static_cast<uint64_t>(transResult);
|
|
return OK;
|
|
}
|
|
|
|
status_t H2BGraphicBufferProducer::getConsumerUsage(uint64_t*) const {
|
|
LOG(INFO) << "getConsumerUsage: not supported.";
|
|
return INVALID_OPERATION;
|
|
}
|
|
|
|
} // namespace utils
|
|
} // namespace V2_0
|
|
} // namespace bufferqueue
|
|
} // namespace graphics
|
|
} // namespace hardware
|
|
} // namespace android
|