/*

 * HEIF codec.

 * Copyright (c) 2017 Dirk Farin <dirk.farin@gmail.com>

 *

 * This file is part of libheif.

 *

 * libheif is free software: you can redistribute it and/or modify

 * it under the terms of the GNU Lesser General Public License as

 * published by the Free Software Foundation, either version 3 of

 * the License, or (at your option) any later version.

 *

 * libheif is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public License

 * along with libheif.  If not, see <http://www.gnu.org/licenses/>.

 */

#include "libheif/heif.h"

#include "libheif/heif_plugin.h"

#include "common_utils.h"

#include <algorithm>

#include <cstring>

#include <cassert>

#include <sstream>

#include <vector>

#include <string>

#include <thread>

#include <memory>

#include <utility>

#include "encoder_aom.h"

#include "encoder_input_check.h"

#include <deque>

#include <aom/aom_encoder.h>

#include <aom/aomcx.h>

#include <mutex>

// Detect whether the aom_codec_set_option() function is available.

// See https://aomedia.googlesource.com/aom/+/c1d42fe6615c96fc929257ed53c41fa094f38836%5E%21/aom/aom_codec.h.

#if AOM_CODEC_ABI_VERSION >= (6 + AOM_IMAGE_ABI_VERSION)

#define HAVE_AOM_CODEC_SET_OPTION 1

#endif

#if defined(HAVE_AOM_CODEC_SET_OPTION)

struct custom_option

{

    std::string name;

    std::string value;

};

#endif

struct encoder_struct_aom

{

  ~encoder_struct_aom()

  {

    for (auto* error : aom_errors) {

      delete[] error;

    }

    // automatically destroy aom_codec_ctx_t when we leave the function

//    auto codec_ctx_deleter = std::unique_ptr<aom_codec_ctx_t, aom_codec_err_t (*)(aom_codec_ctx_t*)>(&codec, aom_codec_destroy);

    aom_codec_destroy(&codec);

  }

  aom_codec_ctx_t codec;

  // --- parameters

  bool realtime_mode;

  int cpu_used;  // = parameter 'speed'. I guess this is a better name than 'cpu_used'.

  int quality;

  int alpha_quality;

  int min_q;

  int max_q;

  int alpha_min_q;

  int alpha_max_q;

  int threads;

  bool lossless;

  bool lossless_alpha;

  bool auto_tiles;

  bool enable_intra_block_copy;

#if defined(HAVE_AOM_CODEC_SET_OPTION)

  std::vector<custom_option> custom_options;

  void add_custom_option(const custom_option&);

  void add_custom_option(std::string name, std::string value);

#endif

  aom_tune_metric tune;

  bool tune_auto = true;

  heif_chroma chroma = heif_chroma_420;

  // --- input

  bool alpha_quality_set = false;

  bool alpha_min_q_set = false;

  bool alpha_max_q_set = false;

  // --- output

  struct Packet

  {

    std::vector<uint8_t> compressedData;

    uintptr_t frameNr = 0;

    bool is_keyframe = false;

  };

  std::deque<Packet> output_packets;

  std::vector<uint8_t> active_output_data;

  //bool data_read = false;

  // --- error message copies

  std::mutex aom_errors_mutex;

  std::vector<const char*> aom_errors;

  const char* set_aom_error(const char* aom_error_detail);

};

#if defined(HAVE_AOM_CODEC_SET_OPTION)

void encoder_struct_aom::add_custom_option(const custom_option& p)

{

  // if there is already a parameter of that name, remove it from list

  for (auto iter = custom_options.begin(); iter != custom_options.end(); ++iter) {

    if (iter->name == p.name) {

      custom_options.erase(iter);

      break;

    }

  }

  // and add the new parameter at the end of the list

  custom_options.push_back(p);

}

void encoder_struct_aom::add_custom_option(std::string name, std::string value)

