/*

% Copyright (C) 2023-2026 GraphicsMagick Group

%

% This program is covered by multiple licenses, which are described in

% Copyright.txt. You should have received a copy of Copyright.txt with this

% package; otherwise see http://www.graphicsmagick.org/www/Copyright.html.

%

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                       H   H  EEEEE  I  FFFFF                                %

%                       H   H  E      I  F                                    %

%                       HHHHH  EEEEE  I  FFFF                                 %

%                       H   H  E      I  F                                    %

%                       H   H  EEEEE  I  F                                    %

%                                                                             %

%           Read HEIF/HEIC/AVIF image formats using libheif.                  %

%                                                                             %

%           Initial version contributed by Tobias Mark, 2021.                 %

%           Since developed by Bob Friesenhahn.                               %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

* Status: Support for reading a single image.

* Ubuntu 22.04 LTS comes with 1.17.6 (Dec 20, 2023)!

* Debian 12 Backports provides 1.19.7 (March 3, 2025)

* Maybe limit support to version 1.17.6 (Dec 20, 2023) or later?

* But 1.20.0 (July 1, 2025) introduces support for sequences!

* Meanwhile, 1.14.0 is required to compile.

*

* Nokia technical publication on HEIF: https://nokiatech.github.io/heif/technical.html

*

* Yet to be done:

*

*   o Read/render HEIF tiles directly.

*   o Possibly support reading directly from file (heif_context_read_from_file())

*     rather than an in-memory BLOB.

*   o Support selecting to read HEIF depth image.

*   o Use HEIF transform properties to evaluate image orientation (requires 1.17).

*   o Provide user control over chroma upsampling options.

*   o Support reading sequences (requires 1.20).

*

*   o Write HEIF (HEIC, AVIF, more?)

*

* Definitions influencing the reader:

*

*  heif:ignore-transformations=yes/no (default no)

*

*    Determines if libheif will automatically rotate the image if it is not

*    right-side up.

*

*  heif:preserve-colorspace=yes/no (default no)

*

*    If image is stored in YCbCr, then return original YCbCr, but without the

*    benefit of applying an associated HEIF color profile.

*

*  heif:interleaved-rgb-decode=yes/no (default no)

*

*    RGB decoding can be done using individual planes (e.g. R, G, B, A), or

*    in an interleaved RGB(A) format.  This option controls libheif's image

*    decoding, but should not produce any change in the final result.

*/

#include "magick/studio.h"

#include "magick/attribute.h"

#include "magick/blob.h"

#include "magick/colormap.h"

#include "magick/log.h"

#include "magick/constitute.h"

#include "magick/magick.h"

#include "magick/monitor.h"

#include "magick/pixel_cache.h"

#include "magick/profile.h"

#include "magick/resource.h"

#include "magick/utility.h"

#include "magick/resource.h"

#include "magick/static.h"

#if defined(HasHEIF)

/* Set to 1 to enable the currently non-functional progress monitor callbacks */

#define HEIF_ENABLE_PROGRESS_MONITOR 0

#if defined(HAVE_LIBHEIF_HEIF_SEQUENCES_H)

/* Set to 1 to enable use of <libheif/heif_sequences.h> APIs */

#define HEIF_SUPPORT_SEQUENCES 1

#endif /* if defined(HAVE_LIBHEIF_HEIF_SEQUENCES_H) */

/* Set to 1 to enable RGB(A) decode in interleaved format */

#define HEIF_SUPPORT_INTERLEAVED 1

/*

  Libheif added LIBHEIF_MAKE_VERSION in 1.14.0 (October 31, 2021).

  Duplicate its definition so we can detect versions lower than

  1.14.0.

 */

#if !defined(LIBHEIF_HAVE_VERSION)

#define LIBHEIF_MAKE_VERSION(h, m, l) (((h) << 24 | (m) << 16 | (l) << 8) | 0)

#define LIBHEIF_HAVE_VERSION(h, m, l) (LIBHEIF_NUMERIC_VERSION >= LIBHEIF_MAKE_VERSION(h, m, l))

#endif /* if !defined(LIBHEIF_HAVE_VERSION) */

#if LIBHEIF_HAVE_VERSION(1,14,0)

#  error "Libheif must be at least 1.14.0!"

#endif

