system/hwc3/Gralloc.cpp - device/generic/goldfish-opengl - Git at Google

 /*
  * Copyright (C) 2022 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 "Gralloc.h"

 #include <aidl/android/hardware/graphics/common/BufferUsage.h>
 #include <aidl/android/hardware/graphics/common/PlaneLayoutComponent.h>
 #include <aidl/android/hardware/graphics/common/PlaneLayoutComponentType.h>
 #include <drm_fourcc.h>
 #include <gralloctypes/Gralloc4.h>
 #include <log/log.h>
 #include <ui/GraphicBufferMapper.h>

 #include <algorithm>

 #include "Drm.h"

 using aidl::android::hardware::graphics::common::BufferUsage;
 using aidl::android::hardware::graphics::common::PlaneLayout;
 using aidl::android::hardware::graphics::common::PlaneLayoutComponent;
 using aidl::android::hardware::graphics::common::PlaneLayoutComponentType;
 using android::GraphicBufferMapper;
 using android::OK;
 using android::Rect;
 using android::status_t;

 namespace aidl::android::hardware::graphics::composer3::impl {

 std::optional<uint32_t> Gralloc::GetWidth(buffer_handle_t buffer) {
     uint64_t width = 0;
     status_t status = GraphicBufferMapper::get().getWidth(buffer, &width);
     if (status != OK) {
         return std::nullopt;
     }

     if (width > std::numeric_limits<uint32_t>::max()) {
         ALOGE("%s Width too large to cast to uint32_t: %ld", __FUNCTION__, width);
         return std::nullopt;
     }
     return static_cast<uint32_t>(width);
 }

 std::optional<uint32_t> Gralloc::GetHeight(buffer_handle_t buffer) {
     uint64_t height = 0;
     status_t status = GraphicBufferMapper::get().getHeight(buffer, &height);
     if (status != OK) {
         return std::nullopt;
     }

     if (height > std::numeric_limits<uint32_t>::max()) {
         ALOGE("%s Height too large to cast to uint32_t: %ld", __FUNCTION__, height);
         return std::nullopt;
     }
     return static_cast<uint32_t>(height);
 }

 std::optional<uint32_t> Gralloc::GetDrmFormat(buffer_handle_t buffer) {
     uint32_t format = 0;
     status_t status = GraphicBufferMapper::get().getPixelFormatFourCC(buffer, &format);
     if (status != OK) {
         return std::nullopt;
     }

     return format;
 }

 std::optional<std::vector<PlaneLayout>> Gralloc::GetPlaneLayouts(buffer_handle_t buffer) {
     std::vector<PlaneLayout> layouts;
     status_t status = GraphicBufferMapper::get().getPlaneLayouts(buffer, &layouts);
     if (status != OK) {
         return std::nullopt;
     }

     return layouts;
 }

 std::optional<uint32_t> Gralloc::GetMonoPlanarStrideBytes(buffer_handle_t buffer) {
     auto plane_layouts_opt = GetPlaneLayouts(buffer);
     if (!plane_layouts_opt) {
         return std::nullopt;
     }

     std::vector<PlaneLayout>& plane_layouts = *plane_layouts_opt;
     if (plane_layouts.size() != 1) {
         return std::nullopt;
     }

     if (plane_layouts[0].strideInBytes > std::numeric_limits<uint32_t>::max()) {
         ALOGE("%s strideInBytes too large to cast to uint32_t: %ld", __FUNCTION__,
               plane_layouts[0].strideInBytes);
         return std::nullopt;
     }
     return static_cast<uint32_t>(plane_layouts[0].strideInBytes);
 }

 std::optional<GrallocBuffer> Gralloc::Import(buffer_handle_t buffer) {
     buffer_handle_t imported_buffer;

     status_t status = GraphicBufferMapper::get().importBufferNoValidate(buffer, &imported_buffer);

     if (status != OK) {
         ALOGE("%s failed to import buffer: %d", __FUNCTION__, status);
         return std::nullopt;
     }
     return GrallocBuffer(this, imported_buffer);
 }

 void Gralloc::Release(buffer_handle_t buffer) {
     status_t status = GraphicBufferMapper::get().freeBuffer(buffer);

     if (status != OK) {
         ALOGE("%s failed to release buffer: %d", __FUNCTION__, status);
     }
 }

 std::optional<void*> Gralloc::Lock(buffer_handle_t buffer) {
     const auto buffer_usage = static_cast<uint64_t>(BufferUsage::CPU_READ_OFTEN) |
                               static_cast<uint64_t>(BufferUsage::CPU_WRITE_OFTEN);

     auto width_opt = GetWidth(buffer);
     if (!width_opt) {
         return std::nullopt;
     }

     auto height_opt = GetHeight(buffer);
     if (!height_opt) {
         return std::nullopt;
     }

     Rect buffer_region;
     buffer_region.left = 0;
     buffer_region.top = 0;
     // width = right - left
     buffer_region.right = static_cast<int32_t>(*width_opt);
     // height = bottom - top
     buffer_region.bottom = static_cast<int32_t>(*height_opt);

     void* data = nullptr;

     status_t status = GraphicBufferMapper::get().lock(buffer, buffer_usage, buffer_region, &data);

     if (status != OK) {
         ALOGE("%s failed to lock buffer: %d", __FUNCTION__, status);
         return std::nullopt;
     }

     return data;
 }

 std::optional<android_ycbcr> Gralloc::LockYCbCr(buffer_handle_t buffer) {
     auto format_opt = GetDrmFormat(buffer);
     if (!format_opt) {
         ALOGE("%s failed to check format of buffer", __FUNCTION__);
         return std::nullopt;
     }

     if (*format_opt != DRM_FORMAT_NV12 && *format_opt != DRM_FORMAT_NV21 &&
         *format_opt != DRM_FORMAT_YVU420) {
         ALOGE("%s called on non-ycbcr buffer", __FUNCTION__);
         return std::nullopt;
     }

     auto lock_opt = Lock(buffer);
     if (!lock_opt) {
         ALOGE("%s failed to lock buffer", __FUNCTION__);
         return std::nullopt;
     }

     auto plane_layouts_opt = GetPlaneLayouts(buffer);
     if (!plane_layouts_opt) {
         ALOGE("%s failed to get plane layouts", __FUNCTION__);
         return std::nullopt;
     }

     android_ycbcr buffer_ycbcr;
     buffer_ycbcr.y = nullptr;
     buffer_ycbcr.cb = nullptr;
     buffer_ycbcr.cr = nullptr;
     buffer_ycbcr.ystride = 0;
     buffer_ycbcr.cstride = 0;
     buffer_ycbcr.chroma_step = 0;

     for (const auto& plane_layout : *plane_layouts_opt) {
         for (const auto& plane_layout_component : plane_layout.components) {
             const auto& type = plane_layout_component.type;

             if (!::android::gralloc4::isStandardPlaneLayoutComponentType(type)) {
                 continue;
             }

             auto* component_data = reinterpret_cast<uint8_t*>(*lock_opt) +
                                    plane_layout.offsetInBytes +
                                    plane_layout_component.offsetInBits / 8;

             switch (static_cast<PlaneLayoutComponentType>(type.value)) {
                 case PlaneLayoutComponentType::Y:
                     buffer_ycbcr.y = component_data;
                     buffer_ycbcr.ystride = static_cast<size_t>(plane_layout.strideInBytes);
                     break;
                 case PlaneLayoutComponentType::CB:
                     buffer_ycbcr.cb = component_data;
                     buffer_ycbcr.cstride = static_cast<size_t>(plane_layout.strideInBytes);
                     buffer_ycbcr.chroma_step =
                         static_cast<size_t>(plane_layout.sampleIncrementInBits / 8);
                     break;
                 case PlaneLayoutComponentType::CR:
                     buffer_ycbcr.cr = component_data;
                     buffer_ycbcr.cstride = static_cast<size_t>(plane_layout.strideInBytes);
                     buffer_ycbcr.chroma_step =
                         static_cast<size_t>(plane_layout.sampleIncrementInBits / 8);
                     break;
                 default:
                     break;
             }
         }
     }

     return buffer_ycbcr;
 }

 void Gralloc::Unlock(buffer_handle_t buffer) {
     status_t status = GraphicBufferMapper::get().unlock(buffer);

     if (status != OK) {
         ALOGE("%s failed to unlock buffer %d", __FUNCTION__, status);
     }
 }

 GrallocBuffer::GrallocBuffer(Gralloc* gralloc, buffer_handle_t buffer)
     : gralloc_(gralloc), buffer_(buffer) {}

 GrallocBuffer::~GrallocBuffer() { Release(); }

 GrallocBuffer::GrallocBuffer(GrallocBuffer&& rhs) { *this = std::move(rhs); }

 GrallocBuffer& GrallocBuffer::operator=(GrallocBuffer&& rhs) {
     gralloc_ = rhs.gralloc_;
     buffer_ = rhs.buffer_;
     rhs.gralloc_ = nullptr;
     rhs.buffer_ = nullptr;
     return *this;
 }

 void GrallocBuffer::Release() {
     if (gralloc_ && buffer_) {
         gralloc_->Release(buffer_);
         gralloc_ = nullptr;
         buffer_ = nullptr;
     }
 }

 std::optional<GrallocBufferView> GrallocBuffer::Lock() {
     if (gralloc_ && buffer_) {
         auto format_opt = GetDrmFormat();
         if (!format_opt) {
             ALOGE("%s failed to check format of buffer", __FUNCTION__);
             return std::nullopt;
         }
         if (*format_opt != DRM_FORMAT_NV12 && *format_opt != DRM_FORMAT_NV21 &&
             *format_opt != DRM_FORMAT_YVU420) {
             auto locked_opt = gralloc_->Lock(buffer_);
             if (!locked_opt) {
                 return std::nullopt;
             }
             return GrallocBufferView(this, *locked_opt);
         } else {
             auto locked_ycbcr_opt = gralloc_->LockYCbCr(buffer_);
             if (!locked_ycbcr_opt) {
                 ALOGE("%s failed to lock ycbcr buffer", __FUNCTION__);
                 return std::nullopt;
             }
             return GrallocBufferView(this, *locked_ycbcr_opt);
         }
     }
     return std::nullopt;
 }

 void GrallocBuffer::Unlock() {
     if (gralloc_ && buffer_) {
         gralloc_->Unlock(buffer_);
     }
 }

 std::optional<uint32_t> GrallocBuffer::GetWidth() {
     if (gralloc_ && buffer_) {
         return gralloc_->GetWidth(buffer_);
     }
     return std::nullopt;
 }

 std::optional<uint32_t> GrallocBuffer::GetHeight() {
     if (gralloc_ && buffer_) {
         return gralloc_->GetHeight(buffer_);
     }
     return std::nullopt;
 }

 std::optional<uint32_t> GrallocBuffer::GetDrmFormat() {
     if (gralloc_ && buffer_) {
         return gralloc_->GetDrmFormat(buffer_);
     }
     return std::nullopt;
 }

 std::optional<std::vector<PlaneLayout>> GrallocBuffer::GetPlaneLayouts() {
     if (gralloc_ && buffer_) {
         return gralloc_->GetPlaneLayouts(buffer_);
     }
     return std::nullopt;
 }

 std::optional<uint32_t> GrallocBuffer::GetMonoPlanarStrideBytes() {
     if (gralloc_ && buffer_) {
         return gralloc_->GetMonoPlanarStrideBytes(buffer_);
     }
     return std::nullopt;
 }

 GrallocBufferView::GrallocBufferView(GrallocBuffer* buffer, void* raw)
     : gralloc_buffer_(buffer), locked_(raw) {}

 GrallocBufferView::GrallocBufferView(GrallocBuffer* buffer, android_ycbcr raw)
     : gralloc_buffer_(buffer), locked_ycbcr_(raw) {}

 GrallocBufferView::~GrallocBufferView() {
     if (gralloc_buffer_) {
         gralloc_buffer_->Unlock();
     }
 }

 GrallocBufferView::GrallocBufferView(GrallocBufferView&& rhs) { *this = std::move(rhs); }

 GrallocBufferView& GrallocBufferView::operator=(GrallocBufferView&& rhs) {
     std::swap(gralloc_buffer_, rhs.gralloc_buffer_);
     std::swap(locked_, rhs.locked_);
     std::swap(locked_ycbcr_, rhs.locked_ycbcr_);
     return *this;
 }

 const std::optional<void*> GrallocBufferView::Get() const { return locked_; }

 const std::optional<android_ycbcr>& GrallocBufferView::GetYCbCr() const { return locked_ycbcr_; }

 }  // namespace aidl::android::hardware::graphics::composer3::impl
	/*
	* Copyright (C) 2022 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 "Gralloc.h"

	#include <aidl/android/hardware/graphics/common/BufferUsage.h>
	#include <aidl/android/hardware/graphics/common/PlaneLayoutComponent.h>
	#include <aidl/android/hardware/graphics/common/PlaneLayoutComponentType.h>
	#include <drm_fourcc.h>
	#include <gralloctypes/Gralloc4.h>
	#include <log/log.h>
	#include <ui/GraphicBufferMapper.h>

	#include <algorithm>

	#include "Drm.h"

	using aidl::android::hardware::graphics::common::BufferUsage;
	using aidl::android::hardware::graphics::common::PlaneLayout;
	using aidl::android::hardware::graphics::common::PlaneLayoutComponent;
	using aidl::android::hardware::graphics::common::PlaneLayoutComponentType;
	using android::GraphicBufferMapper;
	using android::OK;
	using android::Rect;
	using android::status_t;

	namespace aidl::android::hardware::graphics::composer3::impl {

	std::optional<uint32_t> Gralloc::GetWidth(buffer_handle_t buffer) {
	uint64_t width = 0;
	status_t status = GraphicBufferMapper::get().getWidth(buffer, &width);
	if (status != OK) {
	return std::nullopt;
	}

	if (width > std::numeric_limits<uint32_t>::max()) {
	ALOGE("%s Width too large to cast to uint32_t: %ld", __FUNCTION__, width);
	return std::nullopt;
	}
	return static_cast<uint32_t>(width);
	}

	std::optional<uint32_t> Gralloc::GetHeight(buffer_handle_t buffer) {
	uint64_t height = 0;
	status_t status = GraphicBufferMapper::get().getHeight(buffer, &height);
	if (status != OK) {
	return std::nullopt;
	}

	if (height > std::numeric_limits<uint32_t>::max()) {
	ALOGE("%s Height too large to cast to uint32_t: %ld", __FUNCTION__, height);
	return std::nullopt;
	}
	return static_cast<uint32_t>(height);
	}

	std::optional<uint32_t> Gralloc::GetDrmFormat(buffer_handle_t buffer) {
	uint32_t format = 0;
	status_t status = GraphicBufferMapper::get().getPixelFormatFourCC(buffer, &format);
	if (status != OK) {
	return std::nullopt;
	}

	return format;
	}

	std::optional<std::vector<PlaneLayout>> Gralloc::GetPlaneLayouts(buffer_handle_t buffer) {
	std::vector<PlaneLayout> layouts;
	status_t status = GraphicBufferMapper::get().getPlaneLayouts(buffer, &layouts);
	if (status != OK) {
	return std::nullopt;
	}

	return layouts;
	}

	std::optional<uint32_t> Gralloc::GetMonoPlanarStrideBytes(buffer_handle_t buffer) {
	auto plane_layouts_opt = GetPlaneLayouts(buffer);
	if (!plane_layouts_opt) {
	return std::nullopt;
	}

	std::vector<PlaneLayout>& plane_layouts = *plane_layouts_opt;
	if (plane_layouts.size() != 1) {
	return std::nullopt;
	}

	if (plane_layouts[0].strideInBytes > std::numeric_limits<uint32_t>::max()) {
	ALOGE("%s strideInBytes too large to cast to uint32_t: %ld", __FUNCTION__,
	plane_layouts[0].strideInBytes);
	return std::nullopt;
	}
	return static_cast<uint32_t>(plane_layouts[0].strideInBytes);
	}

	std::optional<GrallocBuffer> Gralloc::Import(buffer_handle_t buffer) {
	buffer_handle_t imported_buffer;

	status_t status = GraphicBufferMapper::get().importBufferNoValidate(buffer, &imported_buffer);

	if (status != OK) {
	ALOGE("%s failed to import buffer: %d", __FUNCTION__, status);
	return std::nullopt;
	}
	return GrallocBuffer(this, imported_buffer);
	}

	void Gralloc::Release(buffer_handle_t buffer) {
	status_t status = GraphicBufferMapper::get().freeBuffer(buffer);

	if (status != OK) {
	ALOGE("%s failed to release buffer: %d", __FUNCTION__, status);
	}
	}

	std::optional<void*> Gralloc::Lock(buffer_handle_t buffer) {
	const auto buffer_usage = static_cast<uint64_t>(BufferUsage::CPU_READ_OFTEN) \|
	static_cast<uint64_t>(BufferUsage::CPU_WRITE_OFTEN);

	auto width_opt = GetWidth(buffer);
	if (!width_opt) {
	return std::nullopt;
	}

	auto height_opt = GetHeight(buffer);
	if (!height_opt) {
	return std::nullopt;
	}

	Rect buffer_region;
	buffer_region.left = 0;
	buffer_region.top = 0;
	// width = right - left
	buffer_region.right = static_cast<int32_t>(*width_opt);
	// height = bottom - top
	buffer_region.bottom = static_cast<int32_t>(*height_opt);

	void* data = nullptr;

	status_t status = GraphicBufferMapper::get().lock(buffer, buffer_usage, buffer_region, &data);

	if (status != OK) {
	ALOGE("%s failed to lock buffer: %d", __FUNCTION__, status);
	return std::nullopt;
	}

	return data;
	}

	std::optional<android_ycbcr> Gralloc::LockYCbCr(buffer_handle_t buffer) {
	auto format_opt = GetDrmFormat(buffer);
	if (!format_opt) {
	ALOGE("%s failed to check format of buffer", __FUNCTION__);
	return std::nullopt;
	}

	if (format_opt != DRM_FORMAT_NV12 && format_opt != DRM_FORMAT_NV21 &&
	*format_opt != DRM_FORMAT_YVU420) {
	ALOGE("%s called on non-ycbcr buffer", __FUNCTION__);
	return std::nullopt;
	}

	auto lock_opt = Lock(buffer);
	if (!lock_opt) {
	ALOGE("%s failed to lock buffer", __FUNCTION__);
	return std::nullopt;
	}

	auto plane_layouts_opt = GetPlaneLayouts(buffer);
	if (!plane_layouts_opt) {
	ALOGE("%s failed to get plane layouts", __FUNCTION__);
	return std::nullopt;
	}

	android_ycbcr buffer_ycbcr;
	buffer_ycbcr.y = nullptr;
	buffer_ycbcr.cb = nullptr;
	buffer_ycbcr.cr = nullptr;
	buffer_ycbcr.ystride = 0;
	buffer_ycbcr.cstride = 0;
	buffer_ycbcr.chroma_step = 0;

	for (const auto& plane_layout : *plane_layouts_opt) {
	for (const auto& plane_layout_component : plane_layout.components) {
	const auto& type = plane_layout_component.type;

	if (!::android::gralloc4::isStandardPlaneLayoutComponentType(type)) {
	continue;
	}

	auto* component_data = reinterpret_cast<uint8_t>(lock_opt) +
	plane_layout.offsetInBytes +
	plane_layout_component.offsetInBits / 8;

	switch (static_cast<PlaneLayoutComponentType>(type.value)) {
	case PlaneLayoutComponentType::Y:
	buffer_ycbcr.y = component_data;
	buffer_ycbcr.ystride = static_cast<size_t>(plane_layout.strideInBytes);
	break;
	case PlaneLayoutComponentType::CB:
	buffer_ycbcr.cb = component_data;
	buffer_ycbcr.cstride = static_cast<size_t>(plane_layout.strideInBytes);
	buffer_ycbcr.chroma_step =
	static_cast<size_t>(plane_layout.sampleIncrementInBits / 8);
	break;
	case PlaneLayoutComponentType::CR:
	buffer_ycbcr.cr = component_data;
	buffer_ycbcr.cstride = static_cast<size_t>(plane_layout.strideInBytes);
	buffer_ycbcr.chroma_step =
	static_cast<size_t>(plane_layout.sampleIncrementInBits / 8);
	break;
	default:
	break;
	}
	}
	}

	return buffer_ycbcr;
	}

	void Gralloc::Unlock(buffer_handle_t buffer) {
	status_t status = GraphicBufferMapper::get().unlock(buffer);

	if (status != OK) {
	ALOGE("%s failed to unlock buffer %d", __FUNCTION__, status);
	}
	}

	GrallocBuffer::GrallocBuffer(Gralloc* gralloc, buffer_handle_t buffer)
	: gralloc_(gralloc), buffer_(buffer) {}

	GrallocBuffer::~GrallocBuffer() { Release(); }

	GrallocBuffer::GrallocBuffer(GrallocBuffer&& rhs) { *this = std::move(rhs); }

	GrallocBuffer& GrallocBuffer::operator=(GrallocBuffer&& rhs) {
	gralloc_ = rhs.gralloc_;
	buffer_ = rhs.buffer_;
	rhs.gralloc_ = nullptr;
	rhs.buffer_ = nullptr;
	return *this;
	}

	void GrallocBuffer::Release() {
	if (gralloc_ && buffer_) {
	gralloc_->Release(buffer_);
	gralloc_ = nullptr;
	buffer_ = nullptr;
	}
	}

	std::optional<GrallocBufferView> GrallocBuffer::Lock() {
	if (gralloc_ && buffer_) {
	auto format_opt = GetDrmFormat();
	if (!format_opt) {
	ALOGE("%s failed to check format of buffer", __FUNCTION__);
	return std::nullopt;
	}
	if (format_opt != DRM_FORMAT_NV12 && format_opt != DRM_FORMAT_NV21 &&
	*format_opt != DRM_FORMAT_YVU420) {
	auto locked_opt = gralloc_->Lock(buffer_);
	if (!locked_opt) {
	return std::nullopt;
	}
	return GrallocBufferView(this, *locked_opt);
	} else {
	auto locked_ycbcr_opt = gralloc_->LockYCbCr(buffer_);
	if (!locked_ycbcr_opt) {
	ALOGE("%s failed to lock ycbcr buffer", __FUNCTION__);
	return std::nullopt;
	}
	return GrallocBufferView(this, *locked_ycbcr_opt);
	}
	}
	return std::nullopt;
	}

	void GrallocBuffer::Unlock() {
	if (gralloc_ && buffer_) {
	gralloc_->Unlock(buffer_);
	}
	}

	std::optional<uint32_t> GrallocBuffer::GetWidth() {
	if (gralloc_ && buffer_) {
	return gralloc_->GetWidth(buffer_);
	}
	return std::nullopt;
	}

	std::optional<uint32_t> GrallocBuffer::GetHeight() {
	if (gralloc_ && buffer_) {
	return gralloc_->GetHeight(buffer_);
	}
	return std::nullopt;
	}

	std::optional<uint32_t> GrallocBuffer::GetDrmFormat() {
	if (gralloc_ && buffer_) {
	return gralloc_->GetDrmFormat(buffer_);
	}
	return std::nullopt;
	}

	std::optional<std::vector<PlaneLayout>> GrallocBuffer::GetPlaneLayouts() {
	if (gralloc_ && buffer_) {
	return gralloc_->GetPlaneLayouts(buffer_);
	}
	return std::nullopt;
	}

	std::optional<uint32_t> GrallocBuffer::GetMonoPlanarStrideBytes() {
	if (gralloc_ && buffer_) {
	return gralloc_->GetMonoPlanarStrideBytes(buffer_);
	}
	return std::nullopt;
	}

	GrallocBufferView::GrallocBufferView(GrallocBuffer* buffer, void* raw)
	: gralloc_buffer_(buffer), locked_(raw) {}

	GrallocBufferView::GrallocBufferView(GrallocBuffer* buffer, android_ycbcr raw)
	: gralloc_buffer_(buffer), locked_ycbcr_(raw) {}

	GrallocBufferView::~GrallocBufferView() {
	if (gralloc_buffer_) {
	gralloc_buffer_->Unlock();
	}
	}

	GrallocBufferView::GrallocBufferView(GrallocBufferView&& rhs) { *this = std::move(rhs); }

	GrallocBufferView& GrallocBufferView::operator=(GrallocBufferView&& rhs) {
	std::swap(gralloc_buffer_, rhs.gralloc_buffer_);
	std::swap(locked_, rhs.locked_);
	std::swap(locked_ycbcr_, rhs.locked_ycbcr_);
	return *this;
	}

	const std::optional<void*> GrallocBufferView::Get() const { return locked_; }

	const std::optional<android_ycbcr>& GrallocBufferView::GetYCbCr() const { return locked_ycbcr_; }

	} // namespace aidl::android::hardware::graphics::composer3::impl