grok.h

Go to the documentation of this file.

/*
 *    Copyright (C) 2016-2020 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/>.
 *
 *
 *    This source code incorporates work covered by the BSD 2-clause license.
 *    Please see the LICENSE file in the root directory for details.
 *
 */
 
#pragma once
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include "grk_config.h"
#include <stdint.h>
#include <stdio.h>
#include <stdbool.h>
#include <limits.h>
 
#ifdef __GNUC__
#define GRK_DEPRECATED(func) func __attribute__ ((deprecated))
#elif defined(_MSC_VER)
#define GRK_DEPRECATED(func) __declspec(deprecated) func
#else
#pragma message("WARNING: You need to implement DEPRECATED for this compiler")
#define GRK_DEPRECATED(func) func
#endif
 
#if defined(GRK_STATIC) || !defined(_WIN32)
#               if defined(GRK_STATIC) /* static library uses "hidden" */
#                       define GRK_API    __attribute__ ((visibility ("hidden")))
#               else
#                       define GRK_API    __attribute__ ((visibility ("default")))
#               endif
#       define GRK_CALLCONV
#else
#       define GRK_CALLCONV __stdcall
#       if defined(GRK_EXPORTS) || defined(DLL_EXPORT)
#               define GRK_API __declspec(dllexport)
#       else
#               define GRK_API __declspec(dllimport)
#       endif
#endif
 
enum GRK_SUPPORTED_FILE_FMT {
        GRK_UNK_FMT,
        GRK_J2K_FMT,
        GRK_JP2_FMT,
        GRK_PXM_FMT,
        GRK_PGX_FMT,
        GRK_PAM_FMT,
        GRK_BMP_FMT,
        GRK_TIF_FMT,
        GRK_RAW_FMT, /* MSB / Big Endian */
        GRK_PNG_FMT,
        GRK_RAWL_FMT, /* LSB / Little Endian */
        GRK_JPG_FMT
};
 
#define GRK_PATH_LEN 4096 
/*
 * note: range for number of decomposition levels is 0-32
 * So, accordingly, range for number of resolutions is 1-33
 * */
 
#define GRK_J2K_MAXRLVLS 33                                             
#define GRK_J2K_MAXBANDS (3*GRK_J2K_MAXRLVLS-2) 
// used by dump
#define GRK_IMG_INFO            1       
#define GRK_J2K_MH_INFO         2       
#define GRK_J2K_TH_INFO         4       
#define GRK_J2K_TCH_INFO        8       
#define GRK_J2K_MH_IND          16      
#define GRK_J2K_TH_IND          32      
#define GRK_JP2_INFO            128     
#define GRK_JP2_IND                     256     
#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          0x40  
#define GRK_JPH_RSIZ_FLAG   0x4000 
#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_24_CS     1302083U    
#define GRK_CINEMA_48_CS     651041U     
#define GRK_CINEMA_24_COMP   1041666U    
#define GRK_CINEMA_48_COMP   520833U     
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_PROG_ORDER;
 
/*
 *
 * CIE Lab #defines
 */
#define GRK_CUSTOM_CIELAB_SPACE 0x0
#define GRK_DEFAULT_CIELAB_SPACE 0x44454600  //'DEF'
#define GRK_CIE_DAY   ((((uint32_t) 'C')<<24) + (((uint32_t) 'T')<<16))
#define GRK_CIE_D50   ((uint32_t) 0x00443530)
#define GRK_CIE_D65   ((uint32_t) 0x00443635)
#define GRK_CIE_D75   ((uint32_t) 0x00443735)
#define GRK_CIE_SA   ((uint32_t) 0x00005341)
#define GRK_CIE_SC   ((uint32_t) 0x00005343)
#define GRK_CIE_F2   ((uint32_t) 0x00004632)
#define GRK_CIE_F7   ((uint32_t) 0x00004637)
#define GRK_CIE_F11   ((uint32_t) 0x00463131)
 
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;
 
