Add BufferQueueConverter library (ab614c44) · Commits · e / os / platform_frameworks_native

libs/bufferqueueconverter/Android.bp

0 → 100644

+28 −0

Original line number	Diff line number	Diff line
		cc_library_headers {
		name: "libbufferqueueconverter_headers",
		vendor_available: true,
		export_include_dirs: ["include"],
		}

		cc_library_shared {
		name: "libbufferqueueconverter",
		vendor_available: true,
		vndk: {
		enabled: true,
		},
		double_loadable: true,

		srcs: [
		"BufferQueueConverter.cpp",
		],

		shared_libs: [
		"libgui",
		"libui",
		"libutils",
		"libbinder",
		"libbase",
		"liblog",
		],
		export_include_dirs: ["include"],
		}

libs/bufferqueueconverter/BufferQueueConverter.cpp

0 → 100644

+74 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2020 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 <gui/Surface.h>
		#include <gui/bufferqueue/2.0/H2BGraphicBufferProducer.h>

		#include "include/bufferqueueconverter/BufferQueueConverter.h"


		using ::android::Surface;
		using ::android::IGraphicBufferProducer;
		using ::android::hardware::graphics::bufferqueue::V2_0::utils::H2BGraphicBufferProducer;


		namespace android {

		struct SurfaceHolder {
		sp<Surface> surface;
		SurfaceHolder(const sp<Surface>& s) : surface(s) {}
		};

		/**
		* Custom deleter for SurfaceHolder unique pointer
		*/
		void destroySurfaceHolder(SurfaceHolder* surfaceHolder) {
		delete surfaceHolder;
		}


		SurfaceHolderUniquePtr getSurfaceFromHGBP(const sp<HGraphicBufferProducer>& token) {
		if (token == nullptr) {
		ALOGE("Passed IGraphicBufferProducer handle is invalid.");
		return SurfaceHolderUniquePtr(nullptr, nullptr);
		}

		sp<IGraphicBufferProducer> bufferProducer = new H2BGraphicBufferProducer(token);
		if (bufferProducer == nullptr) {
		ALOGE("Failed to get IGraphicBufferProducer.");
		return SurfaceHolderUniquePtr(nullptr, nullptr);
		}

		sp<Surface> newSurface(new Surface(bufferProducer, true));
		if (newSurface == nullptr) {
		ALOGE("Failed to create Surface from HGBP.");
		return SurfaceHolderUniquePtr(nullptr, nullptr);
		}

		return SurfaceHolderUniquePtr(new SurfaceHolder(newSurface), destroySurfaceHolder);
		}


		ANativeWindow* getNativeWindow(SurfaceHolder* handle) {
		if (handle == nullptr) {
		ALOGE("SurfaceHolder is invalid.");
		return nullptr;
		}

		return static_cast<ANativeWindow*>(handle->surface.get());
		}

		} // namespace android

libs/bufferqueueconverter/include/bufferqueueconverter/BufferQueueConverter.h

0 → 100644

+58 −0

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

		#ifndef ANDROID_BUFFER_QUEUE_CONVERTER_H
		#define ANDROID_BUFFER_QUEUE_CONVERTER_H

		#include <gui/IGraphicBufferProducer.h>
		#include <android/native_window.h>

		using ::android::sp;
		using HGraphicBufferProducer =
		::android::hardware::graphics::bufferqueue::V2_0::IGraphicBufferProducer;

		namespace android {
		/**
		* Opaque handle for a data structure holding Surface.
		*/
		typedef struct SurfaceHolder SurfaceHolder;

		/**
		* SurfaceHolder unique pointer type
		*/
		using SurfaceHolderUniquePtr = std::unique_ptr<SurfaceHolder, void()(SurfaceHolder)>;

		/**
		* Returns a SurfaceHolder that wraps a Surface generated from a given HGBP.
		*
		* @param token Hardware IGraphicBufferProducer to create a
		* Surface.
		* @return SurfaceHolder Unique pointer to created SurfaceHolder object.
		*/
		SurfaceHolderUniquePtr getSurfaceFromHGBP(const sp<HGraphicBufferProducer>& token);

		/**
		* Returns ANativeWindow pointer from a given SurfaceHolder. Returned
		* pointer is valid only while the containing SurfaceHolder is alive.
		*
		* @param surfaceHolder SurfaceHolder to generate a native window.
		* @return ANativeWindow* a pointer to a generated native window.
		*/
		ANativeWindow* getNativeWindow(SurfaceHolder* surfaceHolder);

		} // namespace android

		#endif // ANDROID_BUFFER_QUEUE_CONVERTER_H

services/automotive/display/include/CarWindowService.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -55,7 +55,7 @@ private:
		sp<android::SurfaceComposerClient> mSurfaceComposerClient;
		sp<android::SurfaceControl> mSurfaceControl;
		DisplayConfig mDpyConfig;
		DisplayState mDpyState;
		ui::DisplayState mDpyState;
		};
		} // namespace implementation
		} // namespace V1_0