[Lut NDK] Add new ASurfaceTransaction_setLuts api. (01e9f30b) · Commits · e / os / android_frameworks_native

include/android/display_luts.h

0 → 100644

+163 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2024 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.
		*/

		/**
		* @addtogroup NativeActivity Native Activity
		* @{
		*/

		/**
		* @file display_luts.h
		*/
		#pragma once

		#include <inttypes.h>

		__BEGIN_DECLS

		/**
		* The dimension of the lut
		*/
		enum ADisplayLuts_Dimension : int32_t {
		ADISPLAYLUTS_ONE_DIMENSION = 1,
		ADISPLAYLUTS_THREE_DIMENSION = 3,
		};

		/**
		* The sampling key used by the lut
		*/
		enum ADisplayLuts_SamplingKey : int32_t {
		ADISPLAYLUTS_SAMPLINGKEY_RGB = 0,
		ADISPLAYLUTS_SAMPLINGKEY_MAX_RGB = 1,
		};

		/**
		* Used to get and set display luts entry
		*/
		typedef struct ADisplayLutsEntry ADisplayLutsEntry;

		/**
		* Used to get and set display luts
		*/
		typedef struct ADisplayLuts ADisplayLuts;

		/**
		* Creates a \a ADisplayLutsEntry entry.
		*
		* You are responsible for mamanging the memory of the returned object.
		* Always call \a ADisplayLutsEntry_destroy to release it after use.
		*
		* Functions like \a ADisplayLuts_set create their own copies of entries,
		* therefore they don't take the ownership of the instance created by
		* \a ADisplayLutsEntry_create.
		*
		* @param buffer The lut raw buffer. The function creates a copy of it and does not need to
		* outlive the life of the ADisplayLutsEntry.
		* @param length The length of lut raw buffer
		* @param dimension The dimension of the lut. see \a ADisplayLuts_Dimension
		* @param key The sampling key used by the lut. see \a ADisplayLuts_SamplingKey
		* @return a new \a ADisplayLutsEntry instance.
		*/
		ADisplayLutsEntry* _Nonnull ADisplayLutsEntry_createEntry(float* _Nonnull buffer,
		int32_t length, int32_t dimension, int32_t key) __INTRODUCED_IN(36);

		/**
		* Destroy the \a ADisplayLutsEntry instance.
		*
		* @param entry The entry to be destroyed
		*/
		void ADisplayLutsEntry_destroy(ADisplayLutsEntry* _Nullable entry) __INTRODUCED_IN(36);

		/**
		* Gets the dimension of the entry.
		*
		* The function is only valid for the lifetime of the `entry`.
		*
		* @param entry The entry to query
		* @return the dimension of the lut
		*/
		ADisplayLuts_Dimension ADisplayLutsEntry_getDimension(const ADisplayLutsEntry* _Nonnull entry)
		__INTRODUCED_IN(36);

		/**
		* Gets the size for each dimension of the entry.
		*
		* The function is only valid for the lifetime of the `entry`.
		*
		* @param entry The entry to query
		* @return the size of each dimension of the lut
		*/
		int32_t ADisplayLutsEntry_getSize(const ADisplayLutsEntry* _Nonnull entry)
		__INTRODUCED_IN(36);

		/**
		* Gets the sampling key used by the entry.
		*
		* The function is only valid for the lifetime of the `entry`.
		*
		* @param entry The entry to query
		* @return the sampling key used by the lut
		*/
		ADisplayLuts_SamplingKey ADisplayLutsEntry_getSamplingKey(const ADisplayLutsEntry* _Nonnull entry)
		__INTRODUCED_IN(36);

		/**
		* Gets the lut buffer of the entry.
		*
		* The function is only valid for the lifetime of the `entry`.
		*
		* @param entry The entry to query
		* @return a pointer to the raw lut buffer
		*/
		const float* _Nonnull ADisplayLutsEntry_getBuffer(const ADisplayLutsEntry* _Nonnull entry)
		__INTRODUCED_IN(36);

		/**
		* Creates a \a ADisplayLuts instance.
		*
		* You are responsible for mamanging the memory of the returned object.
		* Always call \a ADisplayLuts_destroy to release it after use. E.g., after calling
		* the function \a ASurfaceTransaction_setLuts.
		*
		* @return a new \a ADisplayLuts instance
		*/
		ADisplayLuts* _Nonnull ADisplayLuts_create() __INTRODUCED_IN(36);

		/**
		* Sets Luts in order to be applied.
		*
		* The function accepts a single 1D Lut, or a single 3D Lut or both 1D and 3D Lut in order.
		* And the function will replace any previously set lut(s).
		* If you want to clear the previously set lut(s), set `entries` to be nullptr,
		* and `numEntries` will be internally ignored.
		*
		* @param luts the pointer of the \a ADisplayLuts instance
		* @param entries the pointer of the array of lut entries to be applied
		* @param numEntries the number of lut entries. The value should be either 1 or 2.
		*/
		void ADisplayLuts_setEntries(ADisplayLuts* _Nonnull luts,
		ADisplayLutsEntry* _Nullable *_Nullable entries, int32_t numEntries) __INTRODUCED_IN(36);

		/**
		* Deletes the \a ADisplayLuts instance.
		*
		* @param luts The luts to be destroyed
		*/
		void ADisplayLuts_destroy(ADisplayLuts* _Nullable luts) __INTRODUCED_IN(36);

		__END_DECLS

		/** @} */
		No newline at end of file

