Update openjpeg

core/src/fxcodec/fx_libopenjpeg/libopenjpeg20/pi.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) 2002-2014, Universite catholique de Louvain (UCL), Belgium
  * Copyright (c) 2002-2014, Professor Benoit Macq
  * Copyright (c) 2001-2003, David Janssens
  * Copyright (c) 2002-2003, Yannick Verschueren
@@ skipping 797 matching lines @@
 
         /* initializations*/
         tcp = &cp->tcps[tileno];
         l_poc_bound = tcp->numpocs+1;
 
         /* memory allocations*/
         l_pi = (opj_pi_iterator_t*) opj_calloc((l_poc_bound), sizeof(opj_pi_iterator_t));
         if (!l_pi) {
                 return NULL;
         }
-        memset(l_pi,0,l_poc_bound * sizeof(opj_pi_iterator_t));
 
         l_current_pi = l_pi;
         for (pino = 0; pino < l_poc_bound ; ++pino) {
 
                 l_current_pi->comps = (opj_pi_comp_t*) opj_calloc(image->numcomps, sizeof(opj_pi_comp_t));
                 if (! l_current_pi->comps) {
                         opj_pi_destroy(l_pi, l_poc_bound);
                         return NULL;
                 }
 
                 l_current_pi->numcomps = image->numcomps;
-                memset(l_current_pi->comps,0,image->numcomps * sizeof(opj_pi_comp_t));
 
                 for (compno = 0; compno < image->numcomps; ++compno) {
                         opj_pi_comp_t *comp = &l_current_pi->comps[compno];
 
                         tccp = &tcp->tccps[compno];
 
-                        comp->resolutions = (opj_pi_resolution_t*) opj_malloc(tccp->numresolutions * sizeof(opj_pi_resolution_t));
+                        comp->resolutions = (opj_pi_resolution_t*) opj_calloc(tccp->numresolutions, sizeof(opj_pi_resolution_t));
                         if (!comp->resolutions) {
                                 opj_pi_destroy(l_pi, l_poc_bound);
                                 return 00;
                         }
 
                         comp->numresolutions = tccp->numresolutions;
-                        memset(comp->resolutions,0,tccp->numresolutions * sizeof(opj_pi_resolution_t));
                 }
                 ++l_current_pi;
         }
         return l_pi;
 }
 
 void opj_pi_update_encode_poc_and_final (   opj_cp_t *p_cp,
                                             OPJ_UINT32 p_tileno,
                                             OPJ_INT32 p_tx0,
                                             OPJ_INT32 p_tx1,
@@ skipping 246 matching lines @@
                                             return OPJ_TRUE;
                                     }else{
                                             return OPJ_FALSE;
                                     }
                             }else{
                                     return OPJ_TRUE;
                             }
                             break;
                     case 'P':
                             switch(tcp->prg){
-                                    case OPJ_LRCP||OPJ_RLCP:
+                    case OPJ_LRCP: // fall through
+                    case OPJ_RLCP:
                                             if(tcp->prc_t == tcp->prcE){
                                                     if(opj_pi_check_next_level(i-1,cp,tileno,pino,prog)){
                                                             return OPJ_TRUE;
                                                     }else{
                                                             return OPJ_FALSE;
                                                     }
                                             }else{
                                                     return OPJ_TRUE;
                                             }
                                             break;
@@ skipping 113 matching lines @@
         /* memory allocation for include */
         l_current_pi->include = (OPJ_INT16*) opj_calloc((l_tcp->numlayers +1) * l_step_l, sizeof(OPJ_INT16));
         if
                 (!l_current_pi->include)
         {
                 opj_free(l_tmp_data);
                 opj_free(l_tmp_ptr);
                 opj_pi_destroy(l_pi, l_bound);
                 return 00;
         }
-        memset(l_current_pi->include,0, (l_tcp->numlayers + 1) * l_step_l* sizeof(OPJ_INT16));
 
         /* special treatment for the first packet iterator */
         l_current_comp = l_current_pi->comps;
         l_img_comp = p_image->comps;
         l_tccp = l_tcp->tccps;
 
         l_current_pi->tx0 = l_tx0;
         l_current_pi->ty0 = l_ty0;
         l_current_pi->tx1 = l_tx1;
         l_current_pi->ty1 = l_ty1;
@@ skipping 176 matching lines @@
         l_current_pi = l_pi;
 
         /* memory allocation for include*/
         l_current_pi->include = (OPJ_INT16*) opj_calloc(l_tcp->numlayers * l_step_l, sizeof(OPJ_INT16));
         if (!l_current_pi->include) {
                 opj_free(l_tmp_data);
                 opj_free(l_tmp_ptr);
                 opj_pi_destroy(l_pi, l_bound);
                 return 00;
         }
-        memset(l_current_pi->include,0,l_tcp->numlayers * l_step_l* sizeof(OPJ_INT16));
 
         /* special treatment for the first packet iterator*/
         l_current_comp = l_current_pi->comps;
         l_img_comp = p_image->comps;
         l_tccp = l_tcp->tccps;
         l_current_pi->tx0 = l_tx0;
         l_current_pi->ty0 = l_ty0;
         l_current_pi->tx1 = l_tx1;
         l_current_pi->ty1 = l_ty1;
         l_current_pi->dx = l_dx_min;
@@ skipping 65 matching lines @@
                 /* special treatment*/
                 l_current_pi->include = (l_current_pi-1)->include;
                 ++l_current_pi;
         }
 
         opj_free(l_tmp_data);
         l_tmp_data = 00;
         opj_free(l_tmp_ptr);
         l_tmp_ptr = 00;
 
