grok.h

Go to the documentation of this file.

/*
 *    Copyright (C) 2016-2026 Grok Image Compression Inc.
 *
 *    This source code is free software: you can redistribute it and/or  modify
 *    it under the terms of the GNU Affero General Public License, version 3,
 *    as published by the Free Software Foundation.
 *
 *    This source code 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 Affero General Public License for more details.
 *
 *    You should have received a copy of the GNU Affero General Public License
 *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#pragma once
 
#include <stdint.h>
#include <stdio.h>
#include <stdbool.h>
#include <limits.h>
 
#ifndef SWIG
#ifdef __cplusplus
extern "C" {
#endif
#endif
 
#include "grk_config.h"
 
#ifndef SWIG
#ifdef _WIN32
#define GRK_CALLCONV __stdcall
#ifdef GRK_STATIC
#define GRK_API
#else
#ifdef GRK_EXPORTS
#define GRK_API __declspec(dllexport)
#else
#define GRK_API __declspec(dllimport)
#endif
#endif
#else
#define GRK_CALLCONV
#ifdef GRK_STATIC
#define GRK_API __attribute__((visibility("hidden")))
#else
#define GRK_API __attribute__((visibility("default")))
#endif
#endif
#else
#define GRK_CALLCONV
#define GRK_API
#endif


typedef enum _GRK_PROG_ORDER
{
  GRK_PROG_UNKNOWN = -1, 
  GRK_LRCP = 0, 
  GRK_RLCP = 1, 
  GRK_RPCL = 2, 
  GRK_PCRL = 3, 
  GRK_CPRL = 4, 
  GRK_NUM_PROGRESSION_ORDERS = 5 
} GRK_PROG_ORDER;

typedef enum _GRK_COLOR_SPACE
{
  GRK_CLRSPC_UNKNOWN = 0, 
  GRK_CLRSPC_SRGB = 2, 
  GRK_CLRSPC_GRAY = 3, 
  GRK_CLRSPC_SYCC = 4, 
  GRK_CLRSPC_EYCC = 5, 
  GRK_CLRSPC_CMYK = 6, 
  GRK_CLRSPC_DEFAULT_CIE = 7, 
  GRK_CLRSPC_CUSTOM_CIE = 8, 
  GRK_CLRSPC_ICC = 9 
} GRK_COLOR_SPACE;

typedef enum _GRK_ENUM_COLOUR_SPACE
{
  GRK_ENUM_CLRSPC_UNKNOWN = 0xFFFFFFFF, /* unknown */
  GRK_ENUM_CLRSPC_BILEVEL1 = 0, /* bilevel 1 */
  GRK_ENUM_CLRSPC_YCBCR1 = 1, /* YCbCr 4:2:2 */
  GRK_ENUM_CLRSPC_YCBCR2 = 3, /* YCbCr 4:4:4 */
  GRK_ENUM_CLRSPC_YCBCR3 = 4, /* YCbCr 4:2:0 */
  GRK_ENUM_CLRSPC_PHOTO_YCC = 9, /* Kodak PhotoYCC */
  GRK_ENUM_CLRSPC_CMY = 11, /* cyan, magenta, yellow */
  GRK_ENUM_CLRSPC_CMYK = 12, /* cyan, magenta, yellow, black */
  GRK_ENUM_CLRSPC_YCCK = 13, /* YCCK */
  GRK_ENUM_CLRSPC_CIE = 14, /* CIE Lab (L*, a*, b*) */
  GRK_ENUM_CLRSPC_BILEVEL2 = 15, /* bilevel 2 */
  GRK_ENUM_CLRSPC_SRGB = 16, /* sRGB */
  GRK_ENUM_CLRSPC_GRAY = 17, /* grayscale */
  GRK_ENUM_CLRSPC_SYCC = 18, /* standard YCC */
  GRK_ENUM_CLRSPC_CIEJAB = 19, /* CIEJAB */
  GRK_ENUM_CLRSPC_ESRGB = 20, /* e-sRGB */
  GRK_ENUM_CLRSPC_ROMMRGB = 21, /* Reference Output Medium Metric RGB */
  GRK_ENUM_CLRSPC_YPBPR60 = 22, /* YPbPr 60 */
  GRK_ENUM_CLRSPC_YPBPR50 = 23, /* YPbPr 50 */
  GRK_ENUM_CLRSPC_EYCC = 24, /* extended YCC */
} GRK_ENUM_COLOUR_SPACE;

#define GRK_NUM_COMMENTS_SUPPORTED 256

#define GRK_NUM_ASOC_BOXES_SUPPORTED 256

#define GRK_NUM_XML_BOXES_SUPPORTED 64

#define GRK_MAX_COMMENT_LENGTH (UINT16_MAX - 2)

#define GRK_MAX_SUPPORTED_IMAGE_PRECISION 16

#define GRK_BIBO_EXTRA_BITS 7

#define GRK_MAX_PASSES (3 * (GRK_MAX_SUPPORTED_IMAGE_PRECISION + GRK_BIBO_EXTRA_BITS) - 2)

typedef void (*grk_msg_callback)(const char* msg, void* client_data);

typedef struct _grk_msg_handlers
{
  grk_msg_callback info_callback;
  void* info_data;
  grk_msg_callback debug_callback;
  void* debug_data;
  grk_msg_callback trace_callback;
  void* trace_data;
  grk_msg_callback warn_callback;
  void* warn_data;
  grk_msg_callback error_callback;
  void* error_data;
} grk_msg_handlers;

typedef struct _grk_object
{
  void* wrapper; /* opaque wrapper */
} grk_object;

typedef struct _grk_progression
{
  GRK_PROG_ORDER progression; /* progression */
  char progression_str[5]; /* progression as string */
  GRK_PROG_ORDER specified_compression_poc_prog; /* compression specified POC*/
  uint32_t tileno; /* tile number */

  uint32_t tx0; /* tile x0 */
  uint32_t ty0; /* tile y0 */
  uint32_t tx1; /* tile x1 */
  uint32_t ty1; /* tile y1 */

  uint16_t comp_s; /* component start */
  uint16_t comp_e; /* component end */
  uint8_t res_s; /* resolution start */
  uint8_t res_e; /* resolution end */
  uint64_t prec_s; /* precinct start */
  uint64_t prec_e; /* precinct end */
  uint16_t lay_s; /* layer start */
  uint16_t lay_e; /* layer end */
  uint16_t tp_comp_s; /* tile part component start */
  uint16_t tp_comp_e; /* tile part component end */
  uint8_t tp_res_s; /* tile part resolution start */
  uint8_t tp_res_e; /* tile part resolution end */
  uint64_t tp_prec_e; /* tile part precinct end */
  uint16_t tp_lay_e; /* tile part layer end */
  uint32_t tp_tx_s; /* tile part x start */
  uint32_t tp_tx_e; /* tile part x end */
  uint32_t tp_ty_s; /* tile part y start */
  uint32_t tp_ty_e; /* tile part y end */
  uint32_t dx; /* dx */
  uint32_t dy; /* dy */
 
  /* temporary POC variables */
  uint16_t comp_temp; /* component */
  uint8_t res_temp; /* resolution */
  uint64_t prec_temp; /* precinct */
  uint16_t lay_temp; /* layer */
  uint32_t tx0_temp; /* x0 */
  uint32_t ty0_temp; /* y0 */
} grk_progression;

typedef struct _grk_raw_comp_cparameters
{
  uint8_t dx; 
  uint8_t dy; 
} grk_raw_comp_cparameters;

typedef struct _grk_raw_cparameters
{
  uint32_t width; 
  uint32_t height; 
  uint16_t numcomps; 
  uint8_t prec; 
  bool sgnd; 
  grk_raw_comp_cparameters* comps; 
} grk_raw_cparameters;

