Merge "Add batching to IGBP functions" (751702b6) · Commits · e / os / platform_frameworks_native

libs/gui/Android.bp

+2 −1

Original line number	Diff line number	Diff line
		@@ -162,6 +162,7 @@ cc_library_static {
		filegroup {
		name: "libgui_bufferqueue_sources",
		srcs: [
		"BatchBufferOps.cpp",
		"BufferItem.cpp",
		"BufferQueue.cpp",
		"BufferQueueConsumer.cpp",
		@@ -172,7 +173,7 @@ filegroup {
		"FrameTimestamps.cpp",
		"GLConsumerUtils.cpp",
		"HdrMetadata.cpp",
		"QueueBufferInputOutput.cpp",
		"IGraphicBufferProducerFlattenables.cpp",
		"bufferqueue/1.0/Conversion.cpp",
		"bufferqueue/1.0/H2BProducerListener.cpp",
		"bufferqueue/1.0/WProducerListener.cpp",

libs/gui/BatchBufferOps.cpp

0 → 100644

+125 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2021 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 <inttypes.h>

		#define LOG_TAG "IGBPBatchOps"
		#define ATRACE_TAG ATRACE_TAG_GRAPHICS
		//#define LOG_NDEBUG 0

		#include <gui/IGraphicBufferProducer.h>

		namespace android {

		/**
		* Default implementation of batched buffer operations. These default
		* implementations call into the non-batched version of the same operation.
		*/

		status_t IGraphicBufferProducer::requestBuffers(
		const std::vector<int32_t>& slots,
		std::vector<RequestBufferOutput>* outputs) {
		outputs->clear();
		outputs->reserve(slots.size());
		for (int32_t slot : slots) {
		RequestBufferOutput& output = outputs->emplace_back();
		output.result = requestBuffer(static_cast<int>(slot),
		&output.buffer);
		}
		return NO_ERROR;
		}

		status_t IGraphicBufferProducer::dequeueBuffers(
		const std::vector<DequeueBufferInput>& inputs,
		std::vector<DequeueBufferOutput>* outputs) {
		outputs->clear();
		outputs->reserve(inputs.size());
		for (const DequeueBufferInput& input : inputs) {
		DequeueBufferOutput& output = outputs->emplace_back();
		output.result = dequeueBuffer(
		&output.slot,
		&output.fence,
		input.width,
		input.height,
		input.format,
		input.usage,
		&output.bufferAge,
		input.getTimestamps ? &output.timestamps.emplace() : nullptr);
		}
		return NO_ERROR;
		}

		status_t IGraphicBufferProducer::detachBuffers(
		const std::vector<int32_t>& slots,
		std::vector<status_t>* results) {
		results->clear();
		results->reserve(slots.size());
		for (int32_t slot : slots) {
		results->emplace_back(detachBuffer(slot));
		}
		return NO_ERROR;
		}

		status_t IGraphicBufferProducer::attachBuffers(
		const std::vector<sp<GraphicBuffer>>& buffers,
		std::vector<AttachBufferOutput>* outputs) {
		outputs->clear();
		outputs->reserve(buffers.size());
		for (const sp<GraphicBuffer>& buffer : buffers) {
		AttachBufferOutput& output = outputs->emplace_back();
		output.result = attachBuffer(&output.slot, buffer);
		}
		return NO_ERROR;
		}

		status_t IGraphicBufferProducer::queueBuffers(
		const std::vector<QueueBufferInput>& inputs,
		std::vector<QueueBufferOutput>* outputs) {
		outputs->clear();
		outputs->reserve(inputs.size());
		for (const QueueBufferInput& input : inputs) {
		QueueBufferOutput& output = outputs->emplace_back();
		output.result = queueBuffer(input.slot, input, &output);
		}
		return NO_ERROR;
		}

		status_t IGraphicBufferProducer::cancelBuffers(
		const std::vector<CancelBufferInput>& inputs,
		std::vector<status_t>* results) {
		results->clear();
		results->reserve(inputs.size());
		for (const CancelBufferInput& input : inputs) {
		results->emplace_back() = cancelBuffer(input.slot, input.fence);
		}
		return NO_ERROR;
		}

		status_t IGraphicBufferProducer::query(const std::vector<int32_t> inputs,
		std::vector<QueryOutput>* outputs) {
		outputs->clear();
		outputs->reserve(inputs.size());
		for (int32_t input : inputs) {
		QueryOutput& output = outputs->emplace_back();
		int value{};
		output.result = static_cast<status_t>(
		query(static_cast<int>(input), &value));
		output.value = static_cast<int64_t>(value);
		}
		return NO_ERROR;
		}

		} // namespace android

libs/gui/IGraphicBufferProducer.cpp

+339 −9

Original line number	Diff line number	Diff line
		@@ -74,6 +74,13 @@ enum {
		GET_CONSUMER_USAGE,
		SET_LEGACY_BUFFER_DROP,
		SET_AUTO_PREROTATION,
		REQUEST_BUFFERS,
		DEQUEUE_BUFFERS,
		DETACH_BUFFERS,
		ATTACH_BUFFERS,
		QUEUE_BUFFERS,
		CANCEL_BUFFERS,
		QUERY_MULTIPLE,
		};

		class BpGraphicBufferProducer : public BpInterface<IGraphicBufferProducer>
		@@ -107,6 +114,27 @@ public:
		return result;
		}

		virtual status_t requestBuffers(
		const std::vector<int32_t>& slots,
		std::vector<RequestBufferOutput>* outputs) override {
		Parcel data, reply;
		data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
		data.writeInt32Vector(slots);
		status_t result = remote()->transact(REQUEST_BUFFERS, data, &reply);
		if (result != NO_ERROR) {
		return result;
		}
		result = reply.resizeOutVector(outputs);
		for (RequestBufferOutput& output : *outputs) {
		if (result != NO_ERROR) {
		return result;
		}
		result = reply.read(output);
		}

		return result;
		}

		virtual status_t setMaxDequeuedBufferCount(int maxDequeuedBuffers) {
		Parcel data, reply;
		data.writeInterfaceToken(
		@@ -183,6 +211,29 @@ public:
		return result;
		}

		virtual status_t dequeueBuffers(
		const std::vector<DequeueBufferInput>& inputs,
		std::vector<DequeueBufferOutput>* outputs) {
		Parcel data, reply;
		data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
		data.writeVectorSize(inputs);
		for (const auto& input : inputs) {
		data.write(input);
		}
		status_t result = remote()->transact(DEQUEUE_BUFFERS, data, &reply);
		if (result != NO_ERROR) {
		return result;
		}
		result = reply.resizeOutVector(outputs);
		for (auto& output : *outputs) {
		if (result != NO_ERROR) {
		return result;
		}
		result = reply.read(output);
		}
		return result;
		}

		virtual status_t detachBuffer(int slot) {
		Parcel data, reply;
		data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
		@@ -195,6 +246,19 @@ public:
		return result;
		}

		virtual status_t detachBuffers(const std::vector<int32_t>& slots,
		std::vector<status_t>* results) {
		Parcel data, reply;
		data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
		data.writeInt32Vector(slots);
		status_t result = remote()->transact(DETACH_BUFFERS, data, &reply);
		if (result != NO_ERROR) {
		return result;
		}
		result = reply.readInt32Vector(results);
		return result;
		}

		virtual status_t detachNextBuffer(sp<GraphicBuffer>* outBuffer,
		sp<Fence>* outFence) {
		if (outBuffer == nullptr) {
		@@ -256,6 +320,39 @@ public:
		return result;
		}

		virtual status_t attachBuffers(
		const std::vector<sp<GraphicBuffer>>& buffers,
		std::vector<AttachBufferOutput>* outputs) {
		Parcel data, reply;
		data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
		data.writeVectorSize(buffers);
		for (const sp<GraphicBuffer>& buffer : buffers) {
		data.write(*buffer.get());
		}
		status_t result = remote()->transact(ATTACH_BUFFERS, data, &reply);
		if (result != NO_ERROR) {
		return result;
		}
		result = reply.resizeOutVector(outputs);
		for (AttachBufferOutput& output : *outputs) {
		if (result != NO_ERROR) {
		return result;
		}
		result = reply.read(output);
		}
		if (result == NO_ERROR) {
		for (AttachBufferOutput& output : *outputs) {
		if (output.result == NO_ERROR && output.slot < 0) {
		ALOGE("attachBuffers returned invalid slot %d",
		output.slot);
		android_errorWriteLog(0x534e4554, "37478824");
		output.result = UNKNOWN_ERROR;
		}
		}
		}
		return result;
		}

		virtual status_t queueBuffer(int buf,
		const QueueBufferInput& input, QueueBufferOutput* output) {
		Parcel data, reply;
		@@ -278,6 +375,28 @@ public:
		return result;
		}

		virtual status_t queueBuffers(const std::vector<QueueBufferInput>& inputs,
		std::vector<QueueBufferOutput>* outputs) {
		Parcel data, reply;
		data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
		data.writeVectorSize(inputs);
		for (const QueueBufferInput& input : inputs) {
		data.write(input);
		}
		status_t result = remote()->transact(QUEUE_BUFFERS, data, &reply);
		if (result != NO_ERROR) {
		return result;
		}
		result = reply.resizeOutVector(outputs);
		for (QueueBufferOutput& output : *outputs) {
		if (result != NO_ERROR) {
		return result;
		}
		result = reply.read(output);
		}
		return result;
		}

		virtual status_t cancelBuffer(int buf, const sp<Fence>& fence) {
		Parcel data, reply;
		data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
		@@ -291,6 +410,23 @@ public:
		return result;
		}

		virtual status_t cancelBuffers(
		const std::vector<CancelBufferInput>& inputs,
		std::vector<status_t>* results) {
		Parcel data, reply;
		data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
		data.writeVectorSize(inputs);
		for (const CancelBufferInput& input : inputs) {
		data.write(input);
		}
		status_t result = remote()->transact(CANCEL_BUFFERS, data, &reply);
		if (result != NO_ERROR) {
		return result;
		}
		result = reply.readInt32Vector(results);
		return result;
		}

		virtual int query(int what, int* value) {
		Parcel data, reply;
		data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
		@@ -304,6 +440,25 @@ public:
		return result;
		}

		virtual status_t query(const std::vector<int32_t> inputs,
		std::vector<QueryOutput>* outputs) {
		Parcel data, reply;
		data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
		data.writeInt32Vector(inputs);
		status_t result = remote()->transact(QUERY_MULTIPLE, data, &reply);
		if (result != NO_ERROR) {
		return result;
		}
		result = reply.resizeOutVector(outputs);
		for (QueryOutput& output : *outputs) {
		if (result != NO_ERROR) {
		return result;
		}
		result = reply.read(output);
		}
		return result;
		}

		virtual status_t connect(const sp<IProducerListener>& listener,
		int api, bool producerControlledByApp, QueueBufferOutput* output) {
		Parcel data, reply;
		@@ -576,6 +731,12 @@ public:
		return mBase->requestBuffer(slot, buf);
		}

		status_t requestBuffers(
		const std::vector<int32_t>& slots,
		std::vector<RequestBufferOutput>* outputs) override {
		return mBase->requestBuffers(slots, outputs);
		}

		status_t setMaxDequeuedBufferCount(int maxDequeuedBuffers) override {
		return mBase->setMaxDequeuedBufferCount(maxDequeuedBuffers);
		}
		@@ -590,10 +751,21 @@ public:
		return mBase->dequeueBuffer(slot, fence, w, h, format, usage, outBufferAge, outTimestamps);
		}

		status_t dequeueBuffers(
		const std::vector<DequeueBufferInput>& inputs,
		std::vector<DequeueBufferOutput>* outputs) override {
		return mBase->dequeueBuffers(inputs, outputs);
		}

		status_t detachBuffer(int slot) override {
		return mBase->detachBuffer(slot);
		}

		status_t detachBuffers(const std::vector<int32_t>& slots,
		std::vector<status_t>* results) override {
		return mBase->detachBuffers(slots, results);
		}

		status_t detachNextBuffer(
		sp<GraphicBuffer>* outBuffer, sp<Fence>* outFence) override {
		return mBase->detachNextBuffer(outBuffer, outFence);
		@@ -604,6 +776,12 @@ public:
		return mBase->attachBuffer(outSlot, buffer);
		}

		status_t attachBuffers(
		const std::vector<sp<GraphicBuffer>>& buffers,
		std::vector<AttachBufferOutput>* outputs) override {
		return mBase->attachBuffers(buffers, outputs);
		}

		status_t queueBuffer(
		int slot,
		const QueueBufferInput& input,
		@@ -611,14 +789,30 @@ public:
		return mBase->queueBuffer(slot, input, output);
		}

		status_t queueBuffers(const std::vector<QueueBufferInput>& inputs,
		std::vector<QueueBufferOutput>* outputs) override {
		return mBase->queueBuffers(inputs, outputs);
		}

		status_t cancelBuffer(int slot, const sp<Fence>& fence) override {
		return mBase->cancelBuffer(slot, fence);
		}

		status_t cancelBuffers(
		const std::vector<CancelBufferInput>& inputs,
		std::vector<status_t>* results) override {
		return mBase->cancelBuffers(inputs, results);
		}

		int query(int what, int* value) override {
		return mBase->query(what, value);
		}

		status_t query(const std::vector<int32_t> inputs,
		std::vector<QueryOutput>* outputs) override {
		return mBase->query(inputs, outputs);
		}

		status_t connect(
		const sp<IProducerListener>& listener,
		int api, bool producerControlledByApp,
		@@ -799,6 +993,24 @@ status_t BnGraphicBufferProducer::onTransact(
		reply->writeInt32(result);
		return NO_ERROR;
		}
		case REQUEST_BUFFERS: {
		CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
		std::vector<int32_t> slots;
		std::vector<RequestBufferOutput> outputs;
		status_t result = data.readInt32Vector(&slots);
		if (result != NO_ERROR) {
		return result;
		}
		(void)requestBuffers(slots, &outputs);
		result = reply->writeVectorSize(outputs);
		for (const RequestBufferOutput& output : outputs) {
		if (result != NO_ERROR) {
		return result;
		}
		result = reply->write(output);
		}
		return result;
		}
		case SET_MAX_DEQUEUED_BUFFER_COUNT: {
		CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
		int maxDequeuedBuffers = data.readInt32();
		@@ -841,6 +1053,30 @@ status_t BnGraphicBufferProducer::onTransact(
		reply->writeInt32(result);
		return NO_ERROR;
		}
		case DEQUEUE_BUFFERS: {
		CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
		std::vector<DequeueBufferInput> inputs;
		std::vector<DequeueBufferOutput> outputs;
		status_t result = data.resizeOutVector(&inputs);
		if (result != NO_ERROR) {
		return result;
		}
		for (DequeueBufferInput& input : inputs) {
		result = data.read(input);
		if (result != NO_ERROR) {
		return result;
		}
		}
		(void)dequeueBuffers(inputs, &outputs);
		result = reply->writeVectorSize(outputs);
		for (const DequeueBufferOutput& output : outputs) {
		if (result != NO_ERROR) {
		return result;
		}
		result = reply->write(output);
		}
		return result;
		}
		case DETACH_BUFFER: {
		CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
		int slot = data.readInt32();
		@@ -848,6 +1084,17 @@ status_t BnGraphicBufferProducer::onTransact(
		reply->writeInt32(result);
		return NO_ERROR;
		}
		case DETACH_BUFFERS: {
		CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
		std::vector<int32_t> slots;
		std::vector<status_t> results;
		status_t result = data.readInt32Vector(&slots);
		if (result != NO_ERROR) {
		return result;
		}
		(void)detachBuffers(slots, &results);
		return reply->writeInt32Vector(results);
		}
		case DETACH_NEXT_BUFFER: {
		CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
		sp<GraphicBuffer> buffer;
		@@ -878,6 +1125,31 @@ status_t BnGraphicBufferProducer::onTransact(
		reply->writeInt32(result);
		return NO_ERROR;
		}
		case ATTACH_BUFFERS: {
		CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
		std::vector<sp<GraphicBuffer>> buffers;
		status_t result = data.resizeOutVector(&buffers);
		if (result != NO_ERROR) {
		return result;
		}
		for (sp<GraphicBuffer>& buffer : buffers) {
		buffer = new GraphicBuffer();
		result = data.read(*buffer.get());
		if (result != NO_ERROR) {
		return result;
		}
		}
		std::vector<AttachBufferOutput> outputs;
		(void)attachBuffers(buffers, &outputs);
		result = reply->writeVectorSize(outputs);
		for (const AttachBufferOutput& output : outputs) {
		if (result != NO_ERROR) {
		return result;
		}
		result = reply->write(output);
		}
		return result;
		}
		case QUEUE_BUFFER: {
		CHECK_INTERFACE(IGraphicBufferProducer, data, reply);

		@@ -890,6 +1162,30 @@ status_t BnGraphicBufferProducer::onTransact(

		return NO_ERROR;
		}
		case QUEUE_BUFFERS: {
		CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
		std::vector<QueueBufferInput> inputs;
		status_t result = data.resizeOutVector(&inputs);
		if (result != NO_ERROR) {
		return result;
		}
		for (QueueBufferInput& input : inputs) {
		result = data.read(input);
		if (result != NO_ERROR) {
		return result;
		}
		}
		std::vector<QueueBufferOutput> outputs;
		(void)queueBuffers(inputs, &outputs);
		result = reply->writeVectorSize(outputs);
		for (const QueueBufferOutput& output : outputs) {
		if (result != NO_ERROR) {
		return result;
		}
		result = reply->write(output);
		}
		return result;
		}
		case CANCEL_BUFFER: {
		CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
		int buf = data.readInt32();
		@@ -901,6 +1197,26 @@ status_t BnGraphicBufferProducer::onTransact(
		reply->writeInt32(result);
		return NO_ERROR;
		}
		case CANCEL_BUFFERS: {
		CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
		std::vector<CancelBufferInput> inputs;
		status_t result = data.resizeOutVector(&inputs);
		for (CancelBufferInput& input : inputs) {
		if (result != NO_ERROR) {
		return result;
		}
		result = data.read(input);
		}
		if (result != NO_ERROR) {
		return result;
		}
		std::vector<status_t> results;
		result = cancelBuffers(inputs, &results);
		if (result != NO_ERROR) {
		return result;
		}
		return reply->writeInt32Vector(results);
		}
		case QUERY: {
		CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
		int value = 0;
		@@ -910,6 +1226,27 @@ status_t BnGraphicBufferProducer::onTransact(
		reply->writeInt32(res);
		return NO_ERROR;
		}
		case QUERY_MULTIPLE: {
		CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
		std::vector<int32_t> inputs;
		status_t result = data.readInt32Vector(&inputs);
		if (result != NO_ERROR) {
		return result;
		}
		std::vector<QueryOutput> outputs;
		result = query(inputs, &outputs);
		if (result != NO_ERROR) {
		return result;
		}
		result = reply->writeVectorSize(outputs);
		for (const QueryOutput& output : outputs) {
		if (result != NO_ERROR) {
		return result;
		}
		result = reply->write(output);
		}
		return result;
		}
		case CONNECT: {
		CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
		sp<IProducerListener> listener;
		@@ -1083,11 +1420,4 @@ status_t BnGraphicBufferProducer::onTransact(
		return BBinder::onTransact(code, data, reply, flags);
		}

		// ----------------------------------------------------------------------------

		IGraphicBufferProducer::QueueBufferInput::QueueBufferInput(const Parcel& parcel) {
		parcel.read(*this);
		}


		}; // namespace android

libs/gui/QueueBufferInputOutput.cpp→libs/gui/IGraphicBufferProducerFlattenables.cpp

+413 −0

File changed and moved.

Preview size limit exceeded, changes collapsed.

libs/gui/include/gui/IGraphicBufferProducer.h

+168 −6

File changed.

Preview size limit exceeded, changes collapsed.