{

  custom_option p;

  p.name = std::move(name);

  p.value = std::move(value);

  add_custom_option(p);

}

#endif

static const char* kError_undefined_error = "Undefined AOM error";

static const char* kError_codec_enc_config_default = "Error creating the default encoder config";

const char* encoder_struct_aom::set_aom_error(const char* aom_error)

{

  if (aom_error) {

    // We have to make a copy because the error returned from aom_codec_error_detail() is only valid

    // while the codec structure exists.

    char* err_copy = new char[strlen(aom_error) + 1];

    strcpy(err_copy, aom_error);

    std::lock_guard<std::mutex> lock(aom_errors_mutex);

    aom_errors.push_back(err_copy);

    return err_copy;

  }

  else {

    return kError_undefined_error;

  }

}

static const char* kParam_min_q = "min-q";

static const char* kParam_max_q = "max-q";

static const char* kParam_alpha_quality = "alpha-quality";

static const char* kParam_alpha_min_q = "alpha-min-q";

static const char* kParam_alpha_max_q = "alpha-max-q";

static const char* kParam_lossless_alpha = "lossless-alpha";

static const char* kParam_auto_tiles = "auto-tiles";

static const char* kParam_enable_intra_block_copy = "enable-intrabc";

static const char* kParam_threads = "threads";

static const char* kParam_realtime = "realtime";

static const char* kParam_speed = "speed";

static const char* kParam_chroma = "chroma";

static const char* const kParam_chroma_valid_values[] = {

    "420", "422", "444", nullptr

};

static const char* kParam_tune = "tune";

static const char* const kParam_tune_valid_values[] = {

    "auto", "psnr", "ssim", "iq", nullptr

};

#if defined(AOM_HAVE_TUNE_IQ)

// This table has been copied from libavif/src/codec_aom.c

// Quality (q) to quantizer (qp) formula for tune=iq (Image Quality), expressed as a look-up table for more clarity.

// Copied from libavif (src/codec_aom.c). The formula is a piecewise linear function empirically selected

// to correct for the non-linear bitrate increase of tune=iq relative to tune=ssim with the same qp.

//

// | Quality | Quantizer                          | Step size |

// |---------|------------------------------------|-----------|

// |  0 -  6 | 63 - floor(quality / 3)            |         3 |

// |  7 - 28 | 61 - round((quality - 7) / 2)      |         2 |

// | 29 - 53 | 50 - round((quality - 29) * 3 / 5) |      1.66 |

// | 54 - 99 | 35 - round((quality - 54) * 3 / 4) |      1.33 |

// |     100 | 0 (lossless)                       |         1 |

//

// The x axis of the table represents the ones digit, while the y axis represents the tens digit

// of the q value [0-100], which is then mapped to a qp value [0-63].

// clang-format off

static const int tuneIqQualityToQuantizer[101] = {

// 1s digit: *0  *1  *2  *3  *4  *5  *6  *7  *8  *9     10s digit:

             63, 63, 63, 62, 62, 62, 61, 61, 60, 60, // 0*

             59, 59, 58, 58, 57, 57, 56, 56, 55, 55, // 1*

             54, 54, 53, 53, 52, 52, 51, 51, 50, 50, // 2*

             49, 49, 48, 48, 47, 46, 46, 45, 45, 44, // 3*

             43, 43, 42, 42, 41, 40, 40, 39, 39, 38, // 4*

             37, 37, 36, 36, 35, 34, 33, 33, 32, 31, // 5*

             30, 30, 29, 28, 27, 27, 26, 25, 24, 24, // 6*

             23, 22, 21, 21, 20, 19, 18, 18, 17, 16, // 7*

             15, 15, 14, 13, 12, 12, 11, 10,  9,  9, // 8*

              8,  7,  6,  6,  5,  4,  3,  3,  2,  1, // 9*

              0  // quality 100

};

// clang-format on

#endif

static const int AOM_PLUGIN_PRIORITY = 60;

