Merge "libgralloctypes: support encode BufferDescriptorInfo" (366d217b) · Commits · e / os / android_frameworks_native-old

libs/gralloc/types/Gralloc4.cpp

+175 −67

Original line number	Diff line number	Diff line
		@@ -42,6 +42,7 @@ using aidl::android::hardware::graphics::common::Smpte2086;
		using aidl::android::hardware::graphics::common::StandardMetadataType;
		using aidl::android::hardware::graphics::common::XyColor;

		using BufferDescriptorInfo = android::hardware::graphics::mapper::V4_0::IMapper::BufferDescriptorInfo;
		using MetadataType = android::hardware::graphics::mapper::V4_0::IMapper::MetadataType;

		namespace android {
		@@ -195,15 +196,32 @@ status_t encodeMetadataType(const MetadataType& input, OutputHidlVec* output);
		status_t validateMetadataType(InputHidlVec* input, const MetadataType& expectedMetadataType);

		/**
		* encode is the main encoding function. It takes in T and uses the encodeHelper function to turn T
		* into the hidl_vec byte stream.
		* 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.
		*
		* This function first calls the encodeHelper function to determine how large the hidl_vec
		* needs to be. It resizes the hidl_vec. Finally, it reruns the encodeHelper function which
		* These functions first call the encodeHelper function to determine how large the hidl_vec
		* needs to be. They resize the hidl_vec. Finally, it reruns the encodeHelper function which
		* encodes T into the hidl_vec byte stream.
		*/
		template <class T>
		status_t encode(const MetadataType& metadataType, const T& input, hidl_vec<uint8_t>* output,
		status_t encode(const T& input, hidl_vec<uint8_t>* output, EncodeHelper<T> encodeHelper) {
		OutputHidlVec outputHidlVec{output};

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

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

		return encodeHelper(input, &outputHidlVec);
		}

		template <class T>
		status_t encodeMetadata(const MetadataType& metadataType, const T& input, hidl_vec<uint8_t>* output,
		EncodeHelper<T> encodeHelper) {
		OutputHidlVec outputHidlVec{output};

		@@ -231,21 +249,42 @@ status_t encode(const MetadataType& metadataType, const T& input, hidl_vec<uint8
		}

		template <class T>
		status_t encodeOptional(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) {
		if (!input) {
		return NO_ERROR;
		}
		return encode(metadataType, *input, output, encodeHelper);
		return encodeMetadata(metadataType, *input, output, encodeHelper);
		}

		/**
		* decode is the main decode function. It takes in a hidl_vec and uses the decodeHelper function to
		* turn the hidl_vec byte stream into T. If an error occurs, the errorHandler function cleans up
		* T.
		* decode/decodeMetadata are the main decoding functions. They take in a hidl_vec and use the
		* decodeHelper function to turn the hidl_vec byte stream into T. If an error occurs, the
		* errorHandler function cleans up T.
		*/
		template <class T>
		status_t decode(const MetadataType& metadataType, const hidl_vec<uint8_t>& input, T* output,
		status_t decode(const hidl_vec<uint8_t>& input, T* output, DecodeHelper<T> decodeHelper,
		ErrorHandler<T> errorHandler = nullptr) {
		InputHidlVec inputHidlVec{&input};

		status_t err = decodeHelper(&inputHidlVec, output);
		if (err) {
		return err;
		}

		err = inputHidlVec.hasRemainingData();
		if (err) {
		if (errorHandler) {
		errorHandler(output);
		}
		return BAD_VALUE;
		}

		return NO_ERROR;
		}

		template <class T>
		status_t decodeMetadata(const MetadataType& metadataType, const hidl_vec<uint8_t>& input, T* output,
		DecodeHelper<T> decodeHelper, ErrorHandler<T> errorHandler = nullptr) {
		InputHidlVec inputHidlVec{&input};

		@@ -271,7 +310,7 @@ status_t decode(const MetadataType& metadataType, const hidl_vec<uint8_t>& input
		}

		template <class T>
		status_t decodeOptional(const MetadataType& metadataType, const hidl_vec<uint8_t>& input,
		status_t decodeOptionalMetadata(const MetadataType& metadataType, const hidl_vec<uint8_t>& input,
		std::optional<T>* output, DecodeHelper<T> decodeHelper) {
		if (!output) {
		return BAD_VALUE;
		@@ -281,7 +320,7 @@ status_t decodeOptional(const MetadataType& metadataType, const hidl_vec<uint8_t
		return NO_ERROR;
		}
		T tmp;
		status_t err = decode(metadataType, input, &tmp, decodeHelper);
		status_t err = decodeMetadata(metadataType, input, &tmp, decodeHelper);
		if (!err) {
		*output = tmp;
		}
		@@ -520,6 +559,66 @@ status_t decodeRect(InputHidlVec* input, Rect* output) {
		return decodeInteger<int32_t>(input, &output->bottom);
		}

		status_t encodeBufferDescriptorInfoHelper(const BufferDescriptorInfo& input,
		OutputHidlVec* output) {
		status_t err = encodeString(input.name, output);
		if (err) {
		return err;
		}
		err = encodeInteger<uint32_t>(input.width, output);
		if (err) {
		return err;
		}
		err = encodeInteger<uint32_t>(input.height, output);
		if (err) {
		return err;
		}
		err = encodeInteger<uint32_t>(input.layerCount, output);
		if (err) {
		return err;
		}
		err = encodeInteger<int32_t>(static_cast<int32_t>(input.format), output);
		if (err) {
		return err;
		}
		err = encodeInteger<uint64_t>(input.usage, output);
		if (err) {
		return err;
		}
		return encodeInteger<uint64_t>(input.reservedSize, output);
		}

		status_t decodeBufferDescriptorInfoHelper(InputHidlVec* input, BufferDescriptorInfo* output) {
		std::string name;
		status_t err = decodeString(input, &name);
		if (err) {
		return err;
		}
		output->name = name;

		err = decodeInteger<uint32_t>(input, &output->width);
		if (err) {
		return err;
		}
		err = decodeInteger<uint32_t>(input, &output->height);
		if (err) {
		return err;
		}
		err = decodeInteger<uint32_t>(input, &output->layerCount);
		if (err) {
		return err;
		}
		err = decodeInteger<int32_t>(input, reinterpret_cast<int32_t*>(&output->format));
		if (err) {
		return err;
		}
		err = decodeInteger<uint64_t>(input, &output->usage);
		if (err) {
		return err;
		}
		return decodeInteger<uint64_t>(input, &output->reservedSize);
		}

		status_t encodePlaneLayoutComponent(const PlaneLayoutComponent& input, OutputHidlVec* output) {
		if (!output) {
		return BAD_VALUE;
		@@ -799,260 +898,269 @@ status_t decodeCta861_3Helper(InputHidlVec* inputHidlVec, Cta861_3* outCta861_3)
		/**
		* Public API functions
		*/
		status_t encodeBufferDescriptorInfo(const BufferDescriptorInfo& bufferDescriptorInfo,
		hidl_vec<uint8_t>* outBufferDescriptorInfo) {
		return encode(bufferDescriptorInfo, outBufferDescriptorInfo, encodeBufferDescriptorInfoHelper);
		}

		status_t decodeBufferDescriptorInfo(const hidl_vec<uint8_t>& bufferDescriptorInfo,
		BufferDescriptorInfo* outBufferDescriptorInfo) {
		return decode(bufferDescriptorInfo, outBufferDescriptorInfo, decodeBufferDescriptorInfoHelper);
		}

		status_t encodeBufferId(uint64_t bufferId, hidl_vec<uint8_t>* outBufferId) {
		return encode(MetadataType_BufferId, bufferId, outBufferId, encodeInteger);
		return encodeMetadata(MetadataType_BufferId, bufferId, outBufferId, encodeInteger);
		}

		status_t decodeBufferId(const hidl_vec<uint8_t>& bufferId, uint64_t* outBufferId) {
		return decode(MetadataType_BufferId, bufferId, outBufferId, decodeInteger);
		return decodeMetadata(MetadataType_BufferId, bufferId, outBufferId, decodeInteger);
		}

		status_t encodeName(const std::string& name, hidl_vec<uint8_t>* outName) {
		return encode(MetadataType_Name, name, outName, encodeString);
		return encodeMetadata(MetadataType_Name, name, outName, encodeString);
		}

		status_t decodeName(const hidl_vec<uint8_t>& name, std::string* outName) {
		return decode(MetadataType_Name, name, outName, decodeString);
		return decodeMetadata(MetadataType_Name, name, outName, decodeString);
		}

		status_t encodeWidth(uint64_t width, hidl_vec<uint8_t>* outWidth) {
		return encode(MetadataType_Width, width, outWidth, encodeInteger);
		return encodeMetadata(MetadataType_Width, width, outWidth, encodeInteger);
		}

		status_t decodeWidth(const hidl_vec<uint8_t>& width, uint64_t* outWidth) {
		return decode(MetadataType_Width, width, outWidth, decodeInteger);
		return decodeMetadata(MetadataType_Width, width, outWidth, decodeInteger);
		}

		status_t encodeHeight(uint64_t height, hidl_vec<uint8_t>* outHeight) {
		return encode(MetadataType_Height, height, outHeight, encodeInteger);
		return encodeMetadata(MetadataType_Height, height, outHeight, encodeInteger);
		}

		status_t decodeHeight(const hidl_vec<uint8_t>& height, uint64_t* outHeight) {
		return decode(MetadataType_Height, height, outHeight, decodeInteger);
		return decodeMetadata(MetadataType_Height, height, outHeight, decodeInteger);
		}

		status_t encodeLayerCount(uint64_t layerCount, hidl_vec<uint8_t>* outLayerCount) {
		return encode(MetadataType_LayerCount, layerCount, outLayerCount, encodeInteger);
		return encodeMetadata(MetadataType_LayerCount, layerCount, outLayerCount, encodeInteger);
		}

		status_t decodeLayerCount(const hidl_vec<uint8_t>& layerCount, uint64_t* outLayerCount) {
		return decode(MetadataType_LayerCount, layerCount, outLayerCount, decodeInteger);
		return decodeMetadata(MetadataType_LayerCount, layerCount, outLayerCount, decodeInteger);
		}

		status_t encodePixelFormatRequested(const hardware::graphics::common::V1_2::PixelFormat& pixelFormatRequested,
		hidl_vec<uint8_t>* outPixelFormatRequested) {
		return encode(MetadataType_PixelFormatRequested, static_cast<int32_t>(pixelFormatRequested),
		return encodeMetadata(MetadataType_PixelFormatRequested, static_cast<int32_t>(pixelFormatRequested),
		outPixelFormatRequested, encodeInteger);
		}

		status_t decodePixelFormatRequested(const hidl_vec<uint8_t>& pixelFormatRequested,
		hardware::graphics::common::V1_2::PixelFormat* outPixelFormatRequested) {
		return decode(MetadataType_PixelFormatRequested, pixelFormatRequested,
		return decodeMetadata(MetadataType_PixelFormatRequested, pixelFormatRequested,
		reinterpret_cast<int32_t*>(outPixelFormatRequested), decodeInteger);
		}

		status_t encodePixelFormatFourCC(uint32_t pixelFormatFourCC, hidl_vec<uint8_t>* outPixelFormatFourCC) {
		return encode(MetadataType_PixelFormatFourCC, pixelFormatFourCC, outPixelFormatFourCC,
		return encodeMetadata(MetadataType_PixelFormatFourCC, pixelFormatFourCC, outPixelFormatFourCC,
		encodeInteger);
		}

		status_t decodePixelFormatFourCC(const hidl_vec<uint8_t>& pixelFormatFourCC, uint32_t* outPixelFormatFourCC) {
		return decode(MetadataType_PixelFormatFourCC, pixelFormatFourCC, outPixelFormatFourCC,
		return decodeMetadata(MetadataType_PixelFormatFourCC, pixelFormatFourCC, outPixelFormatFourCC,
		decodeInteger);
		}

		status_t encodePixelFormatModifier(uint64_t pixelFormatModifier, hidl_vec<uint8_t>* outPixelFormatModifier) {
		return encode(MetadataType_PixelFormatModifier, pixelFormatModifier, outPixelFormatModifier,
		return encodeMetadata(MetadataType_PixelFormatModifier, pixelFormatModifier, outPixelFormatModifier,
		encodeInteger);
		}

		status_t decodePixelFormatModifier(const hidl_vec<uint8_t>& pixelFormatModifier, uint64_t* outPixelFormatModifier) {
		return decode(MetadataType_PixelFormatModifier, pixelFormatModifier, outPixelFormatModifier,
		return decodeMetadata(MetadataType_PixelFormatModifier, pixelFormatModifier, outPixelFormatModifier,
		decodeInteger);
		}

		status_t encodeUsage(uint64_t usage, hidl_vec<uint8_t>* outUsage) {
		return encode(MetadataType_Usage, usage, outUsage, encodeInteger);
		return encodeMetadata(MetadataType_Usage, usage, outUsage, encodeInteger);
		}

		status_t decodeUsage(const hidl_vec<uint8_t>& usage, uint64_t* outUsage) {
		return decode(MetadataType_Usage, usage, outUsage, decodeInteger);
		return decodeMetadata(MetadataType_Usage, usage, outUsage, decodeInteger);
		}

		status_t encodeAllocationSize(uint64_t allocationSize, hidl_vec<uint8_t>* outAllocationSize) {
		return encode(MetadataType_AllocationSize, allocationSize, outAllocationSize, encodeInteger);
		return encodeMetadata(MetadataType_AllocationSize, allocationSize, outAllocationSize, encodeInteger);
		}

		status_t decodeAllocationSize(const hidl_vec<uint8_t>& allocationSize, uint64_t* outAllocationSize) {
		return decode(MetadataType_AllocationSize, allocationSize, outAllocationSize, decodeInteger);
		return decodeMetadata(MetadataType_AllocationSize, allocationSize, outAllocationSize, decodeInteger);
		}

		status_t encodeProtectedContent(uint64_t protectedContent, hidl_vec<uint8_t>* outProtectedContent) {
		return encode(MetadataType_ProtectedContent, protectedContent, outProtectedContent,
		return encodeMetadata(MetadataType_ProtectedContent, protectedContent, outProtectedContent,
		encodeInteger);
		}

		status_t decodeProtectedContent(const hidl_vec<uint8_t>& protectedContent, uint64_t* outProtectedContent) {
		return decode(MetadataType_ProtectedContent, protectedContent, outProtectedContent,
		return decodeMetadata(MetadataType_ProtectedContent, protectedContent, outProtectedContent,
		decodeInteger);
		}

		status_t encodeCompression(const ExtendableType& compression, hidl_vec<uint8_t>* outCompression) {
		return encode(MetadataType_Compression, compression, outCompression, encodeExtendableType);
		return encodeMetadata(MetadataType_Compression, compression, outCompression, encodeExtendableType);
		}

		status_t decodeCompression(const hidl_vec<uint8_t>& compression, ExtendableType* outCompression) {
		return decode(MetadataType_Compression, compression, outCompression, decodeExtendableType,
		return decodeMetadata(MetadataType_Compression, compression, outCompression, decodeExtendableType,
		clearExtendableType);
		}

		status_t encodeInterlaced(const ExtendableType& interlaced, hidl_vec<uint8_t>* outInterlaced) {
		return encode(MetadataType_Interlaced, interlaced, outInterlaced, encodeExtendableType);
		return encodeMetadata(MetadataType_Interlaced, interlaced, outInterlaced, encodeExtendableType);
		}

		status_t decodeInterlaced(const hidl_vec<uint8_t>& interlaced, ExtendableType* outInterlaced) {
		return decode(MetadataType_Interlaced, interlaced, outInterlaced, decodeExtendableType,
		return decodeMetadata(MetadataType_Interlaced, interlaced, outInterlaced, decodeExtendableType,
		clearExtendableType);
		}

		status_t encodeChromaSiting(const ExtendableType& chromaSiting, hidl_vec<uint8_t>* outChromaSiting) {
		return encode(MetadataType_ChromaSiting, chromaSiting, outChromaSiting, encodeExtendableType);
		return encodeMetadata(MetadataType_ChromaSiting, chromaSiting, outChromaSiting, encodeExtendableType);
		}

		status_t decodeChromaSiting(const hidl_vec<uint8_t>& chromaSiting, ExtendableType* outChromaSiting) {
		return decode(MetadataType_ChromaSiting, chromaSiting, outChromaSiting, decodeExtendableType,
		return decodeMetadata(MetadataType_ChromaSiting, chromaSiting, outChromaSiting, decodeExtendableType,
		clearExtendableType);
		}

		status_t encodePlaneLayouts(const std::vector<PlaneLayout>& planeLayouts, hidl_vec<uint8_t>* outPlaneLayouts) {
		return encode(MetadataType_PlaneLayouts, planeLayouts, outPlaneLayouts,
		return encodeMetadata(MetadataType_PlaneLayouts, planeLayouts, outPlaneLayouts,
		encodePlaneLayoutsHelper);
		}

		status_t decodePlaneLayouts(const hidl_vec<uint8_t>& planeLayouts, std::vector<PlaneLayout>* outPlaneLayouts) {
		return decode(MetadataType_PlaneLayouts, planeLayouts, outPlaneLayouts,
		return decodeMetadata(MetadataType_PlaneLayouts, planeLayouts, outPlaneLayouts,
		decodePlaneLayoutsHelper, clearPlaneLayouts);
		}

		status_t encodeDataspace(const Dataspace& dataspace, hidl_vec<uint8_t>* outDataspace) {
		return encode(MetadataType_Dataspace, static_cast<int32_t>(dataspace), outDataspace,
		return encodeMetadata(MetadataType_Dataspace, static_cast<int32_t>(dataspace), outDataspace,
		encodeInteger);
		}

		status_t decodeDataspace(const hidl_vec<uint8_t>& dataspace, Dataspace* outDataspace) {
		return decode(MetadataType_Dataspace, dataspace, reinterpret_cast<int32_t*>(outDataspace),
		return decodeMetadata(MetadataType_Dataspace, dataspace, reinterpret_cast<int32_t*>(outDataspace),
		decodeInteger);
		}

		status_t encodeBlendMode(const BlendMode& blendMode, hidl_vec<uint8_t>* outBlendMode) {
		return encode(MetadataType_BlendMode, static_cast<int32_t>(blendMode), outBlendMode,
		return encodeMetadata(MetadataType_BlendMode, static_cast<int32_t>(blendMode), outBlendMode,
		encodeInteger);
		}

		status_t decodeBlendMode(const hidl_vec<uint8_t>& blendMode, BlendMode* outBlendMode) {
		return decode(MetadataType_BlendMode, blendMode, reinterpret_cast<int32_t*>(outBlendMode),
		return decodeMetadata(MetadataType_BlendMode, blendMode, reinterpret_cast<int32_t*>(outBlendMode),
		decodeInteger);
		}

		status_t encodeSmpte2086(const std::optional<Smpte2086>& smpte2086,
		hidl_vec<uint8_t>* outSmpte2086) {
		return encodeOptional(MetadataType_Smpte2086, smpte2086, outSmpte2086, encodeSmpte2086Helper);
		return encodeOptionalMetadata(MetadataType_Smpte2086, smpte2086, outSmpte2086, encodeSmpte2086Helper);
		}

		status_t decodeSmpte2086(const hidl_vec<uint8_t>& smpte2086,
		std::optional<Smpte2086>* outSmpte2086) {
		return decodeOptional(MetadataType_Smpte2086, smpte2086, outSmpte2086, decodeSmpte2086Helper);
		return decodeOptionalMetadata(MetadataType_Smpte2086, smpte2086, outSmpte2086, decodeSmpte2086Helper);
		}

		status_t encodeCta861_3(const std::optional<Cta861_3>& cta861_3, hidl_vec<uint8_t>* outCta861_3) {
		return encodeOptional(MetadataType_Cta861_3, cta861_3, outCta861_3, encodeCta861_3Helper);
		return encodeOptionalMetadata(MetadataType_Cta861_3, cta861_3, outCta861_3, encodeCta861_3Helper);
		}

		status_t decodeCta861_3(const hidl_vec<uint8_t>& cta861_3, std::optional<Cta861_3>* outCta861_3) {
		return decodeOptional(MetadataType_Cta861_3, cta861_3, outCta861_3, decodeCta861_3Helper);
		return decodeOptionalMetadata(MetadataType_Cta861_3, cta861_3, outCta861_3, decodeCta861_3Helper);
		}

		status_t encodeSmpte2094_40(const std::optional<std::vector<uint8_t>>& smpte2094_40,
		hidl_vec<uint8_t>* outSmpte2094_40) {
		return encodeOptional(MetadataType_Smpte2094_40, smpte2094_40, outSmpte2094_40,
		return encodeOptionalMetadata(MetadataType_Smpte2094_40, smpte2094_40, outSmpte2094_40,
		encodeByteVector);
		}

		status_t decodeSmpte2094_40(const hidl_vec<uint8_t>& smpte2094_40,
		std::optional<std::vector<uint8_t>>* outSmpte2094_40) {
		return decodeOptional(MetadataType_Smpte2094_40, smpte2094_40, outSmpte2094_40,
		return decodeOptionalMetadata(MetadataType_Smpte2094_40, smpte2094_40, outSmpte2094_40,
		decodeByteVector);
		}

		status_t encodeUint32(const MetadataType& metadataType, uint32_t input,
		hidl_vec<uint8_t>* output) {
		return encode(metadataType, input, output, encodeInteger);
		return encodeMetadata(metadataType, input, output, encodeInteger);
		}

		status_t decodeUint32(const MetadataType& metadataType, const hidl_vec<uint8_t>& input,
		uint32_t* output) {
		return decode(metadataType, input, output, decodeInteger);
		return decodeMetadata(metadataType, input, output, decodeInteger);
		}

		status_t encodeInt32(const MetadataType& metadataType, int32_t input,
		hidl_vec<uint8_t>* output) {
		return encode(metadataType, input, output, encodeInteger);
		return encodeMetadata(metadataType, input, output, encodeInteger);
		}

		status_t decodeInt32(const MetadataType& metadataType, const hidl_vec<uint8_t>& input,
		int32_t* output) {
		return decode(metadataType, input, output, decodeInteger);
		return decodeMetadata(metadataType, input, output, decodeInteger);
		}

		status_t encodeUint64(const MetadataType& metadataType, uint64_t input,
		hidl_vec<uint8_t>* output) {
		return encode(metadataType, input, output, encodeInteger);
		return encodeMetadata(metadataType, input, output, encodeInteger);
		}

		status_t decodeUint64(const MetadataType& metadataType, const hidl_vec<uint8_t>& input,
		uint64_t* output) {
		return decode(metadataType, input, output, decodeInteger);
		return decodeMetadata(metadataType, input, output, decodeInteger);
		}

		status_t encodeInt64(const MetadataType& metadataType, int64_t input,
		hidl_vec<uint8_t>* output) {
		return encode(metadataType, input, output, encodeInteger);
		return encodeMetadata(metadataType, input, output, encodeInteger);
		}

		status_t decodeInt64(const MetadataType& metadataType, const hidl_vec<uint8_t>& input,
		int64_t* output) {
		return decode(metadataType, input, output, decodeInteger);
		return decodeMetadata(metadataType, input, output, decodeInteger);
		}

		status_t encodeFloat(const MetadataType& metadataType, float input,
		hidl_vec<uint8_t>* output) {
		return encode(metadataType, input, output, encodeInteger);
		return encodeMetadata(metadataType, input, output, encodeInteger);
		}

		status_t decodeFloat(const MetadataType& metadataType, const hidl_vec<uint8_t>& input,
		float* output) {
		return decode(metadataType, input, output, decodeInteger);
		return decodeMetadata(metadataType, input, output, decodeInteger);
		}

		status_t encodeDouble(const MetadataType& metadataType, double input,
		hidl_vec<uint8_t>* output) {
		return encode(metadataType, input, output, encodeInteger);
		return encodeMetadata(metadataType, input, output, encodeInteger);
		}

		status_t decodeDouble(const MetadataType& metadataType, const hidl_vec<uint8_t>& input,
		double* output) {
		return decode(metadataType, input, output, decodeInteger);
		return decodeMetadata(metadataType, input, output, decodeInteger);
		}

		status_t encodeString(const MetadataType& metadataType, const std::string& input,
		hidl_vec<uint8_t>* output) {
		return encode(metadataType, input, output, encodeString);
		return encodeMetadata(metadataType, input, output, encodeString);
		}

		status_t decodeString(const MetadataType& metadataType, const hidl_vec<uint8_t>& input,
		std::string* output) {
		return decode(metadataType, input, output, decodeString);
		return decodeMetadata(metadataType, input, output, decodeString);
		}

		bool isStandardMetadataType(const MetadataType& metadataType) {

libs/gralloc/types/fuzzer/gralloctypes.cpp

+2 −0

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

		using ::android::status_t;
		using MetadataType = android::hardware::graphics::mapper::V4_0::IMapper::MetadataType;
		using BufferDescriptorInfo = android::hardware::graphics::mapper::V4_0::IMapper::BufferDescriptorInfo;

		#define GRALLOCTYPES_DECODE(T, FUNC) \
		[] (const ::android::hardware::hidl_vec<uint8_t>& vec) {\
		@@ -53,6 +54,7 @@ using MetadataType = android::hardware::graphics::mapper::V4_0::IMapper::Metadat

		// clang-format off
		std::vector<GrallocTypesDecode> GRALLOCTYPES_DECODE_FUNCTIONS {
		GRALLOCTYPES_DECODE(BufferDescriptorInfo, ::android::gralloc4::decodeBufferDescriptorInfo),
		GRALLOCTYPES_DECODE(uint64_t, ::android::gralloc4::decodeBufferId),
		GRALLOCTYPES_DECODE(std::string, ::android::gralloc4::decodeName),
		GRALLOCTYPES_DECODE(uint64_t, ::android::gralloc4::decodeWidth),

libs/gralloc/types/include/gralloctypes/Gralloc4.h

+6 −0

Original line number	Diff line number	Diff line
		@@ -413,6 +413,12 @@ static const aidl::android::hardware::graphics::common::ExtendableType PlaneLayo

		/---------------------------------------------------------------------------------------------/

		/**
		* The functions below encode and decode BufferDescriptorInfo into a byte stream.
		*/
		status_t encodeBufferDescriptorInfo(const android::hardware::graphics::mapper::V4_0::IMapper::BufferDescriptorInfo& bufferDescriptorInfo, android::hardware::hidl_vec<uint8_t>* outBufferDescriptorInfo);
		status_t decodeBufferDescriptorInfo(const android::hardware::hidl_vec<uint8_t>& bufferDescriptorInfo, android::hardware::graphics::mapper::V4_0::IMapper::BufferDescriptorInfo* outBufferDescriptorInfo);

		/**
		* The functions below encode and decode standard metadata into a byte stream. It is STRONGLY
		* recommended that both the vendor and system partitions use these functions when getting

libs/gralloc/types/tests/Gralloc4_test.cpp

+15 −0

File changed.

Preview size limit exceeded, changes collapsed.