/*
 * Copyright 2019 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.
 */

#define LOG_TAG "libgralloctypes"

#include <cstring>
#include <cinttypes>
#include <limits>

#include <hidl/HidlSupport.h>
#include <log/log.h>

#include "gralloctypes/Gralloc4.h"

using android::hardware::hidl_vec;

using aidl::android::hardware::graphics::common::BlendMode;
using aidl::android::hardware::graphics::common::ChromaSiting;
using aidl::android::hardware::graphics::common::Compression;
using aidl::android::hardware::graphics::common::Cta861_3;
using aidl::android::hardware::graphics::common::Dataspace;
using aidl::android::hardware::graphics::common::ExtendableType;
using aidl::android::hardware::graphics::common::Interlaced;
using aidl::android::hardware::graphics::common::PlaneLayout;
using aidl::android::hardware::graphics::common::PlaneLayoutComponent;
using aidl::android::hardware::graphics::common::PlaneLayoutComponentType;
using aidl::android::hardware::graphics::common::Rect;
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 {

namespace gralloc4 {

static inline bool hasAdditionOverflow(size_t a, size_t b) {
    return a > SIZE_MAX - b;
}

/**
 * OutputHidlVec represents the hidl_vec that is outputed when a type is encoded into a byte stream.
 * This class is used to track the current state of a hidl_vec as it is filled with the encoded
 * byte stream.
 *
 * This type is needed because hidl_vec's resize() allocates a new backing array every time.
 * This type does not need an copies and only needs one resize operation.
 */
class OutputHidlVec {
public:
    OutputHidlVec(hidl_vec<uint8_t>* vec)
        : mVec(vec) {}

    status_t resize() {
        if (!mVec) {
            return BAD_VALUE;
        }
        mVec->resize(mNeededResize);
        mResized = true;
        return NO_ERROR;
    }

    status_t encode(const uint8_t* data, size_t size) {
        if (!mVec) {
            return BAD_VALUE;
        }
        if (!mResized) {
            if (hasAdditionOverflow(mNeededResize, size)) {
                clear();
                return BAD_VALUE;
            }
            /**
             * Update mNeededResize and return NO_ERROR here because if (!mResized), the
             * caller hasn't called resize(). No data will be written into the mVec until
             * the caller resizes. We can't resize here for the caller because hidl_vec::resize()
             * allocates a new backing array every time.
             */
            mNeededResize += size;
            return NO_ERROR;
        }

        if (hasAdditionOverflow(mOffset, size) || (mVec->size() < size + mOffset)) {
            clear();
            return BAD_VALUE;
        }

        std::copy(data, data + size, mVec->data() + mOffset);

        mOffset += size;
        return NO_ERROR;
    }

    void clear() {
        if (mVec) {
            mVec->resize(0);
        }
        mNeededResize = 0;
        mResized = false;
        mOffset = 0;
    }

private:
    hidl_vec<uint8_t>* mVec;
    size_t mNeededResize = 0;
    size_t mResized = false;
    size_t mOffset = 0;
};

/**
 * InputHidlVec represents the hidl_vec byte stream that is inputed when a type is decoded.
 * This class is used to track the current index of the byte stream of the hidl_vec as it is
 * decoded.
 */
class InputHidlVec {
public:
    InputHidlVec(const hidl_vec<uint8_t>* vec)
        : mVec(vec) {}

    status_t decode(uint8_t* data, size_t size) {
        if (!mVec || hasAdditionOverflow(mOffset, size) || mOffset + size > mVec->size()) {
            return BAD_VALUE;
        }

        std::copy(mVec->data() + mOffset, mVec->data() + mOffset + size, data);

        mOffset += size;
        return NO_ERROR;
    }

    status_t decode(std::string* string, size_t size) {
        if (!mVec || hasAdditionOverflow(mOffset, size) || mOffset + size > mVec->size()) {
            return BAD_VALUE;
        }

        string->assign(mVec->data() + mOffset, mVec->data() + mOffset + size);

        mOffset += size;
        return NO_ERROR;
    }

    bool hasRemainingData() {
        if (!mVec) {
            return false;
        }
        return mVec->size() > mOffset;
    }

    size_t getRemainingSize() {
        if (!mVec) {
            return 0;
        }
        return mVec->size() - mOffset;
    }

private:
    const hidl_vec<uint8_t>* mVec;
    size_t mOffset = 0;
};

/**
 * EncodeHelper is a function type that encodes T into the OutputHidlVec.
 */
template<class T>
using EncodeHelper = status_t(*)(const T&, OutputHidlVec*);

/**
 * DecodeHelper is a function type that decodes InputHidlVec into T.
 */
template<class T>
using DecodeHelper = status_t(*)(InputHidlVec*, T*);

/**
 * ErrorHandler is a function type that is called when the corresponding DecodeHelper function
 * fails. ErrorHandler cleans up the object T so the caller doesn't receive a partially created
 * T.
 */
template<class T>
using ErrorHandler = void(*)(T*);

status_t encodeMetadataType(const MetadataType& input, OutputHidlVec* output);
status_t validateMetadataType(InputHidlVec* input, const MetadataType& expectedMetadataType);

/**
 * 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.
 *
 * 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 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};

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

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

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

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

    return encodeHelper(input, &outputHidlVec);
}

template <class T>
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 encodeMetadata(metadataType, *input, output, encodeHelper);
}

/**
 * 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 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};

    status_t err = validateMetadataType(&inputHidlVec, metadataType);
    if (err) {
        return err;
    }

    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 decodeOptionalMetadata(const MetadataType& metadataType, const hidl_vec<uint8_t>& input,
                        std::optional<T>* output, DecodeHelper<T> decodeHelper) {
    if (!output) {
        return BAD_VALUE;
    }
    if (input.size() <= 0) {
        output->reset();
        return NO_ERROR;
    }
    T tmp;
    status_t err = decodeMetadata(metadataType, input, &tmp, decodeHelper);
    if (!err) {
        *output = tmp;
    }
    return err;
}

/**
 * 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));
}

status_t encodeString(const std::string& input, OutputHidlVec* output) {
    if (!output) {
        return BAD_VALUE;
    }

    status_t err = encodeInteger<int64_t>(input.size(), output);
    if (err) {
        return err;
    }

    return output->encode(reinterpret_cast<const uint8_t*>(input.data()), input.size());
}

status_t decodeString(InputHidlVec* input, std::string* output) {
    if (!output) {
        return BAD_VALUE;
    }

    int64_t size = 0;
    status_t err = decodeInteger<int64_t>(input, &size);
    if (err) {
        return err;
    }
    if (size < 0) {
        return BAD_VALUE;
    }

    return input->decode(output, size);
}

status_t encodeByteVector(const std::vector<uint8_t>& input, OutputHidlVec* output) {
    if (!output) {
        return BAD_VALUE;
    }

    status_t err = encodeInteger<int64_t>(input.size(), output);
    if (err) {
        return err;
    }

    return output->encode(input.data(), input.size());
}

status_t decodeByteVector(InputHidlVec* input, std::vector<uint8_t>* output) {
    if (!output) {
        return BAD_VALUE;
    }

    int64_t size = 0;
    status_t err = decodeInteger<int64_t>(input, &size);
    if (err || size < 0) {
        return err;
    }

    if (size > input->getRemainingSize()) {
        return BAD_VALUE;
    }
    output->resize(size);

    return input->decode(output->data(), size);
}

status_t encodeExtendableType(const ExtendableType& input, OutputHidlVec* output) {
    status_t err = encodeString(input.name, output);
    if (err) {
        return err;
    }

    err = encodeInteger<int64_t>(input.value, output);
    if (err) {
        return err;
    }

    return NO_ERROR;
}

status_t decodeExtendableType(InputHidlVec* input, ExtendableType* output) {
    status_t err = decodeString(input, &output->name);
    if (err) {
        return err;
    }

    err = decodeInteger<int64_t>(input, &output->value);
    if (err) {
        return err;
    }

    return NO_ERROR;
}

void clearExtendableType(ExtendableType* output) {
    if (!output) {
        return;
    }
    output->name.clear();
    output->value = 0;
}

status_t encodeMetadataType(const MetadataType& input, OutputHidlVec* output) {
    status_t err = encodeString(input.name, output);
    if (err) {
        return err;
    }

    err = encodeInteger<int64_t>(input.value, output);
    if (err) {
        return err;
    }

    return NO_ERROR;
}

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

    err = decodeInteger<int64_t>(input, &output->value);
    if (err) {
        return err;
    }

    return NO_ERROR;
}

status_t validateMetadataType(InputHidlVec* input, const MetadataType& expectedMetadataType) {
    MetadataType receivedMetadataType;

    status_t err = decodeMetadataType(input, &receivedMetadataType);
    if (err) {
        return err;
    }

    if (expectedMetadataType.name != receivedMetadataType.name) {
        return BAD_VALUE;
    }

    if (receivedMetadataType.value != expectedMetadataType.value) {
        return BAD_VALUE;
    }

    return NO_ERROR;
}

status_t encodeXyColor(const XyColor& input, OutputHidlVec* output) {
    status_t err = encodeInteger<float>(input.x, output);
    if (err) {
        return err;
    }
    return encodeInteger<float>(input.y, output);
}

status_t decodeXyColor(InputHidlVec* input, XyColor* output) {
    status_t err = decodeInteger<float>(input, &output->x);
    if (err) {
        return err;
    }
    return decodeInteger<float>(input, &output->y);
}

void clearXyColor(XyColor* output) {
    if (!output) {
        return;
    }
    output->x = 0;
    output->y = 0;
}

status_t encodeRect(const Rect& input, OutputHidlVec* output) {
    status_t err = encodeInteger<int32_t>(static_cast<int32_t>(input.left), output);
    if (err) {
        return err;
    }
    err = encodeInteger<int32_t>(static_cast<int32_t>(input.top), output);
    if (err) {
        return err;
    }
    err = encodeInteger<int32_t>(static_cast<int32_t>(input.right), output);
    if (err) {
        return err;
    }
    return encodeInteger<int32_t>(static_cast<int32_t>(input.bottom), output);
}

status_t decodeRect(InputHidlVec* input, Rect* output) {
    status_t err = decodeInteger<int32_t>(input, &output->left);
    if (err) {
        return err;
    }
    err = decodeInteger<int32_t>(input, &output->top);
    if (err) {
        return err;
    }
    err = decodeInteger<int32_t>(input, &output->right);
    if (err) {
        return err;
    }
    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;
    }

    status_t err = encodeExtendableType(input.type, output);
    if (err) {
        return err;
    }
    err = encodeInteger<int64_t>(static_cast<int64_t>(input.offsetInBits), output);
    if (err) {
        return err;
    }
    return encodeInteger<int64_t>(static_cast<int64_t>(input.sizeInBits), output);
}

status_t decodePlaneLayoutComponent(InputHidlVec* input, PlaneLayoutComponent* output) {
    if (!output) {
        return BAD_VALUE;
    }

    status_t err = decodeExtendableType(input, &output->type);
    if (err) {
        return err;
    }
    err = decodeInteger<int64_t>(input, &output->offsetInBits);
    if (err) {
        return err;
    }
    return decodeInteger<int64_t>(input, &output->sizeInBits);
}

status_t encodePlaneLayoutComponents(const std::vector<PlaneLayoutComponent>& input, OutputHidlVec* output) {
    if (!output) {
        return BAD_VALUE;
    }

    status_t err = encodeInteger<int64_t>(static_cast<int64_t>(input.size()), output);
    if (err) {
        return err;
    }

    for (const auto& planeLayoutComponent: input) {
        err = encodePlaneLayoutComponent(planeLayoutComponent, output);
        if (err) {
            return err;
        }
    }

    return NO_ERROR;
}

status_t decodePlaneLayoutComponents(InputHidlVec* input, std::vector<PlaneLayoutComponent>* output) {
    if (!output) {
        return BAD_VALUE;
    }

    int64_t size = 0;
    status_t err = decodeInteger<int64_t>(input, &size);
    if (err) {
        return err;
    }
    if (size < 0 || size > 10000) {
        return BAD_VALUE;
    }

    output->resize(size);

    for (auto& planeLayoutComponent : *output) {
        err = decodePlaneLayoutComponent(input, &planeLayoutComponent);
        if (err) {
            return err;
        }
    }
    return NO_ERROR;
}

status_t encodePlaneLayout(const PlaneLayout& input, OutputHidlVec* output) {
    if (!output) {
        return BAD_VALUE;
    }

    status_t err = encodePlaneLayoutComponents(input.components, output);
    if (err) {
        return err;
    }

    err = encodeInteger<int64_t>(static_cast<int64_t>(input.offsetInBytes), output);
    if (err) {
        return err;
    }
    err = encodeInteger<int64_t>(static_cast<int64_t>(input.sampleIncrementInBits), output);
    if (err) {
        return err;
    }
    err = encodeInteger<int64_t>(static_cast<int64_t>(input.strideInBytes), output);
    if (err) {
        return err;
    }
    err = encodeInteger<int64_t>(static_cast<int64_t>(input.widthInSamples), output);
    if (err) {
        return err;
    }
    err = encodeInteger<int64_t>(static_cast<int64_t>(input.heightInSamples), output);
    if (err) {
        return err;
    }
    err = encodeInteger<int64_t>(static_cast<int64_t>(input.totalSizeInBytes), output);
    if (err) {
        return err;
    }
    err = encodeInteger<int64_t>(static_cast<int64_t>(input.horizontalSubsampling), output);
    if (err) {
        return err;
    }
    return encodeInteger<int64_t>(static_cast<int64_t>(input.verticalSubsampling), output);
}

status_t decodePlaneLayout(InputHidlVec* input, PlaneLayout* output) {
    if (!output) {
        return BAD_VALUE;
    }

    status_t err = decodePlaneLayoutComponents(input, &output->components);
    if (err) {
        return err;
    }

    err = decodeInteger<int64_t>(input, &output->offsetInBytes);
    if (err) {
        return err;
    }
    err = decodeInteger<int64_t>(input, &output->sampleIncrementInBits);
    if (err) {
        return err;
    }
    err = decodeInteger<int64_t>(input, &output->strideInBytes);
    if (err) {
        return err;
    }
    err = decodeInteger<int64_t>(input, &output->widthInSamples);
    if (err) {
        return err;
    }
    err = decodeInteger<int64_t>(input, &output->heightInSamples);
    if (err) {
        return err;
    }
    err = decodeInteger<int64_t>(input, &output->totalSizeInBytes);
    if (err) {
        return err;
    }
    err = decodeInteger<int64_t>(input, &output->horizontalSubsampling);
    if (err) {
        return err;
    }
    return decodeInteger<int64_t>(input, &output->verticalSubsampling);
}

status_t encodePlaneLayoutsHelper(const std::vector<PlaneLayout>& planeLayouts, OutputHidlVec* outOutputHidlVec) {
    status_t err = encodeInteger<int64_t>(static_cast<int64_t>(planeLayouts.size()), outOutputHidlVec);
    if (err) {
        return err;
    }

    for (const auto& planeLayout : planeLayouts) {
        err = encodePlaneLayout(planeLayout, outOutputHidlVec);
        if (err) {
            return err;
        }
    }

    return NO_ERROR;
}

status_t decodePlaneLayoutsHelper(InputHidlVec* inputHidlVec, std::vector<PlaneLayout>* outPlaneLayouts) {
    int64_t size = 0;
    status_t err = decodeInteger<int64_t>(inputHidlVec, &size);
    if (err) {
        return err;
    }
    if (size < 0) {
        return BAD_VALUE;
    }

    for (size_t i = 0; i < size; i++) {
        outPlaneLayouts->emplace_back();
        err = decodePlaneLayout(inputHidlVec, &outPlaneLayouts->back());
        if (err) {
            return err;
        }
    }
    return NO_ERROR;
}

void clearPlaneLayouts(std::vector<PlaneLayout>* output) {
    if (!output) {
        return;
    }
    output->clear();
}

status_t encodeCropHelper(const std::vector<Rect>& crops, OutputHidlVec* outOutputHidlVec) {
    status_t err = encodeInteger<int64_t>(static_cast<int64_t>(crops.size()), outOutputHidlVec);
    if (err) {
        return err;
    }

    for (const auto& crop : crops) {
        err = encodeRect(crop, outOutputHidlVec);
        if (err) {
            return err;
        }
    }

    return NO_ERROR;
}

status_t decodeCropHelper(InputHidlVec* inputHidlVec, std::vector<Rect>* outCrops) {
    int64_t size = 0;
    status_t err = decodeInteger<int64_t>(inputHidlVec, &size);
    if (err) {
        return err;
    }
    if (size < 0) {
        return BAD_VALUE;
    }

    for (size_t i = 0; i < size; i++) {
        outCrops->emplace_back();
        err = decodeRect(inputHidlVec, &outCrops->back());
        if (err) {
            return err;
        }
    }
    return NO_ERROR;
}

void clearCrop(std::vector<Rect>* output) {
    if (!output) {
        return;
    }
    output->clear();
}

status_t encodeSmpte2086Helper(const Smpte2086& smpte2086, OutputHidlVec* outOutputHidlVec) {
    status_t err = encodeXyColor(smpte2086.primaryRed, outOutputHidlVec);
    if (err) {
        return err;
    }
    err = encodeXyColor(smpte2086.primaryGreen, outOutputHidlVec);
    if (err) {
        return err;
    }
    err = encodeXyColor(smpte2086.primaryBlue, outOutputHidlVec);
    if (err) {
        return err;
    }
    err = encodeXyColor(smpte2086.whitePoint, outOutputHidlVec);
    if (err) {
        return err;
    }
    err = encodeInteger<float>(smpte2086.maxLuminance, outOutputHidlVec);
    if (err) {
        return err;
    }
    return encodeInteger<float>(smpte2086.minLuminance, outOutputHidlVec);
}

status_t decodeSmpte2086Helper(InputHidlVec* inputHidlVec, Smpte2086* outSmpte2086) {
    status_t err = decodeXyColor(inputHidlVec, &outSmpte2086->primaryRed);
    if (err) {
        return err;
    }
    err = decodeXyColor(inputHidlVec, &outSmpte2086->primaryGreen);
    if (err) {
        return err;
    }
    err = decodeXyColor(inputHidlVec, &outSmpte2086->primaryBlue);
    if (err) {
        return err;
    }
    err = decodeXyColor(inputHidlVec, &outSmpte2086->whitePoint);
    if (err) {
        return err;
    }
    err = decodeInteger<float>(inputHidlVec, &outSmpte2086->maxLuminance);
    if (err) {
        return err;
    }
    return decodeInteger<float>(inputHidlVec, &outSmpte2086->minLuminance);
}

status_t encodeCta861_3Helper(const Cta861_3& cta861_3, OutputHidlVec* outOutputHidlVec) {
    status_t err = encodeInteger<float>(cta861_3.maxContentLightLevel, outOutputHidlVec);
    if (err) {
        return err;
    }
    return encodeInteger<float>(cta861_3.maxFrameAverageLightLevel, outOutputHidlVec);
}

status_t decodeCta861_3Helper(InputHidlVec* inputHidlVec, Cta861_3* outCta861_3) {
    status_t err = decodeInteger<float>(inputHidlVec, &outCta861_3->maxContentLightLevel);
    if (err) {
        return err;
    }
    return decodeInteger<float>(inputHidlVec, &outCta861_3->maxFrameAverageLightLevel);
}

/**
 * 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 encodeMetadata(MetadataType_BufferId, bufferId, outBufferId, encodeInteger);
}

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

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

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

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

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

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

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

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

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

status_t encodePixelFormatRequested(const hardware::graphics::common::V1_2::PixelFormat& pixelFormatRequested,
        hidl_vec<uint8_t>* outPixelFormatRequested) {
    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 decodeMetadata(MetadataType_PixelFormatRequested, pixelFormatRequested,
                  reinterpret_cast<int32_t*>(outPixelFormatRequested), decodeInteger);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

status_t encodeCrop(const std::vector<Rect>& crop, hidl_vec<uint8_t>* outCrop) {
    return encodeMetadata(MetadataType_Crop, crop, outCrop, encodeCropHelper);
}

status_t decodeCrop(const hidl_vec<uint8_t>& crop, std::vector<Rect>* outCrop) {
    return decodeMetadata(MetadataType_Crop, crop, outCrop, decodeCropHelper, clearCrop);
}

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

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

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

status_t decodeBlendMode(const hidl_vec<uint8_t>& blendMode, BlendMode* 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 encodeOptionalMetadata(MetadataType_Smpte2086, smpte2086, outSmpte2086, encodeSmpte2086Helper);
}

status_t decodeSmpte2086(const hidl_vec<uint8_t>& smpte2086,
                         std::optional<Smpte2086>* outSmpte2086) {
    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 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 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 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 decodeOptionalMetadata(MetadataType_Smpte2094_40, smpte2094_40, outSmpte2094_40,
                          decodeByteVector);
}

status_t encodeSmpte2094_10(const std::optional<std::vector<uint8_t>>& smpte2094_10,
                            hidl_vec<uint8_t>* outSmpte2094_10) {
    return encodeOptionalMetadata(MetadataType_Smpte2094_10, smpte2094_10, outSmpte2094_10,
                                  encodeByteVector);
}

status_t decodeSmpte2094_10(const hidl_vec<uint8_t>& smpte2094_10,
                            std::optional<std::vector<uint8_t>>* outSmpte2094_10) {
    return decodeOptionalMetadata(MetadataType_Smpte2094_10, smpte2094_10, outSmpte2094_10,
                                  decodeByteVector);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

bool isStandardMetadataType(const MetadataType& metadataType) {
    return !std::strncmp(metadataType.name.c_str(), GRALLOC4_STANDARD_METADATA_TYPE,
                         metadataType.name.size());
}

bool isStandardCompression(const ExtendableType& compression) {
    return !std::strncmp(compression.name.c_str(), GRALLOC4_STANDARD_COMPRESSION,
                         compression.name.size());
}

bool isStandardInterlaced(const ExtendableType& interlaced) {
    return !std::strncmp(interlaced.name.c_str(), GRALLOC4_STANDARD_INTERLACED,
                         interlaced.name.size());
}

bool isStandardChromaSiting(const ExtendableType& chromaSiting) {
    return !std::strncmp(chromaSiting.name.c_str(), GRALLOC4_STANDARD_CHROMA_SITING,
                         chromaSiting.name.size());
}

bool isStandardPlaneLayoutComponentType(const ExtendableType& planeLayoutComponentType) {
    return !std::strncmp(planeLayoutComponentType.name.c_str(), GRALLOC4_STANDARD_PLANE_LAYOUT_COMPONENT_TYPE,
                         planeLayoutComponentType.name.size());
}

StandardMetadataType getStandardMetadataTypeValue(const MetadataType& metadataType) {
    return static_cast<StandardMetadataType>(metadataType.value);
}

Compression getStandardCompressionValue(const ExtendableType& compression) {
    return static_cast<Compression>(compression.value);
}

Interlaced getStandardInterlacedValue(const ExtendableType& interlaced) {
    return static_cast<Interlaced>(interlaced.value);
}

ChromaSiting getStandardChromaSitingValue(const ExtendableType& chromaSiting) {
    return static_cast<ChromaSiting>(chromaSiting.value);
}

PlaneLayoutComponentType getStandardPlaneLayoutComponentTypeValue(
        const ExtendableType& planeLayoutComponentType) {
    return static_cast<PlaneLayoutComponentType>(planeLayoutComponentType.value);
}

std::string getCompressionName(const ExtendableType& compression) {
    if (!isStandardCompression(compression)) {
        std::ostringstream stream;
        stream << compression.name << "#" << compression.value;
        return stream.str();
    }
    switch (getStandardCompressionValue(compression)) {
        case Compression::NONE:
            return "None";
        case Compression::DISPLAY_STREAM_COMPRESSION:
            return "DisplayStreamCompression";
    }
}

std::string getInterlacedName(const ExtendableType& interlaced) {
    if (!isStandardInterlaced(interlaced)) {
        std::ostringstream stream;
        stream << interlaced.name << "#" << interlaced.value;
        return stream.str();
    }
    switch (getStandardInterlacedValue(interlaced)) {
        case Interlaced::NONE:
            return "None";
        case Interlaced::TOP_BOTTOM:
            return "TopBottom";
        case Interlaced::RIGHT_LEFT:
            return "RightLeft";
    }
}

std::string getChromaSitingName(const ExtendableType& chromaSiting) {
    if (!isStandardChromaSiting(chromaSiting)) {
        std::ostringstream stream;
        stream << chromaSiting.name << "#" << chromaSiting.value;
        return stream.str();
    }
    switch (getStandardChromaSitingValue(chromaSiting)) {
        case ChromaSiting::NONE:
            return "None";
        case ChromaSiting::UNKNOWN:
            return "Unknown";
        case ChromaSiting::SITED_INTERSTITIAL:
            return "SitedInterstitial";
        case ChromaSiting::COSITED_HORIZONTAL:
            return "CositedHorizontal";
        case ChromaSiting::COSITED_VERTICAL:
            return "CositedVertical";
        case ChromaSiting::COSITED_BOTH:
            return "CositedBoth";
    }
}

std::string getPlaneLayoutComponentTypeName(const ExtendableType& planeLayoutComponentType) {
    if (!isStandardPlaneLayoutComponentType(planeLayoutComponentType)) {
        std::ostringstream stream;
        stream << planeLayoutComponentType.name << "#" << planeLayoutComponentType.value;
        return stream.str();
    }
    switch (getStandardPlaneLayoutComponentTypeValue(planeLayoutComponentType)) {
        case PlaneLayoutComponentType::Y:
            return "Y";
        case PlaneLayoutComponentType::CB:
            return "Cb";
        case PlaneLayoutComponentType::CR:
            return "Cr";
        case PlaneLayoutComponentType::R:
            return "R";
        case PlaneLayoutComponentType::G:
            return "G";
        case PlaneLayoutComponentType::B:
            return "B";
        case PlaneLayoutComponentType::RAW:
            return "RAW";
        case PlaneLayoutComponentType::A:
            return "A";
    }
}

} // namespace gralloc4

} // namespace android