1diff --git a/third_party/libopenjpeg/j2k.c b/third_party/libopenjpeg/j2k.c 2index 9b06e7ec8..e2e048760 100644 3--- a/third_party/libopenjpeg/j2k.c 4+++ b/third_party/libopenjpeg/j2k.c 5@@ -6685,8 +6685,9 @@ static OPJ_BOOL opj_j2k_read_cpf(opj_j2k_t *p_j2k, 6 /* J2K / JPT decoder interface */ 7 /* ----------------------------------------------------------------------- */ 8 9-void opj_j2k_setup_decoder(opj_j2k_t *j2k, opj_dparameters_t *parameters) 10+void opj_j2k_setup_decoder(void *p_j2k, opj_dparameters_t *parameters) 11 { 12+ opj_j2k_t* j2k = (opj_j2k_t*)p_j2k; 13 if (j2k && parameters) { 14 j2k->m_cp.m_specific_param.m_dec.m_layer = parameters->cp_layer; 15 j2k->m_cp.m_specific_param.m_dec.m_reduce = parameters->cp_reduce; 16@@ -6700,15 +6701,17 @@ void opj_j2k_setup_decoder(opj_j2k_t *j2k, opj_dparameters_t *parameters) 17 } 18 } 19 20-void opj_j2k_decoder_set_strict_mode(opj_j2k_t *j2k, OPJ_BOOL strict) 21+void opj_j2k_decoder_set_strict_mode(void *p_j2k, OPJ_BOOL strict) 22 { 23+ opj_j2k_t* j2k = (opj_j2k_t*)p_j2k; 24 if (j2k) { 25 j2k->m_cp.strict = strict; 26 } 27 } 28 29-OPJ_BOOL opj_j2k_set_threads(opj_j2k_t *j2k, OPJ_UINT32 num_threads) 30+OPJ_BOOL opj_j2k_set_threads(void *p_j2k, OPJ_UINT32 num_threads) 31 { 32+ opj_j2k_t* j2k = (opj_j2k_t*)p_j2k; 33 /* Currently we pass the thread-pool to the tcd, so we cannot re-set it */ 34 /* afterwards */ 35 if (opj_has_thread_support() && j2k->m_tcd == NULL) { 36@@ -7613,11 +7616,12 @@ static OPJ_BOOL opj_j2k_is_imf_compliant(opj_cparameters_t *parameters, 37 } 38 39 40-OPJ_BOOL opj_j2k_setup_encoder(opj_j2k_t *p_j2k, 41+OPJ_BOOL opj_j2k_setup_encoder(void *p_j2k, 42 opj_cparameters_t *parameters, 43 opj_image_t *image, 44 opj_event_mgr_t * p_manager) 45 { 46+ opj_j2k_t* j2k = (opj_j2k_t*)p_j2k; 47 OPJ_UINT32 i, j, tileno, numpocs_tile; 48 opj_cp_t *cp = 00; 49 OPJ_UINT32 cblkw, cblkh; 50@@ -7666,10 +7670,10 @@ OPJ_BOOL opj_j2k_setup_encoder(opj_j2k_t *p_j2k, 51 return OPJ_FALSE; 52 } 53 54- p_j2k->m_specific_param.m_encoder.m_nb_comps = image->numcomps; 55+ j2k->m_specific_param.m_encoder.m_nb_comps = image->numcomps; 56 57 /* keep a link to cp so that we can destroy it later in j2k_destroy_compress */ 58- cp = &(p_j2k->m_cp); 59+ cp = &(j2k->m_cp); 60 61 /* set default values for cp */ 62 cp->tw = 1; 63@@ -7834,7 +7838,7 @@ OPJ_BOOL opj_j2k_setup_encoder(opj_j2k_t *p_j2k, 64 } 65 66 if (OPJ_IS_CINEMA(parameters->rsiz) || OPJ_IS_IMF(parameters->rsiz)) { 67- p_j2k->m_specific_param.m_encoder.m_TLM = OPJ_TRUE; 68+ j2k->m_specific_param.m_encoder.m_TLM = OPJ_TRUE; 69 } 70 71 /* Manage profiles and applications and set RSIZ */ 72@@ -8379,7 +8383,7 @@ static OPJ_BOOL opj_j2k_add_tlmarker(OPJ_UINT32 tileno, 73 * ----------------------------------------------------------------------- 74 */ 75 76-OPJ_BOOL opj_j2k_end_decompress(opj_j2k_t *p_j2k, 77+OPJ_BOOL opj_j2k_end_decompress(void *p_j2k, 78 opj_stream_private_t *p_stream, 79 opj_event_mgr_t * p_manager 80 ) 81@@ -8391,10 +8395,11 @@ OPJ_BOOL opj_j2k_end_decompress(opj_j2k_t *p_j2k, 82 } 83 84 OPJ_BOOL opj_j2k_read_header(opj_stream_private_t *p_stream, 85- opj_j2k_t* p_j2k, 86+ void* j2k, 87 opj_image_t** p_image, 88 opj_event_mgr_t* p_manager) 89 { 90+ opj_j2k_t *p_j2k = (opj_j2k_t*)j2k; 91 /* preconditions */ 92 assert(p_j2k != 00); 93 assert(p_stream != 00); 94@@ -9178,8 +9183,9 @@ static const opj_dec_memory_marker_handler_t * opj_j2k_get_marker_handler( 95 return e; 96 } 97 98-void opj_j2k_destroy(opj_j2k_t *p_j2k) 99+void opj_j2k_destroy(void *j2k) 100 { 101+ opj_j2k_t *p_j2k = (opj_j2k_t*)j2k; 102 if (p_j2k == 00) { 103 return; 104 } 105@@ -9518,7 +9524,7 @@ static OPJ_BOOL opj_j2k_need_nb_tile_parts_correction(opj_stream_private_t 106 return OPJ_TRUE; 107 } 108 109-OPJ_BOOL opj_j2k_read_tile_header(opj_j2k_t * p_j2k, 110+OPJ_BOOL opj_j2k_read_tile_header(void * j2k, 111 OPJ_UINT32 * p_tile_index, 112 OPJ_UINT32 * p_data_size, 113 OPJ_INT32 * p_tile_x0, OPJ_INT32 * p_tile_y0, 114@@ -9528,6 +9534,7 @@ OPJ_BOOL opj_j2k_read_tile_header(opj_j2k_t * p_j2k, 115 opj_stream_private_t *p_stream, 116 opj_event_mgr_t * p_manager) 117 { 118+ opj_j2k_t* p_j2k = (opj_j2k_t*)j2k; 119 OPJ_UINT32 l_current_marker = J2K_MS_SOT; 120 OPJ_UINT32 l_marker_size; 121 const opj_dec_memory_marker_handler_t * l_marker_handler = 00; 122@@ -9827,13 +9834,14 @@ OPJ_BOOL opj_j2k_read_tile_header(opj_j2k_t * p_j2k, 123 return OPJ_TRUE; 124 } 125 126-OPJ_BOOL opj_j2k_decode_tile(opj_j2k_t * p_j2k, 127+OPJ_BOOL opj_j2k_decode_tile(void * j2k, 128 OPJ_UINT32 p_tile_index, 129 OPJ_BYTE * p_data, 130 OPJ_UINT32 p_data_size, 131 opj_stream_private_t *p_stream, 132 opj_event_mgr_t * p_manager) 133 { 134+ opj_j2k_t* p_j2k = (opj_j2k_t*)j2k; 135 OPJ_UINT32 l_current_marker; 136 OPJ_BYTE l_data [2]; 137 opj_tcp_t * l_tcp; 138@@ -10200,11 +10208,12 @@ static OPJ_BOOL opj_j2k_update_image_dimensions(opj_image_t* p_image, 139 return OPJ_TRUE; 140 } 141 142-OPJ_BOOL opj_j2k_set_decoded_components(opj_j2k_t *p_j2k, 143+OPJ_BOOL opj_j2k_set_decoded_components(void *j2k, 144 OPJ_UINT32 numcomps, 145 const OPJ_UINT32* comps_indices, 146 opj_event_mgr_t * p_manager) 147 { 148+ opj_j2k_t* p_j2k = (opj_j2k_t*)j2k; 149 OPJ_UINT32 i; 150 OPJ_BOOL* already_mapped; 151 152@@ -10260,12 +10269,13 @@ OPJ_BOOL opj_j2k_set_decoded_components(opj_j2k_t *p_j2k, 153 } 154 155 156-OPJ_BOOL opj_j2k_set_decode_area(opj_j2k_t *p_j2k, 157+OPJ_BOOL opj_j2k_set_decode_area(void *j2k, 158 opj_image_t* p_image, 159 OPJ_INT32 p_start_x, OPJ_INT32 p_start_y, 160 OPJ_INT32 p_end_x, OPJ_INT32 p_end_y, 161 opj_event_mgr_t * p_manager) 162 { 163+ opj_j2k_t* p_j2k = (opj_j2k_t*)j2k; 164 opj_cp_t * l_cp = &(p_j2k->m_cp); 165 opj_image_t * l_image = p_j2k->m_private_image; 166 OPJ_BOOL ret; 167@@ -11200,8 +11210,9 @@ static void opj_j2k_dump_tile_info(opj_tcp_t * l_default_tile, 168 } 169 } 170 171-void j2k_dump(opj_j2k_t* p_j2k, OPJ_INT32 flag, FILE* out_stream) 172+void j2k_dump(void* j2k, OPJ_INT32 flag, FILE* out_stream) 173 { 174+ opj_j2k_t* p_j2k = (opj_j2k_t*)j2k; 175 /* Check if the flag is compatible with j2k file*/ 176 if ((flag & OPJ_JP2_INFO) || (flag & OPJ_JP2_IND)) { 177 fprintf(out_stream, "Wrong flag\n"); 178@@ -11391,8 +11402,9 @@ void j2k_dump_image_comp_header(opj_image_comp_t* comp_header, 179 } 180 } 181 182-opj_codestream_info_v2_t* j2k_get_cstr_info(opj_j2k_t* p_j2k) 183+opj_codestream_info_v2_t* j2k_get_cstr_info(void* j2k) 184 { 185+ opj_j2k_t* p_j2k = (opj_j2k_t*)j2k; 186 OPJ_UINT32 compno; 187 OPJ_UINT32 numcomps = p_j2k->m_private_image->numcomps; 188 opj_tcp_t *l_default_tile; 189@@ -11467,8 +11479,9 @@ opj_codestream_info_v2_t* j2k_get_cstr_info(opj_j2k_t* p_j2k) 190 return cstr_info; 191 } 192 193-opj_codestream_index_t* j2k_get_cstr_index(opj_j2k_t* p_j2k) 194+opj_codestream_index_t* j2k_get_cstr_index(void* j2k) 195 { 196+ opj_j2k_t* p_j2k = (opj_j2k_t*)j2k; 197 opj_codestream_index_t* l_cstr_index = (opj_codestream_index_t*) 198 opj_calloc(1, sizeof(opj_codestream_index_t)); 199 if (!l_cstr_index) { 200@@ -11972,11 +11985,12 @@ static OPJ_BOOL opj_j2k_move_data_from_codec_to_output_image(opj_j2k_t * p_j2k, 201 return OPJ_TRUE; 202 } 203 204-OPJ_BOOL opj_j2k_decode(opj_j2k_t * p_j2k, 205+OPJ_BOOL opj_j2k_decode(void * j2k, 206 opj_stream_private_t * p_stream, 207 opj_image_t * p_image, 208 opj_event_mgr_t * p_manager) 209 { 210+ opj_j2k_t* p_j2k = (opj_j2k_t*)j2k; 211 if (!p_image) { 212 return OPJ_FALSE; 213 } 214@@ -12030,12 +12044,13 @@ OPJ_BOOL opj_j2k_decode(opj_j2k_t * p_j2k, 215 return opj_j2k_move_data_from_codec_to_output_image(p_j2k, p_image); 216 } 217 218-OPJ_BOOL opj_j2k_get_tile(opj_j2k_t *p_j2k, 219+OPJ_BOOL opj_j2k_get_tile(void *j2k, 220 opj_stream_private_t *p_stream, 221 opj_image_t* p_image, 222 opj_event_mgr_t * p_manager, 223 OPJ_UINT32 tile_index) 224 { 225+ opj_j2k_t* p_j2k = (opj_j2k_t*)j2k; 226 OPJ_UINT32 compno; 227 OPJ_UINT32 l_tile_x, l_tile_y; 228 opj_image_comp_t* l_img_comp; 229@@ -12143,10 +12158,11 @@ OPJ_BOOL opj_j2k_get_tile(opj_j2k_t *p_j2k, 230 return opj_j2k_move_data_from_codec_to_output_image(p_j2k, p_image); 231 } 232 233-OPJ_BOOL opj_j2k_set_decoded_resolution_factor(opj_j2k_t *p_j2k, 234+OPJ_BOOL opj_j2k_set_decoded_resolution_factor(void *j2k, 235 OPJ_UINT32 res_factor, 236 opj_event_mgr_t * p_manager) 237 { 238+ opj_j2k_t* p_j2k = (opj_j2k_t*)j2k; 239 OPJ_UINT32 it_comp; 240 241 p_j2k->m_cp.m_specific_param.m_dec.m_reduce = res_factor; 242@@ -12177,10 +12193,11 @@ OPJ_BOOL opj_j2k_set_decoded_resolution_factor(opj_j2k_t *p_j2k, 243 /* ----------------------------------------------------------------------- */ 244 245 OPJ_BOOL opj_j2k_encoder_set_extra_options( 246- opj_j2k_t *p_j2k, 247+ void *j2k, 248 const char* const* p_options, 249 opj_event_mgr_t * p_manager) 250 { 251+ opj_j2k_t* p_j2k = (opj_j2k_t*)j2k; 252 const char* const* p_option_iter; 253 254 if (p_options == NULL) { 255@@ -12239,10 +12256,11 @@ OPJ_BOOL opj_j2k_encoder_set_extra_options( 256 257 /* ----------------------------------------------------------------------- */ 258 259-OPJ_BOOL opj_j2k_encode(opj_j2k_t * p_j2k, 260+OPJ_BOOL opj_j2k_encode(void * j2k, 261 opj_stream_private_t *p_stream, 262 opj_event_mgr_t * p_manager) 263 { 264+ opj_j2k_t* p_j2k = (opj_j2k_t*)j2k; 265 OPJ_UINT32 i, j; 266 OPJ_UINT32 l_nb_tiles; 267 OPJ_SIZE_T l_max_tile_size = 0, l_current_tile_size; 268@@ -12347,10 +12365,11 @@ OPJ_BOOL opj_j2k_encode(opj_j2k_t * p_j2k, 269 return OPJ_TRUE; 270 } 271 272-OPJ_BOOL opj_j2k_end_compress(opj_j2k_t *p_j2k, 273+OPJ_BOOL opj_j2k_end_compress(void *j2k, 274 opj_stream_private_t *p_stream, 275 opj_event_mgr_t * p_manager) 276 { 277+ opj_j2k_t* p_j2k = (opj_j2k_t*)j2k; 278 /* customization of the encoding */ 279 if (! opj_j2k_setup_end_compress(p_j2k, p_manager)) { 280 return OPJ_FALSE; 281@@ -12363,11 +12382,12 @@ OPJ_BOOL opj_j2k_end_compress(opj_j2k_t *p_j2k, 282 return OPJ_TRUE; 283 } 284 285-OPJ_BOOL opj_j2k_start_compress(opj_j2k_t *p_j2k, 286+OPJ_BOOL opj_j2k_start_compress(void *j2k, 287 opj_stream_private_t *p_stream, 288 opj_image_t * p_image, 289 opj_event_mgr_t * p_manager) 290 { 291+ opj_j2k_t* p_j2k = (opj_j2k_t*)j2k; 292 /* preconditions */ 293 assert(p_j2k != 00); 294 assert(p_stream != 00); 295@@ -13154,13 +13174,14 @@ static OPJ_BOOL opj_j2k_create_tcd(opj_j2k_t *p_j2k, 296 return OPJ_TRUE; 297 } 298 299-OPJ_BOOL opj_j2k_write_tile(opj_j2k_t * p_j2k, 300+OPJ_BOOL opj_j2k_write_tile(void * j2k, 301 OPJ_UINT32 p_tile_index, 302 OPJ_BYTE * p_data, 303 OPJ_UINT32 p_data_size, 304 opj_stream_private_t *p_stream, 305 opj_event_mgr_t * p_manager) 306 { 307+ opj_j2k_t* p_j2k = (opj_j2k_t*)j2k; 308 if (! opj_j2k_pre_write_tile(p_j2k, p_tile_index, p_stream, p_manager)) { 309 opj_event_msg(p_manager, EVT_ERROR, 310 "Error while opj_j2k_pre_write_tile with tile index = %d\n", p_tile_index); 311diff --git a/third_party/libopenjpeg/j2k.h b/third_party/libopenjpeg/j2k.h 312index 04fba645a..1d824c019 100644 313--- a/third_party/libopenjpeg/j2k.h 314+++ b/third_party/libopenjpeg/j2k.h 315@@ -621,15 +621,15 @@ opj_j2k_t; 316 317 /** 318 Setup the decoder decoding parameters using user parameters. 319-Decoding parameters are returned in j2k->cp. 320-@param j2k J2K decompressor handle 321+Decoding parameters are returned in p_j2k->cp. 322+@param p_j2k J2K decompressor handle 323 @param parameters decompression parameters 324 */ 325-void opj_j2k_setup_decoder(opj_j2k_t *j2k, opj_dparameters_t *parameters); 326+void opj_j2k_setup_decoder(void *p_j2k, opj_dparameters_t *parameters); 327 328-void opj_j2k_decoder_set_strict_mode(opj_j2k_t *j2k, OPJ_BOOL strict); 329+void opj_j2k_decoder_set_strict_mode(void *j2k, OPJ_BOOL strict); 330 331-OPJ_BOOL opj_j2k_set_threads(opj_j2k_t *j2k, OPJ_UINT32 num_threads); 332+OPJ_BOOL opj_j2k_set_threads(void *j2k, OPJ_UINT32 num_threads); 333 334 /** 335 * Creates a J2K compression structure 336@@ -639,7 +639,7 @@ OPJ_BOOL opj_j2k_set_threads(opj_j2k_t *j2k, OPJ_UINT32 num_threads); 337 opj_j2k_t* opj_j2k_create_compress(void); 338 339 340-OPJ_BOOL opj_j2k_setup_encoder(opj_j2k_t *p_j2k, 341+OPJ_BOOL opj_j2k_setup_encoder(void *p_j2k, 342 opj_cparameters_t *parameters, 343 opj_image_t *image, 344 opj_event_mgr_t * p_manager); 345@@ -658,7 +658,7 @@ const char *opj_j2k_convert_progression_order(OPJ_PROG_ORDER prg_order); 346 * Ends the decompression procedures and possibiliy add data to be read after the 347 * codestream. 348 */ 349-OPJ_BOOL opj_j2k_end_decompress(opj_j2k_t *j2k, 350+OPJ_BOOL opj_j2k_end_decompress(void *j2k, 351 opj_stream_private_t *p_stream, 352 opj_event_mgr_t * p_manager); 353 354@@ -666,14 +666,14 @@ OPJ_BOOL opj_j2k_end_decompress(opj_j2k_t *j2k, 355 * Reads a jpeg2000 codestream header structure. 356 * 357 * @param p_stream the stream to read data from. 358- * @param p_j2k the jpeg2000 codec. 359+ * @param j2k the jpeg2000 codec. 360 * @param p_image FIXME DOC 361 * @param p_manager the user event manager. 362 * 363 * @return true if the box is valid. 364 */ 365 OPJ_BOOL opj_j2k_read_header(opj_stream_private_t *p_stream, 366- opj_j2k_t* p_j2k, 367+ void* j2k, 368 opj_image_t** p_image, 369 opj_event_mgr_t* p_manager); 370 371@@ -681,9 +681,9 @@ OPJ_BOOL opj_j2k_read_header(opj_stream_private_t *p_stream, 372 /** 373 * Destroys a jpeg2000 codec. 374 * 375- * @param p_j2k the jpeg20000 structure to destroy. 376+ * @param j2k the jpeg20000 structure to destroy. 377 */ 378-void opj_j2k_destroy(opj_j2k_t *p_j2k); 379+void opj_j2k_destroy(void *j2k); 380 381 /** 382 * Destroys a codestream index structure. 383@@ -694,14 +694,14 @@ void j2k_destroy_cstr_index(opj_codestream_index_t *p_cstr_ind); 384 385 /** 386 * Decode tile data. 387- * @param p_j2k the jpeg2000 codec. 388+ * @param j2k the jpeg2000 codec. 389 * @param p_tile_index 390 * @param p_data FIXME DOC 391 * @param p_data_size FIXME DOC 392 * @param p_stream the stream to write data to. 393 * @param p_manager the user event manager. 394 */ 395-OPJ_BOOL opj_j2k_decode_tile(opj_j2k_t * p_j2k, 396+OPJ_BOOL opj_j2k_decode_tile(void * j2k, 397 OPJ_UINT32 p_tile_index, 398 OPJ_BYTE * p_data, 399 OPJ_UINT32 p_data_size, 400@@ -710,7 +710,7 @@ OPJ_BOOL opj_j2k_decode_tile(opj_j2k_t * p_j2k, 401 402 /** 403 * Reads a tile header. 404- * @param p_j2k the jpeg2000 codec. 405+ * @param j2k the jpeg2000 codec. 406 * @param p_tile_index FIXME DOC 407 * @param p_data_size FIXME DOC 408 * @param p_tile_x0 FIXME DOC 409@@ -722,7 +722,7 @@ OPJ_BOOL opj_j2k_decode_tile(opj_j2k_t * p_j2k, 410 * @param p_stream the stream to write data to. 411 * @param p_manager the user event manager. 412 */ 413-OPJ_BOOL opj_j2k_read_tile_header(opj_j2k_t * p_j2k, 414+OPJ_BOOL opj_j2k_read_tile_header(void * j2k, 415 OPJ_UINT32 * p_tile_index, 416 OPJ_UINT32 * p_data_size, 417 OPJ_INT32 * p_tile_x0, 418@@ -737,7 +737,7 @@ OPJ_BOOL opj_j2k_read_tile_header(opj_j2k_t * p_j2k, 419 420 /** Sets the indices of the components to decode. 421 * 422- * @param p_j2k the jpeg2000 codec. 423+ * @param j2k the jpeg2000 codec. 424 * @param numcomps Number of components to decode. 425 * @param comps_indices Array of num_compts indices (numbering starting at 0) 426 * corresponding to the components to decode. 427@@ -745,7 +745,7 @@ OPJ_BOOL opj_j2k_read_tile_header(opj_j2k_t * p_j2k, 428 * 429 * @return OPJ_TRUE in case of success. 430 */ 431-OPJ_BOOL opj_j2k_set_decoded_components(opj_j2k_t *p_j2k, 432+OPJ_BOOL opj_j2k_set_decoded_components(void *j2k, 433 OPJ_UINT32 numcomps, 434 const OPJ_UINT32* comps_indices, 435 opj_event_mgr_t * p_manager); 436@@ -753,7 +753,7 @@ OPJ_BOOL opj_j2k_set_decoded_components(opj_j2k_t *p_j2k, 437 /** 438 * Sets the given area to be decoded. This function should be called right after opj_read_header and before any tile header reading. 439 * 440- * @param p_j2k the jpeg2000 codec. 441+ * @param j2k the jpeg2000 codec. 442 * @param p_image FIXME DOC 443 * @param p_start_x the left position of the rectangle to decode (in image coordinates). 444 * @param p_start_y the up position of the rectangle to decode (in image coordinates). 445@@ -763,7 +763,7 @@ OPJ_BOOL opj_j2k_set_decoded_components(opj_j2k_t *p_j2k, 446 * 447 * @return true if the area could be set. 448 */ 449-OPJ_BOOL opj_j2k_set_decode_area(opj_j2k_t *p_j2k, 450+OPJ_BOOL opj_j2k_set_decode_area(void *j2k, 451 opj_image_t* p_image, 452 OPJ_INT32 p_start_x, OPJ_INT32 p_start_y, 453 OPJ_INT32 p_end_x, OPJ_INT32 p_end_y, 454@@ -780,12 +780,12 @@ opj_j2k_t* opj_j2k_create_decompress(void); 455 /** 456 * Dump some elements from the J2K decompression structure . 457 * 458- *@param p_j2k the jpeg2000 codec. 459+ *@param j2k the jpeg2000 codec. 460 *@param flag flag to describe what elements are dump. 461 *@param out_stream output stream where dump the elements. 462 * 463 */ 464-void j2k_dump(opj_j2k_t* p_j2k, OPJ_INT32 flag, FILE* out_stream); 465+void j2k_dump(void* j2k, OPJ_INT32 flag, FILE* out_stream); 466 467 468 469@@ -812,20 +812,20 @@ void j2k_dump_image_comp_header(opj_image_comp_t* comp, OPJ_BOOL dev_dump_flag, 470 /** 471 * Get the codestream info from a JPEG2000 codec. 472 * 473- *@param p_j2k the component image header to dump. 474+ *@param j2k the component image header to dump. 475 * 476 *@return the codestream information extract from the jpg2000 codec 477 */ 478-opj_codestream_info_v2_t* j2k_get_cstr_info(opj_j2k_t* p_j2k); 479+opj_codestream_info_v2_t* j2k_get_cstr_info(void* j2k); 480 481 /** 482 * Get the codestream index from a JPEG2000 codec. 483 * 484- *@param p_j2k the component image header to dump. 485+ *@param j2k the component image header to dump. 486 * 487 *@return the codestream index extract from the jpg2000 codec 488 */ 489-opj_codestream_index_t* j2k_get_cstr_index(opj_j2k_t* p_j2k); 490+opj_codestream_index_t* j2k_get_cstr_index(void* j2k); 491 492 /** 493 * Decode an image from a JPEG-2000 codestream 494@@ -835,46 +835,46 @@ opj_codestream_index_t* j2k_get_cstr_index(opj_j2k_t* p_j2k); 495 * @param p_manager FIXME DOC 496 * @return FIXME DOC 497 */ 498-OPJ_BOOL opj_j2k_decode(opj_j2k_t *j2k, 499+OPJ_BOOL opj_j2k_decode(void *j2k, 500 opj_stream_private_t *p_stream, 501 opj_image_t *p_image, 502 opj_event_mgr_t *p_manager); 503 504 505-OPJ_BOOL opj_j2k_get_tile(opj_j2k_t *p_j2k, 506+OPJ_BOOL opj_j2k_get_tile(void *j2k, 507 opj_stream_private_t *p_stream, 508 opj_image_t* p_image, 509 opj_event_mgr_t * p_manager, 510 OPJ_UINT32 tile_index); 511 512-OPJ_BOOL opj_j2k_set_decoded_resolution_factor(opj_j2k_t *p_j2k, 513+OPJ_BOOL opj_j2k_set_decoded_resolution_factor(void *j2k, 514 OPJ_UINT32 res_factor, 515 opj_event_mgr_t * p_manager); 516 517 /** 518 * Specify extra options for the encoder. 519 * 520- * @param p_j2k the jpeg2000 codec. 521+ * @param j2k the jpeg2000 codec. 522 * @param p_options options 523 * @param p_manager the user event manager 524 * 525 * @see opj_encoder_set_extra_options() for more details. 526 */ 527 OPJ_BOOL opj_j2k_encoder_set_extra_options( 528- opj_j2k_t *p_j2k, 529+ void *j2k, 530 const char* const* p_options, 531 opj_event_mgr_t * p_manager); 532 533 /** 534 * Writes a tile. 535- * @param p_j2k the jpeg2000 codec. 536+ * @param j2k the jpeg2000 codec. 537 * @param p_tile_index FIXME DOC 538 * @param p_data FIXME DOC 539 * @param p_data_size FIXME DOC 540 * @param p_stream the stream to write data to. 541 * @param p_manager the user event manager. 542 */ 543-OPJ_BOOL opj_j2k_write_tile(opj_j2k_t * p_j2k, 544+OPJ_BOOL opj_j2k_write_tile(void * j2k, 545 OPJ_UINT32 p_tile_index, 546 OPJ_BYTE * p_data, 547 OPJ_UINT32 p_data_size, 548@@ -884,21 +884,21 @@ OPJ_BOOL opj_j2k_write_tile(opj_j2k_t * p_j2k, 549 /** 550 * Encodes an image into a JPEG-2000 codestream 551 */ 552-OPJ_BOOL opj_j2k_encode(opj_j2k_t * p_j2k, 553+OPJ_BOOL opj_j2k_encode(void * j2k, 554 opj_stream_private_t *cio, 555 opj_event_mgr_t * p_manager); 556 557 /** 558 * Starts a compression scheme, i.e. validates the codec parameters, writes the header. 559 * 560- * @param p_j2k the jpeg2000 codec. 561+ * @param j2k the jpeg2000 codec. 562 * @param p_stream the stream object. 563 * @param p_image FIXME DOC 564 * @param p_manager the user event manager. 565 * 566 * @return true if the codec is valid. 567 */ 568-OPJ_BOOL opj_j2k_start_compress(opj_j2k_t *p_j2k, 569+OPJ_BOOL opj_j2k_start_compress(void *j2k, 570 opj_stream_private_t *p_stream, 571 opj_image_t * p_image, 572 opj_event_mgr_t * p_manager); 573@@ -907,7 +907,7 @@ OPJ_BOOL opj_j2k_start_compress(opj_j2k_t *p_j2k, 574 * Ends the compression procedures and possibiliy add data to be read after the 575 * codestream. 576 */ 577-OPJ_BOOL opj_j2k_end_compress(opj_j2k_t *p_j2k, 578+OPJ_BOOL opj_j2k_end_compress(void *j2k, 579 opj_stream_private_t *cio, 580 opj_event_mgr_t * p_manager); 581 582diff --git a/third_party/libopenjpeg/jp2.c b/third_party/libopenjpeg/jp2.c 583index 44d0c98e5..6db728d18 100644 584--- a/third_party/libopenjpeg/jp2.c 585+++ b/third_party/libopenjpeg/jp2.c 586@@ -1609,11 +1609,12 @@ static OPJ_BOOL opj_jp2_read_colr(opj_jp2_t *jp2, 587 return OPJ_TRUE; 588 } 589 590-OPJ_BOOL opj_jp2_decode(opj_jp2_t *jp2, 591+OPJ_BOOL opj_jp2_decode(void *p_jp2, 592 opj_stream_private_t *p_stream, 593 opj_image_t* p_image, 594 opj_event_mgr_t * p_manager) 595 { 596+ opj_jp2_t *jp2 = (opj_jp2_t*)p_jp2; 597 if (!p_image) { 598 return OPJ_FALSE; 599 } 600@@ -1905,8 +1906,9 @@ static OPJ_BOOL opj_jp2_write_jp(opj_jp2_t *jp2, 601 /* JP2 decoder interface */ 602 /* ----------------------------------------------------------------------- */ 603 604-void opj_jp2_setup_decoder(opj_jp2_t *jp2, opj_dparameters_t *parameters) 605+void opj_jp2_setup_decoder(void *p_jp2, opj_dparameters_t *parameters) 606 { 607+ opj_jp2_t *jp2 = (opj_jp2_t*)p_jp2; 608 /* setup the J2K codec */ 609 opj_j2k_setup_decoder(jp2->j2k, parameters); 610 611@@ -1917,13 +1919,15 @@ void opj_jp2_setup_decoder(opj_jp2_t *jp2, opj_dparameters_t *parameters) 612 OPJ_DPARAMETERS_IGNORE_PCLR_CMAP_CDEF_FLAG; 613 } 614 615-void opj_jp2_decoder_set_strict_mode(opj_jp2_t *jp2, OPJ_BOOL strict) 616+void opj_jp2_decoder_set_strict_mode(void *p_jp2, OPJ_BOOL strict) 617 { 618+ opj_jp2_t *jp2 = (opj_jp2_t*)p_jp2; 619 opj_j2k_decoder_set_strict_mode(jp2->j2k, strict); 620 } 621 622-OPJ_BOOL opj_jp2_set_threads(opj_jp2_t *jp2, OPJ_UINT32 num_threads) 623+OPJ_BOOL opj_jp2_set_threads(void *p_jp2, OPJ_UINT32 num_threads) 624 { 625+ opj_jp2_t *jp2 = (opj_jp2_t*)p_jp2; 626 return opj_j2k_set_threads(jp2->j2k, num_threads); 627 } 628 629@@ -1931,11 +1935,12 @@ OPJ_BOOL opj_jp2_set_threads(opj_jp2_t *jp2, OPJ_UINT32 num_threads) 630 /* JP2 encoder interface */ 631 /* ----------------------------------------------------------------------- */ 632 633-OPJ_BOOL opj_jp2_setup_encoder(opj_jp2_t *jp2, 634+OPJ_BOOL opj_jp2_setup_encoder(void *p_jp2, 635 opj_cparameters_t *parameters, 636 opj_image_t *image, 637 opj_event_mgr_t * p_manager) 638 { 639+ opj_jp2_t *jp2 = (opj_jp2_t*)p_jp2; 640 OPJ_UINT32 i; 641 OPJ_UINT32 depth_0; 642 OPJ_UINT32 sign; 643@@ -2118,18 +2123,20 @@ OPJ_BOOL opj_jp2_setup_encoder(opj_jp2_t *jp2, 644 return OPJ_TRUE; 645 } 646 647-OPJ_BOOL opj_jp2_encode(opj_jp2_t *jp2, 648+OPJ_BOOL opj_jp2_encode(void *p_jp2, 649 opj_stream_private_t *stream, 650 opj_event_mgr_t * p_manager) 651 { 652+ opj_jp2_t *jp2 = (opj_jp2_t*)p_jp2; 653 return opj_j2k_encode(jp2->j2k, stream, p_manager); 654 } 655 656-OPJ_BOOL opj_jp2_end_decompress(opj_jp2_t *jp2, 657+OPJ_BOOL opj_jp2_end_decompress(void *p_jp2, 658 opj_stream_private_t *cio, 659 opj_event_mgr_t * p_manager 660 ) 661 { 662+ opj_jp2_t *jp2 = (opj_jp2_t*)p_jp2; 663 /* preconditions */ 664 assert(jp2 != 00); 665 assert(cio != 00); 666@@ -2148,11 +2155,12 @@ OPJ_BOOL opj_jp2_end_decompress(opj_jp2_t *jp2, 667 return opj_j2k_end_decompress(jp2->j2k, cio, p_manager); 668 } 669 670-OPJ_BOOL opj_jp2_end_compress(opj_jp2_t *jp2, 671+OPJ_BOOL opj_jp2_end_compress(void *p_jp2, 672 opj_stream_private_t *cio, 673 opj_event_mgr_t * p_manager 674 ) 675 { 676+ opj_jp2_t *jp2 = (opj_jp2_t*)p_jp2; 677 /* preconditions */ 678 assert(jp2 != 00); 679 assert(cio != 00); 680@@ -2476,12 +2484,13 @@ static OPJ_BOOL opj_jp2_exec(opj_jp2_t * jp2, 681 return l_result; 682 } 683 684-OPJ_BOOL opj_jp2_start_compress(opj_jp2_t *jp2, 685+OPJ_BOOL opj_jp2_start_compress(void *p_jp2, 686 opj_stream_private_t *stream, 687 opj_image_t * p_image, 688 opj_event_mgr_t * p_manager 689 ) 690 { 691+ opj_jp2_t *jp2 = (opj_jp2_t*)p_jp2; 692 /* preconditions */ 693 assert(jp2 != 00); 694 assert(stream != 00); 695@@ -2854,11 +2863,12 @@ static OPJ_BOOL opj_jp2_read_boxhdr_char(opj_jp2_box_t *box, 696 } 697 698 OPJ_BOOL opj_jp2_read_header(opj_stream_private_t *p_stream, 699- opj_jp2_t *jp2, 700+ void *p_jp2, 701 opj_image_t ** p_image, 702 opj_event_mgr_t * p_manager 703 ) 704 { 705+ opj_jp2_t *jp2 = (opj_jp2_t*)p_jp2; 706 /* preconditions */ 707 assert(jp2 != 00); 708 assert(p_stream != 00); 709@@ -2981,7 +2991,7 @@ static OPJ_BOOL opj_jp2_setup_header_reading(opj_jp2_t *jp2, 710 return OPJ_TRUE; 711 } 712 713-OPJ_BOOL opj_jp2_read_tile_header(opj_jp2_t * p_jp2, 714+OPJ_BOOL opj_jp2_read_tile_header(void *p_jp2, 715 OPJ_UINT32 * p_tile_index, 716 OPJ_UINT32 * p_data_size, 717 OPJ_INT32 * p_tile_x0, 718@@ -2994,7 +3004,8 @@ OPJ_BOOL opj_jp2_read_tile_header(opj_jp2_t * p_jp2, 719 opj_event_mgr_t * p_manager 720 ) 721 { 722- return opj_j2k_read_tile_header(p_jp2->j2k, 723+ opj_jp2_t *jp2 = (opj_jp2_t*)p_jp2; 724+ return opj_j2k_read_tile_header(jp2->j2k, 725 p_tile_index, 726 p_data_size, 727 p_tile_x0, p_tile_y0, 728@@ -3005,7 +3016,7 @@ OPJ_BOOL opj_jp2_read_tile_header(opj_jp2_t * p_jp2, 729 p_manager); 730 } 731 732-OPJ_BOOL opj_jp2_write_tile(opj_jp2_t *p_jp2, 733+OPJ_BOOL opj_jp2_write_tile(void *p_jp2, 734 OPJ_UINT32 p_tile_index, 735 OPJ_BYTE * p_data, 736 OPJ_UINT32 p_data_size, 737@@ -3014,11 +3025,12 @@ OPJ_BOOL opj_jp2_write_tile(opj_jp2_t *p_jp2, 738 ) 739 740 { 741- return opj_j2k_write_tile(p_jp2->j2k, p_tile_index, p_data, p_data_size, 742+ opj_jp2_t *jp2 = (opj_jp2_t*)p_jp2; 743+ return opj_j2k_write_tile(jp2->j2k, p_tile_index, p_data, p_data_size, 744 p_stream, p_manager); 745 } 746 747-OPJ_BOOL opj_jp2_decode_tile(opj_jp2_t * p_jp2, 748+OPJ_BOOL opj_jp2_decode_tile(void *p_jp2, 749 OPJ_UINT32 p_tile_index, 750 OPJ_BYTE * p_data, 751 OPJ_UINT32 p_data_size, 752@@ -3026,12 +3038,14 @@ OPJ_BOOL opj_jp2_decode_tile(opj_jp2_t * p_jp2, 753 opj_event_mgr_t * p_manager 754 ) 755 { 756- return opj_j2k_decode_tile(p_jp2->j2k, p_tile_index, p_data, p_data_size, 757+ opj_jp2_t *jp2 = (opj_jp2_t*)p_jp2; 758+ return opj_j2k_decode_tile(jp2->j2k, p_tile_index, p_data, p_data_size, 759 p_stream, p_manager); 760 } 761 762-void opj_jp2_destroy(opj_jp2_t *jp2) 763+void opj_jp2_destroy(void *p_jp2) 764 { 765+ opj_jp2_t *jp2 = (opj_jp2_t*)p_jp2; 766 if (jp2) { 767 /* destroy the J2K codec */ 768 opj_j2k_destroy(jp2->j2k); 769@@ -3098,34 +3112,37 @@ void opj_jp2_destroy(opj_jp2_t *jp2) 770 } 771 } 772 773-OPJ_BOOL opj_jp2_set_decoded_components(opj_jp2_t *p_jp2, 774+OPJ_BOOL opj_jp2_set_decoded_components(void *p_jp2, 775 OPJ_UINT32 numcomps, 776 const OPJ_UINT32* comps_indices, 777 opj_event_mgr_t * p_manager) 778 { 779- return opj_j2k_set_decoded_components(p_jp2->j2k, 780+ opj_jp2_t *jp2 = (opj_jp2_t*)p_jp2; 781+ return opj_j2k_set_decoded_components(jp2->j2k, 782 numcomps, comps_indices, 783 p_manager); 784 } 785 786-OPJ_BOOL opj_jp2_set_decode_area(opj_jp2_t *p_jp2, 787+OPJ_BOOL opj_jp2_set_decode_area(void *p_jp2, 788 opj_image_t* p_image, 789 OPJ_INT32 p_start_x, OPJ_INT32 p_start_y, 790 OPJ_INT32 p_end_x, OPJ_INT32 p_end_y, 791 opj_event_mgr_t * p_manager 792 ) 793 { 794- return opj_j2k_set_decode_area(p_jp2->j2k, p_image, p_start_x, p_start_y, 795+ opj_jp2_t *jp2 = (opj_jp2_t*)p_jp2; 796+ return opj_j2k_set_decode_area(jp2->j2k, p_image, p_start_x, p_start_y, 797 p_end_x, p_end_y, p_manager); 798 } 799 800-OPJ_BOOL opj_jp2_get_tile(opj_jp2_t *p_jp2, 801+OPJ_BOOL opj_jp2_get_tile(void *jp2, 802 opj_stream_private_t *p_stream, 803 opj_image_t* p_image, 804 opj_event_mgr_t * p_manager, 805 OPJ_UINT32 tile_index 806 ) 807 { 808+ opj_jp2_t *p_jp2 = (opj_jp2_t*)jp2; 809 if (!p_image) { 810 return OPJ_FALSE; 811 } 812@@ -3234,41 +3251,46 @@ opj_jp2_t* opj_jp2_create(OPJ_BOOL p_is_decoder) 813 return jp2; 814 } 815 816-void jp2_dump(opj_jp2_t* p_jp2, OPJ_INT32 flag, FILE* out_stream) 817+void jp2_dump(void* p_jp2, OPJ_INT32 flag, FILE* out_stream) 818 { 819+ opj_jp2_t *jp2 = (opj_jp2_t*)p_jp2; 820 /* preconditions */ 821 assert(p_jp2 != 00); 822 823- j2k_dump(p_jp2->j2k, 824+ j2k_dump(jp2->j2k, 825 flag, 826 out_stream); 827 } 828 829-opj_codestream_index_t* jp2_get_cstr_index(opj_jp2_t* p_jp2) 830+opj_codestream_index_t* jp2_get_cstr_index(void* p_jp2) 831 { 832- return j2k_get_cstr_index(p_jp2->j2k); 833+ opj_jp2_t *jp2 = (opj_jp2_t*)p_jp2; 834+ return j2k_get_cstr_index(jp2->j2k); 835 } 836 837-opj_codestream_info_v2_t* jp2_get_cstr_info(opj_jp2_t* p_jp2) 838+opj_codestream_info_v2_t* jp2_get_cstr_info(void* p_jp2) 839 { 840- return j2k_get_cstr_info(p_jp2->j2k); 841+ opj_jp2_t *jp2 = (opj_jp2_t*)p_jp2; 842+ return j2k_get_cstr_info(jp2->j2k); 843 } 844 845-OPJ_BOOL opj_jp2_set_decoded_resolution_factor(opj_jp2_t *p_jp2, 846+OPJ_BOOL opj_jp2_set_decoded_resolution_factor(void *p_jp2, 847 OPJ_UINT32 res_factor, 848 opj_event_mgr_t * p_manager) 849 { 850- return opj_j2k_set_decoded_resolution_factor(p_jp2->j2k, res_factor, p_manager); 851+ opj_jp2_t *jp2 = (opj_jp2_t*)p_jp2; 852+ return opj_j2k_set_decoded_resolution_factor(jp2->j2k, res_factor, p_manager); 853 } 854 855 /* ----------------------------------------------------------------------- */ 856 857 OPJ_BOOL opj_jp2_encoder_set_extra_options( 858- opj_jp2_t *p_jp2, 859+ void *p_jp2, 860 const char* const* p_options, 861 opj_event_mgr_t * p_manager) 862 { 863- return opj_j2k_encoder_set_extra_options(p_jp2->j2k, p_options, p_manager); 864+ opj_jp2_t *jp2 = (opj_jp2_t*)p_jp2; 865+ return opj_j2k_encoder_set_extra_options(jp2->j2k, p_options, p_manager); 866 } 867 868 /* ----------------------------------------------------------------------- */ 869diff --git a/third_party/libopenjpeg/jp2.h b/third_party/libopenjpeg/jp2.h 870index 173f25119..fd9175a4e 100644 871--- a/third_party/libopenjpeg/jp2.h 872+++ b/third_party/libopenjpeg/jp2.h 873@@ -230,38 +230,38 @@ opj_jp2_img_header_writer_handler_t; 874 /** 875 Setup the decoder decoding parameters using user parameters. 876 Decoding parameters are returned in jp2->j2k->cp. 877-@param jp2 JP2 decompressor handle 878+@param p_jp2 JP2 decompressor handle 879 @param parameters decompression parameters 880 */ 881-void opj_jp2_setup_decoder(opj_jp2_t *jp2, opj_dparameters_t *parameters); 882+void opj_jp2_setup_decoder(void *p_jp2, opj_dparameters_t *parameters); 883 884 /** 885 Set the strict mode parameter. When strict mode is enabled, the entire 886 bitstream must be decoded or an error is returned. When it is disabled, 887 the decoder will decode partial bitstreams. 888-@param jp2 JP2 decompressor handle 889+@param p_jp2 JP2 decompressor handle 890 @param strict OPJ_TRUE for strict mode 891 */ 892-void opj_jp2_decoder_set_strict_mode(opj_jp2_t *jp2, OPJ_BOOL strict); 893+void opj_jp2_decoder_set_strict_mode(void *p_jp2, OPJ_BOOL strict); 894 895 /** Allocates worker threads for the compressor/decompressor. 896 * 897- * @param jp2 JP2 decompressor handle 898+ * @param p_jp2 JP2 decompressor handle 899 * @param num_threads Number of threads. 900 * @return OPJ_TRUE in case of success. 901 */ 902-OPJ_BOOL opj_jp2_set_threads(opj_jp2_t *jp2, OPJ_UINT32 num_threads); 903+OPJ_BOOL opj_jp2_set_threads(void *p_jp2, OPJ_UINT32 num_threads); 904 905 /** 906 * Decode an image from a JPEG-2000 file stream 907- * @param jp2 JP2 decompressor handle 908+ * @param p_jp2 JP2 decompressor handle 909 * @param p_stream FIXME DOC 910 * @param p_image FIXME DOC 911 * @param p_manager FIXME DOC 912 * 913 * @return Returns a decoded image if successful, returns NULL otherwise 914 */ 915-OPJ_BOOL opj_jp2_decode(opj_jp2_t *jp2, 916+OPJ_BOOL opj_jp2_decode(void *p_jp2, 917 opj_stream_private_t *p_stream, 918 opj_image_t* p_image, 919 opj_event_mgr_t * p_manager); 920@@ -270,25 +270,25 @@ OPJ_BOOL opj_jp2_decode(opj_jp2_t *jp2, 921 * Setup the encoder parameters using the current image and using user parameters. 922 * Coding parameters are returned in jp2->j2k->cp. 923 * 924- * @param jp2 JP2 compressor handle 925+ * @param p_jp2 JP2 compressor handle 926 * @param parameters compression parameters 927 * @param image input filled image 928 * @param p_manager FIXME DOC 929 * @return OPJ_TRUE if successful, OPJ_FALSE otherwise 930 */ 931-OPJ_BOOL opj_jp2_setup_encoder(opj_jp2_t *jp2, 932+OPJ_BOOL opj_jp2_setup_encoder(void *p_jp2, 933 opj_cparameters_t *parameters, 934 opj_image_t *image, 935 opj_event_mgr_t * p_manager); 936 937 /** 938 Encode an image into a JPEG-2000 file stream 939-@param jp2 JP2 compressor handle 940+@param p_jp2 JP2 compressor handle 941 @param stream Output buffer stream 942 @param p_manager event manager 943 @return Returns true if successful, returns false otherwise 944 */ 945-OPJ_BOOL opj_jp2_encode(opj_jp2_t *jp2, 946+OPJ_BOOL opj_jp2_encode(void *p_jp2, 947 opj_stream_private_t *stream, 948 opj_event_mgr_t * p_manager); 949 950@@ -296,14 +296,14 @@ OPJ_BOOL opj_jp2_encode(opj_jp2_t *jp2, 951 /** 952 * Starts a compression scheme, i.e. validates the codec parameters, writes the header. 953 * 954- * @param jp2 the jpeg2000 file codec. 955+ * @param p_jp2 the jpeg2000 file codec. 956 * @param stream the stream object. 957 * @param p_image FIXME DOC 958 * @param p_manager FIXME DOC 959 * 960 * @return true if the codec is valid. 961 */ 962-OPJ_BOOL opj_jp2_start_compress(opj_jp2_t *jp2, 963+OPJ_BOOL opj_jp2_start_compress(void *p_jp2, 964 opj_stream_private_t *stream, 965 opj_image_t * p_image, 966 opj_event_mgr_t * p_manager); 967@@ -313,7 +313,7 @@ OPJ_BOOL opj_jp2_start_compress(opj_jp2_t *jp2, 968 * Ends the compression procedures and possibiliy add data to be read after the 969 * codestream. 970 */ 971-OPJ_BOOL opj_jp2_end_compress(opj_jp2_t *jp2, 972+OPJ_BOOL opj_jp2_end_compress(void *p_jp2, 973 opj_stream_private_t *cio, 974 opj_event_mgr_t * p_manager); 975 976@@ -323,7 +323,7 @@ OPJ_BOOL opj_jp2_end_compress(opj_jp2_t *jp2, 977 * Ends the decompression procedures and possibiliy add data to be read after the 978 * codestream. 979 */ 980-OPJ_BOOL opj_jp2_end_decompress(opj_jp2_t *jp2, 981+OPJ_BOOL opj_jp2_end_decompress(void *p_jp2, 982 opj_stream_private_t *cio, 983 opj_event_mgr_t * p_manager); 984 985@@ -331,20 +331,20 @@ OPJ_BOOL opj_jp2_end_decompress(opj_jp2_t *jp2, 986 * Reads a jpeg2000 file header structure. 987 * 988 * @param p_stream the stream to read data from. 989- * @param jp2 the jpeg2000 file header structure. 990+ * @param p_jp2 the jpeg2000 file header structure. 991 * @param p_image FIXME DOC 992 * @param p_manager the user event manager. 993 * 994 * @return true if the box is valid. 995 */ 996 OPJ_BOOL opj_jp2_read_header(opj_stream_private_t *p_stream, 997- opj_jp2_t *jp2, 998+ void *p_jp2, 999 opj_image_t ** p_image, 1000 opj_event_mgr_t * p_manager); 1001 1002 /** Sets the indices of the components to decode. 1003 * 1004- * @param jp2 JP2 decompressor handle 1005+ * @param p_jp2 JP2 decompressor handle 1006 * @param numcomps Number of components to decode. 1007 * @param comps_indices Array of num_compts indices (numbering starting at 0) 1008 * corresponding to the components to decode. 1009@@ -352,7 +352,7 @@ OPJ_BOOL opj_jp2_read_header(opj_stream_private_t *p_stream, 1010 * 1011 * @return OPJ_TRUE in case of success. 1012 */ 1013-OPJ_BOOL opj_jp2_set_decoded_components(opj_jp2_t *jp2, 1014+OPJ_BOOL opj_jp2_set_decoded_components(void *p_jp2, 1015 OPJ_UINT32 numcomps, 1016 const OPJ_UINT32* comps_indices, 1017 opj_event_mgr_t * p_manager); 1018@@ -371,7 +371,7 @@ OPJ_BOOL opj_jp2_set_decoded_components(opj_jp2_t *jp2, 1019 * @param p_stream the stream to write data to. 1020 * @param p_manager the user event manager. 1021 */ 1022-OPJ_BOOL opj_jp2_read_tile_header(opj_jp2_t * p_jp2, 1023+OPJ_BOOL opj_jp2_read_tile_header(void * p_jp2, 1024 OPJ_UINT32 * p_tile_index, 1025 OPJ_UINT32 * p_data_size, 1026 OPJ_INT32 * p_tile_x0, 1027@@ -393,7 +393,7 @@ OPJ_BOOL opj_jp2_read_tile_header(opj_jp2_t * p_jp2, 1028 * @param p_stream the stream to write data to. 1029 * @param p_manager the user event manager. 1030 */ 1031-OPJ_BOOL opj_jp2_write_tile(opj_jp2_t *p_jp2, 1032+OPJ_BOOL opj_jp2_write_tile(void *p_jp2, 1033 OPJ_UINT32 p_tile_index, 1034 OPJ_BYTE * p_data, 1035 OPJ_UINT32 p_data_size, 1036@@ -411,7 +411,7 @@ OPJ_BOOL opj_jp2_write_tile(opj_jp2_t *p_jp2, 1037 * 1038 * @return FIXME DOC 1039 */ 1040-OPJ_BOOL opj_jp2_decode_tile(opj_jp2_t * p_jp2, 1041+OPJ_BOOL opj_jp2_decode_tile(void * p_jp2, 1042 OPJ_UINT32 p_tile_index, 1043 OPJ_BYTE * p_data, 1044 OPJ_UINT32 p_data_size, 1045@@ -427,9 +427,9 @@ opj_jp2_t* opj_jp2_create(OPJ_BOOL p_is_decoder); 1046 1047 /** 1048 Destroy a JP2 decompressor handle 1049-@param jp2 JP2 decompressor handle to destroy 1050+@param p_jp2 JP2 decompressor handle to destroy 1051 */ 1052-void opj_jp2_destroy(opj_jp2_t *jp2); 1053+void opj_jp2_destroy(void *p_jp2); 1054 1055 1056 /** 1057@@ -445,7 +445,7 @@ void opj_jp2_destroy(opj_jp2_t *jp2); 1058 * 1059 * @return true if the area could be set. 1060 */ 1061-OPJ_BOOL opj_jp2_set_decode_area(opj_jp2_t *p_jp2, 1062+OPJ_BOOL opj_jp2_set_decode_area(void *p_jp2, 1063 opj_image_t* p_image, 1064 OPJ_INT32 p_start_x, OPJ_INT32 p_start_y, 1065 OPJ_INT32 p_end_x, OPJ_INT32 p_end_y, 1066@@ -454,7 +454,7 @@ OPJ_BOOL opj_jp2_set_decode_area(opj_jp2_t *p_jp2, 1067 /** 1068 * 1069 */ 1070-OPJ_BOOL opj_jp2_get_tile(opj_jp2_t *p_jp2, 1071+OPJ_BOOL opj_jp2_get_tile(void *jp2, 1072 opj_stream_private_t *p_stream, 1073 opj_image_t* p_image, 1074 opj_event_mgr_t * p_manager, 1075@@ -464,7 +464,7 @@ OPJ_BOOL opj_jp2_get_tile(opj_jp2_t *p_jp2, 1076 /** 1077 * 1078 */ 1079-OPJ_BOOL opj_jp2_set_decoded_resolution_factor(opj_jp2_t *p_jp2, 1080+OPJ_BOOL opj_jp2_set_decoded_resolution_factor(void *p_jp2, 1081 OPJ_UINT32 res_factor, 1082 opj_event_mgr_t * p_manager); 1083 1084@@ -478,7 +478,7 @@ OPJ_BOOL opj_jp2_set_decoded_resolution_factor(opj_jp2_t *p_jp2, 1085 * @see opj_encoder_set_extra_options() for more details. 1086 */ 1087 OPJ_BOOL opj_jp2_encoder_set_extra_options( 1088- opj_jp2_t *p_jp2, 1089+ void *p_jp2, 1090 const char* const* p_options, 1091 opj_event_mgr_t * p_manager); 1092 1093@@ -492,7 +492,7 @@ OPJ_BOOL opj_jp2_encoder_set_extra_options( 1094 *@param out_stream output stream where dump the elements. 1095 * 1096 */ 1097-void jp2_dump(opj_jp2_t* p_jp2, OPJ_INT32 flag, FILE* out_stream); 1098+void jp2_dump(void* p_jp2, OPJ_INT32 flag, FILE* out_stream); 1099 1100 /** 1101 * Get the codestream info from a JPEG2000 codec. 1102@@ -501,7 +501,7 @@ void jp2_dump(opj_jp2_t* p_jp2, OPJ_INT32 flag, FILE* out_stream); 1103 * 1104 *@return the codestream information extract from the jpg2000 codec 1105 */ 1106-opj_codestream_info_v2_t* jp2_get_cstr_info(opj_jp2_t* p_jp2); 1107+opj_codestream_info_v2_t* jp2_get_cstr_info(void* p_jp2); 1108 1109 /** 1110 * Get the codestream index from a JPEG2000 codec. 1111@@ -510,7 +510,7 @@ opj_codestream_info_v2_t* jp2_get_cstr_info(opj_jp2_t* p_jp2); 1112 * 1113 *@return the codestream index extract from the jpg2000 codec 1114 */ 1115-opj_codestream_index_t* jp2_get_cstr_index(opj_jp2_t* p_jp2); 1116+opj_codestream_index_t* jp2_get_cstr_index(void* p_jp2); 1117 1118 1119 /*@}*/ 1120diff --git a/third_party/libopenjpeg/openjpeg.c b/third_party/libopenjpeg/openjpeg.c 1121index 29d3ee528..9dd4256d7 100644 1122--- a/third_party/libopenjpeg/openjpeg.c 1123+++ b/third_party/libopenjpeg/openjpeg.c 1124@@ -189,85 +189,48 @@ opj_codec_t* OPJ_CALLCONV opj_create_decompress(OPJ_CODEC_FORMAT p_format) 1125 1126 switch (p_format) { 1127 case OPJ_CODEC_J2K: 1128- l_codec->opj_dump_codec = (void (*)(void*, OPJ_INT32, FILE*)) j2k_dump; 1129+ l_codec->opj_dump_codec = j2k_dump; 1130 1131- l_codec->opj_get_codec_info = (opj_codestream_info_v2_t* (*)( 1132- void*)) j2k_get_cstr_info; 1133+ l_codec->opj_get_codec_info = j2k_get_cstr_info; 1134 1135- l_codec->opj_get_codec_index = (opj_codestream_index_t* (*)( 1136- void*)) j2k_get_cstr_index; 1137+ l_codec->opj_get_codec_index = j2k_get_cstr_index; 1138 1139- l_codec->m_codec_data.m_decompression.opj_decode = 1140- (OPJ_BOOL(*)(void *, 1141- struct opj_stream_private *, 1142- opj_image_t*, struct opj_event_mgr *)) opj_j2k_decode; 1143+ l_codec->m_codec_data.m_decompression.opj_decode = opj_j2k_decode; 1144 1145 l_codec->m_codec_data.m_decompression.opj_end_decompress = 1146- (OPJ_BOOL(*)(void *, 1147- struct opj_stream_private *, 1148- struct opj_event_mgr *)) opj_j2k_end_decompress; 1149+ opj_j2k_end_decompress; 1150 1151 l_codec->m_codec_data.m_decompression.opj_read_header = 1152- (OPJ_BOOL(*)(struct opj_stream_private *, 1153- void *, 1154- opj_image_t **, 1155- struct opj_event_mgr *)) opj_j2k_read_header; 1156+ opj_j2k_read_header; 1157 1158- l_codec->m_codec_data.m_decompression.opj_destroy = 1159- (void (*)(void *))opj_j2k_destroy; 1160+ l_codec->m_codec_data.m_decompression.opj_destroy = opj_j2k_destroy; 1161 1162 l_codec->m_codec_data.m_decompression.opj_setup_decoder = 1163- (void (*)(void *, opj_dparameters_t *)) opj_j2k_setup_decoder; 1164+ opj_j2k_setup_decoder; 1165 1166 l_codec->m_codec_data.m_decompression.opj_decoder_set_strict_mode = 1167- (void (*)(void *, OPJ_BOOL)) opj_j2k_decoder_set_strict_mode; 1168+ opj_j2k_decoder_set_strict_mode; 1169 1170 1171 l_codec->m_codec_data.m_decompression.opj_read_tile_header = 1172- (OPJ_BOOL(*)(void *, 1173- OPJ_UINT32*, 1174- OPJ_UINT32*, 1175- OPJ_INT32*, OPJ_INT32*, 1176- OPJ_INT32*, OPJ_INT32*, 1177- OPJ_UINT32*, 1178- OPJ_BOOL*, 1179- struct opj_stream_private *, 1180- struct opj_event_mgr *)) opj_j2k_read_tile_header; 1181+ opj_j2k_read_tile_header; 1182 1183 l_codec->m_codec_data.m_decompression.opj_decode_tile_data = 1184- (OPJ_BOOL(*)(void *, 1185- OPJ_UINT32, 1186- OPJ_BYTE*, 1187- OPJ_UINT32, 1188- struct opj_stream_private *, 1189- struct opj_event_mgr *)) opj_j2k_decode_tile; 1190+ opj_j2k_decode_tile; 1191 1192 l_codec->m_codec_data.m_decompression.opj_set_decode_area = 1193- (OPJ_BOOL(*)(void *, 1194- opj_image_t*, 1195- OPJ_INT32, OPJ_INT32, OPJ_INT32, OPJ_INT32, 1196- struct opj_event_mgr *)) opj_j2k_set_decode_area; 1197+ opj_j2k_set_decode_area; 1198 1199 l_codec->m_codec_data.m_decompression.opj_get_decoded_tile = 1200- (OPJ_BOOL(*)(void *p_codec, 1201- opj_stream_private_t *p_cio, 1202- opj_image_t *p_image, 1203- struct opj_event_mgr * p_manager, 1204- OPJ_UINT32 tile_index)) opj_j2k_get_tile; 1205+ opj_j2k_get_tile; 1206 1207 l_codec->m_codec_data.m_decompression.opj_set_decoded_resolution_factor = 1208- (OPJ_BOOL(*)(void * p_codec, 1209- OPJ_UINT32 res_factor, 1210- struct opj_event_mgr * p_manager)) opj_j2k_set_decoded_resolution_factor; 1211+ opj_j2k_set_decoded_resolution_factor; 1212 1213 l_codec->m_codec_data.m_decompression.opj_set_decoded_components = 1214- (OPJ_BOOL(*)(void * p_codec, 1215- OPJ_UINT32 numcomps, 1216- const OPJ_UINT32 * comps_indices, 1217- struct opj_event_mgr * p_manager)) opj_j2k_set_decoded_components; 1218+ opj_j2k_set_decoded_components; 1219 1220- l_codec->opj_set_threads = 1221- (OPJ_BOOL(*)(void * p_codec, OPJ_UINT32 num_threads)) opj_j2k_set_threads; 1222+ l_codec->opj_set_threads = opj_j2k_set_threads; 1223 1224 l_codec->m_codec = opj_j2k_create_decompress(); 1225 1226@@ -280,85 +243,47 @@ opj_codec_t* OPJ_CALLCONV opj_create_decompress(OPJ_CODEC_FORMAT p_format) 1227 1228 case OPJ_CODEC_JP2: 1229 /* get a JP2 decoder handle */ 1230- l_codec->opj_dump_codec = (void (*)(void*, OPJ_INT32, FILE*)) jp2_dump; 1231+ l_codec->opj_dump_codec = jp2_dump; 1232 1233- l_codec->opj_get_codec_info = (opj_codestream_info_v2_t* (*)( 1234- void*)) jp2_get_cstr_info; 1235+ l_codec->opj_get_codec_info = jp2_get_cstr_info; 1236 1237- l_codec->opj_get_codec_index = (opj_codestream_index_t* (*)( 1238- void*)) jp2_get_cstr_index; 1239+ l_codec->opj_get_codec_index = jp2_get_cstr_index; 1240 1241- l_codec->m_codec_data.m_decompression.opj_decode = 1242- (OPJ_BOOL(*)(void *, 1243- struct opj_stream_private *, 1244- opj_image_t*, 1245- struct opj_event_mgr *)) opj_jp2_decode; 1246+ l_codec->m_codec_data.m_decompression.opj_decode = opj_jp2_decode; 1247 1248 l_codec->m_codec_data.m_decompression.opj_end_decompress = 1249- (OPJ_BOOL(*)(void *, 1250- struct opj_stream_private *, 1251- struct opj_event_mgr *)) opj_jp2_end_decompress; 1252+ opj_jp2_end_decompress; 1253 1254 l_codec->m_codec_data.m_decompression.opj_read_header = 1255- (OPJ_BOOL(*)(struct opj_stream_private *, 1256- void *, 1257- opj_image_t **, 1258- struct opj_event_mgr *)) opj_jp2_read_header; 1259+ opj_jp2_read_header; 1260 1261 l_codec->m_codec_data.m_decompression.opj_read_tile_header = 1262- (OPJ_BOOL(*)(void *, 1263- OPJ_UINT32*, 1264- OPJ_UINT32*, 1265- OPJ_INT32*, 1266- OPJ_INT32*, 1267- OPJ_INT32 *, 1268- OPJ_INT32 *, 1269- OPJ_UINT32 *, 1270- OPJ_BOOL *, 1271- struct opj_stream_private *, 1272- struct opj_event_mgr *)) opj_jp2_read_tile_header; 1273+ opj_jp2_read_tile_header; 1274 1275 l_codec->m_codec_data.m_decompression.opj_decode_tile_data = 1276- (OPJ_BOOL(*)(void *, 1277- OPJ_UINT32, OPJ_BYTE*, OPJ_UINT32, 1278- struct opj_stream_private *, 1279- struct opj_event_mgr *)) opj_jp2_decode_tile; 1280+ opj_jp2_decode_tile; 1281 1282- l_codec->m_codec_data.m_decompression.opj_destroy = (void (*)( 1283- void *))opj_jp2_destroy; 1284+ l_codec->m_codec_data.m_decompression.opj_destroy = opj_jp2_destroy; 1285 1286 l_codec->m_codec_data.m_decompression.opj_setup_decoder = 1287- (void (*)(void *, opj_dparameters_t *)) opj_jp2_setup_decoder; 1288+ opj_jp2_setup_decoder; 1289 1290 l_codec->m_codec_data.m_decompression.opj_decoder_set_strict_mode = 1291- (void (*)(void *, OPJ_BOOL)) opj_jp2_decoder_set_strict_mode; 1292+ opj_jp2_decoder_set_strict_mode; 1293 1294 l_codec->m_codec_data.m_decompression.opj_set_decode_area = 1295- (OPJ_BOOL(*)(void *, 1296- opj_image_t*, 1297- OPJ_INT32, OPJ_INT32, OPJ_INT32, OPJ_INT32, 1298- struct opj_event_mgr *)) opj_jp2_set_decode_area; 1299+ opj_jp2_set_decode_area; 1300 1301 l_codec->m_codec_data.m_decompression.opj_get_decoded_tile = 1302- (OPJ_BOOL(*)(void *p_codec, 1303- opj_stream_private_t *p_cio, 1304- opj_image_t *p_image, 1305- struct opj_event_mgr * p_manager, 1306- OPJ_UINT32 tile_index)) opj_jp2_get_tile; 1307+ opj_jp2_get_tile; 1308 1309 l_codec->m_codec_data.m_decompression.opj_set_decoded_resolution_factor = 1310- (OPJ_BOOL(*)(void * p_codec, 1311- OPJ_UINT32 res_factor, 1312- opj_event_mgr_t * p_manager)) opj_jp2_set_decoded_resolution_factor; 1313+ opj_jp2_set_decoded_resolution_factor; 1314 1315 l_codec->m_codec_data.m_decompression.opj_set_decoded_components = 1316- (OPJ_BOOL(*)(void * p_codec, 1317- OPJ_UINT32 numcomps, 1318- const OPJ_UINT32 * comps_indices, 1319- struct opj_event_mgr * p_manager)) opj_jp2_set_decoded_components; 1320+ opj_jp2_set_decoded_components; 1321 1322- l_codec->opj_set_threads = 1323- (OPJ_BOOL(*)(void * p_codec, OPJ_UINT32 num_threads)) opj_jp2_set_threads; 1324+ l_codec->opj_set_threads = opj_jp2_set_threads; 1325 1326 l_codec->m_codec = opj_jp2_create(OPJ_TRUE); 1327 1328@@ -662,41 +587,25 @@ opj_codec_t* OPJ_CALLCONV opj_create_compress(OPJ_CODEC_FORMAT p_format) 1329 1330 switch (p_format) { 1331 case OPJ_CODEC_J2K: 1332- l_codec->m_codec_data.m_compression.opj_encode = (OPJ_BOOL(*)(void *, 1333- struct opj_stream_private *, 1334- struct opj_event_mgr *)) opj_j2k_encode; 1335- 1336- l_codec->m_codec_data.m_compression.opj_end_compress = (OPJ_BOOL(*)(void *, 1337- struct opj_stream_private *, 1338- struct opj_event_mgr *)) opj_j2k_end_compress; 1339- 1340- l_codec->m_codec_data.m_compression.opj_start_compress = (OPJ_BOOL(*)(void *, 1341- struct opj_stream_private *, 1342- struct opj_image *, 1343- struct opj_event_mgr *)) opj_j2k_start_compress; 1344- 1345- l_codec->m_codec_data.m_compression.opj_write_tile = (OPJ_BOOL(*)(void *, 1346- OPJ_UINT32, 1347- OPJ_BYTE*, 1348- OPJ_UINT32, 1349- struct opj_stream_private *, 1350- struct opj_event_mgr *)) opj_j2k_write_tile; 1351- 1352- l_codec->m_codec_data.m_compression.opj_destroy = (void (*)( 1353- void *)) opj_j2k_destroy; 1354- 1355- l_codec->m_codec_data.m_compression.opj_setup_encoder = (OPJ_BOOL(*)(void *, 1356- opj_cparameters_t *, 1357- struct opj_image *, 1358- struct opj_event_mgr *)) opj_j2k_setup_encoder; 1359- 1360- l_codec->m_codec_data.m_compression.opj_encoder_set_extra_options = (OPJ_BOOL( 1361- *)(void *, 1362- const char* const*, 1363- struct opj_event_mgr *)) opj_j2k_encoder_set_extra_options; 1364- 1365- l_codec->opj_set_threads = 1366- (OPJ_BOOL(*)(void * p_codec, OPJ_UINT32 num_threads)) opj_j2k_set_threads; 1367+ l_codec->m_codec_data.m_compression.opj_encode = opj_j2k_encode; 1368+ 1369+ l_codec->m_codec_data.m_compression.opj_end_compress = 1370+ opj_j2k_end_compress; 1371+ 1372+ l_codec->m_codec_data.m_compression.opj_start_compress = 1373+ opj_j2k_start_compress; 1374+ 1375+ l_codec->m_codec_data.m_compression.opj_write_tile = opj_j2k_write_tile; 1376+ 1377+ l_codec->m_codec_data.m_compression.opj_destroy = opj_j2k_destroy; 1378+ 1379+ l_codec->m_codec_data.m_compression.opj_setup_encoder = 1380+ opj_j2k_setup_encoder; 1381+ 1382+ l_codec->m_codec_data.m_compression.opj_encoder_set_extra_options = 1383+ opj_j2k_encoder_set_extra_options; 1384+ 1385+ l_codec->opj_set_threads = opj_j2k_set_threads; 1386 1387 l_codec->m_codec = opj_j2k_create_compress(); 1388 if (! l_codec->m_codec) { 1389@@ -708,41 +617,25 @@ opj_codec_t* OPJ_CALLCONV opj_create_compress(OPJ_CODEC_FORMAT p_format) 1390 1391 case OPJ_CODEC_JP2: 1392 /* get a JP2 decoder handle */ 1393- l_codec->m_codec_data.m_compression.opj_encode = (OPJ_BOOL(*)(void *, 1394- struct opj_stream_private *, 1395- struct opj_event_mgr *)) opj_jp2_encode; 1396- 1397- l_codec->m_codec_data.m_compression.opj_end_compress = (OPJ_BOOL(*)(void *, 1398- struct opj_stream_private *, 1399- struct opj_event_mgr *)) opj_jp2_end_compress; 1400- 1401- l_codec->m_codec_data.m_compression.opj_start_compress = (OPJ_BOOL(*)(void *, 1402- struct opj_stream_private *, 1403- struct opj_image *, 1404- struct opj_event_mgr *)) opj_jp2_start_compress; 1405- 1406- l_codec->m_codec_data.m_compression.opj_write_tile = (OPJ_BOOL(*)(void *, 1407- OPJ_UINT32, 1408- OPJ_BYTE*, 1409- OPJ_UINT32, 1410- struct opj_stream_private *, 1411- struct opj_event_mgr *)) opj_jp2_write_tile; 1412- 1413- l_codec->m_codec_data.m_compression.opj_destroy = (void (*)( 1414- void *)) opj_jp2_destroy; 1415- 1416- l_codec->m_codec_data.m_compression.opj_setup_encoder = (OPJ_BOOL(*)(void *, 1417- opj_cparameters_t *, 1418- struct opj_image *, 1419- struct opj_event_mgr *)) opj_jp2_setup_encoder; 1420- 1421- l_codec->m_codec_data.m_compression.opj_encoder_set_extra_options = (OPJ_BOOL( 1422- *)(void *, 1423- const char* const*, 1424- struct opj_event_mgr *)) opj_jp2_encoder_set_extra_options; 1425- 1426- l_codec->opj_set_threads = 1427- (OPJ_BOOL(*)(void * p_codec, OPJ_UINT32 num_threads)) opj_jp2_set_threads; 1428+ l_codec->m_codec_data.m_compression.opj_encode = opj_jp2_encode; 1429+ 1430+ l_codec->m_codec_data.m_compression.opj_end_compress = 1431+ opj_jp2_end_compress; 1432+ 1433+ l_codec->m_codec_data.m_compression.opj_start_compress = 1434+ opj_jp2_start_compress; 1435+ 1436+ l_codec->m_codec_data.m_compression.opj_write_tile = opj_jp2_write_tile; 1437+ 1438+ l_codec->m_codec_data.m_compression.opj_destroy = opj_jp2_destroy; 1439+ 1440+ l_codec->m_codec_data.m_compression.opj_setup_encoder = 1441+ opj_jp2_setup_encoder; 1442+ 1443+ l_codec->m_codec_data.m_compression.opj_encoder_set_extra_options = 1444+ opj_jp2_encoder_set_extra_options; 1445+ 1446+ l_codec->opj_set_threads = opj_jp2_set_threads; 1447 1448 l_codec->m_codec = opj_jp2_create(OPJ_FALSE); 1449 if (! l_codec->m_codec) { 1450