typedef enum _GRK_RATE_CONTROL_ALGORITHM
{
  GRK_RATE_CONTROL_BISECT,
  GRK_RATE_CONTROL_PCRD_OPT
} GRK_RATE_CONTROL_ALGORITHM;

typedef enum _GRK_SUPPORTED_FILE_FMT
{
  GRK_FMT_UNK, /* unknown */
  GRK_FMT_J2K, /* J2K */
  GRK_FMT_JP2, /* JP2 */
  GRK_FMT_PXM, /* PXM */
  GRK_FMT_PGX, /* PGX */
  GRK_FMT_PAM, /* PAM */
  GRK_FMT_BMP, /* BMP */
  GRK_FMT_TIF, /* TIF */
  GRK_FMT_RAW, /* RAW Big Endian */
  GRK_FMT_PNG, /* PNG */
  GRK_FMT_RAWL, /* RAW Little Endian */
  GRK_FMT_JPG, /* JPG */
  GRK_FMT_MJ2 /* MJ2 */
} GRK_SUPPORTED_FILE_FMT;

typedef enum _GRK_CODEC_FORMAT
{
  GRK_CODEC_UNK, 
  GRK_CODEC_J2K, 
  GRK_CODEC_JP2, 
  GRK_CODEC_MJ2 
} GRK_CODEC_FORMAT;
 
#define GRK_PATH_LEN 4096 /* Grok maximum supported filename size */
#define GRK_MAX_LAYERS 256 /* Grok maximum number of quality layers */
 
/*
 * Note: range for number of decomposition levels is 0-32
 * Accordingly, range for number of resolution levels is 1-33
 */
#define GRK_MAX_DECOMP_LVLS                                        \
  32 /* Maximum number of decomposition levels allowed by standard \
      */
#define GRK_MAXRLVLS \
  (GRK_MAX_DECOMP_LVLS + 1) /* Maximum number of resolution levels allowed by standard*/
#define GRK_MAXBANDS (3 * GRK_MAXRLVLS - 2) /*  Maximum number of sub-bands allowed by standard */

 */
typedef struct _grk_component_mapping_comp
{
  uint16_t component; /* component index */
  uint8_t mapping_type; /* mapping type : 1 if mapped to paletted LUT otherwise 0 */
  uint8_t palette_column; /* palette LUT column if mapped to palette */
} grk_component_mapping_comp;

 */
typedef struct _grk_palette_data
{
  int32_t* lut; /* LUT */
  uint16_t num_entries; /* number of LUT entries */
  grk_component_mapping_comp* component_mapping; /* component mapping array*/
  uint8_t num_channels; /* number of channels */
  bool* channel_sign; /* channel signed array */
  uint8_t* channel_prec; /* channel precision array */
} grk_palette_data;
 
/***
 * Channel Definition box structures and enums.
 * When no Component mapping box is present, it is still possible to have
 * a Channel definition box, in which case channels are associated with components
 * in the obvious way : channel `k` corresponds to component `k`.
 * */
 
/* @brief Channel type */
typedef enum _GRK_CHANNEL_TYPE
{
  GRK_CHANNEL_TYPE_COLOUR = 0, /* colour */
  GRK_CHANNEL_TYPE_OPACITY = 1, /* opacity */
  GRK_CHANNEL_TYPE_PREMULTIPLIED_OPACITY = 2, /* premultiplied opacity */
  GRK_CHANNEL_TYPE_UNSPECIFIED = 65535U /* unspecified */
} GRK_CHANNEL_TYPE;

 */
typedef enum _GRK_CHANNEL_ASSOC
{
  GRK_CHANNEL_ASSOC_WHOLE_IMAGE = 0, /* whole image */
  GRK_CHANNEL_ASSOC_COLOUR_1 = 1, /* colour 1 */
  GRK_CHANNEL_ASSOC_COLOUR_2 = 2, /* colour 2 */
  GRK_CHANNEL_ASSOC_COLOUR_3 = 3, /* colour 3 */
  GRK_CHANNEL_ASSOC_UNASSOCIATED = 65535U /* unassociated */
} GRK_CHANNEL_ASSOC;

 */
typedef struct _grk_channel_description
{
  uint16_t channel; /* channel */
  uint16_t typ; /* type */
  uint16_t asoc; /* association */
} grk_channel_description;

 */
typedef struct _grk_channel_definition
{
  grk_channel_description* descriptions; /* channel description array */
  uint16_t num_channel_descriptions; /* size of channel description array */
} grk_channel_definition;

 */
typedef struct _grk_asoc
{
  uint32_t level; /* level: 0 for root level */
  const char* label; /* label */
  uint8_t* xml; /* xml */
  uint32_t xml_len; /* xml length */
} grk_asoc;

 */
typedef enum _grk_precision_mode
{
  GRK_PREC_MODE_CLIP, /* clip */
  GRK_PREC_MODE_SCALE /* scale */
} grk_precision_mode;

 */
typedef struct _grk_precision
{
  uint8_t prec; /* precision */
  grk_precision_mode mode; /* mode */
} grk_precision;

 */
typedef struct _grk_progression_state
{
  uint8_t num_resolutions;
  uint16_t layers_per_resolution[33];
  uint16_t numcomps;
  uint16_t comp[256];
  bool single_tile;
  uint16_t tile_index;
} grk_progression_state;

 */
typedef struct _grk_io_buf
{
  uint8_t* data; /* data */
  size_t offset; /* offset */
  size_t len; /* length */
  size_t alloc_len; /* allocated length */
  bool pooled; /* pooled */
  uint32_t index; /* index */
} grk_io_buf;

 */
typedef struct _grk_io_init
{
  uint32_t max_pooled_requests; /* max pooled requests */
 
} grk_io_init;

typedef bool (*grk_io_callback)(uint32_t worker_id, grk_io_buf buffer, void* io_user_data);

typedef void (*grk_io_register_reclaim_callback)(grk_io_init io_init,
                                                 grk_io_callback reclaim_callback,
                                                 void* io_user_data, void* reclaim_user_data);

typedef bool (*grk_io_pixels_callback)(uint32_t worker_id, grk_io_buf buffer, void* user_data);

typedef size_t (*grk_stream_read_fn)(uint8_t* buffer, size_t numBytes, void* user_data);

typedef size_t (*grk_stream_write_fn)(const uint8_t* buffer, size_t numBytes, void* user_data);

typedef bool (*grk_stream_seek_fn)(uint64_t offset, void* user_data);

typedef void (*grk_stream_free_user_data_fn)(void* user_data);

 */