/* JPEG 2000 standard values for colour spaces */
enum GRK_ENUM_COLOUR_SPACE{
        GRK_ENUM_CLRSPC_UNKNOWN = 0,
        GRK_ENUM_CLRSPC_CMYK = 12,
        GRK_ENUM_CLRSPC_CIE = 14,
        GRK_ENUM_CLRSPC_SRGB = 16,
        GRK_ENUM_CLRSPC_GRAY = 17,
        GRK_ENUM_CLRSPC_SYCC = 18,
        GRK_ENUM_CLRSPC_EYCC = 24
};
 
typedef enum _GRK_CODEC_FORMAT {
        GRK_CODEC_UNKNOWN = -1, 
        GRK_CODEC_J2K = 0, 
        GRK_CODEC_JP2 = 2 
} GRK_CODEC_FORMAT;
 
#define  GRK_NUM_COMMENTS_SUPPORTED 256
#define GRK_MAX_COMMENT_LENGTH (UINT16_MAX-2)
 
typedef void (*grk_msg_callback)(const char *msg, void *client_data);
 
/*
 ==========================================================
 codec structures
 ==========================================================
 */
 
typedef struct _grk_poc {
        uint32_t resno0, compno0;
        uint32_t layno1, resno1, compno1;
        uint32_t layno0;
        uint64_t precno0, precno1;
        GRK_PROG_ORDER prg1, prg;
        char progorder[5];
        uint32_t tile;
        uint32_t tx0, tx1, ty0, ty1;
        uint32_t resS, compS;
        uint32_t layE, resE, compE;
        uint64_t prcE;
        uint32_t txS, txE, tyS, tyE, dx, dy;
        uint32_t lay_t, res_t, comp_t, tx0_t, ty0_t;
        uint64_t prc_t;
} grk_poc;
 
typedef struct _grk_raw_comp_cparameters {
        uint32_t dx;
        uint32_t dy;
} grk_raw_comp_cparameters;
 
typedef struct _grk_raw_cparameters {
        uint32_t width;
        uint32_t height;
        uint16_t numcomps;
        uint32_t prec;
        bool sgnd;
        grk_raw_comp_cparameters *comps;
} grk_raw_cparameters;
 
typedef struct _grk_cparameters {
        bool tile_size_on;
        uint32_t tx0;
        uint32_t ty0;
        uint32_t t_width;
        uint32_t t_height;
        bool cp_disto_alloc;
        bool cp_fixed_quality;
        char *cp_comment[GRK_NUM_COMMENTS_SUPPORTED];
        uint16_t cp_comment_len[GRK_NUM_COMMENTS_SUPPORTED];
        bool cp_is_binary_comment[GRK_NUM_COMMENTS_SUPPORTED];
        size_t cp_num_comments;
        uint8_t csty;
        GRK_PROG_ORDER prog_order;
        grk_poc POC[32];
        uint32_t numpocs;
        uint32_t tcp_numlayers;
        double tcp_rates[100];
        double tcp_distoratio[100];
        uint32_t numresolution;
        uint32_t cblockw_init;
        uint32_t cblockh_init;
        uint8_t cblk_sty;
        /* flag for high throughput */
        bool isHT;
        bool irreversible;
        int32_t roi_compno;
        uint32_t roi_shift;
        /* number of precinct size specifications */
        uint32_t res_spec;
        uint32_t prcw_init[GRK_J2K_MAXRLVLS];
        uint32_t prch_init[GRK_J2K_MAXRLVLS];
        char infile[GRK_PATH_LEN];
        char outfile[GRK_PATH_LEN];
        uint32_t image_offset_x0;
        uint32_t image_offset_y0;
        uint32_t subsampling_dx;
        uint32_t subsampling_dy;
        GRK_SUPPORTED_FILE_FMT decod_format;
        GRK_SUPPORTED_FILE_FMT cod_format;
        grk_raw_cparameters raw_cp;
        uint32_t max_comp_size;
        uint8_t tp_on;
        uint8_t tp_flag;
        uint8_t tcp_mct;
        void *mct_data;
        uint64_t max_cs_size;
        uint16_t rsiz;
        int framerate;
 
        // set to true if input file stores capture resolution
        bool write_capture_resolution_from_file;
        double capture_resolution_from_file[2];
 
        bool write_capture_resolution;
        double capture_resolution[2];
 
        bool write_display_resolution;
        double display_resolution[2];
 
        // 0: bisect with all truncation points,  1: bisect with only feasible truncation points
        uint32_t rateControlAlgorithm;
        uint32_t numThreads;
        int32_t deviceId;
        uint32_t duration; //seconds
        uint32_t kernelBuildOptions;
        uint32_t repeats;
        bool writePLT;
        bool writeTLM;
        bool verbose;
} grk_cparameters;
 
