+ case LRCP:
+ return pi_next_lrcp(pi);
+ case RLCP:
+ return pi_next_rlcp(pi);
+ case RPCL:
+ return pi_next_rpcl(pi);
+ case PCRL:
+ return pi_next_pcrl(pi);
+ case CPRL:
+ return pi_next_cprl(pi);
+ case PROG_UNKNOWN:
+ return OPJ_FALSE;
+ }
+
+ return OPJ_FALSE;
+}
+
+opj_bool pi_create_encode( opj_pi_iterator_t *pi, opj_cp_t *cp,int tileno, int pino,int tpnum, int tppos, J2K_T2_MODE t2_mode,int cur_totnum_tp){
+ char prog[4];
+ int i;
+ int incr_top=1,resetX=0;
+ opj_tcp_t *tcps =&cp->tcps[tileno];
+ opj_poc_t *tcp= &tcps->pocs[pino];
+
+ pi[pino].first = 1;
+ pi[pino].poc.prg = tcp->prg;
+
+ switch(tcp->prg){
+ case CPRL: strncpy(prog, "CPRL",4);
+ break;
+ case LRCP: strncpy(prog, "LRCP",4);
+ break;
+ case PCRL: strncpy(prog, "PCRL",4);
+ break;
+ case RLCP: strncpy(prog, "RLCP",4);
+ break;
+ case RPCL: strncpy(prog, "RPCL",4);
+ break;
+ case PROG_UNKNOWN:
+ return OPJ_TRUE;
+ }
+
+ if(!(cp->tp_on && ((!cp->cinema && (t2_mode == FINAL_PASS)) || cp->cinema))){
+ 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 = tcp->txS;
+ pi[pino].poc.ty0 = tcp->tyS;
+ pi[pino].poc.tx1 = tcp->txE;
+ pi[pino].poc.ty1 = tcp->tyE;
+ }else {
+ if( tpnum < cur_totnum_tp){
+ for(i=3;i>=0;i--){
+ switch(prog[i]){
+ case 'C':
+ if (i > tppos){
+ pi[pino].poc.compno0 = tcp->compS;
+ pi[pino].poc.compno1 = tcp->compE;
+ }else{
+ if (tpnum == 0){
+ tcp->comp_t = tcp->compS;
+ pi[pino].poc.compno0 = tcp->comp_t;
+ pi[pino].poc.compno1 = tcp->comp_t+1;
+ tcp->comp_t+=1;
+ }else{
+ if (incr_top == 1){
+ if(tcp->comp_t ==tcp->compE){
+ tcp->comp_t = tcp->compS;
+ pi[pino].poc.compno0 = tcp->comp_t;
+ pi[pino].poc.compno1 = tcp->comp_t+1;
+ tcp->comp_t+=1;
+ incr_top=1;
+ }else{
+ pi[pino].poc.compno0 = tcp->comp_t;
+ pi[pino].poc.compno1 = tcp->comp_t+1;
+ tcp->comp_t+=1;
+ incr_top=0;
+ }
+ }else{
+ pi[pino].poc.compno0 = tcp->comp_t-1;
+ pi[pino].poc.compno1 = tcp->comp_t;
+ }
+ }
+ }
+ break;
+
+ case 'R':
+ if (i > tppos){
+ pi[pino].poc.resno0 = tcp->resS;
+ pi[pino].poc.resno1 = tcp->resE;
+ }else{
+ if (tpnum == 0){
+ tcp->res_t = tcp->resS;
+ pi[pino].poc.resno0 = tcp->res_t;
+ pi[pino].poc.resno1 = tcp->res_t+1;
+ tcp->res_t+=1;
+ }else{
+ if (incr_top == 1){
+ if(tcp->res_t==tcp->resE){
+ tcp->res_t = tcp->resS;
+ pi[pino].poc.resno0 = tcp->res_t;
+ pi[pino].poc.resno1 = tcp->res_t+1;
+ tcp->res_t+=1;
+ incr_top=1;
+ }else{
+ pi[pino].poc.resno0 = tcp->res_t;
+ pi[pino].poc.resno1 = tcp->res_t+1;
+ tcp->res_t+=1;
+ incr_top=0;
+ }
+ }else{
+ pi[pino].poc.resno0 = tcp->res_t - 1;
+ pi[pino].poc.resno1 = tcp->res_t;
+ }
+ }
+ }
+ break;
+
+ case 'L':
+ if (i > tppos){
+ pi[pino].poc.layno0 = tcp->layS;
+ pi[pino].poc.layno1 = tcp->layE;
+ }else{
+ if (tpnum == 0){
+ tcp->lay_t = tcp->layS;
+ pi[pino].poc.layno0 = tcp->lay_t;
+ pi[pino].poc.layno1 = tcp->lay_t+1;
+ tcp->lay_t+=1;
+ }else{
+ if (incr_top == 1){
+ if(tcp->lay_t == tcp->layE){
+ tcp->lay_t = tcp->layS;
+ pi[pino].poc.layno0 = tcp->lay_t;
+ pi[pino].poc.layno1 = tcp->lay_t+1;
+ tcp->lay_t+=1;
+ incr_top=1;
+ }else{
+ pi[pino].poc.layno0 = tcp->lay_t;
+ pi[pino].poc.layno1 = tcp->lay_t+1;
+ tcp->lay_t+=1;
+ incr_top=0;
+ }
+ }else{
+ pi[pino].poc.layno0 = tcp->lay_t - 1;
+ pi[pino].poc.layno1 = tcp->lay_t;
+ }
+ }
+ }
+ break;
+
+ case 'P':
+ switch(tcp->prg){
+ case LRCP:
+ case RLCP:
+ if (i > tppos){
+ pi[pino].poc.precno0 = tcp->prcS;
+ pi[pino].poc.precno1 = tcp->prcE;
+ }else{
+ if (tpnum == 0){
+ tcp->prc_t = tcp->prcS;
+ pi[pino].poc.precno0 = tcp->prc_t;
+ pi[pino].poc.precno1 = tcp->prc_t+1;
+ tcp->prc_t+=1;
+ }else{
+ if (incr_top == 1){
+ if(tcp->prc_t == tcp->prcE){
+ tcp->prc_t = tcp->prcS;
+ pi[pino].poc.precno0 = tcp->prc_t;
+ pi[pino].poc.precno1 = tcp->prc_t+1;
+ tcp->prc_t+=1;
+ incr_top=1;
+ }else{
+ pi[pino].poc.precno0 = tcp->prc_t;
+ pi[pino].poc.precno1 = tcp->prc_t+1;
+ tcp->prc_t+=1;
+ incr_top=0;
+ }
+ }else{
+ pi[pino].poc.precno0 = tcp->prc_t - 1;
+ pi[pino].poc.precno1 = tcp->prc_t;
+ }
+ }
+ }
+ break;
+ default:
+ if (i > tppos){
+ pi[pino].poc.tx0 = tcp->txS;
+ pi[pino].poc.ty0 = tcp->tyS;
+ pi[pino].poc.tx1 = tcp->txE;
+ pi[pino].poc.ty1 = tcp->tyE;
+ }else{
+ if (tpnum == 0){
+ tcp->tx0_t = tcp->txS;
+ tcp->ty0_t = tcp->tyS;
+ pi[pino].poc.tx0 = tcp->tx0_t;
+ pi[pino].poc.tx1 = tcp->tx0_t + tcp->dx - (tcp->tx0_t % tcp->dx);
+ pi[pino].poc.ty0 = tcp->ty0_t;
+ pi[pino].poc.ty1 = tcp->ty0_t + tcp->dy - (tcp->ty0_t % tcp->dy);
+ tcp->tx0_t = pi[pino].poc.tx1;
+ tcp->ty0_t = pi[pino].poc.ty1;
+ }else{
+ if (incr_top == 1){
+ if(tcp->tx0_t >= tcp->txE){
+ if(tcp->ty0_t >= tcp->tyE){
+ tcp->ty0_t = tcp->tyS;
+ pi[pino].poc.ty0 = tcp->ty0_t;
+ pi[pino].poc.ty1 = tcp->ty0_t + tcp->dy - (tcp->ty0_t % tcp->dy);
+ tcp->ty0_t = pi[pino].poc.ty1;
+ incr_top=1;resetX=1;
+ }else{
+ pi[pino].poc.ty0 = tcp->ty0_t;
+ pi[pino].poc.ty1 = tcp->ty0_t + tcp->dy - (tcp->ty0_t % tcp->dy);
+ tcp->ty0_t = pi[pino].poc.ty1;
+ incr_top=0;resetX=1;
+ }
+ if(resetX==1){
+ tcp->tx0_t = tcp->txS;
+ pi[pino].poc.tx0 = tcp->tx0_t;
+ pi[pino].poc.tx1 = tcp->tx0_t + tcp->dx- (tcp->tx0_t % tcp->dx);
+ tcp->tx0_t = pi[pino].poc.tx1;
+ }
+ }else{
+ pi[pino].poc.tx0 = tcp->tx0_t;
+ pi[pino].poc.tx1 = tcp->tx0_t + tcp->dx- (tcp->tx0_t % tcp->dx);
+ tcp->tx0_t = pi[pino].poc.tx1;
+ pi[pino].poc.ty0 = tcp->ty0_t - tcp->dy - (tcp->ty0_t % tcp->dy);
+ pi[pino].poc.ty1 = tcp->ty0_t ;
+ incr_top=0;
+ }
+ }else{
+ pi[pino].poc.tx0 = tcp->tx0_t - tcp->dx - (tcp->tx0_t % tcp->dx);
+ pi[pino].poc.tx1 = tcp->tx0_t ;
+ pi[pino].poc.ty0 = tcp->ty0_t - tcp->dy - (tcp->ty0_t % tcp->dy);
+ pi[pino].poc.ty1 = tcp->ty0_t ;
+ }
+ }
+ }
+ break;
+ }
+ break;
+ }
+ }
+ }
+ }
+ return OPJ_FALSE;
+}
+
+
+
+/**
+ * Gets the encoding parameters needed to update the coding parameters and all the pocs.
+ * The precinct widths, heights, dx and dy for each component at each resolution will be stored as well.
+ * the last parameter of the function should be an array of pointers of size nb components, each pointer leading
+ * to an area of size 4 * max_res. The data is stored inside this area with the following pattern :
+ * dx_compi_res0 , dy_compi_res0 , w_compi_res0, h_compi_res0 , dx_compi_res1 , dy_compi_res1 , w_compi_res1, h_compi_res1 , ...
+ *
+ * @param p_image the image being encoded.
+ * @param p_cp the coding parameters.
+ * @param tileno the tile index of the tile being encoded.
+ * @param p_tx0 pointer that will hold the X0 parameter for the tile
+ * @param p_tx1 pointer that will hold the X1 parameter for the tile
+ * @param p_ty0 pointer that will hold the Y0 parameter for the tile
+ * @param p_ty1 pointer that will hold the Y1 parameter for the tile
+ * @param p_max_prec pointer that will hold the the maximum precision for all the bands of the tile
+ * @param p_max_res pointer that will hold the the maximum number of resolutions for all the poc inside the tile.
+ * @param dx_min pointer that will hold the the minimum dx of all the components of all the resolutions for the tile.
+ * @param dy_min pointer that will hold the the minimum dy of all the components of all the resolutions for the tile.
+ * @param p_resolutions pointer to an area corresponding to the one described above.
+ */
+void get_all_encoding_parameters(
+ const opj_image_t *p_image,
+ const opj_cp_v2_t *p_cp,
+ OPJ_UINT32 tileno,
+ OPJ_INT32 * p_tx0,
+ OPJ_INT32 * p_tx1,
+ OPJ_INT32 * p_ty0,
+ OPJ_INT32 * p_ty1,
+ OPJ_UINT32 * p_dx_min,
+ OPJ_UINT32 * p_dy_min,
+ OPJ_UINT32 * p_max_prec,
+ OPJ_UINT32 * p_max_res,
+ OPJ_UINT32 ** p_resolutions
+ )
+{
+ // loop
+ OPJ_UINT32 compno, resno;
+
+ // pointers
+ const opj_tcp_v2_t *tcp = 00;
+ const opj_tccp_t * l_tccp = 00;
+ const opj_image_comp_t * l_img_comp = 00;
+
+ // to store l_dx, l_dy, w and h for each resolution and component.
+ OPJ_UINT32 * lResolutionPtr;
+
+ // position in x and y of tile
+ OPJ_UINT32 p, q;
+
+ // preconditions in debug
+ assert(p_cp != 00);
+ assert(p_image != 00);
+ assert(tileno < p_cp->tw * p_cp->th);
+
+ // initializations
+ tcp = &p_cp->tcps [tileno];
+ l_tccp = tcp->tccps;
+ l_img_comp = p_image->comps;
+
+ // position in x and y of tile
+
+ p = tileno % p_cp->tw;
+ q = tileno / p_cp->tw;
+
+ /* here calculation of tx0, tx1, ty0, ty1, maxprec, l_dx and l_dy */
+ *p_tx0 = int_max(p_cp->tx0 + p * p_cp->tdx, p_image->x0);
+ *p_tx1 = int_min(p_cp->tx0 + (p + 1) * p_cp->tdx, p_image->x1);
+ *p_ty0 = int_max(p_cp->ty0 + q * p_cp->tdy, p_image->y0);
+ *p_ty1 = int_min(p_cp->ty0 + (q + 1) * p_cp->tdy, p_image->y1);
+
+ // max precision and resolution is 0 (can only grow)
+ *p_max_prec = 0;
+ *p_max_res = 0;
+
+ // take the largest value for dx_min and dy_min
+ *p_dx_min = 0x7fffffff;
+ *p_dy_min = 0x7fffffff;
+
+ for
+ (compno = 0; compno < p_image->numcomps; ++compno)
+ {
+ // aritmetic variables to calculate
+ OPJ_UINT32 l_level_no;
+ OPJ_INT32 l_rx0, l_ry0, l_rx1, l_ry1;
+ OPJ_INT32 l_px0, l_py0, l_px1, py1;
+ OPJ_UINT32 l_product;
+ OPJ_INT32 l_tcx0, l_tcy0, l_tcx1, l_tcy1;
+ OPJ_UINT32 l_pdx, l_pdy , l_pw , l_ph;
+
+ lResolutionPtr = p_resolutions[compno];
+
+ l_tcx0 = int_ceildiv(*p_tx0, l_img_comp->dx);
+ l_tcy0 = int_ceildiv(*p_ty0, l_img_comp->dy);
+ l_tcx1 = int_ceildiv(*p_tx1, l_img_comp->dx);
+ l_tcy1 = int_ceildiv(*p_ty1, l_img_comp->dy);
+ if
+ (l_tccp->numresolutions > *p_max_res)
+ {
+ *p_max_res = l_tccp->numresolutions;
+ }
+
+ // use custom size for precincts
+ l_level_no = l_tccp->numresolutions - 1;
+ for
+ (resno = 0; resno < l_tccp->numresolutions; ++resno)
+ {
+ OPJ_UINT32 l_dx, l_dy;
+ // precinct width and height
+ l_pdx = l_tccp->prcw[resno];
+ l_pdy = l_tccp->prch[resno];
+ *lResolutionPtr++ = l_pdx;
+ *lResolutionPtr++ = l_pdy;
+ l_dx = l_img_comp->dx * (1 << (l_pdx + l_level_no));
+ l_dy = l_img_comp->dy * (1 << (l_pdy + l_level_no));
+ // take the minimum size for l_dx for each comp and resolution
+ *p_dx_min = int_min(*p_dx_min, l_dx);
+ *p_dy_min = int_min(*p_dy_min, l_dy);
+ // various calculations of extents
+
+ l_rx0 = int_ceildivpow2(l_tcx0, l_level_no);
+ l_ry0 = int_ceildivpow2(l_tcy0, l_level_no);
+ l_rx1 = int_ceildivpow2(l_tcx1, l_level_no);
+ l_ry1 = int_ceildivpow2(l_tcy1, l_level_no);
+ l_px0 = int_floordivpow2(l_rx0, l_pdx) << l_pdx;
+ l_py0 = int_floordivpow2(l_ry0, l_pdy) << l_pdy;
+ l_px1 = int_ceildivpow2(l_rx1, l_pdx) << l_pdx;
+ py1 = int_ceildivpow2(l_ry1, l_pdy) << l_pdy;
+ l_pw = (l_rx0==l_rx1)?0:((l_px1 - l_px0) >> l_pdx);
+ l_ph = (l_ry0==l_ry1)?0:((py1 - l_py0) >> l_pdy);
+ *lResolutionPtr++ = l_pw;
+ *lResolutionPtr++ = l_ph;
+ l_product = l_pw * l_ph;
+ // update precision
+ if
+ (l_product > *p_max_prec)
+ {
+ *p_max_prec = l_product;
+ }
+ --l_level_no;
+ }
+ ++l_tccp;
+ ++l_img_comp;
+ }
+}
+
+/**
+ * Allocates memory for a packet iterator. Data and data sizes are set by this operation.
+ * No other data is set. The include section of the packet iterator is not allocated.
+ *
+ * @param p_image the image used to initialize the packet iterator (in fact only the number of components is relevant.
+ * @param p_cp the coding parameters.
+ * @param p_tile_no the index of the tile from which creating the packet iterator.
+ */
+opj_pi_iterator_t * pi_create( const opj_image_t *image,
+ const opj_cp_v2_t *cp,
+ OPJ_UINT32 tileno )
+{
+ // loop
+ OPJ_UINT32 pino, compno;
+ // number of poc in the p_pi
+ OPJ_UINT32 l_poc_bound;
+
+ // pointers to tile coding parameters and components.
+ opj_pi_iterator_t *l_pi = 00;
+ opj_tcp_v2_t *tcp = 00;
+ const opj_tccp_t *tccp = 00;
+
+ // current packet iterator being allocated
+ opj_pi_iterator_t *l_current_pi = 00;
+
+ // preconditions in debug
+ assert(cp != 00);
+ assert(image != 00);
+ assert(tileno < cp->tw * cp->th);
+
+ // 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) {
+ pi_destroy_v2(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));
+ if (!comp->resolutions) {
+ pi_destroy_v2(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;
+}
+
+
+
+/**
+ * Destroys a packet iterator array.
+ *
+ * @param p_pi the packet iterator array to destroy.
+ * @param p_nb_elements the number of elements in the array.
+ */
+void pi_destroy_v2(
+ opj_pi_iterator_t *p_pi,
+ OPJ_UINT32 p_nb_elements)
+{
+ OPJ_UINT32 compno, pino;
+ opj_pi_iterator_t *l_current_pi = p_pi;
+ if
+ (p_pi)
+ {
+ if
+ (p_pi->include)
+ {
+ opj_free(p_pi->include);
+ p_pi->include = 00;
+ }
+ // TODO
+ for
+ (pino = 0; pino < p_nb_elements; ++pino)
+ {
+ if
+ (l_current_pi->comps)
+ {
+ opj_pi_comp_t *l_current_component = l_current_pi->comps;
+ for
+ (compno = 0; compno < l_current_pi->numcomps; compno++)
+ {
+ if
+ (l_current_component->resolutions)
+ {
+ opj_free(l_current_component->resolutions);
+ l_current_component->resolutions = 00;
+ }
+ ++l_current_component;
+ }
+ opj_free(l_current_pi->comps);
+ l_current_pi->comps = 0;
+ }
+ ++l_current_pi;
+ }
+ opj_free(p_pi);
+ }
+}
+
+
+
+void pi_update_decode_poc (opj_pi_iterator_t * p_pi,opj_tcp_v2_t * p_tcp,OPJ_UINT32 p_max_precision,OPJ_UINT32 p_max_res)
+{
+ // loop
+ OPJ_UINT32 pino;
+
+ // encoding prameters to set
+ OPJ_UINT32 l_bound;
+
+ opj_pi_iterator_t * l_current_pi = 00;
+ opj_poc_t* l_current_poc = 0;
+
+ // preconditions in debug
+ assert(p_pi != 00);
+ assert(p_tcp != 00);
+
+ // initializations
+ l_bound = p_tcp->numpocs+1;
+ l_current_pi = p_pi;
+ l_current_poc = p_tcp->pocs;
+
+ for
+ (pino = 0;pino<l_bound;++pino)
+ {
+ l_current_pi->poc.prg = l_current_poc->prg;
+ l_current_pi->first = 1;
+
+ l_current_pi->poc.resno0 = l_current_poc->resno0;
+ l_current_pi->poc.compno0 = l_current_poc->compno0;
+ l_current_pi->poc.layno0 = 0;
+ l_current_pi->poc.precno0 = 0;
+ l_current_pi->poc.resno1 = l_current_poc->resno1;
+ l_current_pi->poc.compno1 = l_current_poc->compno1;
+ l_current_pi->poc.layno1 = l_current_poc->layno1;
+ l_current_pi->poc.precno1 = p_max_precision;
+ ++l_current_pi;
+ ++l_current_poc;
+ }
+}
+
+
+void pi_update_decode_not_poc (opj_pi_iterator_t * p_pi,opj_tcp_v2_t * p_tcp,OPJ_UINT32 p_max_precision,OPJ_UINT32 p_max_res)
+{
+ // loop
+ OPJ_UINT32 pino;
+
+ // encoding prameters to set
+ OPJ_UINT32 l_bound;
+
+ opj_pi_iterator_t * l_current_pi = 00;
+ // preconditions in debug
+ assert(p_tcp != 00);
+ assert(p_pi != 00);
+
+ // initializations
+ l_bound = p_tcp->numpocs+1;
+ l_current_pi = p_pi;
+
+ for
+ (pino = 0;pino<l_bound;++pino)
+ {
+ l_current_pi->poc.prg = p_tcp->prg;
+ l_current_pi->first = 1;
+ l_current_pi->poc.resno0 = 0;
+ l_current_pi->poc.compno0 = 0;
+ l_current_pi->poc.layno0 = 0;
+ l_current_pi->poc.precno0 = 0;
+ l_current_pi->poc.resno1 = p_max_res;
+ l_current_pi->poc.compno1 = l_current_pi->numcomps;
+ l_current_pi->poc.layno1 = p_tcp->numlayers;
+ l_current_pi->poc.precno1 = p_max_precision;
+ ++l_current_pi;