typedef struct _grk_stream_params
{
  /* 0. General Streaming */
  size_t initial_offset; /* initial offset into stream */
  size_t double_buffer_len; /* length of internal double buffer
                               for stdio and callback streaming */
  size_t initial_double_buffer_len; /* choose a larger initial length
                                       to read the main header in one go */
  bool from_network; /* indicates stream source is on network if true */
  bool is_read_stream; /* true if read stream, otherwise false */
 
  /* 1. File Streaming */
  char file[GRK_PATH_LEN];
  bool use_stdio; /* use C file api - if false then use memory mapping */
 
  /* 2. Buffer Streaming */
  uint8_t* buf; /* data buffer */
  size_t buf_len; /* data buffer length */
  size_t buf_compressed_len; /* length of compressed stream (set by compressor, not client) */
 
  /* 3. Callback Streaming */
  grk_stream_read_fn read_fn; /* read function */
  grk_stream_write_fn write_fn; /* write function */
  grk_stream_seek_fn seek_fn; /* seek function */
  grk_stream_free_user_data_fn free_user_data_fn; /* optional */
  void* user_data; /* user data */
  size_t stream_len; /* mandatory for read stream */
 
  /* 4 Authorization */
  char username[129]; /* AWS access key ID: max 128 chars + null */
  char password[129]; /* Secret access key: max 128 chars + null */
  char bearer_token[4097]; /* Session token: up to 4096 chars + null */
#define GRK_MAX_CUSTOM_HEADERS 16
  char custom_headers[GRK_MAX_CUSTOM_HEADERS][1024]; /* Custom HTTP headers */
  uint8_t
      num_custom_headers; /* Number of entries in custom_headers[] (0..GRK_MAX_CUSTOM_HEADERS) */
  char region[64]; /* Region code: max 50 chars + buffer */
 
  /* 5 S3 Endpoint Configuration (for S3-compatible services like MinIO) */
  char s3_endpoint[256]; /* Custom S3 endpoint URL (e.g. "http://localhost:9000") */
  int8_t s3_use_https; /* 0 = auto (default), 1 = HTTPS, -1 = HTTP */
  int8_t s3_use_virtual_hosting; /* 0 = auto (default), 1 = virtual-hosted, -1 = path-style */
  bool s3_no_sign_request; /* true = skip authentication (public buckets) */
  bool s3_allow_insecure; /* true = disable SSL certificate verification */
 
  /* 6 HTTP cookies */
  char cookie[4096]; /* inline cookie string for CURLOPT_COOKIE
                        (e.g. "name1=value1; name2=value2") */
  char cookie_file[GRK_PATH_LEN]; /* path passed to CURLOPT_COOKIEFILE
                                     (read cookies from a Netscape/HTTP file) */
  char cookie_jar[GRK_PATH_LEN]; /* path passed to CURLOPT_COOKIEJAR
                                    (write cookies on cleanup) */
 
  /* 7 .netrc credentials */
  bool netrc; /* true = enable .netrc lookup (CURLOPT_NETRC=REQUIRED) */
  char netrc_file[GRK_PATH_LEN]; /* optional explicit .netrc path
                                    (CURLOPT_NETRC_FILE) */
 
  /* 8 Proxy */
  char proxy[512]; /* proxy URL (e.g. "http://proxy:8080") */
  char proxy_userpwd[256]; /* proxy credentials ("user:password") */
 
  /* 9 Requester pays (S3) */
  char request_payer[64]; /* e.g. "requester" for x-amz-request-payer header */
 
  /* 10 User agent */
  char user_agent[256]; /* custom User-Agent header string */
 
  /* 11 Timeouts (seconds, 0 = use default) */
  long timeout; /* overall request timeout (CURLOPT_TIMEOUT) */
  long connect_timeout; /* connection timeout (CURLOPT_CONNECTTIMEOUT) */
 
  /* 12 Retry configuration (0 = use default) */
  uint32_t max_retry; /* maximum number of retries */
  uint32_t retry_delay; /* delay between retries in seconds */
 
} grk_stream_params;

#define GRK_TILE_CACHE_NONE 0 /* no tile caching */
#define GRK_TILE_CACHE_IMAGE 1 /* cache final tile image */
#define GRK_TILE_CACHE_ALL 2 /* cache everything */
#define GRK_TILE_CACHE_LRU 4 /* LRU: release decompressed data, keep processor */
 
typedef struct _grk_image grk_image;

typedef bool (*grk_io_band_callback)(uint32_t yBegin, uint32_t yEnd, grk_image* image,
                                     void* user_data);

typedef void (*grk_decompress_callback)(void* codec, uint16_t tile_index, grk_image* tile_image,
                                        uint8_t reduction, void* user_data);

#define GRK_RANDOM_ACCESS_PLT 1 /* Disable PLT marker if present */
#define GRK_RANDOM_ACCESS_TLM 2 /* Disable TLM marker if present */
#define GRK_RANDOM_ACCESS_PLM 4 /* Disable PLM marker if present */

 */
typedef struct _grk_decompress_core_params
{
  uint8_t reduce;
  uint16_t layers_to_decompress;
  uint32_t tile_cache_strategy; /* tile cache strategy */
  uint16_t
      max_active_tiles; /* max tiles with decompressed data (LRU eviction limit, 0 = unlimited) */
  uint32_t disable_random_access_flags; /* disable random access flags */
  bool skip_allocate_composite; /* skip allocate composite image data for multi-tile */
  grk_io_pixels_callback io_buffer_callback; /* IO buffer callback */
  void* io_user_data; /* IO user data */
  grk_io_register_reclaim_callback io_register_client_callback; /* IO register client callback */
  grk_io_band_callback io_band_callback; /* band completion callback for incremental write */
  void* io_band_user_data; /* band callback user data */
  uint16_t* comps_to_decode;
  uint16_t num_comps_to_decode;
  bool fast_16bit_mct; /* opt into fast 16-bit DWT path for 9/7 MCT decompress (prec <= 12) */
} grk_decompress_core_params;

#define GRK_DECOMPRESS_COMPRESSION_LEVEL_DEFAULT (UINT_MAX)

 */
typedef struct _grk_decompress_params
{
  grk_decompress_core_params core; /* core parameters */
  bool asynchronous; /* if true then decompression is executed asynchronously */
  bool simulate_synchronous;
  grk_decompress_callback decompress_callback; /* callback for asynchronous decompression */
  void* decompress_callback_user_data; /* user data passed to callback for asynchronous
                                          decompression */
  char infile[GRK_PATH_LEN]; /* input file */
  char outfile[GRK_PATH_LEN]; /* output file */
  GRK_CODEC_FORMAT decod_format; /* input decode format */
  GRK_SUPPORTED_FILE_FMT cod_format; /* output code format */
  double dw_x0; /* decompress window left boundary*/
  double dw_x1; /* decompress window right boundary*/
  double dw_y0; /* decompress window top boundary*/
  double dw_y1; /* decompress window bottom boundary*/
  uint16_t tile_index; /* index of decompressed tile*/
 
  /***************************************************************************
     Note: when using Grok API, the following parameters should be set
     on the HeaderInfo struct before reading the header. Otherwise they
     will be ignored
  */
  GRK_COLOR_SPACE color_space;
  bool force_rgb; /* force output to sRGB */
  bool upsample; /* upsample components according to their dx and dy values*/
  grk_precision* precision; /* precision array */
  uint32_t num_precision; /* size of precision array*/
  bool split_by_component; /* split output components to different files for PNM */
  bool single_tile_decompress; /* single tile decompress */
  /************************************************************************** */
 
  bool io_xml; /* serialize XML metedata to disk*/
  uint32_t compression; /* compression */
  uint32_t compression_level; /* compression "quality" - meaning depends on output file format */
  uint32_t duration; /* duration of decompression in seconds */
  uint32_t repeats; /* number of repetitions */
  uint32_t num_threads; /* number of CPU threads */
 
  uint32_t kernel_build_options; /* plugin OpenCL kernel build options */
  int32_t device_id; /* plugin device ID */
  void* user_data; /* plugin user data */
} grk_decompress_parameters;

 */
typedef enum _grk_data_type
{
  GRK_INT_32,
  GRK_INT_16,
  GRK_INT_8,
  GRK_FLOAT,
  GRK_DOUBLE
} grk_data_type;

 */