typedef struct _grk_jp2_cdef_info {
        uint16_t cn;
        uint16_t typ;
        uint16_t asoc;
} grk_jp2_cdef_info;
 
typedef struct _grk_jp2_cdef {
        grk_jp2_cdef_info *info;
        uint16_t n;
} grk_jp2_cdef;
 
typedef struct _grk_jp2_cmap_comp {
        uint16_t cmp;
        uint8_t mtyp, pcol;
} grk_jp2_cmap_comp;
 
typedef struct _grk_jp2_pclr {
        uint32_t *entries;
        uint8_t *channel_sign;
        uint8_t *channel_size;
        grk_jp2_cmap_comp *cmap;
        uint16_t nr_entries;
        uint8_t nr_channels;
} grk_jp2_pclr;
 
typedef struct _grk_jp2_color {
        uint8_t *icc_profile_buf;
        uint32_t icc_profile_len;
        grk_jp2_cdef *jp2_cdef;
        grk_jp2_pclr *jp2_pclr;
        uint8_t jp2_has_colour_specification_box;
} grk_jp2_color;
 
typedef struct _grk_header_info {
        uint32_t cblockw_init;
        uint32_t cblockh_init;
        bool irreversible;
        uint32_t mct;
        uint16_t rsiz;
        uint32_t numresolutions;
        // coding style can be specified in main header COD segment,
        // tile header COD segment, and tile component COC segment.
        // !!! Assume that coding style does not vary across tile components !!!
        uint8_t csty;
        // code block style is specified in main header COD segment, and can
        // be overridden in a tile header. !!! Assume that style does
        // not vary across tiles !!!
        uint8_t cblk_sty;
        uint32_t prcw_init[GRK_J2K_MAXRLVLS];
        uint32_t prch_init[GRK_J2K_MAXRLVLS];
        uint32_t tx0;
        uint32_t ty0;
        uint32_t t_width;
        uint32_t t_height;
        uint32_t t_grid_width;
        uint32_t t_grid_height;
        uint32_t tcp_numlayers;
 
        GRK_ENUM_COLOUR_SPACE enumcs;
        // ICC profile information
        // note: the contents of this struct will remain valid
        // until the codec is destroyed
        grk_jp2_color color;
        // note: xml_data will remain valid
        // until codec is destroyed
        uint8_t *xml_data;
        size_t xml_data_len;
        size_t num_comments;
        char *comment[GRK_NUM_COMMENTS_SUPPORTED];
        uint16_t comment_len[GRK_NUM_COMMENTS_SUPPORTED];
        bool isBinaryComment[GRK_NUM_COMMENTS_SUPPORTED];
 
        bool has_capture_resolution;
        double capture_resolution[2];
 
        bool has_display_resolution;
        double display_resolution[2];
 
} grk_header_info;
 
typedef struct _grk_dparameters {
        uint32_t cp_reduce;
        uint32_t cp_layer;
        char infile[GRK_PATH_LEN];
        char outfile[GRK_PATH_LEN];
        GRK_SUPPORTED_FILE_FMT decod_format;
        GRK_SUPPORTED_FILE_FMT cod_format;
        uint32_t DA_x0;
        uint32_t DA_x1;
        uint32_t DA_y0;
        uint32_t DA_y1;
        bool m_verbose;
        uint16_t tile_index;
        uint32_t nb_tile_to_decode;
        uint32_t flags;
} grk_dparameters;
 
