* Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
* Copyright (c) 2005, Herve Drolon, FreeImage Team
+ * Copyright (c) 2008;2011-2012, Centre National d'Etudes Spatiales (CNES), France
+ * Copyright (c) 2012, CS Systemes d'Information, France
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
==========================================================
*/
-opj_tgt_tree_t *tgt_create(OPJ_UINT32 numleafsh, OPJ_UINT32 numleafsv) {
+opj_tgt_tree_t *opj_tgt_create(OPJ_UINT32 numleafsh, OPJ_UINT32 numleafsv) {
OPJ_INT32 nplh[32];
OPJ_INT32 nplv[32];
opj_tgt_node_t *node = 00;
tree = (opj_tgt_tree_t *) opj_malloc(sizeof(opj_tgt_tree_t));
if(!tree) {
- fprintf(stderr, "ERROR in tgt_create_v2 while allocating tree\n");
+ fprintf(stderr, "ERROR in tgt_create while allocating tree\n");
return 00;
}
memset(tree,0,sizeof(opj_tgt_tree_t));
tree->numleafsv = numleafsv;
numlvls = 0;
- nplh[0] = numleafsh;
- nplv[0] = numleafsv;
+ nplh[0] = (OPJ_INT32)numleafsh;
+ nplv[0] = (OPJ_INT32)numleafsv;
tree->numnodes = 0;
do {
- n = nplh[numlvls] * nplv[numlvls];
+ n = (OPJ_UINT32)(nplh[numlvls] * nplv[numlvls]);
nplh[numlvls + 1] = (nplh[numlvls] + 1) / 2;
nplv[numlvls + 1] = (nplv[numlvls] + 1) / 2;
tree->numnodes += n;
/* ADD */
if (tree->numnodes == 0) {
opj_free(tree);
- fprintf(stderr, "WARNING in tgt_create_v2 tree->numnodes == 0, no tree created.\n");
+ fprintf(stderr, "WARNING in 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_v2 while allocating node of the tree\n");
+ fprintf(stderr, "ERROR in tgt_create while allocating node of the tree\n");
opj_free(tree);
return 00;
}
memset(tree->nodes,0,tree->numnodes * sizeof(opj_tgt_node_t));
- tree->nodes_size = tree->numnodes * sizeof(opj_tgt_node_t);
+ tree->nodes_size = tree->numnodes * (OPJ_UINT32)sizeof(opj_tgt_node_t);
node = tree->nodes;
l_parent_node = &tree->nodes[tree->numleafsh * tree->numleafsv];
}
}
node->parent = 0;
- tgt_reset(tree);
+ opj_tgt_reset(tree);
return tree;
}
/**
- * Reinitialises a tag-tree from an exixting one. (V2 framevork)
+ * 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 *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_INT32 l_nplh[32];
OPJ_INT32 l_nplv[32];
OPJ_UINT32 n;
OPJ_UINT32 l_node_size;
- if
- (! p_tree)
- {
+ if (! p_tree){
return 00;
}
- if
- ((p_tree->numleafsh != p_num_leafs_h) || (p_tree->numleafsv != p_num_leafs_v))
- {
+
+ if ((p_tree->numleafsh != p_num_leafs_h) || (p_tree->numleafsv != p_num_leafs_v)) {
p_tree->numleafsh = p_num_leafs_h;
p_tree->numleafsv = p_num_leafs_v;
l_num_levels = 0;
- l_nplh[0] = p_num_leafs_h;
- l_nplv[0] = p_num_leafs_v;
+ l_nplh[0] = (OPJ_INT32)p_num_leafs_h;
+ l_nplv[0] = (OPJ_INT32)p_num_leafs_v;
p_tree->numnodes = 0;
do
{
- n = l_nplh[l_num_levels] * l_nplv[l_num_levels];
+ n = (OPJ_UINT32)(l_nplh[l_num_levels] * l_nplv[l_num_levels]);
l_nplh[l_num_levels + 1] = (l_nplh[l_num_levels] + 1) / 2;
l_nplv[l_num_levels + 1] = (l_nplv[l_num_levels] + 1) / 2;
p_tree->numnodes += n;
while (n > 1);
/* ADD */
- if
- (p_tree->numnodes == 0)
- {
- tgt_destroy(p_tree);
+ if (p_tree->numnodes == 0) {
+ opj_tgt_destroy(p_tree);
return 00;
}
- l_node_size = p_tree->numnodes * sizeof(opj_tgt_node_t);
- if
- (l_node_size > p_tree->nodes_size)
- {
+ 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
- (! p_tree->nodes)
- {
- fprintf(stderr, "Not enough memory to reinitialize the tag tree\n");
- tgt_destroy(p_tree);
+ if (! new_nodes) {
+ fprintf(stderr, "ERROR Not enough memory to reinitialize the tag tree\n");
+ opj_tgt_destroy(p_tree);
return 00;
}
p_tree->nodes = new_nodes;
l_parent_node = &p_tree->nodes[p_tree->numleafsh * p_tree->numleafsv];
l_parent_node0 = l_parent_node;
- for
- (i = 0; i < l_num_levels - 1; ++i)
- {
- for
- (j = 0; j < l_nplv[i]; ++j)
- {
+ for (i = 0; i < l_num_levels - 1; ++i) {
+ for (j = 0; j < l_nplv[i]; ++j) {
k = l_nplh[i];
- while
- (--k >= 0)
- {
+ while (--k >= 0) {
l_node->parent = l_parent_node;
++l_node;
- if (--k >= 0)
- {
+ if (--k >= 0) {
l_node->parent = l_parent_node;
++l_node;
}
}
l_node->parent = 0;
}
- tgt_reset(p_tree);
+ opj_tgt_reset(p_tree);
return p_tree;
}
-/*void tgt_destroy(opj_tgt_tree_t *tree) {
- opj_free(tree->nodes);
- opj_free(tree);
-}*/
-
-void tgt_destroy(opj_tgt_tree_t *p_tree)
+void opj_tgt_destroy(opj_tgt_tree_t *p_tree)
{
if (! p_tree) {
return;
opj_free(p_tree);
}
-/*void tgt_reset(opj_tgt_tree_t *tree) {
- int i;
-
- if (NULL == tree)
- return;
-
- for (i = 0; i < tree->numnodes; i++) {
- tree->nodes[i].value = 999;
- tree->nodes[i].low = 0;
- tree->nodes[i].known = 0;
- }
-}*/
-
-void tgt_reset(opj_tgt_tree_t *p_tree) {
+void opj_tgt_reset(opj_tgt_tree_t *p_tree) {
OPJ_UINT32 i;
opj_tgt_node_t * l_current_node = 00;;
}
}
-void tgt_setvalue(opj_tgt_tree_t *tree, OPJ_UINT32 leafno, OPJ_INT32 value) {
+void opj_tgt_setvalue(opj_tgt_tree_t *tree, OPJ_UINT32 leafno, OPJ_INT32 value) {
opj_tgt_node_t *node;
node = &tree->nodes[leafno];
while (node && node->value > value) {
}
}
-void tgt_encode(opj_bio_t *bio, opj_tgt_tree_t *tree, OPJ_UINT32 leafno, OPJ_INT32 threshold) {
+void opj_tgt_encode(opj_bio_t *bio, opj_tgt_tree_t *tree, OPJ_UINT32 leafno, OPJ_INT32 threshold) {
opj_tgt_node_t *stk[31];
opj_tgt_node_t **stkptr;
opj_tgt_node_t *node;
}
}
-OPJ_UINT32 tgt_decode(opj_bio_t *bio, opj_tgt_tree_t *tree, OPJ_UINT32 leafno, OPJ_INT32 threshold) {
+OPJ_UINT32 opj_tgt_decode(opj_bio_t *bio, opj_tgt_tree_t *tree, OPJ_UINT32 leafno, OPJ_INT32 threshold) {
opj_tgt_node_t *stk[31];
opj_tgt_node_t **stkptr;
opj_tgt_node_t *node;