typedef struct _grk_image_comp
{
  uint32_t x0; /* x offset relative to whole image */
  uint32_t y0; /* y offset relative to whole image */
  uint32_t w; /* width */
  uint32_t stride; /* stride */
  uint32_t h; /* height */
  uint8_t dx; /* horizontal separation of component samples with respect to reference grid  */
  uint8_t dy; /* vertical separation of component samples with respect to reference grid  */
  uint8_t prec; /* precision */
  bool sgnd; /* true if component data is signed */
  GRK_CHANNEL_TYPE type; /* channel type */
  GRK_CHANNEL_ASSOC association; /* channel association */
  uint16_t crg_x; /* component registration x coordinate */
  uint16_t crg_y; /* component registration y coordinate */
  grk_data_type data_type;
  void* data; /* component data */
  bool owns_data; /* true if data is owned by component */
} grk_image_comp;

 */
typedef struct _grk_color
{
  uint8_t* icc_profile_buf; /* ICC profile buffer */
  uint32_t icc_profile_len; /* ICC profile length */
  char* icc_profile_name; /* ICC profile name */
  grk_channel_definition* channel_definition; /* channel definition */
  grk_palette_data* palette; /* palette */
  bool has_colour_specification_box; /* true if colour specification box present*/
} grk_color;

 */
typedef struct _grk_image_meta
{
  grk_object obj; /* object */
  grk_color color; /* color */
  uint8_t* iptc_buf; /* IPTC buffer */
  size_t iptc_len; /* IPTC length */
  uint8_t* xmp_buf; /* XMP buffer */
  size_t xmp_len; /* XMP length */
  uint8_t* exif_buf; /* EXIF buffer (TIFF-structured) */
  size_t exif_len; /* EXIF length */
  uint8_t* geotiff_buf; /* GeoTIFF UUID box data (degenerate GeoTIFF) */
  size_t geotiff_len; /* GeoTIFF UUID box data length */
  uint8_t* ipr_data; /* IPR (Intellectual Property) box data */
  size_t ipr_len; /* IPR box data length */
  uint8_t* xml_buf; /* XML box data */
  size_t xml_len; /* XML box data length */
  grk_asoc* asoc_boxes; /* association boxes (for GMLJP2, etc.) */
  uint32_t num_asoc_boxes; /* number of association box entries */
} grk_image_meta;

 */
typedef struct _grk_image
{
  grk_object obj; /* object */
  uint32_t x0; /* image horizontal offset from origin of reference grid */
  uint32_t y0; /* image vertical offset from origin of reference grid */
  uint32_t x1; /* image right boundary in reference grid*/
  uint32_t y1; /* image bottom boundary in reference grid */
  uint16_t numcomps; /* number of components */
  GRK_COLOR_SPACE color_space; /* color space */
  bool palette_applied; /* true if palette applied */
  bool channel_definition_applied; /* true if channel definition applied */
  bool has_capture_resolution; /* true if capture resolution present*/
  double capture_resolution[2]; /* capture resolution */
  bool has_display_resolution; /* true if display resolution present*/
  double display_resolution[2]; /* display resolution */
  GRK_SUPPORTED_FILE_FMT decompress_fmt; /* decompress format */
  bool force_rgb; /* force RGB */
  bool upsample; /* upsample */
  grk_precision* precision; /* precision */
  uint32_t num_precision; /* number of precision */
  bool has_multiple_tiles; /* has multiple tiles */
  bool split_by_component; /* split by component */
  uint16_t decompress_num_comps; /* decompress number of components */
  uint32_t decompress_width; /* decompress width */
  uint32_t decompress_height; /* decompress height */
  uint8_t decompress_prec; /* decompress precision */
  GRK_COLOR_SPACE decompress_colour_space; /* decompress colour space */
  grk_io_buf interleaved_data; /* interleaved data */
  uint32_t rows_per_strip; /* for storage to output format */
  uint32_t rows_per_task; /* for scheduling */
  uint64_t packed_row_bytes; /* packed row bytes */
  grk_image_meta* meta; /* image meta data */
  grk_image_comp* comps; /* components array */
} grk_image;

 */
typedef struct _grk_header_info
{
  /************************************************************
  Variables below are populated by library after reading header
  *************************************************************/
  grk_image header_image;
  uint32_t cblockw_init; /* nominal code block width, default 64 */
  uint32_t cblockh_init; /* nominal code block height, default 64 */
  bool irreversible; /* true if image compressed irreversibly*/
  uint8_t mct; /* multi-component transform */
  uint16_t rsiz; /* RSIZ */
  uint8_t numresolutions; /* number of resolutions */
  GRK_PROG_ORDER prog_order; /* progression order */
  /********************************************************************************
  coding style
  Can be specified in main header COD segment,
  tile header COD segment, and tile component COC segment.
   Important note: we assume that coding style does not vary across tile components
  *********************************************************************************/
  uint8_t csty;
  /************************************************************************************
  code block style
  Can be specified in main header COD segment, and can   be overridden in a tile header.
  Important note: we assume that code block style does not vary across tiles
  ************************************************************************************/
  uint8_t cblk_sty;
  uint32_t prcw_init[GRK_MAXRLVLS]; /* nominal precinct width */
  uint32_t prch_init[GRK_MAXRLVLS]; /* nominal precinct height */
  uint32_t tx0; /* XTOsiz */
  uint32_t ty0; /* YTOsiz */
  uint32_t t_width; /* XTsiz */
  uint32_t t_height; /* YTsiz */
  uint16_t t_grid_width; /* tile grid width */
  uint16_t t_grid_height; /* tile grid height */
  uint16_t num_layers; /* number of layers */
  uint8_t* xml_data; /* XML data - will remain valid until codec destroyed */
  size_t xml_data_len; /* XML data length */
  uint8_t* xml_boxes_data[GRK_NUM_XML_BOXES_SUPPORTED]; /* additional XML box data */
  size_t xml_boxes_len[GRK_NUM_XML_BOXES_SUPPORTED]; /* additional XML box lengths */
  uint32_t num_xml_boxes; /* total number of XML boxes (including xml_data if present) */
  size_t num_comments; /* number of comments */
  char* comment[GRK_NUM_COMMENTS_SUPPORTED]; /* comment */
  uint16_t comment_len[GRK_NUM_COMMENTS_SUPPORTED]; /* comment length */
  bool is_binary_comment[GRK_NUM_COMMENTS_SUPPORTED]; /* is binary comment */
  grk_asoc asocs[GRK_NUM_ASOC_BOXES_SUPPORTED]; /* associations */
  uint32_t num_asocs; /* number of associations */
 
  /********************************
  Variables below are set by client
  ********************************/
  GRK_COLOR_SPACE color_space;
  GRK_SUPPORTED_FILE_FMT decompress_fmt; /* decompress format */
  bool force_rgb; /* force RGB */
  bool upsample; /* upsample */
  grk_precision* precision; /* precision */
  uint32_t num_precision; /* number of precision */
  bool split_by_component; /* split by component */
  bool single_tile_decompress; /* single tile decompress */
} grk_header_info;

 */
typedef struct grk_swath_buffer
{
  void* data; 
  uint8_t prec; 
  bool sgnd; 
  uint16_t numcomps; 
  int64_t pixel_space; 
  int64_t line_space; 
  int64_t band_space; 
  int* band_map; 
  int promote_alpha; 
  uint32_t x0; 
  uint32_t y0; 
  uint32_t x1; 
  uint32_t y1; 
} grk_swath_buffer;

 */
typedef struct grk_wait_swath
{
  uint32_t x0; 
  uint32_t y0; 
  uint32_t x1; 
  uint32_t y1; 
  uint16_t tile_x0; 
  uint16_t tile_y0; 
  uint16_t tile_x1; 
  uint16_t tile_y1; 
  uint16_t num_tile_cols; 
} grk_wait_swath;
 */
typedef struct _grk_plugin_pass
{
  double distortion_decrease; /* distortion decrease up to and including this pass */
  size_t rate; /* rate up to and including this pass */
  size_t length; /* stream length for this pass */
} grk_plugin_pass;

 */
