Update openjpeg

core/src/fxcodec/fx_libopenjpeg/libopenjpeg20/openjpeg.c

 /*
  * The copyright in this software is being made available under the 2-clauses 
  * BSD License, included below. This software may be subject to other third 
  * party and contributor rights, including patent rights, and no such rights
  * are granted under this license.
  *
  * Copyright (c) 2005, Herve Drolon, FreeImage Team
  * Copyright (c) 2008, 2011-2012, Centre National d'Etudes Spatiales (CNES), FR 
  * Copyright (c) 2012, CS Systemes d'Information, France
  * All rights reserved.
@@ skipping 114 matching lines @@
                 return OPJ_FALSE;
         }
 
         return OPJ_TRUE;
 }
 
 /* ---------------------------------------------------------------------- */
 #ifdef _WIN32
 #ifndef OPJ_STATIC
 BOOL APIENTRY
-DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
+DllMain(HINSTANCE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
 
         OPJ_ARG_NOT_USED(lpReserved);
         OPJ_ARG_NOT_USED(hModule);
 
         switch (ul_reason_for_call) {
                 case DLL_PROCESS_ATTACH :
                         break;
                 case DLL_PROCESS_DETACH :
                         break;
                 case DLL_THREAD_ATTACH :
@@ skipping 16 matching lines @@
 /* DECOMPRESSION FUNCTIONS*/
 
 opj_codec_t* OPJ_CALLCONV opj_create_decompress(OPJ_CODEC_FORMAT p_format)
 {
         opj_codec_private_t *l_codec = 00;
 
         l_codec = (opj_codec_private_t*) opj_calloc(1, sizeof(opj_codec_private_t));
         if (!l_codec){
                 return 00;
         }
-        memset(l_codec, 0, sizeof(opj_codec_private_t));
 
         l_codec->is_decompressor = 1;
 
         switch (p_format) {
                 case OPJ_CODEC_J2K:
                         l_codec->opj_dump_codec = (void (*) (void*, OPJ_INT32, FILE*)) j2k_dump;
 
                         l_codec->opj_get_codec_info = (opj_codestream_info_v2_t* (*) (void*) ) j2k_get_cstr_info;
 
                         l_codec->opj_get_codec_index = (opj_codestream_index_t* (*) (void*) ) j2k_get_cstr_index;
@@ skipping 356 matching lines @@
 /* COMPRESSION FUNCTIONS*/
 
 opj_codec_t* OPJ_CALLCONV opj_create_compress(OPJ_CODEC_FORMAT p_format)
 {
         opj_codec_private_t *l_codec = 00;
 
         l_codec = (opj_codec_private_t*)opj_calloc(1, sizeof(opj_codec_private_t));
         if (!l_codec) {
                 return 00;
         }
-        memset(l_codec, 0, sizeof(opj_codec_private_t));
         
         l_codec->is_decompressor = 0;
 
         switch(p_format) {
                 case OPJ_CODEC_J2K:
                         l_codec->m_codec_data.m_compression.opj_encode = (OPJ_BOOL (*) (void *,
                                                                                                                                                         struct opj_stream_private *,
                                                                                                                                                         struct opj_event_mgr * )) opj_j2k_encode;
 
                         l_codec->m_codec_data.m_compression.opj_end_compress = (OPJ_BOOL (*) (  void *,
                                                                                                                                                                         struct opj_stream_private *,
                                                                                                                                                                         struct opj_event_mgr *)) opj_j2k_end_compress;
 
                         l_codec->m_codec_data.m_compression.opj_start_compress = (OPJ_BOOL (*) (void *,
                                                                                                                                                                         struct opj_stream_private *,
                                                                                                                                                                         struct opj_image * ,
                                                                                                                                                                         struct opj_event_mgr *)) opj_j2k_start_compress;
 
                         l_codec->m_codec_data.m_compression.opj_write_tile = (OPJ_BOOL (*) (void *,
                                                                                                                                                                 OPJ_UINT32,
                                                                                                                                                                 OPJ_BYTE*,
                                                                                                                                                                 OPJ_UINT32,
                                                                                                                                                                 struct opj_stream_private *,
                                                                                                                                                                 struct opj_event_mgr *) ) opj_j2k_write_tile;
 
                         l_codec->m_codec_data.m_compression.opj_destroy = (void (*) (void *)) opj_j2k_destroy;
 
-                        l_codec->m_codec_data.m_compression.opj_setup_encoder = (void (*) (     void *,
+                        l_codec->m_codec_data.m_compression.opj_setup_encoder = (OPJ_BOOL (*) ( void *,
                                                                                                                                                                 opj_cparameters_t *,
                                                                                                                                                                 struct opj_image *,
                                                                                                                                                                 struct opj_event_mgr * )) opj_j2k_setup_encoder;
 
                         l_codec->m_codec = opj_j2k_create_compress();
                         if (! l_codec->m_codec) {
                                 opj_free(l_codec);
                                 return 00;
                         }
 
@@ skipping 16 matching lines @@
 
                         l_codec->m_codec_data.m_compression.opj_write_tile = (OPJ_BOOL (*) (void *,
                                                                                                                                                                 OPJ_UINT32,
                                                                                                                                                                 OPJ_BYTE*,
                                                                                                                                                                 OPJ_UINT32,
                                                                                                                                                                 struct opj_stream_private *,
                                                                                                                                                                 struct opj_event_mgr *)) opj_jp2_write_tile;
 
                         l_codec->m_codec_data.m_compression.opj_destroy = (void (*) (void *)) opj_jp2_destroy;
 
-                        l_codec->m_codec_data.m_compression.opj_setup_encoder = (void (*) (     void *,
+                        l_codec->m_codec_data.m_compression.opj_setup_encoder = (OPJ_BOOL (*) ( void *,
                                                                                                                                                                 opj_cparameters_t *,
                                                                                                                                                                 struct opj_image *,
                                                                                                                                                                 struct opj_event_mgr * )) opj_jp2_setup_encoder;
 
                         l_codec->m_codec = opj_jp2_create(OPJ_FALSE);
                         if (! l_codec->m_codec) {
                                 opj_free(l_codec);
                                 return 00;
                         }
 
                         break;
 
                 case OPJ_CODEC_UNKNOWN:
                 case OPJ_CODEC_JPT:
                 default:
                         opj_free(l_codec);
                         return 00;
         }
 
         opj_set_default_event_handler(&(l_codec->m_event_mgr));
         return (opj_codec_t*) l_codec;
 }
 
 void OPJ_CALLCONV opj_set_default_encoder_parameters(opj_cparameters_t *parameters) {
         if(parameters) {
                 memset(parameters, 0, sizeof(opj_cparameters_t));
                 /* default coding parameters */
-                parameters->cp_cinema = OPJ_OFF; 
+        parameters->cp_cinema = OPJ_OFF; /* DEPRECATED */
+        parameters->rsiz = OPJ_PROFILE_NONE;
                 parameters->max_comp_size = 0;
                 parameters->numresolution = 6;
-                parameters->cp_rsiz = OPJ_STD_RSIZ;
+        parameters->cp_rsiz = OPJ_STD_RSIZ; /* DEPRECATED */
                 parameters->cblockw_init = 64;
                 parameters->cblockh_init = 64;
                 parameters->prog_order = OPJ_LRCP;
                 parameters->roi_compno = -1;            /* no ROI */
                 parameters->subsampling_dx = 1;
                 parameters->subsampling_dy = 1;
                 parameters->tp_on = 0;
                 parameters->decod_format = -1;
                 parameters->cod_format = -1;
                 parameters->tcp_rates[0] = 0;   
@@ skipping 130 matching lines @@
 
 OPJ_BOOL OPJ_CALLCONV opj_set_MCT(opj_cparameters_t *parameters,
                                   OPJ_FLOAT32 * pEncodingMatrix,
                                   OPJ_INT32 * p_dc_shift,OPJ_UINT32 pNbComp)
 {
         OPJ_UINT32 l_matrix_size = pNbComp * pNbComp * (OPJ_UINT32)sizeof(OPJ_FLOAT32);
         OPJ_UINT32 l_dc_shift_size = pNbComp * (OPJ_UINT32)sizeof(OPJ_INT32);
         OPJ_UINT32 l_mct_total_size = l_matrix_size + l_dc_shift_size;
 
         /* add MCT capability */
-        OPJ_INT32 rsiz = (OPJ_INT32)parameters->cp_rsiz | (OPJ_INT32)OPJ_MCT;
-        parameters->cp_rsiz = (OPJ_RSIZ_CAPABILITIES)rsiz;
+    if (OPJ_IS_PART2(parameters->rsiz)) {
+        parameters->rsiz |= OPJ_EXTENSION_MCT;
+    } else {
+        parameters->rsiz = ((OPJ_PROFILE_PART2) | (OPJ_EXTENSION_MCT));
+    }
         parameters->irreversible = 1;
 
         /* use array based MCT */
         parameters->tcp_mct = 2;
         parameters->mct_data = opj_malloc(l_mct_total_size);
         if (! parameters->mct_data) {
                 return OPJ_FALSE;
         }
 
         memcpy(parameters->mct_data,pEncodingMatrix,l_matrix_size);
@@ skipping 102 matching lines @@
 }
 
 void OPJ_CALLCONV opj_destroy_cstr_index(opj_codestream_index_t **p_cstr_index)
 {
         if (*p_cstr_index){
                 j2k_destroy_cstr_index(*p_cstr_index);
                 (*p_cstr_index) = NULL;
         }
 }
 
-opj_stream_t* OPJ_CALLCONV opj_stream_create_default_file_stream_v3 (const char *fname, OPJ_BOOL p_is_read_stream)
+opj_stream_t* OPJ_CALLCONV opj_stream_create_default_file_stream (const char *fname, OPJ_BOOL p_is_read_stream)
 {
-    return opj_stream_create_file_stream_v3(fname, OPJ_J2K_STREAM_CHUNK_SIZE, p_is_read_stream);
+    return opj_stream_create_file_stream(fname, OPJ_J2K_STREAM_CHUNK_SIZE, p_is_read_stream);
 }
 
-opj_stream_t* OPJ_CALLCONV opj_stream_create_file_stream_v3 (
+opj_stream_t* OPJ_CALLCONV opj_stream_create_file_stream (
         const char *fname, 
                 OPJ_SIZE_T p_size, 
         OPJ_BOOL p_is_read_stream)
 {
     opj_stream_t* l_stream = 00;
     FILE *p_file;
     const char *mode;
 
     if (! fname) {
         return NULL;
     }
     
     if(p_is_read_stream) mode = "rb"; else mode = "wb";
 
     p_file = fopen(fname, mode);
 
     if (! p_file) {
             return NULL;
     }
 
     l_stream = opj_stream_create(p_size,p_is_read_stream);
     if (! l_stream) {
         fclose(p_file);
         return NULL;
     }
 
-    opj_stream_set_user_data_v3(l_stream, p_file, (opj_stream_free_user_data_fn) fclose);
+    opj_stream_set_user_data(l_stream, p_file, (opj_stream_free_user_data_fn) fclose);
     opj_stream_set_user_data_length(l_stream, opj_get_data_length_from_file(p_file));
     opj_stream_set_read_function(l_stream, (opj_stream_read_fn) opj_read_from_file);
     opj_stream_set_write_function(l_stream, (opj_stream_write_fn) opj_write_from_file);
     opj_stream_set_skip_function(l_stream, (opj_stream_skip_fn) opj_skip_from_file);
     opj_stream_set_seek_function(l_stream, (opj_stream_seek_fn) opj_seek_from_file);
 
     return l_stream;
 }