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