// Copyright (c) the JPEG XL Project Authors. All rights reserved.

//

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

#include <cstddef>

#include <cstdint>

#include <cstdio>

#include <cstring>

#include <vector>

#include "lib/jxl/base/compiler_specific.h"

#include "lib/jxl/enc_icc_codec.h"

#include "tools/tracking_memory_manager.h"

#ifdef JXL_ICC_FUZZER_SLOW_TEST

#include "lib/jxl/base/span.h"

#include "lib/jxl/dec_bit_reader.h"

#endif

#include "lib/jxl/base/status.h"

#include "lib/jxl/fuzztest.h"

#include "lib/jxl/padded_bytes.h"

namespace jxl {

Status PredictICC(const uint8_t* icc, size_t size, PaddedBytes* result);

Status UnpredictICC(const uint8_t* enc, size_t size, PaddedBytes* result);

}  // namespace jxl

namespace {

using ::jpegxl::tools::kGiB;

using ::jpegxl::tools::TrackingMemoryManager;

using ::jxl::PaddedBytes;

#ifdef JXL_ICC_FUZZER_SLOW_TEST

using ::jxl::BitReader;

using ::jxl::Span;

#endif

void CheckImpl(bool ok, const char* condition, const char* file, int line) {

  if (!ok) {

    fprintf(stderr, "Check(%s) failed at %s:%d\n", condition, file, line);

    JXL_CRASH();

  }

}

#define Check(OK) CheckImpl((OK), #OK, __FILE__, __LINE__)

int DoTestOneInput(const uint8_t* data, size_t size) {

#if defined(JXL_ICC_FUZZER_ONLY_WRITE)

  bool read = false;

#elif defined(JXL_ICC_FUZZER_ONLY_READ)

  bool read = true;

#else

  // Decide whether to test the reader or the writer (both use parsing)

  if (!size) return 0;

  bool read = data[0] == 0;

  data++;

  size--;

#endif

  TrackingMemoryManager memory_manager{/* cap */ 1 * kGiB,

                                       /* total_cap */ 5 * kGiB};

#ifdef JXL_ICC_FUZZER_SLOW_TEST

  // Including JPEG XL LZ77 and ANS compression. These are already fuzzed

  // separately, so it is better to disable JXL_ICC_FUZZER_SLOW_TEST to focus on

  // the ICC parsing.

  if (read) {

    // Reading parses the compressed format.

    BitReader br(Bytes(data, size));

    std::vector<uint8_t> result;

    (void)jxl::test::ReadICC(&br, &result);

    (void)br.Close();

  } else {

    // Writing parses the original ICC profile.

    PaddedBytes icc{memory_manager.get()};

    icc.assign(data, data + size);

    BitWriter writer{memory_manager.get()};

    // Writing should support any random bytestream so must succeed, make

    // fuzzer fail if not.

    Check(jxl::WriteICC(icc, &writer, jxl::LayerType::Header, nullptr));

  }

#else   // JXL_ICC_FUZZER_SLOW_TEST

  if (read) {

    // Reading (unpredicting) parses the compressed format.

    PaddedBytes result{memory_manager.get()};

    (void)jxl::UnpredictICC(data, size, &result);

  } else {

    // Writing (predicting) parses the original ICC profile.

    PaddedBytes result{memory_manager.get()};

    // Writing should support any random bytestream so must succeed, make

    // fuzzer fail if not.

    Check(jxl::PredictICC(data, size, &result));

    PaddedBytes reconstructed{memory_manager.get()};

    Check(jxl::UnpredictICC(result.data(), result.size(), &reconstructed));

    Check(reconstructed.size() == size);

    Check(memcmp(data, reconstructed.data(), size) == 0);

  }

#endif  // JXL_ICC_FUZZER_SLOW_TEST

  Check(memory_manager.Reset());

  return 0;

}

}  // namespace

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

  return DoTestOneInput(data, size);

}

void TestOneInput(const std::vector<uint8_t>& data) {

  DoTestOneInput(data.data(), data.size());

}

FUZZ_TEST(IccCodecFuzzTest, TestOneInput);