typedef enum grk_prec_mode {
        GRK_PREC_MODE_CLIP, GRK_PREC_MODE_SCALE
} grk_precision_mode;
 
typedef struct _grk_prec {
        uint32_t prec;
        grk_precision_mode mode;
} grk_precision;
 
#define GRK_DECOMPRESS_COMPRESSION_LEVEL_DEFAULT (UINT_MAX)
 
typedef struct _grk_decompress_params {
        grk_dparameters core;
        char infile[GRK_PATH_LEN];
        char outfile[GRK_PATH_LEN];
        GRK_SUPPORTED_FILE_FMT decod_format;
        GRK_SUPPORTED_FILE_FMT cod_format;
        char indexfilename[GRK_PATH_LEN];
        uint32_t DA_x0;
        uint32_t DA_x1;
        uint32_t DA_y0;
        uint32_t DA_y1;
        bool m_verbose;
        uint16_t tile_index;
        uint32_t nb_tile_to_decode;
        grk_precision *precision;
        uint32_t nb_precision;
        /* force output colorspace to RGB */
        bool force_rgb;
        /* upsample components according to their dx/dy values */
        bool upsample;
        /* split output components to different files */
        bool split_pnm;
        /* serialize XML metadata to disk */
        bool serialize_xml;
        uint32_t compression;
        // compression "quality". Meaning of "quality" depends
        // on file format we are writing to
        uint32_t compressionLevel;
        int32_t deviceId;
        uint32_t duration; //seconds
        uint32_t kernelBuildOptions;
        uint32_t repeats;
        bool verbose;
        uint32_t numThreads;
} grk_decompress_parameters;
 
typedef void *grk_codec;
 
/*
 ==========================================================
 I/O stream typedef definitions
 ==========================================================
 */
 
/*
 * Callback function prototype for read function
 *
 */
typedef size_t (*grk_stream_read_fn)(void *p_buffer, size_t nb_bytes,
                void *user_data);
 
/*
 * Callback function prototype for zero copy read function
 */
typedef size_t (*grk_stream_zero_copy_read_fn)(void **p_buffer, size_t nb_bytes,
                void *user_data);
 
/*
 * Callback function prototype for write function
 */
typedef size_t (*grk_stream_write_fn)(void *p_buffer, size_t nb_bytes,
                void *user_data);
 
/*
 * Callback function prototype for (absolute) seek function.
 */
typedef bool (*grk_stream_seek_fn)(uint64_t nb_bytes, void *user_data);
 
/*
 * Callback function prototype for free user data function
 */
typedef void (*grk_stream_free_user_data_fn)(void *user_data);
 
/*
 * JPEG 2000 stream.
 */
typedef void *grk_stream;
 
/*
 ==========================================================
 image typedef definitions
 ==========================================================
 */
 
// component type
enum GRK_COMPONENT_TYPE{
 
        GRK_COMPONENT_TYPE_COLOUR =     0,
        GRK_COMPONENT_TYPE_OPACITY =    1,
        GRK_COMPONENT_TYPE_PREMULTIPLIED_OPACITY =  2,
        GRK_COMPONENT_TYPE_UNSPECIFIED = 65535U
 
};
 
// component association
enum GRK_COMPONENT_ASSOC{
 
        GRK_COMPONENT_ASSOC_WHOLE_IMAGE =       0,
        GRK_COMPONENT_ASSOC_COLOUR_1 =  1,
        GRK_COMPONENT_ASSOC_COLOUR_2 =  2,
        GRK_COMPONENT_ASSOC_COLOUR_3 =  3,
        GRK_COMPONENT_ASSOC_UNASSOCIATED = 65535U
 
};
 
