update openjpeg to r2911

core/src/fxcodec/fx_libopenjpeg/libopenjpeg20/tcd.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 658 matching lines @@
         /* testcase 1888.pdf.asan.35.988 */ \
         if (l_tccp->numresolutions == 0) { \
             fprintf(stderr, "tiles require at least one resolution\n"); \
             return OPJ_FALSE; \
         } \
         /*fprintf(stderr, "Tile border = %d,%d,%d,%d\n", l_tile->x0, l_tile->y0,l_tile->x1,l_tile->y1);*/                                                                                                         \
                                                                     \
         /*tile->numcomps = image->numcomps; */                      \
         for(compno = 0; compno < l_tile->numcomps; ++compno) {      \
                 /*fprintf(stderr, "compno = %d/%d\n", compno, l_tile->numcomps);*/                                                                                                                                \
-                                                                    \
+                l_image_comp->resno_decoded = 0;                                                    \
                 /* border of each l_tile component (global) */      \
                 l_tilec->x0 = opj_int_ceildiv(l_tile->x0, (OPJ_INT32)l_image_comp->dx);                                                                                                                                          \
                 l_tilec->y0 = opj_int_ceildiv(l_tile->y0, (OPJ_INT32)l_image_comp->dy);                                                                                                                                          \
                 l_tilec->x1 = opj_int_ceildiv(l_tile->x1, (OPJ_INT32)l_image_comp->dx);                                                                                                                                          \
                 l_tilec->y1 = opj_int_ceildiv(l_tile->y1, (OPJ_INT32)l_image_comp->dy);                                                                                                                                          \
                 /*fprintf(stderr, "\tTile compo border = %d,%d,%d,%d\n", l_tilec->x0, l_tilec->y0,l_tilec->x1,l_tilec->y1);*/                                                                                     \
                                                                     \
                 l_data_size = (OPJ_UINT32)(l_tilec->x1 - l_tilec->x0)           \
                 * (OPJ_UINT32)(l_tilec->y1 - l_tilec->y0) * (OPJ_UINT32)sizeof(OPJ_UINT32 );\
                 l_tilec->numresolutions = l_tccp->numresolutions;   \
@@ skipping 273 matching lines @@
                                         }                                                                                                                                                                         \
                                                                                                                                                                                                                   \
                                         l_code_block = l_current_precinct->cblks.ELEMENT;                                                                                                                         \
                                                                                                                                                                                                                   \
                                         for (cblkno = 0; cblkno < l_nb_code_blocks; ++cblkno) {                                                                                                                   \
                                                 OPJ_INT32 cblkxstart = tlcblkxstart + (OPJ_INT32)(cblkno % l_current_precinct->cw) * (1 << cblkwidthexpn);                                                                   \
                                                 OPJ_INT32 cblkystart = tlcblkystart + (OPJ_INT32)(cblkno / l_current_precinct->cw) * (1 << cblkheightexpn);                                                                  \
                                                 OPJ_INT32 cblkxend = cblkxstart + (1 << cblkwidthexpn);                                                                                                           \
                                                 OPJ_INT32 cblkyend = cblkystart + (1 << cblkheightexpn);                                                                                                          \
                                                                                                                                                                                                                   \
+                                                if (! FUNCTION_ELEMENT(l_code_block)) {                                                                                                                           \
+                                                        return OPJ_FALSE;                                                                                                                                         \
+                                                }                                                                                                                                                                 \
                                                 /* code-block size (global) */                                                                                                                                    \
                                                 l_code_block->x0 = opj_int_max(cblkxstart, l_current_precinct->x0);                                                                                                   \
                                                 l_code_block->y0 = opj_int_max(cblkystart, l_current_precinct->y0);                                                                                                   \
                                                 l_code_block->x1 = opj_int_min(cblkxend, l_current_precinct->x1);                                                                                                     \
                                                 l_code_block->y1 = opj_int_min(cblkyend, l_current_precinct->y1);                                                                                                     \
-                                                                                                                                                                                                                  \
-                                                if (! FUNCTION_ELEMENT(l_code_block)) {                                                                                                                           \
-                                                        return OPJ_FALSE;                                                                                                                                         \
-                                                }                                                                                                                                                                 \
                                                 ++l_code_block;                                                                                                                                                   \
                                         }                                                                                                                                                                         \
                                         ++l_current_precinct;                                                                                                                                                     \
                                 } /* precno */                                                                                                                                                                    \
                                 ++l_band;                                                                                                                                                                         \
                                 ++l_step_size;                                                                                                                                                                    \
                         } /* bandno */                                                                                                                                                                            \
                         ++l_res;                                                                                                                                                                                  \
                         --l_level_no;                                                                                                                                                                             \
                 } /* resno */                                                                                                                                                                                     \
@@ skipping 55 matching lines @@
                 /*fprintf(stderr, "Allocate 8192 elements of code_block->data\n");*/
 
                 p_code_block->segs = (opj_tcd_seg_t *) opj_calloc(OPJ_J2K_DEFAULT_NB_SEGS,sizeof(opj_tcd_seg_t));
                 if (! p_code_block->segs) {
                         return OPJ_FALSE;
                 }
                 /*fprintf(stderr, "Allocate %d elements of code_block->data\n", OPJ_J2K_DEFAULT_NB_SEGS * sizeof(opj_tcd_seg_t));*/
 
                 p_code_block->m_current_max_segs = OPJ_J2K_DEFAULT_NB_SEGS;
                 /*fprintf(stderr, "m_current_max_segs of code_block->data = %d\n", p_code_block->m_current_max_segs);*/
-        }
-        /* TODO */
-        /*p_code_block->numsegs = 0; */
+        } else {
+                                        /* sanitize */
+                                        OPJ_BYTE* l_data = p_code_block->data;
+                                        OPJ_UINT32 l_data_max_size = p_code_block->data_max_size;
+                                        opj_tcd_seg_t * l_segs = p_code_block->segs;
+                                        OPJ_UINT32 l_current_max_segs = p_code_block->m_current_max_segs;
+
+                                        memset(p_code_block, 0, sizeof(opj_tcd_cblk_dec_t));

[Tom Sepez, 2014/10/22 19:03:06]

How do we know that p_code_block can accomodate sizeof(...) bytes?  Is there an
early check against, say, p_code_block->data_max_size?

[Bo Xu, 2014/10/22 22:29:03]

I am asking openjpeg team to cc you in their bug tracker, so we can raise these
questions and upstream to them.

+                                        p_code_block->data = l_data;
+                                        p_code_block->data_max_size = l_data_max_size;
+                                        p_code_block->segs = l_segs;
+                                        p_code_block->m_current_max_segs = l_current_max_segs;
+                                }
 
         return OPJ_TRUE;
 }
 
 OPJ_UINT32 opj_tcd_get_decoded_tile_size ( opj_tcd_t *p_tcd )
 {
         OPJ_UINT32 i;
         OPJ_UINT32 l_data_size = 0;
         opj_image_comp_t * l_img_comp = 00;
         opj_tcd_tilecomp_t * l_tile_comp = 00;
@@ skipping 1044 matching lines @@
                                 }
                                 break;
                 }
 
                 ++l_img_comp;
                 ++l_tilec;
         }
 
         return OPJ_TRUE;
 }