/*

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

 */

#include <fuzzer/FuzzedDataProvider.h>

#include "ultrahdr_api.h"

#include "ultrahdr/ultrahdrcommon.h"

using namespace ultrahdr;

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

constexpr int kTfMin = UHDR_CT_UNSPECIFIED;

constexpr int kTfMax = UHDR_CT_SRGB;

class UltraHdrDecFuzzer {

 public:

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

  void process();

 private:

  FuzzedDataProvider mFdp;

};

void UltraHdrDecFuzzer::process() {

  auto output_ct =

      static_cast<uhdr_color_transfer>(mFdp.ConsumeIntegralInRange<int8_t>(kTfMin, kTfMax));

  auto displayBoost = mFdp.ConsumeFloatingPointInRange<float>(-10.0f, 100.0f);

  auto enableGpu = mFdp.ConsumeBool();

  // editing effects

  auto applyMirror = mFdp.ConsumeBool();

  uhdr_mirror_direction_t direction =

      mFdp.ConsumeBool() ? UHDR_MIRROR_VERTICAL : UHDR_MIRROR_HORIZONTAL;

  auto applyRotate = mFdp.ConsumeBool();

  int degrees = degrees = mFdp.PickValueInArray({-90, 0, 90, 180, 270});

  auto applyCrop = mFdp.ConsumeBool();

  int left = mFdp.ConsumeIntegral<int16_t>();

  int right = mFdp.ConsumeIntegral<int16_t>();

  int top = mFdp.ConsumeIntegral<int16_t>();

  int bottom = mFdp.ConsumeIntegral<int16_t>();

  auto applyResize = mFdp.ConsumeBool();

  int resizeWidth = mFdp.ConsumeIntegralInRange<int32_t>(-32, kMaxWidth + 128);

  int resizeHeight = mFdp.ConsumeIntegralInRange<int32_t>(-32, kMaxHeight + 128);

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

  uhdr_compressed_image_t jpegImgR{

      buffer.data(),       (unsigned int)buffer.size(), (unsigned int)buffer.size(),

      UHDR_CG_UNSPECIFIED, UHDR_CT_UNSPECIFIED,         UHDR_CR_UNSPECIFIED};

#define ON_ERR(x)                              \

  {                                            \

    uhdr_error_info_t status_ = (x);           \

    if (status_.error_code != UHDR_CODEC_OK) { \

      if (status_.has_detail) {                \

        ALOGE("%s", status_.detail);           \

      }                                        \

    }                                          \

  }

  (void)is_uhdr_image(buffer.data(), buffer.size());

  uhdr_codec_private_t* dec_handle = uhdr_create_decoder();

  if (dec_handle) {

    ON_ERR(uhdr_dec_set_image(dec_handle, &jpegImgR))

    ON_ERR(uhdr_dec_set_out_color_transfer(dec_handle, output_ct))

    if (output_ct == UHDR_CT_LINEAR)

      ON_ERR(uhdr_dec_set_out_img_format(dec_handle, UHDR_IMG_FMT_64bppRGBAHalfFloat))

    else if (output_ct == UHDR_CT_SRGB)

      ON_ERR(uhdr_dec_set_out_img_format(dec_handle, UHDR_IMG_FMT_32bppRGBA8888))

    else

      ON_ERR(uhdr_dec_set_out_img_format(dec_handle, UHDR_IMG_FMT_32bppRGBA1010102))

    ON_ERR(uhdr_dec_set_out_max_display_boost(dec_handle, displayBoost))

    ON_ERR(uhdr_enable_gpu_acceleration(dec_handle, enableGpu))

    if (applyMirror) ON_ERR(uhdr_add_effect_mirror(dec_handle, direction))

    if (applyRotate) ON_ERR(uhdr_add_effect_rotate(dec_handle, degrees))

    if (applyCrop) ON_ERR(uhdr_add_effect_crop(dec_handle, left, right, top, bottom))

    if (applyResize) ON_ERR(uhdr_add_effect_resize(dec_handle, resizeWidth, resizeHeight))

    uhdr_dec_probe(dec_handle);

    auto width = uhdr_dec_get_image_width(dec_handle);

    auto height = uhdr_dec_get_image_height(dec_handle);

    auto gainmap_width = uhdr_dec_get_gainmap_width(dec_handle);

    auto gainmap_height = uhdr_dec_get_gainmap_height(dec_handle);

    ALOGV("image dimensions %d x %d ", (int)width, (int)height);

    ALOGV("gainmap image dimensions %d x %d ", (int)gainmap_width, (int)gainmap_height);

    ALOGV("output color transfer %d ", (int)output_ct);

    ALOGV("max display boost %f ", (float)displayBoost);

    ALOGV("enable gpu %d ", (int)enableGpu);

    if (applyMirror) ALOGV("added mirror effect, direction %d", (int)direction);

    if (applyRotate) ALOGV("added rotate effect, degrees %d", (int)degrees);

    if (applyCrop)

      ALOGV("added crop effect, crop-left %d, crop-right %d, crop-top %d, crop-bottom %d", left,

            right, top, bottom);

    if (applyResize)

      ALOGV("added resize effect, resize wd %d, resize ht %d", resizeWidth, resizeHeight);

    uhdr_dec_get_exif(dec_handle);

    uhdr_dec_get_icc(dec_handle);

    uhdr_dec_get_base_image(dec_handle);

    uhdr_dec_get_gainmap_image(dec_handle);

    uhdr_dec_get_gainmap_metadata(dec_handle);

    uhdr_decode(dec_handle);

    uhdr_get_decoded_image(dec_handle);

    uhdr_get_decoded_gainmap_image(dec_handle);

    uhdr_reset_decoder(dec_handle);

    uhdr_release_decoder(dec_handle);

  }

}

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

  UltraHdrDecFuzzer fuzzHandle(data, size);

  fuzzHandle.process();

  return 0;

}