typedef struct _grk_image_comp {
        uint32_t dx;
        uint32_t dy;
        uint32_t w;
        uint32_t stride;
        uint32_t h;
        uint32_t x0;
        uint32_t y0;
        uint32_t prec;
        bool sgnd;
        int32_t *data;
        // if true, then image will manage data, otherwise up to caller
        bool owns_data;
        GRK_COMPONENT_TYPE type;
        GRK_COMPONENT_ASSOC association;
} grk_image_comp;
 
typedef struct _grk_image {
        uint32_t x0;
        uint32_t y0;
        uint32_t x1;
        uint32_t y1;
        uint32_t numcomps;
        GRK_COLOR_SPACE color_space;
        grk_image_comp *comps;
        uint8_t *icc_profile_buf;
        uint32_t icc_profile_len;
        double capture_resolution[2];
        double display_resolution[2];
        uint8_t *iptc_buf;
        size_t iptc_len;
        uint8_t *xmp_buf;
        size_t xmp_len;
} grk_image;
 
typedef struct _grk_image_comptparm {
        uint32_t dx;
        uint32_t dy;
        uint32_t w;
        /* data stride */
        uint32_t stride;
        uint32_t h;
        uint32_t x0;
        uint32_t y0;
        uint32_t prec;
        bool sgnd;
} grk_image_cmptparm;
 
/*
 ==========================================================
 Information about the JPEG 2000 code stream
 ==========================================================
 */
 
typedef struct _grk_packet_info {
        uint64_t start_pos;
        uint64_t end_ph_pos;
        uint64_t end_pos;
        double disto;
} grk_packet_info;
 
typedef struct _grk_marker_info {
        uint16_t type;
        uint64_t pos;
        uint32_t len;
} grk_marker_info;
 
 
typedef struct _grk_tile_info {
        double *thresh;
        uint16_t tileno;
        uint64_t start_pos;
        uint64_t end_header;
        uint64_t end_pos;
        uint32_t pw[GRK_J2K_MAXRLVLS];
        uint32_t ph[GRK_J2K_MAXRLVLS];
        uint32_t pdx[GRK_J2K_MAXRLVLS];
        uint32_t pdy[GRK_J2K_MAXRLVLS];
        grk_packet_info *packet;
        int64_t numpix;
        double distotile;
        uint32_t marknum;
        grk_marker_info *marker;
        uint32_t maxmarknum;
        uint32_t num_tps;
} grk_tile_info;
 
typedef struct _grk_codestream_info {
        double D_max;
        uint32_t packno;
        uint32_t index_write;
        uint32_t numcomps;
        uint32_t numlayers;
        uint32_t *numdecompos;
        uint32_t marknum;
        grk_marker_info *marker;
        uint32_t maxmarknum;
        uint64_t main_head_start;
        uint64_t main_head_end;
        uint64_t codestream_size;
        grk_tile_info *tile;
} grk_codestream_info;
 
typedef struct _grk_tccp_info {
        uint32_t compno;
        uint8_t csty;
        uint32_t numresolutions;
        uint32_t cblkw;
        uint32_t cblkh;
        uint8_t cblk_sty;
        uint8_t qmfbid;
        uint8_t qntsty;
        uint32_t stepsizes_mant[GRK_J2K_MAXBANDS];
        uint32_t stepsizes_expn[GRK_J2K_MAXBANDS];
        uint8_t numgbits;
        uint32_t roishift;
        uint32_t prcw[GRK_J2K_MAXRLVLS];
        uint32_t prch[GRK_J2K_MAXRLVLS];
} grk_tccp_info;
 
typedef struct _grk_tile_v2_info {
        uint16_t tileno;
        uint32_t csty;
        GRK_PROG_ORDER prg;
        uint32_t numlayers;
        uint32_t mct;
        grk_tccp_info *tccp_info;
 
} grk_tile_info_v2;
 
typedef struct _grk_codestream_info_v2 {
        /* Tile info */
        uint32_t tx0;
        uint32_t ty0;
        uint32_t t_width;
        uint32_t t_height;
        uint32_t t_grid_width;
        uint32_t t_grid_height;
        uint32_t nbcomps;
        grk_tile_info_v2 m_default_tile_info;
} grk_codestream_info_v2;
 
