src/lib/openjp2/openjpeg.c

   1 /*
   2  * Copyright (c) 2005, Herve Drolon, FreeImage Team
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
  15  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  18  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  19  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  20  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  21  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  22  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  23  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  24  * POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #ifdef _WIN32
  28 #include <windows.h>
  29 #endif /* _WIN32 */
  30
  31 #include "opj_config.h"
  32 #include "opj_includes.h"
  33
  34 /**
  35  * Decompression handler.
  36  */
  37 typedef struct opj_decompression
  38 {
  39         /** Main header reading function handler*/
  40         opj_bool (*opj_read_header) (   struct opj_stream_private * cio,
  41                                                                         void * p_codec,
  42                                                                         opj_image_t **p_image,
  43                                                                         struct opj_event_mgr * p_manager);
  44         /** Decoding function */
  45         opj_bool (*opj_decode) (        void * p_codec,
  46                                                                 struct opj_stream_private *p_cio,
  47                                                                 opj_image_t *p_image,
  48                                                                 struct opj_event_mgr * p_manager);
  49         /** FIXME DOC */
  50         opj_bool (*opj_read_tile_header)(       void * p_codec,
  51                                                                                 OPJ_UINT32 * p_tile_index,
  52                                                                                 OPJ_UINT32* p_data_size,
  53                                                                                 OPJ_INT32 * p_tile_x0, OPJ_INT32 * p_tile_y0,
  54                                                                                 OPJ_INT32 * p_tile_x1, OPJ_INT32 * p_tile_y1,
  55                                                                                 OPJ_UINT32 * p_nb_comps,
  56                                                                                 opj_bool * p_should_go_on,
  57                                                                                 struct opj_stream_private *p_cio,
  58                                                                                 struct opj_event_mgr * p_manager);
  59         /** FIXME DOC */
  60         opj_bool (*opj_decode_tile_data)(       void * p_codec,
  61                                                                                 OPJ_UINT32 p_tile_index,
  62                                                                                 OPJ_BYTE * p_data,
  63                                                                                 OPJ_UINT32 p_data_size,
  64                                                                                 struct opj_stream_private *p_cio,
  65                                                                                 struct opj_event_mgr * p_manager);
  66         /** Reading function used after codestream if necessary */
  67         opj_bool (* opj_end_decompress) (       void *p_codec,
  68                                                                                 struct opj_stream_private *cio,
  69                                                                                 struct opj_event_mgr * p_manager);
  70         /** Codec destroy function handler*/
  71         void (*opj_destroy) (void * p_codec);
  72         /** Setup decoder function handler */
  73         void (*opj_setup_decoder) (void * p_codec, opj_dparameters_t * p_param);
  74         /** Set decode area function handler */
  75         opj_bool (*opj_set_decode_area) (       void * p_codec,
  76                                                                                 opj_image_t* p_image,
  77                                                                                 OPJ_INT32 p_start_x, OPJ_INT32 p_end_x,
  78                                                                                 OPJ_INT32 p_start_y, OPJ_INT32 p_end_y,
  79                                                                                 struct opj_event_mgr * p_manager);
  80
  81         /** Get tile function */
  82         opj_bool (*opj_get_decoded_tile) (      void *p_codec,
  83                                                                                 opj_stream_private_t *p_cio,
  84                                                                                 opj_image_t *p_image,
  85                                                                                 struct opj_event_mgr * p_manager,
  86                                                                                 OPJ_UINT32 tile_index);
  87
  88         /** Set the decoded resolution factor */
  89         opj_bool (*opj_set_decoded_resolution_factor) ( void * p_codec,
  90                                                     OPJ_UINT32 res_factor,
  91                                                     opj_event_mgr_t * p_manager);
  92
  93 }opj_decompression_t;
  94
  95 /**
  96  * Compression handler. FIXME DOC
  97  */
  98 typedef struct opj_compression
  99 {
 100         opj_bool (* opj_start_compress) (       void *p_codec,
 101                                                                                 struct opj_stream_private *cio,
 102                                                                                 struct opj_image * p_image,
 103                                                                                 struct opj_event_mgr * p_manager);
 104
 105         opj_bool (* opj_encode) (       void * p_codec,
 106                                                                 struct opj_stream_private *p_cio,
 107                                                                 struct opj_event_mgr * p_manager);
 108
 109         opj_bool (* opj_write_tile) (   void * p_codec,
 110                                                                         OPJ_UINT32 p_tile_index,
 111                                                                         OPJ_BYTE * p_data,
 112                                                                         OPJ_UINT32 p_data_size,
 113                                                                         struct opj_stream_private * p_cio,
 114                                                                         struct opj_event_mgr * p_manager);
 115
 116         opj_bool (* opj_end_compress) ( void * p_codec,
 117                                                                         struct opj_stream_private *p_cio,
 118                                                                         struct opj_event_mgr * p_manager);
 119
 120         void (* opj_destroy) (void * p_codec);
 121
 122         void (* opj_setup_encoder) (    void * p_codec,
 123                                                                 opj_cparameters_t * p_param,
 124                                                                 struct opj_image * p_image,
 125                                                                 struct opj_event_mgr * p_manager);
 126
 127 }opj_compression_t;
 128
 129 /**
 130  * Main codec handler used for compression or decompression.
 131  */
 132 typedef struct opj_codec_private
 133 {
 134         /** FIXME DOC */
 135         union
 136     {
 137         opj_decompression_t m_decompression;
 138         opj_compression_t m_compression;
 139     } m_codec_data;
 140     /** FIXME DOC*/
 141         void * m_codec;
 142         /** Event handler */
 143         opj_event_mgr_t m_event_mgr;
 144         /** Flag to indicate if the codec is used to decode or encode*/
 145         opj_bool is_decompressor;
 146         void (*opj_dump_codec) (void * p_codec, OPJ_INT32 info_flag, FILE* output_stream);
 147         opj_codestream_info_v2_t* (*opj_get_codec_info)(void* p_codec);
 148         opj_codestream_index_t* (*opj_get_codec_index)(void* p_codec);
 149 }
 150 opj_codec_private_t;
 151
 152 /* ---------------------------------------------------------------------- */
 153 /* Functions to set the message handlers */
 154
 155 opj_bool OPJ_CALLCONV opj_set_info_handler(     opj_codec_t * p_codec,
 156                                                                                         opj_msg_callback p_callback,
 157                                                                                         void * p_user_data)
 158 {
 159         opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 160         if(! l_codec){
 161                 return OPJ_FALSE;
 162         }
 163
 164         l_codec->m_event_mgr.info_handler = p_callback;
 165         l_codec->m_event_mgr.m_info_data = p_user_data;
 166
 167         return OPJ_TRUE;
 168 }
 169
 170 opj_bool OPJ_CALLCONV opj_set_warning_handler(  opj_codec_t * p_codec,
 171                                                                                                 opj_msg_callback p_callback,
 172                                                                                                 void * p_user_data)
 173 {
 174         opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 175         if (! l_codec) {
 176                 return OPJ_FALSE;
 177         }
 178
 179         l_codec->m_event_mgr.warning_handler = p_callback;
 180         l_codec->m_event_mgr.m_warning_data = p_user_data;
 181
 182         return OPJ_TRUE;
 183 }
 184
 185 opj_bool OPJ_CALLCONV opj_set_error_handler(opj_codec_t * p_codec,
 186                                                                                         opj_msg_callback p_callback,
 187                                                                                         void * p_user_data)
 188 {
 189         opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 190         if (! l_codec) {
 191                 return OPJ_FALSE;
 192         }
 193
 194         l_codec->m_event_mgr.error_handler = p_callback;
 195         l_codec->m_event_mgr.m_error_data = p_user_data;
 196
 197         return OPJ_TRUE;
 198 }
 199
 200 /* ---------------------------------------------------------------------- */
 201
 202 static OPJ_SIZE_T opj_read_from_file (void * p_buffer, OPJ_SIZE_T p_nb_bytes, FILE * p_file)
 203 {
 204         OPJ_SIZE_T l_nb_read = fread(p_buffer,1,p_nb_bytes,p_file);
 205         return l_nb_read ? l_nb_read : (OPJ_SIZE_T)-1;
 206 }
 207
 208 static OPJ_UINT64 opj_get_data_length_from_file (FILE * p_file)
 209 {
 210         OPJ_OFF_T file_length = 0;
 211
 212         OPJ_FSEEK(p_file, 0, SEEK_END);
 213         file_length = (OPJ_UINT64)OPJ_FTELL(p_file);
 214         OPJ_FSEEK(p_file, 0, SEEK_SET);
 215
 216         return file_length;
 217 }
 218
 219 static OPJ_SIZE_T opj_write_from_file (void * p_buffer, OPJ_SIZE_T p_nb_bytes, FILE * p_file)
 220 {
 221         return fwrite(p_buffer,1,p_nb_bytes,p_file);
 222 }
 223
 224 static OPJ_OFF_T opj_skip_from_file (OPJ_OFF_T p_nb_bytes, FILE * p_user_data)
 225 {
 226         if (OPJ_FSEEK(p_user_data,p_nb_bytes,SEEK_CUR)) {
 227                 return -1;
 228         }
 229
 230         return p_nb_bytes;
 231 }
 232
 233 static opj_bool opj_seek_from_file (OPJ_OFF_T p_nb_bytes, FILE * p_user_data)
 234 {
 235         if (OPJ_FSEEK(p_user_data,p_nb_bytes,SEEK_SET)) {
 236                 return OPJ_FALSE;
 237         }
 238
 239         return OPJ_TRUE;
 240 }
 241
 242 /* ---------------------------------------------------------------------- */
 243 #ifdef _WIN32
 244 #ifndef OPJ_STATIC
 245 BOOL APIENTRY
 246 DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
 247
 248         OPJ_ARG_NOT_USED(lpReserved);
 249         OPJ_ARG_NOT_USED(hModule);
 250
 251         switch (ul_reason_for_call) {
 252                 case DLL_PROCESS_ATTACH :
 253                         break;
 254                 case DLL_PROCESS_DETACH :
 255                         break;
 256                 case DLL_THREAD_ATTACH :
 257                 case DLL_THREAD_DETACH :
 258                         break;
 259     }
 260
 261     return TRUE;
 262 }
 263 #endif /* OPJ_STATIC */
 264 #endif /* _WIN32 */
 265
 266 /* ---------------------------------------------------------------------- */
 267
 268 const char* OPJ_CALLCONV opj_version(void) {
 269     return OPJ_PACKAGE_VERSION;
 270 }
 271
 272 /* ---------------------------------------------------------------------- */
 273 /* DECOMPRESSION FUNCTIONS*/
 274
 275 opj_codec_t* OPJ_CALLCONV opj_create_decompress(OPJ_CODEC_FORMAT p_format)
 276 {
 277         opj_codec_private_t *l_codec = 00;
 278
 279         l_codec = (opj_codec_private_t*) opj_calloc(1, sizeof(opj_codec_private_t));
 280         if (!l_codec){
 281                 return 00;
 282         }
 283         memset(l_codec, 0, sizeof(opj_codec_private_t));
 284
 285         l_codec->is_decompressor = 1;
 286
 287         switch (p_format) {
 288                 case OPJ_CODEC_J2K:
 289                         l_codec->opj_dump_codec = (void (*) (void*, OPJ_INT32, FILE*)) j2k_dump;
 290
 291                         l_codec->opj_get_codec_info = (opj_codestream_info_v2_t* (*) (void*) ) j2k_get_cstr_info;
 292
 293                         l_codec->opj_get_codec_index = (opj_codestream_index_t* (*) (void*) ) j2k_get_cstr_index;
 294
 295                         l_codec->m_codec_data.m_decompression.opj_decode =
 296                                         (opj_bool (*) ( void *,
 297                                                                         struct opj_stream_private *,
 298                                                                         opj_image_t*, struct opj_event_mgr * )) opj_j2k_decode;
 299
 300                         l_codec->m_codec_data.m_decompression.opj_end_decompress =
 301                                         (opj_bool (*) ( void *,
 302                                                                         struct opj_stream_private *,
 303                                                                         struct opj_event_mgr *)) opj_j2k_end_decompress;
 304
 305                         l_codec->m_codec_data.m_decompression.opj_read_header =
 306                                         (opj_bool (*) ( struct opj_stream_private *,
 307                                                                         void *,
 308                                                                         opj_image_t **,
 309                                                                         struct opj_event_mgr * )) opj_j2k_read_header;
 310
 311                         l_codec->m_codec_data.m_decompression.opj_destroy =
 312                                         (void (*) (void *))opj_j2k_destroy;
 313
 314                         l_codec->m_codec_data.m_decompression.opj_setup_decoder =
 315                                         (void (*) (void * , opj_dparameters_t * )) opj_j2k_setup_decoder;
 316
 317                         l_codec->m_codec_data.m_decompression.opj_read_tile_header =
 318                                         (opj_bool (*) ( void *,
 319                                                                         OPJ_UINT32*,
 320                                                                         OPJ_UINT32*,
 321                                                                         OPJ_INT32*, OPJ_INT32*,
 322                                                                         OPJ_INT32*, OPJ_INT32*,
 323                                                                         OPJ_UINT32*,
 324                                                                         opj_bool*,
 325                                                                         struct opj_stream_private *,
 326                                                                         struct opj_event_mgr * )) opj_j2k_read_tile_header;
 327
 328                         l_codec->m_codec_data.m_decompression.opj_decode_tile_data =
 329                                         (opj_bool (*) ( void *,
 330                                     OPJ_UINT32,
 331                                     OPJ_BYTE*,
 332                                     OPJ_UINT32,
 333                                     struct opj_stream_private *,
 334                                     struct opj_event_mgr *)) opj_j2k_decode_tile;
 335
 336                         l_codec->m_codec_data.m_decompression.opj_set_decode_area =
 337                                         (opj_bool (*) ( void *,
 338                                     opj_image_t*,
 339                                     OPJ_INT32, OPJ_INT32, OPJ_INT32, OPJ_INT32,
 340                                     struct opj_event_mgr *)) opj_j2k_set_decode_area;
 341
 342                         l_codec->m_codec_data.m_decompression.opj_get_decoded_tile =
 343                     (opj_bool (*) ( void *p_codec,
 344                                                                     opj_stream_private_t *p_cio,
 345                                                                     opj_image_t *p_image,
 346                                                                     struct opj_event_mgr * p_manager,
 347                                                                     OPJ_UINT32 tile_index)) opj_j2k_get_tile;
 348
 349                         l_codec->m_codec_data.m_decompression.opj_set_decoded_resolution_factor =
 350                     (opj_bool (*) ( void * p_codec,
 351                                                                         OPJ_UINT32 res_factor,
 352                                                                         struct opj_event_mgr * p_manager)) opj_j2k_set_decoded_resolution_factor;
 353
 354                         l_codec->m_codec = opj_j2k_create_decompress();
 355
 356                         if (! l_codec->m_codec) {
 357                                 opj_free(l_codec);
 358                                 return NULL;
 359                         }
 360
 361                         break;
 362
 363                 case OPJ_CODEC_JP2:
 364                         /* get a JP2 decoder handle */
 365                         l_codec->opj_dump_codec = (void (*) (void*, OPJ_INT32, FILE*)) jp2_dump;
 366
 367                         l_codec->opj_get_codec_info = (opj_codestream_info_v2_t* (*) (void*) ) jp2_get_cstr_info;
 368
 369                         l_codec->opj_get_codec_index = (opj_codestream_index_t* (*) (void*) ) jp2_get_cstr_index;
 370
 371                         l_codec->m_codec_data.m_decompression.opj_decode =
 372                                         (opj_bool (*) ( void *,
 373                                                                         struct opj_stream_private *,
 374                                                                         opj_image_t*,
 375                                                                         struct opj_event_mgr * )) opj_jp2_decode;
 376
 377                         l_codec->m_codec_data.m_decompression.opj_end_decompress =
 378                     (opj_bool (*) ( void *,
 379                                     struct opj_stream_private *,
 380                                     struct opj_event_mgr *)) opj_jp2_end_decompress;
 381
 382                         l_codec->m_codec_data.m_decompression.opj_read_header =
 383                     (opj_bool (*) ( struct opj_stream_private *,
 384                                                         void *,
 385                                                         opj_image_t **,
 386                                                         struct opj_event_mgr * )) opj_jp2_read_header;
 387
 388                         l_codec->m_codec_data.m_decompression.opj_read_tile_header =
 389                     (opj_bool (*) ( void *,
 390                                                         OPJ_UINT32*,
 391                                                         OPJ_UINT32*,
 392                                                         OPJ_INT32*,
 393                                                         OPJ_INT32*,
 394                                                         OPJ_INT32 * ,
 395                                                         OPJ_INT32 * ,
 396                                                         OPJ_UINT32 * ,
 397                                                         opj_bool *,
 398                                                         struct opj_stream_private *,
 399                                                         struct opj_event_mgr * )) opj_jp2_read_tile_header;
 400
 401                         l_codec->m_codec_data.m_decompression.opj_decode_tile_data =
 402                     (opj_bool (*) ( void *,
 403                                     OPJ_UINT32,OPJ_BYTE*,OPJ_UINT32,
 404                                     struct opj_stream_private *,
 405                                     struct opj_event_mgr * )) opj_jp2_decode_tile;
 406
 407                         l_codec->m_codec_data.m_decompression.opj_destroy = (void (*) (void *))opj_jp2_destroy;
 408
 409                         l_codec->m_codec_data.m_decompression.opj_setup_decoder =
 410                     (void (*) (void * ,opj_dparameters_t * )) opj_jp2_setup_decoder;
 411
 412                         l_codec->m_codec_data.m_decompression.opj_set_decode_area =
 413                     (opj_bool (*) ( void *,
 414                                     opj_image_t*,
 415                                     OPJ_INT32,OPJ_INT32,OPJ_INT32,OPJ_INT32,
 416                                     struct opj_event_mgr * )) opj_jp2_set_decode_area;
 417
 418                         l_codec->m_codec_data.m_decompression.opj_get_decoded_tile =
 419                     (opj_bool (*) ( void *p_codec,
 420                                                                         opj_stream_private_t *p_cio,
 421                                                                         opj_image_t *p_image,
 422                                                                         struct opj_event_mgr * p_manager,
 423                                                                         OPJ_UINT32 tile_index)) opj_jp2_get_tile;
 424
 425                         l_codec->m_codec_data.m_decompression.opj_set_decoded_resolution_factor =
 426                     (opj_bool (*) ( void * p_codec,
 427                                                                 OPJ_UINT32 res_factor,
 428                                                                 opj_event_mgr_t * p_manager)) opj_jp2_set_decoded_resolution_factor;
 429
 430                         l_codec->m_codec = opj_jp2_create(OPJ_TRUE);
 431
 432                         if (! l_codec->m_codec) {
 433                                 opj_free(l_codec);
 434                                 return 00;
 435                         }
 436
 437                         break;
 438                 case OPJ_CODEC_UNKNOWN:
 439                 case OPJ_CODEC_JPT:
 440                 default:
 441                         opj_free(l_codec);
 442                         return 00;
 443         }
 444
 445         opj_set_default_event_handler(&(l_codec->m_event_mgr));
 446         return (opj_codec_t*) l_codec;
 447 }
 448
 449 void OPJ_CALLCONV opj_set_default_decoder_parameters(opj_dparameters_t *parameters) {
 450         if(parameters) {
 451                 memset(parameters, 0, sizeof(opj_dparameters_t));
 452                 /* default decoding parameters */
 453                 parameters->cp_layer = 0;
 454                 parameters->cp_reduce = 0;
 455                 parameters->cp_limit_decoding = NO_LIMITATION;
 456
 457                 parameters->decod_format = -1;
 458                 parameters->cod_format = -1;
 459                 parameters->flags = 0;
 460 /* UniPG>> */
 461 #ifdef USE_JPWL
 462                 parameters->jpwl_correct = OPJ_FALSE;
 463                 parameters->jpwl_exp_comps = JPWL_EXPECTED_COMPONENTS;
 464                 parameters->jpwl_max_tiles = JPWL_MAXIMUM_TILES;
 465 #endif /* USE_JPWL */
 466 /* <<UniPG */
 467         }
 468 }
 469
 470 opj_bool OPJ_CALLCONV opj_setup_decoder(opj_codec_t *p_codec,
 471                                         opj_dparameters_t *parameters
 472                                                                                 )
 473 {
 474         if (p_codec && parameters) {
 475                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 476
 477                 if (! l_codec->is_decompressor) {
 478                         opj_event_msg(&(l_codec->m_event_mgr), EVT_ERROR,
 479                 "Codec provided to the opj_setup_decoder function is not a decompressor handler.\n");
 480                         return OPJ_FALSE;
 481                 }
 482
 483                 l_codec->m_codec_data.m_decompression.opj_setup_decoder(l_codec->m_codec,
 484                                                                                                                                 parameters);
 485                 return OPJ_TRUE;
 486         }
 487         return OPJ_FALSE;
 488 }
 489
 490 opj_bool OPJ_CALLCONV opj_read_header ( opj_stream_t *p_stream,
 491                                                                                 opj_codec_t *p_codec,
 492                                                                                 opj_image_t **p_image )
 493 {
 494         if (p_codec && p_stream) {
 495                 opj_codec_private_t* l_codec = (opj_codec_private_t*) p_codec;
 496                 opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
 497
 498                 if(! l_codec->is_decompressor) {
 499                         opj_event_msg(&(l_codec->m_event_mgr), EVT_ERROR,
 500                 "Codec provided to the opj_read_header function is not a decompressor handler.\n");
 501                         return OPJ_FALSE;
 502                 }
 503
 504                 return l_codec->m_codec_data.m_decompression.opj_read_header(   l_stream,
 505                                                                                                                                                 l_codec->m_codec,
 506                                                                                                                                                 p_image,
 507                                                                                                                                                 &(l_codec->m_event_mgr) );
 508         }
 509
 510         return OPJ_FALSE;
 511 }
 512
 513 opj_bool OPJ_CALLCONV opj_decode(   opj_codec_t *p_codec,
 514                                     opj_stream_t *p_stream,
 515                                     opj_image_t* p_image)
 516 {
 517         if (p_codec && p_stream) {
 518                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 519                 opj_stream_private_t * l_stream = (opj_stream_private_t *) p_stream;
 520
 521                 if (! l_codec->is_decompressor) {
 522                         return OPJ_FALSE;
 523                 }
 524
 525                 return l_codec->m_codec_data.m_decompression.opj_decode(l_codec->m_codec,
 526                                                                                                                                 l_stream,
 527                                                                                                                                 p_image,
 528                                                                                                                                 &(l_codec->m_event_mgr) );
 529         }
 530
 531         return OPJ_FALSE;
 532 }
 533
 534 opj_bool OPJ_CALLCONV opj_set_decode_area(      opj_codec_t *p_codec,
 535                                                                                         opj_image_t* p_image,
 536                                                                                         OPJ_INT32 p_start_x, OPJ_INT32 p_start_y,
 537                                                                                         OPJ_INT32 p_end_x, OPJ_INT32 p_end_y
 538                                                                                         )
 539 {
 540         if (p_codec) {
 541                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 542
 543                 if (! l_codec->is_decompressor) {
 544                         return OPJ_FALSE;
 545                 }
 546
 547                 return  l_codec->m_codec_data.m_decompression.opj_set_decode_area(      l_codec->m_codec,
 548                                                                                                                                                         p_image,
 549                                                                                                                                                         p_start_x, p_start_y,
 550                                                                                                                                                         p_end_x, p_end_y,
 551                                                                                                                                                         &(l_codec->m_event_mgr) );
 552         }
 553         return OPJ_FALSE;
 554 }
 555
 556 opj_bool OPJ_CALLCONV opj_read_tile_header(     opj_codec_t *p_codec,
 557                                                                                         opj_stream_t * p_stream,
 558                                                                                         OPJ_UINT32 * p_tile_index,
 559                                                                                         OPJ_UINT32 * p_data_size,
 560                                                                                         OPJ_INT32 * p_tile_x0, OPJ_INT32 * p_tile_y0,
 561                                                                                         OPJ_INT32 * p_tile_x1, OPJ_INT32 * p_tile_y1,
 562                                                                                         OPJ_UINT32 * p_nb_comps,
 563                                                                                         opj_bool * p_should_go_on)
 564 {
 565         if (p_codec && p_stream && p_data_size && p_tile_index) {
 566                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 567                 opj_stream_private_t * l_stream = (opj_stream_private_t *) p_stream;
 568
 569                 if (! l_codec->is_decompressor) {
 570                         return OPJ_FALSE;
 571                 }
 572
 573                 return l_codec->m_codec_data.m_decompression.opj_read_tile_header(      l_codec->m_codec,
 574                                                                                                                                                         p_tile_index,
 575                                                                                                                                                         p_data_size,
 576                                                                                                                                                         p_tile_x0, p_tile_y0,
 577                                                                                                                                                         p_tile_x1, p_tile_y1,
 578                                                                                                                                                         p_nb_comps,
 579                                                                                                                                                         p_should_go_on,
 580                                                                                                                                                         l_stream,
 581                                                                                                                                                         &(l_codec->m_event_mgr));
 582         }
 583         return OPJ_FALSE;
 584 }
 585
 586 opj_bool OPJ_CALLCONV opj_decode_tile_data(     opj_codec_t *p_codec,
 587                                                                                         OPJ_UINT32 p_tile_index,
 588                                                                                         OPJ_BYTE * p_data,
 589                                                                                         OPJ_UINT32 p_data_size,
 590                                                                                         opj_stream_t *p_stream
 591                                                                                         )
 592 {
 593         if (p_codec && p_data && p_stream) {
 594                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 595                 opj_stream_private_t * l_stream = (opj_stream_private_t *) p_stream;
 596
 597                 if (! l_codec->is_decompressor) {
 598                         return OPJ_FALSE;
 599                 }
 600
 601                 return l_codec->m_codec_data.m_decompression.opj_decode_tile_data(      l_codec->m_codec,
 602                                                                                                                                                         p_tile_index,
 603                                                                                                                                                         p_data,
 604                                                                                                                                                         p_data_size,
 605                                                                                                                                                         l_stream,
 606                                                                                                                                                         &(l_codec->m_event_mgr) );
 607         }
 608         return OPJ_FALSE;
 609 }
 610
 611 opj_bool OPJ_CALLCONV opj_get_decoded_tile(     opj_codec_t *p_codec,
 612                                                                                         opj_stream_t *p_stream,
 613                                                                                         opj_image_t *p_image,
 614                                                                                         OPJ_UINT32 tile_index)
 615 {
 616         if (p_codec && p_stream) {
 617                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 618                 opj_stream_private_t * l_stream = (opj_stream_private_t *) p_stream;
 619
 620                 if (! l_codec->is_decompressor) {
 621                         return OPJ_FALSE;
 622                 }
 623
 624                 return l_codec->m_codec_data.m_decompression.opj_get_decoded_tile(      l_codec->m_codec,
 625                                                                                                                                                         l_stream,
 626                                                                                                                                                         p_image,
 627                                                                                                                                                         &(l_codec->m_event_mgr),
 628                                                                                                                                                         tile_index);
 629         }
 630
 631         return OPJ_FALSE;
 632 }
 633
 634 opj_bool OPJ_CALLCONV opj_set_decoded_resolution_factor(opj_codec_t *p_codec,
 635                                                                                                                 OPJ_UINT32 res_factor )
 636 {
 637         opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 638
 639         if ( !l_codec ){
 640                 fprintf(stderr, "[ERROR] Input parameters of the setup_decoder function are incorrect.\n");
 641                 return OPJ_FALSE;
 642         }
 643
 644         l_codec->m_codec_data.m_decompression.opj_set_decoded_resolution_factor(l_codec->m_codec,
 645                                                                                                                                                         res_factor,
 646                                                                                                                                                         &(l_codec->m_event_mgr) );
 647         return OPJ_TRUE;
 648 }
 649
 650 /* ---------------------------------------------------------------------- */
 651 /* COMPRESSION FUNCTIONS*/
 652
 653 opj_codec_t* OPJ_CALLCONV opj_create_compress(OPJ_CODEC_FORMAT p_format)
 654 {
 655         opj_codec_private_t *l_codec = 00;
 656
 657         l_codec = (opj_codec_private_t*)opj_calloc(1, sizeof(opj_codec_private_t));
 658         if (!l_codec) {
 659                 return 00;
 660         }
 661         memset(l_codec, 0, sizeof(opj_codec_private_t));
 662
 663         l_codec->is_decompressor = 0;
 664
 665         switch(p_format) {
 666                 case OPJ_CODEC_J2K:
 667                         l_codec->m_codec_data.m_compression.opj_encode = (opj_bool (*) (void *,
 668                                                                                                                                                         struct opj_stream_private *,
 669                                                                                                                                                         struct opj_event_mgr * )) opj_j2k_encode_v2;
 670
 671                         l_codec->m_codec_data.m_compression.opj_end_compress = (opj_bool (*) (  void *,
 672                                                                                                                                                                         struct opj_stream_private *,
 673                                                                                                                                                                         struct opj_event_mgr *)) opj_j2k_end_compress;
 674
 675                         l_codec->m_codec_data.m_compression.opj_start_compress = (opj_bool (*) (void *,
 676                                                                                                                                                                         struct opj_stream_private *,
 677                                                                                                                                                                         struct opj_image * ,
 678                                                                                                                                                                         struct opj_event_mgr *)) opj_j2k_start_compress;
 679
 680                         l_codec->m_codec_data.m_compression.opj_write_tile = (opj_bool (*) (void *,
 681                                                                                                                                                                 OPJ_UINT32,
 682                                                                                                                                                                 OPJ_BYTE*,
 683                                                                                                                                                                 OPJ_UINT32,
 684                                                                                                                                                                 struct opj_stream_private *,
 685                                                                                                                                                                 struct opj_event_mgr *) ) opj_j2k_write_tile;
 686
 687                         l_codec->m_codec_data.m_compression.opj_destroy = (void (*) (void *)) opj_j2k_destroy;
 688
 689                         l_codec->m_codec_data.m_compression.opj_setup_encoder = (void (*) (     void *,
 690                                                                                                                                                                 opj_cparameters_t *,
 691                                                                                                                                                                 struct opj_image *,
 692                                                                                                                                                                 struct opj_event_mgr * )) opj_j2k_setup_encoder;
 693
 694                         l_codec->m_codec = opj_j2k_create_compress();
 695                         if (! l_codec->m_codec) {
 696                                 opj_free(l_codec);
 697                                 return 00;
 698                         }
 699
 700                         break;
 701
 702                 case OPJ_CODEC_JP2:
 703                         /* get a JP2 decoder handle */
 704                         l_codec->m_codec_data.m_compression.opj_encode = (opj_bool (*) (void *,
 705                                                                                                                                                         struct opj_stream_private *,
 706                                                                                                                                                         struct opj_event_mgr * )) opj_jp2_encode;
 707
 708                         l_codec->m_codec_data.m_compression.opj_end_compress = (opj_bool (*) (  void *,
 709                                                                                                                                                                         struct opj_stream_private *,
 710                                                                                                                                                                         struct opj_event_mgr *)) opj_jp2_end_compress;
 711
 712                         l_codec->m_codec_data.m_compression.opj_start_compress = (opj_bool (*) (void *,
 713                                                                                                                                                                         struct opj_stream_private *,
 714                                                                                                                                                                         struct opj_image * ,
 715                                                                                                                                                                         struct opj_event_mgr *))  opj_jp2_start_compress;
 716
 717                         l_codec->m_codec_data.m_compression.opj_write_tile = (opj_bool (*) (void *,
 718                                                                                                                                                                 OPJ_UINT32,
 719                                                                                                                                                                 OPJ_BYTE*,
 720                                                                                                                                                                 OPJ_UINT32,
 721                                                                                                                                                                 struct opj_stream_private *,
 722                                                                                                                                                                 struct opj_event_mgr *)) opj_jp2_write_tile;
 723
 724                         l_codec->m_codec_data.m_compression.opj_destroy = (void (*) (void *)) opj_jp2_destroy;
 725
 726                         l_codec->m_codec_data.m_compression.opj_setup_encoder = (void (*) (     void *,
 727                                                                                                                                                                 opj_cparameters_t *,
 728                                                                                                                                                                 struct opj_image *,
 729                                                                                                                                                                 struct opj_event_mgr * )) opj_jp2_setup_encoder;
 730
 731                         l_codec->m_codec = opj_jp2_create(OPJ_FALSE);
 732                         if (! l_codec->m_codec) {
 733                                 opj_free(l_codec);
 734                                 return 00;
 735                         }
 736
 737                         break;
 738
 739                 case OPJ_CODEC_UNKNOWN:
 740                 case OPJ_CODEC_JPT:
 741                 default:
 742                         opj_free(l_codec);
 743                         return 00;
 744         }
 745
 746         opj_set_default_event_handler(&(l_codec->m_event_mgr));
 747         return (opj_codec_t*) l_codec;
 748 }
 749
 750 void OPJ_CALLCONV opj_set_default_encoder_parameters(opj_cparameters_t *parameters) {
 751         if(parameters) {
 752                 memset(parameters, 0, sizeof(opj_cparameters_t));
 753                 /* default coding parameters */
 754                 parameters->cp_cinema = OPJ_OFF;
 755                 parameters->max_comp_size = 0;
 756                 parameters->numresolution = 6;
 757                 parameters->cp_rsiz = OPJ_STD_RSIZ;
 758                 parameters->cblockw_init = 64;
 759                 parameters->cblockh_init = 64;
 760                 parameters->prog_order = OPJ_LRCP;
 761                 parameters->roi_compno = -1;            /* no ROI */
 762                 parameters->subsampling_dx = 1;
 763                 parameters->subsampling_dy = 1;
 764                 parameters->tp_on = 0;
 765                 parameters->decod_format = -1;
 766                 parameters->cod_format = -1;
 767                 parameters->tcp_rates[0] = 0;
 768                 parameters->tcp_numlayers = 0;
 769                 parameters->cp_disto_alloc = 0;
 770                 parameters->cp_fixed_alloc = 0;
 771                 parameters->cp_fixed_quality = 0;
 772                 parameters->jpip_on = OPJ_FALSE;
 773 /* UniPG>> */
 774 #ifdef USE_JPWL
 775                 parameters->jpwl_epc_on = OPJ_FALSE;
 776                 parameters->jpwl_hprot_MH = -1; /* -1 means unassigned */
 777                 {
 778                         int i;
 779                         for (i = 0; i < JPWL_MAX_NO_TILESPECS; i++) {
 780                                 parameters->jpwl_hprot_TPH_tileno[i] = -1; /* unassigned */
 781                                 parameters->jpwl_hprot_TPH[i] = 0; /* absent */
 782                         }
 783                 };
 784                 {
 785                         int i;
 786                         for (i = 0; i < JPWL_MAX_NO_PACKSPECS; i++) {
 787                                 parameters->jpwl_pprot_tileno[i] = -1; /* unassigned */
 788                                 parameters->jpwl_pprot_packno[i] = -1; /* unassigned */
 789                                 parameters->jpwl_pprot[i] = 0; /* absent */
 790                         }
 791                 };
 792                 parameters->jpwl_sens_size = 0; /* 0 means no ESD */
 793                 parameters->jpwl_sens_addr = 0; /* 0 means auto */
 794                 parameters->jpwl_sens_range = 0; /* 0 means packet */
 795                 parameters->jpwl_sens_MH = -1; /* -1 means unassigned */
 796                 {
 797                         int i;
 798                         for (i = 0; i < JPWL_MAX_NO_TILESPECS; i++) {
 799                                 parameters->jpwl_sens_TPH_tileno[i] = -1; /* unassigned */
 800                                 parameters->jpwl_sens_TPH[i] = -1; /* absent */
 801                         }
 802                 };
 803 #endif /* USE_JPWL */
 804 /* <<UniPG */
 805         }
 806 }
 807
 808 opj_bool OPJ_CALLCONV opj_setup_encoder(opj_codec_t *p_codec,
 809                                                                                 opj_cparameters_t *parameters,
 810                                                                                 opj_image_t *p_image)
 811 {
 812         if (p_codec && parameters && p_image) {
 813                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 814
 815                 if (! l_codec->is_decompressor) {
 816                         l_codec->m_codec_data.m_compression.opj_setup_encoder(  l_codec->m_codec,
 817                                                                                                                                         parameters,
 818                                                                                                                                         p_image,
 819                                                                                                                                         &(l_codec->m_event_mgr) );
 820                         return OPJ_TRUE;
 821                 }
 822         }
 823
 824         return OPJ_FALSE;
 825 }
 826
 827 opj_bool OPJ_CALLCONV opj_start_compress (      opj_codec_t *p_codec,
 828                                                                                         opj_image_t * p_image,
 829                                                                                         opj_stream_t *p_stream)
 830 {
 831         if (p_codec && p_stream) {
 832                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 833                 opj_stream_private_t * l_stream = (opj_stream_private_t *) p_stream;
 834
 835                 if (! l_codec->is_decompressor) {
 836                         return l_codec->m_codec_data.m_compression.opj_start_compress(  l_codec->m_codec,
 837                                                                                                                                                         l_stream,
 838                                                                                                                                                         p_image,
 839                                                                                                                                                         &(l_codec->m_event_mgr));
 840                 }
 841         }
 842
 843         return OPJ_FALSE;
 844 }
 845
 846 opj_bool OPJ_CALLCONV opj_encode(opj_codec_t *p_info, opj_stream_t *p_stream)
 847 {
 848         if (p_info && p_stream) {
 849                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_info;
 850                 opj_stream_private_t * l_stream = (opj_stream_private_t *) p_stream;
 851
 852                 if (! l_codec->is_decompressor) {
 853                         l_codec->m_codec_data.m_compression.opj_encode( l_codec->m_codec,
 854                                                                                                                         l_stream,
 855                                                                                                                         &(l_codec->m_event_mgr));
 856                         return OPJ_TRUE;
 857                 }
 858         }
 859
 860         return OPJ_FALSE;
 861
 862 }
 863
 864 opj_bool OPJ_CALLCONV opj_end_compress (opj_codec_t *p_codec,
 865                                                                                 opj_stream_t *p_stream)
 866 {
 867         if (p_codec && p_stream) {
 868                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 869                 opj_stream_private_t * l_stream = (opj_stream_private_t *) p_stream;
 870
 871                 if (! l_codec->is_decompressor) {
 872                         return l_codec->m_codec_data.m_compression.opj_end_compress(l_codec->m_codec,
 873                                                                                                                                                 l_stream,
 874                                                                                                                                                 &(l_codec->m_event_mgr));
 875                 }
 876         }
 877         return OPJ_FALSE;
 878
 879 }
 880
 881 opj_bool OPJ_CALLCONV opj_end_decompress (      opj_codec_t *p_codec,
 882                                                                                         opj_stream_t *p_stream)
 883 {
 884         if (p_codec && p_stream) {
 885                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 886                 opj_stream_private_t * l_stream = (opj_stream_private_t *) p_stream;
 887
 888                 if (! l_codec->is_decompressor) {
 889                         return OPJ_FALSE;
 890                 }
 891
 892                 return l_codec->m_codec_data.m_decompression.opj_end_decompress(l_codec->m_codec,
 893                                                                                                                                                 l_stream,
 894                                                                                                                                                 &(l_codec->m_event_mgr) );
 895         }
 896
 897         return OPJ_FALSE;
 898 }
 899
 900 opj_bool OPJ_CALLCONV opj_set_MCT(opj_cparameters_t *parameters,
 901                                   OPJ_FLOAT32 * pEncodingMatrix,
 902                                   OPJ_INT32 * p_dc_shift,OPJ_UINT32 pNbComp)
 903 {
 904         OPJ_UINT32 l_matrix_size = pNbComp * pNbComp * sizeof(OPJ_FLOAT32);
 905         OPJ_UINT32 l_dc_shift_size = pNbComp * sizeof(OPJ_INT32);
 906         OPJ_UINT32 l_mct_total_size = l_matrix_size + l_dc_shift_size;
 907
 908         /* add MCT capability */
 909         int rsiz = (int)parameters->cp_rsiz | (int)OPJ_MCT;
 910         parameters->cp_rsiz = (OPJ_RSIZ_CAPABILITIES)rsiz;
 911         parameters->irreversible = 1;
 912
 913         /* use array based MCT */
 914         parameters->tcp_mct = 2;
 915         parameters->mct_data = opj_malloc(l_mct_total_size);
 916         if (! parameters->mct_data) {
 917                 return OPJ_FALSE;
 918         }
 919
 920         memcpy(parameters->mct_data,pEncodingMatrix,l_matrix_size);
 921         memcpy(((OPJ_BYTE *) parameters->mct_data) +  l_matrix_size,p_dc_shift,l_dc_shift_size);
 922
 923         return OPJ_TRUE;
 924 }
 925
 926 opj_bool OPJ_CALLCONV opj_write_tile (  opj_codec_t *p_codec,
 927                                                                                 OPJ_UINT32 p_tile_index,
 928                                                                                 OPJ_BYTE * p_data,
 929                                                                                 OPJ_UINT32 p_data_size,
 930                                                                                 opj_stream_t *p_stream )
 931 {
 932         if (p_codec && p_stream && p_data) {
 933                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 934                 opj_stream_private_t * l_stream = (opj_stream_private_t *) p_stream;
 935
 936                 if (l_codec->is_decompressor) {
 937                         return OPJ_FALSE;
 938                 }
 939
 940                 return l_codec->m_codec_data.m_compression.opj_write_tile(      l_codec->m_codec,
 941                                                                                                                                         p_tile_index,
 942                                                                                                                                         p_data,
 943                                                                                                                                         p_data_size,
 944                                                                                                                                         l_stream,
 945                                                                                                                                         &(l_codec->m_event_mgr) );
 946         }
 947
 948         return OPJ_FALSE;
 949 }
 950
 951 /* ---------------------------------------------------------------------- */
 952
 953 void OPJ_CALLCONV opj_destroy_codec(opj_codec_t *p_codec)
 954 {
 955         if (p_codec) {
 956                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 957
 958                 if (l_codec->is_decompressor) {
 959                         l_codec->m_codec_data.m_decompression.opj_destroy(l_codec->m_codec);
 960                 }
 961                 else {
 962                         l_codec->m_codec_data.m_compression.opj_destroy(l_codec->m_codec);
 963                 }
 964
 965                 l_codec->m_codec = 00;
 966                 opj_free(l_codec);
 967         }
 968 }
 969
 970 /* ---------------------------------------------------------------------- */
 971
 972 void OPJ_CALLCONV opj_dump_codec(       opj_codec_t *p_codec,
 973                                                                         OPJ_INT32 info_flag,
 974                                                                         FILE* output_stream)
 975 {
 976         if (p_codec) {
 977                 opj_codec_private_t* l_codec = (opj_codec_private_t*) p_codec;
 978
 979                 l_codec->opj_dump_codec(l_codec->m_codec, info_flag, output_stream);
 980                 return;
 981         }
 982
 983         fprintf(stderr, "[ERROR] Input parameter of the dump_codec function are incorrect.\n");
 984         return;
 985 }
 986
 987 opj_codestream_info_v2_t* OPJ_CALLCONV opj_get_cstr_info(opj_codec_t *p_codec)
 988 {
 989         if (p_codec) {
 990                 opj_codec_private_t* l_codec = (opj_codec_private_t*) p_codec;
 991
 992                 return l_codec->opj_get_codec_info(l_codec->m_codec);
 993         }
 994
 995         return NULL;
 996 }
 997
 998 void OPJ_CALLCONV opj_destroy_cstr_info(opj_codestream_info_v2_t **cstr_info) {
 999         if (cstr_info) {
1000
1001                 if ((*cstr_info)->m_default_tile_info.tccp_info){
1002                         opj_free((*cstr_info)->m_default_tile_info.tccp_info);
1003                 }
1004
1005                 if ((*cstr_info)->tile_info){
1006                         /* FIXME not used for the moment*/
1007                 }
1008
1009                 opj_free((*cstr_info));
1010                 (*cstr_info) = NULL;
1011         }
1012 }
1013
1014 opj_codestream_index_t * OPJ_CALLCONV opj_get_cstr_index(opj_codec_t *p_codec)
1015 {
1016         if (p_codec) {
1017                 opj_codec_private_t* l_codec = (opj_codec_private_t*) p_codec;
1018
1019                 return l_codec->opj_get_codec_index(l_codec->m_codec);
1020         }
1021
1022         return NULL;
1023 }
1024
1025 void OPJ_CALLCONV opj_destroy_cstr_index(opj_codestream_index_t **p_cstr_index)
1026 {
1027         if (*p_cstr_index){
1028                 j2k_destroy_cstr_index(*p_cstr_index);
1029                 (*p_cstr_index) = NULL;
1030         }
1031 }
1032
1033 /* ---------------------------------------------------------------------- */
1034 opj_stream_t* OPJ_CALLCONV opj_stream_create_default_file_stream (FILE * p_file, opj_bool p_is_read_stream)
1035 {
1036         return opj_stream_create_file_stream(p_file,OPJ_J2K_STREAM_CHUNK_SIZE,p_is_read_stream);
1037 }
1038
1039 opj_stream_t* OPJ_CALLCONV opj_stream_create_file_stream (      FILE * p_file,
1040                                                                                                                         OPJ_SIZE_T p_size,
1041                                                                                                                         opj_bool p_is_read_stream)
1042 {
1043         opj_stream_t* l_stream = 00;
1044
1045         if (! p_file) {
1046                 return NULL;
1047         }
1048
1049         l_stream = opj_stream_create(p_size,p_is_read_stream);
1050         if (! l_stream) {
1051                 return NULL;
1052         }
1053
1054         opj_stream_set_user_data(l_stream, p_file);
1055         opj_stream_set_user_data_length(l_stream, opj_get_data_length_from_file(p_file));
1056         opj_stream_set_read_function(l_stream, (opj_stream_read_fn) opj_read_from_file);
1057         opj_stream_set_write_function(l_stream, (opj_stream_write_fn) opj_write_from_file);
1058         opj_stream_set_skip_function(l_stream, (opj_stream_skip_fn) opj_skip_from_file);
1059         opj_stream_set_seek_function(l_stream, (opj_stream_seek_fn) opj_seek_from_file);
1060
1061         return l_stream;
1062 }