You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1692 lines
58 KiB
1692 lines
58 KiB
/*
|
|
* The copyright in this software is being made available under the 2-clauses
|
|
* BSD License, included below. This software may be subject to other third
|
|
* party and contributor rights, including patent rights, and no such rights
|
|
* are granted under this license.
|
|
*
|
|
* Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
|
|
* Copyright (c) 2002-2014, Professor Benoit Macq
|
|
* Copyright (c) 2001-2003, David Janssens
|
|
* Copyright (c) 2002-2003, Yannick Verschueren
|
|
* Copyright (c) 2003-2007, Francois-Olivier Devaux
|
|
* Copyright (c) 2003-2014, Antonin Descampe
|
|
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
|
* Copyright (c) 2006-2007, Parvatha Elangovan
|
|
* Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
|
|
* Copyright (c) 2010-2011, Kaori Hagihara
|
|
* Copyright (c) 2011-2012, Centre National d'Etudes Spatiales (CNES), France
|
|
* Copyright (c) 2012, CS Systemes d'Information, France
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
|
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
#ifndef OPENJPEG_H
|
|
#define OPENJPEG_H
|
|
|
|
|
|
/*
|
|
==========================================================
|
|
Compiler directives
|
|
==========================================================
|
|
*/
|
|
|
|
/*
|
|
The inline keyword is supported by C99 but not by C90.
|
|
Most compilers implement their own version of this keyword ...
|
|
*/
|
|
#ifndef INLINE
|
|
#if defined(_MSC_VER)
|
|
#define INLINE __forceinline
|
|
#elif defined(__GNUC__)
|
|
#define INLINE __inline__
|
|
#elif defined(__MWERKS__)
|
|
#define INLINE inline
|
|
#else
|
|
/* add other compilers here ... */
|
|
#define INLINE
|
|
#endif /* defined(<Compiler>) */
|
|
#endif /* INLINE */
|
|
|
|
/* deprecated attribute */
|
|
#ifdef __GNUC__
|
|
#define OPJ_DEPRECATED(func) func __attribute__ ((deprecated))
|
|
#elif defined(_MSC_VER)
|
|
#define OPJ_DEPRECATED(func) __declspec(deprecated) func
|
|
#else
|
|
#pragma message("WARNING: You need to implement DEPRECATED for this compiler")
|
|
#define OPJ_DEPRECATED(func) func
|
|
#endif
|
|
|
|
#if defined(OPJ_STATIC) || !defined(_WIN32)
|
|
/* http://gcc.gnu.org/wiki/Visibility */
|
|
# if __GNUC__ >= 4
|
|
# if defined(OPJ_STATIC) /* static library uses "hidden" */
|
|
# define OPJ_API __attribute__ ((visibility ("hidden")))
|
|
# else
|
|
# define OPJ_API __attribute__ ((visibility ("default")))
|
|
# endif
|
|
# define OPJ_LOCAL __attribute__ ((visibility ("hidden")))
|
|
# else
|
|
# define OPJ_API
|
|
# define OPJ_LOCAL
|
|
# endif
|
|
# define OPJ_CALLCONV
|
|
#else
|
|
# define OPJ_CALLCONV __stdcall
|
|
/*
|
|
The following ifdef block is the standard way of creating macros which make exporting
|
|
from a DLL simpler. All files within this DLL are compiled with the OPJ_EXPORTS
|
|
symbol defined on the command line. this symbol should not be defined on any project
|
|
that uses this DLL. This way any other project whose source files include this file see
|
|
OPJ_API functions as being imported from a DLL, whereas this DLL sees symbols
|
|
defined with this macro as being exported.
|
|
*/
|
|
# if defined(OPJ_EXPORTS) || defined(DLL_EXPORT)
|
|
# define OPJ_API __declspec(dllexport)
|
|
# else
|
|
# define OPJ_API __declspec(dllimport)
|
|
# endif /* OPJ_EXPORTS */
|
|
#endif /* !OPJ_STATIC || !_WIN32 */
|
|
|
|
typedef int OPJ_BOOL;
|
|
#define OPJ_TRUE 1
|
|
#define OPJ_FALSE 0
|
|
|
|
typedef char OPJ_CHAR;
|
|
typedef float OPJ_FLOAT32;
|
|
typedef double OPJ_FLOAT64;
|
|
typedef unsigned char OPJ_BYTE;
|
|
|
|
#include "opj_stdint.h"
|
|
|
|
typedef int8_t OPJ_INT8;
|
|
typedef uint8_t OPJ_UINT8;
|
|
typedef int16_t OPJ_INT16;
|
|
typedef uint16_t OPJ_UINT16;
|
|
typedef int32_t OPJ_INT32;
|
|
typedef uint32_t OPJ_UINT32;
|
|
typedef int64_t OPJ_INT64;
|
|
typedef uint64_t OPJ_UINT64;
|
|
|
|
typedef int64_t OPJ_OFF_T; /* 64-bit file offset type */
|
|
|
|
#include <stdio.h>
|
|
typedef size_t OPJ_SIZE_T;
|
|
|
|
/* Avoid compile-time warning because parameter is not used */
|
|
#define OPJ_ARG_NOT_USED(x) (void)(x)
|
|
|
|
/*
|
|
==========================================================
|
|
Useful constant definitions
|
|
==========================================================
|
|
*/
|
|
|
|
#define OPJ_PATH_LEN 4096 /**< Maximum allowed size for filenames */
|
|
|
|
#define OPJ_J2K_MAXRLVLS 33 /**< Number of maximum resolution level authorized */
|
|
#define OPJ_J2K_MAXBANDS (3*OPJ_J2K_MAXRLVLS-2) /**< Number of maximum sub-band linked to number of resolution level */
|
|
|
|
#define OPJ_J2K_DEFAULT_NB_SEGS 10
|
|
#define OPJ_J2K_STREAM_CHUNK_SIZE 0x100000 /** 1 mega by default */
|
|
#define OPJ_J2K_DEFAULT_HEADER_SIZE 1000
|
|
#define OPJ_J2K_MCC_DEFAULT_NB_RECORDS 10
|
|
#define OPJ_J2K_MCT_DEFAULT_NB_RECORDS 10
|
|
|
|
/* UniPG>> */ /* NOT YET USED IN THE V2 VERSION OF OPENJPEG */
|
|
#define JPWL_MAX_NO_TILESPECS 16 /**< Maximum number of tile parts expected by JPWL: increase at your will */
|
|
#define JPWL_MAX_NO_PACKSPECS 16 /**< Maximum number of packet parts expected by JPWL: increase at your will */
|
|
#define JPWL_MAX_NO_MARKERS 512 /**< Maximum number of JPWL markers: increase at your will */
|
|
#define JPWL_PRIVATEINDEX_NAME "jpwl_index_privatefilename" /**< index file name used when JPWL is on */
|
|
#define JPWL_EXPECTED_COMPONENTS 3 /**< Expect this number of components, so you'll find better the first EPB */
|
|
#define JPWL_MAXIMUM_TILES 8192 /**< Expect this maximum number of tiles, to avoid some crashes */
|
|
#define JPWL_MAXIMUM_HAMMING 2 /**< Expect this maximum number of bit errors in marker id's */
|
|
#define JPWL_MAXIMUM_EPB_ROOM 65450 /**< Expect this maximum number of bytes for composition of EPBs */
|
|
/* <<UniPG */
|
|
|
|
/**
|
|
* EXPERIMENTAL FOR THE MOMENT
|
|
* Supported options about file information used only in j2k_dump
|
|
*/
|
|
#define OPJ_IMG_INFO 1 /**< Basic image information provided to the user */
|
|
#define OPJ_J2K_MH_INFO 2 /**< Codestream information based only on the main header */
|
|
#define OPJ_J2K_TH_INFO 4 /**< Tile information based on the current tile header */
|
|
#define OPJ_J2K_TCH_INFO 8 /**< Tile/Component information of all tiles */
|
|
#define OPJ_J2K_MH_IND 16 /**< Codestream index based only on the main header */
|
|
#define OPJ_J2K_TH_IND 32 /**< Tile index based on the current tile */
|
|
/*FIXME #define OPJ_J2K_CSTR_IND 48*/ /**< */
|
|
#define OPJ_JP2_INFO 128 /**< JP2 file information */
|
|
#define OPJ_JP2_IND 256 /**< JP2 file index */
|
|
|
|
/**
|
|
* JPEG 2000 Profiles, see Table A.10 from 15444-1 (updated in various AMD)
|
|
* These values help choosing the RSIZ value for the J2K codestream.
|
|
* The RSIZ value triggers various encoding options, as detailed in Table A.10.
|
|
* If OPJ_PROFILE_PART2 is chosen, it has to be combined with one or more extensions
|
|
* described hereunder.
|
|
* Example: rsiz = OPJ_PROFILE_PART2 | OPJ_EXTENSION_MCT;
|
|
* For broadcast profiles, the OPJ_PROFILE value has to be combined with the targeted
|
|
* mainlevel (3-0 LSB, value between 0 and 11):
|
|
* Example: rsiz = OPJ_PROFILE_BC_MULTI | 0x0005; (here mainlevel 5)
|
|
* For IMF profiles, the OPJ_PROFILE value has to be combined with the targeted mainlevel
|
|
* (3-0 LSB, value between 0 and 11) and sublevel (7-4 LSB, value between 0 and 9):
|
|
* Example: rsiz = OPJ_PROFILE_IMF_2K | 0x0040 | 0x0005; (here main 5 and sublevel 4)
|
|
* */
|
|
#define OPJ_PROFILE_NONE 0x0000 /** no profile, conform to 15444-1 */
|
|
#define OPJ_PROFILE_0 0x0001 /** Profile 0 as described in 15444-1,Table A.45 */
|
|
#define OPJ_PROFILE_1 0x0002 /** Profile 1 as described in 15444-1,Table A.45 */
|
|
#define OPJ_PROFILE_PART2 0x8000 /** At least 1 extension defined in 15444-2 (Part-2) */
|
|
#define OPJ_PROFILE_CINEMA_2K 0x0003 /** 2K cinema profile defined in 15444-1 AMD1 */
|
|
#define OPJ_PROFILE_CINEMA_4K 0x0004 /** 4K cinema profile defined in 15444-1 AMD1 */
|
|
#define OPJ_PROFILE_CINEMA_S2K 0x0005 /** Scalable 2K cinema profile defined in 15444-1 AMD2 */
|
|
#define OPJ_PROFILE_CINEMA_S4K 0x0006 /** Scalable 4K cinema profile defined in 15444-1 AMD2 */
|
|
#define OPJ_PROFILE_CINEMA_LTS 0x0007 /** Long term storage cinema profile defined in 15444-1 AMD2 */
|
|
#define OPJ_PROFILE_BC_SINGLE 0x0100 /** Single Tile Broadcast profile defined in 15444-1 AMD3 */
|
|
#define OPJ_PROFILE_BC_MULTI 0x0200 /** Multi Tile Broadcast profile defined in 15444-1 AMD3 */
|
|
#define OPJ_PROFILE_BC_MULTI_R 0x0300 /** Multi Tile Reversible Broadcast profile defined in 15444-1 AMD3 */
|
|
#define OPJ_PROFILE_IMF_2K 0x0400 /** 2K Single Tile Lossy IMF profile defined in 15444-1 AMD 8 */
|
|
#define OPJ_PROFILE_IMF_4K 0x0401 /** 4K Single Tile Lossy IMF profile defined in 15444-1 AMD 8 */
|
|
#define OPJ_PROFILE_IMF_8K 0x0402 /** 8K Single Tile Lossy IMF profile defined in 15444-1 AMD 8 */
|
|
#define OPJ_PROFILE_IMF_2K_R 0x0403 /** 2K Single/Multi Tile Reversible IMF profile defined in 15444-1 AMD 8 */
|
|
#define OPJ_PROFILE_IMF_4K_R 0x0800 /** 4K Single/Multi Tile Reversible IMF profile defined in 15444-1 AMD 8 */
|
|
#define OPJ_PROFILE_IMF_8K_R 0x0801 /** 8K Single/Multi Tile Reversible IMF profile defined in 15444-1 AMD 8 */
|
|
|
|
/**
|
|
* JPEG 2000 Part-2 extensions
|
|
* */
|
|
#define OPJ_EXTENSION_NONE 0x0000 /** No Part-2 extension */
|
|
#define OPJ_EXTENSION_MCT 0x0100 /** Custom MCT support */
|
|
|
|
/**
|
|
* JPEG 2000 profile macros
|
|
* */
|
|
#define OPJ_IS_CINEMA(v) (((v) >= OPJ_PROFILE_CINEMA_2K)&&((v) <= OPJ_PROFILE_CINEMA_S4K))
|
|
#define OPJ_IS_STORAGE(v) ((v) == OPJ_PROFILE_CINEMA_LTS)
|
|
#define OPJ_IS_BROADCAST(v) (((v) >= OPJ_PROFILE_BC_SINGLE)&&((v) <= ((OPJ_PROFILE_BC_MULTI_R) | (0x000b))))
|
|
#define OPJ_IS_IMF(v) (((v) >= OPJ_PROFILE_IMF_2K)&&((v) <= ((OPJ_PROFILE_IMF_8K_R) | (0x009b))))
|
|
#define OPJ_IS_PART2(v) ((v) & OPJ_PROFILE_PART2)
|
|
|
|
/**
|
|
* JPEG 2000 codestream and component size limits in cinema profiles
|
|
* */
|
|
#define OPJ_CINEMA_24_CS 1302083 /** Maximum codestream length for 24fps */
|
|
#define OPJ_CINEMA_48_CS 651041 /** Maximum codestream length for 48fps */
|
|
#define OPJ_CINEMA_24_COMP 1041666 /** Maximum size per color component for 2K & 4K @ 24fps */
|
|
#define OPJ_CINEMA_48_COMP 520833 /** Maximum size per color component for 2K @ 48fps */
|
|
|
|
/*
|
|
==========================================================
|
|
enum definitions
|
|
==========================================================
|
|
*/
|
|
|
|
/**
|
|
* DEPRECATED: use RSIZ, OPJ_PROFILE_* and OPJ_EXTENSION_* instead
|
|
* Rsiz Capabilities
|
|
* */
|
|
typedef enum RSIZ_CAPABILITIES {
|
|
OPJ_STD_RSIZ = 0, /** Standard JPEG2000 profile*/
|
|
OPJ_CINEMA2K = 3, /** Profile name for a 2K image*/
|
|
OPJ_CINEMA4K = 4, /** Profile name for a 4K image*/
|
|
OPJ_MCT = 0x8100
|
|
} OPJ_RSIZ_CAPABILITIES;
|
|
|
|
/**
|
|
* DEPRECATED: use RSIZ, OPJ_PROFILE_* and OPJ_EXTENSION_* instead
|
|
* Digital cinema operation mode
|
|
* */
|
|
typedef enum CINEMA_MODE {
|
|
OPJ_OFF = 0, /** Not Digital Cinema*/
|
|
OPJ_CINEMA2K_24 = 1, /** 2K Digital Cinema at 24 fps*/
|
|
OPJ_CINEMA2K_48 = 2, /** 2K Digital Cinema at 48 fps*/
|
|
OPJ_CINEMA4K_24 = 3 /** 4K Digital Cinema at 24 fps*/
|
|
} OPJ_CINEMA_MODE;
|
|
|
|
/**
|
|
* Progression order
|
|
* */
|
|
typedef enum PROG_ORDER {
|
|
OPJ_PROG_UNKNOWN = -1, /**< place-holder */
|
|
OPJ_LRCP = 0, /**< layer-resolution-component-precinct order */
|
|
OPJ_RLCP = 1, /**< resolution-layer-component-precinct order */
|
|
OPJ_RPCL = 2, /**< resolution-precinct-component-layer order */
|
|
OPJ_PCRL = 3, /**< precinct-component-resolution-layer order */
|
|
OPJ_CPRL = 4 /**< component-precinct-resolution-layer order */
|
|
} OPJ_PROG_ORDER;
|
|
|
|
/**
|
|
* Supported image color spaces
|
|
*/
|
|
typedef enum COLOR_SPACE {
|
|
OPJ_CLRSPC_UNKNOWN = -1, /**< not supported by the library */
|
|
OPJ_CLRSPC_UNSPECIFIED = 0, /**< not specified in the codestream */
|
|
OPJ_CLRSPC_SRGB = 1, /**< sRGB */
|
|
OPJ_CLRSPC_GRAY = 2, /**< grayscale */
|
|
OPJ_CLRSPC_SYCC = 3, /**< YUV */
|
|
OPJ_CLRSPC_EYCC = 4, /**< e-YCC */
|
|
OPJ_CLRSPC_CMYK = 5 /**< CMYK */
|
|
} OPJ_COLOR_SPACE;
|
|
|
|
/**
|
|
* Supported codec
|
|
*/
|
|
typedef enum CODEC_FORMAT {
|
|
OPJ_CODEC_UNKNOWN = -1, /**< place-holder */
|
|
OPJ_CODEC_J2K = 0, /**< JPEG-2000 codestream : read/write */
|
|
OPJ_CODEC_JPT = 1, /**< JPT-stream (JPEG 2000, JPIP) : read only */
|
|
OPJ_CODEC_JP2 = 2, /**< JP2 file format : read/write */
|
|
OPJ_CODEC_JPP = 3, /**< JPP-stream (JPEG 2000, JPIP) : to be coded */
|
|
OPJ_CODEC_JPX = 4 /**< JPX file format (JPEG 2000 Part-2) : to be coded */
|
|
} OPJ_CODEC_FORMAT;
|
|
|
|
|
|
/*
|
|
==========================================================
|
|
event manager typedef definitions
|
|
==========================================================
|
|
*/
|
|
|
|
/**
|
|
* Callback function prototype for events
|
|
* @param msg Event message
|
|
* @param client_data Client object where will be return the event message
|
|
* */
|
|
typedef void (*opj_msg_callback)(const char *msg, void *client_data);
|
|
|
|
/*
|
|
==========================================================
|
|
codec typedef definitions
|
|
==========================================================
|
|
*/
|
|
|
|
/**
|
|
* Progression order changes
|
|
*
|
|
*/
|
|
typedef struct opj_poc {
|
|
/** Resolution num start, Component num start, given by POC */
|
|
OPJ_UINT32 resno0, compno0;
|
|
/** Layer num end,Resolution num end, Component num end, given by POC */
|
|
OPJ_UINT32 layno1, resno1, compno1;
|
|
/** Layer num start,Precinct num start, Precinct num end */
|
|
OPJ_UINT32 layno0, precno0, precno1;
|
|
/** Progression order enum*/
|
|
OPJ_PROG_ORDER prg1, prg;
|
|
/** Progression order string*/
|
|
OPJ_CHAR progorder[5];
|
|
/** Tile number */
|
|
OPJ_UINT32 tile;
|
|
/** Start and end values for Tile width and height*/
|
|
OPJ_INT32 tx0, tx1, ty0, ty1;
|
|
/** Start value, initialised in pi_initialise_encode*/
|
|
OPJ_UINT32 layS, resS, compS, prcS;
|
|
/** End value, initialised in pi_initialise_encode */
|
|
OPJ_UINT32 layE, resE, compE, prcE;
|
|
/** Start and end values of Tile width and height, initialised in pi_initialise_encode*/
|
|
OPJ_UINT32 txS, txE, tyS, tyE, dx, dy;
|
|
/** Temporary values for Tile parts, initialised in pi_create_encode */
|
|
OPJ_UINT32 lay_t, res_t, comp_t, prc_t, tx0_t, ty0_t;
|
|
} opj_poc_t;
|
|
|
|
/**
|
|
* Compression parameters
|
|
* */
|
|
typedef struct opj_cparameters {
|
|
/** size of tile: tile_size_on = false (not in argument) or = true (in argument) */
|
|
OPJ_BOOL tile_size_on;
|
|
/** XTOsiz */
|
|
int cp_tx0;
|
|
/** YTOsiz */
|
|
int cp_ty0;
|
|
/** XTsiz */
|
|
int cp_tdx;
|
|
/** YTsiz */
|
|
int cp_tdy;
|
|
/** allocation by rate/distortion */
|
|
int cp_disto_alloc;
|
|
/** allocation by fixed layer */
|
|
int cp_fixed_alloc;
|
|
/** add fixed_quality */
|
|
int cp_fixed_quality;
|
|
/** fixed layer */
|
|
int *cp_matrice;
|
|
/** comment for coding */
|
|
char *cp_comment;
|
|
/** csty : coding style */
|
|
int csty;
|
|
/** progression order (default OPJ_LRCP) */
|
|
OPJ_PROG_ORDER prog_order;
|
|
/** progression order changes */
|
|
opj_poc_t POC[32];
|
|
/** number of progression order changes (POC), default to 0 */
|
|
OPJ_UINT32 numpocs;
|
|
/** number of layers */
|
|
int tcp_numlayers;
|
|
/** rates of layers - might be subsequently limited by the max_cs_size field.
|
|
* Should be decreasing. 1 can be
|
|
* used as last value to indicate the last layer is lossless. */
|
|
float tcp_rates[100];
|
|
/** different psnr for successive layers. Should be increasing. 0 can be
|
|
* used as last value to indicate the last layer is lossless. */
|
|
float tcp_distoratio[100];
|
|
/** number of resolutions */
|
|
int numresolution;
|
|
/** initial code block width, default to 64 */
|
|
int cblockw_init;
|
|
/** initial code block height, default to 64 */
|
|
int cblockh_init;
|
|
/** mode switch (cblk_style) */
|
|
int mode;
|
|
/** 1 : use the irreversible DWT 9-7, 0 : use lossless compression (default) */
|
|
int irreversible;
|
|
/** region of interest: affected component in [0..3], -1 means no ROI */
|
|
int roi_compno;
|
|
/** region of interest: upshift value */
|
|
int roi_shift;
|
|
/* number of precinct size specifications */
|
|
int res_spec;
|
|
/** initial precinct width */
|
|
int prcw_init[OPJ_J2K_MAXRLVLS];
|
|
/** initial precinct height */
|
|
int prch_init[OPJ_J2K_MAXRLVLS];
|
|
|
|
/**@name command line encoder parameters (not used inside the library) */
|
|
/*@{*/
|
|
/** input file name */
|
|
char infile[OPJ_PATH_LEN];
|
|
/** output file name */
|
|
char outfile[OPJ_PATH_LEN];
|
|
/** DEPRECATED. Index generation is now handeld with the opj_encode_with_info() function. Set to NULL */
|
|
int index_on;
|
|
/** DEPRECATED. Index generation is now handeld with the opj_encode_with_info() function. Set to NULL */
|
|
char index[OPJ_PATH_LEN];
|
|
/** subimage encoding: origin image offset in x direction */
|
|
int image_offset_x0;
|
|
/** subimage encoding: origin image offset in y direction */
|
|
int image_offset_y0;
|
|
/** subsampling value for dx */
|
|
int subsampling_dx;
|
|
/** subsampling value for dy */
|
|
int subsampling_dy;
|
|
/** input file format 0: PGX, 1: PxM, 2: BMP 3:TIF*/
|
|
int decod_format;
|
|
/** output file format 0: J2K, 1: JP2, 2: JPT */
|
|
int cod_format;
|
|
/*@}*/
|
|
|
|
/* UniPG>> */ /* NOT YET USED IN THE V2 VERSION OF OPENJPEG */
|
|
/**@name JPWL encoding parameters */
|
|
/*@{*/
|
|
/** enables writing of EPC in MH, thus activating JPWL */
|
|
OPJ_BOOL jpwl_epc_on;
|
|
/** error protection method for MH (0,1,16,32,37-128) */
|
|
int jpwl_hprot_MH;
|
|
/** tile number of header protection specification (>=0) */
|
|
int jpwl_hprot_TPH_tileno[JPWL_MAX_NO_TILESPECS];
|
|
/** error protection methods for TPHs (0,1,16,32,37-128) */
|
|
int jpwl_hprot_TPH[JPWL_MAX_NO_TILESPECS];
|
|
/** tile number of packet protection specification (>=0) */
|
|
int jpwl_pprot_tileno[JPWL_MAX_NO_PACKSPECS];
|
|
/** packet number of packet protection specification (>=0) */
|
|
int jpwl_pprot_packno[JPWL_MAX_NO_PACKSPECS];
|
|
/** error protection methods for packets (0,1,16,32,37-128) */
|
|
int jpwl_pprot[JPWL_MAX_NO_PACKSPECS];
|
|
/** enables writing of ESD, (0=no/1/2 bytes) */
|
|
int jpwl_sens_size;
|
|
/** sensitivity addressing size (0=auto/2/4 bytes) */
|
|
int jpwl_sens_addr;
|
|
/** sensitivity range (0-3) */
|
|
int jpwl_sens_range;
|
|
/** sensitivity method for MH (-1=no,0-7) */
|
|
int jpwl_sens_MH;
|
|
/** tile number of sensitivity specification (>=0) */
|
|
int jpwl_sens_TPH_tileno[JPWL_MAX_NO_TILESPECS];
|
|
/** sensitivity methods for TPHs (-1=no,0-7) */
|
|
int jpwl_sens_TPH[JPWL_MAX_NO_TILESPECS];
|
|
/*@}*/
|
|
/* <<UniPG */
|
|
|
|
/**
|
|
* DEPRECATED: use RSIZ, OPJ_PROFILE_* and MAX_COMP_SIZE instead
|
|
* Digital Cinema compliance 0-not compliant, 1-compliant
|
|
* */
|
|
OPJ_CINEMA_MODE cp_cinema;
|
|
/**
|
|
* Maximum size (in bytes) for each component.
|
|
* If == 0, component size limitation is not considered
|
|
* */
|
|
int max_comp_size;
|
|
/**
|
|
* DEPRECATED: use RSIZ, OPJ_PROFILE_* and OPJ_EXTENSION_* instead
|
|
* Profile name
|
|
* */
|
|
OPJ_RSIZ_CAPABILITIES cp_rsiz;
|
|
/** Tile part generation*/
|
|
char tp_on;
|
|
/** Flag for Tile part generation*/
|
|
char tp_flag;
|
|
/** MCT (multiple component transform) */
|
|
char tcp_mct;
|
|
/** Enable JPIP indexing*/
|
|
OPJ_BOOL jpip_on;
|
|
/** Naive implementation of MCT restricted to a single reversible array based
|
|
encoding without offset concerning all the components. */
|
|
void * mct_data;
|
|
/**
|
|
* Maximum size (in bytes) for the whole codestream.
|
|
* If == 0, codestream size limitation is not considered
|
|
* If it does not comply with tcp_rates, max_cs_size prevails
|
|
* and a warning is issued.
|
|
* */
|
|
int max_cs_size;
|
|
/** RSIZ value
|
|
To be used to combine OPJ_PROFILE_*, OPJ_EXTENSION_* and (sub)levels values. */
|
|
OPJ_UINT16 rsiz;
|
|
} opj_cparameters_t;
|
|
|
|
#define OPJ_DPARAMETERS_IGNORE_PCLR_CMAP_CDEF_FLAG 0x0001
|
|
#define OPJ_DPARAMETERS_DUMP_FLAG 0x0002
|
|
|
|
/**
|
|
* Decompression parameters
|
|
* */
|
|
typedef struct opj_dparameters {
|
|
/**
|
|
Set the number of highest resolution levels to be discarded.
|
|
The image resolution is effectively divided by 2 to the power of the number of discarded levels.
|
|
The reduce factor is limited by the smallest total number of decomposition levels among tiles.
|
|
if != 0, then original dimension divided by 2^(reduce);
|
|
if == 0 or not used, image is decoded to the full resolution
|
|
*/
|
|
OPJ_UINT32 cp_reduce;
|
|
/**
|
|
Set the maximum number of quality layers to decode.
|
|
If there are less quality layers than the specified number, all the quality layers are decoded.
|
|
if != 0, then only the first "layer" layers are decoded;
|
|
if == 0 or not used, all the quality layers are decoded
|
|
*/
|
|
OPJ_UINT32 cp_layer;
|
|
|
|
/**@name command line decoder parameters (not used inside the library) */
|
|
/*@{*/
|
|
/** input file name */
|
|
char infile[OPJ_PATH_LEN];
|
|
/** output file name */
|
|
char outfile[OPJ_PATH_LEN];
|
|
/** input file format 0: J2K, 1: JP2, 2: JPT */
|
|
int decod_format;
|
|
/** output file format 0: PGX, 1: PxM, 2: BMP */
|
|
int cod_format;
|
|
|
|
/** Decoding area left boundary */
|
|
OPJ_UINT32 DA_x0;
|
|
/** Decoding area right boundary */
|
|
OPJ_UINT32 DA_x1;
|
|
/** Decoding area up boundary */
|
|
OPJ_UINT32 DA_y0;
|
|
/** Decoding area bottom boundary */
|
|
OPJ_UINT32 DA_y1;
|
|
/** Verbose mode */
|
|
OPJ_BOOL m_verbose;
|
|
|
|
/** tile number of the decoded tile */
|
|
OPJ_UINT32 tile_index;
|
|
/** Nb of tile to decode */
|
|
OPJ_UINT32 nb_tile_to_decode;
|
|
|
|
/*@}*/
|
|
|
|
/* UniPG>> */ /* NOT YET USED IN THE V2 VERSION OF OPENJPEG */
|
|
/**@name JPWL decoding parameters */
|
|
/*@{*/
|
|
/** activates the JPWL correction capabilities */
|
|
OPJ_BOOL jpwl_correct;
|
|
/** expected number of components */
|
|
int jpwl_exp_comps;
|
|
/** maximum number of tiles */
|
|
int jpwl_max_tiles;
|
|
/*@}*/
|
|
/* <<UniPG */
|
|
|
|
unsigned int flags;
|
|
|
|
} opj_dparameters_t;
|
|
|
|
|
|
/**
|
|
* JPEG2000 codec V2.
|
|
* */
|
|
typedef void * opj_codec_t;
|
|
|
|
/*
|
|
==========================================================
|
|
I/O stream typedef definitions
|
|
==========================================================
|
|
*/
|
|
|
|
/**
|
|
* Stream open flags.
|
|
* */
|
|
/** The stream was opened for reading. */
|
|
#define OPJ_STREAM_READ OPJ_TRUE
|
|
/** The stream was opened for writing. */
|
|
#define OPJ_STREAM_WRITE OPJ_FALSE
|
|
|
|
/*
|
|
* Callback function prototype for read function
|
|
*/
|
|
typedef OPJ_SIZE_T(* opj_stream_read_fn)(void * p_buffer, OPJ_SIZE_T p_nb_bytes,
|
|
void * p_user_data) ;
|
|
|
|
/*
|
|
* Callback function prototype for write function
|
|
*/
|
|
typedef OPJ_SIZE_T(* opj_stream_write_fn)(void * p_buffer,
|
|
OPJ_SIZE_T p_nb_bytes, void * p_user_data) ;
|
|
|
|
/*
|
|
* Callback function prototype for skip function
|
|
*/
|
|
typedef OPJ_OFF_T(* opj_stream_skip_fn)(OPJ_OFF_T p_nb_bytes,
|
|
void * p_user_data) ;
|
|
|
|
/*
|
|
* Callback function prototype for seek function
|
|
*/
|
|
typedef OPJ_BOOL(* opj_stream_seek_fn)(OPJ_OFF_T p_nb_bytes,
|
|
void * p_user_data) ;
|
|
|
|
/*
|
|
* Callback function prototype for free user data function
|
|
*/
|
|
typedef void (* opj_stream_free_user_data_fn)(void * p_user_data) ;
|
|
|
|
/*
|
|
* JPEG2000 Stream.
|
|
*/
|
|
typedef void * opj_stream_t;
|
|
|
|
/*
|
|
==========================================================
|
|
image typedef definitions
|
|
==========================================================
|
|
*/
|
|
|
|
/**
|
|
* Defines a single image component
|
|
* */
|
|
typedef struct opj_image_comp {
|
|
/** XRsiz: horizontal separation of a sample of ith component with respect to the reference grid */
|
|
OPJ_UINT32 dx;
|
|
/** YRsiz: vertical separation of a sample of ith component with respect to the reference grid */
|
|
OPJ_UINT32 dy;
|
|
/** data width */
|
|
OPJ_UINT32 w;
|
|
/** data height */
|
|
OPJ_UINT32 h;
|
|
/** x component offset compared to the whole image */
|
|
OPJ_UINT32 x0;
|
|
/** y component offset compared to the whole image */
|
|
OPJ_UINT32 y0;
|
|
/** precision */
|
|
OPJ_UINT32 prec;
|
|
/** image depth in bits */
|
|
OPJ_UINT32 bpp;
|
|
/** signed (1) / unsigned (0) */
|
|
OPJ_UINT32 sgnd;
|
|
/** number of decoded resolution */
|
|
OPJ_UINT32 resno_decoded;
|
|
/** number of division by 2 of the out image compared to the original size of image */
|
|
OPJ_UINT32 factor;
|
|
/** image component data */
|
|
OPJ_INT32 *data;
|
|
/** alpha channel */
|
|
OPJ_UINT16 alpha;
|
|
} opj_image_comp_t;
|
|
|
|
/**
|
|
* Defines image data and characteristics
|
|
* */
|
|
typedef struct opj_image {
|
|
/** XOsiz: horizontal offset from the origin of the reference grid to the left side of the image area */
|
|
OPJ_UINT32 x0;
|
|
/** YOsiz: vertical offset from the origin of the reference grid to the top side of the image area */
|
|
OPJ_UINT32 y0;
|
|
/** Xsiz: width of the reference grid */
|
|
OPJ_UINT32 x1;
|
|
/** Ysiz: height of the reference grid */
|
|
OPJ_UINT32 y1;
|
|
/** number of components in the image */
|
|
OPJ_UINT32 numcomps;
|
|
/** color space: sRGB, Greyscale or YUV */
|
|
OPJ_COLOR_SPACE color_space;
|
|
/** image components */
|
|
opj_image_comp_t *comps;
|
|
/** 'restricted' ICC profile */
|
|
OPJ_BYTE *icc_profile_buf;
|
|
/** size of ICC profile */
|
|
OPJ_UINT32 icc_profile_len;
|
|
} opj_image_t;
|
|
|
|
|
|
/**
|
|
* Component parameters structure used by the opj_image_create function
|
|
* */
|
|
typedef struct opj_image_comptparm {
|
|
/** XRsiz: horizontal separation of a sample of ith component with respect to the reference grid */
|
|
OPJ_UINT32 dx;
|
|
/** YRsiz: vertical separation of a sample of ith component with respect to the reference grid */
|
|
OPJ_UINT32 dy;
|
|
/** data width */
|
|
OPJ_UINT32 w;
|
|
/** data height */
|
|
OPJ_UINT32 h;
|
|
/** x component offset compared to the whole image */
|
|
OPJ_UINT32 x0;
|
|
/** y component offset compared to the whole image */
|
|
OPJ_UINT32 y0;
|
|
/** precision */
|
|
OPJ_UINT32 prec;
|
|
/** image depth in bits */
|
|
OPJ_UINT32 bpp;
|
|
/** signed (1) / unsigned (0) */
|
|
OPJ_UINT32 sgnd;
|
|
} opj_image_cmptparm_t;
|
|
|
|
|
|
/*
|
|
==========================================================
|
|
Information on the JPEG 2000 codestream
|
|
==========================================================
|
|
*/
|
|
/* QUITE EXPERIMENTAL FOR THE MOMENT */
|
|
|
|
/**
|
|
* Index structure : Information concerning a packet inside tile
|
|
* */
|
|
typedef struct opj_packet_info {
|
|
/** packet start position (including SOP marker if it exists) */
|
|
OPJ_OFF_T start_pos;
|
|
/** end of packet header position (including EPH marker if it exists)*/
|
|
OPJ_OFF_T end_ph_pos;
|
|
/** packet end position */
|
|
OPJ_OFF_T end_pos;
|
|
/** packet distorsion */
|
|
double disto;
|
|
} opj_packet_info_t;
|
|
|
|
|
|
/* UniPG>> */
|
|
/**
|
|
* Marker structure
|
|
* */
|
|
typedef struct opj_marker_info {
|
|
/** marker type */
|
|
unsigned short int type;
|
|
/** position in codestream */
|
|
OPJ_OFF_T pos;
|
|
/** length, marker val included */
|
|
int len;
|
|
} opj_marker_info_t;
|
|
/* <<UniPG */
|
|
|
|
/**
|
|
* Index structure : Information concerning tile-parts
|
|
*/
|
|
typedef struct opj_tp_info {
|
|
/** start position of tile part */
|
|
int tp_start_pos;
|
|
/** end position of tile part header */
|
|
int tp_end_header;
|
|
/** end position of tile part */
|
|
int tp_end_pos;
|
|
/** start packet of tile part */
|
|
int tp_start_pack;
|
|
/** number of packets of tile part */
|
|
int tp_numpacks;
|
|
} opj_tp_info_t;
|
|
|
|
/**
|
|
* Index structure : information regarding tiles
|
|
*/
|
|
typedef struct opj_tile_info {
|
|
/** value of thresh for each layer by tile cfr. Marcela */
|
|
double *thresh;
|
|
/** number of tile */
|
|
int tileno;
|
|
/** start position */
|
|
int start_pos;
|
|
/** end position of the header */
|
|
int end_header;
|
|
/** end position */
|
|
int end_pos;
|
|
/** precinct number for each resolution level (width) */
|
|
int pw[33];
|
|
/** precinct number for each resolution level (height) */
|
|
int ph[33];
|
|
/** precinct size (in power of 2), in X for each resolution level */
|
|
int pdx[33];
|
|
/** precinct size (in power of 2), in Y for each resolution level */
|
|
int pdy[33];
|
|
/** information concerning packets inside tile */
|
|
opj_packet_info_t *packet;
|
|
/** add fixed_quality */
|
|
int numpix;
|
|
/** add fixed_quality */
|
|
double distotile;
|
|
/** number of markers */
|
|
int marknum;
|
|
/** list of markers */
|
|
opj_marker_info_t *marker;
|
|
/** actual size of markers array */
|
|
int maxmarknum;
|
|
/** number of tile parts */
|
|
int num_tps;
|
|
/** information concerning tile parts */
|
|
opj_tp_info_t *tp;
|
|
} opj_tile_info_t;
|
|
|
|
/**
|
|
* Index structure of the codestream
|
|
*/
|
|
typedef struct opj_codestream_info {
|
|
/** maximum distortion reduction on the whole image (add for Marcela) */
|
|
double D_max;
|
|
/** packet number */
|
|
int packno;
|
|
/** writing the packet in the index with t2_encode_packets */
|
|
int index_write;
|
|
/** image width */
|
|
int image_w;
|
|
/** image height */
|
|
int image_h;
|
|
/** progression order */
|
|
OPJ_PROG_ORDER prog;
|
|
/** tile size in x */
|
|
int tile_x;
|
|
/** tile size in y */
|
|
int tile_y;
|
|
/** */
|
|
int tile_Ox;
|
|
/** */
|
|
int tile_Oy;
|
|
/** number of tiles in X */
|
|
int tw;
|
|
/** number of tiles in Y */
|
|
int th;
|
|
/** component numbers */
|
|
int numcomps;
|
|
/** number of layer */
|
|
int numlayers;
|
|
/** number of decomposition for each component */
|
|
int *numdecompos;
|
|
/* UniPG>> */
|
|
/** number of markers */
|
|
int marknum;
|
|
/** list of markers */
|
|
opj_marker_info_t *marker;
|
|
/** actual size of markers array */
|
|
int maxmarknum;
|
|
/* <<UniPG */
|
|
/** main header position */
|
|
int main_head_start;
|
|
/** main header position */
|
|
int main_head_end;
|
|
/** codestream's size */
|
|
int codestream_size;
|
|
/** information regarding tiles inside image */
|
|
opj_tile_info_t *tile;
|
|
} opj_codestream_info_t;
|
|
|
|
/* <----------------------------------------------------------- */
|
|
/* new output management of the codestream information and index */
|
|
|
|
/**
|
|
* Tile-component coding parameters information
|
|
*/
|
|
typedef struct opj_tccp_info {
|
|
/** component index */
|
|
OPJ_UINT32 compno;
|
|
/** coding style */
|
|
OPJ_UINT32 csty;
|
|
/** number of resolutions */
|
|
OPJ_UINT32 numresolutions;
|
|
/** log2 of code-blocks width */
|
|
OPJ_UINT32 cblkw;
|
|
/** log2 of code-blocks height */
|
|
OPJ_UINT32 cblkh;
|
|
/** code-block coding style */
|
|
OPJ_UINT32 cblksty;
|
|
/** discrete wavelet transform identifier: 0 = 9-7 irreversible, 1 = 5-3 reversible */
|
|
OPJ_UINT32 qmfbid;
|
|
/** quantisation style */
|
|
OPJ_UINT32 qntsty;
|
|
/** stepsizes used for quantization */
|
|
OPJ_UINT32 stepsizes_mant[OPJ_J2K_MAXBANDS];
|
|
/** stepsizes used for quantization */
|
|
OPJ_UINT32 stepsizes_expn[OPJ_J2K_MAXBANDS];
|
|
/** number of guard bits */
|
|
OPJ_UINT32 numgbits;
|
|
/** Region Of Interest shift */
|
|
OPJ_INT32 roishift;
|
|
/** precinct width */
|
|
OPJ_UINT32 prcw[OPJ_J2K_MAXRLVLS];
|
|
/** precinct height */
|
|
OPJ_UINT32 prch[OPJ_J2K_MAXRLVLS];
|
|
}
|
|
opj_tccp_info_t;
|
|
|
|
/**
|
|
* Tile coding parameters information
|
|
*/
|
|
typedef struct opj_tile_v2_info {
|
|
|
|
/** number (index) of tile */
|
|
int tileno;
|
|
/** coding style */
|
|
OPJ_UINT32 csty;
|
|
/** progression order */
|
|
OPJ_PROG_ORDER prg;
|
|
/** number of layers */
|
|
OPJ_UINT32 numlayers;
|
|
/** multi-component transform identifier */
|
|
OPJ_UINT32 mct;
|
|
|
|
/** information concerning tile component parameters*/
|
|
opj_tccp_info_t *tccp_info;
|
|
|
|
} opj_tile_info_v2_t;
|
|
|
|
/**
|
|
* Information structure about the codestream (FIXME should be expand and enhance)
|
|
*/
|
|
typedef struct opj_codestream_info_v2 {
|
|
/* Tile info */
|
|
/** tile origin in x = XTOsiz */
|
|
OPJ_UINT32 tx0;
|
|
/** tile origin in y = YTOsiz */
|
|
OPJ_UINT32 ty0;
|
|
/** tile size in x = XTsiz */
|
|
OPJ_UINT32 tdx;
|
|
/** tile size in y = YTsiz */
|
|
OPJ_UINT32 tdy;
|
|
/** number of tiles in X */
|
|
OPJ_UINT32 tw;
|
|
/** number of tiles in Y */
|
|
OPJ_UINT32 th;
|
|
|
|
/** number of components*/
|
|
OPJ_UINT32 nbcomps;
|
|
|
|
/** Default information regarding tiles inside image */
|
|
opj_tile_info_v2_t m_default_tile_info;
|
|
|
|
/** information regarding tiles inside image */
|
|
opj_tile_info_v2_t *tile_info; /* FIXME not used for the moment */
|
|
|
|
} opj_codestream_info_v2_t;
|
|
|
|
|
|
/**
|
|
* Index structure about a tile part
|
|
*/
|
|
typedef struct opj_tp_index {
|
|
/** start position */
|
|
OPJ_OFF_T start_pos;
|
|
/** end position of the header */
|
|
OPJ_OFF_T end_header;
|
|
/** end position */
|
|
OPJ_OFF_T end_pos;
|
|
|
|
} opj_tp_index_t;
|
|
|
|
/**
|
|
* Index structure about a tile
|
|
*/
|
|
typedef struct opj_tile_index {
|
|
/** tile index */
|
|
OPJ_UINT32 tileno;
|
|
|
|
/** number of tile parts */
|
|
OPJ_UINT32 nb_tps;
|
|
/** current nb of tile part (allocated)*/
|
|
OPJ_UINT32 current_nb_tps;
|
|
/** current tile-part index */
|
|
OPJ_UINT32 current_tpsno;
|
|
/** information concerning tile parts */
|
|
opj_tp_index_t *tp_index;
|
|
|
|
/* UniPG>> */ /* NOT USED FOR THE MOMENT IN THE V2 VERSION */
|
|
/** number of markers */
|
|
OPJ_UINT32 marknum;
|
|
/** list of markers */
|
|
opj_marker_info_t *marker;
|
|
/** actual size of markers array */
|
|
OPJ_UINT32 maxmarknum;
|
|
/* <<UniPG */
|
|
|
|
/** packet number */
|
|
OPJ_UINT32 nb_packet;
|
|
/** information concerning packets inside tile */
|
|
opj_packet_info_t *packet_index;
|
|
|
|
} opj_tile_index_t;
|
|
|
|
/**
|
|
* Index structure of the codestream (FIXME should be expand and enhance)
|
|
*/
|
|
typedef struct opj_codestream_index {
|
|
/** main header start position (SOC position) */
|
|
OPJ_OFF_T main_head_start;
|
|
/** main header end position (first SOT position) */
|
|
OPJ_OFF_T main_head_end;
|
|
|
|
/** codestream's size */
|
|
OPJ_UINT64 codestream_size;
|
|
|
|
/* UniPG>> */ /* NOT USED FOR THE MOMENT IN THE V2 VERSION */
|
|
/** number of markers */
|
|
OPJ_UINT32 marknum;
|
|
/** list of markers */
|
|
opj_marker_info_t *marker;
|
|
/** actual size of markers array */
|
|
OPJ_UINT32 maxmarknum;
|
|
/* <<UniPG */
|
|
|
|
/** */
|
|
OPJ_UINT32 nb_of_tiles;
|
|
/** */
|
|
opj_tile_index_t *tile_index; /* FIXME not used for the moment */
|
|
|
|
} opj_codestream_index_t;
|
|
/* -----------------------------------------------------------> */
|
|
|
|
/*
|
|
==========================================================
|
|
Metadata from the JP2file
|
|
==========================================================
|
|
*/
|
|
|
|
/**
|
|
* Info structure of the JP2 file
|
|
* EXPERIMENTAL FOR THE MOMENT
|
|
*/
|
|
typedef struct opj_jp2_metadata {
|
|
/** */
|
|
OPJ_INT32 not_used;
|
|
|
|
} opj_jp2_metadata_t;
|
|
|
|
/**
|
|
* Index structure of the JP2 file
|
|
* EXPERIMENTAL FOR THE MOMENT
|
|
*/
|
|
typedef struct opj_jp2_index {
|
|
/** */
|
|
OPJ_INT32 not_used;
|
|
|
|
} opj_jp2_index_t;
|
|
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
|
|
/*
|
|
==========================================================
|
|
openjpeg version
|
|
==========================================================
|
|
*/
|
|
|
|
/* Get the version of the openjpeg library*/
|
|
OPJ_API const char * OPJ_CALLCONV opj_version(void);
|
|
|
|
/*
|
|
==========================================================
|
|
image functions definitions
|
|
==========================================================
|
|
*/
|
|
|
|
/**
|
|
* Create an image
|
|
*
|
|
* @param numcmpts number of components
|
|
* @param cmptparms components parameters
|
|
* @param clrspc image color space
|
|
* @return returns a new image structure if successful, returns NULL otherwise
|
|
* */
|
|
OPJ_API opj_image_t* OPJ_CALLCONV opj_image_create(OPJ_UINT32 numcmpts,
|
|
opj_image_cmptparm_t *cmptparms, OPJ_COLOR_SPACE clrspc);
|
|
|
|
/**
|
|
* Deallocate any resources associated with an image
|
|
*
|
|
* @param image image to be destroyed
|
|
*/
|
|
OPJ_API void OPJ_CALLCONV opj_image_destroy(opj_image_t *image);
|
|
|
|
/**
|
|
* Creates an image without allocating memory for the image (used in the new version of the library).
|
|
*
|
|
* @param numcmpts the number of components
|
|
* @param cmptparms the components parameters
|
|
* @param clrspc the image color space
|
|
*
|
|
* @return a new image structure if successful, NULL otherwise.
|
|
*/
|
|
OPJ_API opj_image_t* OPJ_CALLCONV opj_image_tile_create(OPJ_UINT32 numcmpts,
|
|
opj_image_cmptparm_t *cmptparms, OPJ_COLOR_SPACE clrspc);
|
|
|
|
/**
|
|
* Allocator for opj_image_t->comps[].data
|
|
* To be paired with opj_image_data_free.
|
|
*
|
|
* @param size number of bytes to allocate
|
|
*
|
|
* @return a new pointer if successful, NULL otherwise.
|
|
* @since 2.2.0
|
|
*/
|
|
OPJ_API void* OPJ_CALLCONV opj_image_data_alloc(OPJ_SIZE_T size);
|
|
|
|
/**
|
|
* Destructor for opj_image_t->comps[].data
|
|
* To be paired with opj_image_data_alloc.
|
|
*
|
|
* @param ptr Pointer to free
|
|
*
|
|
* @since 2.2.0
|
|
*/
|
|
OPJ_API void OPJ_CALLCONV opj_image_data_free(void* ptr);
|
|
|
|
/*
|
|
==========================================================
|
|
stream functions definitions
|
|
==========================================================
|
|
*/
|
|
|
|
/**
|
|
* Creates an abstract stream. This function does nothing except allocating memory and initializing the abstract stream.
|
|
*
|
|
* @param p_is_input if set to true then the stream will be an input stream, an output stream else.
|
|
*
|
|
* @return a stream object.
|
|
*/
|
|
OPJ_API opj_stream_t* OPJ_CALLCONV opj_stream_default_create(
|
|
OPJ_BOOL p_is_input);
|
|
|
|
/**
|
|
* Creates an abstract stream. This function does nothing except allocating memory and initializing the abstract stream.
|
|
*
|
|
* @param p_buffer_size FIXME DOC
|
|
* @param p_is_input if set to true then the stream will be an input stream, an output stream else.
|
|
*
|
|
* @return a stream object.
|
|
*/
|
|
OPJ_API opj_stream_t* OPJ_CALLCONV opj_stream_create(OPJ_SIZE_T p_buffer_size,
|
|
OPJ_BOOL p_is_input);
|
|
|
|
/**
|
|
* Destroys a stream created by opj_create_stream. This function does NOT close the abstract stream. If needed the user must
|
|
* close its own implementation of the stream.
|
|
*
|
|
* @param p_stream the stream to destroy.
|
|
*/
|
|
OPJ_API void OPJ_CALLCONV opj_stream_destroy(opj_stream_t* p_stream);
|
|
|
|
/**
|
|
* Sets the given function to be used as a read function.
|
|
* @param p_stream the stream to modify
|
|
* @param p_function the function to use a read function.
|
|
*/
|
|
OPJ_API void OPJ_CALLCONV opj_stream_set_read_function(opj_stream_t* p_stream,
|
|
opj_stream_read_fn p_function);
|
|
|
|
/**
|
|
* Sets the given function to be used as a write function.
|
|
* @param p_stream the stream to modify
|
|
* @param p_function the function to use a write function.
|
|
*/
|
|
OPJ_API void OPJ_CALLCONV opj_stream_set_write_function(opj_stream_t* p_stream,
|
|
opj_stream_write_fn p_function);
|
|
|
|
/**
|
|
* Sets the given function to be used as a skip function.
|
|
* @param p_stream the stream to modify
|
|
* @param p_function the function to use a skip function.
|
|
*/
|
|
OPJ_API void OPJ_CALLCONV opj_stream_set_skip_function(opj_stream_t* p_stream,
|
|
opj_stream_skip_fn p_function);
|
|
|
|
/**
|
|
* Sets the given function to be used as a seek function, the stream is then seekable,
|
|
* using SEEK_SET behavior.
|
|
* @param p_stream the stream to modify
|
|
* @param p_function the function to use a skip function.
|
|
*/
|
|
OPJ_API void OPJ_CALLCONV opj_stream_set_seek_function(opj_stream_t* p_stream,
|
|
opj_stream_seek_fn p_function);
|
|
|
|
/**
|
|
* Sets the given data to be used as a user data for the stream.
|
|
* @param p_stream the stream to modify
|
|
* @param p_data the data to set.
|
|
* @param p_function the function to free p_data when opj_stream_destroy() is called.
|
|
*/
|
|
OPJ_API void OPJ_CALLCONV opj_stream_set_user_data(opj_stream_t* p_stream,
|
|
void * p_data, opj_stream_free_user_data_fn p_function);
|
|
|
|
/**
|
|
* Sets the length of the user data for the stream.
|
|
*
|
|
* @param p_stream the stream to modify
|
|
* @param data_length length of the user_data.
|
|
*/
|
|
OPJ_API void OPJ_CALLCONV opj_stream_set_user_data_length(
|
|
opj_stream_t* p_stream, OPJ_UINT64 data_length);
|
|
|
|
/**
|
|
* Create a stream from a file identified with its filename with default parameters (helper function)
|
|
* @param fname the filename of the file to stream
|
|
* @param p_is_read_stream whether the stream is a read stream (true) or not (false)
|
|
*/
|
|
OPJ_API opj_stream_t* OPJ_CALLCONV opj_stream_create_default_file_stream(
|
|
const char *fname, OPJ_BOOL p_is_read_stream);
|
|
|
|
/** Create a stream from a file identified with its filename with a specific buffer size
|
|
* @param fname the filename of the file to stream
|
|
* @param p_buffer_size size of the chunk used to stream
|
|
* @param p_is_read_stream whether the stream is a read stream (true) or not (false)
|
|
*/
|
|
OPJ_API opj_stream_t* OPJ_CALLCONV opj_stream_create_file_stream(
|
|
const char *fname,
|
|
OPJ_SIZE_T p_buffer_size,
|
|
OPJ_BOOL p_is_read_stream);
|
|
|
|
/*
|
|
==========================================================
|
|
event manager functions definitions
|
|
==========================================================
|
|
*/
|
|
/**
|
|
* Set the info handler use by openjpeg.
|
|
* @param p_codec the codec previously initialise
|
|
* @param p_callback the callback function which will be used
|
|
* @param p_user_data client object where will be returned the message
|
|
*/
|
|
OPJ_API OPJ_BOOL OPJ_CALLCONV opj_set_info_handler(opj_codec_t * p_codec,
|
|
opj_msg_callback p_callback,
|
|
void * p_user_data);
|
|
/**
|
|
* Set the warning handler use by openjpeg.
|
|
* @param p_codec the codec previously initialise
|
|
* @param p_callback the callback function which will be used
|
|
* @param p_user_data client object where will be returned the message
|
|
*/
|
|
OPJ_API OPJ_BOOL OPJ_CALLCONV opj_set_warning_handler(opj_codec_t * p_codec,
|
|
opj_msg_callback p_callback,
|
|
void * p_user_data);
|
|
/**
|
|
* Set the error handler use by openjpeg.
|
|
* @param p_codec the codec previously initialise
|
|
* @param p_callback the callback function which will be used
|
|
* @param p_user_data client object where will be returned the message
|
|
*/
|
|
OPJ_API OPJ_BOOL OPJ_CALLCONV opj_set_error_handler(opj_codec_t * p_codec,
|
|
opj_msg_callback p_callback,
|
|
void * p_user_data);
|
|
|
|
/*
|
|
==========================================================
|
|
codec functions definitions
|
|
==========================================================
|
|
*/
|
|
|
|
/**
|
|
* Creates a J2K/JP2 decompression structure
|
|
* @param format Decoder to select
|
|
*
|
|
* @return Returns a handle to a decompressor if successful, returns NULL otherwise
|
|
* */
|
|
OPJ_API opj_codec_t* OPJ_CALLCONV opj_create_decompress(
|
|
OPJ_CODEC_FORMAT format);
|
|
|
|
/**
|
|
* Destroy a decompressor handle
|
|
*
|
|
* @param p_codec decompressor handle to destroy
|
|
*/
|
|
OPJ_API void OPJ_CALLCONV opj_destroy_codec(opj_codec_t * p_codec);
|
|
|
|
/**
|
|
* Read after the codestream if necessary
|
|
* @param p_codec the JPEG2000 codec to read.
|
|
* @param p_stream the JPEG2000 stream.
|
|
*/
|
|
OPJ_API OPJ_BOOL OPJ_CALLCONV opj_end_decompress(opj_codec_t *p_codec,
|
|
opj_stream_t *p_stream);
|
|
|
|
|
|
/**
|
|
* Set decoding parameters to default values
|
|
* @param parameters Decompression parameters
|
|
*/
|
|
OPJ_API void OPJ_CALLCONV opj_set_default_decoder_parameters(
|
|
opj_dparameters_t *parameters);
|
|
|
|
/**
|
|
* Setup the decoder with decompression parameters provided by the user and with the message handler
|
|
* provided by the user.
|
|
*
|
|
* @param p_codec decompressor handler
|
|
* @param parameters decompression parameters
|
|
*
|
|
* @return true if the decoder is correctly set
|
|
*/
|
|
OPJ_API OPJ_BOOL OPJ_CALLCONV opj_setup_decoder(opj_codec_t *p_codec,
|
|
opj_dparameters_t *parameters);
|
|
|
|
/**
|
|
* Allocates worker threads for the compressor/decompressor.
|
|
*
|
|
* By default, only the main thread is used. If this function is not used,
|
|
* but the OPJ_NUM_THREADS environment variable is set, its value will be
|
|
* used to initialize the number of threads. The value can be either an integer
|
|
* number, or "ALL_CPUS". If OPJ_NUM_THREADS is set and this function is called,
|
|
* this function will override the behaviour of the environment variable.
|
|
*
|
|
* Currently this function must be called after opj_setup_decoder() and
|
|
* before opj_read_header().
|
|
*
|
|
* Note: currently only has effect on the decompressor.
|
|
*
|
|
* @param p_codec decompressor handler
|
|
* @param num_threads number of threads.
|
|
*
|
|
* @return OPJ_TRUE if the decoder is correctly set
|
|
*/
|
|
OPJ_API OPJ_BOOL OPJ_CALLCONV opj_codec_set_threads(opj_codec_t *p_codec,
|
|
int num_threads);
|
|
|
|
/**
|
|
* Decodes an image header.
|
|
*
|
|
* @param p_stream the jpeg2000 stream.
|
|
* @param p_codec the jpeg2000 codec to read.
|
|
* @param p_image the image structure initialized with the characteristics of encoded image.
|
|
*
|
|
* @return true if the main header of the codestream and the JP2 header is correctly read.
|
|
*/
|
|
OPJ_API OPJ_BOOL OPJ_CALLCONV opj_read_header(opj_stream_t *p_stream,
|
|
opj_codec_t *p_codec,
|
|
opj_image_t **p_image);
|
|
|
|
|
|
/** Restrict the number of components to decode.
|
|
*
|
|
* This function should be called after opj_read_header().
|
|
*
|
|
* This function enables to restrict the set of decoded components to the
|
|
* specified indices.
|
|
* Note that the current implementation (apply_color_transforms == OPJ_FALSE)
|
|
* is such that neither the multi-component transform at codestream level,
|
|
* nor JP2 channel transformations will be applied.
|
|
* Consequently the indices are relative to the codestream.
|
|
*
|
|
* Note: opj_decode_tile_data() should not be used together with opj_set_decoded_components().
|
|
*
|
|
* @param p_codec the jpeg2000 codec to read.
|
|
* @param numcomps Size of the comps_indices array.
|
|
* @param comps_indices Array of numcomps values representing the indices
|
|
* of the components to decode (relative to the
|
|
* codestream, starting at 0)
|
|
* @param apply_color_transforms Whether multi-component transform at codestream level
|
|
* or JP2 channel transformations should be applied.
|
|
* Currently this parameter should be set to OPJ_FALSE.
|
|
* Setting it to OPJ_TRUE will result in an error.
|
|
*
|
|
* @return OPJ_TRUE in case of success.
|
|
*/
|
|
OPJ_API OPJ_BOOL OPJ_CALLCONV opj_set_decoded_components(opj_codec_t *p_codec,
|
|
OPJ_UINT32 numcomps,
|
|
const OPJ_UINT32* comps_indices,
|
|
OPJ_BOOL apply_color_transforms);
|
|
|
|
/**
|
|
* Sets the given area to be decoded. This function should be called right after opj_read_header and before any tile header reading.
|
|
*
|
|
* The coordinates passed to this function should be expressed in the reference grid,
|
|
* that is to say at the highest resolution level, even if requesting the image at lower
|
|
* resolution levels.
|
|
*
|
|
* Generally opj_set_decode_area() should be followed by opj_decode(), and the
|
|
* codec cannot be re-used.
|
|
* In the particular case of an image made of a single tile, several sequences of
|
|
* calls to opoj_set_decode_area() and opj_decode() are allowed, and will bring
|
|
* performance improvements when reading an image by chunks.
|
|
*
|
|
* @param p_codec the jpeg2000 codec.
|
|
* @param p_image the decoded image previously set by opj_read_header
|
|
* @param p_start_x the left position of the rectangle to decode (in image coordinates).
|
|
* @param p_end_x the right position of the rectangle to decode (in image coordinates).
|
|
* @param p_start_y the up position of the rectangle to decode (in image coordinates).
|
|
* @param p_end_y the bottom position of the rectangle to decode (in image coordinates).
|
|
*
|
|
* @return true if the area could be set.
|
|
*/
|
|
OPJ_API OPJ_BOOL OPJ_CALLCONV opj_set_decode_area(opj_codec_t *p_codec,
|
|
opj_image_t* p_image,
|
|
OPJ_INT32 p_start_x, OPJ_INT32 p_start_y,
|
|
OPJ_INT32 p_end_x, OPJ_INT32 p_end_y);
|
|
|
|
/**
|
|
* Decode an image from a JPEG-2000 codestream
|
|
*
|
|
* @param p_decompressor decompressor handle
|
|
* @param p_stream Input buffer stream
|
|
* @param p_image the decoded image
|
|
* @return true if success, otherwise false
|
|
* */
|
|
OPJ_API OPJ_BOOL OPJ_CALLCONV opj_decode(opj_codec_t *p_decompressor,
|
|
opj_stream_t *p_stream,
|
|
opj_image_t *p_image);
|
|
|
|
/**
|
|
* Get the decoded tile from the codec
|
|
*
|
|
* @param p_codec the jpeg2000 codec.
|
|
* @param p_stream input streamm
|
|
* @param p_image output image
|
|
* @param tile_index index of the tile which will be decode
|
|
*
|
|
* @return true if success, otherwise false
|
|
*/
|
|
OPJ_API OPJ_BOOL OPJ_CALLCONV opj_get_decoded_tile(opj_codec_t *p_codec,
|
|
opj_stream_t *p_stream,
|
|
opj_image_t *p_image,
|
|
OPJ_UINT32 tile_index);
|
|
|
|
/**
|
|
* Set the resolution factor of the decoded image
|
|
* @param p_codec the jpeg2000 codec.
|
|
* @param res_factor resolution factor to set
|
|
*
|
|
* @return true if success, otherwise false
|
|
*/
|
|
OPJ_API OPJ_BOOL OPJ_CALLCONV opj_set_decoded_resolution_factor(
|
|
opj_codec_t *p_codec, OPJ_UINT32 res_factor);
|
|
|
|
/**
|
|
* Writes a tile with the given data.
|
|
*
|
|
* @param p_codec the jpeg2000 codec.
|
|
* @param p_tile_index the index of the tile to write. At the moment, the tiles must be written from 0 to n-1 in sequence.
|
|
* @param p_data pointer to the data to write. Data is arranged in sequence, data_comp0, then data_comp1, then ... NO INTERLEAVING should be set.
|
|
* @param p_data_size this value os used to make sure the data being written is correct. The size must be equal to the sum for each component of
|
|
* tile_width * tile_height * component_size. component_size can be 1,2 or 4 bytes, depending on the precision of the given component.
|
|
* @param p_stream the stream to write data to.
|
|
*
|
|
* @return true if the data could be written.
|
|
*/
|
|
OPJ_API OPJ_BOOL OPJ_CALLCONV opj_write_tile(opj_codec_t *p_codec,
|
|
OPJ_UINT32 p_tile_index,
|
|
OPJ_BYTE * p_data,
|
|
OPJ_UINT32 p_data_size,
|
|
opj_stream_t *p_stream);
|
|
|
|
/**
|
|
* Reads a tile header. This function is compulsory and allows one to know the size of the tile that will be decoded.
|
|
* The user may need to refer to the image got by opj_read_header to understand the size being taken by the tile.
|
|
*
|
|
* @param p_codec the jpeg2000 codec.
|
|
* @param p_tile_index pointer to a value that will hold the index of the tile being decoded, in case of success.
|
|
* @param p_data_size pointer to a value that will hold the maximum size of the decoded data, in case of success. In case
|
|
* of truncated codestreams, the actual number of bytes decoded may be lower. The computation of the size is the same
|
|
* as depicted in opj_write_tile.
|
|
* @param p_tile_x0 pointer to a value that will hold the x0 pos of the tile (in the image).
|
|
* @param p_tile_y0 pointer to a value that will hold the y0 pos of the tile (in the image).
|
|
* @param p_tile_x1 pointer to a value that will hold the x1 pos of the tile (in the image).
|
|
* @param p_tile_y1 pointer to a value that will hold the y1 pos of the tile (in the image).
|
|
* @param p_nb_comps pointer to a value that will hold the number of components in the tile.
|
|
* @param p_should_go_on pointer to a boolean that will hold the fact that the decoding should go on. In case the
|
|
* codestream is over at the time of the call, the value will be set to false. The user should then stop
|
|
* the decoding.
|
|
* @param p_stream the stream to decode.
|
|
* @return true if the tile header could be decoded. In case the decoding should end, the returned value is still true.
|
|
* returning false may be the result of a shortage of memory or an internal error.
|
|
*/
|
|
OPJ_API OPJ_BOOL OPJ_CALLCONV opj_read_tile_header(opj_codec_t *p_codec,
|
|
opj_stream_t * p_stream,
|
|
OPJ_UINT32 * p_tile_index,
|
|
OPJ_UINT32 * p_data_size,
|
|
OPJ_INT32 * p_tile_x0, OPJ_INT32 * p_tile_y0,
|
|
OPJ_INT32 * p_tile_x1, OPJ_INT32 * p_tile_y1,
|
|
OPJ_UINT32 * p_nb_comps,
|
|
OPJ_BOOL * p_should_go_on);
|
|
|
|
/**
|
|
* Reads a tile data. This function is compulsory and allows one to decode tile data. opj_read_tile_header should be called before.
|
|
* The user may need to refer to the image got by opj_read_header to understand the size being taken by the tile.
|
|
*
|
|
* Note: opj_decode_tile_data() should not be used together with opj_set_decoded_components().
|
|
*
|
|
* @param p_codec the jpeg2000 codec.
|
|
* @param p_tile_index the index of the tile being decoded, this should be the value set by opj_read_tile_header.
|
|
* @param p_data pointer to a memory block that will hold the decoded data.
|
|
* @param p_data_size size of p_data. p_data_size should be bigger or equal to the value set by opj_read_tile_header.
|
|
* @param p_stream the stream to decode.
|
|
*
|
|
* @return true if the data could be decoded.
|
|
*/
|
|
OPJ_API OPJ_BOOL OPJ_CALLCONV opj_decode_tile_data(opj_codec_t *p_codec,
|
|
OPJ_UINT32 p_tile_index,
|
|
OPJ_BYTE * p_data,
|
|
OPJ_UINT32 p_data_size,
|
|
opj_stream_t *p_stream);
|
|
|
|
/* COMPRESSION FUNCTIONS*/
|
|
|
|
/**
|
|
* Creates a J2K/JP2 compression structure
|
|
* @param format Coder to select
|
|
* @return Returns a handle to a compressor if successful, returns NULL otherwise
|
|
*/
|
|
OPJ_API opj_codec_t* OPJ_CALLCONV opj_create_compress(OPJ_CODEC_FORMAT format);
|
|
|
|
/**
|
|
Set encoding parameters to default values, that means :
|
|
<ul>
|
|
<li>Lossless
|
|
<li>1 tile
|
|
<li>Size of precinct : 2^15 x 2^15 (means 1 precinct)
|
|
<li>Size of code-block : 64 x 64
|
|
<li>Number of resolutions: 6
|
|
<li>No SOP marker in the codestream
|
|
<li>No EPH marker in the codestream
|
|
<li>No sub-sampling in x or y direction
|
|
<li>No mode switch activated
|
|
<li>Progression order: LRCP
|
|
<li>No index file
|
|
<li>No ROI upshifted
|
|
<li>No offset of the origin of the image
|
|
<li>No offset of the origin of the tiles
|
|
<li>Reversible DWT 5-3
|
|
</ul>
|
|
@param parameters Compression parameters
|
|
*/
|
|
OPJ_API void OPJ_CALLCONV opj_set_default_encoder_parameters(
|
|
opj_cparameters_t *parameters);
|
|
|
|
/**
|
|
* Setup the encoder parameters using the current image and using user parameters.
|
|
* @param p_codec Compressor handle
|
|
* @param parameters Compression parameters
|
|
* @param image Input filled image
|
|
*/
|
|
OPJ_API OPJ_BOOL OPJ_CALLCONV opj_setup_encoder(opj_codec_t *p_codec,
|
|
opj_cparameters_t *parameters,
|
|
opj_image_t *image);
|
|
|
|
/**
|
|
* Start to compress the current image.
|
|
* @param p_codec Compressor handle
|
|
* @param p_image Input filled image
|
|
* @param p_stream Input stgream
|
|
*/
|
|
OPJ_API OPJ_BOOL OPJ_CALLCONV opj_start_compress(opj_codec_t *p_codec,
|
|
opj_image_t * p_image,
|
|
opj_stream_t *p_stream);
|
|
|
|
/**
|
|
* End to compress the current image.
|
|
* @param p_codec Compressor handle
|
|
* @param p_stream Input stgream
|
|
*/
|
|
OPJ_API OPJ_BOOL OPJ_CALLCONV opj_end_compress(opj_codec_t *p_codec,
|
|
opj_stream_t *p_stream);
|
|
|
|
/**
|
|
* Encode an image into a JPEG-2000 codestream
|
|
* @param p_codec compressor handle
|
|
* @param p_stream Output buffer stream
|
|
*
|
|
* @return Returns true if successful, returns false otherwise
|
|
*/
|
|
OPJ_API OPJ_BOOL OPJ_CALLCONV opj_encode(opj_codec_t *p_codec,
|
|
opj_stream_t *p_stream);
|
|
/*
|
|
==========================================================
|
|
codec output functions definitions
|
|
==========================================================
|
|
*/
|
|
/* EXPERIMENTAL FUNCTIONS FOR NOW, USED ONLY IN J2K_DUMP*/
|
|
|
|
/**
|
|
Destroy Codestream information after compression or decompression
|
|
@param cstr_info Codestream information structure
|
|
*/
|
|
OPJ_API void OPJ_CALLCONV opj_destroy_cstr_info(opj_codestream_info_v2_t
|
|
**cstr_info);
|
|
|
|
|
|
/**
|
|
* Dump the codec information into the output stream
|
|
*
|
|
* @param p_codec the jpeg2000 codec.
|
|
* @param info_flag type of information dump.
|
|
* @param output_stream output stream where dump the information gotten from the codec.
|
|
*
|
|
*/
|
|
OPJ_API void OPJ_CALLCONV opj_dump_codec(opj_codec_t *p_codec,
|
|
OPJ_INT32 info_flag,
|
|
FILE* output_stream);
|
|
|
|
/**
|
|
* Get the codestream information from the codec
|
|
*
|
|
* @param p_codec the jpeg2000 codec.
|
|
*
|
|
* @return a pointer to a codestream information structure.
|
|
*
|
|
*/
|
|
OPJ_API opj_codestream_info_v2_t* OPJ_CALLCONV opj_get_cstr_info(
|
|
opj_codec_t *p_codec);
|
|
|
|
/**
|
|
* Get the codestream index from the codec
|
|
*
|
|
* @param p_codec the jpeg2000 codec.
|
|
*
|
|
* @return a pointer to a codestream index structure.
|
|
*
|
|
*/
|
|
OPJ_API opj_codestream_index_t * OPJ_CALLCONV opj_get_cstr_index(
|
|
opj_codec_t *p_codec);
|
|
|
|
OPJ_API void OPJ_CALLCONV opj_destroy_cstr_index(opj_codestream_index_t
|
|
**p_cstr_index);
|
|
|
|
|
|
/**
|
|
* Get the JP2 file information from the codec FIXME
|
|
*
|
|
* @param p_codec the jpeg2000 codec.
|
|
*
|
|
* @return a pointer to a JP2 metadata structure.
|
|
*
|
|
*/
|
|
OPJ_API opj_jp2_metadata_t* OPJ_CALLCONV opj_get_jp2_metadata(
|
|
opj_codec_t *p_codec);
|
|
|
|
/**
|
|
* Get the JP2 file index from the codec FIXME
|
|
*
|
|
* @param p_codec the jpeg2000 codec.
|
|
*
|
|
* @return a pointer to a JP2 index structure.
|
|
*
|
|
*/
|
|
OPJ_API opj_jp2_index_t* OPJ_CALLCONV opj_get_jp2_index(opj_codec_t *p_codec);
|
|
|
|
|
|
/*
|
|
==========================================================
|
|
MCT functions
|
|
==========================================================
|
|
*/
|
|
|
|
/**
|
|
* Sets the MCT matrix to use.
|
|
*
|
|
* @param parameters the parameters to change.
|
|
* @param pEncodingMatrix the encoding matrix.
|
|
* @param p_dc_shift the dc shift coefficients to use.
|
|
* @param pNbComp the number of components of the image.
|
|
*
|
|
* @return true if the parameters could be set.
|
|
*/
|
|
OPJ_API OPJ_BOOL OPJ_CALLCONV opj_set_MCT(opj_cparameters_t *parameters,
|
|
OPJ_FLOAT32 * pEncodingMatrix,
|
|
OPJ_INT32 * p_dc_shift,
|
|
OPJ_UINT32 pNbComp);
|
|
|
|
/*
|
|
==========================================================
|
|
Thread functions
|
|
==========================================================
|
|
*/
|
|
|
|
/** Returns if the library is built with thread support.
|
|
* OPJ_TRUE if mutex, condition, thread, thread pool are available.
|
|
*/
|
|
OPJ_API OPJ_BOOL OPJ_CALLCONV opj_has_thread_support(void);
|
|
|
|
/** Return the number of virtual CPUs */
|
|
OPJ_API int OPJ_CALLCONV opj_get_num_cpus(void);
|
|
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* OPENJPEG_H */
|