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_includes.h"
  34
  35 /**
  36  * Decompression handler.
  37  */
  38 typedef struct opj_decompression
  39 {
  40         /** Main header reading function handler*/
  41         OPJ_BOOL (*opj_read_header) (   struct opj_stream_private * cio,
  42                                                                         void * p_codec,
  43                                                                         opj_image_t **p_image,
  44                                                                         struct opj_event_mgr * p_manager);
  45         /** Decoding function */
  46         OPJ_BOOL (*opj_decode) (        void * p_codec,
  47                                                                 struct opj_stream_private *p_cio,
  48                                                                 opj_image_t *p_image,
  49                                                                 struct opj_event_mgr * p_manager);
  50         /** FIXME DOC */
  51         OPJ_BOOL (*opj_read_tile_header)(       void * p_codec,
  52                                                                                 OPJ_UINT32 * p_tile_index,
  53                                                                                 OPJ_UINT32* p_data_size,
  54                                                                                 OPJ_INT32 * p_tile_x0, OPJ_INT32 * p_tile_y0,
  55                                                                                 OPJ_INT32 * p_tile_x1, OPJ_INT32 * p_tile_y1,
  56                                                                                 OPJ_UINT32 * p_nb_comps,
  57                                                                                 OPJ_BOOL * p_should_go_on,
  58                                                                                 struct opj_stream_private *p_cio,
  59                                                                                 struct opj_event_mgr * p_manager);
  60         /** FIXME DOC */
  61         OPJ_BOOL (*opj_decode_tile_data)(       void * p_codec,
  62                                                                                 OPJ_UINT32 p_tile_index,
  63                                                                                 OPJ_BYTE * p_data,
  64                                                                                 OPJ_UINT32 p_data_size,
  65                                                                                 struct opj_stream_private *p_cio,
  66                                                                                 struct opj_event_mgr * p_manager);
  67         /** Reading function used after codestream if necessary */
  68         OPJ_BOOL (* opj_end_decompress) (       void *p_codec,
  69                                                                                 struct opj_stream_private *cio,
  70                                                                                 struct opj_event_mgr * p_manager);
  71         /** Codec destroy function handler*/
  72         void (*opj_destroy) (void * p_codec);
  73         /** Setup decoder function handler */
  74         void (*opj_setup_decoder) (void * p_codec, opj_dparameters_t * p_param);
  75         /** Set decode area function handler */
  76         OPJ_BOOL (*opj_set_decode_area) (       void * p_codec,
  77                                                                                 opj_image_t* p_image,
  78                                                                                 OPJ_INT32 p_start_x, OPJ_INT32 p_end_x,
  79                                                                                 OPJ_INT32 p_start_y, OPJ_INT32 p_end_y,
  80                                                                                 struct opj_event_mgr * p_manager);
  81
  82         /** Get tile function */
  83         OPJ_BOOL (*opj_get_decoded_tile) (      void *p_codec,
  84                                                                                 opj_stream_private_t *p_cio,
  85                                                                                 opj_image_t *p_image,
  86                                                                                 struct opj_event_mgr * p_manager,
  87                                                                                 OPJ_UINT32 tile_index);
  88
  89         /** Set the decoded resolution factor */
  90         OPJ_BOOL (*opj_set_decoded_resolution_factor) ( void * p_codec,
  91                                                     OPJ_UINT32 res_factor,
  92                                                     opj_event_mgr_t * p_manager);
  93
  94 }opj_decompression_t;
  95
  96 /**
  97  * Compression handler. FIXME DOC
  98  */
  99 typedef struct opj_compression
 100 {
 101         OPJ_BOOL (* opj_start_compress) (       void *p_codec,
 102                                                                                 struct opj_stream_private *cio,
 103                                                                                 struct opj_image * p_image,
 104                                                                                 struct opj_event_mgr * p_manager);
 105
 106         OPJ_BOOL (* opj_encode) (       void * p_codec,
 107                                                                 struct opj_stream_private *p_cio,
 108                                                                 struct opj_event_mgr * p_manager);
 109
 110         OPJ_BOOL (* opj_write_tile) (   void * p_codec,
 111                                                                         OPJ_UINT32 p_tile_index,
 112                                                                         OPJ_BYTE * p_data,
 113                                                                         OPJ_UINT32 p_data_size,
 114                                                                         struct opj_stream_private * p_cio,
 115                                                                         struct opj_event_mgr * p_manager);
 116
 117         OPJ_BOOL (* opj_end_compress) ( void * p_codec,
 118                                                                         struct opj_stream_private *p_cio,
 119                                                                         struct opj_event_mgr * p_manager);
 120
 121         void (* opj_destroy) (void * p_codec);
 122
 123         void (* opj_setup_encoder) (    void * p_codec,
 124                                                                 opj_cparameters_t * p_param,
 125                                                                 struct opj_image * p_image,
 126                                                                 struct opj_event_mgr * p_manager);
 127
 128 }opj_compression_t;
 129
 130 /**
 131  * Main codec handler used for compression or decompression.
 132  */
 133 typedef struct opj_codec_private
 134 {
 135         /** FIXME DOC */
 136         union
 137     {
 138         opj_decompression_t m_decompression;
 139         opj_compression_t m_compression;
 140     } m_codec_data;
 141     /** FIXME DOC*/
 142         void * m_codec;
 143         /** Event handler */
 144         opj_event_mgr_t m_event_mgr;
 145         /** Flag to indicate if the codec is used to decode or encode*/
 146         OPJ_BOOL is_decompressor;
 147         void (*opj_dump_codec) (void * p_codec, OPJ_INT32 info_flag, FILE* output_stream);
 148         opj_codestream_info_v2_t* (*opj_get_codec_info)(void* p_codec);
 149         opj_codestream_index_t* (*opj_get_codec_index)(void* p_codec);
 150 }
 151 opj_codec_private_t;
 152
 153 /* ---------------------------------------------------------------------- */
 154 /* Functions to set the message handlers */
 155
 156 OPJ_BOOL OPJ_CALLCONV opj_set_info_handler(     opj_codec_t * p_codec,
 157                                                                                         opj_msg_callback p_callback,
 158                                                                                         void * p_user_data)
 159 {
 160         opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 161         if(! l_codec){
 162                 return OPJ_FALSE;
 163         }
 164
 165         l_codec->m_event_mgr.info_handler = p_callback;
 166         l_codec->m_event_mgr.m_info_data = p_user_data;
 167
 168         return OPJ_TRUE;
 169 }
 170
 171 OPJ_BOOL OPJ_CALLCONV opj_set_warning_handler(  opj_codec_t * p_codec,
 172                                                                                                 opj_msg_callback p_callback,
 173                                                                                                 void * p_user_data)
 174 {
 175         opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 176         if (! l_codec) {
 177                 return OPJ_FALSE;
 178         }
 179
 180         l_codec->m_event_mgr.warning_handler = p_callback;
 181         l_codec->m_event_mgr.m_warning_data = p_user_data;
 182
 183         return OPJ_TRUE;
 184 }
 185
 186 OPJ_BOOL OPJ_CALLCONV opj_set_error_handler(opj_codec_t * p_codec,
 187                                                                                         opj_msg_callback p_callback,
 188                                                                                         void * p_user_data)
 189 {
 190         opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 191         if (! l_codec) {
 192                 return OPJ_FALSE;
 193         }
 194
 195         l_codec->m_event_mgr.error_handler = p_callback;
 196         l_codec->m_event_mgr.m_error_data = p_user_data;
 197
 198         return OPJ_TRUE;
 199 }
 200
 201 /* ---------------------------------------------------------------------- */
 202
 203 static OPJ_SIZE_T opj_read_from_file (void * p_buffer, OPJ_SIZE_T p_nb_bytes, FILE * p_file)
 204 {
 205         OPJ_SIZE_T l_nb_read = fread(p_buffer,1,p_nb_bytes,p_file);
 206         return l_nb_read ? l_nb_read : (OPJ_SIZE_T)-1;
 207 }
 208
 209 static OPJ_UINT64 opj_get_data_length_from_file (FILE * p_file)
 210 {
 211         OPJ_OFF_T file_length = 0;
 212
 213         OPJ_FSEEK(p_file, 0, SEEK_END);
 214         file_length = (OPJ_UINT64)OPJ_FTELL(p_file);
 215         OPJ_FSEEK(p_file, 0, SEEK_SET);
 216
 217         return file_length;
 218 }
 219
 220 static OPJ_SIZE_T opj_write_from_file (void * p_buffer, OPJ_SIZE_T p_nb_bytes, FILE * p_file)
 221 {
 222         return fwrite(p_buffer,1,p_nb_bytes,p_file);
 223 }
 224
 225 static OPJ_OFF_T opj_skip_from_file (OPJ_OFF_T p_nb_bytes, FILE * p_user_data)
 226 {
 227         if (OPJ_FSEEK(p_user_data,p_nb_bytes,SEEK_CUR)) {
 228                 return -1;
 229         }
 230
 231         return p_nb_bytes;
 232 }
 233
 234 static OPJ_BOOL opj_seek_from_file (OPJ_OFF_T p_nb_bytes, FILE * p_user_data)
 235 {
 236         if (OPJ_FSEEK(p_user_data,p_nb_bytes,SEEK_SET)) {
 237                 return OPJ_FALSE;
 238         }
 239
 240         return OPJ_TRUE;
 241 }
 242
 243 /* ---------------------------------------------------------------------- */
 244 #ifdef _WIN32
 245 #ifndef OPJ_STATIC
 246 BOOL APIENTRY
 247 DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
 248
 249         OPJ_ARG_NOT_USED(lpReserved);
 250         OPJ_ARG_NOT_USED(hModule);
 251
 252         switch (ul_reason_for_call) {
 253                 case DLL_PROCESS_ATTACH :
 254                         break;
 255                 case DLL_PROCESS_DETACH :
 256                         break;
 257                 case DLL_THREAD_ATTACH :
 258                 case DLL_THREAD_DETACH :
 259                         break;
 260     }
 261
 262     return TRUE;
 263 }
 264 #endif /* OPJ_STATIC */
 265 #endif /* _WIN32 */
 266
 267 /* ---------------------------------------------------------------------- */
 268
 269 const char* OPJ_CALLCONV opj_version(void) {
 270     return OPJ_PACKAGE_VERSION;
 271 }
 272
 273 /* ---------------------------------------------------------------------- */
 274 /* DECOMPRESSION FUNCTIONS*/
 275
 276 opj_codec_t* OPJ_CALLCONV opj_create_decompress(OPJ_CODEC_FORMAT p_format)
 277 {
 278         opj_codec_private_t *l_codec = 00;
 279
 280         l_codec = (opj_codec_private_t*) opj_calloc(1, sizeof(opj_codec_private_t));
 281         if (!l_codec){
 282                 return 00;
 283         }
 284         memset(l_codec, 0, sizeof(opj_codec_private_t));
 285
 286         l_codec->is_decompressor = 1;
 287
 288         switch (p_format) {
 289                 case OPJ_CODEC_J2K:
 290                         l_codec->opj_dump_codec = (void (*) (void*, OPJ_INT32, FILE*)) j2k_dump;
 291
 292                         l_codec->opj_get_codec_info = (opj_codestream_info_v2_t* (*) (void*) ) j2k_get_cstr_info;
 293
 294                         l_codec->opj_get_codec_index = (opj_codestream_index_t* (*) (void*) ) j2k_get_cstr_index;
 295
 296                         l_codec->m_codec_data.m_decompression.opj_decode =
 297                                         (OPJ_BOOL (*) ( void *,
 298                                                                         struct opj_stream_private *,
 299                                                                         opj_image_t*, struct opj_event_mgr * )) opj_j2k_decode;
 300
 301                         l_codec->m_codec_data.m_decompression.opj_end_decompress =
 302                                         (OPJ_BOOL (*) ( void *,
 303                                                                         struct opj_stream_private *,
 304                                                                         struct opj_event_mgr *)) opj_j2k_end_decompress;
 305
 306                         l_codec->m_codec_data.m_decompression.opj_read_header =
 307                                         (OPJ_BOOL (*) ( struct opj_stream_private *,
 308                                                                         void *,
 309                                                                         opj_image_t **,
 310                                                                         struct opj_event_mgr * )) opj_j2k_read_header;
 311
 312                         l_codec->m_codec_data.m_decompression.opj_destroy =
 313                                         (void (*) (void *))opj_j2k_destroy;
 314
 315                         l_codec->m_codec_data.m_decompression.opj_setup_decoder =
 316                                         (void (*) (void * , opj_dparameters_t * )) opj_j2k_setup_decoder;
 317
 318                         l_codec->m_codec_data.m_decompression.opj_read_tile_header =
 319                                         (OPJ_BOOL (*) ( void *,
 320                                                                         OPJ_UINT32*,
 321                                                                         OPJ_UINT32*,
 322                                                                         OPJ_INT32*, OPJ_INT32*,
 323                                                                         OPJ_INT32*, OPJ_INT32*,
 324                                                                         OPJ_UINT32*,
 325                                                                         OPJ_BOOL*,
 326                                                                         struct opj_stream_private *,
 327                                                                         struct opj_event_mgr * )) opj_j2k_read_tile_header;
 328
 329                         l_codec->m_codec_data.m_decompression.opj_decode_tile_data =
 330                                         (OPJ_BOOL (*) ( void *,
 331                                     OPJ_UINT32,
 332                                     OPJ_BYTE*,
 333                                     OPJ_UINT32,
 334                                     struct opj_stream_private *,
 335                                     struct opj_event_mgr *)) opj_j2k_decode_tile;
 336
 337                         l_codec->m_codec_data.m_decompression.opj_set_decode_area =
 338                                         (OPJ_BOOL (*) ( void *,
 339                                     opj_image_t*,
 340                                     OPJ_INT32, OPJ_INT32, OPJ_INT32, OPJ_INT32,
 341                                     struct opj_event_mgr *)) opj_j2k_set_decode_area;
 342
 343                         l_codec->m_codec_data.m_decompression.opj_get_decoded_tile =
 344                     (OPJ_BOOL (*) ( void *p_codec,
 345                                                                     opj_stream_private_t *p_cio,
 346                                                                     opj_image_t *p_image,
 347                                                                     struct opj_event_mgr * p_manager,
 348                                                                     OPJ_UINT32 tile_index)) opj_j2k_get_tile;
 349
 350                         l_codec->m_codec_data.m_decompression.opj_set_decoded_resolution_factor =
 351                     (OPJ_BOOL (*) ( void * p_codec,
 352                                                                         OPJ_UINT32 res_factor,
 353                                                                         struct opj_event_mgr * p_manager)) opj_j2k_set_decoded_resolution_factor;
 354
 355                         l_codec->m_codec = opj_j2k_create_decompress();
 356
 357                         if (! l_codec->m_codec) {
 358                                 opj_free(l_codec);
 359                                 return NULL;
 360                         }
 361
 362                         break;
 363
 364                 case OPJ_CODEC_JP2:
 365                         /* get a JP2 decoder handle */
 366                         l_codec->opj_dump_codec = (void (*) (void*, OPJ_INT32, FILE*)) jp2_dump;
 367
 368                         l_codec->opj_get_codec_info = (opj_codestream_info_v2_t* (*) (void*) ) jp2_get_cstr_info;
 369
 370                         l_codec->opj_get_codec_index = (opj_codestream_index_t* (*) (void*) ) jp2_get_cstr_index;
 371
 372                         l_codec->m_codec_data.m_decompression.opj_decode =
 373                                         (OPJ_BOOL (*) ( void *,
 374                                                                         struct opj_stream_private *,
 375                                                                         opj_image_t*,
 376                                                                         struct opj_event_mgr * )) opj_jp2_decode;
 377
 378                         l_codec->m_codec_data.m_decompression.opj_end_decompress =
 379                     (OPJ_BOOL (*) ( void *,
 380                                     struct opj_stream_private *,
 381                                     struct opj_event_mgr *)) opj_jp2_end_decompress;
 382
 383                         l_codec->m_codec_data.m_decompression.opj_read_header =
 384                     (OPJ_BOOL (*) ( struct opj_stream_private *,
 385                                                         void *,
 386                                                         opj_image_t **,
 387                                                         struct opj_event_mgr * )) opj_jp2_read_header;
 388
 389                         l_codec->m_codec_data.m_decompression.opj_read_tile_header =
 390                     (OPJ_BOOL (*) ( void *,
 391                                                         OPJ_UINT32*,
 392                                                         OPJ_UINT32*,
 393                                                         OPJ_INT32*,
 394                                                         OPJ_INT32*,
 395                                                         OPJ_INT32 * ,
 396                                                         OPJ_INT32 * ,
 397                                                         OPJ_UINT32 * ,
 398                                                         OPJ_BOOL *,
 399                                                         struct opj_stream_private *,
 400                                                         struct opj_event_mgr * )) opj_jp2_read_tile_header;
 401
 402                         l_codec->m_codec_data.m_decompression.opj_decode_tile_data =
 403                     (OPJ_BOOL (*) ( void *,
 404                                     OPJ_UINT32,OPJ_BYTE*,OPJ_UINT32,
 405                                     struct opj_stream_private *,
 406                                     struct opj_event_mgr * )) opj_jp2_decode_tile;
 407
 408                         l_codec->m_codec_data.m_decompression.opj_destroy = (void (*) (void *))opj_jp2_destroy;
 409
 410                         l_codec->m_codec_data.m_decompression.opj_setup_decoder =
 411                     (void (*) (void * ,opj_dparameters_t * )) opj_jp2_setup_decoder;
 412
 413                         l_codec->m_codec_data.m_decompression.opj_set_decode_area =
 414                     (OPJ_BOOL (*) ( void *,
 415                                     opj_image_t*,
 416                                     OPJ_INT32,OPJ_INT32,OPJ_INT32,OPJ_INT32,
 417                                     struct opj_event_mgr * )) opj_jp2_set_decode_area;
 418
 419                         l_codec->m_codec_data.m_decompression.opj_get_decoded_tile =
 420                     (OPJ_BOOL (*) ( void *p_codec,
 421                                                                         opj_stream_private_t *p_cio,
 422                                                                         opj_image_t *p_image,
 423                                                                         struct opj_event_mgr * p_manager,
 424                                                                         OPJ_UINT32 tile_index)) opj_jp2_get_tile;
 425
 426                         l_codec->m_codec_data.m_decompression.opj_set_decoded_resolution_factor =
 427                     (OPJ_BOOL (*) ( void * p_codec,
 428                                                                 OPJ_UINT32 res_factor,
 429                                                                 opj_event_mgr_t * p_manager)) opj_jp2_set_decoded_resolution_factor;
 430
 431                         l_codec->m_codec = opj_jp2_create(OPJ_TRUE);
 432
 433                         if (! l_codec->m_codec) {
 434                                 opj_free(l_codec);
 435                                 return 00;
 436                         }
 437
 438                         break;
 439                 case OPJ_CODEC_UNKNOWN:
 440                 case OPJ_CODEC_JPT:
 441                 default:
 442                         opj_free(l_codec);
 443                         return 00;
 444         }
 445
 446         opj_set_default_event_handler(&(l_codec->m_event_mgr));
 447         return (opj_codec_t*) l_codec;
 448 }
 449
 450 void OPJ_CALLCONV opj_set_default_decoder_parameters(opj_dparameters_t *parameters) {
 451         if(parameters) {
 452                 memset(parameters, 0, sizeof(opj_dparameters_t));
 453                 /* default decoding parameters */
 454                 parameters->cp_layer = 0;
 455                 parameters->cp_reduce = 0;
 456
 457                 parameters->decod_format = -1;
 458                 parameters->cod_format = -1;
 459                 parameters->flags = 0;
 460 /* UniPG>> */
 461 #ifdef USE_JPWL
 462                 parameters->jpwl_correct = OPJ_FALSE;
 463                 parameters->jpwl_exp_comps = JPWL_EXPECTED_COMPONENTS;
 464                 parameters->jpwl_max_tiles = JPWL_MAXIMUM_TILES;
 465 #endif /* USE_JPWL */
 466 /* <<UniPG */
 467         }
 468 }
 469
 470 OPJ_BOOL OPJ_CALLCONV opj_setup_decoder(opj_codec_t *p_codec,
 471                                         opj_dparameters_t *parameters
 472                                                                                 )
 473 {
 474         if (p_codec && parameters) {
 475                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 476
 477                 if (! l_codec->is_decompressor) {
 478                         opj_event_msg(&(l_codec->m_event_mgr), EVT_ERROR,
 479                 "Codec provided to the opj_setup_decoder function is not a decompressor handler.\n");
 480                         return OPJ_FALSE;
 481                 }
 482
 483                 l_codec->m_codec_data.m_decompression.opj_setup_decoder(l_codec->m_codec,
 484                                                                                                                                 parameters);
 485                 return OPJ_TRUE;
 486         }
 487         return OPJ_FALSE;
 488 }
 489
 490 OPJ_BOOL OPJ_CALLCONV opj_read_header ( opj_stream_t *p_stream,
 491                                                                                 opj_codec_t *p_codec,
 492                                                                                 opj_image_t **p_image )
 493 {
 494         if (p_codec && p_stream) {
 495                 opj_codec_private_t* l_codec = (opj_codec_private_t*) p_codec;
 496                 opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
 497
 498                 if(! l_codec->is_decompressor) {
 499                         opj_event_msg(&(l_codec->m_event_mgr), EVT_ERROR,
 500                 "Codec provided to the opj_read_header function is not a decompressor handler.\n");
 501                         return OPJ_FALSE;
 502                 }
 503
 504                 return l_codec->m_codec_data.m_decompression.opj_read_header(   l_stream,
 505                                                                                                                                                 l_codec->m_codec,
 506                                                                                                                                                 p_image,
 507                                                                                                                                                 &(l_codec->m_event_mgr) );
 508         }
 509
 510         return OPJ_FALSE;
 511 }
 512
 513 OPJ_BOOL OPJ_CALLCONV opj_decode(   opj_codec_t *p_codec,
 514                                     opj_stream_t *p_stream,
 515                                     opj_image_t* p_image)
 516 {
 517         if (p_codec && p_stream) {
 518                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 519                 opj_stream_private_t * l_stream = (opj_stream_private_t *) p_stream;
 520
 521                 if (! l_codec->is_decompressor) {
 522                         return OPJ_FALSE;
 523                 }
 524
 525                 return l_codec->m_codec_data.m_decompression.opj_decode(l_codec->m_codec,
 526                                                                                                                                 l_stream,
 527                                                                                                                                 p_image,
 528                                                                                                                                 &(l_codec->m_event_mgr) );
 529         }
 530
 531         return OPJ_FALSE;
 532 }
 533
 534 OPJ_BOOL OPJ_CALLCONV opj_set_decode_area(      opj_codec_t *p_codec,
 535                                                                                         opj_image_t* p_image,
 536                                                                                         OPJ_INT32 p_start_x, OPJ_INT32 p_start_y,
 537                                                                                         OPJ_INT32 p_end_x, OPJ_INT32 p_end_y
 538                                                                                         )
 539 {
 540         if (p_codec) {
 541                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 542
 543                 if (! l_codec->is_decompressor) {
 544                         return OPJ_FALSE;
 545                 }
 546
 547                 return  l_codec->m_codec_data.m_decompression.opj_set_decode_area(      l_codec->m_codec,
 548                                                                                                                                                         p_image,
 549                                                                                                                                                         p_start_x, p_start_y,
 550                                                                                                                                                         p_end_x, p_end_y,
 551                                                                                                                                                         &(l_codec->m_event_mgr) );
 552         }
 553         return OPJ_FALSE;
 554 }
 555
 556 OPJ_BOOL OPJ_CALLCONV opj_read_tile_header(     opj_codec_t *p_codec,
 557                                                                                         opj_stream_t * p_stream,
 558                                                                                         OPJ_UINT32 * p_tile_index,
 559                                                                                         OPJ_UINT32 * p_data_size,
 560                                                                                         OPJ_INT32 * p_tile_x0, OPJ_INT32 * p_tile_y0,
 561                                                                                         OPJ_INT32 * p_tile_x1, OPJ_INT32 * p_tile_y1,
 562                                                                                         OPJ_UINT32 * p_nb_comps,
 563                                                                                         OPJ_BOOL * p_should_go_on)
 564 {
 565         if (p_codec && p_stream && p_data_size && p_tile_index) {
 566                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 567                 opj_stream_private_t * l_stream = (opj_stream_private_t *) p_stream;
 568
 569                 if (! l_codec->is_decompressor) {
 570                         return OPJ_FALSE;
 571                 }
 572
 573                 return l_codec->m_codec_data.m_decompression.opj_read_tile_header(      l_codec->m_codec,
 574                                                                                                                                                         p_tile_index,
 575                                                                                                                                                         p_data_size,
 576                                                                                                                                                         p_tile_x0, p_tile_y0,
 577                                                                                                                                                         p_tile_x1, p_tile_y1,
 578                                                                                                                                                         p_nb_comps,
 579                                                                                                                                                         p_should_go_on,
 580                                                                                                                                                         l_stream,
 581                                                                                                                                                         &(l_codec->m_event_mgr));
 582         }
 583         return OPJ_FALSE;
 584 }
 585
 586 OPJ_BOOL OPJ_CALLCONV opj_decode_tile_data(     opj_codec_t *p_codec,
 587                                                                                         OPJ_UINT32 p_tile_index,
 588                                                                                         OPJ_BYTE * p_data,
 589                                                                                         OPJ_UINT32 p_data_size,
 590                                                                                         opj_stream_t *p_stream
 591                                                                                         )
 592 {
 593         if (p_codec && p_data && p_stream) {
 594                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 595                 opj_stream_private_t * l_stream = (opj_stream_private_t *) p_stream;
 596
 597                 if (! l_codec->is_decompressor) {
 598                         return OPJ_FALSE;
 599                 }
 600
 601                 return l_codec->m_codec_data.m_decompression.opj_decode_tile_data(      l_codec->m_codec,
 602                                                                                                                                                         p_tile_index,
 603                                                                                                                                                         p_data,
 604                                                                                                                                                         p_data_size,
 605                                                                                                                                                         l_stream,
 606                                                                                                                                                         &(l_codec->m_event_mgr) );
 607         }
 608         return OPJ_FALSE;
 609 }
 610
 611 OPJ_BOOL OPJ_CALLCONV opj_get_decoded_tile(     opj_codec_t *p_codec,
 612                                                                                         opj_stream_t *p_stream,
 613                                                                                         opj_image_t *p_image,
 614                                                                                         OPJ_UINT32 tile_index)
 615 {
 616         if (p_codec && p_stream) {
 617                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 618                 opj_stream_private_t * l_stream = (opj_stream_private_t *) p_stream;
 619
 620                 if (! l_codec->is_decompressor) {
 621                         return OPJ_FALSE;
 622                 }
 623
 624                 return l_codec->m_codec_data.m_decompression.opj_get_decoded_tile(      l_codec->m_codec,
 625                                                                                                                                                         l_stream,
 626                                                                                                                                                         p_image,
 627                                                                                                                                                         &(l_codec->m_event_mgr),
 628                                                                                                                                                         tile_index);
 629         }
 630
 631         return OPJ_FALSE;
 632 }
 633
 634 OPJ_BOOL OPJ_CALLCONV opj_set_decoded_resolution_factor(opj_codec_t *p_codec,
 635                                                                                                                 OPJ_UINT32 res_factor )
 636 {
 637         opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 638
 639         if ( !l_codec ){
 640                 fprintf(stderr, "[ERROR] Input parameters of the setup_decoder function are incorrect.\n");
 641                 return OPJ_FALSE;
 642         }
 643
 644         l_codec->m_codec_data.m_decompression.opj_set_decoded_resolution_factor(l_codec->m_codec,
 645                                                                                                                                                         res_factor,
 646                                                                                                                                                         &(l_codec->m_event_mgr) );
 647         return OPJ_TRUE;
 648 }
 649
 650 /* ---------------------------------------------------------------------- */
 651 /* COMPRESSION FUNCTIONS*/
 652
 653 opj_codec_t* OPJ_CALLCONV opj_create_compress(OPJ_CODEC_FORMAT p_format)
 654 {
 655         opj_codec_private_t *l_codec = 00;
 656
 657         l_codec = (opj_codec_private_t*)opj_calloc(1, sizeof(opj_codec_private_t));
 658         if (!l_codec) {
 659                 return 00;
 660         }
 661         memset(l_codec, 0, sizeof(opj_codec_private_t));
 662
 663         l_codec->is_decompressor = 0;
 664
 665         switch(p_format) {
 666                 case OPJ_CODEC_J2K:
 667                         l_codec->m_codec_data.m_compression.opj_encode = (OPJ_BOOL (*) (void *,
 668                                                                                                                                                         struct opj_stream_private *,
 669                                                                                                                                                         struct opj_event_mgr * )) opj_j2k_encode;
 670
 671                         l_codec->m_codec_data.m_compression.opj_end_compress = (OPJ_BOOL (*) (  void *,
 672                                                                                                                                                                         struct opj_stream_private *,
 673                                                                                                                                                                         struct opj_event_mgr *)) opj_j2k_end_compress;
 674
 675                         l_codec->m_codec_data.m_compression.opj_start_compress = (OPJ_BOOL (*) (void *,
 676                                                                                                                                                                         struct opj_stream_private *,
 677                                                                                                                                                                         struct opj_image * ,
 678                                                                                                                                                                         struct opj_event_mgr *)) opj_j2k_start_compress;
 679
 680                         l_codec->m_codec_data.m_compression.opj_write_tile = (OPJ_BOOL (*) (void *,
 681                                                                                                                                                                 OPJ_UINT32,
 682                                                                                                                                                                 OPJ_BYTE*,
 683                                                                                                                                                                 OPJ_UINT32,
 684                                                                                                                                                                 struct opj_stream_private *,
 685                                                                                                                                                                 struct opj_event_mgr *) ) opj_j2k_write_tile;
 686
 687                         l_codec->m_codec_data.m_compression.opj_destroy = (void (*) (void *)) opj_j2k_destroy;
 688
 689                         l_codec->m_codec_data.m_compression.opj_setup_encoder = (void (*) (     void *,
 690                                                                                                                                                                 opj_cparameters_t *,
 691                                                                                                                                                                 struct opj_image *,
 692                                                                                                                                                                 struct opj_event_mgr * )) opj_j2k_setup_encoder;
 693
 694                         l_codec->m_codec = opj_j2k_create_compress();
 695                         if (! l_codec->m_codec) {
 696                                 opj_free(l_codec);
 697                                 return 00;
 698                         }
 699
 700                         break;
 701
 702                 case OPJ_CODEC_JP2:
 703                         /* get a JP2 decoder handle */
 704                         l_codec->m_codec_data.m_compression.opj_encode = (OPJ_BOOL (*) (void *,
 705                                                                                                                                                         struct opj_stream_private *,
 706                                                                                                                                                         struct opj_event_mgr * )) opj_jp2_encode;
 707
 708                         l_codec->m_codec_data.m_compression.opj_end_compress = (OPJ_BOOL (*) (  void *,
 709                                                                                                                                                                         struct opj_stream_private *,
 710                                                                                                                                                                         struct opj_event_mgr *)) opj_jp2_end_compress;
 711
 712                         l_codec->m_codec_data.m_compression.opj_start_compress = (OPJ_BOOL (*) (void *,
 713                                                                                                                                                                         struct opj_stream_private *,
 714                                                                                                                                                                         struct opj_image * ,
 715                                                                                                                                                                         struct opj_event_mgr *))  opj_jp2_start_compress;
 716
 717                         l_codec->m_codec_data.m_compression.opj_write_tile = (OPJ_BOOL (*) (void *,
 718                                                                                                                                                                 OPJ_UINT32,
 719                                                                                                                                                                 OPJ_BYTE*,
 720                                                                                                                                                                 OPJ_UINT32,
 721                                                                                                                                                                 struct opj_stream_private *,
 722                                                                                                                                                                 struct opj_event_mgr *)) opj_jp2_write_tile;
 723
 724                         l_codec->m_codec_data.m_compression.opj_destroy = (void (*) (void *)) opj_jp2_destroy;
 725
 726                         l_codec->m_codec_data.m_compression.opj_setup_encoder = (void (*) (     void *,
 727                                                                                                                                                                 opj_cparameters_t *,
 728                                                                                                                                                                 struct opj_image *,
 729                                                                                                                                                                 struct opj_event_mgr * )) opj_jp2_setup_encoder;
 730
 731                         l_codec->m_codec = opj_jp2_create(OPJ_FALSE);
 732                         if (! l_codec->m_codec) {
 733                                 opj_free(l_codec);
 734                                 return 00;
 735                         }
 736
 737                         break;
 738
 739                 case OPJ_CODEC_UNKNOWN:
 740                 case OPJ_CODEC_JPT:
 741                 default:
 742                         opj_free(l_codec);
 743                         return 00;
 744         }
 745
 746         opj_set_default_event_handler(&(l_codec->m_event_mgr));
 747         return (opj_codec_t*) l_codec;
 748 }
 749
 750 void OPJ_CALLCONV opj_set_default_encoder_parameters(opj_cparameters_t *parameters) {
 751         if(parameters) {
 752                 memset(parameters, 0, sizeof(opj_cparameters_t));
 753                 /* default coding parameters */
 754                 parameters->cp_cinema = OPJ_OFF;
 755                 parameters->max_comp_size = 0;
 756                 parameters->numresolution = 6;
 757                 parameters->cp_rsiz = OPJ_STD_RSIZ;
 758                 parameters->cblockw_init = 64;
 759                 parameters->cblockh_init = 64;
 760                 parameters->prog_order = OPJ_LRCP;
 761                 parameters->roi_compno = -1;            /* no ROI */
 762                 parameters->subsampling_dx = 1;
 763                 parameters->subsampling_dy = 1;
 764                 parameters->tp_on = 0;
 765                 parameters->decod_format = -1;
 766                 parameters->cod_format = -1;
 767                 parameters->tcp_rates[0] = 0;
 768                 parameters->tcp_numlayers = 0;
 769                 parameters->cp_disto_alloc = 0;
 770                 parameters->cp_fixed_alloc = 0;
 771                 parameters->cp_fixed_quality = 0;
 772                 parameters->jpip_on = OPJ_FALSE;
 773 /* UniPG>> */
 774 #ifdef USE_JPWL
 775                 parameters->jpwl_epc_on = OPJ_FALSE;
 776                 parameters->jpwl_hprot_MH = -1; /* -1 means unassigned */
 777                 {
 778                         int i;
 779                         for (i = 0; i < JPWL_MAX_NO_TILESPECS; i++) {
 780                                 parameters->jpwl_hprot_TPH_tileno[i] = -1; /* unassigned */
 781                                 parameters->jpwl_hprot_TPH[i] = 0; /* absent */
 782                         }
 783                 };
 784                 {
 785                         int i;
 786                         for (i = 0; i < JPWL_MAX_NO_PACKSPECS; i++) {
 787                                 parameters->jpwl_pprot_tileno[i] = -1; /* unassigned */
 788                                 parameters->jpwl_pprot_packno[i] = -1; /* unassigned */
 789                                 parameters->jpwl_pprot[i] = 0; /* absent */
 790                         }
 791                 };
 792                 parameters->jpwl_sens_size = 0; /* 0 means no ESD */
 793                 parameters->jpwl_sens_addr = 0; /* 0 means auto */
 794                 parameters->jpwl_sens_range = 0; /* 0 means packet */
 795                 parameters->jpwl_sens_MH = -1; /* -1 means unassigned */
 796                 {
 797                         int i;
 798                         for (i = 0; i < JPWL_MAX_NO_TILESPECS; i++) {
 799                                 parameters->jpwl_sens_TPH_tileno[i] = -1; /* unassigned */
 800                                 parameters->jpwl_sens_TPH[i] = -1; /* absent */
 801                         }
 802                 };
 803 #endif /* USE_JPWL */
 804 /* <<UniPG */
 805         }
 806 }
 807
 808 OPJ_BOOL OPJ_CALLCONV opj_setup_encoder(opj_codec_t *p_codec,
 809                                                                                 opj_cparameters_t *parameters,
 810                                                                                 opj_image_t *p_image)
 811 {
 812         if (p_codec && parameters && p_image) {
 813                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 814
 815                 if (! l_codec->is_decompressor) {
 816                         l_codec->m_codec_data.m_compression.opj_setup_encoder(  l_codec->m_codec,
 817                                                                                                                                         parameters,
 818                                                                                                                                         p_image,
 819                                                                                                                                         &(l_codec->m_event_mgr) );
 820                         return OPJ_TRUE;
 821                 }
 822         }
 823
 824         return OPJ_FALSE;
 825 }
 826
 827 OPJ_BOOL OPJ_CALLCONV opj_start_compress (      opj_codec_t *p_codec,
 828                                                                                         opj_image_t * p_image,
 829                                                                                         opj_stream_t *p_stream)
 830 {
 831         if (p_codec && p_stream) {
 832                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
 833                 opj_stream_private_t * l_stream = (opj_stream_private_t *) p_stream;
 834
 835                 if (! l_codec->is_decompressor) {
 836                         return l_codec->m_codec_data.m_compression.opj_start_compress(  l_codec->m_codec,
 837                                                                                                                                                         l_stream,
 838                                                                                                                                                         p_image,
 839                                                                                                                                                         &(l_codec->m_event_mgr));
 840                 }
 841         }
 842
 843         return OPJ_FALSE;
 844 }
 845
 846 OPJ_BOOL OPJ_CALLCONV opj_encode(opj_codec_t *p_info, opj_stream_t *p_stream)
 847 {
 848         if (p_info && p_stream) {
 849                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_info;
 850                 opj_stream_private_t * l_stream = (opj_stream_private_t *) p_stream;
 851
 852                 if (! l_codec->is_decompressor) {
 853                         return l_codec->m_codec_data.m_compression.opj_encode(  l_codec->m_codec,
 854                                                                                                                         l_stream,
 855                                                                                                                         &(l_codec->m_event_mgr));
 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         OPJ_INT32 rsiz = (OPJ_INT32)parameters->cp_rsiz | (OPJ_INT32)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 opj_stream_t* OPJ_CALLCONV opj_stream_create_default_file_stream_v3 (const char *fname, OPJ_BOOL p_is_read_stream)
1033 {
1034     return opj_stream_create_file_stream_v3(fname, OPJ_J2K_STREAM_CHUNK_SIZE, p_is_read_stream);
1035 }
1036
1037 opj_stream_t* OPJ_CALLCONV opj_stream_create_file_stream_v3 (
1038         const char *fname,
1039                 OPJ_SIZE_T p_size,
1040         OPJ_BOOL p_is_read_stream)
1041 {
1042     opj_stream_t* l_stream = 00;
1043     FILE *p_file;
1044     const char *mode;
1045
1046     if (! fname) {
1047         return NULL;
1048     }
1049
1050     if(p_is_read_stream) mode = "rb"; else mode = "wb";
1051
1052     p_file = fopen(fname, mode);
1053
1054     if (! p_file) {
1055             return NULL;
1056     }
1057
1058     l_stream = opj_stream_create(p_size,p_is_read_stream);
1059     if (! l_stream) {
1060         fclose(p_file);
1061         return NULL;
1062     }
1063
1064     opj_stream_set_user_data(l_stream, p_file);
1065     opj_stream_set_user_data_length(l_stream, opj_get_data_length_from_file(p_file));
1066     opj_stream_set_read_function(l_stream, (opj_stream_read_fn) opj_read_from_file);
1067     opj_stream_set_write_function(l_stream, (opj_stream_write_fn) opj_write_from_file);
1068     opj_stream_set_skip_function(l_stream, (opj_stream_skip_fn) opj_skip_from_file);
1069     opj_stream_set_seek_function(l_stream, (opj_stream_seek_fn) opj_seek_from_file);
1070
1071     return l_stream;
1072 }