typedef struct _grk_tp_index {
        uint64_t start_pos;
        uint64_t end_header;
        uint64_t end_pos;
} grk_tp_index;
 
typedef struct _grk_tile_index {
        uint16_t tileno;
        uint32_t nb_tps;
        uint32_t current_nb_tps;
        uint32_t current_tpsno;
        grk_tp_index *tp_index;
        uint32_t marknum;
        grk_marker_info *marker;
        uint32_t maxmarknum;
} grk_tile_index;
 
typedef struct _grk_codestream_index {
        uint64_t main_head_start;
        uint64_t main_head_end;
        uint64_t codestream_size;
        uint32_t marknum;
        grk_marker_info *marker;
        uint32_t maxmarknum;
        uint32_t nb_of_tiles;
        grk_tile_index *tile_index;
} grk_codestream_index;
 
// Structs to pass data between grok and plugin
 
typedef struct _grk_plugin_pass {
        double distortionDecrease; //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;
        unsigned int *contextStream;
        uint32_t numPix;
        uint8_t *compressedData;
        uint32_t compressedDataLength;
        size_t numBitPlanes;
        size_t numPasses;
        grk_plugin_pass passes[67];
        unsigned int sortedIndex;
} grk_plugin_code_block;
 
typedef struct _grk_plugin_precinct {
        uint64_t numBlocks;
        grk_plugin_code_block **blocks;
} grk_plugin_precinct;
 
typedef struct _grk_plugin_band {
        size_t orient;
        uint64_t numPrecincts;
        grk_plugin_precinct **precincts;
        float stepsize;
} grk_plugin_band;
 
typedef struct _grk_plugin_resolution {
        size_t level;
        size_t numBands;
        grk_plugin_band **bands;
} grk_plugin_resolution;
 
typedef struct grk_plugin_tile_component {
        size_t numResolutions;
        grk_plugin_resolution **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 decode_flags;
        size_t numComponents;
        grk_plugin_tile_component **tileComponents;
} grk_plugin_tile;
 
GRK_API const char* GRK_CALLCONV grk_version(void);
 
GRK_API bool GRK_CALLCONV grk_initialize(const char *plugin_path,
                uint32_t numthreads);
 
GRK_API void GRK_CALLCONV grk_deinitialize();
 
/*
 ============================
 image functions definitions
 ============================
 */
 
GRK_API grk_image* GRK_CALLCONV grk_image_create(uint32_t numcmpts,
                grk_image_cmptparm *cmptparms, GRK_COLOR_SPACE clrspc, bool allocData);
 
GRK_API void GRK_CALLCONV grk_image_destroy(grk_image *image);
 
GRK_API bool GRK_CALLCONV grk_image_single_component_data_alloc(
                grk_image_comp *image);
 
GRK_API void GRK_CALLCONV grk_image_all_components_data_free(grk_image *image);
 
GRK_API void GRK_CALLCONV grk_image_single_component_data_free(
                grk_image_comp *image);
 
GRK_API uint8_t* GRK_CALLCONV grk_buffer_new(size_t len);
 
GRK_API void GRK_CALLCONV grk_buffer_delete(uint8_t *buffer);
/*
 =================================
 stream functions definitions
 =================================
 */
 
GRK_API grk_stream* GRK_CALLCONV grk_stream_create(size_t buffer_size,
                bool is_input);
 
GRK_API void GRK_CALLCONV grk_stream_destroy(grk_stream *stream);
 
GRK_API void GRK_CALLCONV grk_stream_set_read_function(grk_stream *stream,
                grk_stream_read_fn p_function);
 
GRK_API void GRK_CALLCONV grk_stream_set_zero_copy_read_function(
                grk_stream *stream, grk_stream_zero_copy_read_fn p_function);
 
