Merge "libgralloctypes: support encode BufferDescriptorInfo"
diff --git a/libs/gralloc/types/Gralloc4.cpp b/libs/gralloc/types/Gralloc4.cpp
index 4851b44..4e8569f 100644
--- a/libs/gralloc/types/Gralloc4.cpp
+++ b/libs/gralloc/types/Gralloc4.cpp
@@ -42,6 +42,7 @@
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 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 @@
}
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 @@
}
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 @@
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 @@
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 @@
/**
* 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) {
diff --git a/libs/gralloc/types/fuzzer/gralloctypes.cpp b/libs/gralloc/types/fuzzer/gralloctypes.cpp
index b18f407..b5644be 100644
--- a/libs/gralloc/types/fuzzer/gralloctypes.cpp
+++ b/libs/gralloc/types/fuzzer/gralloctypes.cpp
@@ -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 @@
// 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),
diff --git a/libs/gralloc/types/include/gralloctypes/Gralloc4.h b/libs/gralloc/types/include/gralloctypes/Gralloc4.h
index 42c6e15..d855439 100644
--- a/libs/gralloc/types/include/gralloctypes/Gralloc4.h
+++ b/libs/gralloc/types/include/gralloctypes/Gralloc4.h
@@ -414,6 +414,12 @@
/*---------------------------------------------------------------------------------------------*/
/**
+ * 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
* and setting metadata through gralloc 4 (IMapper 4.0).
diff --git a/libs/gralloc/types/tests/Gralloc4_test.cpp b/libs/gralloc/types/tests/Gralloc4_test.cpp
index 3542ed9..dbe41f1 100644
--- a/libs/gralloc/types/tests/Gralloc4_test.cpp
+++ b/libs/gralloc/types/tests/Gralloc4_test.cpp
@@ -25,6 +25,7 @@
using android::hardware::hidl_vec;
using android::hardware::graphics::common::V1_2::PixelFormat;
+using android::hardware::graphics::common::V1_2::BufferUsage;
using aidl::android::hardware::graphics::common::BlendMode;
using aidl::android::hardware::graphics::common::ChromaSiting;
@@ -41,6 +42,7 @@
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 {
@@ -435,6 +437,19 @@
ASSERT_NO_FATAL_FAILURE(testHelperStableAidlTypeOptional(GetParam(), gralloc4::encodeSmpte2094_40, gralloc4::decodeSmpte2094_40));
}
+class Gralloc4TestBufferDescriptorInfo : public testing::TestWithParam<BufferDescriptorInfo> { };
+
+INSTANTIATE_TEST_CASE_P(
+ Gralloc4TestBufferDescriptorInfoParams, Gralloc4TestBufferDescriptorInfo,
+ ::testing::Values(BufferDescriptorInfo{"BufferName", 64, 64, 1,
+ PixelFormat::RGBA_8888,
+ static_cast<uint64_t>(BufferUsage::CPU_READ_OFTEN | BufferUsage::CPU_WRITE_OFTEN),
+ 1024}));
+
+TEST_P(Gralloc4TestBufferDescriptorInfo, BufferDescriptorInfo) {
+ ASSERT_NO_FATAL_FAILURE(testHelperConst(GetParam(), gralloc4::encodeBufferDescriptorInfo, gralloc4::decodeBufferDescriptorInfo));
+}
+
class Gralloc4TestErrors : public testing::Test { };
TEST_F(Gralloc4TestErrors, Gralloc4TestEncodeNull) {