#define MAX_PLUGIN_NAME_LENGTH 80

static char plugin_name[MAX_PLUGIN_NAME_LENGTH];

static void aom_set_default_parameters(void* encoder);

static const char* aom_plugin_name()

{

  const char* encoder_name = aom_codec_iface_name(aom_codec_av1_cx());

  if (strlen(encoder_name) < MAX_PLUGIN_NAME_LENGTH) {

    strcpy(plugin_name, encoder_name);

  }

  else {

    strcpy(plugin_name, "AOMedia AV1 encoder");

  }

  return plugin_name;

}

#define MAX_NPARAMETERS 16

static heif_encoder_parameter aom_encoder_params[MAX_NPARAMETERS];

static const heif_encoder_parameter* aom_encoder_parameter_ptrs[MAX_NPARAMETERS + 1];

static void aom_init_parameters()

{

  heif_encoder_parameter* p = aom_encoder_params;

  const heif_encoder_parameter** d = aom_encoder_parameter_ptrs;

  int i = 0;

  assert(i < MAX_NPARAMETERS);

  p->version = 2;

  p->name = kParam_realtime;

  p->type = heif_encoder_parameter_type_boolean;

  p->boolean.default_value = false;

  p->has_default = true;

  d[i++] = p++;

  assert(i < MAX_NPARAMETERS);

  p->version = 2;

  p->name = kParam_speed;

  p->type = heif_encoder_parameter_type_integer;

  p->integer.default_value = 6;

  p->has_default = true;

  p->integer.have_minimum_maximum = true;

  p->integer.minimum = 0;

  if (aom_codec_version_major() >= 3) {

    p->integer.maximum = 9;

  }

  else {

    p->integer.maximum = 8;

  }

  p->integer.valid_values = NULL;

  p->integer.num_valid_values = 0;

  d[i++] = p++;

  assert(i < MAX_NPARAMETERS);

  p->version = 2;

  p->name = kParam_threads;

  p->type = heif_encoder_parameter_type_integer;

  p->has_default = true;

  p->integer.have_minimum_maximum = true;

  p->integer.minimum = 1;

  p->integer.maximum = 64;

  int threads = static_cast<int>(std::thread::hardware_concurrency());

  if (threads == 0) {

    // Could not autodetect, use previous default value.

    threads = 4;

  }

  threads = std::min(threads, p->integer.maximum);

  p->integer.default_value = threads;

  p->integer.valid_values = NULL;

  p->integer.num_valid_values = 0;

  d[i++] = p++;

  assert(i < MAX_NPARAMETERS);

  p->version = 2;

  p->name = heif_encoder_parameter_name_quality;

  p->type = heif_encoder_parameter_type_integer;

  p->integer.default_value = 50;

  p->has_default = true;

  p->integer.have_minimum_maximum = true;

  p->integer.minimum = 0;

  p->integer.maximum = 100;

  p->integer.valid_values = NULL;

  p->integer.num_valid_values = 0;

  d[i++] = p++;

  assert(i < MAX_NPARAMETERS);

  p->version = 2;

  p->name = heif_encoder_parameter_name_lossless;

  p->type = heif_encoder_parameter_type_boolean;

  p->boolean.default_value = false;

  p->has_default = true;

  d[i++] = p++;

  assert(i < MAX_NPARAMETERS);

  p->version = 2;

  p->name = kParam_chroma;

  p->type = heif_encoder_parameter_type_string;

  p->string.default_value = "420";

  p->has_default = true;

  p->string.valid_values = kParam_chroma_valid_values;

  d[i++] = p++;

  assert(i < MAX_NPARAMETERS);

  p->version = 2;

  p->name = kParam_tune;

  p->type = heif_encoder_parameter_type_string;

  p->string.default_value = "auto";

  p->has_default = true;

  p->string.valid_values = kParam_tune_valid_values;

  d[i++] = p++;

  assert(i < MAX_NPARAMETERS);

  p->version = 2;

  p->name = kParam_min_q;

  p->type = heif_encoder_parameter_type_integer;

  p->integer.default_value = 0;

  p->has_default = true;

  p->integer.have_minimum_maximum = true;

  p->integer.minimum = 0;

  p->integer.maximum = 63;

  p->integer.valid_values = NULL;

  p->integer.num_valid_values = 0;

  d[i++] = p++;

  assert(i < MAX_NPARAMETERS);

  p->version = 2;

  p->name = kParam_max_q;

  p->type = heif_encoder_parameter_type_integer;

  p->integer.default_value = 63;

  p->has_default = true;

  p->integer.have_minimum_maximum = true;

  p->integer.minimum = 0;

  p->integer.maximum = 63;

  p->integer.valid_values = NULL;

  p->integer.num_valid_values = 0;

  d[i++] = p++;

  assert(i < MAX_NPARAMETERS);

  p->version = 2;

  p->name = kParam_alpha_quality;

  p->type = heif_encoder_parameter_type_integer;

  p->has_default = false;

  p->integer.have_minimum_maximum = true;

  p->integer.minimum = 0;

  p->integer.maximum = 100;

  p->integer.valid_values = NULL;

  p->integer.num_valid_values = 0;

  d[i++] = p++;

  assert(i < MAX_NPARAMETERS);

  p->version = 2;

  p->name = kParam_alpha_min_q;

  p->type = heif_encoder_parameter_type_integer;

  p->has_default = false;

  p->integer.have_minimum_maximum = true;

  p->integer.minimum = 0;

  p->integer.maximum = 63;

  p->integer.valid_values = NULL;

  p->integer.num_valid_values = 0;

  d[i++] = p++;

  assert(i < MAX_NPARAMETERS);

  p->version = 2;

  p->name = kParam_alpha_max_q;

  p->type = heif_encoder_parameter_type_integer;

  p->has_default = false;

  p->integer.have_minimum_maximum = true;

  p->integer.minimum = 0;

  p->integer.maximum = 63;

  p->integer.valid_values = NULL;

  p->integer.num_valid_values = 0;

  d[i++] = p++;

  assert(i < MAX_NPARAMETERS);

  p->version = 2;

  p->name = kParam_lossless_alpha;

  p->type = heif_encoder_parameter_type_boolean;

  p->boolean.default_value = false;

  p->has_default = true;

  d[i++] = p++;

  assert(i < MAX_NPARAMETERS);

  p->version = 2;

  p->name = kParam_auto_tiles;

  p->type = heif_encoder_parameter_type_boolean;

  p->boolean.default_value = false;

  p->has_default = true;

  d[i++] = p++;

  assert(i < MAX_NPARAMETERS);

  p->version = 2;

  p->name = kParam_enable_intra_block_copy;

  p->type = heif_encoder_parameter_type_boolean;

  p->boolean.default_value = true;

  p->has_default = true;

  d[i++] = p++;

  assert(i < MAX_NPARAMETERS + 1);

  d[i++] = nullptr;

}

