upgrade openjpeg to commit# cf352af

third_party/libopenjpeg20/tgt.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 27 matching lines @@
  */
 
 #include "opj_includes.h"
 
 /* 
 ==========================================================
    Tag-tree coder interface
 ==========================================================
 */
 
-opj_tgt_tree_t *opj_tgt_create(OPJ_UINT32 numleafsh, OPJ_UINT32 numleafsv) {
+opj_tgt_tree_t *opj_tgt_create(OPJ_UINT32 numleafsh, OPJ_UINT32 numleafsv, opj_event_mgr_t *manager) {
         OPJ_INT32 nplh[32];
         OPJ_INT32 nplv[32];
         opj_tgt_node_t *node = 00;
         opj_tgt_node_t *l_parent_node = 00;
         opj_tgt_node_t *l_parent_node0 = 00;
         opj_tgt_tree_t *tree = 00;
         OPJ_UINT32 i;
         OPJ_INT32  j,k;
         OPJ_UINT32 numlvls;
         OPJ_UINT32 n;
 
         tree = (opj_tgt_tree_t *) opj_calloc(1,sizeof(opj_tgt_tree_t));
         if(!tree) {
-                fprintf(stderr, "ERROR in tgt_create while allocating tree\n");
+                opj_event_msg(manager, EVT_ERROR, "Not enough memory to create Tag-tree\n");
                 return 00;
         }
 
         tree->numleafsh = numleafsh;
         tree->numleafsv = numleafsv;
 
         numlvls = 0;
         nplh[0] = (OPJ_INT32)numleafsh;
         nplv[0] = (OPJ_INT32)numleafsv;
         tree->numnodes = 0;
         do {
                 n = (OPJ_UINT32)(nplh[numlvls] * nplv[numlvls]);
                 nplh[numlvls + 1] = (nplh[numlvls] + 1) / 2;
                 nplv[numlvls + 1] = (nplv[numlvls] + 1) / 2;
                 tree->numnodes += n;
                 ++numlvls;
         } while (n > 1);
 
         /* ADD */
         if (tree->numnodes == 0) {
                 opj_free(tree);
-                fprintf(stderr, "WARNING in tgt_create tree->numnodes == 0, no tree created.\n");
+                opj_event_msg(manager, EVT_WARNING, "tgt_create tree->numnodes == 0, no tree created.\n");
                 return 00;
         }
 
         tree->nodes = (opj_tgt_node_t*) opj_calloc(tree->numnodes, sizeof(opj_tgt_node_t));
         if(!tree->nodes) {
-                fprintf(stderr, "ERROR in tgt_create while allocating node of the tree\n");
+                opj_event_msg(manager, EVT_ERROR, "Not enough memory to create Tag-tree nodes\n");
                 opj_free(tree);
                 return 00;
         }
         tree->nodes_size = tree->numnodes * (OPJ_UINT32)sizeof(opj_tgt_node_t);
 
         node = tree->nodes;
         l_parent_node = &tree->nodes[tree->numleafsh * tree->numleafsv];
         l_parent_node0 = l_parent_node;
 
         for (i = 0; i < numlvls - 1; ++i) {
@@ skipping 22 matching lines @@
 }
 
 /**
  * Reinitialises a tag-tree from an existing one.
  *
  * @param       p_tree                          the tree to reinitialize.
  * @param       p_num_leafs_h           the width of the array of leafs of the tree
  * @param       p_num_leafs_v           the height of the array of leafs of the tree
  * @return      a new tag-tree if successful, NULL otherwise
 */
-opj_tgt_tree_t *opj_tgt_init(opj_tgt_tree_t * p_tree,OPJ_UINT32 p_num_leafs_h, OPJ_UINT32 p_num_leafs_v)
+opj_tgt_tree_t *opj_tgt_init(opj_tgt_tree_t * p_tree,OPJ_UINT32 p_num_leafs_h, OPJ_UINT32 p_num_leafs_v, opj_event_mgr_t *p_manager)
 {
         OPJ_INT32 l_nplh[32];
         OPJ_INT32 l_nplv[32];
         opj_tgt_node_t *l_node = 00;
         opj_tgt_node_t *l_parent_node = 00;
         opj_tgt_node_t *l_parent_node0 = 00;
         OPJ_UINT32 i;
         OPJ_INT32 j,k;
         OPJ_UINT32 l_num_levels;
         OPJ_UINT32 n;
@@ skipping 24 matching lines @@
                 /* ADD */
                 if (p_tree->numnodes == 0) {
                         opj_tgt_destroy(p_tree);
                         return 00;
                 }
                 l_node_size = p_tree->numnodes * (OPJ_UINT32)sizeof(opj_tgt_node_t);
                 
                 if (l_node_size > p_tree->nodes_size) {
                         opj_tgt_node_t* new_nodes = (opj_tgt_node_t*) opj_realloc(p_tree->nodes, l_node_size);
                         if (! new_nodes) {
-                                fprintf(stderr, "ERROR Not enough memory to reinitialize the tag tree\n");
+                                opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to reinitialize the tag tree\n");
                                 opj_tgt_destroy(p_tree);
                                 return 00;
                         }
                         p_tree->nodes = new_nodes;
                         memset(((char *) p_tree->nodes) + p_tree->nodes_size, 0 , l_node_size - p_tree->nodes_size);
                         p_tree->nodes_size = l_node_size;
                 }
                 l_node = p_tree->nodes;
                 l_parent_node = &p_tree->nodes[p_tree->numleafsh * p_tree->numleafsv];
                 l_parent_node0 = l_parent_node;
@@ skipping 137 matching lines @@
                 }
                 node->low = low;
                 if (stkptr == stk) {
                         break;
                 }
                 node = *--stkptr;
         }
         
         return (node->value < threshold) ? 1 : 0;
 }