Deleting obsolete files and directories, adding v2-specific files and directories, updating existing files to v2. See README.v2 for more info

1 files changed, 873 insertions, 370 deletions

diff --git a/libopenjpeg/t2.c b/libopenjpeg/t2.c
index be9b42a4..18397e33 100644
--- a/libopenjpeg/t2.c
+++ b/libopenjpeg/t2.c
@@ -5,6 +5,7 @@
  * 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, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -28,8 +29,19 @@
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
-
+#include "openjpeg.h"
 #include "opj_includes.h"
+#include "t2.h"
+#include "bio.h"
+#include "tcd.h"
+#include "pi.h"
+#include "event.h"
+#include "j2k.h"
+#include "tgt.h"
+#include "int.h"
+#include "opj_malloc.h"
+#include "pi.h"
+
 
 /** @defgroup T2 T2 - Implementation of a tier-2 coding */
 /*@{*/
@@ -37,15 +49,15 @@
 /** @name Local static functions */
 /*@{*/
 
-static void t2_putcommacode(opj_bio_t *bio, int n);
-static int t2_getcommacode(opj_bio_t *bio);
+static void t2_putcommacode(opj_bio_t *bio, OPJ_UINT32 n);
+static OPJ_UINT32 t2_getcommacode(opj_bio_t *bio);
 /**
 Variable length code for signalling delta Zil (truncation point)
 @param bio Bit Input/Output component
 @param n delta Zil
 */
-static void t2_putnumpasses(opj_bio_t *bio, int n);
-static int t2_getnumpasses(opj_bio_t *bio);
+static void t2_putnumpasses(opj_bio_t *bio, OPJ_UINT32 n);
+static OPJ_UINT32 t2_getnumpasses(opj_bio_t *bio);
 /**
 Encode a packet of a tile to a destination buffer
 @param tile Tile for which to write the packets
@@ -57,13 +69,21 @@ Encode a packet of a tile to a destination buffer
 @param tileno Number of the tile encoded
 @return 
 */
-static int t2_encode_packet(opj_tcd_tile_t *tile, opj_tcp_t *tcp, opj_pi_iterator_t *pi, unsigned char *dest, int len, opj_codestream_info_t *cstr_info, int tileno);
+static bool t2_encode_packet(
+							 OPJ_UINT32 tileno, 
+							 opj_tcd_tile_t *tile, 
+							 opj_tcp_t *tcp, 
+							 opj_pi_iterator_t *pi, 
+							 OPJ_BYTE *dest, 
+							 OPJ_UINT32 * p_data_written,	
+							 OPJ_UINT32 len, 
+							 opj_codestream_info_t *cstr_info);
 /**
 @param seg
 @param cblksty
 @param first
 */
-static void t2_init_seg(opj_tcd_cblk_dec_t* cblk, int index, int cblksty, int first);
+static bool t2_init_seg(opj_tcd_cblk_dec_t* cblk, OPJ_UINT32 index, OPJ_UINT32 cblksty, OPJ_UINT32 first);
 /**
 Decode a packet of a tile from a source buffer
 @param t2 T2 handle
@@ -74,8 +94,15 @@ Decode a packet of a tile from a source buffer
 @param pi Packet identity
 @return 
 */
-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);
+static bool t2_decode_packet(
+							 opj_t2_t* p_t2,
+							 opj_tcd_tile_t *p_tile,
+                             opj_tcp_t *p_tcp, 
+							 opj_pi_iterator_t *p_pi,
+							 OPJ_BYTE *p_src, 
+							 OPJ_UINT32 * p_data_read,
+							 OPJ_UINT32 p_max_length,  
+							 opj_packet_info_t *p_pack_info);
 
 /*@}*/
 
