libs/gui/bufferqueue/2.0/H2BGraphicBufferProducer.cpp - android_frameworks_native - Gitiles

 /*
  * 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
	/*
	* 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