typedef struct _grk_plugin_code_block
{
  /**************************
  debug info
  **************************/
  uint32_t x0, y0, x1, y1; /* x0, y0, x1, y1 */
  unsigned int* context_stream; /* context stream */
  /***************************/
 
  uint32_t num_pix; /* number of pixels */
  uint8_t* compressed_data; /* compressed data */
  uint32_t compressed_data_length; /* compressed data length */
  uint8_t num_bit_planes; /* number of bit planes */
  uint8_t num_passes; /* number of passes */
  grk_plugin_pass passes[GRK_MAX_PASSES]; /* passes */
  unsigned int sorted_index; /* sorted index */
} grk_plugin_code_block;

 */
typedef struct _grk_plugin_precinct
{
  uint64_t num_blocks; /* number of blocks */
  grk_plugin_code_block** blocks; /* blocks */
} grk_plugin_precinct;

 */
typedef struct _grk_plugin_band
{
  uint8_t orientation; /* orientation */
  uint64_t num_precincts; /* number of precincts */
  grk_plugin_precinct** precincts; /* precincts */
  float stepsize; /* stepsize */
} grk_plugin_band;

 */
typedef struct _grk_plugin_resolution
{
  uint8_t level; /* level */
  uint8_t num_bands; /* number of bands */
  grk_plugin_band** band; /* band */
} grk_plugin_resolution;

 */
typedef struct grk_plugin_tile_component
{
  uint8_t numresolutions; /* number of resolutions */
  grk_plugin_resolution** resolutions; /* resolutions */
} grk_plugin_tile_component;
 
#define GRK_DECODE_HEADER (1 << 0)
#define GRK_DECODE_T2 (1 << 1)
#define GRK_DECODE_T1 (1 << 2)
#define GRK_DECODE_POST_T1 (1 << 3)
#define GRK_PLUGIN_DECODE_CLEAN (1 << 4)
#define GRK_DECODE_ALL \
  (GRK_PLUGIN_DECODE_CLEAN | GRK_DECODE_HEADER | GRK_DECODE_T2 | GRK_DECODE_T1 | GRK_DECODE_POST_T1)

 */
typedef struct _grk_plugin_tile
{
  uint32_t decompress_flags; /* decompress flags */
  uint16_t num_components; /* number of components */
  grk_plugin_tile_component** tile_components; /* tile components */
} grk_plugin_tile;

GRK_API const char* GRK_CALLCONV grk_version(void);

GRK_API bool GRK_CALLCONV grk_detect_format(const char* file_path, GRK_CODEC_FORMAT* format);

GRK_API void GRK_CALLCONV grk_initialize(const char* plugin_path, uint32_t num_threads,
                                         bool* plugin_initialized);

GRK_API void GRK_CALLCONV grk_deinitialize(void);

GRK_API grk_object* GRK_CALLCONV grk_object_ref(grk_object* obj);

GRK_API void GRK_CALLCONV grk_object_unref(grk_object* obj);

GRK_API void GRK_CALLCONV grk_set_msg_handlers(grk_msg_handlers msg_handlers);

GRK_API grk_image* GRK_CALLCONV grk_image_new(uint16_t numcmpts, grk_image_comp* cmptparms,
                                              GRK_COLOR_SPACE clrspc, bool alloc_data);

GRK_API grk_data_type GRK_CALLCONV grk_get_data_type(bool compress, uint8_t prec, bool is_mct,
                                                     uint8_t qmfbid, bool fast_mct);

GRK_API grk_image_meta* GRK_CALLCONV grk_image_meta_new(void);

GRK_API bool GRK_CALLCONV grk_image_meta_set_field(grk_image_meta* meta, const char* field,
                                                   const uint8_t* data, size_t len);

GRK_API bool GRK_CALLCONV grk_image_meta_get_field(grk_image_meta* meta, const char* field,
                                                   uint8_t** data, size_t* len);

GRK_API bool GRK_CALLCONV grk_image_meta_set_asocs(grk_image_meta* meta, const grk_asoc* asocs,
                                                   uint32_t num_asocs);

GRK_API grk_object* GRK_CALLCONV grk_decompress_init(grk_stream_params* stream_params,
                                                     grk_decompress_parameters* params);

GRK_API bool GRK_CALLCONV grk_decompress_update(grk_decompress_parameters* params,
                                                grk_object* codec);

GRK_API grk_progression_state GRK_CALLCONV
    grk_decompress_get_progression_state(grk_object* codec, uint16_t tile_index);

GRK_API bool GRK_CALLCONV grk_decompress_set_progression_state(grk_object* codec,
                                                               grk_progression_state state);

GRK_API bool GRK_CALLCONV grk_decompress_read_header(grk_object* codec,
                                                     grk_header_info* header_info);

GRK_API grk_image* GRK_CALLCONV grk_decompress_get_tile_image(grk_object* codec,
                                                              uint16_t tile_index, bool wait);

GRK_API grk_image* GRK_CALLCONV grk_decompress_get_image(grk_object* codec);

GRK_API void GRK_CALLCONV grk_decompress_set_band_callback(grk_object* codec,
                                                           grk_io_band_callback callback,
                                                           void* user_data);

GRK_API bool GRK_CALLCONV grk_image_is_post_process_no_op(grk_image* image);

GRK_API bool GRK_CALLCONV grk_decompress(grk_object* codec, grk_plugin_tile* tile);

GRK_API void GRK_CALLCONV grk_decompress_wait(grk_object* codec, grk_wait_swath* swath);

GRK_API void GRK_CALLCONV grk_decompress_schedule_swath_copy(grk_object* codec,
                                                             const grk_wait_swath* swath,
                                                             grk_swath_buffer* buf);

GRK_API void GRK_CALLCONV grk_decompress_wait_swath_copy(grk_object* codec);

GRK_API void GRK_CALLCONV grk_copy_tile_to_swath(const grk_image* tile_img,
                                                 const grk_swath_buffer* buf);

GRK_API bool GRK_CALLCONV grk_decompress_tile(grk_object* codec, uint16_t tile_index);

GRK_API uint32_t GRK_CALLCONV grk_decompress_num_samples(grk_object* codec);

GRK_API bool GRK_CALLCONV grk_decompress_sample(grk_object* codec, uint32_t sample_index);

GRK_API grk_image* GRK_CALLCONV grk_decompress_get_sample_image(grk_object* codec,
                                                                uint32_t sample_index);

GRK_API grk_image* GRK_CALLCONV grk_decompress_get_sample_tile_image(grk_object* codec,
                                                                     uint32_t sample_index,
                                                                     uint16_t tile_index);
 
/* COMPRESSION FUNCTIONS*/

 */
