X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libopenjpeg%2Ft2.c;h=2fb739e99e757be9b6a617b6d78b03284aaabe76;hb=08f7bfbb5f1e8dccaef0128b39af1cea7548c50e;hp=0e8f3174d852c508f8c11a8376c2b1b2b54afe49;hpb=64c34e0d5260ef8e4dee4638458431aec0e1e614;p=openjpeg.git

diff --git a/libopenjpeg/t2.c b/libopenjpeg/t2.c
index 0e8f3174..2fb739e9 100644
--- a/libopenjpeg/t2.c
+++ b/libopenjpeg/t2.c
@@ -1,7 +1,9 @@
 /*
- * Copyright (c) 2001-2002, David Janssens
- * Copyright (c) 2002-2004, Yannick Verschueren
- * Copyright (c) 2002-2004, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
+ * Copyright (c) 2001-2003, David Janssens
+ * Copyright (c) 2002-2003, Yannick Verschueren
+ * Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
+ * Copyright (c) 2005, HervŽ Drolon, FreeImage Team
+ * Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -26,609 +28,591 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "t2.h"
-#include "tcd.h"
-#include "bio.h"
-#include "j2k.h"
-#include "pi.h"
-#include "tgt.h"
-#include "int.h"
-#include "cio.h"
-#include <stdio.h>
-#include <setjmp.h>
-#include <string.h>
-#include <stdlib.h>
-
-#define RESTART 0x04
-
-extern jmp_buf j2k_error;
-
-void t2_putcommacode(int n)
-{
+#include "opj_includes.h"
+
+
+/* #define RESTART 0x04 */
+
+static void t2_putcommacode(opj_bio_t *bio, int n) {
   while (--n >= 0) {
-    bio_write(1, 1);
+    bio_write(bio, 1, 1);
   }
-  bio_write(0, 1);
+  bio_write(bio, 0, 1);
 }
 