/* FIXME: It would be nice to use MagickSizeStrToInt64(), but it does

   not provide error status */

#define MagickAttributeToU32(image_info, magick, name, out_val)         \

  {                                                                     \

    const char *string_value;                                           \

    if ((string_value = AccessDefinition(image_info,magick,name)))      \

      {                                                                 \

        unsigned int ui_value;                                          \

        if (MagickAtoUIChk(string_value, &ui_value) != MagickFail)      \

          {                                                             \

            out_val = ui_value;                                         \

            (void) LogMagickEvent(CoderEvent,GetMagickModule(),         \

                                  "security limits: %s = "              \

                                  "%" MAGICK_UINTMAX_F "u", name,       \

                                  (magick_uintmax_t) out_val);          \

          }                                                             \

      }                                                                 \

  }

/* Rely on the compiler to remove unused code */

/* FIXME: It would be nice to use MagickSizeStrToInt64(), but it does

   not provide error status */

#define MagickAttributeToU64(image_info, magick, name, out_val)         \

  {                                                                     \

    const char *string_value;                                           \

    if ((string_value = AccessDefinition(image_info,magick,name)))      \

    {                                                                   \

      if (sizeof(long) == 64)                                           \

        {                                                               \

          unsigned long ul_value;                                       \

          if (MagickAtoULChk(string_value, &ul_value) != MagickFail)    \

            {                                                           \

              out_val = ul_value;                                       \

              (void) LogMagickEvent(CoderEvent,GetMagickModule(),       \

                                    "security limits: %s = "            \

                                    "%" MAGICK_UINTMAX_F "u", name,     \

                                    (magick_uintmax_t) out_val);        \

            }                                                           \

        }                                                               \

      else                                                              \

        {                                                               \

          unsigned long long ull_value;                                 \

          if (MagickAtoULLChk(string_value, &ull_value) != MagickFail)  \

            {                                                           \

              out_val = ull_value;                                      \

              (void) LogMagickEvent(CoderEvent,GetMagickModule(),       \

                                    "security limits: %s = "            \

                                    "%" MAGICK_UINTMAX_F "u", name,     \

                                    (magick_uintmax_t) out_val);        \

            }                                                           \

        }                                                               \

    }                                                                   \

  }

#include <libheif/heif.h>

#if defined(HEIF_SUPPORT_SEQUENCES) && HEIF_SUPPORT_SEQUENCES

#include <libheif/heif_sequences.h>

#endif /* if defined(HEIF_SUPPORT_SEQUENCES) */

static MagickBool heif_initialized = MagickFalse;

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%   I s H E I F                                                               %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  Method IsHEIF returns True if the image format type, identified by the

%  magick string, is supported by this HEIF reader.

%

%  The format of the IsHEIF  method is:

%

%      MagickBool IsHEIF(const unsigned char *magick,const size_t length)

%

%  A description of each parameter follows:

%

%    o status:  Method IsHEIF returns MagickTrue if the image format type is HEIF.

%

%    o magick: This string is generally the first few bytes of an image file

%      or blob.

%

%    o length: Specifies the length of the magick string.

%

%

*/

static MagickBool IsHEIF(const unsigned char *magick,const size_t length)

{

  enum heif_filetype_result

    heif_filetype;

  MagickBool

    status = MagickFalse;

  if ((length < 12) || (length > (size_t) INT_MAX))

    {

      (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                            "Data is too short (%zu bytes)", length);

      return status;

    }

  heif_filetype = heif_check_filetype(magick, (int) length);

  switch (heif_filetype)

    {

    case heif_filetype_yes_supported:

      (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                            "Data is HEIF (supported by libheif)");

      status = MagickTrue;

      break;

    case heif_filetype_yes_unsupported:

      (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                            "Data is HEIF (unsupported by libheif)");

      status = MagickTrue;

      break;

    case heif_filetype_maybe:

      (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                            "Data may be HEIF");

      status = MagickTrue;

      break;

    case heif_filetype_no:

      (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                            "Data not HEIF");

      status = MagickFalse;

      break;

    default:

      (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                            "Unexpected enum value %d",

                            (int) heif_filetype);

      status = MagickFalse;

    }

  return status;

}

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%   R e a d H E I F I m a g e                                                 %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  ReadHEIFImage() reads an image in the HEIF image format.

%