typedef struct _grk_cparameters
{
  bool tile_size_on; /* tile size on */
  uint32_t tx0; /* XTOsiz */
  uint32_t ty0; /* YTOsiz */
  uint32_t t_width; /* XTsiz */
  uint32_t t_height; /* YTsiz */
  uint16_t numlayers; /* number of layers */
  bool allocation_by_rate_distortion; /* allocation by rate distortion */
  double layer_rate[GRK_MAX_LAYERS]; /* layer rate */
  bool allocation_by_quality; /* rate control allocation by fixed_PSNR quality */
  double layer_distortion[GRK_MAX_LAYERS]; /* layer PSNR values */
  char* comment[GRK_NUM_COMMENTS_SUPPORTED]; /* comment */
  uint16_t comment_len[GRK_NUM_COMMENTS_SUPPORTED]; /* comment length */
  bool is_binary_comment[GRK_NUM_COMMENTS_SUPPORTED]; /* is binary comment */
  size_t num_comments; /* number of comments */
  uint8_t csty; /* coding style */
  uint8_t numgbits; /* number of guard bits */
  GRK_PROG_ORDER prog_order; /* progression order (default LRCP)*/
  grk_progression progression[GRK_MAXRLVLS]; /* progression array */
  uint32_t numpocs; /* number of progression order changes (POCs) */
  uint8_t numresolution; /* number of resolutions */
  uint32_t cblockw_init; /* nominal code block width (default 64) */
  uint32_t cblockh_init; /* nominal code block height (default 64) */
  uint8_t cblk_sty; /* code block style */
  bool irreversible; /* true if irreversible compression enabled, default false */
  int32_t roi_compno; /* ROI component number */
  uint32_t roi_shift; /* ROI upshift */
  /* number of precinct size specifications */
  uint32_t res_spec; /* res spec */
  uint32_t prcw_init[GRK_MAXRLVLS]; /* nominal precinct width */
  uint32_t prch_init[GRK_MAXRLVLS]; /* nominal precinct height */
  char infile[GRK_PATH_LEN]; /* input file */
  char outfile[GRK_PATH_LEN]; /* output file */
  uint32_t image_offset_x0; /* image offset x0 */
  uint32_t image_offset_y0; /* image offset y0 */
  uint8_t subsampling_dx; /* subsampling dx */
  uint8_t subsampling_dy; /* subsampling dy */
  GRK_SUPPORTED_FILE_FMT decod_format; /* input decode format */
  GRK_SUPPORTED_FILE_FMT cod_format; /* output code format */
  grk_raw_cparameters raw_cp; /* raw parameters */
  bool enable_tile_part_generation; /* enable tile part generation */
  uint8_t new_tile_part_progression_divider; /* new tile part progression divider */
  uint8_t mct; /* MCT */
  void* mct_data; /* MCT data */
  uint64_t max_cs_size; /* max code stream size */
  uint64_t max_comp_size; /* max component size */
  uint16_t rsiz; /* RSIZ */
  uint16_t framerate; /* frame rate */
 
  bool write_capture_resolution_from_file; /* write capture resolution from file */
  double capture_resolution_from_file[2]; /* capture resolution from file */
  bool write_capture_resolution; /* write capture resolution */
  double capture_resolution[2]; /* capture resolution */
  bool write_display_resolution; /* write display resolution */
  double display_resolution[2]; /* display resolution */
 
  bool apply_icc; /* apply ICC */
 
  GRK_RATE_CONTROL_ALGORITHM rate_control_algorithm; /* rate control algorithm */
  uint32_t num_threads; /* number of threads */
  int32_t device_id; /* device ID */
  uint32_t duration; /* duration seconds */
  uint32_t kernel_build_options; /* kernel build options */
  uint32_t repeats; /* repeats */
  bool write_plt; /* write PLT */
  bool write_tlm; /* write TLM */
  bool shared_memory_interface; /* shared memory interface */
  bool jpx_branding; /* advertise jpx brand (enables asoc/lbl boxes) */
  bool write_rreq; /* write reader requirements box */
  uint16_t rreq_standard_features[8]; /* standard features for rreq box */
  uint8_t num_rreq_standard_features; /* number of standard features */
  bool geoboxes_after_jp2c; /* write metadata boxes (UUID, asoc, XML) after codestream */
 
  /* Transcode mode: rewrite JP2 boxes while copying the codestream verbatim.
   * Set transcode=true and populate transcode_src with the source stream.
   * The image passed to grk_transcode() provides the metadata for the new boxes.
   * Codestream modification (TLM/PLT insertion, SOP/EPH injection, layer/resolution
   * stripping, progression reorder) is also supported in this mode. */
  bool transcode; /* enable transcode mode */
  grk_stream_params transcode_src; /* source stream to copy codestream from */
  bool write_sop; /* inject SOP markers during transcode */
  bool write_eph; /* inject EPH markers during transcode */
  uint16_t max_layers_transcode; /* max quality layers to keep (0 = all) */
  uint8_t max_res_transcode; /* max resolutions to keep (0 = all) */
  GRK_PROG_ORDER
  transcode_prog_order; /* reorder packets to this progression (GRK_PROG_UNKNOWN = keep) */
} grk_cparameters;

GRK_API void GRK_CALLCONV grk_compress_set_default_params(grk_cparameters* parameters);

GRK_API grk_object* GRK_CALLCONV grk_compress_init(grk_stream_params* stream_params,
                                                   grk_cparameters* parameters, grk_image* image);
GRK_API uint64_t GRK_CALLCONV grk_compress(grk_object* codec, grk_plugin_tile* tile);

GRK_API uint64_t GRK_CALLCONV grk_compress_frame(grk_object* codec, grk_image* image,
                                                 grk_plugin_tile* tile);

GRK_API bool GRK_CALLCONV grk_compress_finish(grk_object* codec);

GRK_API uint64_t GRK_CALLCONV grk_compress_get_compressed_length(grk_object* codec);

GRK_API uint64_t GRK_CALLCONV grk_transcode(grk_stream_params* src_stream,
                                            grk_stream_params* dst_stream,
                                            grk_cparameters* parameters, grk_image* image);

GRK_API void GRK_CALLCONV grk_dump_codec(grk_object* codec, uint32_t info_flag,
                                         FILE* output_stream);

GRK_API bool GRK_CALLCONV grk_set_MCT(grk_cparameters* parameters, const float* encoding_matrix,
                                      const int32_t* dc_shift, uint32_t nb_comp);
 
/* Decoder state flags */
#define GRK_IMG_INFO 1 /* Basic image information provided to the user */
#define GRK_MH_INFO 2 /* Codestream information based only on the main header */
#define GRK_TH_INFO 4 /* Tile information based on the current tile header */
#define GRK_TCH_INFO 8 
#define GRK_MH_IND 16 
#define GRK_TH_IND 32 
 
/* Code block styles */
#define GRK_CBLKSTY_LAZY 0x01 
#define GRK_CBLKSTY_RESET 0x02 
#define GRK_CBLKSTY_TERMALL 0x04 
#define GRK_CBLKSTY_VSC 0x08 
#define GRK_CBLKSTY_PTERM 0x10 
#define GRK_CBLKSTY_SEGSYM 0x20 
#define GRK_CBLKSTY_HT_ONLY 0x40 
#define GRK_CBLKSTY_HT_MIXED 0xC0 
#define GRK_JPH_RSIZ_FLAG 0x4000 
 
/*****************************************************************************
 * JPEG 2000 Profiles, see Table A.10 from 15444-1 (updated in various AMDs)
 *
 * These values help choose the RSIZ value for the JPEG 2000 code stream.
 * The RSIZ value forces various compressing options, as detailed in Table A.10.
 * If GRK_PROFILE_PART2 is chosen, it must be combined with one or more extensions
 * described below.
 *
 *   Example: rsiz = GRK_PROFILE_PART2 | GRK_EXTENSION_MCT;
 *
 * For broadcast profiles, the GRK_PROFILE_X value has to be combined with the target
 * level (3-0 LSB, value between 0 and 11):
 *   Example: rsiz = GRK_PROFILE_BC_MULTI | 0x0005; (level equals 5)
 *
 * For IMF profiles, the GRK_PROFILE_X value has to be combined with the target main-level
 * (3-0 LSB, value between 0 and 11) and sub-level (7-4 LSB, value between 0 and 9):
 *   Example: rsiz = GRK_PROFILE_IMF_2K | 0x0040 | 0x0005; (main-level equals 5 and sub-level
 * equals 4
 *
 * */