-int t2_getcommacode()
-{
+static int t2_getcommacode(opj_bio_t *bio) {
   int n;
-  for (n = 0; bio_read(1); n++) {
+  for (n = 0; bio_read(bio, 1); n++) {
+    ;
   }
   return n;
 }
 
-/* <summary> */
-/* Variable length code for signalling delta Zil (truncation point) */
-/* <val> n : delta Zil */
-/* <\summary> */
-void t2_putnumpasses(int n)
-{
+static void t2_putnumpasses(opj_bio_t *bio, int n) {
   if (n == 1) {
-    bio_write(0, 1);
+    bio_write(bio, 0, 1);
   } else if (n == 2) {
-    bio_write(2, 2);
+    bio_write(bio, 2, 2);
   } else if (n <= 5) {
-    bio_write(0xc | (n - 3), 4);
+    bio_write(bio, 0xc | (n - 3), 4);
   } else if (n <= 36) {
-    bio_write(0x1e0 | (n - 6), 9);
+    bio_write(bio, 0x1e0 | (n - 6), 9);
   } else if (n <= 164) {
-    bio_write(0xff80 | (n - 37), 16);
+    bio_write(bio, 0xff80 | (n - 37), 16);
   }
 }
 
-int t2_getnumpasses()
-{
+static int t2_getnumpasses(opj_bio_t *bio) {
   int n;
-  if (!bio_read(1))
+  if (!bio_read(bio, 1))
     return 1;
-  if (!bio_read(1))
+  if (!bio_read(bio, 1))
     return 2;
-  if ((n = bio_read(2)) != 3)
-    return 3 + n;
-  if ((n = bio_read(5)) != 31)
-    return 6 + n;
-  return 37 + bio_read(7);
+  if ((n = bio_read(bio, 2)) != 3)
+    return (3 + n);
+  if ((n = bio_read(bio, 5)) != 31)
+    return (6 + n);
+  return (37 + bio_read(bio, 7));
 }
 
-/*
- * Encode a packet of a tile to a destination buffer
- *
- * Tile    : the tile for which to write the packets
- * tcp     : the tile coding parameters
- * compno  : Identity of the packet --> component value
- * resno   : Identity of the packet --> resolution level value
- * precno  : Identity of the packet --> precinct value
- * layno   : Identity of the packet --> quality layer value
- * dest    : the destination buffer
- * len     : the length of the destination buffer
- * info_IM : structure to create an index file
- * tileno  : number of the tile encoded
-*/
-int t2_encode_packet(tcd_tile_t * tile, j2k_tcp_t * tcp, int compno,
-		     int resno, int precno, int layno, unsigned char *dest,
-		     int len, info_image * info_IM, int tileno)
-{
+static int t2_encode_packet(opj_t2_t* t2, opj_tcd_tile_t * tile, opj_tcp_t * tcp, opj_pi_iterator_t *pi, unsigned char *dest, int len, opj_image_info_t * image_info, int tileno) {
   int bandno, cblkno;
   unsigned char *sop = 0, *eph = 0;
-  tcd_tilecomp_t *tilec = &tile->comps[compno];
-  tcd_resolution_t *res = &tilec->resolutions[resno];
   unsigned char *c = dest;
 
+  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_tilecomp_t *tilec = &tile->comps[compno];
+  opj_tcd_resolution_t *res = &tilec->resolutions[resno];
+  
+  opj_bio_t *bio = NULL;  /* BIO component */
+  
   /* <SOP 0xff91> */
   if (tcp->csty & J2K_CP_CSTY_SOP) {
-    sop = (unsigned char *) malloc(6 * sizeof(unsigned char));
+    sop = (unsigned char *) opj_malloc(6 * sizeof(unsigned char));
     sop[0] = 255;
     sop[1] = 145;
     sop[2] = 0;
     sop[3] = 4;
-    sop[4] = (info_IM->num % 65536) / 256;
-    sop[5] = (info_IM->num % 65536) % 256;
+    sop[4] = (image_info->num % 65536) / 256;
+    sop[5] = (image_info->num % 65536) % 256;
     memcpy(c, sop, 6);
-    free(sop);
+    opj_free(sop);
     c += 6;
   }
   /* </SOP> */
-
+  
   if (!layno) {
     for (bandno = 0; bandno < res->numbands; bandno++) {
-      tcd_band_t *band = &res->bands[bandno];
-      tcd_precinct_t *prc = &band->precincts[precno];
+      opj_tcd_band_t *band = &res->bands[bandno];
+      opj_tcd_precinct_t *prc = &band->precincts[precno];
       tgt_reset(prc->incltree);
       tgt_reset(prc->imsbtree);
       for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
-	tcd_cblk_t *cblk = &prc->cblks[cblkno];
-	cblk->numpasses = 0;
-	tgt_setvalue(prc->imsbtree, cblkno, band->numbps - cblk->numbps);
+        opj_tcd_cblk_t *cblk = &prc->cblks[cblkno];
+        cblk->numpasses = 0;
+        tgt_setvalue(prc->imsbtree, cblkno, band->numbps - cblk->numbps);
       }
     }
   }
-
-  bio_init_enc(c, len);
-  bio_write(1, 1);		/* Empty header bit */
-
+  
+  bio = bio_create();
+  bio_init_enc(bio, c, len);
+  bio_write(bio, 1, 1);   /* Empty header bit */
+  
   /* Writing Packet header */
   for (bandno = 0; bandno < res->numbands; bandno++) {
-    tcd_band_t *band = &res->bands[bandno];
-    tcd_precinct_t *prc = &band->precincts[precno];
+    opj_tcd_band_t *band = &res->bands[bandno];
+    opj_tcd_precinct_t *prc = &band->precincts[precno];
     for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
-      tcd_cblk_t *cblk = &prc->cblks[cblkno];
-      tcd_layer_t *layer = &cblk->layers[layno];
+      opj_tcd_cblk_t *cblk = &prc->cblks[cblkno];
+      opj_tcd_layer_t *layer = &cblk->layers[layno];
       if (!cblk->numpasses && layer->numpasses) {
-	tgt_setvalue(prc->incltree, cblkno, layno);
+        tgt_setvalue(prc->incltree, cblkno, layno);
       }
     }
     for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
-      tcd_cblk_t *cblk = &prc->cblks[cblkno];
-      tcd_layer_t *layer = &cblk->layers[layno];
+      opj_tcd_cblk_t *cblk = &prc->cblks[cblkno];
+      opj_tcd_layer_t *layer = &cblk->layers[layno];
       int increment = 0;
       int nump = 0;
       int len = 0, passno;
       /* cblk inclusion bits */
       if (!cblk->numpasses) {
-	tgt_encode(prc->incltree, cblkno, layno + 1);
+        tgt_encode(bio, prc->incltree, cblkno, layno + 1);
       } else {
-	bio_write(layer->numpasses != 0, 1);
+        bio_write(bio, layer->numpasses != 0, 1);
       }
       /* if cblk not included, go to the next cblk  */
       if (!layer->numpasses) {
-	continue;
+        continue;
       }
       /* if first instance of cblk --> zero bit-planes information */
       if (!cblk->numpasses) {
-	cblk->numlenbits = 3;
-	tgt_encode(prc->imsbtree, cblkno, 999);
+        cblk->numlenbits = 3;
+        tgt_encode(bio, prc->imsbtree, cblkno, 999);
       }
       /* number of coding passes included */
-      t2_putnumpasses(layer->numpasses);
-
+      t2_putnumpasses(bio, layer->numpasses);
+      
       /* computation of the increase of the length indicator and insertion in the header     */
-      for (passno = cblk->numpasses;
-	   passno < cblk->numpasses + layer->numpasses; passno++) {
-	tcd_pass_t *pass = &cblk->passes[passno];
-	nump++;
-	len += pass->len;
-	if (pass->term
-	    || passno == (cblk->numpasses + layer->numpasses) - 1) {
-	  increment =
-	    int_max(increment,
-		    int_floorlog2(len) + 1 -
-		    (cblk->numlenbits + int_floorlog2(nump)));
-	  len = 0;
-	  nump = 0;
-	}
+      for (passno = cblk->numpasses; passno < cblk->numpasses + layer->numpasses; passno++) {
+        opj_tcd_pass_t *pass = &cblk->passes[passno];
+        nump++;
+        len += pass->len;
+        if (pass->term || passno == (cblk->numpasses + layer->numpasses) - 1) {
+          increment = int_max(increment, int_floorlog2(len) + 1 - (cblk->numlenbits + int_floorlog2(nump)));
+          len = 0;
+          nump = 0;
+        }
       }
-      t2_putcommacode(increment);
+      t2_putcommacode(bio, increment);
+
       /* computation of the new Length indicator */
       cblk->numlenbits += increment;
-      /* insertion of the codeword segment length */
 
-      for (passno = cblk->numpasses;
-	   passno < cblk->numpasses + layer->numpasses; passno++) {
-	tcd_pass_t *pass = &cblk->passes[passno];
-	nump++;
-	len += pass->len;
-	if (pass->term
-	    || passno == (cblk->numpasses + layer->numpasses) - 1) {
-	  bio_write(len, cblk->numlenbits + int_floorlog2(nump));
-	  len = 0;
-	  nump = 0;
-	}
+      /* insertion of the codeword segment length */
+      for (passno = cblk->numpasses; passno < cblk->numpasses + layer->numpasses; passno++) {
+        opj_tcd_pass_t *pass = &cblk->passes[passno];
+        nump++;
+        len += pass->len;
+        if (pass->term || passno == (cblk->numpasses + layer->numpasses) - 1) {
+          bio_write(bio, len, cblk->numlenbits + int_floorlog2(nump));
+          len = 0;
+          nump = 0;
+        }
       }
     }
   }
+  
+  if (bio_flush(bio)) {
+    return -999;    /* modified to eliminate longjmp !! */
+  }
+  
+  c += bio_numbytes(bio);
 
-  if (bio_flush())
-    return -999;		/* modified to eliminate longjmp !! */
-
-  c += bio_numbytes();
-
+  bio_destroy(bio);
+  
   /* <EPH 0xff92> */
   if (tcp->csty & J2K_CP_CSTY_EPH) {
-    eph = (unsigned char *) malloc(2 * sizeof(unsigned char));
+    eph = (unsigned char *) opj_malloc(2 * sizeof(unsigned char));
     eph[0] = 255;
     eph[1] = 146;
     memcpy(c, eph, 2);
-    free(eph);
+    opj_free(eph);
     c += 2;
   }
   /* </EPH> */
-
+  
   /* Writing the packet body */
-
+  
   for (bandno = 0; bandno < res->numbands; bandno++) {
-    tcd_band_t *band = &res->bands[bandno];
-    tcd_precinct_t *prc = &band->precincts[precno];
+    opj_tcd_band_t *band = &res->bands[bandno];
+    opj_tcd_precinct_t *prc = &band->precincts[precno];
     for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
-      tcd_cblk_t *cblk = &prc->cblks[cblkno];
-      tcd_layer_t *layer = &cblk->layers[layno];
+      opj_tcd_cblk_t *cblk = &prc->cblks[cblkno];
+      opj_tcd_layer_t *layer = &cblk->layers[layno];
       if (!layer->numpasses) {
-	continue;
+        continue;
       }
       if (c + layer->len > dest + len) {
-	return -999;
+        return -999;
       }
-
+      
       memcpy(c, layer->data, layer->len);
       cblk->numpasses += layer->numpasses;
       c += layer->len;
       /* ADD for index Cfr. Marcela --> delta disto by packet */
-      if (info_IM->index_write && info_IM->index_on) {
-	info_tile *info_TL = &info_IM->tile[tileno];
-	info_packet *info_PK = &info_TL->packet[info_IM->num];
-	info_PK->disto += layer->disto;
-	if (info_IM->D_max < info_PK->disto)
-	  info_IM->D_max = info_PK->disto;
-      }				/* </ADD> */
+      if(image_info && image_info->index_write && image_info->index_on) {
+        opj_tile_info_t *info_TL = &image_info->tile[tileno];
+        opj_packet_info_t *info_PK = &info_TL->packet[image_info->num];
+        info_PK->disto += layer->disto;
+        if (image_info->D_max < info_PK->disto) {
+          image_info->D_max = info_PK->disto;
+        }
+      }
+      /* </ADD> */
     }
   }
-  return c - dest;
+  
+  return (c - dest);
 }
 
-void t2_init_seg(tcd_seg_t * seg, int cblksty, int first)
-{
+static void t2_init_seg(opj_tcd_seg_t * seg, int cblksty, int first) {
   seg->numpasses = 0;
   seg->len = 0;
-  if (cblksty & J2K_CCP_CBLKSTY_TERMALL)
+  if (cblksty & J2K_CCP_CBLKSTY_TERMALL) {
     seg->maxpasses = 1;
+  }
   else if (cblksty & J2K_CCP_CBLKSTY_LAZY) {
-    if (first)
+    if (first) {
       seg->maxpasses = 10;
-    else
-      seg->maxpasses = (((seg - 1)->maxpasses == 1)
-			|| ((seg - 1)->maxpasses == 10)) ? 2 : 1;
-  } else
+    } else {
+      seg->maxpasses = (((seg - 1)->maxpasses == 1) || ((seg - 1)->maxpasses == 10)) ? 2 : 1;
+    }
+  } else {
     seg->maxpasses = 109;
+  }
 }
 
-/*  
- * Decode a packet of a tile from a source buffer
- *
- * src          : the source buffer
- * len          : the length of the source buffer
- * tile         : the tile for which to write the packets
- * cp           : the image coding parameters
- * tcp          : the tile coding parameters
- * compno  : Identity of the packet --> component value
- * resno      : Identity of the packet --> resolution level value
- * precno    : Identity of the packet --> precinct value
- * layno      : Identity of the packet --> quality layer value
- */
-int t2_decode_packet(unsigned char *src, int len, tcd_tile_t * tile,
-		     j2k_cp_t * cp, j2k_tcp_t * tcp, int compno, int resno,
-		     int precno, int layno)
-{
+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) {
   int bandno, cblkno;
-  tcd_tilecomp_t *tilec = &tile->comps[compno];
-  tcd_resolution_t *res = &tilec->resolutions[resno];
   unsigned char *c = src;
-  int present;
 
+  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_tilecomp_t *tilec = &tile->comps[compno];
+  opj_tcd_resolution_t *res = &tilec->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++) {
-      tcd_band_t *band = &res->bands[bandno];
-      tcd_precinct_t *prc = &band->precincts[precno];
+      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++) {
-	tcd_cblk_t *cblk = &prc->cblks[cblkno];
-	cblk->numsegs = 0;
+        opj_tcd_cblk_t *cblk = &prc->cblks[cblkno];
+        cblk->numsegs = 0;
       }
     }
   }
-
-  /* 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: (futher) return to codestream for decoding */
-  if (cp->ppm == 1) {		/* PPM */
-    c = cp->ppm_data;
-    bio_init_dec(c, 1000);
-  } else {
-    if (tcp->ppt == 1) {	/* PPT */
-      c = tcp->ppt_data;
-      bio_init_dec(c, 1000);
-    } else {			/* Normal Case */
-
-      if (tcp->csty & J2K_CP_CSTY_SOP) {
-	if ((*c) != 255 || (*(c + 1) != 145)) {
-	  printf("Error : expected SOP marker [1]!!!\n");
-	}
-	c += 6;
-      }
-      bio_init_dec(c, src + len - c);
+  
+  /* SOP markers */
+  
+  if (tcp->csty & J2K_CP_CSTY_SOP) {
+    if ((*c) != 0xff || (*(c + 1) != 0x91)) {
+      opg_event_msg(t2->cinfo, EVT_WARNING, "Expected SOP marker\n");
+    } else {
+      c += 6;
     }
+    
+    /** TODO : check the Nsop value */
   }
-
-  present = bio_read(1);
-
+  
+  /* 
+  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();
-    /* Normal case */
-    c += bio_numbytes();
+    bio_inalign(bio);
+    hd += bio_numbytes(bio);
+    bio_destroy(bio);
+    
+    /* EPH markers */
+    
     if (tcp->csty & J2K_CP_CSTY_EPH) {
-      if ((*c) != 255 || (*(c + 1) != 146)) {
-	printf("Error : expected EPH marker [1]!!!\n");
+      if ((*hd) != 0xff || (*(hd + 1) != 0x92)) {
+        printf("Error : expected EPH marker\n");
+      } else {
+        hd += 2;
       }
-      c += 2;
     }
-
-    /* PPT and PPM dealing */
-    if (cp->ppm == 1) {		/* PPM */
-      cp->ppm_data = c;
-      return 0;
+    
+    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 */
-      tcp->ppt_data = c;
-      return 0;
+    if (tcp->ppt == 1) {  /* PPT case */
+      tcp->ppt_len+=tcp->ppt_data-hd;
+      tcp->ppt_data = hd;
+      return (c - src);
     }
-    return c - src;
+    
+    return (hd - src);
   }
+  
   for (bandno = 0; bandno < res->numbands; bandno++) {
-    tcd_band_t *band = &res->bands[bandno];
-    tcd_precinct_t *prc = &band->precincts[precno];
+    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;
-      tcd_cblk_t *cblk = &prc->cblks[cblkno];
-      tcd_seg_t *seg;
+      opj_tcd_cblk_t *cblk = &prc->cblks[cblkno];
+      opj_tcd_seg_t *seg = NULL;
       /* if cblk not yet included before --> inclusion tagtree */
       if (!cblk->numsegs) {
-	included = tgt_decode(prc->incltree, cblkno, layno + 1);
-	/* else one bit */
+        included = tgt_decode(bio, prc->incltree, cblkno, layno + 1);
+        /* else one bit */
       } else {
-	included = bio_read(1);
+        included = bio_read(bio, 1);
       }
       /* if cblk not included */
       if (!included) {
-	cblk->numnewpasses = 0;
-	continue;
+        cblk->numnewpasses = 0;
+        continue;
       }
       /* if cblk not yet included --> zero-bitplane tagtree */
       if (!cblk->numsegs) {
-	int i, numimsbs;
-	for (i = 0; !tgt_decode(prc->imsbtree, cblkno, i); i++) {
-	}
-	numimsbs = i - 1;
-	cblk->numbps = band->numbps - numimsbs;
-	cblk->numlenbits = 3;
+        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();
-      increment = t2_getcommacode();
+      cblk->numnewpasses = t2_getnumpasses(bio);
+      increment = t2_getcommacode(bio);
       /* length indicator increment */
       cblk->numlenbits += increment;
       if (!cblk->numsegs) {
-	seg = &cblk->segs[0];
-	t2_init_seg(seg, tcp->tccps[compno].cblksty, 1);
+        seg = &cblk->segs[0];
+        t2_init_seg(seg, tcp->tccps[compno].cblksty, 1);
       } else {
-	seg = &cblk->segs[cblk->numsegs - 1];
-	if (seg->numpasses == seg->maxpasses) {
-	  t2_init_seg(++seg, tcp->tccps[compno].cblksty, 0);
-	}
+        seg = &cblk->segs[cblk->numsegs - 1];
+        if (seg->numpasses == seg->maxpasses) {
+          t2_init_seg(++seg, tcp->tccps[compno].cblksty, 0);
+        }
       }
       n = cblk->numnewpasses;
-
+      
       do {
-	seg->numnewpasses = int_min(seg->maxpasses - seg->numpasses, n);
-	seg->newlen =
-	  bio_read(cblk->numlenbits + int_floorlog2(seg->numnewpasses));
-	n -= seg->numnewpasses;
-	if (n > 0) {
-	  t2_init_seg(++seg, tcp->tccps[compno].cblksty, 0);
-	}
+        seg->numnewpasses = int_min(seg->maxpasses - seg->numpasses, n);
+        seg->newlen = bio_read(bio, cblk->numlenbits + int_floorlog2(seg->numnewpasses));
+        n -= seg->numnewpasses;
+        if (n > 0) {
+          t2_init_seg(++seg, tcp->tccps[compno].cblksty, 0);
+        }
       } while (n > 0);
     }
   }
-  if (bio_inalign())
+  
+  if (bio_inalign(bio)) {
+    bio_destroy(bio);
     return -999;
-
-  c += bio_numbytes();
-
-  if (tcp->csty & J2K_CP_CSTY_EPH) {	/* EPH marker */
-    if ((*c) != 255 || (*(c + 1) != 146)) {
-      printf("Error : expected EPH marker [2]!!!\n");
-    }
-    c += 2;
   }
-
-  /* PPT Step 2 : see above for details */
-  if (cp->ppm == 1) {
-    cp->ppm_data = c;		/* Update pointer */
-
-    c = src;
-    if (tcp->csty & J2K_CP_CSTY_SOP) {
-      if ((*c) != 255 || (*(c + 1) != 145)) {
-	printf("Error : expected SOP marker [2] !!!\n");
-      }
-      c += 6;
+  
+  hd += bio_numbytes(bio);
+  bio_destroy(bio);
+  
+  /* EPH markers */
+  if (tcp->csty & J2K_CP_CSTY_EPH) {
+    if ((*hd) != 0xff || (*(hd + 1) != 0x92)) {
+      opg_event_msg(t2->cinfo, EVT_ERROR, "Expected EPH marker\n");
+    } else {
+      hd += 2;
     }
-    bio_init_dec(c, src + len - c);
+  }
+  
+  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 {
-    if (tcp->ppt == 1) {
-      tcp->ppt_data = c;	/* Update pointer */
-      c = src;
-      if (tcp->csty & J2K_CP_CSTY_SOP) {	/* SOP marker */
-	if ((*c) != 255 || (*(c + 1) != 145)) {
-	  printf("Error : expected SOP marker [2] !!!\n");
-	}
-	c += 6;
-      }
-      bio_init_dec(c, src + len - c);
-
-    }
+    c=hd;
   }
-
+  
   for (bandno = 0; bandno < res->numbands; bandno++) {
-    tcd_band_t *band = &res->bands[bandno];
-    tcd_precinct_t *prc = &band->precincts[precno];
+    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++) {
-      tcd_cblk_t *cblk = &prc->cblks[cblkno];
-      tcd_seg_t *seg;
+      opj_tcd_cblk_t *cblk = &prc->cblks[cblkno];
+      opj_tcd_seg_t *seg = NULL;
       if (!cblk->numnewpasses)
-	continue;
+        continue;
       if (!cblk->numsegs) {
-	seg = &cblk->segs[cblk->numsegs++];
-	cblk->len = 0;
+        seg = &cblk->segs[0];
+        cblk->numsegs++;
+        cblk->len = 0;
       } else {
-	seg = &cblk->segs[cblk->numsegs - 1];
-	if (seg->numpasses == seg->maxpasses) {
-	  seg++;
-	  cblk->numsegs++;
-	}
+        seg = &cblk->segs[cblk->numsegs - 1];
+        if (seg->numpasses == seg->maxpasses) {
+          seg++;
+          cblk->numsegs++;
+        }
       }
+      
       do {
-	if (c + seg->newlen > src + len) {
-	  return -999;
-	}
-
-	memcpy(cblk->data + cblk->len, c, seg->newlen);
-	if (seg->numpasses == 0) {
-	  seg->data = cblk->data + 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++;
-	}
+        if (c + seg->newlen > src + len) {
+          return -999;
+        }
+        
+        memcpy(cblk->data + cblk->len, c, seg->newlen);
+        if (seg->numpasses == 0) {
+          seg->data = cblk->data + 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;
+  
+  return (c - src);
 }
 
+/* ----------------------------------------------------------------------- */
 
-
-/*
- * Encode the packets of a tile to a destination buffer
- *
- * img        : the source image
- * cp         : the image coding parameters
- * tileno     : number of the tile encoded
- * tile       : the tile for which to write the packets
- * maxlayers  : maximum number of layers
- * dest       : the destination buffer
- * len        : the length of the destination buffer
- * info_IM    : structure to create an index file
- */
-int t2_encode_packets(j2k_image_t * img, j2k_cp_t * cp, int tileno,
-		      tcd_tile_t * tile, int maxlayers,
-		      unsigned char *dest, int len, info_image * info_IM)
-{
+int t2_encode_packets(opj_t2_t* t2, int tileno, opj_tcd_tile_t *tile, int maxlayers, unsigned char *dest, int len, opj_image_info_t *image_info) {
   unsigned char *c = dest;
   int e = 0;
-  pi_iterator_t *pi;
-  int pino, compno;
-
-  pi = pi_create(img, cp, tileno);
-
+  opj_pi_iterator_t *pi = NULL;
+  int pino;
+
+  opj_image_t *image = t2->image;
+  opj_cp_t *cp = t2->cp;
+  
+  /* create a packet iterator */
+  pi = pi_create(image, cp, tileno);
+  if(!pi) {
+    /* TODO: throw an error */
+    return -999;
+  }
+  
   for (pino = 0; pino <= cp->tcps[tileno].numpocs; pino++) {
     while (pi_next(&pi[pino])) {
       if (pi[pino].layno < maxlayers) {
-	e = t2_encode_packet(tile, &cp->tcps[tileno],
-			     pi[pino].compno, pi[pino].resno,
-			     pi[pino].precno, pi[pino].layno, c,
-			     dest + len - c, info_IM, tileno);
-	if (e == -999) {
-	  break;
-	} else
-	  c += e;
-	/* INDEX >> */
-	if (info_IM->index_write && info_IM->index_on) {
-	  info_tile *info_TL = &info_IM->tile[tileno];
-	  info_packet *info_PK = &info_TL->packet[info_IM->num];
-	  if (!info_IM->num) {
-	    info_PK->start_pos = info_TL->end_header + 1;
-	  } else {
-	    info_PK->start_pos =
-	      info_TL->packet[info_IM->num - 1].end_pos + 1;
-	  }
-	  info_PK->end_pos = info_PK->start_pos + e - 1;
-
-	}
-	/* << INDEX */
-	if ((info_IM->index_write
-	     && cp->tcps[tileno].csty & J2K_CP_CSTY_SOP)
-	    || (info_IM->index_write && info_IM->index_on)) {
-	  info_IM->num++;
-	}
+        e = t2_encode_packet(t2, tile, &cp->tcps[tileno], &pi[pino], c, dest + len - c, image_info, tileno);
+        if (e == -999) {
+          break;
+        } else {
+          c += e;
+        }
+        
+        /* INDEX >> */
+        if(image_info && image_info->index_on) {
+          if(image_info->index_write) {
+            opj_tile_info_t *info_TL = &image_info->tile[tileno];
+            opj_packet_info_t *info_PK = &info_TL->packet[image_info->num];
+            if (!image_info->num) {
+              info_PK->start_pos = info_TL->end_header + 1;
+            } else {
+              info_PK->start_pos = info_TL->packet[image_info->num - 1].end_pos + 1;
+            }
+            info_PK->end_pos = info_PK->start_pos + e - 1;
+          }
+
+          image_info->num++;
+        }
+        /* << INDEX */
       }
-
-    }
-
-    /* FREE space memory taken by pi */
-    for (compno = 0; compno < pi[pino].numcomps; compno++) {
-      free(pi[pino].comps[compno].resolutions);
     }
-    free(pi[pino].comps);
   }
-  free(pi[0].include);
-  free(pi);
-  if (e == -999)
-    return e;
-  else
-    return c - dest;
-}
 
+  /* don't forget to release pi */
+  pi_destroy(pi, cp, tileno);
+  
+  if (e == -999) {
+    return e;
+  }
 
+    return (c - dest);
+}
 
-/*
- * Decode the packets of a tile from a source buffer
- *
- * src: the source buffer
- * len: length of the source buffer
- * img: destination image
- * cp: image coding parameters
- * tileno: number that identifies the tile for which to decode the packets
- * tile: tile for which to decode the packets
- */
-int t2_decode_packets(unsigned char *src, int len, j2k_image_t * img,
-		      j2k_cp_t * cp, int tileno, tcd_tile_t * tile)
-{
+int t2_decode_packets(opj_t2_t *t2, unsigned char *src, int len, int tileno, opj_tcd_tile_t *tile) {
   unsigned char *c = src;
-  pi_iterator_t *pi;
-  int pino, compno, e = 0;
+  opj_pi_iterator_t *pi;
+  int pino, e = 0;
   int n = 0;
 
-  pi = pi_create(img, cp, tileno);
-
+  opj_image_t *image = t2->image;
+  opj_cp_t *cp = t2->cp;
+  
+  /* create a packet iterator */
+  pi = pi_create(image, cp, tileno);
+  if(!pi) {
+    /* TODO: throw an error */
+    return -999;
+  }
+  
   for (pino = 0; pino <= cp->tcps[tileno].numpocs; pino++) {
     while (pi_next(&pi[pino])) {
-      e = t2_decode_packet(c, src + len - c, tile, cp,
-			   &cp->tcps[tileno], pi[pino].compno,
-			   pi[pino].resno, pi[pino].precno,
-			   pi[pino].layno);
-
+      if ((cp->layer==0) || (cp->layer>=((pi[pino].layno)+1))) {
+        e = t2_decode_packet(t2, c, src + len - c, tile, &cp->tcps[tileno], &pi[pino]);
+      } else {
+        e = 0;
+      }
+      
       /* progression in resolution */
-      img->comps[pi[pino].compno].resno_decoded =
-	e > 0 ? int_max(pi[pino].resno,
-			img->comps[pi[pino].compno].
-			resno_decoded) : img->comps[pi[pino].
-						    compno].resno_decoded;
+      image->comps[pi[pino].compno].resno_decoded = 
+        (e > 0) ? 
+        int_max(pi[pino].resno, image->comps[pi[pino].compno].resno_decoded) 
+        : image->comps[pi[pino].compno].resno_decoded;
       n++;
-
-      if (e == -999) {		/* ADD */
-	break;
-      } else
-	c += e;
-    }
-
-    /* FREE space memory taken by pi */
-    for (compno = 0; compno < pi[pino].numcomps; compno++) {
-      free(pi[pino].comps[compno].resolutions);
+      
+      if (e == -999) {    /* ADD */
+        break;
+      } else {
+        c += e;
+      }
     }
-    free(pi[pino].comps);
   }
-  free(pi[0].include);
-  free(pi);
 
-  if (e == -999)
+  /* don't forget to release pi */
+  pi_destroy(pi, cp, tileno);
+  
+  if (e == -999) {
     return e;
-  else
-    return c - src;
+  }
+  
+    return (c - src);
 }
+
+/* ----------------------------------------------------------------------- */
+
+opj_t2_t* t2_create(opj_common_ptr cinfo, opj_image_t *image, opj_cp_t *cp) {
+  /* create the tcd structure */
+  opj_t2_t *t2 = (opj_t2_t*)opj_malloc(sizeof(opj_t2_t));
+  if(!t2) return NULL;
+  t2->cinfo = cinfo;
+  t2->image = image;
+  t2->cp = cp;
+
+  return t2;
+}
+
+void t2_destroy(opj_t2_t *t2) {
+  if(t2) {
+    opj_free(t2);
+  }
+}
+