GRK_API void GRK_CALLCONV grk_stream_set_write_function(grk_stream *stream,
                grk_stream_write_fn p_function);
 
GRK_API void GRK_CALLCONV grk_stream_set_seek_function(grk_stream *stream,
                grk_stream_seek_fn p_function);
 
GRK_API void GRK_CALLCONV grk_stream_set_user_data(grk_stream *stream,
                void *data, grk_stream_free_user_data_fn p_function);
 
GRK_API void GRK_CALLCONV grk_stream_set_user_data_length(grk_stream *stream,
                uint64_t data_length);
 
GRK_API grk_stream* GRK_CALLCONV grk_stream_create_file_stream(
                const char *fname, size_t buffer_size, bool is_read_stream);
 
GRK_API grk_stream* GRK_CALLCONV grk_stream_create_mem_stream(uint8_t *buf,
                size_t buffer_len, bool ownsBuffer, bool is_read_stream);
 
GRK_API size_t GRK_CALLCONV grk_stream_get_write_mem_stream_length(
                grk_stream *stream);
 
GRK_API grk_stream* GRK_CALLCONV grk_stream_create_mapped_file_read_stream(
                const char *fname);
 
/*
 ========================================
 logger functions definitions
 ========================================
 */
GRK_API bool GRK_CALLCONV grk_set_info_handler(grk_msg_callback p_callback,
                void *user_data);
GRK_API bool GRK_CALLCONV grk_set_warning_handler(grk_msg_callback p_callback,
                void *user_data);
GRK_API bool GRK_CALLCONV grk_set_error_handler(grk_msg_callback p_callback,
                void *user_data);
 
/*
 ===============================
 codec functions definitions
 ===============================
 */
 
GRK_API void GRK_CALLCONV grk_destroy_codec(grk_codec codec);
 
GRK_API grk_codec GRK_CALLCONV grk_create_decompress(GRK_CODEC_FORMAT format,
                grk_stream *stream);
 
GRK_API bool GRK_CALLCONV grk_end_decompress(grk_codec codec);
 
GRK_API void GRK_CALLCONV grk_set_default_decompress_params(
                grk_dparameters *parameters);
 
GRK_API bool GRK_CALLCONV grk_init_decompress(grk_codec codec,
                grk_dparameters *parameters);
 
GRK_API bool GRK_CALLCONV grk_read_header(grk_codec codec,
                grk_header_info *header_info, grk_image **image);
 
GRK_API bool GRK_CALLCONV grk_set_decompress_area(grk_codec codec,
                grk_image *image, uint32_t start_x, uint32_t start_y, uint32_t end_x,
                uint32_t end_y);
 
GRK_API bool GRK_CALLCONV grk_decompress(grk_codec p_decompressor,
                grk_plugin_tile *tile, grk_image *image);
 
GRK_API bool GRK_CALLCONV grk_decompress_tile(grk_codec codec,
                grk_image *image, uint16_t tile_index);
 
/* COMPRESSION FUNCTIONS*/
 
GRK_API grk_codec GRK_CALLCONV grk_create_compress(GRK_CODEC_FORMAT format,
                grk_stream *stream);
 
GRK_API void GRK_CALLCONV grk_set_default_compress_params(
                grk_cparameters *parameters);
 
GRK_API bool GRK_CALLCONV grk_init_compress(grk_codec codec,
                grk_cparameters *parameters, grk_image *image);
 
GRK_API bool GRK_CALLCONV grk_start_compress(grk_codec codec);
 
GRK_API bool GRK_CALLCONV grk_compress(grk_codec codec);
 
GRK_API bool GRK_CALLCONV grk_compress_tile(grk_codec codec,
                uint16_t tile_index, uint8_t *data, uint64_t data_size);
 
 
GRK_API bool GRK_CALLCONV grk_compress_with_plugin(grk_codec codec,
                grk_plugin_tile *tile);
 
 
GRK_API bool GRK_CALLCONV grk_end_compress(grk_codec codec);
 
 
GRK_API void GRK_CALLCONV grk_destroy_cstr_info(
                grk_codestream_info_v2 **cstr_info);
 