#define GRK_PROFILE_NONE 0x0000 
#define GRK_PROFILE_0 0x0001 
#define GRK_PROFILE_1 0x0002 
#define GRK_PROFILE_CINEMA_2K 0x0003 
#define GRK_PROFILE_CINEMA_4K 0x0004 
#define GRK_PROFILE_CINEMA_S2K 0x0005 
#define GRK_PROFILE_CINEMA_S4K 0x0006 
#define GRK_PROFILE_CINEMA_LTS \
  0x0007 
#define GRK_PROFILE_BC_SINGLE 0x0100 
#define GRK_PROFILE_BC_MULTI 0x0200 
#define GRK_PROFILE_BC_MULTI_R \
  0x0300 
#define GRK_PROFILE_BC_MASK 0x030F 
#define GRK_PROFILE_IMF_2K 0x0400 
#define GRK_PROFILE_IMF_4K 0x0500 
#define GRK_PROFILE_IMF_8K 0x0600 
#define GRK_PROFILE_IMF_2K_R \
  0x0700 
#define GRK_PROFILE_IMF_4K_R \
  0x0800 
#define GRK_PROFILE_IMF_8K_R \
  0x0900 
#define GRK_PROFILE_MASK 0x0FFF 
#define GRK_PROFILE_PART2 0x8000 
#define GRK_PROFILE_PART2_EXTENSIONS_MASK 0x3FFF /*  Mask for Part-2 extension bits */

#define GRK_EXTENSION_NONE 0x0000 
#define GRK_EXTENSION_MCT 0x0100 
#define GRK_IS_PART2(v) ((v) & GRK_PROFILE_PART2)
 
#define GRK_IS_CINEMA(v) (((v) >= GRK_PROFILE_CINEMA_2K) && ((v) <= GRK_PROFILE_CINEMA_S4K))
#define GRK_IS_STORAGE(v) ((v) == GRK_PROFILE_CINEMA_LTS)
 
/*
 *
 * *********************************************
 * Broadcast level (3-0 LSB) (15444-1 AMD4,AMD8)
 * *********************************************
 *
 * indicates maximum bit rate and sample rate for a code stream
 *
 * Note: Mbit/s == 10^6 bits/s;  Msamples/s == 10^6 samples/s
 *
 * 0:       no maximum rate
 * 1:       200 Mbits/s, 65  Msamples/s
 * 2:       200 Mbits/s, 130 Msamples/s
 * 3:       200 Mbits/s, 195 Msamples/s
 * 4:       400 Mbits/s, 260 Msamples/s
 * 5:       800Mbits/s,  520 Msamples/s
 * >= 6:    2^(level-6) * 1600 Mbits/s, 2^(level-6) * 1200 Msamples/s
 *
 * Note: level cannot be greater than 11
 *
 * ****************
 * Broadcast tiling
 * ****************
 *
 * Either single-tile or multi-tile. Multi-tile only permits
 * 1 or 4 tiles per frame, where multiple tiles have identical
 * sizes, and are configured in either 2x2 or 1x4 layout.
 *
 *************************************************************
 *
 * ***************************************
 * IMF main-level (3-0) LSB (15444-1 AMD8)
 * ***************************************
 *
 * main-level indicates maximum number of samples per second,
 * as listed above.
 *
 *
 * **************************************
 * IMF sub-level (7-4) LSB (15444-1 AMD8)
 * **************************************
 *
 * sub-level indicates maximum bit rate for a code stream:
 *
 * 0:   no maximum rate
 * >0:  2^sub-level * 100 Mbits/second
 *
 * Note: sub-level cannot be greater than 9, and cannot be larger
 * then maximum of (main-level -2) and 1.
 *
 */
 
#define GRK_GET_IMF_OR_BROADCAST_PROFILE(v) \
  ((v) & 0x0f00) 
 
#define GRK_LEVEL_MAX 11U 
#define GRK_GET_LEVEL(v) ((v) & 0xf) 
 
/******* BROADCAST **********************************************************/
 
#define GRK_IS_BROADCAST(v)                                                        \
  (((v) >= GRK_PROFILE_BC_SINGLE) && ((v) <= (GRK_PROFILE_BC_MULTI_R | 0x000b)) && \
   (((v) & 0xf) <= 0xb))
 
/* Maximum component sampling Rate (Mbits/sec) per level */
#define GRK_BROADCAST_LEVEL_1_MBITSSEC 200U 
#define GRK_BROADCAST_LEVEL_2_MBITSSEC 200U 
#define GRK_BROADCAST_LEVEL_3_MBITSSEC 200U 
#define GRK_BROADCAST_LEVEL_4_MBITSSEC 400U 
#define GRK_BROADCAST_LEVEL_5_MBITSSEC 800U 
#define GRK_BROADCAST_LEVEL_6_MBITSSEC 1600U 
#define GRK_BROADCAST_LEVEL_7_MBITSSEC 3200U 
#define GRK_BROADCAST_LEVEL_8_MBITSSEC 6400U 
#define GRK_BROADCAST_LEVEL_9_MBITSSEC 12800U 
#define GRK_BROADCAST_LEVEL_10_MBITSSEC 25600U 
#define GRK_BROADCAST_LEVEL_11_MBITSSEC 51200U 
 
#define GRK_BROADCAST_LEVEL_1_MSAMPLESSEC 64U 
#define GRK_BROADCAST_LEVEL_2_MSAMPLESSEC 130U 
#define GRK_BROADCAST_LEVEL_3_MSAMPLESSEC 195U 
#define GRK_BROADCAST_LEVEL_4_MSAMPLESSEC 260U 
#define GRK_BROADCAST_LEVEL_5_MSAMPLESSEC 520U 
#define GRK_BROADCAST_LEVEL_6_MSAMPLESSEC 1200U 
#define GRK_BROADCAST_LEVEL_7_MSAMPLESSEC 2400U 
#define GRK_BROADCAST_LEVEL_8_MSAMPLESSEC 4800U 
#define GRK_BROADCAST_LEVEL_9_MSAMPLESSEC 9600U 
#define GRK_BROADCAST_LEVEL_10_MSAMPLESSEC 19200U 
#define GRK_BROADCAST_LEVEL_11_MSAMPLESSEC 38400U 
 
/********IMF *****************************************************************/
 
#define GRK_IS_IMF(v)                                                         \
  (((v) >= GRK_PROFILE_IMF_2K) && ((v) <= (GRK_PROFILE_IMF_8K_R | 0x009b)) && \
   (((v) & 0xf) <= 0xb) && (((v) & 0xf0) <= 0x90))
 
/* Maximum component sampling rate (MSamples/sec) per main level */
#define GRK_IMF_MAINLEVEL_1_MSAMPLESSEC 65U 
#define GRK_IMF_MAINLEVEL_2_MSAMPLESSEC 130U 
#define GRK_IMF_MAINLEVEL_3_MSAMPLESSEC 195U 
#define GRK_IMF_MAINLEVEL_4_MSAMPLESSEC 260U 
#define GRK_IMF_MAINLEVEL_5_MSAMPLESSEC 520U 
#define GRK_IMF_MAINLEVEL_6_MSAMPLESSEC 1200U 
#define GRK_IMF_MAINLEVEL_7_MSAMPLESSEC 2400U 
#define GRK_IMF_MAINLEVEL_8_MSAMPLESSEC 4800U 
#define GRK_IMF_MAINLEVEL_9_MSAMPLESSEC 9600U 
#define GRK_IMF_MAINLEVEL_10_MSAMPLESSEC 19200U 
#define GRK_IMF_MAINLEVEL_11_MSAMPLESSEC 38400U 
 
#define GRK_IMF_SUBLEVEL_MAX 9U 
#define GRK_GET_IMF_SUBLEVEL(v) (((v) >> 4) & 0xf) 