%  The format of the ReadHEIFImage method is:

%

%      Image *ReadHEIFImage(const ImageInfo *image_info,

%        ExceptionInfo *exception)

%

%  A description of each parameter follows:

%

%    o image_info: the image info.

%

%    o exception: return any errors or warnings in this structure.

%

*/

#define NATIVE_PLANAR_DECODE 1

#define HEIFReadCleanup()                                              \

  do                                                                   \

    {                                                                  \

      MagickFreeResourceLimitedMemory(heif_item_id *,item_ids);        \

      if (heif_image)                                                  \

        heif_image_release(heif_image);                                \

      if (heif_image_handle)                                           \

        heif_image_handle_release(heif_image_handle);                  \

      if (heif)                                                        \

        heif_context_free(heif);                                       \

      if (decode_options)                                              \

        heif_decoding_options_free(decode_options);                    \

      if (in_buf_allocated)                                            \

        MagickFreeResourceLimitedMemory(unsigned char *,in_buf);       \

    } while (0);

#define ThrowHEIFReaderException(code_,reason_,image_) \

  do                                                   \

    {                                                  \

      HEIFReadCleanup();                               \

      ThrowReaderException(code_,reason_,image_);      \

    } while (0);

/*

  Read metadata (Exif and XMP)

*/

static MagickPassFail ReadMetadata(struct heif_image_handle *heif_image_handle,

                                   Image *image, const MagickBool ignore_transformations)