GRK_API void GRK_CALLCONV grk_dump_codec(grk_codec codec, uint32_t info_flag,
                FILE *output_stream);
 
GRK_API grk_codestream_info_v2* GRK_CALLCONV grk_get_cstr_info(
                grk_codec codec);
 
GRK_API grk_codestream_index* GRK_CALLCONV grk_get_cstr_index(grk_codec codec);
 
GRK_API void GRK_CALLCONV grk_destroy_cstr_index(
                grk_codestream_index **p_cstr_index);
 
GRK_API bool GRK_CALLCONV grk_set_MCT(grk_cparameters *parameters,
                float *pEncodingMatrix, int32_t *p_dc_shift, uint32_t pNbComp);
 
/*****************
 Plugin Interface
 ******************/
 
/*
 Plugin management
 */
 
typedef struct _grk_plugin_load_info {
        const char *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);
 
// No debug is done on plugin. Production setting.
#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();
 
/*
 Plugin encoding
 */
typedef struct _grk_plugin_init_info {
        int32_t deviceId;
        bool verbose;
} grk_plugin_init_info;
 
GRK_API bool GRK_CALLCONV grk_plugin_init(grk_plugin_init_info initInfo);
 
typedef struct grk_plugin_encode_user_callback_info {
        const char *input_file_name;
        bool outputFileNameIsRelative;
        const char *output_file_name;
        grk_cparameters *encoder_parameters;
        grk_image *image;
        grk_plugin_tile *tile;
        uint8_t *compressBuffer;
        size_t compressBufferLen;
        unsigned int error_code;
} grk_plugin_encode_user_callback_info;
 
typedef bool (*GRK_PLUGIN_ENCODE_USER_CALLBACK)(
                grk_plugin_encode_user_callback_info *info);
 
GRK_API int32_t GRK_CALLCONV grk_plugin_compress(
                grk_cparameters *encode_parameters,
                GRK_PLUGIN_ENCODE_USER_CALLBACK callback);
 
GRK_API int32_t GRK_CALLCONV grk_plugin_batch_compress(const char *input_dir,
                const char *output_dir, grk_cparameters *encode_parameters,
                GRK_PLUGIN_ENCODE_USER_CALLBACK callback);
 
GRK_API bool GRK_CALLCONV grk_plugin_is_batch_complete(void);
 
GRK_API void GRK_CALLCONV grk_plugin_stop_batch_compress(void);
 
/*
 Plugin decompression
 */
 
typedef int (*GROK_INIT_DECODERS)(grk_header_info *header_info,
                grk_image *image);
 
typedef struct _grk_plugin_decode_callback_info {
        size_t deviceId;
        GROK_INIT_DECODERS init_decoders_func;
        const char *input_file_name;
        const char *output_file_name;
        // input file format 0: J2K, 1: JP2
        GRK_SUPPORTED_FILE_FMT decod_format;
        // output file format 0: PGX, 1: PxM, 2: BMP etc 
        GRK_SUPPORTED_FILE_FMT cod_format;
        grk_stream *l_stream;
        grk_codec l_codec;
        grk_header_info header_info;
        grk_decompress_parameters *decoder_parameters;
        grk_image *image;
        bool plugin_owns_image;
        grk_plugin_tile *tile;
        unsigned int error_code;
        uint32_t decode_flags;
} grk_plugin_decode_callback_info;
 
typedef int32_t (*grk_plugin_decode_callback)(
                grk_plugin_decode_callback_info *info);
 
GRK_API int32_t GRK_CALLCONV grk_plugin_decompress(
                grk_decompress_parameters *decompress_parameters,
                grk_plugin_decode_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_decode_callback callback);
 
GRK_API int32_t GRK_CALLCONV grk_plugin_batch_decompress(void);
 
GRK_API void GRK_CALLCONV grk_plugin_stop_batch_decompress(void);
 
#ifdef __cplusplus
}
#endif