-        if (l_tcp->POC && ( p_cp->m_specific_param.m_enc.m_cinema || p_t2_mode == FINAL_PASS)) {
+    if (l_tcp->POC && (OPJ_IS_CINEMA(p_cp->rsiz) || p_t2_mode == FINAL_PASS)) {
                 opj_pi_update_encode_poc_and_final(p_cp,p_tile_no,l_tx0,l_tx1,l_ty0,l_ty1,l_max_prec,l_max_res,l_dx_min,l_dy_min);
         }
         else {
                 opj_pi_update_encode_not_poc(p_cp,p_image->numcomps,p_tile_no,l_tx0,l_tx1,l_ty0,l_ty1,l_max_prec,l_max_res,l_dx_min,l_dy_min);
         }
 
         return l_pi;
 }
 
 void opj_pi_create_encode(      opj_pi_iterator_t *pi,
                                                         opj_cp_t *cp,
                                                         OPJ_UINT32 tileno,
                                                         OPJ_UINT32 pino,
                                                         OPJ_UINT32 tpnum,
                                                         OPJ_INT32 tppos,
                                                         J2K_T2_MODE t2_mode)
 {
         const OPJ_CHAR *prog;
         OPJ_INT32 i;
         OPJ_UINT32 incr_top=1,resetX=0;
         opj_tcp_t *tcps =&cp->tcps[tileno];
         opj_poc_t *tcp= &tcps->pocs[pino];
 
         prog = opj_j2k_convert_progression_order(tcp->prg);
 
         pi[pino].first = 1;
         pi[pino].poc.prg = tcp->prg;
 
-        if(!(cp->m_specific_param.m_enc.m_tp_on && ((!cp->m_specific_param.m_enc.m_cinema && (t2_mode == FINAL_PASS)) || cp->m_specific_param.m_enc.m_cinema))){
+    if(!(cp->m_specific_param.m_enc.m_tp_on && ((!OPJ_IS_CINEMA(cp->rsiz) && (t2_mode == FINAL_PASS)) || OPJ_IS_CINEMA(cp->rsiz)))){
                 pi[pino].poc.resno0 = tcp->resS;
                 pi[pino].poc.resno1 = tcp->resE;
                 pi[pino].poc.compno0 = tcp->compS;
                 pi[pino].poc.compno1 = tcp->compE;
                 pi[pino].poc.layno0 = tcp->layS;
                 pi[pino].poc.layno1 = tcp->layE;
                 pi[pino].poc.precno0 = tcp->prcS;
                 pi[pino].poc.precno1 = tcp->prcE;
                 pi[pino].poc.tx0 = (OPJ_INT32)tcp->txS;
                 pi[pino].poc.ty0 = (OPJ_INT32)tcp->tyS;
@@ skipping 299 matching lines @@
                 case OPJ_PCRL:
                         return opj_pi_next_pcrl(pi);
                 case OPJ_CPRL:
                         return opj_pi_next_cprl(pi);
                 case OPJ_PROG_UNKNOWN:
                         return OPJ_FALSE;
         }
         
         return OPJ_FALSE;
 }