{

  int

    count,

    i;

  heif_item_id

    *ids;

  struct heif_error

    err;

  /* Get number of metadata blocks attached to image */

  count=heif_image_handle_get_number_of_metadata_blocks(heif_image_handle,

                                                        /*type_filter*/ NULL);

  if (count==0)

    return MagickPass;

  ids=MagickAllocateResourceLimitedArray(heif_item_id *,count,sizeof(*ids));

  if (ids == (heif_item_id *) NULL)

    ThrowBinaryException(ResourceLimitError,MemoryAllocationFailed,(char *) NULL);

  /* Get list of metadata block ids */

  count=heif_image_handle_get_list_of_metadata_block_IDs(heif_image_handle, NULL,

                                                         ids,count);

  /* For each block id ... */

  for (i=0; i < count; i++)

    {

      const char

        *content_type,

        *profile_name;

      size_t

        exif_pad = 0,

        profile_size;

      unsigned char

        *profile;

      /* Access string indicating the type of the metadata (e.g. "Exif") */

      profile_name=heif_image_handle_get_metadata_type(heif_image_handle,ids[i]);

      /* Access string indicating the content type */

      content_type=heif_image_handle_get_metadata_content_type(heif_image_handle,ids[i]);

      /* Get the size of the raw metadata, as stored in the HEIF file */

      profile_size=heif_image_handle_get_metadata_size(heif_image_handle,ids[i]);

      if (image->logging)

        (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                              "Profile \"%s\" with content type \"%s\""

                              " and size %" MAGICK_SIZE_T_F "u bytes",

                              profile_name ? profile_name : "(null)",

                              content_type ? content_type : "(null)",

                              (MAGICK_SIZE_T) profile_size);

      if (NULL != profile_name && profile_size > 0)

        {

          if (strncmp(profile_name,"Exif",4) == 0)

            exif_pad=2;

          /* Allocate memory for profile */

          profile=MagickAllocateResourceLimitedArray(unsigned char*,profile_size+exif_pad,

                                                     sizeof(*profile));

          if (profile == (unsigned char*) NULL)

            {

              MagickFreeResourceLimitedMemory(heif_item_id *,ids);

              ThrowBinaryException(ResourceLimitError,MemoryAllocationFailed,(char *) NULL);

            }

          /*

            Copy metadata into 'profile' buffer. For Exif data, you

            probably have to skip the first four bytes of the data,

            since they indicate the offset to the start of the TIFF

            header of the Exif data.

          */

          err=heif_image_handle_get_metadata(heif_image_handle,ids[i],profile+exif_pad);

          if (err.code != heif_error_Ok)

            {

              if (image->logging)

                (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                      "heif_image_handle_get_metadata() "

                                      "reports error %d, suberror %d, message \"%s\"",

                                      err.code, err.subcode, err.message);

              MagickFreeResourceLimitedMemory(unsigned char *,profile);

              MagickFreeResourceLimitedMemory(heif_item_id *,ids);

              ThrowBinaryException(CorruptImageError,

                                   AnErrorHasOccurredReadingFromFile,image->filename);

            }

          if (strncmp(profile_name,"Exif",4) == 0 && profile_size > 4)

            {

              /* Parse and skip offset to TIFF header */

              unsigned char *p = profile;

              magick_uint32_t offset;

              /* Big-endian offset decoding */

              offset = (magick_uint32_t) p[exif_pad+0] << 24 |

                (magick_uint32_t) p[exif_pad+1] << 16 |

                (magick_uint32_t) p[exif_pad+2] << 8 |

                (magick_uint32_t) p[exif_pad+3];

              /*

                If the TIFF header offset is not zero, then need to

                move the TIFF data forward to the correct offset.

              */

              profile_size -= 4;

              if (offset > 0 && offset < profile_size)

                {

                  profile_size -= offset;

                  /* Strip any EOI marker if payload starts with a JPEG marker */

                  if (profile_size > 2 &&

                      (memcmp(p+exif_pad+4,"\xff\xd8",2) == 0 ||

                       memcmp(p+exif_pad+4,"\xff\xe1",2) == 0) &&

                      memcmp(p+exif_pad+4+profile_size-2,"\xff\xd9",2) == 0)

                    profile_size -= 2;

                  (void) memmove(p+exif_pad+4,p+exif_pad+4+offset,profile_size);

                }

              p[0]='E';

              p[1]='x';

              p[2]='i';

              p[3]='f';

              p[4]='\0';

              p[5]='\0';

              SetImageProfile(image,"EXIF",profile,profile_size+exif_pad+4);

              /*

                Retrieve image orientation from EXIF and store in

                image.

              */

              {

                const ImageAttribute

                  *attribute;

                attribute = GetImageAttribute(image,"EXIF:Orientation");

                if ((attribute != (const ImageAttribute *) NULL) &&

                    (attribute->value != (char *) NULL))

                  {

                    int

                      orientation;

                    orientation=MagickAtoI(attribute->value);

                    if ((orientation > UndefinedOrientation) &&

                        (orientation <= LeftBottomOrientation))

                      image->orientation=(OrientationType) orientation;

                  }

              }

            }

          else

            {

              if (NULL != content_type && strncmp(content_type,"application/rdf+xml",19) == 0)

                SetImageProfile(image,"XMP",profile,profile_size);

            }

          /*

            Only apply Exif orientation if ignore-transformations is true

            since HEIF native transformations will handle orientation otherwise

          */

          if (strncmp(profile_name,"Exif",4) == 0)

            {

              if (ignore_transformations)

                {

                  const ImageAttribute *attribute = GetImageAttribute(image,"EXIF:Orientation");

                  if (attribute && attribute->value)

                    {

                      SetImageAttribute(image,"EXIF:Orientation","1");

                      image->orientation = UndefinedOrientation;

                    }

                }

            }

          MagickFreeResourceLimitedMemory(unsigned char *,profile);

        }

    }

  MagickFreeResourceLimitedMemory(heif_item_id *,ids);

  return MagickPass;

}

/*

  Read Color Profile

*/

static MagickPassFail ReadColorProfile(struct heif_image_handle *heif_image_handle,

                                       Image *image)

