libs/gui/IGraphicBufferProducerFlattenables.cpp - platform/frameworks/native - Gitiles

 /*
  * 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>
 #include <gui/IGraphicBufferProducer.h>

 namespace android {

 constexpr size_t IGraphicBufferProducer::QueueBufferInput::minFlattenedSize() {
     return sizeof(timestamp) +
             sizeof(isAutoTimestamp) +
             sizeof(dataSpace) +
             sizeof(crop) +
             sizeof(scalingMode) +
             sizeof(transform) +
             sizeof(stickyTransform) +
             sizeof(getFrameTimestamps) +
             sizeof(slot);
 }

 size_t IGraphicBufferProducer::QueueBufferInput::getFlattenedSize() const {
     return minFlattenedSize() +
             fence->getFlattenedSize() +
             surfaceDamage.getFlattenedSize() +
             hdrMetadata.getFlattenedSize();
 }

 size_t IGraphicBufferProducer::QueueBufferInput::getFdCount() const {
     return fence->getFdCount();
 }

 status_t IGraphicBufferProducer::QueueBufferInput::flatten(
         void*& buffer, size_t& size, int*& fds, size_t& count) const
 {
     if (size < getFlattenedSize()) {
         return NO_MEMORY;
     }

     FlattenableUtils::write(buffer, size, timestamp);
     FlattenableUtils::write(buffer, size, isAutoTimestamp);
     FlattenableUtils::write(buffer, size, dataSpace);
     FlattenableUtils::write(buffer, size, crop);
     FlattenableUtils::write(buffer, size, scalingMode);
     FlattenableUtils::write(buffer, size, transform);
     FlattenableUtils::write(buffer, size, stickyTransform);
     FlattenableUtils::write(buffer, size, getFrameTimestamps);

     status_t result = fence->flatten(buffer, size, fds, count);
     if (result != NO_ERROR) {
         return result;
     }
     result = surfaceDamage.flatten(buffer, size);
     if (result != NO_ERROR) {
         return result;
     }
     FlattenableUtils::advance(buffer, size, surfaceDamage.getFlattenedSize());
     result = hdrMetadata.flatten(buffer, size);
     if (result != NO_ERROR) {
         return result;
     }
     FlattenableUtils::advance(buffer, size, hdrMetadata.getFlattenedSize());
     FlattenableUtils::write(buffer, size, slot);
     return NO_ERROR;
 }

 status_t IGraphicBufferProducer::QueueBufferInput::unflatten(
         void const*& buffer, size_t& size, int const*& fds, size_t& count)
 {
     if (size < minFlattenedSize()) {
         return NO_MEMORY;
     }

     FlattenableUtils::read(buffer, size, timestamp);
     FlattenableUtils::read(buffer, size, isAutoTimestamp);
     FlattenableUtils::read(buffer, size, dataSpace);
     FlattenableUtils::read(buffer, size, crop);
     FlattenableUtils::read(buffer, size, scalingMode);
     FlattenableUtils::read(buffer, size, transform);
     FlattenableUtils::read(buffer, size, stickyTransform);
     FlattenableUtils::read(buffer, size, getFrameTimestamps);

     fence = new Fence();
     status_t result = fence->unflatten(buffer, size, fds, count);
     if (result != NO_ERROR) {
         return result;
     }
     result = surfaceDamage.unflatten(buffer, size);
     if (result != NO_ERROR) {
         return result;
     }
     FlattenableUtils::advance(buffer, size, surfaceDamage.getFlattenedSize());
     result =  hdrMetadata.unflatten(buffer, size);
     if (result != NO_ERROR) {
         return result;
     }
     FlattenableUtils::advance(buffer, size, hdrMetadata.getFlattenedSize());
     FlattenableUtils::read(buffer, size, slot);
     return NO_ERROR;
 }

 ////////////////////////////////////////////////////////////////////////
 constexpr size_t IGraphicBufferProducer::QueueBufferOutput::minFlattenedSize() {
     return sizeof(width) + sizeof(height) + sizeof(transformHint) + sizeof(numPendingBuffers) +
             sizeof(nextFrameNumber) + sizeof(bufferReplaced) + sizeof(maxBufferCount) +
             sizeof(result);
 }
 size_t IGraphicBufferProducer::QueueBufferOutput::getFlattenedSize() const {
     return minFlattenedSize() + frameTimestamps.getFlattenedSize();
 }

 size_t IGraphicBufferProducer::QueueBufferOutput::getFdCount() const {
     return frameTimestamps.getFdCount();
 }

 status_t IGraphicBufferProducer::QueueBufferOutput::flatten(
         void*& buffer, size_t& size, int*& fds, size_t& count) const
 {
     if (size < getFlattenedSize()) {
         return NO_MEMORY;
     }

     FlattenableUtils::write(buffer, size, width);
     FlattenableUtils::write(buffer, size, height);
     FlattenableUtils::write(buffer, size, transformHint);
     FlattenableUtils::write(buffer, size, numPendingBuffers);
     FlattenableUtils::write(buffer, size, nextFrameNumber);
     FlattenableUtils::write(buffer, size, bufferReplaced);
     FlattenableUtils::write(buffer, size, maxBufferCount);

     status_t result = frameTimestamps.flatten(buffer, size, fds, count);
     if (result != NO_ERROR) {
         return result;
     }
     FlattenableUtils::write(buffer, size, result);
     return NO_ERROR;
 }

 status_t IGraphicBufferProducer::QueueBufferOutput::unflatten(
         void const*& buffer, size_t& size, int const*& fds, size_t& count)
 {
     if (size < minFlattenedSize()) {
         return NO_MEMORY;
     }

     FlattenableUtils::read(buffer, size, width);
     FlattenableUtils::read(buffer, size, height);
     FlattenableUtils::read(buffer, size, transformHint);
     FlattenableUtils::read(buffer, size, numPendingBuffers);
     FlattenableUtils::read(buffer, size, nextFrameNumber);
     FlattenableUtils::read(buffer, size, bufferReplaced);
     FlattenableUtils::read(buffer, size, maxBufferCount);

     status_t result = frameTimestamps.unflatten(buffer, size, fds, count);
     if (result != NO_ERROR) {
         return result;
     }
     FlattenableUtils::read(buffer, size, result);
     return NO_ERROR;
 }

 ////////////////////////////////////////////////////////////////////////
 constexpr size_t IGraphicBufferProducer::RequestBufferOutput::minFlattenedSize() {
     return sizeof(result) +
             sizeof(int32_t); // IsBufferNull
 }

 size_t IGraphicBufferProducer::RequestBufferOutput::getFlattenedSize() const {
     return minFlattenedSize() + (buffer == nullptr ? 0 : buffer->getFlattenedSize());
 }

 size_t IGraphicBufferProducer::RequestBufferOutput::getFdCount() const {
     return (buffer == nullptr ? 0 : buffer->getFdCount());
 }

 status_t IGraphicBufferProducer::RequestBufferOutput::flatten(
         void*& fBuffer, size_t& size, int*& fds, size_t& count) const {
     if (size < getFlattenedSize()) {
         return NO_MEMORY;
     }

     FlattenableUtils::write(fBuffer, size, result);
     const int32_t isBufferNull = (buffer == nullptr ? 1 : 0);
     FlattenableUtils::write(fBuffer, size, isBufferNull);

     if (!isBufferNull) {
         status_t status = buffer->flatten(fBuffer, size, fds, count);
         if (status != NO_ERROR) {
             return status;
         }
     }
     return NO_ERROR;
 }

 status_t IGraphicBufferProducer::RequestBufferOutput::unflatten(
         void const*& fBuffer, size_t& size, int const*& fds, size_t& count) {
     if (size < minFlattenedSize()) {
         return NO_MEMORY;
     }

     FlattenableUtils::read(fBuffer, size, result);
     int32_t isBufferNull = 0;
     FlattenableUtils::read(fBuffer, size, isBufferNull);
     buffer = new GraphicBuffer();
     if (!isBufferNull) {
         status_t status = buffer->unflatten(fBuffer, size, fds, count);
         if (status != NO_ERROR) {
             return status;
         }
     }
     return NO_ERROR;
 }

 ////////////////////////////////////////////////////////////////////////

 size_t IGraphicBufferProducer::DequeueBufferInput::getFlattenedSize() const {
     return sizeof(width) + sizeof(height) + sizeof(format) + sizeof(usage) +
             sizeof(int32_t/*getTimestamps*/);
 }

 status_t IGraphicBufferProducer::DequeueBufferInput::flatten(void* buffer, size_t size) const {
     if (size < getFlattenedSize()) {
         return NO_MEMORY;
     }
     FlattenableUtils::write(buffer, size, width);
     FlattenableUtils::write(buffer, size, height);
     FlattenableUtils::write(buffer, size, format);
     FlattenableUtils::write(buffer, size, usage);
     const int32_t getTimestampsInt = (getTimestamps ? 1 : 0);
     FlattenableUtils::write(buffer, size, getTimestampsInt);

     return NO_ERROR;
 }

 status_t IGraphicBufferProducer::DequeueBufferInput::unflatten(void const* buffer, size_t size) {
     if (size < getFlattenedSize()) {
         return NO_MEMORY;
     }

     FlattenableUtils::read(buffer, size, width);
     FlattenableUtils::read(buffer, size, height);
     FlattenableUtils::read(buffer, size, format);
     FlattenableUtils::read(buffer, size, usage);
     int32_t getTimestampsInt = 0;
     FlattenableUtils::read(buffer, size, getTimestampsInt);
     getTimestamps = (getTimestampsInt == 1);

     return NO_ERROR;
 }

 ////////////////////////////////////////////////////////////////////////

 constexpr size_t IGraphicBufferProducer::DequeueBufferOutput::minFlattenedSize() {
     return sizeof(result) + sizeof(slot) + sizeof(bufferAge) + sizeof(int32_t/*hasTimestamps*/);
 }

 size_t IGraphicBufferProducer::DequeueBufferOutput::getFlattenedSize() const {
     return minFlattenedSize() +
             fence->getFlattenedSize() +
             (timestamps.has_value() ? timestamps->getFlattenedSize() : 0);
 }

 size_t IGraphicBufferProducer::DequeueBufferOutput::getFdCount() const {
     return fence->getFdCount() +
             (timestamps.has_value() ? timestamps->getFdCount() : 0);
 }

 status_t IGraphicBufferProducer::DequeueBufferOutput::flatten(
         void*& buffer, size_t& size, int*& fds, size_t& count) const {
     if (size < getFlattenedSize()) {
         return NO_MEMORY;
     }

     FlattenableUtils::write(buffer, size, result);
     FlattenableUtils::write(buffer, size, slot);
     FlattenableUtils::write(buffer, size, bufferAge);
     status_t status = fence->flatten(buffer, size, fds, count);
     if (status != NO_ERROR) {
         return result;
     }
     const int32_t hasTimestamps = timestamps.has_value() ? 1 : 0;
     FlattenableUtils::write(buffer, size, hasTimestamps);
     if (timestamps.has_value()) {
         status = timestamps->flatten(buffer, size, fds, count);
     }
     return status;
 }

 status_t IGraphicBufferProducer::DequeueBufferOutput::unflatten(
         void const*& buffer, size_t& size, int const*& fds, size_t& count) {
     if (size < minFlattenedSize()) {
         return NO_MEMORY;
     }

     FlattenableUtils::read(buffer, size, result);
     FlattenableUtils::read(buffer, size, slot);
     FlattenableUtils::read(buffer, size, bufferAge);

     fence = new Fence();
     status_t status = fence->unflatten(buffer, size, fds, count);
     if (status != NO_ERROR) {
         return status;
     }
     int32_t hasTimestamps = 0;
     FlattenableUtils::read(buffer, size, hasTimestamps);
     if (hasTimestamps) {
         timestamps.emplace();
         status = timestamps->unflatten(buffer, size, fds, count);
     }
     return status;
 }

 ////////////////////////////////////////////////////////////////////////

 size_t IGraphicBufferProducer::AttachBufferOutput::getFlattenedSize() const {
     return sizeof(result) + sizeof(slot);
 }

 status_t IGraphicBufferProducer::AttachBufferOutput::flatten(void* buffer, size_t size) const {
     if (size < getFlattenedSize()) {
         return NO_MEMORY;
     }
     FlattenableUtils::write(buffer, size, result);
     FlattenableUtils::write(buffer, size, slot);

     return NO_ERROR;
 }

 status_t IGraphicBufferProducer::AttachBufferOutput::unflatten(void const* buffer, size_t size) {
     if (size < getFlattenedSize()) {
         return NO_MEMORY;
     }
     FlattenableUtils::read(buffer, size, result);
     FlattenableUtils::read(buffer, size, slot);

     return NO_ERROR;
 }

 ////////////////////////////////////////////////////////////////////////

 constexpr size_t IGraphicBufferProducer::CancelBufferInput::minFlattenedSize() {
     return sizeof(slot);
 }

 size_t IGraphicBufferProducer::CancelBufferInput::getFlattenedSize() const {
     return minFlattenedSize() + fence->getFlattenedSize();
 }

 size_t IGraphicBufferProducer::CancelBufferInput::getFdCount() const {
     return fence->getFdCount();
 }

 status_t IGraphicBufferProducer::CancelBufferInput::flatten(
         void*& buffer, size_t& size, int*& fds, size_t& count) const {
     if (size < getFlattenedSize()) {
         return NO_MEMORY;
     }

     FlattenableUtils::write(buffer, size, slot);
     return fence->flatten(buffer, size, fds, count);
 }

 status_t IGraphicBufferProducer::CancelBufferInput::unflatten(
         void const*& buffer, size_t& size, int const*& fds, size_t& count) {
     if (size < minFlattenedSize()) {
         return NO_MEMORY;
     }

     FlattenableUtils::read(buffer, size, slot);

     fence = new Fence();
     return fence->unflatten(buffer, size, fds, count);
 }

 ////////////////////////////////////////////////////////////////////////

 size_t IGraphicBufferProducer::QueryOutput::getFlattenedSize() const {
     return sizeof(result) + sizeof(value);
 }

 status_t IGraphicBufferProducer::QueryOutput::flatten(void* buffer, size_t size) const {
     if (size < getFlattenedSize()) {
         return NO_MEMORY;
     }
     FlattenableUtils::write(buffer, size, result);
     FlattenableUtils::write(buffer, size, value);

     return NO_ERROR;
 }

 status_t IGraphicBufferProducer::QueryOutput::unflatten(void const* buffer, size_t size) {
     if (size < getFlattenedSize()) {
         return NO_MEMORY;
     }
     FlattenableUtils::read(buffer, size, result);
     FlattenableUtils::read(buffer, size, value);

     return NO_ERROR;
 }

 } // namespace android
	/*
	* 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>
	#include <gui/IGraphicBufferProducer.h>

	namespace android {

	constexpr size_t IGraphicBufferProducer::QueueBufferInput::minFlattenedSize() {
	return sizeof(timestamp) +
	sizeof(isAutoTimestamp) +
	sizeof(dataSpace) +
	sizeof(crop) +
	sizeof(scalingMode) +
	sizeof(transform) +
	sizeof(stickyTransform) +
	sizeof(getFrameTimestamps) +
	sizeof(slot);
	}

	size_t IGraphicBufferProducer::QueueBufferInput::getFlattenedSize() const {
	return minFlattenedSize() +
	fence->getFlattenedSize() +
	surfaceDamage.getFlattenedSize() +
	hdrMetadata.getFlattenedSize();
	}

	size_t IGraphicBufferProducer::QueueBufferInput::getFdCount() const {
	return fence->getFdCount();
	}

	status_t IGraphicBufferProducer::QueueBufferInput::flatten(
	void& buffer, size_t& size, int& fds, size_t& count) const
	{
	if (size < getFlattenedSize()) {
	return NO_MEMORY;
	}

	FlattenableUtils::write(buffer, size, timestamp);
	FlattenableUtils::write(buffer, size, isAutoTimestamp);
	FlattenableUtils::write(buffer, size, dataSpace);
	FlattenableUtils::write(buffer, size, crop);
	FlattenableUtils::write(buffer, size, scalingMode);
	FlattenableUtils::write(buffer, size, transform);
	FlattenableUtils::write(buffer, size, stickyTransform);
	FlattenableUtils::write(buffer, size, getFrameTimestamps);

	status_t result = fence->flatten(buffer, size, fds, count);
	if (result != NO_ERROR) {
	return result;
	}
	result = surfaceDamage.flatten(buffer, size);
	if (result != NO_ERROR) {
	return result;
	}
	FlattenableUtils::advance(buffer, size, surfaceDamage.getFlattenedSize());
	result = hdrMetadata.flatten(buffer, size);
	if (result != NO_ERROR) {
	return result;
	}
	FlattenableUtils::advance(buffer, size, hdrMetadata.getFlattenedSize());
	FlattenableUtils::write(buffer, size, slot);
	return NO_ERROR;
	}

	status_t IGraphicBufferProducer::QueueBufferInput::unflatten(
	void const& buffer, size_t& size, int const& fds, size_t& count)
	{
	if (size < minFlattenedSize()) {
	return NO_MEMORY;
	}

	FlattenableUtils::read(buffer, size, timestamp);
	FlattenableUtils::read(buffer, size, isAutoTimestamp);
	FlattenableUtils::read(buffer, size, dataSpace);
	FlattenableUtils::read(buffer, size, crop);
	FlattenableUtils::read(buffer, size, scalingMode);
	FlattenableUtils::read(buffer, size, transform);
	FlattenableUtils::read(buffer, size, stickyTransform);
	FlattenableUtils::read(buffer, size, getFrameTimestamps);

	fence = new Fence();
	status_t result = fence->unflatten(buffer, size, fds, count);
	if (result != NO_ERROR) {
	return result;
	}
	result = surfaceDamage.unflatten(buffer, size);
	if (result != NO_ERROR) {
	return result;
	}
	FlattenableUtils::advance(buffer, size, surfaceDamage.getFlattenedSize());
	result = hdrMetadata.unflatten(buffer, size);
	if (result != NO_ERROR) {
	return result;
	}
	FlattenableUtils::advance(buffer, size, hdrMetadata.getFlattenedSize());
	FlattenableUtils::read(buffer, size, slot);
	return NO_ERROR;
	}

	////////////////////////////////////////////////////////////////////////
	constexpr size_t IGraphicBufferProducer::QueueBufferOutput::minFlattenedSize() {
	return sizeof(width) + sizeof(height) + sizeof(transformHint) + sizeof(numPendingBuffers) +
	sizeof(nextFrameNumber) + sizeof(bufferReplaced) + sizeof(maxBufferCount) +
	sizeof(result);
	}
	size_t IGraphicBufferProducer::QueueBufferOutput::getFlattenedSize() const {
	return minFlattenedSize() + frameTimestamps.getFlattenedSize();
	}

	size_t IGraphicBufferProducer::QueueBufferOutput::getFdCount() const {
	return frameTimestamps.getFdCount();
	}

	status_t IGraphicBufferProducer::QueueBufferOutput::flatten(
	void& buffer, size_t& size, int& fds, size_t& count) const
	{
	if (size < getFlattenedSize()) {
	return NO_MEMORY;
	}

	FlattenableUtils::write(buffer, size, width);
	FlattenableUtils::write(buffer, size, height);
	FlattenableUtils::write(buffer, size, transformHint);
	FlattenableUtils::write(buffer, size, numPendingBuffers);
	FlattenableUtils::write(buffer, size, nextFrameNumber);
	FlattenableUtils::write(buffer, size, bufferReplaced);
	FlattenableUtils::write(buffer, size, maxBufferCount);

	status_t result = frameTimestamps.flatten(buffer, size, fds, count);
	if (result != NO_ERROR) {
	return result;
	}
	FlattenableUtils::write(buffer, size, result);
	return NO_ERROR;
	}

	status_t IGraphicBufferProducer::QueueBufferOutput::unflatten(
	void const& buffer, size_t& size, int const& fds, size_t& count)
	{
	if (size < minFlattenedSize()) {
	return NO_MEMORY;
	}

	FlattenableUtils::read(buffer, size, width);
	FlattenableUtils::read(buffer, size, height);
	FlattenableUtils::read(buffer, size, transformHint);
	FlattenableUtils::read(buffer, size, numPendingBuffers);
	FlattenableUtils::read(buffer, size, nextFrameNumber);
	FlattenableUtils::read(buffer, size, bufferReplaced);
	FlattenableUtils::read(buffer, size, maxBufferCount);

	status_t result = frameTimestamps.unflatten(buffer, size, fds, count);
	if (result != NO_ERROR) {
	return result;
	}
	FlattenableUtils::read(buffer, size, result);
	return NO_ERROR;
	}

	////////////////////////////////////////////////////////////////////////
	constexpr size_t IGraphicBufferProducer::RequestBufferOutput::minFlattenedSize() {
	return sizeof(result) +
	sizeof(int32_t); // IsBufferNull
	}

	size_t IGraphicBufferProducer::RequestBufferOutput::getFlattenedSize() const {
	return minFlattenedSize() + (buffer == nullptr ? 0 : buffer->getFlattenedSize());
	}

	size_t IGraphicBufferProducer::RequestBufferOutput::getFdCount() const {
	return (buffer == nullptr ? 0 : buffer->getFdCount());
	}

	status_t IGraphicBufferProducer::RequestBufferOutput::flatten(
	void& fBuffer, size_t& size, int& fds, size_t& count) const {
	if (size < getFlattenedSize()) {
	return NO_MEMORY;
	}

	FlattenableUtils::write(fBuffer, size, result);
	const int32_t isBufferNull = (buffer == nullptr ? 1 : 0);
	FlattenableUtils::write(fBuffer, size, isBufferNull);

	if (!isBufferNull) {
	status_t status = buffer->flatten(fBuffer, size, fds, count);
	if (status != NO_ERROR) {
	return status;
	}
	}
	return NO_ERROR;
	}

	status_t IGraphicBufferProducer::RequestBufferOutput::unflatten(
	void const& fBuffer, size_t& size, int const& fds, size_t& count) {
	if (size < minFlattenedSize()) {
	return NO_MEMORY;
	}

	FlattenableUtils::read(fBuffer, size, result);
	int32_t isBufferNull = 0;
	FlattenableUtils::read(fBuffer, size, isBufferNull);
	buffer = new GraphicBuffer();
	if (!isBufferNull) {
	status_t status = buffer->unflatten(fBuffer, size, fds, count);
	if (status != NO_ERROR) {
	return status;
	}
	}
	return NO_ERROR;
	}

	////////////////////////////////////////////////////////////////////////

	size_t IGraphicBufferProducer::DequeueBufferInput::getFlattenedSize() const {
	return sizeof(width) + sizeof(height) + sizeof(format) + sizeof(usage) +
	sizeof(int32_t/getTimestamps/);
	}

	status_t IGraphicBufferProducer::DequeueBufferInput::flatten(void* buffer, size_t size) const {
	if (size < getFlattenedSize()) {
	return NO_MEMORY;
	}
	FlattenableUtils::write(buffer, size, width);
	FlattenableUtils::write(buffer, size, height);
	FlattenableUtils::write(buffer, size, format);
	FlattenableUtils::write(buffer, size, usage);
	const int32_t getTimestampsInt = (getTimestamps ? 1 : 0);
	FlattenableUtils::write(buffer, size, getTimestampsInt);

	return NO_ERROR;
	}

	status_t IGraphicBufferProducer::DequeueBufferInput::unflatten(void const* buffer, size_t size) {
	if (size < getFlattenedSize()) {
	return NO_MEMORY;
	}

	FlattenableUtils::read(buffer, size, width);
	FlattenableUtils::read(buffer, size, height);
	FlattenableUtils::read(buffer, size, format);
	FlattenableUtils::read(buffer, size, usage);
	int32_t getTimestampsInt = 0;
	FlattenableUtils::read(buffer, size, getTimestampsInt);
	getTimestamps = (getTimestampsInt == 1);

	return NO_ERROR;
	}

	////////////////////////////////////////////////////////////////////////

	constexpr size_t IGraphicBufferProducer::DequeueBufferOutput::minFlattenedSize() {
	return sizeof(result) + sizeof(slot) + sizeof(bufferAge) + sizeof(int32_t/hasTimestamps/);
	}

	size_t IGraphicBufferProducer::DequeueBufferOutput::getFlattenedSize() const {
	return minFlattenedSize() +
	fence->getFlattenedSize() +
	(timestamps.has_value() ? timestamps->getFlattenedSize() : 0);
	}

	size_t IGraphicBufferProducer::DequeueBufferOutput::getFdCount() const {
	return fence->getFdCount() +
	(timestamps.has_value() ? timestamps->getFdCount() : 0);
	}

	status_t IGraphicBufferProducer::DequeueBufferOutput::flatten(
	void& buffer, size_t& size, int& fds, size_t& count) const {
	if (size < getFlattenedSize()) {
	return NO_MEMORY;
	}

	FlattenableUtils::write(buffer, size, result);
	FlattenableUtils::write(buffer, size, slot);
	FlattenableUtils::write(buffer, size, bufferAge);
	status_t status = fence->flatten(buffer, size, fds, count);
	if (status != NO_ERROR) {
	return result;
	}
	const int32_t hasTimestamps = timestamps.has_value() ? 1 : 0;
	FlattenableUtils::write(buffer, size, hasTimestamps);
	if (timestamps.has_value()) {
	status = timestamps->flatten(buffer, size, fds, count);
	}
	return status;
	}

	status_t IGraphicBufferProducer::DequeueBufferOutput::unflatten(
	void const& buffer, size_t& size, int const& fds, size_t& count) {
	if (size < minFlattenedSize()) {
	return NO_MEMORY;
	}

	FlattenableUtils::read(buffer, size, result);
	FlattenableUtils::read(buffer, size, slot);
	FlattenableUtils::read(buffer, size, bufferAge);

	fence = new Fence();
	status_t status = fence->unflatten(buffer, size, fds, count);
	if (status != NO_ERROR) {
	return status;
	}
	int32_t hasTimestamps = 0;
	FlattenableUtils::read(buffer, size, hasTimestamps);
	if (hasTimestamps) {
	timestamps.emplace();
	status = timestamps->unflatten(buffer, size, fds, count);
	}
	return status;
	}

	////////////////////////////////////////////////////////////////////////

	size_t IGraphicBufferProducer::AttachBufferOutput::getFlattenedSize() const {
	return sizeof(result) + sizeof(slot);
	}

	status_t IGraphicBufferProducer::AttachBufferOutput::flatten(void* buffer, size_t size) const {
	if (size < getFlattenedSize()) {
	return NO_MEMORY;
	}
	FlattenableUtils::write(buffer, size, result);
	FlattenableUtils::write(buffer, size, slot);

	return NO_ERROR;
	}

	status_t IGraphicBufferProducer::AttachBufferOutput::unflatten(void const* buffer, size_t size) {
	if (size < getFlattenedSize()) {
	return NO_MEMORY;
	}
	FlattenableUtils::read(buffer, size, result);
	FlattenableUtils::read(buffer, size, slot);

	return NO_ERROR;
	}

	////////////////////////////////////////////////////////////////////////

	constexpr size_t IGraphicBufferProducer::CancelBufferInput::minFlattenedSize() {
	return sizeof(slot);
	}

	size_t IGraphicBufferProducer::CancelBufferInput::getFlattenedSize() const {
	return minFlattenedSize() + fence->getFlattenedSize();
	}

	size_t IGraphicBufferProducer::CancelBufferInput::getFdCount() const {
	return fence->getFdCount();
	}

	status_t IGraphicBufferProducer::CancelBufferInput::flatten(
	void& buffer, size_t& size, int& fds, size_t& count) const {
	if (size < getFlattenedSize()) {
	return NO_MEMORY;
	}

	FlattenableUtils::write(buffer, size, slot);
	return fence->flatten(buffer, size, fds, count);
	}

	status_t IGraphicBufferProducer::CancelBufferInput::unflatten(
	void const& buffer, size_t& size, int const& fds, size_t& count) {
	if (size < minFlattenedSize()) {
	return NO_MEMORY;
	}

	FlattenableUtils::read(buffer, size, slot);

	fence = new Fence();
	return fence->unflatten(buffer, size, fds, count);
	}

	////////////////////////////////////////////////////////////////////////

	size_t IGraphicBufferProducer::QueryOutput::getFlattenedSize() const {
	return sizeof(result) + sizeof(value);
	}

	status_t IGraphicBufferProducer::QueryOutput::flatten(void* buffer, size_t size) const {
	if (size < getFlattenedSize()) {
	return NO_MEMORY;
	}
	FlattenableUtils::write(buffer, size, result);
	FlattenableUtils::write(buffer, size, value);

	return NO_ERROR;
	}

	status_t IGraphicBufferProducer::QueryOutput::unflatten(void const* buffer, size_t size) {
	if (size < getFlattenedSize()) {
	return NO_MEMORY;
	}
	FlattenableUtils::read(buffer, size, result);
	FlattenableUtils::read(buffer, size, value);

	return NO_ERROR;
	}

	} // namespace android