const heif_encoder_parameter** aom_list_parameters(void* encoder)

{

  return aom_encoder_parameter_ptrs;

}

static void aom_init_plugin()

{

  aom_init_parameters();

}

static void aom_cleanup_plugin()

{

}

heif_error aom_new_encoder(void** enc)

{

  encoder_struct_aom* encoder = new encoder_struct_aom();

  heif_error err = heif_error_ok;

  *enc = encoder;

  // set default parameters

  aom_set_default_parameters(encoder);

  return err;

}

void aom_free_encoder(void* encoder_raw)

{

  struct encoder_struct_aom* encoder = (encoder_struct_aom*) encoder_raw;

  delete encoder;

}

heif_error aom_set_parameter_quality(void* encoder_raw, int quality)

{

  encoder_struct_aom* encoder = (encoder_struct_aom*) encoder_raw;

  if (quality < 0 || quality > 100) {

    return heif_error_invalid_parameter_value;

  }

  encoder->quality = quality;

  return heif_error_ok;

}

heif_error aom_get_parameter_quality(void* encoder_raw, int* quality)

{

  encoder_struct_aom* encoder = (encoder_struct_aom*) encoder_raw;

  *quality = encoder->quality;

  return heif_error_ok;

}

heif_error aom_set_parameter_lossless(void* encoder_raw, int enable)