{

  struct heif_error

    err;

  enum heif_color_profile_type

    profile_type; /* 4 chars encoded into enum by 'heif_fourcc()' */

  unsigned char

    *profile;

  profile_type = heif_image_handle_get_color_profile_type(heif_image_handle);

  if (heif_color_profile_type_not_present == profile_type)

    return MagickPass;

  if (image->logging && (heif_color_profile_type_not_present !=profile_type))

    (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                          "Found color profile of type \"%c%c%c%c\"",

                          ((char) ((unsigned int) profile_type >> 24) & 0xff),

                          ((char) ((unsigned int) profile_type >> 16) & 0xff),

                          ((char) ((unsigned int) profile_type >> 8) & 0xff),

                          ((char) ((unsigned int) profile_type) & 0xff));

  if (heif_color_profile_type_prof == profile_type)

    {

      size_t profile_size;

      profile_size = heif_image_handle_get_raw_color_profile_size(heif_image_handle);

      if (image->logging)

        (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                              "Reading ICC profile with size %" MAGICK_SIZE_T_F "u bytes...",

                              (MAGICK_SIZE_T) profile_size);

      if (profile_size > 0)

        {

          /* Allocate 'profile' buffer for profile */

          profile=MagickAllocateResourceLimitedArray(unsigned char*,profile_size,

                                                     sizeof(*profile));

          if (profile == (unsigned char*) NULL)

            ThrowBinaryException(ResourceLimitError,MemoryAllocationFailed,(char *) NULL);

          /* Copy ICC profile to 'profile' buffer */

          err = heif_image_handle_get_raw_color_profile(heif_image_handle,

                                                        profile);

          if (err.code != heif_error_Ok)

            {

              if (image->logging)

                (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                      "heif_image_handle_get_raw_color_profile() "

                                      "reports error %d, suberror %d, message \"%s\"",

                                      err.code, err.subcode, err.message);

              MagickFreeResourceLimitedMemory(unsigned char *,profile);

              ThrowBinaryException(CorruptImageError,

                                   AnErrorHasOccurredReadingFromFile,image->filename);

            }

          SetImageProfile(image,"ICM",profile,profile_size);

          MagickFreeResourceLimitedMemory(unsigned char *,profile);

          if (image->logging)

            (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                  "  done reading ICC profile");

        }

    }

  return MagickPass;

}

/*

  This progress monitor implementation is tentative since it is not invoked

  According to libheif issue 161

  (https://github.com/strukturag/libheif/issues/161) progress monitor

  does not actually work since the decoders it depends on do not

  support it.

  Libheif issue 546 (https://github.com/strukturag/libheif/pull/546)

  suggests changing the return type of on_progress and start_progress

  to "bool" so that one can implement cancellation support.

 */

typedef struct ProgressUserData_

{

  ExceptionInfo *exception;

  Image *image;

  enum heif_progress_step step;

  unsigned long int progress;

  unsigned long int max_progress;

} ProgressUserData;

#if HEIF_ENABLE_PROGRESS_MONITOR

/* Called when progress monitor starts.  The 'max_progress' parameter indicates the maximum value of progress */

static void start_progress(enum heif_progress_step step, int max_progress, void* progress_user_data)

{

  ProgressUserData *context= (ProgressUserData *) progress_user_data;

  Image *image=context->image;

  context->step = step;

  context->progress = 0;

  context->max_progress = max_progress;

  if (context->image->logging)

    (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                          "start_progress: step=%d, max_progress=%d",step, max_progress);

  MagickMonitorFormatted(context->progress,context->max_progress,&image->exception,

                         "[%s] Loading image: %lux%lu...  ",

                         image->filename,

                         image->columns,image->rows);

}

/* Called for each step of progress.  The 'progress' parameter represents the progress within the span of 'max_progress' */

static void on_progress(enum heif_progress_step step, int progress, void* progress_user_data)

{

  ProgressUserData *context = (ProgressUserData *) progress_user_data;

  Image *image=context->image;

  context->step = step;

  context->progress = progress;

  if (context->image->logging)

    (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                          "on_progress: step=%d, progress=%d",step, progress);

  MagickMonitorFormatted(context->progress,context->max_progress,&image->exception,

                         "[%s] Loading image: %lux%lu...  ",

                         image->filename,

                         image->columns,image->rows);

}

/* Called when progress monitor stops */

static void end_progress(enum heif_progress_step step, void* progress_user_data)

{

  ProgressUserData *context = (ProgressUserData *) progress_user_data;

  context->step = step;

  if (context->image->logging)

    (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                          "end_progress: step=%d",step);

}

#endif /* if HEIF_ENABLE_PROGRESS_MONITOR */

/*

  Apply security limits

 */

static MagickPassFail apply_security_limits(const ImageInfo *image_info,

                                            struct heif_context *heif_context)

{

#if LIBHEIF_NUMERIC_VERSION >= LIBHEIF_MAKE_VERSION(1,19,0)

  struct heif_security_limits

    *security_limits;

  magick_uintmax_t

    memory_limit,

    width_limit,

    height_limit,

    pixels_limit;

  security_limits=heif_context_get_security_limits(heif_context);

  memory_limit = (magick_uintmax_t) GetMagickResourceLimit(MemoryResource);

