v2/libopenjpeg/openjpeg.c

   1 /*\r
   2  * Copyright (c) 2005, Herv� Drolon, FreeImage Team\r
   3  * Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>\r
   4  * All rights reserved.\r
   5  *\r
   6  * Redistribution and use in source and binary forms, with or without\r
   7  * modification, are permitted provided that the following conditions\r
   8  * are met:\r
   9  * 1. Redistributions of source code must retain the above copyright\r
  10  *    notice, this list of conditions and the following disclaimer.\r
  11  * 2. Redistributions in binary form must reproduce the above copyright\r
  12  *    notice, this list of conditions and the following disclaimer in the\r
  13  *    documentation and/or other materials provided with the distribution.\r
  14  *\r
  15  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'\r
  16  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r
  19  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
  20  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
  21  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
  22  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
  23  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
  24  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
  25  * POSSIBILITY OF SUCH DAMAGE.\r
  26  */\r
  27 \r
  28 #ifdef WIN32\r
  29 #include <windows.h>\r
  30 #endif /* WIN32 */\r
  31 \r
  32 #include "openjpeg.h"\r
  33 #include "opj_malloc.h"\r
  34 #include "j2k.h"\r
  35 #include "jp2.h"\r
  36 #include "event.h"\r
  37 #include "cio.h"\r
  38 \r
  39 typedef struct opj_decompression\r
  40 {\r
  41         bool (* opj_read_header) (\r
  42                 void *p_codec,\r
  43                 opj_image_t **,\r
  44                 OPJ_INT32 * p_tile_x0,\r
  45                 OPJ_INT32 * p_tile_y0,\r
  46                 OPJ_UINT32 * p_tile_width,\r
  47                 OPJ_UINT32 * p_tile_height,\r
  48                 OPJ_UINT32 * p_nb_tiles_x,\r
  49                 OPJ_UINT32 * p_nb_tiles_y,\r
  50                 struct opj_stream_private *cio, \r
  51                 struct opj_event_mgr * p_manager);\r
  52         opj_image_t* (* opj_decode) (void * p_codec, struct opj_stream_private *p_cio, struct opj_event_mgr * p_manager);\r
  53         bool (*opj_read_tile_header)(\r
  54                 void * p_codec,\r
  55                 OPJ_UINT32 * p_tile_index,\r
  56                 OPJ_UINT32* p_data_size,\r
  57                 OPJ_INT32 * p_tile_x0,\r
  58                 OPJ_INT32 * p_tile_y0,\r
  59                 OPJ_INT32 * p_tile_x1,\r
  60                 OPJ_INT32 * p_tile_y1,\r
  61                 OPJ_UINT32 * p_nb_comps,\r
  62                 bool * p_should_go_on,\r
  63                 struct opj_stream_private *p_cio,\r
  64                 struct opj_event_mgr * p_manager);\r
  65                 bool (*opj_decode_tile_data)(void * p_codec,OPJ_UINT32 p_tile_index,OPJ_BYTE * p_data,OPJ_UINT32 p_data_size,struct opj_stream_private *p_cio,struct opj_event_mgr * p_manager);\r
  66         bool (* opj_end_decompress) (void *p_codec,struct opj_stream_private *cio,struct opj_event_mgr * p_manager);\r
  67         void (* opj_destroy) (void * p_codec);\r
  68         void (*opj_setup_decoder) (void * p_codec,opj_dparameters_t * p_param);\r
  69         bool (*opj_set_decode_area) (void * p_codec,OPJ_INT32 p_start_x,OPJ_INT32 p_end_x,OPJ_INT32 p_start_y,OPJ_INT32 p_end_y,struct opj_event_mgr * p_manager);\r
  70 \r
  71 \r
  72 }opj_decompression_t;\r
  73 \r
  74 typedef struct opj_compression\r
  75 {\r
  76         bool (* opj_start_compress) (void *p_codec,struct opj_stream_private *cio,struct opj_image * p_image,   struct opj_event_mgr * p_manager);\r
  77         bool (* opj_encode) (void * p_codec, struct opj_stream_private *p_cio, struct opj_event_mgr * p_manager);\r
  78         bool (* opj_write_tile) (void * p_codec,OPJ_UINT32 p_tile_index,OPJ_BYTE * p_data,OPJ_UINT32 p_data_size,struct opj_stream_private * p_cio,struct opj_event_mgr * p_manager);\r
  79         bool (* opj_end_compress) (void * p_codec, struct opj_stream_private *p_cio, struct opj_event_mgr * p_manager);\r
  80         void (* opj_destroy) (void * p_codec);\r
  81         void (*opj_setup_encoder) (void * p_codec,opj_cparameters_t * p_param,struct opj_image * p_image, struct opj_event_mgr * p_manager);\r
  82         \r
  83 }opj_compression_t;\r
  84 \r
  85 \r
  86 \r
  87 typedef struct opj_codec_private\r
  88 {\r
  89         union\r
  90         {               /* code-blocks informations */\r
  91           opj_decompression_t m_decompression;\r
  92           opj_compression_t m_compression;\r
  93     } m_codec_data;\r
  94         void * m_codec;\r
  95         opj_event_mgr_t m_event_mgr;\r
  96         unsigned is_decompressor : 1;\r
  97 }\r
  98 opj_codec_private_t;\r
  99 \r
 100 \r
 101 \r
 102 /**\r
 103  * Default callback function.\r
 104  * Do nothing.\r
 105  */\r
 106 void opj_default_callback (const char *msg, void *client_data)\r
 107 {\r
 108 }\r
 109 \r
 110 void set_default_event_handler(opj_event_mgr_t * p_manager)\r
 111 {\r
 112         p_manager->m_error_data = 00;\r
 113         p_manager->m_warning_data = 00;\r
 114         p_manager->m_info_data = 00;\r
 115         p_manager->error_handler = opj_default_callback;\r
 116         p_manager->info_handler = opj_default_callback;\r
 117         p_manager->warning_handler = opj_default_callback;\r
 118 }\r
 119 \r
 120 OPJ_UINT32 opj_read_from_file (void * p_buffer, OPJ_UINT32 p_nb_bytes, FILE * p_file)\r
 121 {\r
 122         OPJ_UINT32 l_nb_read = fread(p_buffer,1,p_nb_bytes,p_file);\r
 123         return l_nb_read ? l_nb_read : -1;\r
 124 }\r
 125 \r
 126 OPJ_UINT32 opj_write_from_file (void * p_buffer, OPJ_UINT32 p_nb_bytes, FILE * p_file)\r
 127 {\r
 128         return fwrite(p_buffer,1,p_nb_bytes,p_file);\r
 129 }\r
 130 \r
 131 OPJ_SIZE_T opj_skip_from_file (OPJ_SIZE_T p_nb_bytes, FILE * p_user_data)\r
 132 {\r
 133         if\r
 134                 (fseek(p_user_data,p_nb_bytes,SEEK_CUR))\r
 135         {\r
 136                 return -1;\r
 137         }\r
 138         return p_nb_bytes;\r
 139 }\r
 140 \r
 141 bool opj_seek_from_file (OPJ_SIZE_T p_nb_bytes, FILE * p_user_data)\r
 142 {\r
 143         if\r
 144                 (fseek(p_user_data,p_nb_bytes,SEEK_SET))\r
 145         {\r
 146                 return false;\r
 147         }\r
 148         return true;\r
 149 }\r
 150 \r
 151 /* ---------------------------------------------------------------------- */\r
 152 #ifdef WIN32\r
 153 #ifndef OPJ_STATIC\r
 154 BOOL APIENTRY\r
 155 DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {\r
 156         switch (ul_reason_for_call) {\r
 157                 case DLL_PROCESS_ATTACH :\r
 158                         break;\r
 159                 case DLL_PROCESS_DETACH :\r
 160                         break;\r
 161                 case DLL_THREAD_ATTACH :\r
 162                 case DLL_THREAD_DETACH :\r
 163                         break;\r
 164     }\r
 165 \r
 166     return TRUE;\r
 167 }\r
 168 #endif /* OPJ_STATIC */\r
 169 #endif /* WIN32 */\r
 170 \r
 171 /* ---------------------------------------------------------------------- */\r
 172 \r
 173 \r
 174 const char* OPJ_CALLCONV opj_version(void) {\r
 175     return OPENJPEG_VERSION;\r
 176 }\r
 177 \r
 178 opj_codec_t* OPJ_CALLCONV opj_create_decompress(OPJ_CODEC_FORMAT p_format) \r
 179 {\r
 180         opj_codec_private_t *l_info = 00;\r
 181         \r
 182         l_info = (opj_codec_private_t*) opj_calloc(1, sizeof(opj_codec_private_t));\r
 183         if\r
 184                 (!l_info) \r
 185         {\r
 186                 return 00;\r
 187         }\r
 188         memset(l_info, 0, sizeof(opj_codec_private_t));\r
 189         l_info->is_decompressor = 1;\r
 190         switch\r
 191                 (p_format) \r
 192         {\r
 193                 case CODEC_J2K:\r
 194                         l_info->m_codec_data.m_decompression.opj_decode = (opj_image_t* (*) (void *, struct opj_stream_private *, struct opj_event_mgr * ))j2k_decode;\r
 195                         l_info->m_codec_data.m_decompression.opj_end_decompress =  (bool (*) (void *,struct opj_stream_private *,struct opj_event_mgr *))j2k_end_decompress;\r
 196                         l_info->m_codec_data.m_decompression.opj_read_header =  (bool (*) (\r
 197                                 void *,\r
 198                                 opj_image_t **,\r
 199                                 OPJ_INT32 * ,\r
 200                                 OPJ_INT32 * ,\r
 201                                 OPJ_UINT32 * ,\r
 202                                 OPJ_UINT32 * ,\r
 203                                 OPJ_UINT32 * ,\r
 204                                 OPJ_UINT32 * ,\r
 205                                 struct opj_stream_private *,    \r
 206                                 struct opj_event_mgr * )) j2k_read_header;\r
 207                         l_info->m_codec_data.m_decompression.opj_destroy = (void (*) (void *))j2k_destroy;\r
 208                         l_info->m_codec_data.m_decompression.opj_setup_decoder = (void (*) (void * ,opj_dparameters_t * )) j2k_setup_decoder;\r
 209                         l_info->m_codec_data.m_decompression.opj_read_tile_header = (bool (*) (\r
 210                                 void *,\r
 211                                 OPJ_UINT32*,\r
 212                                 OPJ_UINT32*,\r
 213                                 OPJ_INT32 * ,\r
 214                                 OPJ_INT32 * ,\r
 215                                 OPJ_INT32 * ,\r
 216                                 OPJ_INT32 * ,\r
 217                                 OPJ_UINT32 * ,\r
 218                                 bool *,\r
 219                                 struct opj_stream_private *,    \r
 220                                 struct opj_event_mgr * )) j2k_read_tile_header;\r
 221                                 l_info->m_codec_data.m_decompression.opj_decode_tile_data = (bool (*) (void *,OPJ_UINT32,OPJ_BYTE*,OPJ_UINT32,struct opj_stream_private *,      struct opj_event_mgr * )) j2k_decode_tile;\r
 222                         l_info->m_codec_data.m_decompression.opj_set_decode_area = (bool (*) (void *,OPJ_INT32,OPJ_INT32,OPJ_INT32,OPJ_INT32, struct opj_event_mgr * )) j2k_set_decode_area;\r
 223                         l_info->m_codec = j2k_create_decompress();\r
 224                         if\r
 225                                 (! l_info->m_codec)\r
 226                         {\r
 227                                 opj_free(l_info);\r
 228                                 return 00;\r
 229                         }\r
 230                         break;\r
 231                 \r
 232                 case CODEC_JP2:\r
 233                         /* get a JP2 decoder handle */\r
 234                         l_info->m_codec_data.m_decompression.opj_decode = (opj_image_t* (*) (void *, struct opj_stream_private *, struct opj_event_mgr * ))jp2_decode;\r
 235                         l_info->m_codec_data.m_decompression.opj_end_decompress =  (bool (*) (void *,struct opj_stream_private *,struct opj_event_mgr *)) jp2_end_decompress;\r
 236                         l_info->m_codec_data.m_decompression.opj_read_header =  (bool (*) (\r
 237                                 void *,\r
 238                                 opj_image_t **,\r
 239                         \r
 240                                 OPJ_INT32 * ,\r
 241                                 OPJ_INT32 * ,\r
 242                                 OPJ_UINT32 * ,\r
 243                                 OPJ_UINT32 * ,\r
 244                                 OPJ_UINT32 * ,\r
 245                                 OPJ_UINT32 * ,\r
 246                                 struct opj_stream_private *,    \r
 247                                 struct opj_event_mgr * )) jp2_read_header;\r
 248 \r
 249                         l_info->m_codec_data.m_decompression.opj_read_tile_header = (\r
 250                                 bool (*) (\r
 251                                         void *,\r
 252                                         OPJ_UINT32*,\r
 253                                         OPJ_UINT32*,\r
 254                                         OPJ_INT32*,\r
 255                                         OPJ_INT32*,\r
 256                                         OPJ_INT32 * ,\r
 257                                         OPJ_INT32 * ,\r
 258                                         OPJ_UINT32 * ,\r
 259                                         bool *,\r
 260                                         struct opj_stream_private *,    \r
 261                                         struct opj_event_mgr * )) jp2_read_tile_header;\r
 262 \r
 263                         l_info->m_codec_data.m_decompression.opj_decode_tile_data = (bool (*) (void *,OPJ_UINT32,OPJ_BYTE*,OPJ_UINT32,struct opj_stream_private *,      struct opj_event_mgr * )) jp2_decode_tile;\r
 264 \r
 265                         l_info->m_codec_data.m_decompression.opj_destroy = (void (*) (void *))jp2_destroy;\r
 266                         l_info->m_codec_data.m_decompression.opj_setup_decoder = (void (*) (void * ,opj_dparameters_t * )) jp2_setup_decoder;\r
 267                         l_info->m_codec_data.m_decompression.opj_set_decode_area = (bool (*) (void *,OPJ_INT32,OPJ_INT32,OPJ_INT32,OPJ_INT32, struct opj_event_mgr * )) jp2_set_decode_area;\r
 268 \r
 269                         \r
 270                         l_info->m_codec = jp2_create(true);\r
 271                         if\r
 272                                 (! l_info->m_codec)\r
 273                         {\r
 274                                 opj_free(l_info);\r
 275                                 return 00;\r
 276                         }\r
 277                         break;\r
 278                 case CODEC_UNKNOWN:\r
 279                 case CODEC_JPT:\r
 280                 default:\r
 281                         opj_free(l_info);\r
 282                         return 00;\r
 283         }\r
 284         set_default_event_handler(&(l_info->m_event_mgr));\r
 285         return (opj_codec_t*) l_info;\r
 286 }\r
 287 \r
 288 void OPJ_CALLCONV opj_destroy_codec(opj_codec_t *p_info) \r
 289 {\r
 290         if\r
 291                 (p_info) \r
 292         {\r
 293                 opj_codec_private_t * l_info = (opj_codec_private_t *) p_info;\r
 294                 if\r
 295                         (l_info->is_decompressor)\r
 296                 {\r
 297                         l_info->m_codec_data.m_decompression.opj_destroy(l_info->m_codec);\r
 298                 }\r
 299                 else\r
 300                 {\r
 301                         l_info->m_codec_data.m_compression.opj_destroy(l_info->m_codec);\r
 302                 }\r
 303                 l_info->m_codec = 00;\r
 304                 opj_free(l_info);\r
 305         }\r
 306 }\r
 307 \r
 308 void OPJ_CALLCONV opj_set_default_decoder_parameters(opj_dparameters_t *parameters) {\r
 309         if(parameters) {\r
 310                 memset(parameters, 0, sizeof(opj_dparameters_t));\r
 311                 /* default decoding parameters */\r
 312                 parameters->cp_layer = 0;\r
 313                 parameters->cp_reduce = 0;\r
 314 \r
 315                 parameters->decod_format = -1;\r
 316                 parameters->cod_format = -1;\r
 317 /* UniPG>> */\r
 318 #ifdef USE_JPWL\r
 319                 parameters->jpwl_correct = false;\r
 320                 parameters->jpwl_exp_comps = JPWL_EXPECTED_COMPONENTS;\r
 321                 parameters->jpwl_max_tiles = JPWL_MAXIMUM_TILES;\r
 322 #endif /* USE_JPWL */\r
 323 /* <<UniPG */\r
 324         }\r
 325 }\r
 326 \r
 327 bool OPJ_CALLCONV opj_setup_decoder(opj_codec_t *p_info, opj_dparameters_t *parameters) {\r
 328         if\r
 329                 (p_info && parameters) \r
 330         {\r
 331                 opj_codec_private_t * l_info = (opj_codec_private_t *) p_info;\r
 332                 if\r
 333                         (! l_info->is_decompressor)\r
 334                 {\r
 335                         return false;\r
 336                 }\r
 337                 l_info->m_codec_data.m_decompression.opj_setup_decoder(l_info->m_codec,parameters);\r
 338                 return true;\r
 339         }\r
 340         return false;\r
 341 }\r
 342 \r
 343 opj_image_t* OPJ_CALLCONV opj_decode(opj_codec_t *p_info, opj_stream_t *cio) \r
 344 {\r
 345         if\r
 346                 (p_info && cio) \r
 347         {\r
 348                 opj_codec_private_t * l_info = (opj_codec_private_t *) p_info;\r
 349                 opj_stream_private_t * l_cio = (opj_stream_private_t *) cio;\r
 350                 if\r
 351                         (! l_info->is_decompressor)\r
 352                 {\r
 353                         return 00;\r
 354                 }\r
 355                 return l_info->m_codec_data.m_decompression.opj_decode(l_info->m_codec,l_cio,&(l_info->m_event_mgr));\r
 356         }\r
 357         return 00;\r
 358 }\r
 359 \r
 360 /**\r
 361  * Writes a tile with the given data.\r
 362  * \r
 363  * @param       p_compressor            the jpeg2000 codec.\r
 364  * @param       p_tile_index            the index of the tile to write. At the moment, the tiles must be written from 0 to n-1 in sequence.\r
 365  * @param       p_data                          pointer to the data to write. Data is arranged in sequence, data_comp0, then data_comp1, then ... NO INTERLEAVING should be set.\r
 366  * @param       p_data_size                     this value os used to make sure the data being written is correct. The size must be equal to the sum for each component of tile_width * tile_height * component_size. component_size can be 1,2 or 4 bytes,\r
 367  *                                                              depending on the precision of the given component.\r
 368  * @param       p_stream                        the stream to write data to.\r
 369  */\r
 370 bool opj_write_tile (\r
 371                                          opj_codec_t *p_codec,\r
 372                                          OPJ_UINT32 p_tile_index,\r
 373                                          OPJ_BYTE * p_data,\r
 374                                          OPJ_UINT32 p_data_size,\r
 375                                          opj_stream_t *p_stream\r
 376                                         )\r
 377 {\r
 378         if\r
 379                 (p_codec && p_stream && p_data) \r
 380         {\r
 381                 opj_codec_private_t * l_info = (opj_codec_private_t *) p_codec;\r
 382                 opj_stream_private_t * l_cio = (opj_stream_private_t *) p_stream;\r
 383                 if\r
 384                         (l_info->is_decompressor)\r
 385                 {\r
 386                         return false;\r
 387                 }\r
 388                 return l_info->m_codec_data.m_compression.opj_write_tile(l_info->m_codec,p_tile_index,p_data,p_data_size,l_cio,&(l_info->m_event_mgr));\r
 389         }\r
 390         return false;\r
 391 }\r
 392 \r
 393 /**\r
 394  * Reads a tile header. This function is compulsory and allows one to know the size of the tile thta will be decoded.\r
 395  * The user may need to refer to the image got by opj_read_header to understand the size being taken by the tile.\r
 396  *\r
 397  * @param       p_codec                 the jpeg2000 codec.\r
 398  * @param       p_tile_index    pointer to a value that will hold the index of the tile being decoded, in case of success.\r
 399  * @param       p_data_size             pointer to a value that will hold the maximum size of the decoded data, in case of success. In case\r
 400  *                                                      of truncated codestreams, the actual number of bytes decoded may be lower. The computation of the size is the same\r
 401  *                                                      as depicted in opj_write_tile.\r
 402  * @param       p_tile_x0               pointer to a value that will hold the x0 pos of the tile (in the image).\r
 403  * @param       p_tile_y0               pointer to a value that will hold the y0 pos of the tile (in the image).\r
 404  * @param       p_tile_x1               pointer to a value that will hold the x1 pos of the tile (in the image).\r
 405  * @param       p_tile_y1               pointer to a value that will hold the y1 pos of the tile (in the image).\r
 406  * @param       p_nb_comps              pointer to a value that will hold the number of components in the tile.\r
 407  * @param       p_should_go_on  pointer to a boolean that will hold the fact that the decoding should go on. In case the\r
 408  *                                                      codestream is over at the time of the call, the value will be set to false. The user should then stop\r
 409  *                                                      the decoding.\r
 410  * @param       p_stream                the stream to decode.\r
 411  * @return      true                    if the tile header could be decoded. In case the decoding should end, the returned value is still true.\r
 412  *                                                      returning false may be the result of a shortage of memory or an internal error.\r
 413  */                             \r
 414 bool opj_read_tile_header(\r
 415                                         opj_codec_t *p_codec,\r
 416                                         OPJ_UINT32 * p_tile_index,\r
 417                                         OPJ_UINT32 * p_data_size,\r
 418                                         OPJ_INT32 * p_tile_x0,\r
 419                                         OPJ_INT32 * p_tile_y0,\r
 420                                         OPJ_INT32 * p_tile_x1,\r
 421                                         OPJ_INT32 * p_tile_y1,\r
 422                                         OPJ_UINT32 * p_nb_comps,\r
 423                                         bool * p_should_go_on,\r
 424                                         opj_stream_t * p_stream)\r
 425 {\r
 426         if\r
 427                 (p_codec && p_stream && p_data_size && p_tile_index) \r
 428         {\r
 429                 opj_codec_private_t * l_info = (opj_codec_private_t *) p_codec;\r
 430                 opj_stream_private_t * l_cio = (opj_stream_private_t *) p_stream;\r
 431                 if\r
 432                         (! l_info->is_decompressor)\r
 433                 {\r
 434                         return false;\r
 435                 }\r
 436                 return l_info->m_codec_data.m_decompression.opj_read_tile_header(\r
 437                         l_info->m_codec,\r
 438                         p_tile_index,\r
 439                         p_data_size,\r
 440                         p_tile_x0,\r
 441                         p_tile_y0,\r
 442                         p_tile_x1,\r
 443                         p_tile_y1,\r
 444                         p_nb_comps,\r
 445                         p_should_go_on,\r
 446                         l_cio,&(l_info->m_event_mgr));\r
 447         }\r
 448         return false;\r
 449 }\r
 450 \r
 451 /**\r
 452  * Reads a tile data. This function is compulsory and allows one to decode tile data. opj_read_tile_header should be called before.\r
 453  * The user may need to refer to the image got by opj_read_header to understand the size being taken by the tile.\r
 454  *\r
 455  * @param       p_codec                 the jpeg2000 codec.\r
 456  * @param       p_tile_index    the index of the tile being decoded, this should be the value set by opj_read_tile_header.\r
 457  * @param       p_data                  pointer to a memory block that will hold the decoded data.\r
 458  * @param       p_data_size             size of p_data. p_data_size should be bigger or equal to the value set by opj_read_tile_header.\r
 459  * @param       p_stream                the stream to decode.\r
 460  *\r
 461  * @return      true                    if the data could be decoded.\r
 462  */                             \r
 463 bool opj_decode_tile_data(\r
 464                                         opj_codec_t *p_codec,\r
 465                                         OPJ_UINT32 p_tile_index,\r
 466                                         OPJ_BYTE * p_data,\r
 467                                         OPJ_UINT32 p_data_size,\r
 468                                         opj_stream_t *p_stream\r
 469                                         )\r
 470 {\r
 471         if\r
 472                 (p_codec && p_data && p_stream) \r
 473         {\r
 474                 opj_codec_private_t * l_info = (opj_codec_private_t *) p_codec;\r
 475                 opj_stream_private_t * l_cio = (opj_stream_private_t *) p_stream;\r
 476                 if\r
 477                         (! l_info->is_decompressor)\r
 478                 {\r
 479                         return false;\r
 480                 }\r
 481                 return l_info->m_codec_data.m_decompression.opj_decode_tile_data(l_info->m_codec,p_tile_index,p_data,p_data_size,l_cio,&(l_info->m_event_mgr));\r
 482         }\r
 483         return false;\r
 484 }\r
 485 \r
 486 bool OPJ_CALLCONV opj_read_header (\r
 487                                                                    opj_codec_t *p_codec,\r
 488                                                                    opj_image_t ** p_image,\r
 489                                                                    OPJ_INT32 * p_tile_x0,\r
 490                                                                    OPJ_INT32 * p_tile_y0,\r
 491                                                                    OPJ_UINT32 * p_tile_width,\r
 492                                                                    OPJ_UINT32 * p_tile_height,\r
 493                                                                    OPJ_UINT32 * p_nb_tiles_x,\r
 494                                                                    OPJ_UINT32 * p_nb_tiles_y,\r
 495                                                                    opj_stream_t *p_cio)\r
 496 {\r
 497         if\r
 498                 (p_codec && p_cio) \r
 499         {\r
 500                 opj_codec_private_t * l_info = (opj_codec_private_t *) p_codec;\r
 501                 opj_stream_private_t * l_cio = (opj_stream_private_t *) p_cio;\r
 502                 if\r
 503                         (! l_info->is_decompressor)\r
 504                 {\r
 505                         return false;\r
 506                 }\r
 507                 return l_info->m_codec_data.m_decompression.opj_read_header(\r
 508                         l_info->m_codec,\r
 509                         p_image,\r
 510                         p_tile_x0,\r
 511                         p_tile_y0,\r
 512                         p_tile_width,\r
 513                         p_tile_height,\r
 514                         p_nb_tiles_x,\r
 515                         p_nb_tiles_y,\r
 516                         l_cio,\r
 517                         &(l_info->m_event_mgr));\r
 518         }\r
 519         return false;\r
 520 }\r
 521 \r
 522 /**\r
 523  * Sets the given area to be decoded. This function should be called right after opj_read_header and before any tile header reading.\r
 524  * \r
 525  * @param       p_codec                 the jpeg2000 codec.\r
 526  * @param       p_start_x               the left position of the rectangle to decode (in image coordinates).\r
 527  * @param       p_end_x                 the right position of the rectangle to decode (in image coordinates).\r
 528  * @param       p_start_y               the up position of the rectangle to decode (in image coordinates).\r
 529  * @param       p_end_y                 the bottom position of the rectangle to decode (in image coordinates).\r
 530  *\r
 531  * @return      true                    if the area could be set.\r
 532  */                             \r
 533 bool opj_set_decode_area(\r
 534                                         opj_codec_t *p_codec,\r
 535                                         OPJ_INT32 p_start_x,\r
 536                                         OPJ_INT32 p_start_y,\r
 537                                         OPJ_INT32 p_end_x,\r
 538                                         OPJ_INT32 p_end_y\r
 539                                         )\r
 540 {\r
 541         if\r
 542                 (p_codec) \r
 543         {\r
 544                 opj_codec_private_t * l_info = (opj_codec_private_t *) p_codec;\r
 545                 if\r
 546                         (! l_info->is_decompressor)\r
 547                 {\r
 548                         return false;\r
 549                 }\r
 550                 return  l_info->m_codec_data.m_decompression.opj_set_decode_area(\r
 551                                 l_info->m_codec,\r
 552                                 p_start_x,\r
 553                                 p_start_y,\r
 554                                 p_end_x,\r
 555                                 p_end_y,\r
 556                                 &(l_info->m_event_mgr));\r
 557 \r
 558         }\r
 559         return false;\r
 560 \r
 561 }\r
 562 \r
 563 bool OPJ_CALLCONV opj_end_decompress (opj_codec_t *p_codec,opj_stream_t *p_cio)\r
 564 {\r
 565         if\r
 566                 (p_codec && p_cio) \r
 567         {\r
 568                 opj_codec_private_t * l_info = (opj_codec_private_t *) p_codec;\r
 569                 opj_stream_private_t * l_cio = (opj_stream_private_t *) p_cio;\r
 570                 if\r
 571                         (! l_info->is_decompressor)\r
 572                 {\r
 573                         return false;\r
 574                 }\r
 575                 return l_info->m_codec_data.m_decompression.opj_end_decompress(l_info->m_codec,l_cio,&(l_info->m_event_mgr));\r
 576         }\r
 577         return false;\r
 578 }\r
 579 \r
 580 \r
 581 opj_codec_t* OPJ_CALLCONV opj_create_compress(OPJ_CODEC_FORMAT p_format) \r
 582 {\r
 583         opj_codec_private_t *l_info = 00;\r
 584         \r
 585         l_info = (opj_codec_private_t*)opj_calloc(1, sizeof(opj_codec_private_t));\r
 586         if\r
 587                 (!l_info) \r
 588         {\r
 589                 return 00;\r
 590         }\r
 591         memset(l_info, 0, sizeof(opj_codec_private_t));\r
 592         l_info->is_decompressor = 0;\r
 593         switch\r
 594                 (p_format) \r
 595         {\r
 596                 case CODEC_J2K:\r
 597                         l_info->m_codec_data.m_compression.opj_encode = (bool (*) (void *, struct opj_stream_private *, struct opj_event_mgr * )) j2k_encode;\r
 598                         l_info->m_codec_data.m_compression.opj_end_compress = (bool (*) (void *, struct opj_stream_private *, struct opj_event_mgr *)) j2k_end_compress;\r
 599                         l_info->m_codec_data.m_compression.opj_start_compress = (bool (*) (void *,struct opj_stream_private *,struct opj_image * ,      struct opj_event_mgr *)) j2k_start_compress;\r
 600                         l_info->m_codec_data.m_compression.opj_write_tile = (bool (*) (void *,OPJ_UINT32,OPJ_BYTE*,OPJ_UINT32,struct opj_stream_private *,      struct opj_event_mgr *)) j2k_write_tile;\r
 601                         l_info->m_codec_data.m_compression.opj_destroy = (void (*) (void *)) j2k_destroy;\r
 602                         l_info->m_codec_data.m_compression.opj_setup_encoder = (void (*) (void *,opj_cparameters_t *,struct opj_image *, struct opj_event_mgr * )) j2k_setup_encoder;\r
 603 \r
 604                         l_info->m_codec = j2k_create_compress();\r
 605                         if\r
 606                                 (! l_info->m_codec)\r
 607                         {\r
 608                                 opj_free(l_info);\r
 609                                 return 00;\r
 610                         }\r
 611                         break;\r
 612                 \r
 613                 case CODEC_JP2:\r
 614                         /* get a JP2 decoder handle */\r
 615                         l_info->m_codec_data.m_compression.opj_encode = (bool (*) (void *, struct opj_stream_private *, struct opj_event_mgr * )) jp2_encode;\r
 616                         l_info->m_codec_data.m_compression.opj_end_compress = (bool (*) (void *, struct opj_stream_private *, struct opj_event_mgr *)) jp2_end_compress;\r
 617                         l_info->m_codec_data.m_compression.opj_start_compress = (bool (*) (void *,struct opj_stream_private *,struct opj_image * ,      struct opj_event_mgr *))  jp2_start_compress;\r
 618                         l_info->m_codec_data.m_compression.opj_write_tile = (bool (*) (void *,OPJ_UINT32,OPJ_BYTE*,OPJ_UINT32,struct opj_stream_private *,      struct opj_event_mgr *)) jp2_write_tile;\r
 619                         l_info->m_codec_data.m_compression.opj_destroy = (void (*) (void *)) jp2_destroy;\r
 620                         l_info->m_codec_data.m_compression.opj_setup_encoder = (void (*) (void *,opj_cparameters_t *,struct opj_image *, struct opj_event_mgr * )) jp2_setup_encoder;\r
 621                         \r
 622                         l_info->m_codec = jp2_create(false);\r
 623                         if\r
 624                                 (! l_info->m_codec)\r
 625                         {\r
 626                                 opj_free(l_info);\r
 627                                 return 00;\r
 628                         }\r
 629                         break;\r
 630                 case CODEC_UNKNOWN:\r
 631                 case CODEC_JPT:\r
 632                 default:\r
 633                         opj_free(l_info);\r
 634                         return 00;\r
 635         }\r
 636         set_default_event_handler(&(l_info->m_event_mgr));\r
 637         return (opj_codec_t*) l_info;\r
 638 }\r
 639 \r
 640 void OPJ_CALLCONV opj_set_default_encoder_parameters(opj_cparameters_t *parameters) {\r
 641         if(parameters) {\r
 642                 memset(parameters, 0, sizeof(opj_cparameters_t));\r
 643                 /* default coding parameters */\r
 644                 parameters->cp_cinema = OFF; \r
 645                 parameters->max_comp_size = 0;\r
 646                 parameters->numresolution = 6;\r
 647                 parameters->cp_rsiz = STD_RSIZ;\r
 648                 parameters->cblockw_init = 64;\r
 649                 parameters->cblockh_init = 64;\r
 650                 parameters->prog_order = LRCP;\r
 651                 parameters->roi_compno = -1;            /* no ROI */\r
 652                 parameters->subsampling_dx = 1;\r
 653                 parameters->subsampling_dy = 1;\r
 654                 parameters->tp_on = 0;\r
 655                 parameters->decod_format = -1;\r
 656                 parameters->cod_format = -1;\r
 657 /* UniPG>> */\r
 658 #ifdef USE_JPWL\r
 659                 parameters->jpwl_epc_on = false;\r
 660                 parameters->jpwl_hprot_MH = -1; /* -1 means unassigned */\r
 661                 {\r
 662                         int i;\r
 663                         for (i = 0; i < JPWL_MAX_NO_TILESPECS; i++) {\r
 664                                 parameters->jpwl_hprot_TPH_tileno[i] = -1; /* unassigned */\r
 665                                 parameters->jpwl_hprot_TPH[i] = 0; /* absent */\r
 666                         }\r
 667                 };\r
 668                 {\r
 669                         int i;\r
 670                         for (i = 0; i < JPWL_MAX_NO_PACKSPECS; i++) {\r
 671                                 parameters->jpwl_pprot_tileno[i] = -1; /* unassigned */\r
 672                                 parameters->jpwl_pprot_packno[i] = -1; /* unassigned */\r
 673                                 parameters->jpwl_pprot[i] = 0; /* absent */\r
 674                         }\r
 675                 };\r
 676                 parameters->jpwl_sens_size = 0; /* 0 means no ESD */\r
 677                 parameters->jpwl_sens_addr = 0; /* 0 means auto */\r
 678                 parameters->jpwl_sens_range = 0; /* 0 means packet */\r
 679                 parameters->jpwl_sens_MH = -1; /* -1 means unassigned */\r
 680                 {\r
 681                         int i;\r
 682                         for (i = 0; i < JPWL_MAX_NO_TILESPECS; i++) {\r
 683                                 parameters->jpwl_sens_TPH_tileno[i] = -1; /* unassigned */\r
 684                                 parameters->jpwl_sens_TPH[i] = -1; /* absent */\r
 685                         }\r
 686                 };\r
 687 #endif /* USE_JPWL */\r
 688 /* <<UniPG */\r
 689         }\r
 690 }\r
 691 \r
 692 /**\r
 693  * Helper function.\r
 694  * Sets the stream to be a file stream. The FILE must have been open previously.\r
 695  * @param               p_stream        the stream to modify\r
 696  * @param               p_file          handler to an already open file.\r
 697 */\r
 698 opj_stream_t* OPJ_CALLCONV opj_stream_create_default_file_stream (FILE * p_file,bool p_is_read_stream)\r
 699 {\r
 700         return opj_stream_create_file_stream(p_file,J2K_STREAM_CHUNK_SIZE,p_is_read_stream);\r
 701 }\r
 702 \r
 703 opj_stream_t* OPJ_CALLCONV opj_stream_create_file_stream (FILE * p_file,OPJ_UINT32 p_size,bool p_is_read_stream)\r
 704 {\r
 705         opj_stream_t* l_stream = 00;\r
 706         if\r
 707                 (! p_file)\r
 708         {\r
 709                 return 00;\r
 710         }\r
 711         l_stream = opj_stream_create(p_size,p_is_read_stream);\r
 712         if\r
 713                 (! l_stream)\r
 714         {\r
 715                 return 00;\r
 716         }\r
 717         opj_stream_set_user_data(l_stream,p_file);\r
 718         opj_stream_set_read_function(l_stream,(opj_stream_read_fn) opj_read_from_file);\r
 719         opj_stream_set_write_function(l_stream, (opj_stream_write_fn) opj_write_from_file);\r
 720         opj_stream_set_skip_function(l_stream, (opj_stream_skip_fn) opj_skip_from_file);\r
 721         opj_stream_set_seek_function(l_stream, (opj_stream_seek_fn) opj_seek_from_file);\r
 722         return l_stream;\r
 723 }\r
 724 \r
 725 \r
 726 bool OPJ_CALLCONV opj_setup_encoder(opj_codec_t *p_info, opj_cparameters_t *parameters, opj_image_t *image) \r
 727 {\r
 728         if\r
 729                 (p_info && parameters && image) \r
 730         {\r
 731                 opj_codec_private_t * l_codec = ((opj_codec_private_t *) p_info);\r
 732                 if\r
 733                         (! l_codec->is_decompressor)\r
 734                 {\r
 735                         l_codec->m_codec_data.m_compression.opj_setup_encoder(l_codec->m_codec,parameters,image,&(l_codec->m_event_mgr));\r
 736                         return true;\r
 737                 }\r
 738         }\r
 739         return false;\r
 740 }\r
 741 \r
 742 bool OPJ_CALLCONV opj_encode(opj_codec_t *p_info, opj_stream_t *cio) \r
 743 {\r
 744         if\r
 745                 (p_info && cio) \r
 746         {\r
 747                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_info;\r
 748                 opj_stream_private_t * l_cio = (opj_stream_private_t *) cio;\r
 749                 if\r
 750                         (! l_codec->is_decompressor)\r
 751                 {\r
 752                         l_codec->m_codec_data.m_compression.opj_encode(l_codec->m_codec,l_cio,&(l_codec->m_event_mgr));\r
 753                         return true;\r
 754                 }\r
 755         }\r
 756         return false;\r
 757 \r
 758 }\r
 759 \r
 760 bool OPJ_CALLCONV opj_start_compress (opj_codec_t *p_codec,opj_image_t * p_image,opj_stream_t *p_cio)\r
 761 {\r
 762         if\r
 763                 (p_codec && p_cio) \r
 764         {\r
 765                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;\r
 766                 opj_stream_private_t * l_cio = (opj_stream_private_t *) p_cio;\r
 767                 if\r
 768                         (! l_codec->is_decompressor)\r
 769                 {\r
 770                         return l_codec->m_codec_data.m_compression.opj_start_compress(l_codec->m_codec,l_cio,p_image,&(l_codec->m_event_mgr));\r
 771                 }\r
 772         }\r
 773         return false;\r
 774 }\r
 775 \r
 776 bool OPJ_CALLCONV opj_end_compress (opj_codec_t *p_codec,opj_stream_t *p_cio)\r
 777 {\r
 778         if\r
 779                 (p_codec && p_cio) \r
 780         {\r
 781                 opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;\r
 782                 opj_stream_private_t * l_cio = (opj_stream_private_t *) p_cio;\r
 783                 if\r
 784                         (! l_codec->is_decompressor)\r
 785                 {\r
 786                         return l_codec->m_codec_data.m_compression.opj_end_compress(l_codec->m_codec,l_cio,&(l_codec->m_event_mgr));\r
 787                 }\r
 788         }\r
 789         return false;\r
 790 \r
 791 }\r
 792 \r
 793 bool OPJ_CALLCONV opj_set_info_handler(opj_codec_t * p_codec, opj_msg_callback p_callback,void * p_user_data)\r
 794 {\r
 795         opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;\r
 796         if\r
 797                 (! l_codec)\r
 798         {\r
 799                 return false;\r
 800         }\r
 801         l_codec->m_event_mgr.info_handler = p_callback;\r
 802         l_codec->m_event_mgr.m_info_data = p_user_data;\r
 803         return true;\r
 804 }\r
 805 \r
 806 bool OPJ_CALLCONV opj_set_warning_handler(opj_codec_t * p_codec, opj_msg_callback p_callback,void * p_user_data)\r
 807 {\r
 808         opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;\r
 809         if\r
 810                 (! l_codec)\r
 811         {\r
 812                 return false;\r
 813         }\r
 814         l_codec->m_event_mgr.warning_handler = p_callback;\r
 815         l_codec->m_event_mgr.m_warning_data = p_user_data;\r
 816         return true;\r
 817 }\r
 818 \r
 819 bool OPJ_CALLCONV opj_set_error_handler(opj_codec_t * p_codec, opj_msg_callback p_callback,void * p_user_data)\r
 820 {\r
 821         opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;\r
 822         if\r
 823                 (! l_codec)\r
 824         {\r
 825                 return false;\r
 826         }\r
 827         l_codec->m_event_mgr.error_handler = p_callback;\r
 828         l_codec->m_event_mgr.m_error_data = p_user_data;\r
 829         return true;\r
 830 }\r
 831 \r
 832 /*bool OPJ_CALLCONV opj_encode_with_info(opj_cinfo_t *cinfo, opj_stream_t *cio, opj_image_t *image, opj_codestream_info_t *cstr_info) {\r
 833         if(cinfo && cio && image) {\r
 834                 switch(cinfo->codec_format) {\r
 835                         case CODEC_J2K:\r
 836                                 return j2k_encode((opj_j2k_t*)cinfo->j2k_handle, (opj_stream_private_t *) cio, image, cstr_info);\r
 837                         case CODEC_JP2:\r
 838                                 return jp2_encode((opj_jp2_t*)cinfo->jp2_handle, (opj_stream_private_t *) cio, image, cstr_info);\r
 839                         case CODEC_JPT:\r
 840                         case CODEC_UNKNOWN:\r
 841                         default:\r
 842                                 break;\r
 843                 }\r
 844         }\r
 845         return false;\r
 846 }*/\r
 847 \r
 848 void OPJ_CALLCONV opj_destroy_cstr_info(opj_codestream_info_t *cstr_info) {\r
 849         if \r
 850                 (cstr_info) \r
 851         {\r
 852                 int tileno;\r
 853                 for (tileno = 0; tileno < cstr_info->tw * cstr_info->th; tileno++) {\r
 854                         opj_tile_info_t *tile_info = &cstr_info->tile[tileno];\r
 855                         opj_free(tile_info->thresh);\r
 856                         opj_free(tile_info->packet);\r
 857                         opj_free(tile_info->tp);\r
 858                 }\r
 859                 opj_free(cstr_info->tile);\r
 860                 opj_free(cstr_info->marker);\r
 861         }\r
 862 }\r
 863 \r
 864 bool opj_set_MCT(opj_cparameters_t *parameters,OPJ_FLOAT32 * pEncodingMatrix,OPJ_INT32 * p_dc_shift,OPJ_UINT32 pNbComp)\r
 865 {\r
 866         OPJ_UINT32 l_matrix_size = pNbComp * pNbComp * sizeof(OPJ_FLOAT32);\r
 867         OPJ_UINT32 l_dc_shift_size = pNbComp * sizeof(OPJ_INT32);\r
 868         OPJ_UINT32 l_mct_total_size = l_matrix_size + l_dc_shift_size;\r
 869         // add MCT capability\r
 870         parameters->cp_rsiz |= 0x8100;\r
 871         parameters->irreversible = 1;\r
 872         // use array based MCT\r
 873         parameters->tcp_mct = 2;\r
 874         parameters->mct_data = opj_malloc(l_mct_total_size);\r
 875         if\r
 876                 (! parameters->mct_data)\r
 877         {\r
 878                 return false;\r
 879         }\r
 880         memcpy(parameters->mct_data,pEncodingMatrix,l_matrix_size);\r
 881         memcpy(((OPJ_BYTE *) parameters->mct_data) +  l_matrix_size,p_dc_shift,l_dc_shift_size);\r
 882         return true;\r
 883 }\r
 884 \r
 885 /**\r
 886  * Restricts the decoding to the given image area.\r
 887  * \r
 888  * @param       parameters              the parameters to update.\r
 889  * @param       p_start_x               the starting x position of the area to decode.\r
 890  * @param       p_start_y               the starting y position of the area to decode.\r
 891  * @param       p_end_x                 the x end position of the area to decode. \r
 892  * @param       p_end_x                 the y end position of the area to decode.\r
 893  */\r
 894 OPJ_API bool OPJ_CALLCONV opj_restrict_decoding (opj_dparameters_t *parameters,OPJ_INT32 p_start_x,OPJ_INT32 p_start_y,OPJ_INT32 p_end_x,OPJ_INT32 p_end_y)\r
 895 {\r
 896         parameters->m_use_restrict_decode = 1;\r
 897         parameters->m_decode_start_x = p_start_x;\r
 898         parameters->m_decode_start_y = p_start_y;\r
 899         parameters->m_decode_end_x = p_end_x;\r
 900         parameters->m_decode_end_y = p_end_y;\r
 901         return true;\r
 902 }\r