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

Commit 5d16e393 authored by Android Build Coastguard Worker's avatar Android Build Coastguard Worker
Browse files

Snap for 10269577 from fcb80a22 to udc-release 

Change-Id: I7ec4a375f69f29336ff84c4dddcf3a44805dba11
parents 68ecaf72 fcb80a22

data/etc/Android.bp

+12 −0
Original line number Diff line number Diff line
@@ -328,6 +328,12 @@ prebuilt_etc { 
    defaults: ["frameworks_native_data_etc_defaults"],

}



prebuilt_etc {

    name: "android.software.opengles.deqp.level-2023-03-01.prebuilt.xml",

    src: "android.software.opengles.deqp.level-2023-03-01.xml",

    defaults: ["frameworks_native_data_etc_defaults"],

}



prebuilt_etc {

    name: "android.software.sip.voip.prebuilt.xml",

    src: "android.software.sip.voip.xml",
@@ -352,6 +358,12 @@ prebuilt_etc { 
    defaults: ["frameworks_native_data_etc_defaults"],

}



prebuilt_etc {

    name: "android.software.vulkan.deqp.level-2023-03-01.prebuilt.xml",

    src: "android.software.vulkan.deqp.level-2023-03-01.xml",

    defaults: ["frameworks_native_data_etc_defaults"],

}



prebuilt_etc {

    name: "aosp_excluded_hardware.prebuilt.xml",

    src: "aosp_excluded_hardware.xml",

libs/ultrahdr/fuzzer/Android.bp

+20 −16
Original line number Diff line number Diff line
@@ -24,7 +24,17 @@ package { 
cc_defaults {

    name: "ultrahdr_fuzzer_defaults",

    host_supported: true,

    static_libs: ["liblog"],

    shared_libs: [

        "libimage_io",

        "libjpeg",

    ],

    static_libs: [

        "libjpegdecoder",

        "libjpegencoder",

        "libultrahdr",

        "libutils",

        "liblog",

    ],

    target: {

        darwin: {

            enabled: false,
@@ -37,6 +47,8 @@ cc_defaults { 
        description: "The fuzzers target the APIs of jpeg hdr",

        service_privilege: "constrained",

        users: "multi_user",

        fuzzed_code_usage: "future_version",

        vector: "local_no_privileges_required",

    },

}
@@ -46,20 +58,12 @@ cc_fuzz { 
    srcs: [

        "ultrahdr_enc_fuzzer.cpp",

    ],

    shared_libs: [

        "libimage_io",

        "libjpeg",

        "liblog",

    ],

    static_libs: [

        "libjpegdecoder",

        "libjpegencoder",

        "libultrahdr",

        "libutils",

    ],

    fuzz_config: {

        fuzzed_code_usage: "future_version",

        vector: "local_no_privileges_required",

    },

}



cc_fuzz {

    name: "ultrahdr_dec_fuzzer",

    defaults: ["ultrahdr_fuzzer_defaults"],

    srcs: [

        "ultrahdr_dec_fuzzer.cpp",

    ],

}

libs/ultrahdr/fuzzer/ultrahdr_dec_fuzzer.cpp

0 → 100644
+73 −0
Original line number Diff line number Diff line 
/*

 * Copyright 2023 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.

 */



// System include files

#include <fuzzer/FuzzedDataProvider.h>

#include <iostream>

#include <vector>



// User include files

#include "ultrahdr/jpegr.h"



using namespace android::ultrahdr;



// Transfer functions for image data, sync with ultrahdr.h

const int kOfMin = ULTRAHDR_OUTPUT_UNSPECIFIED + 1;

const int kOfMax = ULTRAHDR_OUTPUT_MAX;



class UltraHdrDecFuzzer {

public:

    UltraHdrDecFuzzer(const uint8_t* data, size_t size) : mFdp(data, size){};

    void process();



private:

    FuzzedDataProvider mFdp;

};



void UltraHdrDecFuzzer::process() {

    // hdr_of

    auto of = static_cast<ultrahdr_output_format>(mFdp.ConsumeIntegralInRange<int>(kOfMin, kOfMax));

    auto buffer = mFdp.ConsumeRemainingBytes<uint8_t>();

    jpegr_compressed_struct jpegImgR{buffer.data(), (int)buffer.size(), (int)buffer.size(),

                                     ULTRAHDR_COLORGAMUT_UNSPECIFIED};



    std::vector<uint8_t> iccData(0);

    std::vector<uint8_t> exifData(0);

    jpegr_info_struct info{0, 0, &iccData, &exifData};

    JpegR jpegHdr;

    (void)jpegHdr.getJPEGRInfo(&jpegImgR, &info);

//#define DUMP_PARAM

#ifdef DUMP_PARAM

    std::cout << "input buffer size " << jpegImgR.length << std::endl;

    std::cout << "image dimensions " << info.width << " x " << info.width << std::endl;

#endif

    size_t outSize = info.width * info.height * ((of == ULTRAHDR_OUTPUT_SDR) ? 4 : 8);

    jpegr_uncompressed_struct decodedJpegR;

    auto decodedRaw = std::make_unique<uint8_t[]>(outSize);

    decodedJpegR.data = decodedRaw.get();

    ultrahdr_metadata_struct metadata;

    jpegr_uncompressed_struct decodedGainMap{};

    (void)jpegHdr.decodeJPEGR(&jpegImgR, &decodedJpegR,

                              mFdp.ConsumeFloatingPointInRange<float>(1.0, FLT_MAX), nullptr, of,

                              &decodedGainMap, &metadata);

    if (decodedGainMap.data) free(decodedGainMap.data);

}



extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {

    UltraHdrDecFuzzer fuzzHandle(data, size);

    fuzzHandle.process();

    return 0;

}

libs/ultrahdr/fuzzer/ultrahdr_enc_fuzzer.cpp

+11 −12
Original line number Diff line number Diff line
@@ -55,12 +55,9 @@ const int kOfMax = ULTRAHDR_OUTPUT_MAX; 
const int kQfMin = 0;

const int kQfMax = 100;



// seed

const unsigned kSeed = 0x7ab7;



class JpegHDRFuzzer {

class UltraHdrEncFuzzer {

public:

    JpegHDRFuzzer(const uint8_t* data, size_t size) : mFdp(data, size){};

    UltraHdrEncFuzzer(const uint8_t* data, size_t size) : mFdp(data, size){};

    void process();

    void fillP010Buffer(uint16_t* data, int width, int height, int stride);

    void fill420Buffer(uint8_t* data, int size);
@@ -69,7 +66,7 @@ private: 
    FuzzedDataProvider mFdp;

};



void JpegHDRFuzzer::fillP010Buffer(uint16_t* data, int width, int height, int stride) {

void UltraHdrEncFuzzer::fillP010Buffer(uint16_t* data, int width, int height, int stride) {

    uint16_t* tmp = data;

    std::vector<uint16_t> buffer(16);

    for (int i = 0; i < buffer.size(); i++) {
@@ -78,22 +75,24 @@ void JpegHDRFuzzer::fillP010Buffer(uint16_t* data, int width, int height, int st 
    for (int j = 0; j < height; j++) {

        for (int i = 0; i < width; i += buffer.size()) {

            memcpy(data + i, buffer.data(), std::min((int)buffer.size(), (width - i)));

            std::shuffle(buffer.begin(), buffer.end(), std::default_random_engine(kSeed));

            std::shuffle(buffer.begin(), buffer.end(),

                         std::default_random_engine(std::random_device{}()));

        }

        tmp += stride;

    }

}



void JpegHDRFuzzer::fill420Buffer(uint8_t* data, int size) {

void UltraHdrEncFuzzer::fill420Buffer(uint8_t* data, int size) {

    std::vector<uint8_t> buffer(16);

    mFdp.ConsumeData(buffer.data(), buffer.size());

    for (int i = 0; i < size; i += buffer.size()) {

        memcpy(data + i, buffer.data(), std::min((int)buffer.size(), (size - i)));

        std::shuffle(buffer.begin(), buffer.end(), std::default_random_engine(kSeed));

        std::shuffle(buffer.begin(), buffer.end(),

                     std::default_random_engine(std::random_device{}()));

    }

}



void JpegHDRFuzzer::process() {

void UltraHdrEncFuzzer::process() {

    while (mFdp.remaining_bytes()) {

        struct jpegr_uncompressed_struct p010Img {};

        struct jpegr_uncompressed_struct yuv420Img {};
@@ -256,7 +255,7 @@ void JpegHDRFuzzer::process() { 
                        } else if (tf == ULTRAHDR_TF_PQ) {

                            metadata.maxContentBoost = kPqMaxNits / kSdrWhiteNits;

                        } else {

                            metadata.maxContentBoost = 0;

                            metadata.maxContentBoost = 1.0f;

                        }

                        metadata.minContentBoost = 1.0f;

                        status = jpegHdr.encodeJPEGR(&jpegImg, &jpegGainMap, &metadata, &jpegImgR);
@@ -293,7 +292,7 @@ void JpegHDRFuzzer::process() { 
}



extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {

    JpegHDRFuzzer fuzzHandle(data, size);

    UltraHdrEncFuzzer fuzzHandle(data, size);

    fuzzHandle.process();

    return 0;

}

libs/ultrahdr/icc.cpp

+9 −9
Original line number Diff line number Diff line
@@ -180,7 +180,7 @@ sp<DataStruct> IccHelper::write_text_tag(const char* text) { 


    uint32_t total_length = text_length * 2 + sizeof(header);

    total_length = (((total_length + 2) >> 2) << 2);  // 4 aligned

    sp<DataStruct> dataStruct = new DataStruct(total_length);

    sp<DataStruct> dataStruct = sp<DataStruct>::make(total_length);



    if (!dataStruct->write(header, sizeof(header))) {

        ALOGE("write_text_tag(): error in writing data");
@@ -204,7 +204,7 @@ sp<DataStruct> IccHelper::write_xyz_tag(float x, float y, float z) { 
            static_cast<uint32_t>(Endian_SwapBE32(float_round_to_fixed(y))),

            static_cast<uint32_t>(Endian_SwapBE32(float_round_to_fixed(z))),

    };

    sp<DataStruct> dataStruct = new DataStruct(sizeof(data));

    sp<DataStruct> dataStruct = sp<DataStruct>::make(sizeof(data));

    dataStruct->write(&data, sizeof(data));

    return dataStruct;

}
@@ -212,7 +212,7 @@ sp<DataStruct> IccHelper::write_xyz_tag(float x, float y, float z) { 
sp<DataStruct> IccHelper::write_trc_tag(const int table_entries, const void* table_16) {

    int total_length = 4 + 4 + 4 + table_entries * 2;

    total_length = (((total_length + 2) >> 2) << 2);  // 4 aligned

    sp<DataStruct> dataStruct = new DataStruct(total_length);

    sp<DataStruct> dataStruct = sp<DataStruct>::make(total_length);

    dataStruct->write32(Endian_SwapBE32(kTAG_CurveType));     // Type

    dataStruct->write32(0);                                     // Reserved

    dataStruct->write32(Endian_SwapBE32(table_entries));  // Value count
@@ -225,7 +225,7 @@ sp<DataStruct> IccHelper::write_trc_tag(const int table_entries, const void* tab 


sp<DataStruct> IccHelper::write_trc_tag_for_linear() {

    int total_length = 16;

    sp<DataStruct> dataStruct = new DataStruct(total_length);

    sp<DataStruct> dataStruct = sp<DataStruct>::make(total_length);

    dataStruct->write32(Endian_SwapBE32(kTAG_ParaCurveType));  // Type

    dataStruct->write32(0);                                      // Reserved

    dataStruct->write32(Endian_SwapBE16(kExponential_ParaCurveType));
@@ -263,7 +263,7 @@ float IccHelper::compute_tone_map_gain(const ultrahdr_transfer_function tf, floa 
sp<DataStruct> IccHelper::write_cicp_tag(uint32_t color_primaries,

                                         uint32_t transfer_characteristics) {

    int total_length = 12;  // 4 + 4 + 1 + 1 + 1 + 1

    sp<DataStruct> dataStruct = new DataStruct(total_length);

    sp<DataStruct> dataStruct = sp<DataStruct>::make(total_length);

    dataStruct->write32(Endian_SwapBE32(kTAG_cicp));    // Type signature

    dataStruct->write32(0);                             // Reserved

    dataStruct->write8(color_primaries);                // Color primaries
@@ -314,7 +314,7 @@ sp<DataStruct> IccHelper::write_clut(const uint8_t* grid_points, const uint8_t* 


    int total_length = 20 + 2 * value_count;

    total_length = (((total_length + 2) >> 2) << 2);  // 4 aligned

    sp<DataStruct> dataStruct = new DataStruct(total_length);

    sp<DataStruct> dataStruct = sp<DataStruct>::make(total_length);



    for (size_t i = 0; i < 16; ++i) {

        dataStruct->write8(i < kNumChannels ? grid_points[i] : 0);  // Grid size
@@ -372,7 +372,7 @@ sp<DataStruct> IccHelper::write_mAB_or_mBA_tag(uint32_t type, 
            total_length += a_curves_data[i]->getLength();

        }

    }

    sp<DataStruct> dataStruct = new DataStruct(total_length);

    sp<DataStruct> dataStruct = sp<DataStruct>::make(total_length);

    dataStruct->write32(Endian_SwapBE32(type));             // Type signature

    dataStruct->write32(0);                                 // Reserved

    dataStruct->write8(kNumChannels);                       // Input channels
@@ -421,7 +421,7 @@ sp<DataStruct> IccHelper::writeIccProfile(ultrahdr_transfer_function tf, 
            break;

        default:

            // Should not fall here.

            return new DataStruct(0);

            return nullptr;

    }



    // Compute primaries.
@@ -546,7 +546,7 @@ sp<DataStruct> IccHelper::writeIccProfile(ultrahdr_transfer_function tf, 
    header.size = Endian_SwapBE32(profile_size);

    header.tag_count = Endian_SwapBE32(tags.size());



    sp<DataStruct> dataStruct = new DataStruct(profile_size);

    sp<DataStruct> dataStruct = sp<DataStruct>::make(profile_size);

    if (!dataStruct->write(&header, sizeof(header))) {

        ALOGE("writeIccProfile(): error in header");

        return dataStruct;