  security_limits->max_memory_block_size = (uint64_t) memory_limit;

  security_limits->max_total_memory = (uint64_t) memory_limit;

  width_limit = (magick_uintmax_t) GetMagickResourceLimit(WidthResource);

  if (width_limit > INT_MAX)

    width_limit = INT_MAX;

  height_limit = (magick_uintmax_t) GetMagickResourceLimit(HeightResource);

  if (height_limit > INT_MAX)

    height_limit = INT_MAX;

  pixels_limit = (magick_uintmax_t) GetMagickResourceLimit(PixelsResource);

  if ((width_limit < pixels_limit) && (height_limit < pixels_limit) &&

      (width_limit*height_limit < pixels_limit))

    pixels_limit = width_limit*height_limit;

  security_limits->max_image_size_pixels = (uint64_t) pixels_limit;

  /*

    Version 1 interface has:

    uint64_t max_image_size_pixels;

    uint64_t max_number_of_tiles;

    uint32_t max_bayer_pattern_pixels;

    uint32_t max_items;

    uint32_t max_color_profile_size;

    uint64_t max_memory_block_size;

    uint32_t max_components;

    uint32_t max_iloc_extents_per_item;

    uint32_t max_size_entity_group;

    uint32_t max_children_per_box; // for all boxes that are not covered by other limits

    and the version 2 interface adds:

    uint64_t max_total_memory;

    uint32_t max_sample_description_box_entries;

    uint32_t max_sample_group_description_box_entries;

  */

  /* version 1 interface */

  MagickAttributeToU64(image_info,"heif","max-image-size-pixels",

                       security_limits->max_image_size_pixels);

  MagickAttributeToU64(image_info,"heif","max-number-of-tiles",

                       security_limits->max_number_of_tiles);

  MagickAttributeToU32(image_info,"heif","max-bayer-pattern-pixels",

                       security_limits->max_bayer_pattern_pixels);

  MagickAttributeToU32(image_info,"heif","max-items",

                       security_limits->max_items);

  MagickAttributeToU32(image_info,"heif","max-color-profile-size",

                       security_limits->max_color_profile_size);

  MagickAttributeToU64(image_info,"heif","max-memory-block-size",

                       security_limits->max_memory_block_size);

  MagickAttributeToU32(image_info,"heif","max-components",

                       security_limits->max_components);

  MagickAttributeToU32(image_info,"heif","max-iloc-extents-per-item",

                       security_limits->max_iloc_extents_per_item);

  MagickAttributeToU32(image_info,"heif","max-size-entity-group",

                       security_limits->max_size_entity_group);

  MagickAttributeToU32(image_info,"heif","max-children-per-box",

                       security_limits->max_children_per_box);

  /* version 2 interface */

  /* Added in 1.13.0, September 2, 2022 */

  MagickAttributeToU64(image_info,"heif","max-total-memory",

                       security_limits->max_total_memory);

  /* Added in 1.13.0, September 2, 2022 */

  MagickAttributeToU32(image_info,"heif","max-sample-description-box-entries",

                       security_limits->max_sample_description_box_entries);

  /* Added in 1.17.6? ?*/

  MagickAttributeToU32(image_info,"heif","max-sample-group-description-box-entries",

                       security_limits->max_sample_group_description_box_entries);