include/android/surface_control.h

+18 −0

Original line number	Diff line number	Diff line
		@@ -28,6 +28,7 @@

		#include <sys/cdefs.h>

		#include <android/display_luts.h>
		#include <android/choreographer.h>
		#include <android/data_space.h>
		#include <android/hardware_buffer.h>
		@@ -712,6 +713,23 @@ void ASurfaceTransaction_setDesiredHdrHeadroom(ASurfaceTransaction* _Nonnull tra
		float desiredHeadroom)
		__INTRODUCED_IN(__ANDROID_API_V__);

		/**
		* Sets the Lut(s) to be applied for the layer.
		*
		* The function makes a deep copy of the provided `luts`.
		* Any modifications made to the `luts` object after calling this function
		* will not affect the Lut(s) applied to the layer.
		*
		* @param surface_control The layer where Lut(s) is being applied
		* @param luts The Lut(s) to be applied
		*
		* Available since API level 36.
		*/
		void ASurfaceTransaction_setLuts(ASurfaceTransaction* _Nonnull transaction,
		ASurfaceControl* _Nonnull surface_control,
		const struct ADisplayLuts* _Nullable luts)
		__INTRODUCED_IN(36);

		/**
		* Same as ASurfaceTransaction_setFrameRateWithChangeStrategy(transaction, surface_control,
		* frameRate, compatibility, ANATIVEWINDOW_CHANGE_FRAME_RATE_ONLY_IF_SEAMLESS).

include/private/display_luts_private.h

0 → 100644

+65 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2024 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.
		*/

		#pragma once

		#include <stdint.h>
		#include <vector>
		#include <utils/RefBase.h>

		using namespace android;

		__BEGIN_DECLS

		struct ADisplayLutsEntry_buffer {
		std::vector<float> data;
		};

		struct ADisplayLutsEntry_properties {
		int32_t dimension;
		int32_t size;
		int32_t samplingKey;
		};

		struct ADisplayLutsEntry: public RefBase {
		struct ADisplayLutsEntry_buffer buffer;
		struct ADisplayLutsEntry_properties properties;
		ADisplayLutsEntry() {}

		// copy constructor
		ADisplayLutsEntry(const ADisplayLutsEntry& other) :
		buffer(other.buffer),
		properties(other.properties) {}

		// copy operator
		ADisplayLutsEntry& operator=(const ADisplayLutsEntry& other) {
		if (this != &other) { // Protect against self-assignment
		buffer = other.buffer;
		properties = other.properties;
		}
		return *this;
		}
		};

		struct ADisplayLuts: public RefBase {
		int32_t totalBufferSize;
		std::vector<int32_t> offsets;
		std::vector<sp<ADisplayLutsEntry>> entries;

		ADisplayLuts() : totalBufferSize(0) {}
		};

		__END_DECLS
		No newline at end of file