#define GRK_IMF_SUBLEVEL_1_MBITSSEC 200U 
#define GRK_IMF_SUBLEVEL_2_MBITSSEC 400U 
#define GRK_IMF_SUBLEVEL_3_MBITSSEC 800U 
#define GRK_IMF_SUBLEVEL_4_MBITSSEC 1600U 
#define GRK_IMF_SUBLEVEL_5_MBITSSEC 3200U 
#define GRK_IMF_SUBLEVEL_6_MBITSSEC 6400U 
#define GRK_IMF_SUBLEVEL_7_MBITSSEC 12800U 
#define GRK_IMF_SUBLEVEL_8_MBITSSEC 25600U 
#define GRK_IMF_SUBLEVEL_9_MBITSSEC 51200U 
/**********************************************************************************/

 
#define GRK_CINEMA_DCI_MAX_BANDWIDTH 250000000
 
#define GRK_CINEMA_24_CS 1302083 
#define GRK_CINEMA_24_COMP 1041666 
 
#define GRK_CINEMA_48_CS 651041 
#define GRK_CINEMA_48_COMP 520833 
 
#define GRK_CINEMA_4K_DEFAULT_NUM_RESOLUTIONS 7 /* Default number of resolutions for 4K cinema */
 
/*
 * CIE Lab #defines
 */
#define GRK_CUSTOM_CIELAB_SPACE 0x0
#define GRK_DEFAULT_CIELAB_SPACE 0x44454600 /* 'DEF' */
 
/*************************************************************************************
 Plugin Interface
 *************************************************************************************/

 */
typedef struct _grk_plugin_load_info
{
  const char* pluginPath; /* plugin path */
} grk_plugin_load_info;

GRK_API bool GRK_CALLCONV grk_plugin_load(grk_plugin_load_info info);

GRK_API void GRK_CALLCONV grk_plugin_cleanup(void);

#define GRK_PLUGIN_STATE_NO_DEBUG 0x0
 
/*
 For compress debugging, the plugin first performs a T1 compress.
 Then:
 1. perform host DWT on plugin MCT data, and write to host image
 This way, both plugin and host start from same point
 (assume MCT is equivalent for both host and plugin)
 2. map plugin DWT data, compare with host DWT, and then write to plugin image
 At this point in the code, the plugin image holds plugin DWT data. And if no warnings are
 triggered, then we can safely say that host and plugin DWT data are identical.
 3. Perform host compress, skipping MCT and DWT (they have already been performed)
 4. during host compress, each context that is formed is compared against context stream from plugin
 5. rate control - synch with plugin code stream, and compare
 6. T2 and store to disk
 */
 
#define GRK_PLUGIN_STATE_DEBUG 0x1
#define GRK_PLUGIN_STATE_PRE_TR1 0x2
#define GRK_PLUGIN_STATE_DWT_QUANTIZATION 0x4
#define GRK_PLUGIN_STATE_MCT_ONLY 0x8

GRK_API uint32_t GRK_CALLCONV grk_plugin_get_debug_state();
 
/*
 * @struct grk_plugin_init_info
 * @brief Plugin init info
 */
typedef struct _grk_plugin_init_info
{
  int32_t device_id; /* device ID */
  bool verbose; /* enable diagnostic logging */
  const char* license; /* license */
  const char* server; /* server */
} grk_plugin_init_info;

GRK_API bool GRK_CALLCONV grk_plugin_init(grk_plugin_init_info init_info);

 */
typedef struct grk_plugin_compress_user_callback_info
{
  const char* input_file_name; /* input file name */
  bool output_file_name_is_relative; /* output file name is relative */
  const char* output_file_name; /* output file name */
  grk_cparameters* compressor_parameters; /* compressor parameters */
  grk_image* image; /* image */
  grk_plugin_tile* tile; /* tile */
  grk_stream_params stream_params; /* stream parameters */
  unsigned int error_code; /* error code */
} grk_plugin_compress_user_callback_info;

typedef uint64_t (*GRK_PLUGIN_COMPRESS_USER_CALLBACK)(grk_plugin_compress_user_callback_info* info);

 */
typedef struct grk_plugin_compress_batch_info
{
  const char* input_dir; /* input directory */
  const char* output_dir; /* output directory */
  grk_cparameters* compress_parameters; /* compress parameters */
  GRK_PLUGIN_COMPRESS_USER_CALLBACK callback; /* callback */
} grk_plugin_compress_batch_info;

GRK_API int32_t GRK_CALLCONV grk_plugin_compress(grk_cparameters* compress_parameters,
                                                 GRK_PLUGIN_COMPRESS_USER_CALLBACK callback);

GRK_API int32_t GRK_CALLCONV grk_plugin_batch_compress(grk_plugin_compress_batch_info info);

GRK_API void GRK_CALLCONV grk_plugin_wait_for_batch_complete(void);

GRK_API void GRK_CALLCONV grk_plugin_stop_batch_compress(void);

typedef int (*GROK_INIT_DECOMPRESSORS)(grk_header_info* header_info, grk_image* image);

 */
typedef struct _grk_plugin_decompress_callback_info
{
  size_t device_id; /* device ID */
  GROK_INIT_DECOMPRESSORS init_decompressors_func; /* init decompressors func */
  const char* input_file_name; /* input file name */
  const char* output_file_name; /* output file name */
  /* input file format 0: J2K, 1: JP2 */
  GRK_CODEC_FORMAT decod_format; /* decode format */
  /* output file format 0: PGX, 1: PxM, 2: BMP etc */
  GRK_SUPPORTED_FILE_FMT cod_format; /* code format */
  grk_object* codec; /* codec */
  grk_header_info header_info; /* header info */
  grk_decompress_parameters* decompressor_parameters; /* decompressor parameters */
  grk_image* image; /* image */
  bool plugin_owns_image; /* plugin owns image */
  grk_plugin_tile* tile; /* tile */
  unsigned int error_code; /* error code */
  uint32_t decompress_flags; /* decompress flags */
  uint32_t full_image_x0; /* full image x0 */
  uint32_t full_image_y0; /* full image y0 */
  void* user_data; /* user data */
  void* format_private; /* format-specific private data */
} grk_plugin_decompress_callback_info;

typedef int32_t (*grk_plugin_decompress_callback)(grk_plugin_decompress_callback_info* info);

GRK_API int32_t GRK_CALLCONV grk_plugin_decompress(grk_decompress_parameters* decompress_parameters,
                                                   grk_plugin_decompress_callback callback);

GRK_API int32_t GRK_CALLCONV grk_plugin_init_batch_decompress(
    const char* input_dir, const char* output_dir, grk_decompress_parameters* decompress_parameters,
    grk_plugin_decompress_callback callback);

GRK_API int32_t GRK_CALLCONV grk_plugin_batch_decompress(void);

GRK_API void GRK_CALLCONV grk_plugin_stop_batch_decompress(void);
 
/*******************************************************************************
 *  Thread-pool access
 *
 *  These functions expose the core library's TaskFlow thread pool so that
 *  other libraries (e.g. the codec library) can submit work to the same
 *  pool, avoiding thread contention.
 *
 *  The returned handle is only valid between grk_initialize() and
 *  grk_deinitialize().  Internal C++ consumers should prefer the typed
 *  wrappers in grk_thread_pool.h.
 ******************************************************************************/

GRK_API void* GRK_CALLCONV grk_thread_pool(void);

GRK_API size_t GRK_CALLCONV grk_num_workers(void);

GRK_API uint32_t GRK_CALLCONV grk_worker_id(void);
 
#ifndef SWIG
#ifdef __cplusplus
}
#endif
#endif