{

  encoder_struct_aom* encoder = (encoder_struct_aom*) encoder_raw;

  if (enable) {

    encoder->min_q = 0;

    encoder->max_q = 0;

    encoder->alpha_min_q = 0;

    encoder->alpha_min_q_set = true;

    encoder->alpha_max_q = 0;

    encoder->alpha_max_q_set = true;

  }

  encoder->lossless = enable;

  return heif_error_ok;

}

heif_error aom_get_parameter_lossless(void* encoder_raw, int* enable)

{

  encoder_struct_aom* encoder = (encoder_struct_aom*) encoder_raw;

  *enable = encoder->lossless;

  return heif_error_ok;

}

struct heif_error aom_set_parameter_logging_level(void* encoder_raw, int logging)

{

#if 0

  struct encoder_struct_x265* encoder = (struct encoder_struct_x265*)encoder_raw;

  if (logging<0 || logging>4) {

    return heif_error_invalid_parameter_value;

  }

  encoder->logLevel = logging;

#endif

  return heif_error_ok;

}

struct heif_error aom_get_parameter_logging_level(void* encoder_raw, int* loglevel)

{

#if 0

  struct encoder_struct_x265* encoder = (struct encoder_struct_x265*)encoder_raw;

  *loglevel = encoder->logLevel;

#else

  *loglevel = 0;

#endif

  return heif_error_ok;

}

#define set_value(paramname, paramvar) if (strcmp(name, paramname)==0) { encoder->paramvar = value; return heif_error_ok; }

#define get_value(paramname, paramvar) if (strcmp(name, paramname)==0) { *value = encoder->paramvar; return heif_error_ok; }

heif_error aom_set_parameter_integer(void* encoder_raw, const char* name, int value)

{

  encoder_struct_aom* encoder = (encoder_struct_aom*) encoder_raw;

  if (strcmp(name, heif_encoder_parameter_name_quality) == 0) {

    return aom_set_parameter_quality(encoder, value);

  }

  else if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {

    return aom_set_parameter_lossless(encoder, value);

  }

  else if (strcmp(name, kParam_alpha_quality) == 0) {

      if (value < 0 || value > 100) {

          return heif_error_invalid_parameter_value;

      }

      encoder->alpha_quality = value;

      encoder->alpha_quality_set = true;

      return heif_error_ok;

  }

  else if (strcmp(name, kParam_alpha_min_q) == 0) {

      encoder->alpha_min_q = value;

      encoder->alpha_min_q_set = true;

      return heif_error_ok;

  }

  else if (strcmp(name, kParam_alpha_max_q) == 0) {

      encoder->alpha_max_q = value;

      encoder->alpha_max_q_set = true;

      return heif_error_ok;

  }

  set_value(kParam_min_q, min_q);

  set_value(kParam_max_q, max_q);

  set_value(kParam_threads, threads);

  set_value(kParam_speed, cpu_used);

  return heif_error_unsupported_parameter;

}

heif_error aom_get_parameter_integer(void* encoder_raw, const char* name, int* value)

