Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 15282ca7 authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Merge "Updates encoding/decoding of optional metadata" am: 67fbd47a 

Original change: https://android-review.googlesource.com/c/platform/frameworks/native/+/1907915

Change-Id: Ieda8ad960a8295a59a9e4f016fceecddcd9b388d
parents 74724e2d 67fbd47a

libs/gralloc/types/Gralloc4.cpp

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

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



/**

 * Private helper functions

 */

template <class T>

status_t encodeInteger(const T& input, OutputHidlVec* output) {

    static_assert(std::is_same<T, uint32_t>::value || std::is_same<T, int32_t>::value ||

                  std::is_same<T, uint64_t>::value || std::is_same<T, int64_t>::value ||

                  std::is_same<T, float>::value || std::is_same<T, double>::value);

    if (!output) {

        return BAD_VALUE;

    }



    const uint8_t* tmp = reinterpret_cast<const uint8_t*>(&input);

    return output->encode(tmp, sizeof(input));

}



template <class T>

status_t decodeInteger(InputHidlVec* input, T* output) {

    static_assert(std::is_same<T, uint32_t>::value || std::is_same<T, int32_t>::value ||

                  std::is_same<T, uint64_t>::value || std::is_same<T, int64_t>::value ||

                  std::is_same<T, float>::value || std::is_same<T, double>::value);

    if (!output) {

        return BAD_VALUE;

    }



    uint8_t* tmp = reinterpret_cast<uint8_t*>(output);

    return input->decode(tmp, sizeof(*output));

}



/**

 * encode/encodeMetadata are the main encoding functions. They take in T and uses the encodeHelper

 * function to turn T into the hidl_vec byte stream.
@@ -251,10 +280,45 @@ status_t encodeMetadata(const MetadataType& metadataType, const T& input, hidl_v 
template <class T>

status_t encodeOptionalMetadata(const MetadataType& metadataType, const std::optional<T>& input,

                        hidl_vec<uint8_t>* output, EncodeHelper<T> encodeHelper) {

    if (!input) {

        return NO_ERROR;

    OutputHidlVec outputHidlVec{output};



    status_t err = encodeMetadataType(metadataType, &outputHidlVec);

    if (err) {

        return err;

    }

    return encodeMetadata(metadataType, *input, output, encodeHelper);



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

    if (err) {

        return err;

    }



    if (input) {

        err = encodeHelper(*input, &outputHidlVec);

        if (err) {

            return err;

        }

    }



    err = outputHidlVec.resize();

    if (err) {

        return err;

    }



    err = encodeMetadataType(metadataType, &outputHidlVec);

    if (err) {

        return err;

    }



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

    if (err) {

        return err;

    }



    if (input) {

        return encodeHelper(*input, &outputHidlVec);

    }



    return NO_ERROR;

}



/**
@@ -315,45 +379,36 @@ status_t decodeOptionalMetadata(const MetadataType& metadataType, const hidl_vec 
    if (!output) {

        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;



    InputHidlVec inputHidlVec{&input};



    status_t err = validateMetadataType(&inputHidlVec, metadataType);

    if (err) {

        return err;

    }



    uint32_t present = 0;

    err = decodeInteger<uint32_t>(&inputHidlVec, &present);

    if (err) {

        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;

    if (present) {

        T tmp;

        err = decodeHelper(&inputHidlVec, &tmp);

        if (err) {

            return err;

        }



    const uint8_t* tmp = reinterpret_cast<const uint8_t*>(&input);

    return output->encode(tmp, sizeof(input));

        *output = tmp;

    }



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) {

    err = inputHidlVec.hasRemainingData();

    if (err) {

        return BAD_VALUE;

    }



    uint8_t* tmp = reinterpret_cast<uint8_t*>(output);

    return input->decode(tmp, sizeof(*output));

    return NO_ERROR;

}



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