@@ -85,22 +112,26 @@ static int t2_decode_packet(opj_t2_t* t2, unsigned char *src, int len, opj_tcd_t
 
 /* #define RESTART 0x04 */
 
-static void t2_putcommacode(opj_bio_t *bio, int n) {
-	while (--n >= 0) {
+static void t2_putcommacode(opj_bio_t *bio, OPJ_UINT32 n) {
+	while 
+		(--n != -1) 
+	{
 		bio_write(bio, 1, 1);
 	}
 	bio_write(bio, 0, 1);
 }
 
-static int t2_getcommacode(opj_bio_t *bio) {
-	int n;
-	for (n = 0; bio_read(bio, 1); n++) {
-		;
+static OPJ_UINT32 t2_getcommacode(opj_bio_t *bio) {
+	OPJ_UINT32 n = 0;
+	while
+		(bio_read(bio, 1))
+	{
+		++n;
 	}
 	return n;
 }
 
-static void t2_putnumpasses(opj_bio_t *bio, int n) {
+static void t2_putnumpasses(opj_bio_t *bio, OPJ_UINT32 n) {
 	if (n == 1) {
 		bio_write(bio, 0, 1);
 	} else if (n == 2) {
@@ -114,8 +145,8 @@ static void t2_putnumpasses(opj_bio_t *bio, int n) {
 	}
 }
 
-static int t2_getnumpasses(opj_bio_t *bio) {
-	int n;
+static OPJ_UINT32 t2_getnumpasses(opj_bio_t *bio) {
+	OPJ_UINT32 n;
 	if (!bio_read(bio, 1))
 		return 1;
 	if (!bio_read(bio, 1))
@@ -127,19 +158,32 @@ static int t2_getnumpasses(opj_bio_t *bio) {
 	return (37 + bio_read(bio, 7));
 }
 
-static int t2_encode_packet(opj_tcd_tile_t * tile, opj_tcp_t * tcp, opj_pi_iterator_t *pi, unsigned char *dest, int length, opj_codestream_info_t *cstr_info, int tileno) {
-	int bandno, cblkno;
-	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 */
+static bool t2_encode_packet(
+							 OPJ_UINT32 tileno, 
+							 opj_tcd_tile_t * tile, 
+							 opj_tcp_t * tcp, 
+							 opj_pi_iterator_t *pi,
+							 OPJ_BYTE *dest, 
+							 OPJ_UINT32 * p_data_written, 
+							 OPJ_UINT32 length, 
+							 opj_codestream_info_t *cstr_info) 
+{
+	OPJ_UINT32 bandno, cblkno;
+	OPJ_BYTE *c = dest;
+	OPJ_UINT32 l_nb_bytes;
+	OPJ_UINT32 compno = pi->compno;	/* component value */
+	OPJ_UINT32 resno  = pi->resno;		/* resolution level value */
+	OPJ_UINT32 precno = pi->precno;	/* precinct value */
+	OPJ_UINT32 layno  = pi->layno;		/* quality layer value */
+	OPJ_UINT32 l_nb_blocks;
+	opj_tcd_band_t *band = 00;
+	opj_tcd_cblk_enc_t* cblk = 00;
+	opj_tcd_pass_t *pass = 00;
 
 	opj_tcd_tilecomp_t *tilec = &tile->comps[compno];
 	opj_tcd_resolution_t *res = &tilec->resolutions[resno];
 	
-	opj_bio_t *bio = NULL;	/* BIO component */
+	opj_bio_t *bio = 00;	/* BIO component */
 	
 	/* <SOP 0xff91> */
 	if (tcp->csty & J2K_CP_CSTY_SOP) {
@@ -150,20 +194,27 @@ static int t2_encode_packet(opj_tcd_tile_t * tile, opj_tcp_t * tcp, opj_pi_itera
 		c[4] = (tile->packno % 65536) / 256;
 		c[5] = (tile->packno % 65536) % 256;
 		c += 6;
+		length -= 6;
 	}
 	/* </SOP> */
 	
 	if (!layno) {
-		for (bandno = 0; bandno < res->numbands; bandno++) {
-			opj_tcd_band_t *band = &res->bands[bandno];
+		band = res->bands;
+		for 
+			(bandno = 0; bandno < res->numbands; ++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++) {
+			l_nb_blocks = prc->cw * prc->ch;
+			for 
+				(cblkno = 0; cblkno < l_nb_blocks; ++cblkno) 
+			{
 				opj_tcd_cblk_enc_t* cblk = &prc->cblks.enc[cblkno];
 				cblk->numpasses = 0;
 				tgt_setvalue(prc->imsbtree, cblkno, band->numbps - cblk->numbps);
 			}
+			++band;
 		}
 	}
 	
@@ -172,22 +223,32 @@ static int t2_encode_packet(opj_tcd_tile_t * tile, opj_tcp_t * tcp, opj_pi_itera
 	bio_write(bio, 1, 1);		/* Empty header bit */
 	
 	/* Writing Packet header */
-	for (bandno = 0; bandno < res->numbands; bandno++) {
-		opj_tcd_band_t *band = &res->bands[bandno];
+	band = res->bands;
+	for 
+		(bandno = 0; bandno < res->numbands; ++bandno) 
+	{
 		opj_tcd_precinct_t *prc = &band->precincts[precno];
-		for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
-			opj_tcd_cblk_enc_t* cblk = &prc->cblks.enc[cblkno];
+		l_nb_blocks = prc->cw * prc->ch;
+		cblk = prc->cblks.enc;
+		for (cblkno = 0; cblkno < l_nb_blocks; ++cblkno) 
+		{
 			opj_tcd_layer_t *layer = &cblk->layers[layno];
-			if (!cblk->numpasses && layer->numpasses) {
+			if 
+				(!cblk->numpasses && layer->numpasses) 
+			{
 				tgt_setvalue(prc->incltree, cblkno, layno);
 			}
+			++cblk;
 		}
-		for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
-			opj_tcd_cblk_enc_t* cblk = &prc->cblks.enc[cblkno];
+		cblk = prc->cblks.enc;
+		for 
+			(cblkno = 0; cblkno < l_nb_blocks; cblkno++) 
+		{
 			opj_tcd_layer_t *layer = &cblk->layers[layno];
-			int increment = 0;
-			int nump = 0;
-			int len = 0, passno;
+			OPJ_UINT32 increment = 0;
+			OPJ_UINT32 nump = 0;
+			OPJ_UINT32 len = 0, passno;
+			OPJ_UINT32 l_nb_passes;
 			/* cblk inclusion bits */
 			if (!cblk->numpasses) {
 				tgt_encode(bio, prc->incltree, cblkno, layno + 1);
@@ -195,53 +256,73 @@ static int t2_encode_packet(opj_tcd_tile_t * tile, opj_tcp_t * tcp, opj_pi_itera
 				bio_write(bio, layer->numpasses != 0, 1);
 			}
 			/* if cblk not included, go to the next cblk  */
-			if (!layer->numpasses) {
+			if 
+				(!layer->numpasses)
+			{
+				++cblk;
 				continue;
 			}
 			/* if first instance of cblk --> zero bit-planes information */
-			if (!cblk->numpasses) {
+			if 
+				(!cblk->numpasses) 
+			{
 				cblk->numlenbits = 3;
 				tgt_encode(bio, prc->imsbtree, cblkno, 999);
 			}
 			/* number of coding passes included */
 			t2_putnumpasses(bio, layer->numpasses);
-			
+			l_nb_passes = cblk->numpasses + layer->numpasses;
+			pass = cblk->passes +  cblk->numpasses;
 			/* computation of the increase of the length indicator and insertion in the header     */
-			for (passno = cblk->numpasses; passno < cblk->numpasses + layer->numpasses; passno++) {
-				opj_tcd_pass_t *pass = &cblk->passes[passno];
-				nump++;
+			for 
+				(passno = cblk->numpasses; passno < l_nb_passes; ++passno) 
+			{
+				++nump;
 				len += pass->len;
-				if (pass->term || passno == (cblk->numpasses + layer->numpasses) - 1) {
+				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;
 				}
+				++pass;
 			}
 			t2_putcommacode(bio, increment);
 
 			/* computation of the new Length indicator */
 			cblk->numlenbits += increment;
 
+			pass = cblk->passes +  cblk->numpasses;
 			/* insertion of the codeword segment length */
-			for (passno = cblk->numpasses; passno < cblk->numpasses + layer->numpasses; passno++) {
-				opj_tcd_pass_t *pass = &cblk->passes[passno];
+			for 
+				(passno = cblk->numpasses; passno < l_nb_passes; ++passno) 
+			{
 				nump++;
 				len += pass->len;
-				if (pass->term || passno == (cblk->numpasses + layer->numpasses) - 1) {
+				if 
+					(pass->term || passno == (cblk->numpasses + layer->numpasses) - 1) 
+				{
 					bio_write(bio, len, cblk->numlenbits + int_floorlog2(nump));
 					len = 0;
 					nump = 0;
 				}
+				++pass;
 			}
+			++cblk;
 		}
+		++band;
 	}
 
-	if (bio_flush(bio)) {
+	if 
+		(bio_flush(bio)) 
+	{
 		bio_destroy(bio);
-		return -999;		/* modified to eliminate longjmp !! */
+		return false;		/* modified to eliminate longjmp !! */
 	}
-
-	c += bio_numbytes(bio);
+	l_nb_bytes = bio_numbytes(bio);
+	c += l_nb_bytes;
+	length -= l_nb_bytes;
 	bio_destroy(bio);
 	
 	/* <EPH 0xff92> */
@@ -249,6 +330,7 @@ static int t2_encode_packet(opj_tcd_tile_t * tile, opj_tcp_t * tcp, opj_pi_itera
 		c[0] = 255;
 		c[1] = 146;
 		c += 2;
+		length -= 2;
 	}
 	/* </EPH> */
 
@@ -257,28 +339,37 @@ static int t2_encode_packet(opj_tcd_tile_t * tile, opj_tcp_t * tcp, opj_pi_itera
 	// Will be updated later by incrementing with packet start value
 	if(cstr_info && cstr_info->index_write) {
 		opj_packet_info_t *info_PK = &cstr_info->tile[tileno].packet[cstr_info->packno];
-		info_PK->end_ph_pos = (int)(c - dest);
+		info_PK->end_ph_pos = (OPJ_INT32)(c - dest);
 	}
 	/* INDEX >> */
 	
 	/* Writing the packet body */
-	
-	for (bandno = 0; bandno < res->numbands; bandno++) {
-		opj_tcd_band_t *band = &res->bands[bandno];
+	band = res->bands;
+	for 
+		(bandno = 0; bandno < res->numbands; bandno++) 
+	{
 		opj_tcd_precinct_t *prc = &band->precincts[precno];
-		for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
-			opj_tcd_cblk_enc_t* cblk = &prc->cblks.enc[cblkno];
+		l_nb_blocks = prc->cw * prc->ch;
+		cblk = prc->cblks.enc;
+		for 
+			(cblkno = 0; cblkno < l_nb_blocks; ++cblkno) 
+		{
 			opj_tcd_layer_t *layer = &cblk->layers[layno];
-			if (!layer->numpasses) {
+			if 
+				(!layer->numpasses) 
+			{
+				++cblk;
 				continue;
 			}
-			if (c + layer->len > dest + length) {
-				return -999;
+			if 
+				(layer->len > length) 
+			{
+				return false;
 			}
-			
 			memcpy(c, layer->data, layer->len);
 			cblk->numpasses += layer->numpasses;
 			c += layer->len;
+			length -= layer->len;
 			/* << INDEX */ 
 			if(cstr_info && cstr_info->index_write) {
 				opj_packet_info_t *info_PK = &cstr_info->tile[tileno].packet[cstr_info->packno];
@@ -287,21 +378,34 @@ static int t2_encode_packet(opj_tcd_tile_t * tile, opj_tcp_t * tcp, opj_pi_itera
 					cstr_info->D_max = info_PK->disto;
 				}
 			}
+			++cblk;
 			/* INDEX >> */
 		}
+		++band;
 	}
-	
-	return (c - dest);
+	* p_data_written += (c - dest);
+	return true;
 }
 
-static void t2_init_seg(opj_tcd_cblk_dec_t* cblk, int index, int cblksty, int first) {
-	opj_tcd_seg_t* seg;
-	cblk->segs = (opj_tcd_seg_t*) opj_realloc(cblk->segs, (index + 1) * sizeof(opj_tcd_seg_t));
+static bool t2_init_seg(opj_tcd_cblk_dec_t* cblk, OPJ_UINT32 index, OPJ_UINT32 cblksty, OPJ_UINT32 first) 
+{
+	opj_tcd_seg_t* seg = 00;
+	OPJ_UINT32 l_nb_segs = index + 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[index];
-	seg->data = NULL;
-	seg->dataindex = 0;
-	seg->numpasses = 0;
-	seg->len = 0;
+	memset(seg,0,sizeof(opj_tcd_seg_t));
+
 	if (cblksty & J2K_CCP_CBLKSTY_TERMALL) {
 		seg->maxpasses = 1;
 	}
@@ -314,50 +418,74 @@ static void t2_init_seg(opj_tcd_cblk_dec_t* cblk, int index, int cblksty, int fi
 	} else {
 		seg->maxpasses = 109;
 	}
+	return true;
 }
 
-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;
+static bool t2_read_packet_header(
+							 opj_t2_t* p_t2,
+							 opj_tcd_tile_t *p_tile,
+                             opj_tcp_t *p_tcp, 
+							 opj_pi_iterator_t *p_pi,
+							 bool * p_is_data_present,
+							 OPJ_BYTE *p_src_data, 
+							 OPJ_UINT32 * p_data_read,
+							 OPJ_UINT32 p_max_length, 
+							 opj_packet_info_t *p_pack_info)
+{
+	/* loop */
+	OPJ_UINT32 bandno, cblkno;
+	OPJ_UINT32 l_nb_code_blocks;
+	OPJ_UINT32 l_remaining_length;
+	OPJ_UINT32 l_header_length;
+	OPJ_UINT32 * l_modified_length_ptr = 00;
+	OPJ_BYTE *l_current_data = p_src_data;
+	opj_cp_t *l_cp = p_t2->cp;
+	opj_bio_t *l_bio = 00;	/* BIO component */
+	opj_tcd_band_t *l_band = 00;
+	opj_tcd_cblk_dec_t* l_cblk = 00;
+	opj_tcd_resolution_t* l_res = &p_tile->comps[p_pi->compno].resolutions[p_pi->resno];
 	
-	opj_bio_t *bio = NULL;	/* BIO component */
+	OPJ_BYTE *l_header_data = 00;
+	OPJ_BYTE **l_header_data_start = 00;
 	
-	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;
+	OPJ_UINT32 l_present;
+	
+	if 
+		(p_pi->layno == 0) 
+	{
+		l_band = l_res->bands;
+		/* reset tagtrees */
+		for 
+			(bandno = 0; bandno < l_res->numbands; ++bandno) 
+		{
+			opj_tcd_precinct_t *l_prc = &l_band->precincts[p_pi->precno];
 			
-			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;
+			if (
+				! ((l_band->x1-l_band->x0 == 0)||(l_band->y1-l_band->y0 == 0)))
+			{
+				tgt_reset(l_prc->incltree);
+				tgt_reset(l_prc->imsbtree);
+				l_cblk = l_prc->cblks.dec;
+				l_nb_code_blocks = l_prc->cw * l_prc->ch;
+				for 
+					(cblkno = 0; cblkno < l_nb_code_blocks; ++cblkno) 
+				{
+					l_cblk->numsegs = 0;
+					l_cblk->real_num_segs = 0;
+					++l_cblk;
+				}
 			}
+			++l_band;
 		}
 	}
 	
 	/* 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");
+	if (p_tcp->csty & J2K_CP_CSTY_SOP) {
+		if ((*l_current_data) != 0xff || (*(l_current_data + 1) != 0x91)) {
+			// TODO opj_event_msg(t2->cinfo->event_mgr, EVT_WARNING, "Expected SOP marker\n");
 		} else {
-			c += 6;
+			l_current_data += 6;
 		}
 		
 		/** TODO : check the Nsop value */
@@ -370,179 +498,276 @@ static int t2_decode_packet(opj_t2_t* t2, unsigned char *src, int len, opj_tcd_t
 	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);
+	l_bio = bio_create();
+	if
+		(! l_bio)
+	{
+		return false;
 	}
 	
-	present = bio_read(bio, 1);
-	
-	if (!present) {
-		bio_inalign(bio);
-		hd += bio_numbytes(bio);
-		bio_destroy(bio);
+	if 
+		(l_cp->ppm == 1) 
+	{		/* PPM */
+		l_header_data_start = &l_cp->ppm_data;
+		l_header_data = *l_header_data_start;
+		l_modified_length_ptr = &(l_cp->ppm_len);
 		
+	} 
+	else if 
+		(p_tcp->ppt == 1) 
+	{	/* PPT */
+		l_header_data_start = &(p_tcp->ppt_data);
+		l_header_data = *l_header_data_start;
+		l_modified_length_ptr = &(p_tcp->ppt_len);
+	} 
+	else 
+	{	/* Normal Case */
+		l_header_data_start = &(l_current_data);
+		l_header_data = *l_header_data_start;
+		l_remaining_length = p_src_data+p_max_length-l_header_data;
+		l_modified_length_ptr = &(l_remaining_length);
+	}
+	bio_init_dec(l_bio, l_header_data,*l_modified_length_ptr);
+	l_present = bio_read(l_bio, 1);
+	if 
+		(!l_present) 
+	{
+		bio_inalign(l_bio);
+		l_header_data += bio_numbytes(l_bio);
+		bio_destroy(l_bio);
 		/* EPH markers */
-		
-		if (tcp->csty & J2K_CP_CSTY_EPH) {
-			if ((*hd) != 0xff || (*(hd + 1) != 0x92)) {
+		if (p_tcp->csty & J2K_CP_CSTY_EPH) {
+			if ((*l_header_data) != 0xff || (*(l_header_data + 1) != 0x92)) {
 				printf("Error : expected EPH marker\n");
 			} else {
-				hd += 2;
+				l_header_data += 2;
 			}
 		}
-
+		l_header_length = (l_header_data - *l_header_data_start);
+		*l_modified_length_ptr -= l_header_length;
+		*l_header_data_start += l_header_length;
 		/* << 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);
+		if
+			(p_pack_info) 
+		{
+			p_pack_info->end_ph_pos = (OPJ_INT32)(l_current_data - p_src_data);
 		}
 		/* 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);
+		* p_is_data_present = false;
+		*p_data_read = l_current_data - p_src_data;
+		return true;
 	}
 	
-	for (bandno = 0; bandno < res->numbands; bandno++) {
-		opj_tcd_band_t *band = &res->bands[bandno];
-		opj_tcd_precinct_t *prc = &band->precincts[precno];
+	l_band = l_res->bands;
+	for 
+		(bandno = 0; bandno < l_res->numbands; ++bandno) 
+	{
+		opj_tcd_precinct_t *l_prc = &(l_band->precincts[p_pi->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 ((l_band->x1-l_band->x0 == 0)||(l_band->y1-l_band->y0 == 0))
+		{
+			++l_band;
+			continue;
+		}
+		l_nb_code_blocks = l_prc->cw * l_prc->ch;
+		l_cblk = l_prc->cblks.dec;
+		for 
+			(cblkno = 0; cblkno < l_nb_code_blocks; cblkno++) 
+		{
+			OPJ_UINT32 l_included,l_increment, l_segno;
+			OPJ_INT32 n;
 			/* if cblk not yet included before --> inclusion tagtree */
-			if (!cblk->numsegs) {
-				included = tgt_decode(bio, prc->incltree, cblkno, layno + 1);
+			if 
+				(!l_cblk->numsegs) 
+			{
+				l_included = tgt_decode(l_bio, l_prc->incltree, cblkno, p_pi->layno + 1);
 				/* else one bit */
-			} else {
-				included = bio_read(bio, 1);
+			} 
+			else 
+			{
+				l_included = bio_read(l_bio, 1);
 			}
 			/* if cblk not included */
-			if (!included) {
-				cblk->numnewpasses = 0;
+			if 
+				(!l_included) 
+			{
+				l_cblk->numnewpasses = 0;
+				++l_cblk;
 				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++) {
-					;
+			if 
+				(!l_cblk->numsegs) 
+			{
+				OPJ_UINT32 i = 0;
+				while
+					(!tgt_decode(l_bio, l_prc->imsbtree, cblkno, i))
+				{
+					++i;
 				}
-				numimsbs = i - 1;
-				cblk->numbps = band->numbps - numimsbs;
-				cblk->numlenbits = 3;
+				l_cblk->numbps = l_band->numbps + 1 - i;
+				l_cblk->numlenbits = 3;
 			}
 			/* number of coding passes */
-			cblk->numnewpasses = t2_getnumpasses(bio);
-			increment = t2_getcommacode(bio);
+			l_cblk->numnewpasses = t2_getnumpasses(l_bio);
+			l_increment = t2_getcommacode(l_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);
+			l_cblk->numlenbits += l_increment;
+			l_segno = 0;
+			if 
+				(!l_cblk->numsegs) 
+			{
+				if
+					(! t2_init_seg(l_cblk, l_segno, p_tcp->tccps[p_pi->compno].cblksty, 1))
+				{
+					bio_destroy(l_bio);
+					return false;
+				}
+
+			} 
+			else 
+			{
+				l_segno = l_cblk->numsegs - 1;
+				if 
+					(l_cblk->segs[l_segno].numpasses == l_cblk->segs[l_segno].maxpasses)
+				{
+					++l_segno;
+					if
+						(! t2_init_seg(l_cblk, l_segno, p_tcp->tccps[p_pi->compno].cblksty, 0))
+					{
+						bio_destroy(l_bio);
+						return false;
+					}
 				}
 			}
-			n = cblk->numnewpasses;
+			n = l_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);
+				l_cblk->segs[l_segno].numnewpasses = int_min(l_cblk->segs[l_segno].maxpasses - l_cblk->segs[l_segno].numpasses, n);
+				l_cblk->segs[l_segno].newlen = bio_read(l_bio, l_cblk->numlenbits + uint_floorlog2(l_cblk->segs[l_segno].numnewpasses));
+				n -= l_cblk->segs[l_segno].numnewpasses;
+				if 
+					(n > 0) 
+				{
+					++l_segno;
+					if
+						(! t2_init_seg(l_cblk, l_segno, p_tcp->tccps[p_pi->compno].cblksty, 0))
+					{
+						bio_destroy(l_bio);
+						return false;
+					}
 				}
-			} while (n > 0);
+			} 
+			while (n > 0);
+			++l_cblk;
 		}
+		++l_band;
 	}
 	
-	if (bio_inalign(bio)) {
-		bio_destroy(bio);
-		return -999;
+	if 
+		(bio_inalign(l_bio)) 
+	{
+		bio_destroy(l_bio);
+		return false;
 	}
 	
-	hd += bio_numbytes(bio);
-	bio_destroy(bio);
+	l_header_data += bio_numbytes(l_bio);
+	bio_destroy(l_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");
+	if (p_tcp->csty & J2K_CP_CSTY_EPH) {
+		if ((*l_header_data) != 0xff || (*(l_header_data + 1) != 0x92)) {
+			// TODO opj_event_msg(t2->cinfo->event_mgr, EVT_ERROR, "Expected EPH marker\n");
 		} else {
-			hd += 2;
+			l_header_data += 2;
 		}
 	}
 
+	
+	l_header_length = (l_header_data - *l_header_data_start);
+	*l_modified_length_ptr -= l_header_length;
+	*l_header_data_start += l_header_length;
 	/* << 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);
+	if
+		(p_pack_info) 
+	{
+		p_pack_info->end_ph_pos = (OPJ_INT32)(l_current_data - p_src_data);
 	}
 	/* 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;
+	* p_is_data_present = true;
+	*p_data_read = l_current_data - p_src_data;
+	return true;
+}
+
+static bool t2_read_packet_data(
+							 opj_t2_t* p_t2,
+							 opj_tcd_tile_t *p_tile,
+							 opj_pi_iterator_t *p_pi,
+							 OPJ_BYTE *p_src_data, 
+							 OPJ_UINT32 * p_data_read,
+							 OPJ_UINT32 p_max_length,  
+							 opj_packet_info_t *pack_info)
+{
+	OPJ_UINT32 bandno, cblkno;
+	OPJ_UINT32 l_nb_code_blocks;
+	OPJ_BYTE *l_current_data = p_src_data;
+	opj_tcd_band_t *l_band = 00;
+	opj_tcd_cblk_dec_t* l_cblk = 00;
+	opj_tcd_resolution_t* l_res = &p_tile->comps[p_pi->compno].resolutions[p_pi->resno];
+
+	l_band = l_res->bands;
+	for 
+		(bandno = 0; bandno < l_res->numbands; ++bandno) 
+	{
+		opj_tcd_precinct_t *l_prc = &l_band->precincts[p_pi->precno];
 		
-		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)
+		if 
+			((l_band->x1-l_band->x0 == 0)||(l_band->y1-l_band->y0 == 0))
+		{
+			++l_band;
+			continue;
+		}
+		l_nb_code_blocks = l_prc->cw * l_prc->ch;
+		l_cblk = l_prc->cblks.dec;
+		for 
+			(cblkno = 0; cblkno < l_nb_code_blocks; ++cblkno) 
+		{
+			opj_tcd_seg_t *l_seg = 00;
+			if 
+				(!l_cblk->numnewpasses)
+			{
+				/* nothing to do */
+				++l_cblk;
 				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++;
+			}
+			if 
+				(!l_cblk->numsegs) 
+			{
+				l_seg = l_cblk->segs;
+				++l_cblk->numsegs;
+				l_cblk->len = 0;
+			} 
+			else 
+			{
+				l_seg = &l_cblk->segs[l_cblk->numsegs - 1];
+				if 
+					(l_seg->numpasses == l_seg->maxpasses) 
+				{
+					++l_seg;
+					++l_cblk->numsegs;
 				}
 			}
 			
-			do {
-				if (c + seg->newlen > src + len) {
-					return -999;
+			do 
+			{
+				if 
+					(l_current_data + l_seg->newlen > p_src_data + p_max_length) 
+				{
+					return false;
 				}
 
 #ifdef USE_JPWL
@@ -565,99 +790,337 @@ static int t2_decode_packet(opj_t2_t* t2, unsigned char *src, int len, opj_tcd_t
 
 #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;
+				memcpy(l_cblk->data + l_cblk->len, l_current_data, l_seg->newlen);
+				if 
+					(l_seg->numpasses == 0) 
+				{
+					l_seg->data = &l_cblk->data;
+					l_seg->dataindex = l_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++;
+				l_current_data += l_seg->newlen;
+				l_seg->numpasses += l_seg->numnewpasses;
+				l_cblk->numnewpasses -= l_seg->numnewpasses;
+
+				l_seg->real_num_passes = l_seg->numpasses;
+				l_cblk->len += l_seg->newlen;
+				l_seg->len += l_seg->newlen;
+				if 
+					(l_cblk->numnewpasses > 0) 
+				{
+					++l_seg;
+					++l_cblk->numsegs;
 				}
-			} while (cblk->numnewpasses > 0);
+			} 
+			while (l_cblk->numnewpasses > 0);
+			l_cblk->real_num_segs = l_cblk->numsegs;
+			++l_cblk;
 		}
+		++l_band;
 	}
+	*(p_data_read) = l_current_data - p_src_data;
+	return true;
+}
+
+
+static bool t2_skip_packet_data(
+							 opj_t2_t* p_t2,
+							 opj_tcd_tile_t *p_tile,
+							 opj_pi_iterator_t *p_pi,
+							 OPJ_UINT32 * p_data_read,
+							 OPJ_UINT32 p_max_length,  
+							 opj_packet_info_t *pack_info)
+{
+	OPJ_UINT32 bandno, cblkno;
+	OPJ_UINT32 l_nb_code_blocks;
+	opj_tcd_band_t *l_band = 00;
+	opj_tcd_cblk_dec_t* l_cblk = 00;
+
+	opj_tcd_resolution_t* l_res = &p_tile->comps[p_pi->compno].resolutions[p_pi->resno];
 	
-	return (c - src);
+	*p_data_read = 0;
+	l_band = l_res->bands;
+	for 
+		(bandno = 0; bandno < l_res->numbands; ++bandno) 
+	{
+		opj_tcd_precinct_t *l_prc = &l_band->precincts[p_pi->precno];
+		
+		if 
+			((l_band->x1-l_band->x0 == 0)||(l_band->y1-l_band->y0 == 0))
+		{
+			++l_band;
+			continue;
+		}
+		l_nb_code_blocks = l_prc->cw * l_prc->ch;
+		l_cblk = l_prc->cblks.dec;
+		for 
+			(cblkno = 0; cblkno < l_nb_code_blocks; ++cblkno) 
+		{
+			opj_tcd_seg_t *l_seg = 00;
+			if 
+				(!l_cblk->numnewpasses)
+			{
+				/* nothing to do */
+				++l_cblk;
+				continue;
+			}
+			if 
+				(!l_cblk->numsegs) 
+			{
+				l_seg = l_cblk->segs;
+				++l_cblk->numsegs;
+				l_cblk->len = 0;
+			} 
+			else 
+			{
+				l_seg = &l_cblk->segs[l_cblk->numsegs - 1];
+				if 
+					(l_seg->numpasses == l_seg->maxpasses) 
+				{
+					++l_seg;
+					++l_cblk->numsegs;
+				}
+			}
+			
+			do 
+			{
+				if 
+					(* p_data_read + l_seg->newlen > p_max_length) 
+				{
+					return false;
+				}
+
+#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 */
+				*(p_data_read) += l_seg->newlen;
+				l_seg->numpasses += l_seg->numnewpasses;
+				l_cblk->numnewpasses -= l_seg->numnewpasses;
+				if 
+					(l_cblk->numnewpasses > 0) 
+				{
+					++l_seg;
+					++l_cblk->numsegs;
+				}
+			} 
+			while (l_cblk->numnewpasses > 0);
+			++l_cblk;
+		}
+	}
+	return true;
 }
 
-/* ----------------------------------------------------------------------- */
+static bool t2_decode_packet(
+							 opj_t2_t* p_t2,
+							 opj_tcd_tile_t *p_tile,
+                             opj_tcp_t *p_tcp, 
+							 opj_pi_iterator_t *p_pi,
+							 OPJ_BYTE *p_src, 
+							 OPJ_UINT32 * p_data_read,
+							 OPJ_UINT32 p_max_length,  
+							 opj_packet_info_t *p_pack_info)
+{
+	bool l_read_data;
+	OPJ_UINT32 l_nb_bytes_read = 0;
+	OPJ_UINT32 l_nb_total_bytes_read = 0;
 
-int t2_encode_packets(opj_t2_t* t2,int tileno, opj_tcd_tile_t *tile, int maxlayers, unsigned char *dest, int len, opj_codestream_info_t *cstr_info,int tpnum, int tppos,int pino, J2K_T2_MODE t2_mode, int cur_totnum_tp){
-	unsigned char *c = dest;
-	int e = 0;
-	int compno;
-	opj_pi_iterator_t *pi = NULL;
-	int poc;
-	opj_image_t *image = t2->image;
-	opj_cp_t *cp = t2->cp;
-	opj_tcp_t *tcp = &cp->tcps[tileno];
-	int pocno = cp->cinema == CINEMA4K_24? 2: 1;
-	int maxcomp = cp->max_comp_size > 0 ? image->numcomps : 1;
+	*p_data_read = 0;
 	
-	pi = pi_initialise_encode(image, cp, tileno, t2_mode);
-	if(!pi) {
-		/* TODO: throw an error */
-		return -999;
+	if
+		(! t2_read_packet_header(p_t2,p_tile,p_tcp,p_pi,&l_read_data,p_src,&l_nb_bytes_read,p_max_length,p_pack_info))
+	{
+		return false;
 	}
+	p_src += l_nb_bytes_read;
+	l_nb_total_bytes_read += l_nb_bytes_read;
+	p_max_length -= l_nb_bytes_read;
+	/* we should read data for the packet */
+	if
+		(l_read_data)
+	{
+		l_nb_bytes_read = 0;
+		if
+			(! t2_read_packet_data(p_t2,p_tile,p_pi,p_src,&l_nb_bytes_read,p_max_length,p_pack_info))
+		{
+			return false;
+		}
+		l_nb_total_bytes_read += l_nb_bytes_read;
+	}
+	*p_data_read = l_nb_total_bytes_read;
+	return true;
+}
+
+static bool t2_skip_packet(
+							 opj_t2_t* p_t2,
+							 opj_tcd_tile_t *p_tile,
+                             opj_tcp_t *p_tcp, 
+							 opj_pi_iterator_t *p_pi,
+							 OPJ_BYTE *p_src, 
+							 OPJ_UINT32 * p_data_read,
+							 OPJ_UINT32 p_max_length,  
+							 opj_packet_info_t *p_pack_info)
+{
+	bool l_read_data;
+	OPJ_UINT32 l_nb_bytes_read = 0;
+	OPJ_UINT32 l_nb_total_bytes_read = 0;
+
+	*p_data_read = 0;
 	
-	if(t2_mode == THRESH_CALC ){ /* Calculating threshold */
-		for(compno = 0; compno < maxcomp; compno++ ){
-			for(poc = 0; poc < pocno ; poc++){
-				int comp_len = 0;
-				int tpnum = compno;
-				if (pi_create_encode(pi, cp,tileno,poc,tpnum,tppos,t2_mode,cur_totnum_tp)) {
-					opj_event_msg(t2->cinfo, EVT_ERROR, "Error initializing Packet Iterator\n");
-					return -999;
-				}
-				while (pi_next(&pi[poc])) {
-					if (pi[poc].layno < maxlayers) {
-						e = t2_encode_packet(tile, &cp->tcps[tileno], &pi[poc], c, dest + len - c, cstr_info, tileno);
-						comp_len = comp_len + e;
-						if (e == -999) {
-							break;
-						} else {
-							c += e;
+	if
+		(! t2_read_packet_header(p_t2,p_tile,p_tcp,p_pi,&l_read_data,p_src,&l_nb_bytes_read,p_max_length,p_pack_info))
+	{
+		return false;
+	}
+	p_src += l_nb_bytes_read;
+	l_nb_total_bytes_read += l_nb_bytes_read;
+	p_max_length -= l_nb_bytes_read;
+	/* we should read data for the packet */
+	if
+		(l_read_data)
+	{
+		l_nb_bytes_read = 0;
+		if
+			(! t2_skip_packet_data(p_t2,p_tile,p_pi,&l_nb_bytes_read,p_max_length,p_pack_info))
+		{
+			return false;
+		}
+		l_nb_total_bytes_read += l_nb_bytes_read;
+	}
+	*p_data_read = l_nb_total_bytes_read;
+	return true;
+}
+
+/* ----------------------------------------------------------------------- */
+
+bool t2_encode_packets(
+					   opj_t2_t* p_t2,
+					   OPJ_UINT32 p_tile_no, 
+					   opj_tcd_tile_t *p_tile, 
+					   OPJ_UINT32 p_maxlayers, 
+					   OPJ_BYTE *p_dest,
+					   OPJ_UINT32 * p_data_written, 
+					   OPJ_UINT32 p_max_len, 
+					   opj_codestream_info_t *cstr_info,
+					   OPJ_UINT32 p_tp_num, 
+					   OPJ_INT32 p_tp_pos,
+					   OPJ_UINT32 p_pino, 
+					   J2K_T2_MODE p_t2_mode)
+{
+	OPJ_BYTE *l_current_data = p_dest;
+	OPJ_UINT32 l_nb_bytes = 0;
+	OPJ_UINT32 compno;
+	OPJ_UINT32 poc;
+	opj_pi_iterator_t *l_pi = 00;
+	opj_pi_iterator_t *l_current_pi = 00;
+	opj_image_t *l_image = p_t2->image;
+	opj_cp_t *l_cp = p_t2->cp;
+	opj_tcp_t *l_tcp = &l_cp->tcps[p_tile_no];
+	OPJ_UINT32 pocno = l_cp->m_specific_param.m_enc.m_cinema == CINEMA4K_24? 2: 1;
+	OPJ_UINT32 l_max_comp = l_cp->m_specific_param.m_enc.m_max_comp_size > 0 ? l_image->numcomps : 1;
+	OPJ_UINT32 l_nb_pocs = l_tcp->numpocs + 1;
+
+	l_pi = pi_initialise_encode(l_image, l_cp, p_tile_no, p_t2_mode);
+	if
+		(!l_pi) 
+	{
+		return false;
+	}
+	* p_data_written = 0;
+	if
+		(p_t2_mode == THRESH_CALC )
+	{ /* Calculating threshold */
+		l_current_pi = l_pi;
+		for
+			(compno = 0; compno < l_max_comp; ++compno)
+		{
+			OPJ_UINT32 l_comp_len = 0;
+			l_current_pi = l_pi;
+
+			for
+				(poc = 0; poc < pocno ; ++poc)
+			{
+				OPJ_UINT32 l_tp_num = compno;
+				pi_create_encode(l_pi, l_cp,p_tile_no,poc,l_tp_num,p_tp_pos,p_t2_mode);
+				while 
+					(pi_next(l_current_pi)) 
+				{
+					if 
+						(l_current_pi->layno < p_maxlayers) 
+					{
+						l_nb_bytes = 0;
+						if
+							(! t2_encode_packet(p_tile_no,p_tile, l_tcp, l_current_pi, l_current_data, &l_nb_bytes, p_max_len, cstr_info))
+						{
+							pi_destroy(l_pi, l_nb_pocs);
+							return false;
 						}
+						l_comp_len += l_nb_bytes;
+						l_current_data += l_nb_bytes;
+						p_max_len -= l_nb_bytes;
+						* p_data_written += l_nb_bytes;
 					}
 				}
-				if (e == -999) break;
-				if (cp->max_comp_size){
-					if (comp_len > cp->max_comp_size){
-						e = -999;
-						break;
+				if 
+					(l_cp->m_specific_param.m_enc.m_max_comp_size)
+				{
+					if 
+						(l_comp_len > l_cp->m_specific_param.m_enc.m_max_comp_size)
+					{
+						pi_destroy(l_pi, l_nb_pocs);
+						return false;
 					}
 				}
+				++l_current_pi;
 			}
-			if (e == -999)  break;
 		}
-	}else{  /* t2_mode == FINAL_PASS  */
-		pi_create_encode(pi, cp,tileno,pino,tpnum,tppos,t2_mode,cur_totnum_tp);
-		while (pi_next(&pi[pino])) {
-			if (pi[pino].layno < maxlayers) {
-				e = t2_encode_packet(tile, &cp->tcps[tileno], &pi[pino], c, dest + len - c, cstr_info, tileno);
-				if (e == -999) {
-					break;
-				} else {
-					c += e;
+	}
+	else
+	{  /* t2_mode == FINAL_PASS  */
+		pi_create_encode(l_pi, l_cp,p_tile_no,p_pino,p_tp_num,p_tp_pos,p_t2_mode);
+		l_current_pi = &l_pi[p_pino];
+		while 
+			(pi_next(l_current_pi)) 
+		{
+			if 
+				(l_current_pi->layno < p_maxlayers) 
+			{
+				l_nb_bytes=0;
+				if
+					(! t2_encode_packet(p_tile_no,p_tile, l_tcp, l_current_pi, l_current_data, &l_nb_bytes, p_max_len, cstr_info))
+				{
+					pi_destroy(l_pi, l_nb_pocs);
+					return false;
 				}
+				l_current_data += l_nb_bytes;
+				p_max_len -= l_nb_bytes;
+				* p_data_written += l_nb_bytes;
+
 				/* INDEX >> */
 				if(cstr_info) {
 					if(cstr_info->index_write) {
-						opj_tile_info_t *info_TL = &cstr_info->tile[tileno];
+						opj_tile_info_t *info_TL = &cstr_info->tile[p_tile_no];
 						opj_packet_info_t *info_PK = &info_TL->packet[cstr_info->packno];
 						if (!cstr_info->packno) {
 							info_PK->start_pos = info_TL->end_header + 1;
 						} else {
-							info_PK->start_pos = ((cp->tp_on | tcp->POC)&& info_PK->start_pos) ? info_PK->start_pos : info_TL->packet[cstr_info->packno - 1].end_pos + 1;
+							info_PK->start_pos = ((l_cp->m_specific_param.m_enc.m_tp_on | l_tcp->POC)&& info_PK->start_pos) ? info_PK->start_pos : info_TL->packet[cstr_info->packno - 1].end_pos + 1;
 						}
-						info_PK->end_pos = info_PK->start_pos + e - 1;
+						info_PK->end_pos = info_PK->start_pos + l_nb_bytes - 1;
 						info_PK->end_ph_pos += info_PK->start_pos - 1;	// End of packet header which now only represents the distance 
 																														// to start of packet is incremented by value of start of packet
 					}
@@ -665,123 +1128,163 @@ int t2_encode_packets(opj_t2_t* t2,int tileno, opj_tcd_tile_t *tile, int maxlaye
 					cstr_info->packno++;
 				}
 				/* << INDEX */
-				tile->packno++;
+				++p_tile->packno;
 			}
 		}
 	}
-	
-	pi_destroy(pi, cp, tileno);
-	
-	if (e == -999) {
-		return e;
-	}
-	
-  return (c - dest);
+	pi_destroy(l_pi, l_nb_pocs);
+	return true;
 }
 
-int t2_decode_packets(opj_t2_t *t2, unsigned char *src, int len, int tileno, opj_tcd_tile_t *tile, opj_codestream_info_t *cstr_info) {
-	unsigned char *c = src;
-	opj_pi_iterator_t *pi;
-	int pino, e = 0;
-	int n = 0, curtp = 0;
-	int tp_start_packno;
+bool t2_decode_packets(
+						opj_t2_t *p_t2, 
+						OPJ_UINT32 p_tile_no,
+						struct opj_tcd_tile *p_tile, 
+						OPJ_BYTE *p_src,
+						OPJ_UINT32 * p_data_read, 
+						OPJ_UINT32 p_max_len,   
+						struct opj_codestream_info *p_cstr_info) 
+{
+	OPJ_BYTE *l_current_data = p_src;
+	opj_pi_iterator_t *l_pi = 00;
+	OPJ_UINT32 pino;
+	opj_image_t *l_image = p_t2->image;
+	opj_cp_t *l_cp = p_t2->cp;
+	opj_cp_t *cp = p_t2->cp;
+	opj_tcp_t *l_tcp = &(p_t2->cp->tcps[p_tile_no]);
+	OPJ_UINT32 l_nb_bytes_read;
+	OPJ_UINT32 l_nb_pocs = l_tcp->numpocs + 1;
+	opj_pi_iterator_t *l_current_pi = 00;
+	OPJ_UINT32 curtp = 0;
+	OPJ_UINT32 tp_start_packno;
+	opj_packet_info_t *l_pack_info = 00;
+	opj_image_comp_t* l_img_comp = 00;
 
-	opj_image_t *image = t2->image;
-	opj_cp_t *cp = t2->cp;
+	
+	if 
+		(p_cstr_info)
+	{
+		l_pack_info = p_cstr_info->tile[p_tile_no].packet;
+	}
 	
 	/* create a packet iterator */
-	pi = pi_create_decode(image, cp, tileno);
-	if(!pi) {
-		/* TODO: throw an error */
-		return -999;
+	l_pi = pi_create_decode(l_image, l_cp, p_tile_no);
+	if
+		(!l_pi) 
+	{
+		return false;
 	}
 
 	tp_start_packno = 0;
+	l_current_pi = l_pi;
 	
-	for (pino = 0; pino <= cp->tcps[tileno].numpocs; pino++) {
-		while (pi_next(&pi[pino])) {
-			if ((cp->layer==0) || (cp->layer>=((pi[pino].layno)+1))) {
-				opj_packet_info_t *pack_info;
-				if (cstr_info)
-					pack_info = &cstr_info->tile[tileno].packet[cstr_info->packno];
-				else
-					pack_info = NULL;
-				e = t2_decode_packet(t2, c, src + len - c, tile, &cp->tcps[tileno], &pi[pino], pack_info);
-			} else {
-				e = 0;
-			}
+	for 
+		(pino = 0; pino <= l_tcp->numpocs; ++pino) 
+	{
+		while 
+			(pi_next(l_current_pi)) 
+		{
 			
-			/* progression in resolution */
-			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 
+				(l_tcp->num_layers_to_decode > l_current_pi->layno && l_current_pi->resno < p_tile->comps[l_current_pi->compno].minimum_num_resolutions) 
+			{
+				l_nb_bytes_read = 0;
+				if
+					(! t2_decode_packet(p_t2,p_tile,l_tcp,l_current_pi,l_current_data,&l_nb_bytes_read,p_max_len,l_pack_info))
+				{
+					pi_destroy(l_pi,l_nb_pocs);
+					return false;
+				}
+				l_img_comp = &(l_image->comps[l_current_pi->compno]);
+				l_img_comp->resno_decoded = uint_max(l_current_pi->resno, l_img_comp->resno_decoded);
+			}	
+			else 
+			{
+				l_nb_bytes_read = 0;
+				if
+					(! t2_skip_packet(p_t2,p_tile,l_tcp,l_current_pi,l_current_data,&l_nb_bytes_read,p_max_len,l_pack_info))
+				{
+					pi_destroy(l_pi,l_nb_pocs);
+					return false;
+				}
+			}
+			l_current_data += l_nb_bytes_read;
+			p_max_len -= l_nb_bytes_read;
 
 			/* INDEX >> */
-			if(cstr_info) {
-				opj_tile_info_t *info_TL = &cstr_info->tile[tileno];
-				opj_packet_info_t *info_PK = &info_TL->packet[cstr_info->packno];
-				if (!cstr_info->packno) {
+			if(p_cstr_info) {
+				opj_tile_info_t *info_TL = &p_cstr_info->tile[p_tile_no];
+				opj_packet_info_t *info_PK = &info_TL->packet[p_cstr_info->packno];
+				if (!p_cstr_info->packno) {
 					info_PK->start_pos = info_TL->end_header + 1;
-				} else if (info_TL->packet[cstr_info->packno-1].end_pos >= (int)cstr_info->tile[tileno].tp[curtp].tp_end_pos){ // New tile part
-					info_TL->tp[curtp].tp_numpacks = cstr_info->packno - tp_start_packno; // Number of packets in previous tile-part
-					tp_start_packno = cstr_info->packno;
+				} else if (info_TL->packet[p_cstr_info->packno-1].end_pos >= (OPJ_INT32)p_cstr_info->tile[p_tile_no].tp[curtp].tp_end_pos){ // New tile part
+					info_TL->tp[curtp].tp_numpacks = p_cstr_info->packno - tp_start_packno; // Number of packets in previous tile-part
+					tp_start_packno = p_cstr_info->packno;
 					curtp++;
-					info_PK->start_pos = cstr_info->tile[tileno].tp[curtp].tp_end_header+1;
+					info_PK->start_pos = p_cstr_info->tile[p_tile_no].tp[curtp].tp_end_header+1;
 				} else {
-					info_PK->start_pos = (cp->tp_on && info_PK->start_pos) ? info_PK->start_pos : info_TL->packet[cstr_info->packno - 1].end_pos + 1;
+					info_PK->start_pos = (cp->m_specific_param.m_enc.m_tp_on && info_PK->start_pos) ? info_PK->start_pos : info_TL->packet[p_cstr_info->packno - 1].end_pos + 1;
 				}
-				info_PK->end_pos = info_PK->start_pos + e - 1;
+				info_PK->end_pos = info_PK->start_pos + l_nb_bytes_read - 1;
 				info_PK->end_ph_pos += info_PK->start_pos - 1;	// End of packet header which now only represents the distance 
-																												// to start of packet is incremented by value of start of packet
-				cstr_info->packno++;
+				++p_cstr_info->packno;
 			}
 			/* << INDEX */
-			
-			if (e == -999) {		/* ADD */
-				break;
-			} else {
-				c += e;
-			}			
 		}
+		++l_current_pi;
 	}
 	/* INDEX >> */
-	if(cstr_info) {
-		cstr_info->tile[tileno].tp[curtp].tp_numpacks = cstr_info->packno - tp_start_packno; // Number of packets in last tile-part
+	if
+		(p_cstr_info) {
+		p_cstr_info->tile[p_tile_no].tp[curtp].tp_numpacks = p_cstr_info->packno - tp_start_packno; // Number of packets in last tile-part
 	}
 	/* << INDEX */
 
 	/* don't forget to release pi */
-	pi_destroy(pi, cp, tileno);
-	
-	if (e == -999) {
-		return e;
-	}
-	
-	return (c - src);
+	pi_destroy(l_pi,l_nb_pocs);
+	*p_data_read = l_current_data - p_src;
+	return true;
 }
 
 /* ----------------------------------------------------------------------- */
-
-opj_t2_t* t2_create(opj_common_ptr cinfo, opj_image_t *image, opj_cp_t *cp) {
+/**
+ * Creates a Tier 2 handle
+ * 
+ * @param	p_image		Source or destination image
+ * @param	p_cp		Image coding parameters.
+ * @return		a new T2 handle if successful, NULL otherwise.
+*/
+opj_t2_t* t2_create(
+					opj_image_t *p_image, 
+					opj_cp_t *p_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;
+	opj_t2_t *l_t2 = (opj_t2_t*)opj_malloc(sizeof(opj_t2_t));
+	if
+		(!l_t2) 
+	{
+		return 00;
+	}
+	memset(l_t2,0,sizeof(opj_t2_t));
+	l_t2->image = p_image;
+	l_t2->cp = p_cp;
+	return l_t2;
 }
 
-void t2_destroy(opj_t2_t *t2) {
-	if(t2) {
-		opj_free(t2);
+/**
+ * Destroys a Tier 2 handle.
+ * 
+ * @param	p_t2	the Tier 2 handle to destroy
+*/
+void t2_destroy(opj_t2_t *p_t2) 
+{
+	if
+		(p_t2) 
+	{
+		opj_free(p_t2);
 	}
 }
 
 
 
 
-