{

  encoder_struct_aom* encoder = (encoder_struct_aom*) encoder_raw;

  if (strcmp(name, heif_encoder_parameter_name_quality) == 0) {

    return aom_get_parameter_quality(encoder, value);

  }

  else if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {

    return aom_get_parameter_lossless(encoder, value);

  }

  else if (strcmp(name, kParam_alpha_quality) == 0) {

      *value = encoder->alpha_quality_set ? encoder->alpha_quality : encoder->quality;

      return heif_error_ok;

  }

  else if (strcmp(name, kParam_alpha_max_q) == 0) {

      *value = encoder->alpha_max_q_set ? encoder->alpha_max_q : encoder->max_q;

      return heif_error_ok;

  }

  else if (strcmp(name, kParam_alpha_min_q) == 0) {

      *value = encoder->alpha_min_q_set ? encoder->alpha_min_q : encoder->min_q;

      return heif_error_ok;

  }

  get_value(kParam_min_q, min_q);

  get_value(kParam_max_q, max_q);

  get_value(kParam_threads, threads);

  get_value(kParam_speed, cpu_used);

  return heif_error_unsupported_parameter;

}

heif_error aom_set_parameter_boolean(void* encoder_raw, const char* name, int value)

{

  encoder_struct_aom* encoder = (encoder_struct_aom*) encoder_raw;

  if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {

    return aom_set_parameter_lossless(encoder, value);

  }

  else if (strcmp(name, kParam_lossless_alpha) == 0) {

      encoder->lossless_alpha = value;

      if (value) {

          encoder->alpha_max_q = 0;

          encoder->alpha_max_q_set = true;

          encoder->alpha_min_q = 0;

          encoder->alpha_min_q_set = true;

      }

      return heif_error_ok;

  } else if (strcmp(name, kParam_auto_tiles) == 0) {

      encoder->auto_tiles = value;

      return heif_error_ok;

  } else if (strcmp(name, kParam_enable_intra_block_copy) == 0) {

      encoder->enable_intra_block_copy = value;

      return heif_error_ok;

  }

  set_value(kParam_realtime, realtime_mode);

  return heif_error_unsupported_parameter;

}

heif_error aom_get_parameter_boolean(void* encoder_raw, const char* name, int* value)

{

  encoder_struct_aom* encoder = (encoder_struct_aom*) encoder_raw;

  if (strcmp(name, heif_encoder_parameter_name_lossless) == 0) {

    return aom_get_parameter_lossless(encoder, value);

  }

  get_value(kParam_realtime, realtime_mode);

  get_value(kParam_lossless_alpha, lossless_alpha);

  get_value(kParam_auto_tiles, auto_tiles);

  get_value(kParam_enable_intra_block_copy, enable_intra_block_copy);

  return heif_error_unsupported_parameter;

}

heif_error aom_set_parameter_string(void* encoder_raw, const char* name, const char* value)

{

  encoder_struct_aom* encoder = (encoder_struct_aom*) encoder_raw;

  if (strcmp(name, kParam_chroma) == 0) {

    if (strcmp(value, "420") == 0) {

      encoder->chroma = heif_chroma_420;

      return heif_error_ok;

    }

    else if (strcmp(value, "422") == 0) {

      encoder->chroma = heif_chroma_422;

      return heif_error_ok;

    }

    else if (strcmp(value, "444") == 0) {

      encoder->chroma = heif_chroma_444;

      return heif_error_ok;

    }

    else {

      return heif_error_invalid_parameter_value;

    }

  }

  if (strcmp(name, kParam_tune) == 0) {

    if (strcmp(value, "auto") == 0) {

      encoder->tune_auto = true;

      return heif_error_ok;

    }

    else if (strcmp(value, "psnr") == 0) {

      encoder->tune = AOM_TUNE_PSNR;

      encoder->tune_auto = false;

      return heif_error_ok;

    }

    else if (strcmp(value, "ssim") == 0) {

      encoder->tune = AOM_TUNE_SSIM;

      encoder->tune_auto = false;

      return heif_error_ok;

    }

#if defined(AOM_HAVE_TUNE_IQ)

    else if (strcmp(value, "iq") == 0) {

      encoder->tune = AOM_TUNE_IQ;

      encoder->tune_auto = false;

      return heif_error_ok;

    }

#endif

    else {

      return heif_error_invalid_parameter_value;

    }

  }

#if defined(HAVE_AOM_CODEC_SET_OPTION)

  if (strncmp(name, "aom:", 4) == 0) {

    encoder->add_custom_option(std::string(name).substr(4), std::string(value));

    return heif_error_ok;

  }

#endif

  return heif_error_unsupported_parameter;

}

