bool opj_procedure_list_add_procedure (opj_procedure_list_t * p_validation_list, opj_procedure p_procedure, opj_event_mgr_t* p_manager ) { assert(p_manager != NULL); if (p_validation_list->m_nb_max_procedures == p_validation_list->m_nb_procedures) { opj_procedure * new_procedures; p_validation_list->m_nb_max_procedures += OPJ_VALIDATION_SIZE; new_procedures = (opj_procedure*)opj_realloc( p_validation_list->m_procedures, p_validation_list->m_nb_max_procedures * sizeof(opj_procedure)); if (! new_procedures) { opj_free(p_validation_list->m_procedures); p_validation_list->m_nb_max_procedures = 0; p_validation_list->m_nb_procedures = 0; opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to add a new validation procedure\n"); return false; } else { p_validation_list->m_procedures = new_procedures; } } p_validation_list->m_procedures[p_validation_list->m_nb_procedures] = p_procedure; ++p_validation_list->m_nb_procedures; return true; }
static bool t2_init_seg(opj_tcd_cblk_dec_t* cblk, OPJ_UINT32 indexvalue, OPJ_UINT32 cblksty, OPJ_UINT32 first) { opj_tcd_seg_t* seg = 00; OPJ_UINT32 l_nb_segs = indexvalue + 1; if (l_nb_segs > cblk->m_current_max_segs) { cblk->m_current_max_segs += J2K_DEFAULT_NB_SEGS; cblk->segs = (opj_tcd_seg_t*) opj_realloc(cblk->segs, cblk->m_current_max_segs * sizeof(opj_tcd_seg_t)); if (! cblk->segs) { return false; } } seg = &cblk->segs[indexvalue]; memset(seg,0,sizeof(opj_tcd_seg_t)); if (cblksty & J2K_CCP_CBLKSTY_TERMALL) { seg->maxpasses = 1; } else if (cblksty & J2K_CCP_CBLKSTY_LAZY) { if (first) { seg->maxpasses = 10; } else { seg->maxpasses = (((seg - 1)->maxpasses == 1) || ((seg - 1)->maxpasses == 10)) ? 2 : 1; } } else { seg->maxpasses = 109; } return true; }
static opj_bool t2_init_seg(opj_tcd_cblk_dec_t* cblk, int index, int cblksty, int first) { opj_tcd_seg_t* seg; opj_tcd_seg_t* segs; segs = (opj_tcd_seg_t*) opj_realloc(cblk->segs, (index + 1) * sizeof(opj_tcd_seg_t)); if (segs == NULL) { return OPJ_FALSE; } cblk->segs = segs; seg = &cblk->segs[index]; seg->data = NULL; seg->dataindex = 0; seg->numpasses = 0; seg->len = 0; if (cblksty & J2K_CCP_CBLKSTY_TERMALL) { seg->maxpasses = 1; } else if (cblksty & J2K_CCP_CBLKSTY_LAZY) { if (first) { seg->maxpasses = 10; } else { seg->maxpasses = (((seg - 1)->maxpasses == 1) || ((seg - 1)->maxpasses == 10)) ? 2 : 1; } } else { seg->maxpasses = 109; } return OPJ_TRUE; }
OPJ_BOOL opj_procedure_list_add_procedure (opj_procedure_list_t * p_validation_list, opj_procedure p_procedure) { if (p_validation_list->m_nb_max_procedures == p_validation_list->m_nb_procedures) { opj_procedure * new_procedures; p_validation_list->m_nb_max_procedures += OPJ_VALIDATION_SIZE; new_procedures = (opj_procedure*)opj_realloc( p_validation_list->m_procedures, p_validation_list->m_nb_max_procedures * sizeof(opj_procedure)); if (! new_procedures) { opj_free(p_validation_list->m_procedures); p_validation_list->m_nb_max_procedures = 0; p_validation_list->m_nb_procedures = 0; /* opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to add a new validation procedure\n"); */ fprintf(stderr, "Not enough memory to add a new validation procedure\n"); return OPJ_FALSE; } else { p_validation_list->m_procedures = new_procedures; } } p_validation_list->m_procedures[p_validation_list->m_nb_procedures] = p_procedure; ++p_validation_list->m_nb_procedures; return OPJ_TRUE; }
OPJ_BOOL opj_tls_set(opj_tls_t* tls, int key, void* value, opj_tls_free_func opj_free_func) { opj_tls_key_val_t* new_key_val; int i; if (tls->key_val_count == INT_MAX) { return OPJ_FALSE; } for(i=0;i<tls->key_val_count;i++) { if( tls->key_val[i].key == key ) { if( tls->key_val[i].opj_free_func ) { tls->key_val[i].opj_free_func(tls->key_val[i].value); } tls->key_val[i].value = value; tls->key_val[i].opj_free_func = opj_free_func; return OPJ_TRUE; } } new_key_val = (opj_tls_key_val_t*) opj_realloc( tls->key_val, ((size_t)tls->key_val_count + 1U) * sizeof(opj_tls_key_val_t) ); if( !new_key_val ) return OPJ_FALSE; tls->key_val = new_key_val; new_key_val[tls->key_val_count].key = key; new_key_val[tls->key_val_count].value = value; new_key_val[tls->key_val_count].opj_free_func = opj_free_func; tls->key_val_count ++; return OPJ_TRUE; }
static void t2_init_seg(opj_tcd_cblk_dec_t* cblk, S32 index, S32 cblksty, S32 first) { opj_tcd_seg_t* seg; cblk->segs = (opj_tcd_seg_t*) opj_realloc(cblk->segs, (index + 1) * sizeof(opj_tcd_seg_t)); seg = &cblk->segs[index]; seg->data = NULL; seg->dataindex = 0; seg->numpasses = 0; seg->len = 0; if (cblksty & J2K_CCP_CBLKSTY_TERMALL) { seg->maxpasses = 1; } else if (cblksty & J2K_CCP_CBLKSTY_LAZY) { if (first) { seg->maxpasses = 10; } else { seg->maxpasses = (((seg - 1)->maxpasses == 1) || ((seg - 1)->maxpasses == 10)) ? 2 : 1; } } else { seg->maxpasses = 109; } }
static int t2_decode_packet(opj_t2_t* t2, unsigned char *src, int len, opj_tcd_tile_t *tile, opj_tcp_t *tcp, opj_pi_iterator_t *pi, opj_packet_info_t *pack_info) { int bandno, cblkno; unsigned char *c = src; opj_cp_t *cp = t2->cp; int compno = pi->compno; /* component value */ int resno = pi->resno; /* resolution level value */ int precno = pi->precno; /* precinct value */ int layno = pi->layno; /* quality layer value */ opj_tcd_resolution_t* res = &tile->comps[compno].resolutions[resno]; unsigned char *hd = NULL; int present; opj_bio_t *bio = NULL; /* BIO component */ if (layno == 0) { for (bandno = 0; bandno < res->numbands; bandno++) { opj_tcd_band_t *band = &res->bands[bandno]; opj_tcd_precinct_t *prc = &band->precincts[precno]; if ((band->x1-band->x0 == 0)||(band->y1-band->y0 == 0)) continue; tgt_reset(prc->incltree); tgt_reset(prc->imsbtree); for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) { opj_tcd_cblk_dec_t* cblk = &prc->cblks.dec[cblkno]; cblk->numsegs = 0; } } } /* SOP markers */ if (tcp->csty & J2K_CP_CSTY_SOP) { if ((*c) != 0xff || (*(c + 1) != 0x91)) { opj_event_msg(t2->cinfo, EVT_WARNING, "Expected SOP marker\n"); } else { c += 6; } /** TODO : check the Nsop value */ } /* When the marker PPT/PPM is used the packet header are store in PPT/PPM marker This part deal with this caracteristic step 1: Read packet header in the saved structure step 2: Return to codestream for decoding */ bio = bio_create(); if (cp->ppm == 1) { /* PPM */ hd = cp->ppm_data; bio_init_dec(bio, hd, cp->ppm_len); } else if (tcp->ppt == 1) { /* PPT */ hd = tcp->ppt_data; bio_init_dec(bio, hd, tcp->ppt_len); } else { /* Normal Case */ hd = c; bio_init_dec(bio, hd, src+len-hd); } present = bio_read(bio, 1); if (!present) { bio_inalign(bio); hd += bio_numbytes(bio); bio_destroy(bio); /* EPH markers */ if (tcp->csty & J2K_CP_CSTY_EPH) { if ((*hd) != 0xff || (*(hd + 1) != 0x92)) { printf("Error : expected EPH marker\n"); } else { hd += 2; } } /* << INDEX */ /* End of packet header position. Currently only represents the distance to start of packet // Will be updated later by incrementing with packet start value*/ if(pack_info) { pack_info->end_ph_pos = (int)(c - src); } /* INDEX >> */ if (cp->ppm == 1) { /* PPM case */ cp->ppm_len += cp->ppm_data-hd; cp->ppm_data = hd; return (c - src); } if (tcp->ppt == 1) { /* PPT case */ tcp->ppt_len+=tcp->ppt_data-hd; tcp->ppt_data = hd; return (c - src); } return (hd - src); } for (bandno = 0; bandno < res->numbands; bandno++) { opj_tcd_band_t *band = &res->bands[bandno]; opj_tcd_precinct_t *prc = &band->precincts[precno]; if ((band->x1-band->x0 == 0)||(band->y1-band->y0 == 0)) continue; for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) { int included, increment, n, segno; opj_tcd_cblk_dec_t* cblk = &prc->cblks.dec[cblkno]; /* if cblk not yet included before --> inclusion tagtree */ if (!cblk->numsegs) { included = tgt_decode(bio, prc->incltree, cblkno, layno + 1); /* else one bit */ } else { included = bio_read(bio, 1); } /* if cblk not included */ if (!included) { cblk->numnewpasses = 0; continue; } /* if cblk not yet included --> zero-bitplane tagtree */ if (!cblk->numsegs) { int i, numimsbs; for (i = 0; !tgt_decode(bio, prc->imsbtree, cblkno, i); i++) { ; } numimsbs = i - 1; cblk->numbps = band->numbps - numimsbs; cblk->numlenbits = 3; } /* number of coding passes */ cblk->numnewpasses = t2_getnumpasses(bio); increment = t2_getcommacode(bio); /* length indicator increment */ cblk->numlenbits += increment; segno = 0; if (!cblk->numsegs) { t2_init_seg(cblk, segno, tcp->tccps[compno].cblksty, 1); } else { segno = cblk->numsegs - 1; if (cblk->segs[segno].numpasses == cblk->segs[segno].maxpasses) { ++segno; t2_init_seg(cblk, segno, tcp->tccps[compno].cblksty, 0); } } n = cblk->numnewpasses; do { cblk->segs[segno].numnewpasses = int_min(cblk->segs[segno].maxpasses - cblk->segs[segno].numpasses, n); cblk->segs[segno].newlen = bio_read(bio, cblk->numlenbits + int_floorlog2(cblk->segs[segno].numnewpasses)); n -= cblk->segs[segno].numnewpasses; if (n > 0) { ++segno; t2_init_seg(cblk, segno, tcp->tccps[compno].cblksty, 0); } } while (n > 0); } } if (bio_inalign(bio)) { bio_destroy(bio); return -999; } hd += bio_numbytes(bio); bio_destroy(bio); /* EPH markers */ if (tcp->csty & J2K_CP_CSTY_EPH) { if ((*hd) != 0xff || (*(hd + 1) != 0x92)) { opj_event_msg(t2->cinfo, EVT_ERROR, "Expected EPH marker\n"); return -999; } else { hd += 2; } } /* << INDEX */ /* End of packet header position. Currently only represents the distance to start of packet // Will be updated later by incrementing with packet start value*/ if(pack_info) { pack_info->end_ph_pos = (int)(hd - src); } /* INDEX >> */ if (cp->ppm==1) { cp->ppm_len+=cp->ppm_data-hd; cp->ppm_data = hd; } else if (tcp->ppt == 1) { tcp->ppt_len+=tcp->ppt_data-hd; tcp->ppt_data = hd; } else { c=hd; } for (bandno = 0; bandno < res->numbands; bandno++) { opj_tcd_band_t *band = &res->bands[bandno]; opj_tcd_precinct_t *prc = &band->precincts[precno]; if ((band->x1-band->x0 == 0)||(band->y1-band->y0 == 0)) continue; for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) { opj_tcd_cblk_dec_t* cblk = &prc->cblks.dec[cblkno]; opj_tcd_seg_t *seg = NULL; if (!cblk->numnewpasses) continue; if (!cblk->numsegs) { seg = &cblk->segs[0]; cblk->numsegs++; cblk->len = 0; } else { seg = &cblk->segs[cblk->numsegs - 1]; if (seg->numpasses == seg->maxpasses) { seg++; cblk->numsegs++; } } do { if (c + seg->newlen > src + len) { return -999; } #ifdef USE_JPWL /* we need here a j2k handle to verify if making a check to the validity of cblocks parameters is selected from user (-W) */ /* let's check that we are not exceeding */ if ((cblk->len + seg->newlen) > 8192) { opj_event_msg(t2->cinfo, EVT_WARNING, "JPWL: segment too long (%d) for codeblock %d (p=%d, b=%d, r=%d, c=%d)\n", seg->newlen, cblkno, precno, bandno, resno, compno); if (!JPWL_ASSUME) { opj_event_msg(t2->cinfo, EVT_ERROR, "JPWL: giving up\n"); return -999; } seg->newlen = 8192 - cblk->len; opj_event_msg(t2->cinfo, EVT_WARNING, " - truncating segment to %d\n", seg->newlen); break; }; #endif /* USE_JPWL */ cblk->data = (unsigned char*) opj_realloc(cblk->data, (cblk->len + seg->newlen) * sizeof(unsigned char)); memcpy(cblk->data + cblk->len, c, seg->newlen); if (seg->numpasses == 0) { seg->data = &cblk->data; seg->dataindex = cblk->len; } c += seg->newlen; cblk->len += seg->newlen; seg->len += seg->newlen; seg->numpasses += seg->numnewpasses; cblk->numnewpasses -= seg->numnewpasses; if (cblk->numnewpasses > 0) { seg++; cblk->numsegs++; } } while (cblk->numnewpasses > 0); } } return (c - src); }
/** * 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_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; OPJ_UINT32 l_node_size; if (! p_tree){ return 00; } 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] = (OPJ_INT32)p_num_leafs_h; l_nplv[0] = (OPJ_INT32)p_num_leafs_v; p_tree->numnodes = 0; do { 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; ++l_num_levels; } while (n > 1); /* 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_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; for (i = 0; i < l_num_levels - 1; ++i) { for (j = 0; j < l_nplv[i]; ++j) { k = l_nplh[i]; while (--k >= 0) { l_node->parent = l_parent_node; ++l_node; if (--k >= 0) { l_node->parent = l_parent_node; ++l_node; } ++l_parent_node; } if ((j & 1) || j == l_nplv[i] - 1) { l_parent_node0 = l_parent_node; } else { l_parent_node = l_parent_node0; l_parent_node0 += l_nplh[i]; } } } l_node->parent = 0; } opj_tgt_reset(p_tree); return p_tree; }