  (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                        "security limits:"

                        /* version 1 interface */

                        "  max_image_size_pixels = %" MAGICK_UINTMAX_F "u"","

                        "  max_number_of_tiles = %" MAGICK_UINTMAX_F "u"","

                        "  max_bayer_pattern_pixels = %" MAGICK_UINTMAX_F "u"","

                        "  max_items = %" MAGICK_UINTMAX_F "u"","

                        "  max_color_profile_size = %" MAGICK_UINTMAX_F "u"","

                        "  max_memory_block_size = %" MAGICK_UINTMAX_F "u"","

                        "  max_components = %" MAGICK_UINTMAX_F "u"","

                        "  max_iloc_extents_per_item = %" MAGICK_UINTMAX_F "u"","

                        "  max_size_entity_group = %" MAGICK_UINTMAX_F "u"","

                        "  max_children_per_box = %" MAGICK_UINTMAX_F "u"","

                        /* version 2 interface */

                        "  max_total_memory = %" MAGICK_UINTMAX_F "u"","

                        "  max_sample_description_box_entries = %" MAGICK_UINTMAX_F "u"","

                        "  max_sample_group_description_box_entries = %" MAGICK_UINTMAX_F "u",

                        /* version 1 interface */

                        (magick_uintmax_t) security_limits->max_image_size_pixels,

                        (magick_uintmax_t) security_limits->max_number_of_tiles,

                        (magick_uintmax_t) security_limits->max_bayer_pattern_pixels,

                        (magick_uintmax_t) security_limits->max_items,

                        (magick_uintmax_t) security_limits->max_color_profile_size,

                        (magick_uintmax_t) security_limits->max_memory_block_size,

                        (magick_uintmax_t) security_limits->max_components,

                        (magick_uintmax_t) security_limits->max_iloc_extents_per_item,

                        (magick_uintmax_t) security_limits->max_size_entity_group,

                        (magick_uintmax_t) security_limits->max_children_per_box,

                        /* version 2 interface */

                        (magick_uintmax_t) security_limits->max_total_memory,

                        (magick_uintmax_t) security_limits->max_sample_description_box_entries,

                        (magick_uintmax_t) security_limits->max_sample_group_description_box_entries

                        );

#else

  {

    /* DEPRECATED: Add an image size limit based on maximum_width ^ 2 */

    magick_int64_t width_limit = GetMagickResourceLimit(WidthResource);

    if (MagickResourceInfinity != width_limit)

      {

        if (width_limit > INT_MAX)

          width_limit =  INT_MAX;

        /* Added in libheif 1.4.0 */

        heif_context_set_maximum_image_size_limit(heif, (int) width_limit);

      }

  }

#endif /* if LIBHEIF_NUMERIC_VERSION >= LIBHEIF_MAKE_VERSION(1,19,0) */

  return MagickPass;

}

/*

  libheif/color-conversion/colorconversion.cc provides this to output to

  an ostream, but our code is not C++!

  std::ostream& operator<<(std::ostream& ostr, heif_colorspace c)

*/

static const char *HEIF_colorspace_to_string(const enum heif_colorspace c)

{

  const char *s = "unknown";

  switch (c)

    {

    case heif_colorspace_undefined:

      s = "undefined";

      break;

    case heif_colorspace_YCbCr:

      s = "YCbCr";

      break;

    case heif_colorspace_RGB:

      s = "RGB";

      break;

    case heif_colorspace_monochrome:

      s = "monochrome";

      break;

    case heif_colorspace_nonvisual:

      s = "nonvisual";

      break;

#if LIBHEIF_HAVE_VERSION(1,21,3)

      /* Git commit cb6e524 added heif_colorspace_filter_array on 2/24/26 */

    case heif_colorspace_filter_array:

      s = "filter_array";

      break;

#endif /* if LIBHEIF_HAVE_VERSION(1,21,3) */

    }

  return s;

}

static ColorspaceType HEIF_colorspace_to_ColorspaceType(const enum heif_colorspace c)

{

  ColorspaceType t = UndefinedColorspace;

  switch (c)

    {

    case heif_colorspace_undefined:

      t = UndefinedColorspace;

      break;

    case heif_colorspace_YCbCr:

      t = YUVColorspace;

      break;

    case heif_colorspace_RGB:

      t = RGBColorspace;

      break;

    case heif_colorspace_monochrome:

      t = GRAYColorspace;

      break;

    case heif_colorspace_nonvisual:

      t = UndefinedColorspace;

      break;

#if LIBHEIF_HAVE_VERSION(1,21,3)

    case heif_colorspace_filter_array:

      t = UndefinedColorspace;

      break;

#endif /* if LIBHEIF_HAVE_VERSION(1,21,2) */

    }

  return t;

}

static const char *HEIF_chroma_to_string(const enum heif_chroma c)