static void save_strcpy(char* dst, int dst_size, const char* src)

{

  strncpy(dst, src, dst_size - 1);

  dst[dst_size - 1] = 0;

}

heif_error aom_get_parameter_string(void* encoder_raw, const char* name,

                                    char* value, int value_size)

{

  encoder_struct_aom* encoder = (encoder_struct_aom*) encoder_raw;

  if (strcmp(name, kParam_chroma) == 0) {

    switch (encoder->chroma) {

      case heif_chroma_420:

        save_strcpy(value, value_size, "420");

        break;

      case heif_chroma_422:

        save_strcpy(value, value_size, "422");

        break;

      case heif_chroma_444:

        save_strcpy(value, value_size, "444");

        break;

      default:

        assert(false);

        return heif_error_invalid_parameter_value;

    }

    return heif_error_ok;

  }

  else if (strcmp(name, kParam_tune) == 0) {

    if (encoder->tune_auto) {

      save_strcpy(value, value_size, "auto");

      return heif_error_ok;

    }

    switch (encoder->tune) {

      case AOM_TUNE_PSNR:

        save_strcpy(value, value_size, "psnr");

        break;

      case AOM_TUNE_SSIM:

        save_strcpy(value, value_size, "ssim");

        break;

#if defined(AOM_HAVE_TUNE_IQ)

      case AOM_TUNE_IQ:

        save_strcpy(value, value_size, "iq");

        break;

#endif

      default:

        assert(false);

        return heif_error_invalid_parameter_value;

    }

    return heif_error_ok;

  }

  return heif_error_unsupported_parameter;

}

static void aom_set_default_parameters(void* encoder)

{

  for (const heif_encoder_parameter** p = aom_encoder_parameter_ptrs; *p; p++) {

    const heif_encoder_parameter* param = *p;

    if (param->has_default) {

      switch (param->type) {

        case heif_encoder_parameter_type_integer:

          aom_set_parameter_integer(encoder, param->name, param->integer.default_value);

          break;

        case heif_encoder_parameter_type_boolean:

          aom_set_parameter_boolean(encoder, param->name, param->boolean.default_value);

          break;

        case heif_encoder_parameter_type_string:

          aom_set_parameter_string(encoder, param->name, param->string.default_value);

          break;

      }

    }

  }

}

void aom_query_input_colorspace(heif_colorspace* colorspace, heif_chroma* chroma)

{

  *colorspace = heif_colorspace_YCbCr;

  *chroma = heif_chroma_420;

}

void aom_query_input_colorspace2(void* encoder_raw, heif_colorspace* colorspace, heif_chroma* chroma)

{

  encoder_struct_aom* encoder = (encoder_struct_aom*) encoder_raw;

  if (*colorspace == heif_colorspace_monochrome) {

    // keep the monochrome colorspace

  }

  else {

    *colorspace = heif_colorspace_YCbCr;

    *chroma = encoder->chroma;

  }

}

// returns 'true' when an error was detected

// Note: some older AOM versions take a non-const pointer to aom_codec_error(). Thus, we also have to use a non-const pointer here.

static bool check_aom_error(aom_codec_err_t aom_error, /*const*/ aom_codec_ctx_t* codec, encoder_struct_aom* encoder, struct heif_error* heif_error)

