src/lib/openjp2/openjpeg.c

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