{

  const char *s = "unknown";

  switch (c)

    {

    case heif_chroma_undefined:

      s = "undefined";

      break;

    case heif_chroma_monochrome:

      s = "monochrome";

      break;

    case heif_chroma_420:

      s = "420";

      break;

    case heif_chroma_422:

      s = "422";

      break;

    case heif_chroma_444:

      s = "444";

      break;

    case heif_chroma_interleaved_RGB:

      s = "interleaved_RGB";

      break;

    case heif_chroma_interleaved_RGBA:

      s = "interleaved_RGBA";

      break;

    case heif_chroma_interleaved_RRGGBB_BE:

      s = "interleaved_RRGGBB_BE";

      break;

    case heif_chroma_interleaved_RRGGBBAA_BE:

      s = "interleaved_RRGGBBAA_BE";

      break;

    case heif_chroma_interleaved_RRGGBB_LE:

      s = "interleaved_RRGGBB_LE";

      break;

    case heif_chroma_interleaved_RRGGBBAA_LE:

      s = "interleaved_RRGGBBAA_LE";

      break;

    }

  return s;

}

static const char *HEIF_channel_to_string(const enum heif_channel c)

{

  const char *s = "unknown";

  switch (c)

    {

    case heif_channel_Y:

      s = "Y";

      break;

    case heif_channel_Cb:

      s = "Cb";

      break;

    case heif_channel_Cr:

      s = "Cr";

      break;

    case heif_channel_R:

      s = "R";

      break;

    case heif_channel_G:

      s = "G";

      break;

    case heif_channel_B:

      s = "B";

      break;

    case heif_channel_Alpha:

      s = "Alpha";

      break;

    case heif_channel_interleaved:

      s = "interleaved";

      break;

#if LIBHEIF_HAVE_VERSION(1,21,3)

    case heif_channel_filter_array:

      /* Git commit cb6e524 added heif_channel_filter_array on 2/24/26 */

      s = "filter_array";

      break;

#endif /* if LIBHEIF_HAVE_VERSION(1,21,3) */

    case heif_channel_depth:

      s = "channel_depth";

      break;

    case heif_channel_disparity:

      s = "disparity";

      break;

#if LIBHEIF_HAVE_VERSION(1,21,3)

      /* Added by changeset b4326c42 on 2/12/26 after v1.21.2 */

    case heif_channel_unknown:

      s = "unknown";

      break;

#endif /* if LIBHEIF_HAVE_VERSION(1,21,3) */

    default:

      s = "unknown";

      break;

    }

  return s;

}

static MagickPassFail ReadHEIFImageFrame(heif_image_handle* heif_image_handle,

                                         struct heif_decoding_options *decode_options,

                                         Image *image,

                                         const ImageInfo *image_info,

                                         ExceptionInfo *exception)

{

#define HEIFReadImageFrameCleanup()             \

  do                                            \

    {                                           \

      if (heif_image)                           \

        heif_image_release(heif_image);         \

    } while (0);

#define ThrowHEIFThrowReadImageFrameException(code_,reason_,image_)     \

  do                                                                    \

    {                                                                   \

      HEIFReadImageFrameCleanup();                                      \

      if (code_ > exception->severity)                                  \

        {                                                               \

          ThrowException(&(image_)->exception,code_,reason_,(image_)->filename); \

          CopyException(exception,&(image_)->exception);                \

        }                                                               \

      return(MagickFail);                                               \

    } while (0);

  struct heif_image

    *heif_image = NULL;

  PixelPacket

    *q;

  long

    x,

    y;

  int

    bits_per_pixel;

  struct heif_error

    heif_status;

#if HEIF_ENABLE_PROGRESS_MONITOR

  ProgressUserData

    progress_user_data;

#endif

  enum heif_colorspace

    heif_colorspace,

    preferred_colorspace = heif_colorspace_undefined;

  enum heif_chroma

    preferred_chroma = heif_chroma_undefined;

  /*

    Note: Those values are preliminary but likely the upper bound

    The real image values might be rotated or cropped due to transformations

    heif_image_handle APIs are declared in heif_image_handle.h

  */

  image->depth=8;

  bits_per_pixel=heif_image_handle_get_luma_bits_per_pixel(heif_image_handle);

  /*

    This function only works for YCbCr-based images.  We only use it

    in ping mode since otherwise it screws up the depth in the Q8

    build (due to scaling in libheif).

  */

  if (image_info->ping)

    {

      if (image->logging)

        if (bits_per_pixel < 0)

          (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                "Image has undefined bit-depth!");

      if (bits_per_pixel > 0)

        image->depth=(unsigned int) bits_per_pixel;

      if (image->logging)

        (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                              "Depth: %u", image->depth);

    }

  image->columns=heif_image_handle_get_width(heif_image_handle);