{

  if (aom_error == AOM_CODEC_OK) {

    return false;

  }

  std::stringstream sstr;

  sstr << "AOM encoder error: " << aom_codec_error(codec) << " - " << aom_codec_error_detail(codec);

  heif_error->code = heif_error_Encoder_plugin_error;

  heif_error->subcode = heif_suberror_Unsupported_parameter;

  heif_error->message = encoder->set_aom_error(sstr.str().c_str());

  return true;

}

#define CHECK_ERROR \

if (check_aom_error(aom_error, &codec, encoder, &err)) { \

  return err; \

}

struct chroma_info

{

  aom_img_fmt_t img_format = AOM_IMG_FMT_NONE;

  int chroma_height = 0;

  int chroma_sample_position = AOM_CSP_UNKNOWN;

};

chroma_info get_chroma_info(heif_chroma chroma,

                            int bpp_y, int source_height)

{

  chroma_info info;

  switch (chroma) {

    case heif_chroma_420:

    case heif_chroma_monochrome:

      info.img_format = AOM_IMG_FMT_I420;

      info.chroma_height = (source_height+1)/2;

      info.chroma_sample_position = AOM_CSP_UNKNOWN; // TODO: change this to CSP_CENTER in the future (https://github.com/AOMediaCodec/av1-avif/issues/88)

      break;

    case heif_chroma_422:

      info.img_format = AOM_IMG_FMT_I422;

      info.chroma_height = source_height; // 4:2:2 is subsampled horizontally only

      info.chroma_sample_position = AOM_CSP_COLOCATED;

      break;

    case heif_chroma_444:

      info.img_format = AOM_IMG_FMT_I444;

      info.chroma_height = source_height;

      info.chroma_sample_position = AOM_CSP_COLOCATED;

      break;

    default:

      info.img_format = AOM_IMG_FMT_NONE;

      info.chroma_sample_position = AOM_CSP_UNKNOWN;

      assert(false);

      break;

  }

  if (bpp_y > 8) {

    // aom_img_fmt_t is a set of flags, so the combined value is intentionally not an enumerator.

    info.img_format = (aom_img_fmt_t) (info.img_format | AOM_IMG_FMT_HIGHBITDEPTH); // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)

  }

  return info;

}

static heif_error aom_start_sequence_encoding_intern(void* encoder_raw, const heif_image* image,

                                                     enum heif_image_input_class input_class,

                                                     uint32_t framerate_num, uint32_t framerate_denom,

                                                     const heif_sequence_encoding_options* options,

                                                     bool image_sequence)

{

  encoder_struct_aom* encoder = (encoder_struct_aom*) encoder_raw;

  // destroy the codec in case it was already initialized

  // (e.g. when the encoder is reused for alpha encoding after being used for YUV encoding)

  aom_codec_destroy(&encoder->codec);

  heif_error err;

  const int source_width = heif_image_get_width(image, heif_channel_Y);

  const int source_height = heif_image_get_height(image, heif_channel_Y);

  const heif_chroma chroma = heif_image_get_chroma_format(image);

  int bpp_y = heif_image_get_bits_per_pixel_range(image, heif_channel_Y);

  // --- check for AOM 3.6.0 bug

  bool is_aom_3_6_0 = (aom_codec_version() == 0x030600);

  if (is_aom_3_6_0) {

    // This bound might be too tight, as I still could encode images with 8193 x 4353 correctly. Even 8200x4400, but 8200x4800 fails.

    // Let's still keep it as most images will be smaller anyway.

    if (!(source_width <= 8192 * 2 && source_height <= 4352 * 2 && source_width * source_height <= 8192 * 4352)) {

      err = {heif_error_Encoding_error,

             heif_suberror_Encoder_encoding,

             "AOM v3.6.0 has a bug when encoding large images. Please upgrade to at least AOM v3.6.1."};

      return err;

    }

  }

  // --- copy libheif image to aom image

  chroma_info chroma_info = get_chroma_info(chroma, bpp_y, source_height);

  // --- configure codec

  aom_codec_iface_t* iface;

  aom_codec_ctx_t& codec = encoder->codec;