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
 456                 parameters->decod_format = -1;
 457                 parameters->cod_format = -1;
 458                 parameters->flags = 0;
 459 /* UniPG>> */
 460 #ifdef USE_JPWL
 461                 parameters->jpwl_correct = OPJ_FALSE;
 462                 parameters->jpwl_exp_comps = JPWL_EXPECTED_COMPONENTS;
 463                 parameters->jpwl_max_tiles = JPWL_MAXIMUM_TILES;
 464 #endif /* USE_JPWL */
 465 /* <<UniPG */
 466         }
 467 }
 468
 469 opj_bool OPJ_CALLCONV opj_setup_decoder(opj_codec_t *p_codec,
 470                                         opj_dparameters_t *parameters
 471                                                                                 )
 472 {
 473         if (p_codec && parameters) {
 474                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 475
 476                 if (! l_codec->is_decompressor) {
 477                         opj_event_msg(&(l_codec->m_event_mgr), EVT_ERROR,
 478                 "Codec provided to the opj_setup_decoder function is not a decompressor handler.\n");
 479                         return OPJ_FALSE;
 480                 }
 481
 482                 l_codec->m_codec_data.m_decompression.opj_setup_decoder(l_codec->m_codec,
 483                                                                                                                                 parameters);
 484                 return OPJ_TRUE;
 485         }
 486         return OPJ_FALSE;
 487 }
 488
 489 opj_bool OPJ_CALLCONV opj_read_header ( opj_stream_t *p_stream,
 490                                                                                 opj_codec_t *p_codec,
 491                                                                                 opj_image_t **p_image )
 492 {
 493         if (p_codec && p_stream) {
 494                 opj_codec_private_t* l_codec = (opj_codec_private_t*) p_codec;
 495                 opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
 496
 497                 if(! l_codec->is_decompressor) {
 498                         opj_event_msg(&(l_codec->m_event_mgr), EVT_ERROR,
 499                 "Codec provided to the opj_read_header function is not a decompressor handler.\n");
 500                         return OPJ_FALSE;
 501                 }
 502
 503                 return l_codec->m_codec_data.m_decompression.opj_read_header(   l_stream,
 504                                                                                                                                                 l_codec->m_codec,
 505                                                                                                                                                 p_image,
 506                                                                                                                                                 &(l_codec->m_event_mgr) );
 507         }
 508
 509         return OPJ_FALSE;
 510 }
 511
 512 opj_bool OPJ_CALLCONV opj_decode(   opj_codec_t *p_codec,
 513                                     opj_stream_t *p_stream,
 514                                     opj_image_t* p_image)
 515 {
 516         if (p_codec && p_stream) {
 517                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 518                 opj_stream_private_t * l_stream = (opj_stream_private_t *) p_stream;
 519
 520                 if (! l_codec->is_decompressor) {
 521                         return OPJ_FALSE;
 522                 }
 523
 524                 return l_codec->m_codec_data.m_decompression.opj_decode(l_codec->m_codec,
 525                                                                                                                                 l_stream,
 526                                                                                                                                 p_image,
 527                                                                                                                                 &(l_codec->m_event_mgr) );
 528         }
 529
 530         return OPJ_FALSE;
 531 }
 532
 533 opj_bool OPJ_CALLCONV opj_set_decode_area(      opj_codec_t *p_codec,
 534                                                                                         opj_image_t* p_image,
 535                                                                                         OPJ_INT32 p_start_x, OPJ_INT32 p_start_y,
 536                                                                                         OPJ_INT32 p_end_x, OPJ_INT32 p_end_y
 537                                                                                         )
 538 {
 539         if (p_codec) {
 540                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 541
 542                 if (! l_codec->is_decompressor) {
 543                         return OPJ_FALSE;
 544                 }
 545
 546                 return  l_codec->m_codec_data.m_decompression.opj_set_decode_area(      l_codec->m_codec,
 547                                                                                                                                                         p_image,
 548                                                                                                                                                         p_start_x, p_start_y,
 549                                                                                                                                                         p_end_x, p_end_y,
 550                                                                                                                                                         &(l_codec->m_event_mgr) );
 551         }
 552         return OPJ_FALSE;
 553 }
 554
 555 opj_bool OPJ_CALLCONV opj_read_tile_header(     opj_codec_t *p_codec,
 556                                                                                         opj_stream_t * p_stream,
 557                                                                                         OPJ_UINT32 * p_tile_index,
 558                                                                                         OPJ_UINT32 * p_data_size,
 559                                                                                         OPJ_INT32 * p_tile_x0, OPJ_INT32 * p_tile_y0,
 560                                                                                         OPJ_INT32 * p_tile_x1, OPJ_INT32 * p_tile_y1,
 561                                                                                         OPJ_UINT32 * p_nb_comps,
 562                                                                                         opj_bool * p_should_go_on)
 563 {
 564         if (p_codec && p_stream && p_data_size && p_tile_index) {
 565                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 566                 opj_stream_private_t * l_stream = (opj_stream_private_t *) p_stream;
 567
 568                 if (! l_codec->is_decompressor) {
 569                         return OPJ_FALSE;
 570                 }
 571
 572                 return l_codec->m_codec_data.m_decompression.opj_read_tile_header(      l_codec->m_codec,
 573                                                                                                                                                         p_tile_index,
 574                                                                                                                                                         p_data_size,
 575                                                                                                                                                         p_tile_x0, p_tile_y0,
 576                                                                                                                                                         p_tile_x1, p_tile_y1,
 577                                                                                                                                                         p_nb_comps,
 578                                                                                                                                                         p_should_go_on,
 579                                                                                                                                                         l_stream,
 580                                                                                                                                                         &(l_codec->m_event_mgr));
 581         }
 582         return OPJ_FALSE;
 583 }
 584
 585 opj_bool OPJ_CALLCONV opj_decode_tile_data(     opj_codec_t *p_codec,
 586                                                                                         OPJ_UINT32 p_tile_index,
 587                                                                                         OPJ_BYTE * p_data,
 588                                                                                         OPJ_UINT32 p_data_size,
 589                                                                                         opj_stream_t *p_stream
 590                                                                                         )
 591 {
 592         if (p_codec && p_data && p_stream) {
 593                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 594                 opj_stream_private_t * l_stream = (opj_stream_private_t *) p_stream;
 595
 596                 if (! l_codec->is_decompressor) {
 597                         return OPJ_FALSE;
 598                 }
 599
 600                 return l_codec->m_codec_data.m_decompression.opj_decode_tile_data(      l_codec->m_codec,
 601                                                                                                                                                         p_tile_index,
 602                                                                                                                                                         p_data,
 603                                                                                                                                                         p_data_size,
 604                                                                                                                                                         l_stream,
 605                                                                                                                                                         &(l_codec->m_event_mgr) );
 606         }
 607         return OPJ_FALSE;
 608 }
 609
 610 opj_bool OPJ_CALLCONV opj_get_decoded_tile(     opj_codec_t *p_codec,
 611                                                                                         opj_stream_t *p_stream,
 612                                                                                         opj_image_t *p_image,
 613                                                                                         OPJ_UINT32 tile_index)
 614 {
 615         if (p_codec && p_stream) {
 616                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 617                 opj_stream_private_t * l_stream = (opj_stream_private_t *) p_stream;
 618
 619                 if (! l_codec->is_decompressor) {
 620                         return OPJ_FALSE;
 621                 }
 622
 623                 return l_codec->m_codec_data.m_decompression.opj_get_decoded_tile(      l_codec->m_codec,
 624                                                                                                                                                         l_stream,
 625                                                                                                                                                         p_image,
 626                                                                                                                                                         &(l_codec->m_event_mgr),
 627                                                                                                                                                         tile_index);
 628         }
 629
 630         return OPJ_FALSE;
 631 }
 632
 633 opj_bool OPJ_CALLCONV opj_set_decoded_resolution_factor(opj_codec_t *p_codec,
 634                                                                                                                 OPJ_UINT32 res_factor )
 635 {
 636         opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 637
 638         if ( !l_codec ){
 639                 fprintf(stderr, "[ERROR] Input parameters of the setup_decoder function are incorrect.\n");
 640                 return OPJ_FALSE;
 641         }
 642
 643         l_codec->m_codec_data.m_decompression.opj_set_decoded_resolution_factor(l_codec->m_codec,
 644                                                                                                                                                         res_factor,
 645                                                                                                                                                         &(l_codec->m_event_mgr) );
 646         return OPJ_TRUE;
 647 }
 648
 649 /* ---------------------------------------------------------------------- */
 650 /* COMPRESSION FUNCTIONS*/
 651
 652 opj_codec_t* OPJ_CALLCONV opj_create_compress(OPJ_CODEC_FORMAT p_format)
 653 {
 654         opj_codec_private_t *l_codec = 00;
 655
 656         l_codec = (opj_codec_private_t*)opj_calloc(1, sizeof(opj_codec_private_t));
 657         if (!l_codec) {
 658                 return 00;
 659         }
 660         memset(l_codec, 0, sizeof(opj_codec_private_t));
 661
 662         l_codec->is_decompressor = 0;
 663
 664         switch(p_format) {
 665                 case OPJ_CODEC_J2K:
 666                         l_codec->m_codec_data.m_compression.opj_encode = (opj_bool (*) (void *,
 667                                                                                                                                                         struct opj_stream_private *,
 668                                                                                                                                                         struct opj_event_mgr * )) opj_j2k_encode_v2;
 669
 670                         l_codec->m_codec_data.m_compression.opj_end_compress = (opj_bool (*) (  void *,
 671                                                                                                                                                                         struct opj_stream_private *,
 672                                                                                                                                                                         struct opj_event_mgr *)) opj_j2k_end_compress;
 673
 674                         l_codec->m_codec_data.m_compression.opj_start_compress = (opj_bool (*) (void *,
 675                                                                                                                                                                         struct opj_stream_private *,
 676                                                                                                                                                                         struct opj_image * ,
 677                                                                                                                                                                         struct opj_event_mgr *)) opj_j2k_start_compress;
 678
 679                         l_codec->m_codec_data.m_compression.opj_write_tile = (opj_bool (*) (void *,
 680                                                                                                                                                                 OPJ_UINT32,
 681                                                                                                                                                                 OPJ_BYTE*,
 682                                                                                                                                                                 OPJ_UINT32,
 683                                                                                                                                                                 struct opj_stream_private *,
 684                                                                                                                                                                 struct opj_event_mgr *) ) opj_j2k_write_tile;
 685
 686                         l_codec->m_codec_data.m_compression.opj_destroy = (void (*) (void *)) opj_j2k_destroy;
 687
 688                         l_codec->m_codec_data.m_compression.opj_setup_encoder = (void (*) (     void *,
 689                                                                                                                                                                 opj_cparameters_t *,
 690                                                                                                                                                                 struct opj_image *,
 691                                                                                                                                                                 struct opj_event_mgr * )) opj_j2k_setup_encoder;
 692
 693                         l_codec->m_codec = opj_j2k_create_compress();
 694                         if (! l_codec->m_codec) {
 695                                 opj_free(l_codec);
 696                                 return 00;
 697                         }
 698
 699                         break;
 700
 701                 case OPJ_CODEC_JP2:
 702                         /* get a JP2 decoder handle */
 703                         l_codec->m_codec_data.m_compression.opj_encode = (opj_bool (*) (void *,
 704                                                                                                                                                         struct opj_stream_private *,
 705                                                                                                                                                         struct opj_event_mgr * )) opj_jp2_encode;
 706
 707                         l_codec->m_codec_data.m_compression.opj_end_compress = (opj_bool (*) (  void *,
 708                                                                                                                                                                         struct opj_stream_private *,
 709                                                                                                                                                                         struct opj_event_mgr *)) opj_jp2_end_compress;
 710
 711                         l_codec->m_codec_data.m_compression.opj_start_compress = (opj_bool (*) (void *,
 712                                                                                                                                                                         struct opj_stream_private *,
 713                                                                                                                                                                         struct opj_image * ,
 714                                                                                                                                                                         struct opj_event_mgr *))  opj_jp2_start_compress;
 715
 716                         l_codec->m_codec_data.m_compression.opj_write_tile = (opj_bool (*) (void *,
 717                                                                                                                                                                 OPJ_UINT32,
 718                                                                                                                                                                 OPJ_BYTE*,
 719                                                                                                                                                                 OPJ_UINT32,
 720                                                                                                                                                                 struct opj_stream_private *,
 721                                                                                                                                                                 struct opj_event_mgr *)) opj_jp2_write_tile;
 722
 723                         l_codec->m_codec_data.m_compression.opj_destroy = (void (*) (void *)) opj_jp2_destroy;
 724
 725                         l_codec->m_codec_data.m_compression.opj_setup_encoder = (void (*) (     void *,
 726                                                                                                                                                                 opj_cparameters_t *,
 727                                                                                                                                                                 struct opj_image *,
 728                                                                                                                                                                 struct opj_event_mgr * )) opj_jp2_setup_encoder;
 729
 730                         l_codec->m_codec = opj_jp2_create(OPJ_FALSE);
 731                         if (! l_codec->m_codec) {
 732                                 opj_free(l_codec);
 733                                 return 00;
 734                         }
 735
 736                         break;
 737
 738                 case OPJ_CODEC_UNKNOWN:
 739                 case OPJ_CODEC_JPT:
 740                 default:
 741                         opj_free(l_codec);
 742                         return 00;
 743         }
 744
 745         opj_set_default_event_handler(&(l_codec->m_event_mgr));
 746         return (opj_codec_t*) l_codec;
 747 }
 748
 749 void OPJ_CALLCONV opj_set_default_encoder_parameters(opj_cparameters_t *parameters) {
 750         if(parameters) {
 751                 memset(parameters, 0, sizeof(opj_cparameters_t));
 752                 /* default coding parameters */
 753                 parameters->cp_cinema = OPJ_OFF;
 754                 parameters->max_comp_size = 0;
 755                 parameters->numresolution = 6;
 756                 parameters->cp_rsiz = OPJ_STD_RSIZ;
 757                 parameters->cblockw_init = 64;
 758                 parameters->cblockh_init = 64;
 759                 parameters->prog_order = OPJ_LRCP;
 760                 parameters->roi_compno = -1;            /* no ROI */
 761                 parameters->subsampling_dx = 1;
 762                 parameters->subsampling_dy = 1;
 763                 parameters->tp_on = 0;
 764                 parameters->decod_format = -1;
 765                 parameters->cod_format = -1;
 766                 parameters->tcp_rates[0] = 0;
 767                 parameters->tcp_numlayers = 0;
 768                 parameters->cp_disto_alloc = 0;
 769                 parameters->cp_fixed_alloc = 0;
 770                 parameters->cp_fixed_quality = 0;
 771                 parameters->jpip_on = OPJ_FALSE;
 772 /* UniPG>> */
 773 #ifdef USE_JPWL
 774                 parameters->jpwl_epc_on = OPJ_FALSE;
 775                 parameters->jpwl_hprot_MH = -1; /* -1 means unassigned */
 776                 {
 777                         int i;
 778                         for (i = 0; i < JPWL_MAX_NO_TILESPECS; i++) {
 779                                 parameters->jpwl_hprot_TPH_tileno[i] = -1; /* unassigned */
 780                                 parameters->jpwl_hprot_TPH[i] = 0; /* absent */
 781                         }
 782                 };
 783                 {
 784                         int i;
 785                         for (i = 0; i < JPWL_MAX_NO_PACKSPECS; i++) {
 786                                 parameters->jpwl_pprot_tileno[i] = -1; /* unassigned */
 787                                 parameters->jpwl_pprot_packno[i] = -1; /* unassigned */
 788                                 parameters->jpwl_pprot[i] = 0; /* absent */
 789                         }
 790                 };
 791                 parameters->jpwl_sens_size = 0; /* 0 means no ESD */
 792                 parameters->jpwl_sens_addr = 0; /* 0 means auto */
 793                 parameters->jpwl_sens_range = 0; /* 0 means packet */
 794                 parameters->jpwl_sens_MH = -1; /* -1 means unassigned */
 795                 {
 796                         int i;
 797                         for (i = 0; i < JPWL_MAX_NO_TILESPECS; i++) {
 798                                 parameters->jpwl_sens_TPH_tileno[i] = -1; /* unassigned */
 799                                 parameters->jpwl_sens_TPH[i] = -1; /* absent */
 800                         }
 801                 };
 802 #endif /* USE_JPWL */
 803 /* <<UniPG */
 804         }
 805 }
 806
 807 opj_bool OPJ_CALLCONV opj_setup_encoder(opj_codec_t *p_codec,
 808                                                                                 opj_cparameters_t *parameters,
 809                                                                                 opj_image_t *p_image)
 810 {
 811         if (p_codec && parameters && p_image) {
 812                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 813
 814                 if (! l_codec->is_decompressor) {
 815                         l_codec->m_codec_data.m_compression.opj_setup_encoder(  l_codec->m_codec,
 816                                                                                                                                         parameters,
 817                                                                                                                                         p_image,
 818                                                                                                                                         &(l_codec->m_event_mgr) );
 819                         return OPJ_TRUE;
 820                 }
 821         }
 822
 823         return OPJ_FALSE;
 824 }
 825
 826 opj_bool OPJ_CALLCONV opj_start_compress (      opj_codec_t *p_codec,
 827                                                                                         opj_image_t * p_image,
 828                                                                                         opj_stream_t *p_stream)
 829 {
 830         if (p_codec && p_stream) {
 831                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 832                 opj_stream_private_t * l_stream = (opj_stream_private_t *) p_stream;
 833
 834                 if (! l_codec->is_decompressor) {
 835                         return l_codec->m_codec_data.m_compression.opj_start_compress(  l_codec->m_codec,
 836                                                                                                                                                         l_stream,
 837                                                                                                                                                         p_image,
 838                                                                                                                                                         &(l_codec->m_event_mgr));
 839                 }
 840         }
 841
 842         return OPJ_FALSE;
 843 }
 844
 845 opj_bool OPJ_CALLCONV opj_encode(opj_codec_t *p_info, opj_stream_t *p_stream)
 846 {
 847         if (p_info && p_stream) {
 848                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_info;
 849                 opj_stream_private_t * l_stream = (opj_stream_private_t *) p_stream;
 850
 851                 if (! l_codec->is_decompressor) {
 852                         l_codec->m_codec_data.m_compression.opj_encode( l_codec->m_codec,
 853                                                                                                                         l_stream,
 854                                                                                                                         &(l_codec->m_event_mgr));
 855                         return OPJ_TRUE;
 856                 }
 857         }
 858
 859         return OPJ_FALSE;
 860
 861 }
 862
 863 opj_bool OPJ_CALLCONV opj_end_compress (opj_codec_t *p_codec,
 864                                                                                 opj_stream_t *p_stream)
 865 {
 866         if (p_codec && p_stream) {
 867                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 868                 opj_stream_private_t * l_stream = (opj_stream_private_t *) p_stream;
 869
 870                 if (! l_codec->is_decompressor) {
 871                         return l_codec->m_codec_data.m_compression.opj_end_compress(l_codec->m_codec,
 872                                                                                                                                                 l_stream,
 873                                                                                                                                                 &(l_codec->m_event_mgr));
 874                 }
 875         }
 876         return OPJ_FALSE;
 877
 878 }
 879
 880 opj_bool OPJ_CALLCONV opj_end_decompress (      opj_codec_t *p_codec,
 881                                                                                         opj_stream_t *p_stream)
 882 {
 883         if (p_codec && p_stream) {
 884                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 885                 opj_stream_private_t * l_stream = (opj_stream_private_t *) p_stream;
 886
 887                 if (! l_codec->is_decompressor) {
 888                         return OPJ_FALSE;
 889                 }
 890
 891                 return l_codec->m_codec_data.m_decompression.opj_end_decompress(l_codec->m_codec,
 892                                                                                                                                                 l_stream,
 893                                                                                                                                                 &(l_codec->m_event_mgr) );
 894         }
 895
 896         return OPJ_FALSE;
 897 }
 898
 899 opj_bool OPJ_CALLCONV opj_set_MCT(opj_cparameters_t *parameters,
 900                                   OPJ_FLOAT32 * pEncodingMatrix,
 901                                   OPJ_INT32 * p_dc_shift,OPJ_UINT32 pNbComp)
 902 {
 903         OPJ_UINT32 l_matrix_size = pNbComp * pNbComp * sizeof(OPJ_FLOAT32);
 904         OPJ_UINT32 l_dc_shift_size = pNbComp * sizeof(OPJ_INT32);
 905         OPJ_UINT32 l_mct_total_size = l_matrix_size + l_dc_shift_size;
 906
 907         /* add MCT capability */
 908         int rsiz = (int)parameters->cp_rsiz | (int)OPJ_MCT;
 909         parameters->cp_rsiz = (OPJ_RSIZ_CAPABILITIES)rsiz;
 910         parameters->irreversible = 1;
 911
 912         /* use array based MCT */
 913         parameters->tcp_mct = 2;
 914         parameters->mct_data = opj_malloc(l_mct_total_size);
 915         if (! parameters->mct_data) {
 916                 return OPJ_FALSE;
 917         }
 918
 919         memcpy(parameters->mct_data,pEncodingMatrix,l_matrix_size);
 920         memcpy(((OPJ_BYTE *) parameters->mct_data) +  l_matrix_size,p_dc_shift,l_dc_shift_size);
 921
 922         return OPJ_TRUE;
 923 }
 924
 925 opj_bool OPJ_CALLCONV opj_write_tile (  opj_codec_t *p_codec,
 926                                                                                 OPJ_UINT32 p_tile_index,
 927                                                                                 OPJ_BYTE * p_data,
 928                                                                                 OPJ_UINT32 p_data_size,
 929                                                                                 opj_stream_t *p_stream )
 930 {
 931         if (p_codec && p_stream && p_data) {
 932                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 933                 opj_stream_private_t * l_stream = (opj_stream_private_t *) p_stream;
 934
 935                 if (l_codec->is_decompressor) {
 936                         return OPJ_FALSE;
 937                 }
 938
 939                 return l_codec->m_codec_data.m_compression.opj_write_tile(      l_codec->m_codec,
 940                                                                                                                                         p_tile_index,
 941                                                                                                                                         p_data,
 942                                                                                                                                         p_data_size,
 943                                                                                                                                         l_stream,
 944                                                                                                                                         &(l_codec->m_event_mgr) );
 945         }
 946
 947         return OPJ_FALSE;
 948 }
 949
 950 /* ---------------------------------------------------------------------- */
 951
 952 void OPJ_CALLCONV opj_destroy_codec(opj_codec_t *p_codec)
 953 {
 954         if (p_codec) {
 955                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 956
 957                 if (l_codec->is_decompressor) {
 958                         l_codec->m_codec_data.m_decompression.opj_destroy(l_codec->m_codec);
 959                 }
 960                 else {
 961                         l_codec->m_codec_data.m_compression.opj_destroy(l_codec->m_codec);
 962                 }
 963
 964                 l_codec->m_codec = 00;
 965                 opj_free(l_codec);
 966         }
 967 }
 968
 969 /* ---------------------------------------------------------------------- */
 970
 971 void OPJ_CALLCONV opj_dump_codec(       opj_codec_t *p_codec,
 972                                                                         OPJ_INT32 info_flag,
 973                                                                         FILE* output_stream)
 974 {
 975         if (p_codec) {
 976                 opj_codec_private_t* l_codec = (opj_codec_private_t*) p_codec;
 977
 978                 l_codec->opj_dump_codec(l_codec->m_codec, info_flag, output_stream);
 979                 return;
 980         }
 981
 982         fprintf(stderr, "[ERROR] Input parameter of the dump_codec function are incorrect.\n");
 983         return;
 984 }
 985
 986 opj_codestream_info_v2_t* OPJ_CALLCONV opj_get_cstr_info(opj_codec_t *p_codec)
 987 {
 988         if (p_codec) {
 989                 opj_codec_private_t* l_codec = (opj_codec_private_t*) p_codec;
 990
 991                 return l_codec->opj_get_codec_info(l_codec->m_codec);
 992         }
 993
 994         return NULL;
 995 }
 996
 997 void OPJ_CALLCONV opj_destroy_cstr_info(opj_codestream_info_v2_t **cstr_info) {
 998         if (cstr_info) {
 999
1000                 if ((*cstr_info)->m_default_tile_info.tccp_info){
1001                         opj_free((*cstr_info)->m_default_tile_info.tccp_info);
1002                 }
1003
1004                 if ((*cstr_info)->tile_info){
1005                         /* FIXME not used for the moment*/
1006                 }
1007
1008                 opj_free((*cstr_info));
1009                 (*cstr_info) = NULL;
1010         }
1011 }
1012
1013 opj_codestream_index_t * OPJ_CALLCONV opj_get_cstr_index(opj_codec_t *p_codec)
1014 {
1015         if (p_codec) {
1016                 opj_codec_private_t* l_codec = (opj_codec_private_t*) p_codec;
1017
1018                 return l_codec->opj_get_codec_index(l_codec->m_codec);
1019         }
1020
1021         return NULL;
1022 }
1023
1024 void OPJ_CALLCONV opj_destroy_cstr_index(opj_codestream_index_t **p_cstr_index)
1025 {
1026         if (*p_cstr_index){
1027                 j2k_destroy_cstr_index(*p_cstr_index);
1028                 (*p_cstr_index) = NULL;
1029         }
1030 }
1031
1032 /* ---------------------------------------------------------------------- */
1033 opj_stream_t* OPJ_CALLCONV opj_stream_create_default_file_stream (FILE * p_file, opj_bool p_is_read_stream)
1034 {
1035         return opj_stream_create_file_stream(p_file,OPJ_J2K_STREAM_CHUNK_SIZE,p_is_read_stream);
1036 }
1037
1038 opj_stream_t* OPJ_CALLCONV opj_stream_create_file_stream (      FILE * p_file,
1039                                                                                                                         OPJ_SIZE_T p_size,
1040                                                                                                                         opj_bool p_is_read_stream)
1041 {
1042         opj_stream_t* l_stream = 00;
1043
1044         if (! p_file) {
1045                 return NULL;
1046         }
1047
1048         l_stream = opj_stream_create(p_size,p_is_read_stream);
1049         if (! l_stream) {
1050                 return NULL;
1051         }
1052
1053         opj_stream_set_user_data(l_stream, p_file);
1054         opj_stream_set_user_data_length(l_stream, opj_get_data_length_from_file(p_file));
1055         opj_stream_set_read_function(l_stream, (opj_stream_read_fn) opj_read_from_file);
1056         opj_stream_set_write_function(l_stream, (opj_stream_write_fn) opj_write_from_file);
1057         opj_stream_set_skip_function(l_stream, (opj_stream_skip_fn) opj_skip_from_file);
1058         opj_stream_set_seek_function(l_stream, (opj_stream_seek_fn) opj_seek_from_file);
1059
1060         return l_stream;
1061 }