Merge "Updates encoding/decoding of optional metadata" (67fbd47a) · Commits · e / os / android_frameworks_native

libs/gralloc/types/Gralloc4.cpp

+89 −34

Original line number	Original line	Diff line number	Diff line
	@@ -195,6 +195,35 @@ using ErrorHandler = void()(T);
	status_t encodeMetadataType(const MetadataType& input, OutputHidlVec* output);		status_t encodeMetadataType(const MetadataType& input, OutputHidlVec* output);
	status_t validateMetadataType(InputHidlVec* input, const MetadataType& expectedMetadataType);		status_t validateMetadataType(InputHidlVec* input, const MetadataType& expectedMetadataType);

			/**
			* Private helper functions
			*/
			template <class T>
			status_t encodeInteger(const T& input, OutputHidlVec* output) {
			static_assert(std::is_same<T, uint32_t>::value \|\| std::is_same<T, int32_t>::value \|\|
			std::is_same<T, uint64_t>::value \|\| std::is_same<T, int64_t>::value \|\|
			std::is_same<T, float>::value \|\| std::is_same<T, double>::value);
			if (!output) {
			return BAD_VALUE;
			}

			const uint8_t* tmp = reinterpret_cast<const uint8_t*>(&input);
			return output->encode(tmp, sizeof(input));
			}

			template <class T>
			status_t decodeInteger(InputHidlVec* input, T* output) {
			static_assert(std::is_same<T, uint32_t>::value \|\| std::is_same<T, int32_t>::value \|\|
			std::is_same<T, uint64_t>::value \|\| std::is_same<T, int64_t>::value \|\|
			std::is_same<T, float>::value \|\| std::is_same<T, double>::value);
			if (!output) {
			return BAD_VALUE;
			}

			uint8_t* tmp = reinterpret_cast<uint8_t*>(output);
			return input->decode(tmp, sizeof(*output));
			}

	/**		/**
	* encode/encodeMetadata are the main encoding functions. They take in T and uses the encodeHelper		* encode/encodeMetadata are the main encoding functions. They take in T and uses the encodeHelper
	* function to turn T into the hidl_vec byte stream.		* function to turn T into the hidl_vec byte stream.
	@@ -251,10 +280,45 @@ status_t encodeMetadata(const MetadataType& metadataType, const T& input, hidl_v
	template <class T>		template <class T>
	status_t encodeOptionalMetadata(const MetadataType& metadataType, const std::optional<T>& input,		status_t encodeOptionalMetadata(const MetadataType& metadataType, const std::optional<T>& input,
	hidl_vec<uint8_t>* output, EncodeHelper<T> encodeHelper) {		hidl_vec<uint8_t>* output, EncodeHelper<T> encodeHelper) {
	if (!input) {		OutputHidlVec outputHidlVec{output};
	return NO_ERROR;
			status_t err = encodeMetadataType(metadataType, &outputHidlVec);
			if (err) {
			return err;
	}		}
	return encodeMetadata(metadataType, *input, output, encodeHelper);
			err = encodeInteger<uint32_t>(input.has_value() ? 1 : 0, &outputHidlVec);
			if (err) {
			return err;
			}

			if (input) {
			err = encodeHelper(*input, &outputHidlVec);
			if (err) {
			return err;
			}
			}

			err = outputHidlVec.resize();
			if (err) {
			return err;
			}

			err = encodeMetadataType(metadataType, &outputHidlVec);
			if (err) {
			return err;
			}

			err = encodeInteger<uint32_t>(input.has_value() ? 1 : 0, &outputHidlVec);
			if (err) {
			return err;
			}

			if (input) {
			return encodeHelper(*input, &outputHidlVec);
			}

			return NO_ERROR;
	}		}

	/**		/**
	@@ -315,45 +379,36 @@ status_t decodeOptionalMetadata(const MetadataType& metadataType, const hidl_vec
	if (!output) {		if (!output) {
	return BAD_VALUE;		return BAD_VALUE;
	}		}
	if (input.size() <= 0) {
	output->reset();		InputHidlVec inputHidlVec{&input};
	return NO_ERROR;
	}		status_t err = validateMetadataType(&inputHidlVec, metadataType);
	T tmp;		if (err) {
	status_t err = decodeMetadata(metadataType, input, &tmp, decodeHelper);		return err;
	if (!err) {
	*output = tmp;
	}		}

			uint32_t present = 0;
			err = decodeInteger<uint32_t>(&inputHidlVec, &present);
			if (err) {
	return err;		return err;
	}		}

	/**		if (present) {
	* Private helper functions		T tmp;
	*/		err = decodeHelper(&inputHidlVec, &tmp);
	template <class T>		if (err) {
	status_t encodeInteger(const T& input, OutputHidlVec* output) {		return err;
	static_assert(std::is_same<T, uint32_t>::value \|\| std::is_same<T, int32_t>::value \|\|
	std::is_same<T, uint64_t>::value \|\| std::is_same<T, int64_t>::value \|\|
	std::is_same<T, float>::value \|\| std::is_same<T, double>::value);
	if (!output) {
	return BAD_VALUE;
	}		}

	const uint8_t* tmp = reinterpret_cast<const uint8_t*>(&input);		*output = tmp;
	return output->encode(tmp, sizeof(input));
	}		}

	template <class T>		err = inputHidlVec.hasRemainingData();
	status_t decodeInteger(InputHidlVec* input, T* output) {		if (err) {
	static_assert(std::is_same<T, uint32_t>::value \|\| std::is_same<T, int32_t>::value \|\|
	std::is_same<T, uint64_t>::value \|\| std::is_same<T, int64_t>::value \|\|
	std::is_same<T, float>::value \|\| std::is_same<T, double>::value);
	if (!output) {
	return BAD_VALUE;		return BAD_VALUE;
	}		}

	uint8_t* tmp = reinterpret_cast<uint8_t*>(output);		return NO_ERROR;
	return input->decode(tmp, sizeof(*output));
	}		}

	status_t encodeString(const std::string& input, OutputHidlVec* output) {		status_t encodeString(const std::string& input, OutputHidlVec* output) {