X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libopenjpeg%2Fj2k.c;h=660e91b09bc7072e27957de48b14f5598800175c;hb=440adddcde73ff60c947f5c48de342c063f6aa3f;hp=e3e4c4987f606c5ae6207d1a5427da35be67f899;hpb=27e255fa75b7b9e989de3ec379c9de2b7462983b;p=openjpeg.git

diff --git a/libopenjpeg/j2k.c b/libopenjpeg/j2k.c
index e3e4c498..660e91b0 100644
--- a/libopenjpeg/j2k.c
+++ b/libopenjpeg/j2k.c
@@ -5,8 +5,10 @@
  * 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>
  * Copyright (c) 2006-2007, Parvatha Elangovan
  * Copyright (c) 2010-2011, Kaori Hagihara
+ * Copyright (c) 2011, Mickael Savinaud, Communications & Systemes <mickael.savinaud@c-s.fr>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -124,11 +126,11 @@ static const struct opj_dec_memory_marker_handler * j2k_get_marker_handler (OPJ_
 static void j2k_tcp_destroy (opj_tcp_v2_t *p_tcp);
 
 /**
- * Destroys a codestream index structure.
+ * Destroys the data inside a tile coding parameter structure.
  *
- * @param	p_cstr_ind	the codestream index parameter to destroy.
+ * @param	p_tcp		the tile coding parameter which contain data to destroy.
  */
-static void j2k_destroy_cstr_index (opj_codestream_index_t* p_cstr_ind);
+static void j2k_tcp_data_destroy (opj_tcp_v2_t *p_tcp);
 
 /**
  * Destroys a coding parameter structure.
@@ -197,7 +199,7 @@ opj_bool j2k_decode_tiles (		opj_j2k_v2_t *p_j2k,
 								opj_stream_private_t *p_stream,
 								opj_event_mgr_t * p_manager);
 
-static opj_bool j2k_update_image_data (opj_tcd_v2_t * p_tcd, OPJ_BYTE * p_data);
+static opj_bool j2k_update_image_data (opj_tcd_v2_t * p_tcd, OPJ_BYTE * p_data, opj_image_t* p_output_image);
 
 
 /*
@@ -673,7 +675,7 @@ Add main header marker information
  */
 static void j2k_add_mhmarker(opj_codestream_info_t *cstr_info, unsigned short int type, int pos, int len);
 
-static void j2k_add_mhmarker_v2(opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_UINT32 pos, OPJ_UINT32 len) ;
+static void j2k_add_mhmarker_v2(opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_OFF_T pos, OPJ_UINT32 len) ;
 /**
 Add tile header marker information
 @param tileno tile index number
@@ -684,6 +686,7 @@ Add tile header marker information
  */
 static void j2k_add_tlmarker( int tileno, opj_codestream_info_t *cstr_info, unsigned short int type, int pos, int len);
 
+static void j2k_add_tlmarker_v2(OPJ_UINT32 tileno, opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_OFF_T pos, OPJ_UINT32 len);
 
 /**
  * Reads an unknown marker
@@ -768,17 +771,6 @@ static opj_bool j2k_read_cbd (	opj_j2k_v2_t *p_j2k,
 							struct opj_event_mgr * p_manager);
 
 
-/**
- * Copy the image header from the jpeg2000 codec into an external image_header
- *
- * @param	p_j2k			the jpeg2000 codec.
- * @param	p_image_header	the external empty image header
- *
- * @return	true			if the image header is correctly copy.
- */
-static opj_bool j2k_copy_img_header(opj_j2k_v2_t* p_j2k, opj_image_t** p_image);
-
-
 static void j2k_dump_MH_info(opj_j2k_v2_t* p_j2k, FILE* out_stream);
 
 static void j2k_dump_MH_index(opj_j2k_v2_t* p_j2k, FILE* out_stream);
@@ -804,6 +796,8 @@ j2k_prog_order_t j2k_prog_order_list[] = {
 	{(OPJ_PROG_ORDER)-1, ""}
 };
 
+
+
 /**
  * FIXME DOC
  */
@@ -1251,7 +1245,7 @@ static opj_bool j2k_read_soc_v2(	opj_j2k_v2_t *p_j2k,
 	p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_MHSIZ;
 
 	/* FIXME move it in a index structure included in p_j2k*/
-	p_j2k->cstr_index->main_head_start = (OPJ_UINT32) opj_stream_tell(p_stream) - 2;
+	p_j2k->cstr_index->main_head_start = opj_stream_tell(p_stream) - 2;
 
 	opj_event_msg_v2(p_manager, EVT_INFO, "Start to read j2k main header (%d).\n", p_j2k->cstr_index->main_head_start);
 
@@ -1536,7 +1530,7 @@ opj_bool j2k_read_siz_v2 (
 	assert(p_manager != 00);
 	assert(p_header_data != 00);
 
-	l_image = p_j2k->m_image;
+	l_image = p_j2k->m_private_image;
 	l_cp = &(p_j2k->m_cp);
 
 	// minimum size == 39 - 3 (= minimum component parameter)
@@ -2036,7 +2030,7 @@ opj_bool j2k_read_cod_v2 (
 	assert(p_j2k != 00);
 	assert(p_manager != 00);
 
-	l_image = p_j2k->m_image;
+	l_image = p_j2k->m_private_image;
 	l_cp = &(p_j2k->m_cp);
 
 	/* If we are in the first tile-part header of the current tile */
@@ -2166,7 +2160,7 @@ opj_bool j2k_read_coc_v2 (
 	l_tcp = (p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH ) ? /*FIXME J2K_DEC_STATE_TPH*/
 				&l_cp->tcps[p_j2k->m_current_tile_number] :
 				p_j2k->m_specific_param.m_decoder.m_default_tcp;
-	l_image = p_j2k->m_image;
+	l_image = p_j2k->m_private_image;
 
 	l_comp_room = l_image->numcomps <= 256 ? 1 : 2;
 
@@ -2436,7 +2430,7 @@ opj_bool j2k_read_qcc_v2(	opj_j2k_v2_t *p_j2k,
 	assert(p_j2k != 00);
 	assert(p_manager != 00);
 
-	l_num_comp = p_j2k->m_image->numcomps;
+	l_num_comp = p_j2k->m_private_image->numcomps;
 
 	if (l_num_comp <= 256) {
 		if (p_header_size < 1) {
@@ -2582,7 +2576,7 @@ opj_bool j2k_read_poc_v2 (
 	assert(p_j2k != 00);
 	assert(p_manager != 00);
 
-	l_image = p_j2k->m_image;
+	l_image = p_j2k->m_private_image;
 	l_nb_comp = l_image->numcomps;
 	if (l_nb_comp <= 256) {
 		l_comp_room = 1;
@@ -2669,7 +2663,7 @@ opj_bool j2k_read_crg_v2 (
 	assert(p_j2k != 00);
 	assert(p_manager != 00);
 
-	l_nb_comp = p_j2k->m_image->numcomps;
+	l_nb_comp = p_j2k->m_private_image->numcomps;
 
 	if (p_header_size != l_nb_comp *4) {
 		opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading CRG marker\n");
@@ -3699,14 +3693,61 @@ opj_bool j2k_read_sot_v2 (
 
 	p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_TPH;
 
-	/* Check if the current tile is outside the area we want decode (in tile index)*/
-	p_j2k->m_specific_param.m_decoder.m_skip_data =
-			(l_tile_x < p_j2k->m_specific_param.m_decoder.m_start_tile_x)
-		||	(l_tile_x >= p_j2k->m_specific_param.m_decoder.m_end_tile_x)
-		||  (l_tile_y < p_j2k->m_specific_param.m_decoder.m_start_tile_y)
-		||	(l_tile_y >= p_j2k->m_specific_param.m_decoder.m_end_tile_y);
+	/* Check if the current tile is outside the area we want decode or not corresponding to the tile index*/
+	if (p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec == -1) {
+		p_j2k->m_specific_param.m_decoder.m_skip_data =
+				(l_tile_x < p_j2k->m_specific_param.m_decoder.m_start_tile_x)
+			||	(l_tile_x >= p_j2k->m_specific_param.m_decoder.m_end_tile_x)
+			||  (l_tile_y < p_j2k->m_specific_param.m_decoder.m_start_tile_y)
+			||	(l_tile_y >= p_j2k->m_specific_param.m_decoder.m_end_tile_y);
+	}
+	else
+		p_j2k->m_specific_param.m_decoder.m_skip_data =
+			(p_j2k->m_current_tile_number != p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec);
 
 	/* Index */
+	if (p_j2k->cstr_index)
+	{
+		p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tileno = p_j2k->m_current_tile_number;
+		p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_tpsno = l_current_part;
+
+		if (l_num_parts != 0){
+			p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].nb_tps = l_num_parts;
+			p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps = l_num_parts;
+
+
+			if (!p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index)
+				p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index =
+					(opj_tp_index_t*)opj_calloc(l_num_parts, sizeof(opj_tp_index_t));
+			else
+				p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index =
+					(opj_tp_index_t*)opj_realloc(
+							p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index,
+							l_num_parts* sizeof(opj_tp_index_t));
+		}
+		else{
+			/*if (!p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index)*/ {
+
+				if (!p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index) {
+					p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps = 10;
+					p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index =
+						(opj_tp_index_t*)opj_calloc( p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps,
+													 sizeof(opj_tp_index_t));
+				}
+
+				if ( l_current_part >= p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps ){
+					p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps += 10;
+					p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index =
+						(opj_tp_index_t*)opj_realloc( p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index,
+													  p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps
+													  * sizeof(opj_tp_index_t));
+				}
+			}
+
+		}
+
+	}
+
 
 	/* FIXME move this onto a separate method to call before reading any SOT, remove part about main_end header, use a index struct inside p_j2k */
 	/* if (p_j2k->cstr_info) {
@@ -3879,8 +3920,13 @@ opj_bool j2k_read_sod_v2 (
 
 	l_tcp = &(p_j2k->m_cp.tcps[p_j2k->m_current_tile_number]);
 
-	if (p_j2k->m_specific_param.m_decoder.m_last_tile_part)
-		p_j2k->m_specific_param.m_decoder.m_sot_length = opj_stream_get_number_byte_left(p_stream) - 2;
+	if (p_j2k->m_specific_param.m_decoder.m_last_tile_part) {
+		// opj_stream_get_number_byte_left returns OPJ_OFF_T
+		// but we are in the last tile part,
+		// so its result will fit on OPJ_UINT32 unless we find
+		// a file with a single tile part of more than 4 GB...
+		p_j2k->m_specific_param.m_decoder.m_sot_length = (OPJ_UINT32)(opj_stream_get_number_byte_left(p_stream) - 2);
+	}
 	else
 		p_j2k->m_specific_param.m_decoder.m_sot_length -= 2;
 
@@ -3888,10 +3934,10 @@ opj_bool j2k_read_sod_v2 (
 	l_tile_len = &l_tcp->m_data_size;
 
 	if (! *l_current_data) {
-		*l_current_data = (OPJ_BYTE*) opj_malloc/*FIXME V2 -> my_opj_malloc*/(p_j2k->m_specific_param.m_decoder.m_sot_length);
+		*l_current_data = (OPJ_BYTE*) opj_malloc(p_j2k->m_specific_param.m_decoder.m_sot_length);
 	}
 	else {
-		*l_current_data = (OPJ_BYTE*) opj_realloc/*FIXME V2 -> my_opj_realloc*/(*l_current_data, *l_tile_len + p_j2k->m_specific_param.m_decoder.m_sot_length);
+		*l_current_data = (OPJ_BYTE*) opj_realloc(*l_current_data, *l_tile_len + p_j2k->m_specific_param.m_decoder.m_sot_length);
 	}
 
 	if (*l_current_data == 00) {
@@ -3899,17 +3945,26 @@ opj_bool j2k_read_sod_v2 (
 		return OPJ_FALSE;
 	}
 
-#ifdef TODO_MSD /* FIXME */
-	l_cstr_index = p_j2k->cstr_index;
 
 	/* Index */
+	l_cstr_index = p_j2k->cstr_index;
 	if (l_cstr_index) {
-		OPJ_SIZE_T l_current_pos = opj_stream_tell(p_stream)-1;
-		l_cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index[p_j2k->m_specific_param.m_encoder.m_current_tile_part_number].tp_end_header = l_current_pos;
+		OPJ_OFF_T l_current_pos = opj_stream_tell(p_stream) - 2;
 
-		l_cstr_index->packno = 0;
+		OPJ_UINT32 l_current_tile_part = l_cstr_index->tile_index[p_j2k->m_current_tile_number].current_tpsno;
+		l_cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index[l_current_tile_part].end_header =
+				l_current_pos;
+		l_cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index[l_current_tile_part].end_pos =
+				l_current_pos + p_j2k->m_specific_param.m_decoder.m_sot_length + 2;
+
+		j2k_add_tlmarker_v2(p_j2k->m_current_tile_number,
+							l_cstr_index,
+							J2K_MS_SOD,
+							l_current_pos,
+							p_j2k->m_specific_param.m_decoder.m_sot_length + 2);
+
+		/*l_cstr_index->packno = 0;*/
 	}
-#endif
 
 	l_current_read_size = opj_stream_read_data(	p_stream,
 												*l_current_data + *l_tile_len,
@@ -4012,7 +4067,7 @@ opj_bool j2k_read_rgn_v2 (
 	assert(p_j2k != 00);
 	assert(p_manager != 00);
 
-	l_image = p_j2k->m_image;
+	l_image = p_j2k->m_private_image;
 	l_nb_comp = l_image->numcomps;
 
 	if (l_nb_comp <= 256) {
@@ -4688,7 +4743,7 @@ opj_bool j2k_read_mco (	opj_j2k_v2_t *p_j2k,
 	assert(p_j2k != 00);
 	assert(p_manager != 00);
 
-	l_image = p_j2k->m_image;
+	l_image = p_j2k->m_private_image;
 	l_tcp = p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH ?
 			&p_j2k->m_cp.tcps[p_j2k->m_current_tile_number] :
 			p_j2k->m_specific_param.m_decoder.m_default_tcp;
@@ -4728,7 +4783,7 @@ opj_bool j2k_read_mco (	opj_j2k_v2_t *p_j2k,
 		opj_read_bytes(p_header_data,&l_tmp,1);
 		++p_header_data;
 
-		if (! j2k_add_mct(l_tcp,p_j2k->m_image,l_tmp)) {
+		if (! j2k_add_mct(l_tcp,p_j2k->m_private_image,l_tmp)) {
 			return OPJ_FALSE;
 		}
 	}
@@ -4840,9 +4895,9 @@ opj_bool j2k_read_cbd (	opj_j2k_v2_t *p_j2k,
 	assert(p_j2k != 00);
 	assert(p_manager != 00);
 
-	l_num_comp = p_j2k->m_image->numcomps;
+	l_num_comp = p_j2k->m_private_image->numcomps;
 
-	if (p_header_size != (p_j2k->m_image->numcomps + 2)) {
+	if (p_header_size != (p_j2k->m_private_image->numcomps + 2)) {
 		opj_event_msg_v2(p_manager, EVT_ERROR, "Crror reading CBD marker\n");
 		return OPJ_FALSE;
 	}
@@ -4855,7 +4910,7 @@ opj_bool j2k_read_cbd (	opj_j2k_v2_t *p_j2k,
 		return OPJ_FALSE;
 	}
 
-	l_comp = p_j2k->m_image->comps;
+	l_comp = p_j2k->m_private_image->comps;
 	for (i=0;i<l_num_comp;++i) {
 		opj_read_bytes(p_header_data,&l_comp_def,1);			/* Component bit depth */
 		++p_header_data;
@@ -5721,7 +5776,7 @@ static void j2k_add_mhmarker(opj_codestream_info_t *cstr_info, unsigned short in
 
 }
 
-static void j2k_add_mhmarker_v2(opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_UINT32 pos, OPJ_UINT32 len) {
+static void j2k_add_mhmarker_v2(opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_OFF_T pos, OPJ_UINT32 len) {
 
 	if (!cstr_index)
 		return;
@@ -5763,6 +5818,38 @@ static void j2k_add_tlmarker( int tileno, opj_codestream_info_t *cstr_info, unsi
 	cstr_info->tile[tileno].marknum++;
 }
 
+static void j2k_add_tlmarker_v2(OPJ_UINT32 tileno, opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_OFF_T pos, OPJ_UINT32 len)
+{
+
+	if (!cstr_index)
+		return;
+
+	if (!cstr_index->tile_index)
+
+	/* expand the list? */
+	if ((cstr_index->tile_index[tileno].marknum + 1) > cstr_index->tile_index[tileno].maxmarknum) {
+		cstr_index->tile_index[tileno].maxmarknum = 100 + (int) ((float) cstr_index->tile_index[tileno].maxmarknum * 1.0F);
+		cstr_index->tile_index[tileno].marker =
+				(opj_marker_info_t*)opj_realloc(cstr_index->tile_index[tileno].marker,
+												cstr_index->tile_index[tileno].maxmarknum *sizeof(opj_marker_info_t));
+	}
+
+	/* add the marker */
+	cstr_index->tile_index[tileno].marker[cstr_index->tile_index[tileno].marknum].type = (OPJ_UINT16)type;
+	cstr_index->tile_index[tileno].marker[cstr_index->tile_index[tileno].marknum].pos = (OPJ_INT32)pos;
+	cstr_index->tile_index[tileno].marker[cstr_index->tile_index[tileno].marknum].len = (OPJ_INT32)len;
+	cstr_index->tile_index[tileno].marknum++;
+
+	if (type == J2K_MS_SOT) {
+		OPJ_UINT32 l_current_tile_part = cstr_index->tile_index[tileno].current_tpsno;
+
+		if (cstr_index->tile_index[tileno].tp_index)
+			cstr_index->tile_index[tileno].tp_index[l_current_tile_part].start_pos = pos;
+
+	}
+
+}
+
 
 
 
@@ -5805,8 +5892,8 @@ opj_bool j2k_read_header(	struct opj_stream_private *p_stream,
 	assert(p_manager != 00);
 
 	/* create an empty image header */
-	p_j2k->m_image = opj_image_create0();
-	if (! p_j2k->m_image) {
+	p_j2k->m_private_image = opj_image_create0();
+	if (! p_j2k->m_private_image) {
 		return OPJ_FALSE;
 	}
 
@@ -5815,8 +5902,8 @@ opj_bool j2k_read_header(	struct opj_stream_private *p_stream,
 
 	/* validation of the parameters codec */
 	if (! j2k_exec(p_j2k, p_j2k->m_validation_list, p_stream,p_manager)) {
-		opj_image_destroy(p_j2k->m_image);
-		p_j2k->m_image = NULL;
+		opj_image_destroy(p_j2k->m_private_image);
+		p_j2k->m_private_image = NULL;
 		return OPJ_FALSE;
 	}
 
@@ -5825,8 +5912,8 @@ opj_bool j2k_read_header(	struct opj_stream_private *p_stream,
 
 	/* read header */
 	if (! j2k_exec (p_j2k,p_j2k->m_procedure_list,p_stream,p_manager)) {
-		opj_image_destroy(p_j2k->m_image);
-		p_j2k->m_image = NULL;
+		opj_image_destroy(p_j2k->m_private_image);
+		p_j2k->m_private_image = NULL;
 		return OPJ_FALSE;
 	}
 
@@ -5835,57 +5922,13 @@ opj_bool j2k_read_header(	struct opj_stream_private *p_stream,
 		return OPJ_FALSE;
 	}
 
-	if (! j2k_copy_img_header(p_j2k, p_image)){
-		opj_image_destroy(p_j2k->m_image);
-		p_j2k->m_image = NULL;
-		return OPJ_FALSE;
-	}
+	/* Copy codestream image information to the output image */
+	opj_copy_image_header(p_j2k->m_private_image, *p_image);
 
 
 	return OPJ_TRUE;
 }
 
-opj_bool j2k_copy_img_header(opj_j2k_v2_t* p_j2k, opj_image_t** p_image)
-{
-	OPJ_UINT16 compno;
-
-	/* preconditions */
-	assert(p_j2k != 00);
-
-	(*p_image)->x0 = p_j2k->m_image->x0;
-	(*p_image)->y0 = p_j2k->m_image->y0;
-	(*p_image)->x1 = p_j2k->m_image->x1;
-	(*p_image)->y1 = p_j2k->m_image->y1;
-
-	(*p_image)->numcomps = p_j2k->m_image->numcomps;
-	(*p_image)->comps = (opj_image_comp_t*)opj_malloc((*p_image)->numcomps * sizeof(opj_image_comp_t));
-	if (!(*p_image)->comps)
-		return OPJ_FALSE;
-	for (compno=0; compno < (*p_image)->numcomps; compno++){
-		memcpy( &((*p_image)->comps[compno]),
-				&(p_j2k->m_image->comps[compno]),
-				sizeof(opj_image_comp_t));
-	}
-
-	(*p_image)->color_space = p_j2k->m_image->color_space;
-	(*p_image)->icc_profile_len = p_j2k->m_image->icc_profile_len;
-	if (!(*p_image)->icc_profile_len) {
-
-		(*p_image)->icc_profile_buf = (unsigned char*)opj_malloc((*p_image)->icc_profile_len);
-		if (!(*p_image)->icc_profile_buf)
-			return OPJ_FALSE;
-		memcpy( (*p_image)->icc_profile_buf,
-				p_j2k->m_image->icc_profile_buf,
-				p_j2k->m_image->icc_profile_len);
-	}
-	else
-		(*p_image)->icc_profile_buf = NULL;
-
-	return OPJ_TRUE;
-}
-
-
-
 /**
  * Sets up the procedures to do on reading header. Developpers wanting to extend the library can add their own reading procedures.
  */
@@ -6157,7 +6200,7 @@ opj_bool j2k_copy_default_tcp_and_create_tcd
 	assert(p_stream != 00);
 	assert(p_manager != 00);
 
-	l_image = p_j2k->m_image;
+	l_image = p_j2k->m_private_image;
 	l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
 	l_tcp = p_j2k->m_cp.tcps;
 	l_tccp_size = l_image->numcomps * sizeof(opj_tccp_t);
@@ -6270,7 +6313,7 @@ opj_bool j2k_copy_default_tcp_and_create_tcd
  *
  * @return	the handler associated with the id.
 */
-const opj_dec_memory_marker_handler_t * j2k_get_marker_handler (const OPJ_UINT32 p_id)
+const opj_dec_memory_marker_handler_t * j2k_get_marker_handler (OPJ_UINT32 p_id)
 {
 	const opj_dec_memory_marker_handler_t *e;
 	for (e = j2k_memory_marker_handler_tab; e->id != 0; ++e) {
@@ -6341,8 +6384,11 @@ void j2k_destroy (opj_j2k_v2_t *p_j2k)
 	j2k_destroy_cstr_index(p_j2k->cstr_index);
 	p_j2k->cstr_index = NULL;
 
-	opj_image_destroy(p_j2k->m_image);
-	p_j2k->m_image = NULL;
+	opj_image_destroy(p_j2k->m_private_image);
+	p_j2k->m_private_image = NULL;
+
+	opj_image_destroy(p_j2k->m_output_image);
+	p_j2k->m_output_image = NULL;
 
 	opj_free(p_j2k);
 }
@@ -6357,7 +6403,29 @@ void j2k_destroy_cstr_index (opj_codestream_index_t *p_cstr_ind)
 		}
 
 		if (p_cstr_ind->tile_index) {
-			// FIXME not used for the moment
+			OPJ_UINT32 it_tile = 0;
+
+			for (it_tile=0; it_tile < p_cstr_ind->nb_of_tiles; it_tile++) {
+
+				if(p_cstr_ind->tile_index[it_tile].packet_index) {
+					opj_free(p_cstr_ind->tile_index[it_tile].packet_index);
+					p_cstr_ind->tile_index[it_tile].packet_index = NULL;
+				}
+
+				if(p_cstr_ind->tile_index[it_tile].tp_index){
+					opj_free(p_cstr_ind->tile_index[it_tile].tp_index);
+					p_cstr_ind->tile_index[it_tile].tp_index = NULL;
+				}
+
+				if(p_cstr_ind->tile_index[it_tile].marker){
+					opj_free(p_cstr_ind->tile_index[it_tile].marker);
+					p_cstr_ind->tile_index[it_tile].marker = NULL;
+
+				}
+			}
+
+			opj_free( p_cstr_ind->tile_index);
+			p_cstr_ind->tile_index = NULL;
 		}
 
 		opj_free(p_cstr_ind);
@@ -6426,13 +6494,24 @@ void j2k_tcp_destroy (opj_tcp_v2_t *p_tcp)
 		p_tcp->mct_norms = 00;
 	}
 
+	j2k_tcp_data_destroy(p_tcp);
+
+}
+
+/**
+ * Destroys the data inside a tile coding parameter structure.
+ *
+ * @param	p_tcp		the tile coding parameter which contain data to destroy.
+ */
+void j2k_tcp_data_destroy (opj_tcp_v2_t *p_tcp)
+{
 	if (p_tcp->m_data) {
 		opj_free(p_tcp->m_data);
-		p_tcp->m_data = 00;
+		p_tcp->m_data = NULL;
+		p_tcp->m_data_size = 0;
 	}
 }
 
-
 /**
  * Destroys a coding parameter structure.
  *
@@ -6579,6 +6658,23 @@ opj_bool j2k_read_tile_header(	opj_j2k_v2_t * p_j2k,
 				return OPJ_FALSE;
 			}
 
+			/* Add the marker to the codestream index*/
+			j2k_add_tlmarker_v2(p_j2k->m_current_tile_number,
+								p_j2k->cstr_index,
+								l_marker_handler->id,
+								(OPJ_UINT32) opj_stream_tell(p_stream) - l_marker_size - 4,
+								l_marker_size + 4 );
+
+			/* Keep the position of the last SOT marker read */
+			if ( l_marker_handler->id == J2K_MS_SOT ) {
+				OPJ_UINT32 sot_pos = (OPJ_UINT32) opj_stream_tell(p_stream) - l_marker_size - 4 ;
+				if (sot_pos > p_j2k->m_specific_param.m_decoder.m_last_sot_read_pos)
+				{
+					p_j2k->m_specific_param.m_decoder.m_last_sot_read_pos = sot_pos;
+				}
+			}
+
+
 			if (p_j2k->m_specific_param.m_decoder.m_skip_data) {
 				/* Skip the rest of the tile part header*/
 				if (opj_stream_skip(p_stream,p_j2k->m_specific_param.m_decoder.m_sot_length,p_manager) != p_j2k->m_specific_param.m_decoder.m_sot_length) {
@@ -6605,6 +6701,8 @@ opj_bool j2k_read_tile_header(	opj_j2k_v2_t * p_j2k,
 				return OPJ_FALSE;
 			}
 
+
+
 			if (! p_j2k->m_specific_param.m_decoder.m_can_decode){
 				/* Try to read 2 bytes (the next marker ID) from stream and copy them into the buffer */
 				if (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,2,p_manager) != 2) {
@@ -6664,7 +6762,7 @@ opj_bool j2k_read_tile_header(	opj_j2k_v2_t * p_j2k,
 	}
 
 	opj_event_msg_v2(p_manager, EVT_INFO, "Header of tile %d / %d has been read.\n",
-			p_j2k->m_current_tile_number +1, p_j2k->m_cp.th * p_j2k->m_cp.tw);
+			p_j2k->m_current_tile_number, (p_j2k->m_cp.th * p_j2k->m_cp.tw) - 1);
 
 	*p_tile_index = p_j2k->m_current_tile_number;
 	*p_go_on = OPJ_TRUE;
@@ -6704,7 +6802,7 @@ opj_bool j2k_decode_tile (	opj_j2k_v2_t * p_j2k,
 
 	l_tcp = &(p_j2k->m_cp.tcps[p_tile_index]);
 	if (! l_tcp->m_data) {
-		j2k_tcp_destroy(&(p_j2k->m_cp.tcps[p_tile_index]));
+		j2k_tcp_destroy(l_tcp);
 		return OPJ_FALSE;
 	}
 
@@ -6722,8 +6820,11 @@ opj_bool j2k_decode_tile (	opj_j2k_v2_t * p_j2k,
 		return OPJ_FALSE;
 	}
 
-	j2k_tcp_destroy(l_tcp);
-	p_j2k->m_tcd->tcp = 0;
+	/* To avoid to destroy the tcp which can be useful when we try to decode a tile decoded before (cf j2k_random_tile_access)
+	 * we destroy just the data which will be re-read in read_tile_header*/
+	/*j2k_tcp_destroy(l_tcp);
+	p_j2k->m_tcd->tcp = 0;*/
+	j2k_tcp_data_destroy(l_tcp);
 
 	p_j2k->m_specific_param.m_decoder.m_can_decode = 0;
 	p_j2k->m_specific_param.m_decoder.m_state &= (~ (0x0080));// FIXME J2K_DEC_STATE_DATA);
@@ -6751,37 +6852,51 @@ opj_bool j2k_decode_tile (	opj_j2k_v2_t * p_j2k,
 }
 
 
-opj_bool j2k_update_image_data (opj_tcd_v2_t * p_tcd, OPJ_BYTE * p_data)
+opj_bool j2k_update_image_data (opj_tcd_v2_t * p_tcd, OPJ_BYTE * p_data, opj_image_t* p_output_image)
 {
 	OPJ_UINT32 i,j,k = 0;
-	OPJ_UINT32 l_width,l_height,l_offset_x,l_offset_y;
-	opj_image_comp_t * l_img_comp = 00;
+	OPJ_UINT32 l_width_src,l_height_src;
+	OPJ_UINT32 l_width_dest,l_height_dest;
+	OPJ_INT32 l_offset_x0_src, l_offset_y0_src, l_offset_x1_src, l_offset_y1_src;
+	OPJ_INT32 l_start_offset_src, l_line_offset_src, l_end_offset_src ;
+	OPJ_UINT32 l_start_x_dest , l_start_y_dest;
+	OPJ_UINT32 l_x0_dest, l_y0_dest, l_x1_dest, l_y1_dest;
+	OPJ_INT32 l_start_offset_dest, l_line_offset_dest;
+
+	opj_image_comp_t * l_img_comp_src = 00;
+	opj_image_comp_t * l_img_comp_dest = 00;
+
 	opj_tcd_tilecomp_v2_t * l_tilec = 00;
-	opj_image_t * l_image = 00;
+	opj_image_t * l_image_src = 00;
 	OPJ_UINT32 l_size_comp, l_remaining;
-	OPJ_UINT32 l_dest_stride;
 	OPJ_INT32 * l_dest_ptr;
 	opj_tcd_resolution_v2_t* l_res= 00;
 
-
 	l_tilec = p_tcd->tcd_image->tiles->comps;
-	l_image = p_tcd->image;
-	l_img_comp = l_image->comps;
+	l_image_src = p_tcd->image;
+	l_img_comp_src = l_image_src->comps;
+
+	l_img_comp_dest = p_output_image->comps;
 
-	for (i=0;i<p_tcd->image->numcomps;++i) {
+	for (i=0; i<l_image_src->numcomps; i++) {
 
-		if (!l_img_comp->data) {
+		/* Allocate output component buffer if necessary */
+		if (!l_img_comp_dest->data) {
 
-			l_img_comp->data = (OPJ_INT32*) opj_malloc(l_img_comp->w * l_img_comp->h * sizeof(OPJ_INT32));
-			if (! l_img_comp->data) {
+			l_img_comp_dest->data = (OPJ_INT32*) opj_calloc(l_img_comp_dest->w * l_img_comp_dest->h, sizeof(OPJ_INT32));
+			if (! l_img_comp_dest->data) {
 				return OPJ_FALSE;
 			}
-			memset(l_img_comp->data,0,l_img_comp->w * l_img_comp->h * sizeof(OPJ_INT32));
 		}
 
-		l_size_comp = l_img_comp->prec >> 3; /*(/ 8)*/
-		l_remaining = l_img_comp->prec & 7;  /* (%8) */
-		l_res = l_tilec->resolutions + l_img_comp->resno_decoded;
+		/* Copy info from decoded comp image to output image */
+		l_img_comp_dest->resno_decoded = l_img_comp_src->resno_decoded;
+
+		/*-----*/
+		/* Compute the precision of the output buffer */
+		l_size_comp = l_img_comp_src->prec >> 3; /*(/ 8)*/
+		l_remaining = l_img_comp_src->prec & 7;  /* (%8) */
+		l_res = l_tilec->resolutions + l_img_comp_src->resno_decoded;
 
 		if (l_remaining) {
 			++l_size_comp;
@@ -6790,87 +6905,207 @@ opj_bool j2k_update_image_data (opj_tcd_v2_t * p_tcd, OPJ_BYTE * p_data)
 		if (l_size_comp == 3) {
 			l_size_comp = 4;
 		}
+		/*-----*/
+
+		/* Current tile component size*/
+		/*if (i == 0) {
+		fprintf(stdout, "SRC: l_res_x0=%d, l_res_x1=%d, l_res_y0=%d, l_res_y1=%d\n",
+				l_res->x0, l_res->x1, l_res->y0, l_res->y1);
+		}*/
+
+		l_width_src = (l_res->x1 - l_res->x0);
+		l_height_src = (l_res->y1 - l_res->y0);
+
+		/* Border of the current output component*/
+		l_x0_dest = int_ceildivpow2(l_img_comp_dest->x0, l_img_comp_dest->factor);
+		l_y0_dest = int_ceildivpow2(l_img_comp_dest->y0, l_img_comp_dest->factor);
+		l_x1_dest = l_x0_dest + l_img_comp_dest->w;
+		l_y1_dest = l_y0_dest + l_img_comp_dest->h;
+
+		/*if (i == 0) {
+		fprintf(stdout, "DEST: l_x0_dest=%d, l_x1_dest=%d, l_y0_dest=%d, l_y1_dest=%d (%d)\n",
+				l_x0_dest, l_x1_dest, l_y0_dest, l_y1_dest, l_img_comp_dest->factor );
+		}*/
+
+		/*-----*/
+		/* Compute the area (l_offset_x0_src, l_offset_y0_src, l_offset_x1_src, l_offset_y1_src)
+		 * of the input buffer (decoded tile component) which will be move
+		 * in the output buffer. Compute the area of the output buffer (l_start_x_dest,
+		 * l_start_y_dest, l_width_dest, l_height_dest)  which will be modified
+		 * by this input area.
+		 * */
+		if ( l_x0_dest < l_res->x0 ) {
+			l_start_x_dest = l_res->x0 - l_x0_dest;
+			l_offset_x0_src = 0;
+
+			if ( l_x1_dest >= l_res->x1 ) {
+				l_width_dest = l_width_src;
+				l_offset_x1_src = 0;
+			}
+			else {
+				l_width_dest = l_x1_dest - l_res->x0 ;
+				l_offset_x1_src = l_width_src - l_width_dest;
+			}
+		}
+		else {
+			l_start_x_dest = 0 ;
+			l_offset_x0_src = l_x0_dest - l_res->x0;
 
-		l_width = (l_res->x1 - l_res->x0);
-		l_height = (l_res->y1 - l_res->y0);
+			if ( l_x1_dest >= l_res->x1 ) {
+				l_width_dest = l_width_src - l_offset_x0_src;
+				l_offset_x1_src = 0;
+			}
+			else {
+				l_width_dest = l_img_comp_dest->w ;
+				l_offset_x1_src = l_res->x1 - l_x1_dest;
+			}
+		}
 
-		l_dest_stride = (l_img_comp->w) - l_width;
+		if ( l_y0_dest < l_res->y0 ) {
+			l_start_y_dest = l_res->y0 - l_y0_dest;
+			l_offset_y0_src = 0;
+
+			if ( l_y1_dest >= l_res->y1 ) {
+				l_height_dest = l_height_src;
+				l_offset_y1_src = 0;
+			}
+			else {
+				l_height_dest = l_y1_dest - l_res->y0 ;
+				l_offset_y1_src =  l_height_src - l_height_dest;
+			}
+		}
+		else {
+			l_start_y_dest = 0 ;
+			l_offset_y0_src = l_y0_dest - l_res->y0;
+
+			if ( l_y1_dest >= l_res->y1 ) {
+				l_height_dest = l_height_src - l_offset_y0_src;
+				l_offset_y1_src = 0;
+			}
+			else {
+				l_height_dest = l_img_comp_dest->h ;
+				l_offset_y1_src = l_res->y1 - l_y1_dest;
+			}
+		}
+
+		if( (l_offset_x0_src < 0 ) || (l_offset_y0_src < 0 ) || (l_offset_x1_src < 0 ) || (l_offset_y1_src < 0 ) ){
+			return OPJ_FALSE;
+		}
+		/*-----*/
+
+		/* Compute the input buffer offset */
+		l_start_offset_src = l_offset_x0_src + l_offset_y0_src * l_width_src;
+		l_line_offset_src = l_offset_x1_src + l_offset_x0_src;
+		l_end_offset_src = l_offset_y1_src * l_width_src - l_offset_x0_src;
+
+		/* Compute the output buffer offset */
+		l_start_offset_dest = l_start_x_dest + l_start_y_dest * l_img_comp_dest->w;
+		l_line_offset_dest = l_img_comp_dest->w - l_width_dest;
+
+		/* Move the output buffer to the first place where we will write*/
+		l_dest_ptr = l_img_comp_dest->data + l_start_offset_dest;
+
+		/*if (i == 0) {
+			fprintf(stdout, "COMPO[%d]:\n",i);
+			fprintf(stdout, "SRC: l_start_x_src=%d, l_start_y_src=%d, l_width_src=%d, l_height_src=%d\n"
+					"\t tile offset:%d, %d, %d, %d\n"
+					"\t buffer offset: %d; %d, %d\n",
+					l_res->x0, l_res->y0, l_width_src, l_height_src,
+					l_offset_x0_src, l_offset_y0_src, l_offset_x1_src, l_offset_y1_src,
+					l_start_offset_src, l_line_offset_src, l_end_offset_src);
+
+			fprintf(stdout, "DEST: l_start_x_dest=%d, l_start_y_dest=%d, l_width_dest=%d, l_height_dest=%d\n"
+					"\t start offset: %d, line offset= %d\n",
+					l_start_x_dest, l_start_y_dest, l_width_dest, l_height_dest, l_start_offset_dest, l_line_offset_dest);
+		}*/
 
-		l_offset_x = int_ceildivpow2(l_img_comp->x0, l_img_comp->factor);
-		l_offset_y = int_ceildivpow2(l_img_comp->y0, l_img_comp->factor);
-		l_dest_ptr = l_img_comp->data + (l_res->x0 - l_offset_x) + (l_res->y0 - l_offset_y) * l_img_comp->w;
 
 		switch (l_size_comp) {
 			case 1:
 				{
 					OPJ_CHAR * l_src_ptr = (OPJ_CHAR*) p_data;
-					if (l_img_comp->sgnd) {
-						for (j=0;j<l_height;++j) {
-							for (k=0;k<l_width;++k) {
-								*(l_dest_ptr++) = (OPJ_INT32) (*(l_src_ptr++));
+					l_src_ptr += l_start_offset_src; /* Move to the first place where we will read*/
+
+					if (l_img_comp_src->sgnd) {
+						for (j = 0 ; j < l_height_dest ; ++j) {
+							for ( k = 0 ; k < l_width_dest ; ++k) {
+								*(l_dest_ptr++) = (OPJ_INT32) (*(l_src_ptr++)); /* Copy only the data needed for the output image */
 							}
 
-							l_dest_ptr += l_dest_stride;
+							l_dest_ptr+= l_line_offset_dest; /* Move to the next place where we will write */
+							l_src_ptr += l_line_offset_src ; /* Move to the next place where we will read */
 						}
 					}
 					else {
-						for (j=0;j<l_height;++j) {
-							for (k=0;k<l_width;++k) {
+						for ( j = 0 ; j < l_height_dest ; ++j ) {
+							for ( k = 0 ; k < l_width_dest ; ++k) {
 								*(l_dest_ptr++) = (OPJ_INT32) ((*(l_src_ptr++))&0xff);
 							}
 
-							l_dest_ptr += l_dest_stride;
+							l_dest_ptr+= l_line_offset_dest;
+							l_src_ptr += l_line_offset_src;
 						}
 					}
 
-					p_data = (OPJ_BYTE*) l_src_ptr;
+					l_src_ptr += l_end_offset_src; /* Move to the end of this component-part of the input buffer */
+					p_data = (OPJ_BYTE*) l_src_ptr; /* Keep the current position for the next component-part */
 				}
 				break;
 			case 2:
 				{
 					OPJ_INT16 * l_src_ptr = (OPJ_INT16 *) p_data;
+					l_src_ptr += l_start_offset_src;
 
-					if (l_img_comp->sgnd) {
-						for (j=0;j<l_height;++j) {
-							for (k=0;k<l_width;++k) {
+					if (l_img_comp_src->sgnd) {
+						for (j=0;j<l_height_dest;++j) {
+							for (k=0;k<l_width_dest;++k) {
 								*(l_dest_ptr++) = *(l_src_ptr++);
 							}
 
-							l_dest_ptr += l_dest_stride;
+							l_dest_ptr+= l_line_offset_dest;
+							l_src_ptr += l_line_offset_src ;
 						}
 					}
 					else {
-						for (j=0;j<l_height;++j) {
-							for (k=0;k<l_width;++k) {
+						for (j=0;j<l_height_dest;++j) {
+							for (k=0;k<l_width_dest;++k) {
 								*(l_dest_ptr++) = (*(l_src_ptr++))&0xffff;
 							}
 
-							l_dest_ptr += l_dest_stride;
+							l_dest_ptr+= l_line_offset_dest;
+							l_src_ptr += l_line_offset_src ;
 						}
 					}
 
+					l_src_ptr += l_end_offset_src;
 					p_data = (OPJ_BYTE*) l_src_ptr;
 				}
 				break;
 			case 4:
 				{
 					OPJ_INT32 * l_src_ptr = (OPJ_INT32 *) p_data;
-					for (j=0;j<l_height;++j) {
-						for (k=0;k<l_width;++k) {
+					l_src_ptr += l_start_offset_src;
+
+					for (j=0;j<l_height_dest;++j) {
+						for (k=0;k<l_width_dest;++k) {
 							*(l_dest_ptr++) = (*(l_src_ptr++));
 						}
 
-						l_dest_ptr += l_dest_stride;
+						l_dest_ptr+= l_line_offset_dest;
+						l_src_ptr += l_line_offset_src ;
 					}
 
+					l_src_ptr += l_end_offset_src;
 					p_data = (OPJ_BYTE*) l_src_ptr;
 				}
 				break;
 		}
 
-		++l_img_comp;
+		++l_img_comp_dest;
+		++l_img_comp_src;
 		++l_tilec;
 	}
+
 	return OPJ_TRUE;
 }
 
@@ -6887,11 +7122,17 @@ opj_bool j2k_update_image_data (opj_tcd_v2_t * p_tcd, OPJ_BYTE * p_data)
  * @return	true			if the area could be set.
  */
 opj_bool j2k_set_decode_area(	opj_j2k_v2_t *p_j2k,
+								opj_image_t* p_image,
 								OPJ_INT32 p_start_x, OPJ_INT32 p_start_y,
 								OPJ_INT32 p_end_x, OPJ_INT32 p_end_y,
 								struct opj_event_mgr * p_manager )
 {
 	opj_cp_v2_t * l_cp = &(p_j2k->m_cp);
+	opj_image_t * l_image = p_j2k->m_private_image;
+
+	OPJ_UINT32 it_comp;
+	OPJ_INT32 l_comp_x1, l_comp_y1;
+	opj_image_comp_t* l_img_comp = NULL;
 
 	/* Check if we are read the main header */
 	if (p_j2k->m_specific_param.m_decoder.m_state != J2K_STATE_TPHSOT) { // FIXME J2K_DEC_STATE_TPHSOT)
@@ -6899,76 +7140,136 @@ opj_bool j2k_set_decode_area(	opj_j2k_v2_t *p_j2k,
 		return OPJ_FALSE;
 	}
 
+	if ( !p_start_x && !p_start_y && !p_end_x && !p_end_y){
+		opj_event_msg_v2(p_manager, EVT_INFO, "No decoded area parameters, set the decoded area to the all image\n");
+
+		p_j2k->m_specific_param.m_decoder.m_start_tile_x = 0;
+		p_j2k->m_specific_param.m_decoder.m_start_tile_y = 0;
+		p_j2k->m_specific_param.m_decoder.m_end_tile_x = l_cp->tw;
+		p_j2k->m_specific_param.m_decoder.m_end_tile_y = l_cp->th;
+
+		return OPJ_TRUE;
+	}
+
 	/* ----- */
 	/* Check if the positions provided by the user are correct */
 
 	/* Left */
-	if (p_start_x > l_cp->tx0 + l_cp->tw * l_cp->tdx) {
+	if (p_start_x > l_image->x1 ) {
 		opj_event_msg_v2(p_manager, EVT_ERROR,
-			"Left position of the decoded area (ROI_x0=%d) is outside the tile area (XTOsiz + nb_tw x XTsiz=%d).\n",
-			p_start_x, l_cp->tx0 + l_cp->tw * l_cp->tdx);
+			"Left position of the decoded area (region_x0=%d) is outside the image area (Xsiz=%d).\n",
+			p_start_x, l_image->x1);
 		return OPJ_FALSE;
 	}
-	else if (p_start_x < l_cp->tx0){
+	else if (p_start_x < l_image->x0){
 		opj_event_msg_v2(p_manager, EVT_WARNING,
-				"Left position of the decoded area (ROI_x0=%d) is outside the tile area (XTOsiz=%d).\n",
-				p_start_x, l_cp->tx0);
+				"Left position of the decoded area (region_x0=%d) is outside the image area (XOsiz=%d).\n",
+				p_start_x, l_image->x0);
 		p_j2k->m_specific_param.m_decoder.m_start_tile_x = 0;
+		p_image->x0 = l_image->x0;
 	}
-	else
+	else {
 		p_j2k->m_specific_param.m_decoder.m_start_tile_x = (p_start_x - l_cp->tx0) / l_cp->tdx;
+		p_image->x0 = p_start_x;
+	}
 
 	/* Up */
-	if (p_start_y > l_cp->ty0 + l_cp->th * l_cp->tdy){
+	if (p_start_y > l_image->y1){
 		opj_event_msg_v2(p_manager, EVT_ERROR,
-				"Up position of the decoded area (ROI_y0=%d) is outside the tile area (YTOsiz + nb_th x YTsiz=%d).\n",
-				p_start_y, l_cp->ty0 + l_cp->th * l_cp->tdy);
+				"Up position of the decoded area (region_y0=%d) is outside the image area (Ysiz=%d).\n",
+				p_start_y, l_image->y1);
 		return OPJ_FALSE;
 	}
-	else if (p_start_y < l_cp->ty0){
+	else if (p_start_y < l_image->y0){
 		opj_event_msg_v2(p_manager, EVT_WARNING,
-				"Up position of the decoded area (ROI_y0=%d) is outside the tile area (YTOsiz=%d).\n",
-				p_start_y, l_cp->ty0);
+				"Up position of the decoded area (region_y0=%d) is outside the image area (YOsiz=%d).\n",
+				p_start_y, l_image->y0);
 		p_j2k->m_specific_param.m_decoder.m_start_tile_y = 0;
+		p_image->y0 = l_image->y0;
 	}
-	else
+	else {
 		p_j2k->m_specific_param.m_decoder.m_start_tile_y = (p_start_y - l_cp->ty0) / l_cp->tdy;
+		p_image->y0 = p_start_y;
+	}
 
 	/* Right */
-	if (p_end_x < l_cp->tx0) {
+	if (p_end_x < l_image->x0) {
 		opj_event_msg_v2(p_manager, EVT_ERROR,
-			"Right position of the decoded area (ROI_x1=%d) is outside the tile area (XTOsiz=%d).\n",
-			p_end_x, l_cp->tx0);
+			"Right position of the decoded area (region_x1=%d) is outside the image area (XOsiz=%d).\n",
+			p_end_x, l_image->x0);
 		return OPJ_FALSE;
 	}
-	else if (p_end_x > l_cp->tx0 + l_cp->tw * l_cp->tdx) {
+	else if (p_end_x > l_image->x1) {
 		opj_event_msg_v2(p_manager, EVT_WARNING,
-			"Right position of the decoded area (ROI_x1=%d) is outside the tile area (XTOsiz + nb_tw x XTsiz=%d).\n",
-			p_end_x, l_cp->tx0 + l_cp->tw * l_cp->tdx);
-		p_j2k->m_specific_param.m_decoder.m_end_tile_x = l_cp->tw; // FIXME (-1) ???
+			"Right position of the decoded area (region_x1=%d) is outside the image area (Xsiz=%d).\n",
+			p_end_x, l_image->x1);
+		p_j2k->m_specific_param.m_decoder.m_end_tile_x = l_cp->tw;
+		p_image->x1 = l_image->x1;
 	}
-	else
+	else {
 		p_j2k->m_specific_param.m_decoder.m_end_tile_x = int_ceildiv((p_end_x - l_cp->tx0), l_cp->tdx);
+		p_image->x1 = p_end_x;
+	}
 
 	/* Bottom */
-	if (p_end_y < l_cp->ty0) {
+	if (p_end_y < l_image->y0) {
 		opj_event_msg_v2(p_manager, EVT_ERROR,
-			"Right position of the decoded area (ROI_y1=%d) is outside the tile area (YTOsiz=%d).\n",
-			p_end_y, l_cp->ty0);
+			"Right position of the decoded area (region_y1=%d) is outside the image area (YOsiz=%d).\n",
+			p_end_y, l_image->y0);
 		return OPJ_FALSE;
 	}
-	if (p_end_y > l_cp->ty0 + l_cp->th * l_cp->tdy){
+	if (p_end_y > l_image->y1){
 		opj_event_msg_v2(p_manager, EVT_WARNING,
-			"Bottom position of the decoded area (ROI_y1=%d) is outside the tile area (YTOsiz + nb_th x YTsiz=%d).\n",
-			p_end_y, l_cp->ty0 + l_cp->th * l_cp->tdy);
-		p_j2k->m_specific_param.m_decoder.m_start_tile_y = l_cp->th; // FIXME (-1) ???
+			"Bottom position of the decoded area (region_y1=%d) is outside the image area (Ysiz=%d).\n",
+			p_end_y, l_image->y1);
+		p_j2k->m_specific_param.m_decoder.m_end_tile_y = l_cp->th;
+		p_image->y1 = l_image->y1;
 	}
-	else
+	else{
 		p_j2k->m_specific_param.m_decoder.m_end_tile_y = int_ceildiv((p_end_y - l_cp->ty0), l_cp->tdy);
+		p_image->y1 = p_end_y;
+	}
 	/* ----- */
 
 	p_j2k->m_specific_param.m_decoder.m_discard_tiles = 1;
 
+	l_img_comp = p_image->comps;
+	for (it_comp=0; it_comp < p_image->numcomps; ++it_comp)
+	{
+		OPJ_INT32 l_h,l_w;
+
+		l_img_comp->x0 = int_ceildiv(p_image->x0, l_img_comp->dx);
+		l_img_comp->y0 = int_ceildiv(p_image->y0, l_img_comp->dy);
+		l_comp_x1 = int_ceildiv(p_image->x1, l_img_comp->dx);
+		l_comp_y1 = int_ceildiv(p_image->y1, l_img_comp->dy);
+
+		l_w = int_ceildivpow2(l_comp_x1, l_img_comp->factor)
+				- int_ceildivpow2(l_img_comp->x0, l_img_comp->factor);
+		if (l_w < 0){
+			opj_event_msg_v2(p_manager, EVT_ERROR,
+				"Size x of the decoded component image is incorrect (comp[%d].w=%d).\n",
+				it_comp, l_w);
+			return OPJ_FALSE;
+		}
+		l_img_comp->w = l_w;
+
+		l_h = int_ceildivpow2(l_comp_y1, l_img_comp->factor)
+				- int_ceildivpow2(l_img_comp->y0, l_img_comp->factor);
+		if (l_h < 0){
+			opj_event_msg_v2(p_manager, EVT_ERROR,
+				"Size y of the decoded component image is incorrect (comp[%d].h=%d).\n",
+				it_comp, l_h);
+			return OPJ_FALSE;
+		}
+		l_img_comp->h = l_h;
+
+		l_img_comp++;
+	}
+
+	opj_event_msg_v2( p_manager, EVT_INFO,"Setting decoding area to %d,%d,%d,%d\n",
+			p_image->x0, p_image->y0, p_image->x1, p_image->y1);
+
+
 	return OPJ_TRUE;
 }
 
@@ -7007,6 +7308,10 @@ opj_j2k_v2_t* j2k_create_decompress_v2()
 
 	l_j2k->m_specific_param.m_decoder.m_header_data_size = J2K_DEFAULT_HEADER_SIZE;
 
+	l_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec = -1 ;
+
+	l_j2k->m_specific_param.m_decoder.m_last_sot_read_pos = 0 ;
+
 	/* codestream index creation */
 	l_j2k->cstr_index = j2k_create_cstr_index();
 
@@ -7088,7 +7393,7 @@ opj_bool j2k_read_SPCod_SPCoc(
 				p_j2k->m_specific_param.m_decoder.m_default_tcp;
 
 	/* precondition again */
-	assert(compno < p_j2k->m_image->numcomps);
+	assert(compno < p_j2k->m_private_image->numcomps);
 
 	l_tccp = &l_tcp->tccps[compno];
 	l_current_ptr = p_header_data;
@@ -7198,7 +7503,7 @@ void j2k_copy_tile_component_parameters( opj_j2k_v2_t *p_j2k )
 	l_copied_tccp = l_ref_tccp + 1;
 	l_prc_size = l_ref_tccp->numresolutions * sizeof(OPJ_UINT32);
 
-	for	(i=1; i<p_j2k->m_image->numcomps; ++i) {
+	for	(i=1; i<p_j2k->m_private_image->numcomps; ++i) {
 		l_copied_tccp->numresolutions = l_ref_tccp->numresolutions;
 		l_copied_tccp->cblkw = l_ref_tccp->cblkw;
 		l_copied_tccp->cblkh = l_ref_tccp->cblkh;
@@ -7247,7 +7552,7 @@ opj_bool j2k_read_SQcd_SQcc(
 				p_j2k->m_specific_param.m_decoder.m_default_tcp;
 
 	// precondition again
-	assert(p_comp_no <  p_j2k->m_image->numcomps);
+	assert(p_comp_no <  p_j2k->m_private_image->numcomps);
 
 	l_tccp = &l_tcp->tccps[p_comp_no];
 	l_current_ptr = p_header_data;
@@ -7363,7 +7668,7 @@ void j2k_copy_tile_quantization_parameters( opj_j2k_v2_t *p_j2k )
 	l_copied_tccp = l_ref_tccp + 1;
 	l_size = J2K_MAXBANDS * sizeof(opj_stepsize_t);
 
-	for	(i=1;i<p_j2k->m_image->numcomps;++i) {
+	for	(i=1;i<p_j2k->m_private_image->numcomps;++i) {
 		l_copied_tccp->qntsty = l_ref_tccp->qntsty;
 		l_copied_tccp->numgbits = l_ref_tccp->numgbits;
 		memcpy(l_copied_tccp->stepsizes,l_ref_tccp->stepsizes,l_size);
@@ -7389,8 +7694,8 @@ void j2k_dump (opj_j2k_v2_t* p_j2k, OPJ_INT32 flag, FILE* out_stream)
 
 	/* Dump the image_header */
 	if (flag & OPJ_IMG_INFO){
-		if (p_j2k->m_image)
-			j2k_dump_image_header(p_j2k->m_image, 0, out_stream);
+		if (p_j2k->m_private_image)
+			j2k_dump_image_header(p_j2k->m_private_image, 0, out_stream);
 	}
 
 	/* Dump the codestream info from main header */
@@ -7426,23 +7731,59 @@ void j2k_dump (opj_j2k_v2_t* p_j2k, OPJ_INT32 flag, FILE* out_stream)
 void j2k_dump_MH_index(opj_j2k_v2_t* p_j2k, FILE* out_stream)
 {
 	opj_codestream_index_t* cstr_index = p_j2k->cstr_index;
-	OPJ_UINT32 it_marker;
+	OPJ_UINT32 it_marker, it_tile, it_tile_part;
 
 	fprintf(out_stream, "Codestream index from main header: {\n");
 
-	fprintf(out_stream, "\t Main header start position=%d\n\t Main header end position=%d\n",
+	fprintf(out_stream, "\t Main header start position=%" OPJ_OFF_F "d\n"
+			            "\t Main header end position=%" OPJ_OFF_F "d\n",
 			cstr_index->main_head_start, cstr_index->main_head_end);
 
 	fprintf(out_stream, "\t Marker list: {\n");
 
-	for (it_marker=0; it_marker < cstr_index->marknum ; it_marker++){
-		fprintf(out_stream, "\t\t type=%#x, pos=%d, len=%d\n",
-				cstr_index->marker[it_marker].type,
-				cstr_index->marker[it_marker].pos,
-				cstr_index->marker[it_marker].len );
+	if (cstr_index->marker){
+		for (it_marker=0; it_marker < cstr_index->marknum ; it_marker++){
+			fprintf(out_stream, "\t\t type=%#x, pos=%" OPJ_OFF_F "d, len=%d\n",
+					cstr_index->marker[it_marker].type,
+					cstr_index->marker[it_marker].pos,
+					cstr_index->marker[it_marker].len );
+		}
+	}
+
+	fprintf(out_stream, "\t }\n");
+
+
+	if (cstr_index->tile_index){
+		fprintf(out_stream, "\t Tile index: {\n");
+
+		for (it_tile=0; it_tile < cstr_index->nb_of_tiles ; it_tile++){
+			OPJ_UINT32 nb_of_tile_part = cstr_index->tile_index[it_tile].nb_tps;
+
+			fprintf(out_stream, "\t\t nb of tile-part in tile [%d]=%d\n", it_tile, nb_of_tile_part);
+
+			if (cstr_index->tile_index[it_tile].tp_index){
+				for (it_tile_part =0; it_tile_part < nb_of_tile_part; it_tile_part++){
+					fprintf(out_stream, "\t\t\t tile-part[%d]: star_pos=%" OPJ_OFF_F "d, end_header=%" OPJ_OFF_F "d, end_pos=%" OPJ_OFF_F "d.\n",
+							it_tile_part,
+							cstr_index->tile_index[it_tile].tp_index[it_tile_part].start_pos,
+							cstr_index->tile_index[it_tile].tp_index[it_tile_part].end_header,
+							cstr_index->tile_index[it_tile].tp_index[it_tile_part].end_pos);
+				}
+			}
+
+			if (cstr_index->tile_index[it_tile].marker){
+				for (it_marker=0; it_marker < cstr_index->tile_index[it_tile].marknum ; it_marker++){
+					fprintf(out_stream, "\t\t type=%#x, pos=%" OPJ_OFF_F "d, len=%d\n",
+							cstr_index->tile_index[it_tile].marker[it_marker].type,
+							cstr_index->tile_index[it_tile].marker[it_marker].pos,
+							cstr_index->tile_index[it_tile].marker[it_marker].len );
+				}
+			}
+		}
+		fprintf(out_stream,"\t }\n");
 	}
 
-	fprintf(out_stream, "\t }\n}\n");
+	fprintf(out_stream,"}\n");
 
 }
 
@@ -7467,7 +7808,7 @@ void j2k_dump_MH_info(opj_j2k_v2_t* p_j2k, FILE* out_stream)
 	if (l_default_tile)
 	{
 		OPJ_INT32 compno;
-		OPJ_INT32 numcomps = p_j2k->m_image->numcomps;
+		OPJ_INT32 numcomps = p_j2k->m_private_image->numcomps;
 
 		fprintf(out_stream, "\t default tile {\n");
 		fprintf(out_stream, "\t\t csty=%#x\n", l_default_tile->csty);
@@ -7591,11 +7932,11 @@ void j2k_dump_image_comp_header(opj_image_comp_t* comp_header, opj_bool dev_dump
 opj_codestream_info_v2_t* j2k_get_cstr_info(opj_j2k_v2_t* p_j2k)
 {
 	OPJ_UINT16 compno;
-	OPJ_UINT16 numcomps = p_j2k->m_image->numcomps;
+	OPJ_UINT16 numcomps = p_j2k->m_private_image->numcomps;
 	opj_tcp_v2_t *l_default_tile;
 	opj_codestream_info_v2_t* cstr_info = (opj_codestream_info_v2_t*) opj_calloc(1,sizeof(opj_codestream_info_v2_t));
 
-	cstr_info->nbcomps = p_j2k->m_image->numcomps;
+	cstr_info->nbcomps = p_j2k->m_private_image->numcomps;
 
 	cstr_info->tx0 = p_j2k->m_cp.tx0;
 	cstr_info->ty0 = p_j2k->m_cp.ty0;
@@ -7671,20 +8012,124 @@ opj_codestream_index_t* j2k_get_cstr_index(opj_j2k_v2_t* p_j2k)
 	l_cstr_index->main_head_end = p_j2k->cstr_index->main_head_end;
 	l_cstr_index->codestream_size = p_j2k->cstr_index->codestream_size;
 
-	l_cstr_index->maxmarknum = p_j2k->cstr_index->maxmarknum;
 	l_cstr_index->marknum = p_j2k->cstr_index->marknum;
 	l_cstr_index->marker = (opj_marker_info_t*)opj_malloc(l_cstr_index->marknum*sizeof(opj_marker_info_t));
-	if (!l_cstr_index->marker)
+	if (!l_cstr_index->marker){
+		opj_free( l_cstr_index);
+		return NULL;
+	}
+
+	if (p_j2k->cstr_index->marker)
+		memcpy(l_cstr_index->marker, p_j2k->cstr_index->marker, l_cstr_index->marknum * sizeof(opj_marker_info_t) );
+	else{
+		opj_free(l_cstr_index->marker);
+		l_cstr_index->marker = NULL;
+	}
+
+	l_cstr_index->nb_of_tiles = p_j2k->cstr_index->nb_of_tiles;
+	l_cstr_index->tile_index = (opj_tile_index_t*)opj_calloc(l_cstr_index->nb_of_tiles, sizeof(opj_tile_index_t) );
+	if (!l_cstr_index->tile_index){
+		opj_free( l_cstr_index->marker);
+		opj_free( l_cstr_index);
 		return NULL;
+	}
 
-	memcpy(l_cstr_index->marker, p_j2k->cstr_index->marker, l_cstr_index->marknum * sizeof(opj_marker_info_t) );
+	if (!p_j2k->cstr_index->tile_index){
+		opj_free(l_cstr_index->tile_index);
+		l_cstr_index->tile_index = NULL;
+	}
+	else {
+		OPJ_UINT32 it_tile = 0;
+		for (it_tile = 0; it_tile < l_cstr_index->nb_of_tiles; it_tile++ ){
 
-	l_cstr_index->tile_index = NULL; /* FIXME not used for the moment*/
+			/* Tile Marker*/
+			l_cstr_index->tile_index[it_tile].marknum = p_j2k->cstr_index->tile_index[it_tile].marknum;
+
+			l_cstr_index->tile_index[it_tile].marker =
+				(opj_marker_info_t*)opj_malloc(l_cstr_index->tile_index[it_tile].marknum*sizeof(opj_marker_info_t));
+
+			if (!l_cstr_index->tile_index[it_tile].marker) {
+				OPJ_UINT32 it_tile_free;
+
+				for (it_tile_free=0; it_tile_free < it_tile; it_tile_free++){
+					opj_free(l_cstr_index->tile_index[it_tile_free].marker);
+				}
+
+				opj_free( l_cstr_index->tile_index);
+				opj_free( l_cstr_index->marker);
+				opj_free( l_cstr_index);
+				return NULL;
+			}
+
+			if (p_j2k->cstr_index->tile_index[it_tile].marker)
+				memcpy(	l_cstr_index->tile_index[it_tile].marker,
+						p_j2k->cstr_index->tile_index[it_tile].marker,
+						l_cstr_index->tile_index[it_tile].marknum * sizeof(opj_marker_info_t) );
+			else{
+				opj_free(l_cstr_index->tile_index[it_tile].marker);
+				l_cstr_index->tile_index[it_tile].marker = NULL;
+			}
+
+			/* Tile part index*/
+			l_cstr_index->tile_index[it_tile].nb_tps = p_j2k->cstr_index->tile_index[it_tile].nb_tps;
+
+			l_cstr_index->tile_index[it_tile].tp_index =
+				(opj_tp_index_t*)opj_malloc(l_cstr_index->tile_index[it_tile].nb_tps*sizeof(opj_tp_index_t));
+
+			if(!l_cstr_index->tile_index[it_tile].tp_index){
+				OPJ_UINT32 it_tile_free;
+
+				for (it_tile_free=0; it_tile_free < it_tile; it_tile_free++){
+					opj_free(l_cstr_index->tile_index[it_tile_free].marker);
+					opj_free(l_cstr_index->tile_index[it_tile_free].tp_index);
+				}
+
+				opj_free( l_cstr_index->tile_index);
+				opj_free( l_cstr_index->marker);
+				opj_free( l_cstr_index);
+				return NULL;
+			}
+
+			if (p_j2k->cstr_index->tile_index[it_tile].tp_index){
+				memcpy(	l_cstr_index->tile_index[it_tile].tp_index,
+						p_j2k->cstr_index->tile_index[it_tile].tp_index,
+						l_cstr_index->tile_index[it_tile].nb_tps * sizeof(opj_tp_index_t) );
+			}
+			else{
+				opj_free(l_cstr_index->tile_index[it_tile].tp_index);
+				l_cstr_index->tile_index[it_tile].tp_index = NULL;
+			}
+
+			/* Packet index (NOT USED)*/
+			l_cstr_index->tile_index[it_tile].nb_packet = 0;
+			l_cstr_index->tile_index[it_tile].packet_index = NULL;
+
+		}
+	}
 
 	return l_cstr_index;
 }
 
+opj_bool j2k_allocate_tile_element_cstr_index(opj_j2k_v2_t *p_j2k)
+{
+	OPJ_UINT32 it_tile=0;
+
+	p_j2k->cstr_index->nb_of_tiles = p_j2k->m_cp.tw * p_j2k->m_cp.tw;
+	p_j2k->cstr_index->tile_index = (opj_tile_index_t*)opj_calloc(p_j2k->cstr_index->nb_of_tiles, sizeof(opj_tile_index_t));
+	if (!p_j2k->cstr_index->tile_index)
+		return OPJ_FALSE;
+
+	for (it_tile=0; it_tile < p_j2k->cstr_index->nb_of_tiles; it_tile++){
+		p_j2k->cstr_index->tile_index[it_tile].maxmarknum = 100;
+		p_j2k->cstr_index->tile_index[it_tile].marknum = 0;
+		p_j2k->cstr_index->tile_index[it_tile].marker = (opj_marker_info_t*)
+				opj_calloc(p_j2k->cstr_index->tile_index[it_tile].maxmarknum, sizeof(opj_marker_info_t));
+		if (!p_j2k->cstr_index->tile_index[it_tile].marker)
+			return OPJ_FALSE;
+	}
 
+	return OPJ_TRUE;
+}
 
 /**
  * Reads the tiles.
@@ -7706,6 +8151,10 @@ opj_bool j2k_decode_tiles (	opj_j2k_v2_t *p_j2k,
 	}
 	l_max_data_size = 1000;
 
+	/*Allocate and initialize some elements of codestrem index*/
+	if (!j2k_allocate_tile_element_cstr_index(p_j2k))
+		return OPJ_FALSE;
+
 	while (OPJ_TRUE) {
 		if (! j2k_read_tile_header(	p_j2k,
 									&l_current_tile_no,
@@ -7716,6 +8165,7 @@ opj_bool j2k_decode_tiles (	opj_j2k_v2_t *p_j2k,
 									&l_go_on,
 									p_stream,
 									p_manager)) {
+			opj_free(l_current_data);
 			return OPJ_FALSE;
 		}
 
@@ -7738,7 +8188,7 @@ opj_bool j2k_decode_tiles (	opj_j2k_v2_t *p_j2k,
 		}
 		opj_event_msg_v2(p_manager, EVT_INFO, "Tile %d/%d has been decode.\n", l_current_tile_no +1, p_j2k->m_cp.th * p_j2k->m_cp.tw);
 
-		if (! j2k_update_image_data(p_j2k->m_tcd,l_current_data)) {
+		if (! j2k_update_image_data(p_j2k->m_tcd,l_current_data, p_j2k->m_output_image)) {
 			opj_free(l_current_data);
 			return OPJ_FALSE;
 		}
@@ -7747,10 +8197,10 @@ opj_bool j2k_decode_tiles (	opj_j2k_v2_t *p_j2k,
 	}
 
 	opj_free(l_current_data);
+
 	return OPJ_TRUE;
 }
 
-
 /**
  * Sets up the procedures to do on decoding data. Developpers wanting to extend the library can add their own reading procedures.
  */
@@ -7764,6 +8214,133 @@ void j2k_setup_decoding (opj_j2k_v2_t *p_j2k)
 
 }
 
+/*
+ * Read and decode one tile.
+ */
+opj_bool j2k_decode_one_tile (	opj_j2k_v2_t *p_j2k,
+								opj_stream_private_t *p_stream,
+								opj_event_mgr_t * p_manager)
+{
+	opj_bool l_go_on = OPJ_TRUE;
+	OPJ_UINT32 l_current_tile_no;
+	OPJ_UINT32 l_tile_no_to_dec;
+	OPJ_UINT32 l_data_size,l_max_data_size;
+	OPJ_INT32 l_tile_x0,l_tile_y0,l_tile_x1,l_tile_y1;
+	OPJ_UINT32 l_nb_comps;
+	OPJ_BYTE * l_current_data;
+
+	l_current_data = (OPJ_BYTE*)opj_malloc(1000);
+	if (! l_current_data) {
+		return OPJ_FALSE;
+	}
+	l_max_data_size = 1000;
+
+	/*Allocate and initialize some elements of codestrem index if not already done*/
+	if( !p_j2k->cstr_index->tile_index)
+	{
+		if (!j2k_allocate_tile_element_cstr_index(p_j2k))
+			return OPJ_FALSE;
+	}
+	/* Move into the codestream to the first SOT used to decode the desired tile */
+	l_tile_no_to_dec = p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec;
+	if (p_j2k->cstr_index->tile_index)
+		if(p_j2k->cstr_index->tile_index->tp_index)
+		{
+			if ( ! p_j2k->cstr_index->tile_index[l_tile_no_to_dec].nb_tps) {
+				/* the index for this tile has not been built,
+				 *  so move to the last SOT read */
+				if ( opj_stream_read_seek(p_stream, p_j2k->m_specific_param.m_decoder.m_last_sot_read_pos+2, p_manager) ){
+					opj_event_msg_v2(p_manager, EVT_ERROR, "Problem with seek function\n");
+					return OPJ_FALSE;
+				}
+			}
+			else{
+				if (opj_stream_read_seek(p_stream, p_j2k->cstr_index->tile_index[l_tile_no_to_dec].tp_index[0].start_pos+2, p_manager)) {
+					opj_event_msg_v2(p_manager, EVT_ERROR, "Problem with seek function\n");
+					return OPJ_FALSE;
+				}
+			}
+			/* Special case if we have previously read the EOC marker (if the previous tile getted is the last ) */
+			if(p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_EOC)
+				p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_TPHSOT;
+		}
+
+	while (OPJ_TRUE) {
+		if (! j2k_read_tile_header(	p_j2k,
+									&l_current_tile_no,
+									&l_data_size,
+									&l_tile_x0, &l_tile_y0,
+									&l_tile_x1, &l_tile_y1,
+									&l_nb_comps,
+									&l_go_on,
+									p_stream,
+									p_manager)) {
+			opj_free(l_current_data);
+			return OPJ_FALSE;
+		}
+
+
+		if (! l_go_on) {
+			break;
+		}
+
+		if (l_data_size > l_max_data_size) {
+			l_current_data = (OPJ_BYTE*)opj_realloc(l_current_data,l_data_size);
+			if (! l_current_data) {
+				return OPJ_FALSE;
+			}
+
+			l_max_data_size = l_data_size;
+		}
+
+
+
+		if (! j2k_decode_tile(p_j2k,l_current_tile_no,l_current_data,l_data_size,p_stream,p_manager)) {
+			opj_free(l_current_data);
+			return OPJ_FALSE;
+		}
+		opj_event_msg_v2(p_manager, EVT_INFO, "Tile %d/%d has been decode.\n", l_current_tile_no, (p_j2k->m_cp.th * p_j2k->m_cp.tw) - 1);
+
+		if (! j2k_update_image_data(p_j2k->m_tcd,l_current_data, p_j2k->m_output_image)) {
+			opj_free(l_current_data);
+			return OPJ_FALSE;
+		}
+		opj_event_msg_v2(p_manager, EVT_INFO, "Image data has been updated with tile %d.\n\n", l_current_tile_no);
+
+		if(l_current_tile_no == l_tile_no_to_dec)
+		{
+			/* move into the codestream to the the first SOT (FIXME or not move?)*/
+			if (opj_stream_read_seek(p_stream, p_j2k->cstr_index->main_head_end + 2, p_manager) ) {
+				opj_event_msg_v2(p_manager, EVT_ERROR, "Problem with seek function\n");
+				return OPJ_FALSE;
+			}
+			break;
+		}
+		else {
+			opj_event_msg_v2(p_manager, EVT_WARNING, "Tile read, decode and updated is not the desired (%d vs %d).\n", l_current_tile_no, l_tile_no_to_dec);
+		}
+
+	}
+
+	opj_free(l_current_data);
+
+	return OPJ_TRUE;
+}
+
+
+/**
+ * Sets up the procedures to do on decoding one tile. Developpers wanting to extend the library can add their own reading procedures.
+ */
+void j2k_setup_decoding_tile (opj_j2k_v2_t *p_j2k)
+{
+	// preconditions
+	assert(p_j2k != 00);
+
+	opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_decode_one_tile);
+	/* DEVELOPER CORNER, add your custom procedures */
+
+}
+
 
 /**
  * Decodes the tiles of the stream.
@@ -7778,21 +8355,161 @@ opj_bool j2k_decode_v2(	opj_j2k_v2_t * p_j2k,
 	if (!p_image)
 		return OPJ_FALSE;
 
+	p_j2k->m_output_image = opj_image_create0();
+	if (! (p_j2k->m_output_image)) {
+		return OPJ_FALSE;
+	}
+	opj_copy_image_header(p_image, p_j2k->m_output_image);
+
 	/* customization of the decoding */
 	j2k_setup_decoding(p_j2k);
 
 	/* Decode the codestream */
 	if (! j2k_exec (p_j2k,p_j2k->m_procedure_list,p_stream,p_manager)) {
-		opj_image_destroy(p_j2k->m_image);
-		p_j2k->m_image = NULL;
+		opj_image_destroy(p_j2k->m_private_image);
+		p_j2k->m_private_image = NULL;
+		return OPJ_FALSE;
+	}
+
+	/* Move data and copy one information from codec to output image*/
+	for (compno = 0; compno < p_image->numcomps; compno++) {
+		p_image->comps[compno].resno_decoded = p_j2k->m_output_image->comps[compno].resno_decoded;
+		p_image->comps[compno].data = p_j2k->m_output_image->comps[compno].data;
+		p_j2k->m_output_image->comps[compno].data = NULL;
+	}
+
+	return OPJ_TRUE;
+}
+
+
+/**
+ * Get the decoded tile.
+ *
+ * @param	p_j2k			the jpeg2000 codestream codec.
+ * @param	p_stream		input_stream
+ * @param	p_image			output image.	.
+ * @param	p_manager		the user event manager
+ * @param	tile_index		index of the tile we want decode
+ *
+ * @return	true			if succeed.
+ */
+opj_bool j2k_get_tile(	opj_j2k_v2_t *p_j2k,
+						opj_stream_private_t *p_stream,
+						opj_image_t* p_image,
+						struct opj_event_mgr * p_manager,
+						OPJ_UINT32 tile_index )
+{
+	OPJ_UINT32 compno;
+	OPJ_UINT32 l_tile_x, l_tile_y;
+	opj_image_comp_t* l_img_comp;
+
+	if (!p_image) {
+		opj_event_msg_v2(p_manager, EVT_ERROR, "We need a image previously created.\n");
+		return OPJ_FALSE;
+	}
+
+	if ( (tile_index < 0) && (tile_index >= p_j2k->m_cp.tw * p_j2k->m_cp.th) ){
+		opj_event_msg_v2(p_manager, EVT_ERROR, "Tile index provided by the user is incorrect %d (max = %d) \n", tile_index, (p_j2k->m_cp.tw * p_j2k->m_cp.th) - 1);
+		return OPJ_FALSE;
+	}
+
+	/* Compute the dimension of the desired tile*/
+	l_tile_x = tile_index % p_j2k->m_cp.tw;
+	l_tile_y = tile_index / p_j2k->m_cp.tw;
+
+	p_image->x0 = l_tile_x * p_j2k->m_cp.tdx + p_j2k->m_cp.tx0;
+	if (p_image->x0 < p_j2k->m_private_image->x0)
+		p_image->x0 = p_j2k->m_private_image->x0;
+	p_image->x1 = (l_tile_x + 1) * p_j2k->m_cp.tdx + p_j2k->m_cp.tx0;
+	if (p_image->x1 > p_j2k->m_private_image->x1)
+		p_image->x1 = p_j2k->m_private_image->x1;
+
+	p_image->y0 = l_tile_y * p_j2k->m_cp.tdy + p_j2k->m_cp.ty0;
+	if (p_image->y0 < p_j2k->m_private_image->y0)
+		p_image->y0 = p_j2k->m_private_image->y0;
+	p_image->y1 = (l_tile_y + 1) * p_j2k->m_cp.tdy + p_j2k->m_cp.ty0;
+	if (p_image->y1 > p_j2k->m_private_image->y1)
+		p_image->y1 = p_j2k->m_private_image->y1;
+
+	l_img_comp = p_image->comps;
+	for (compno=0; compno < p_image->numcomps; ++compno)
+	{
+		OPJ_INT32 l_comp_x1, l_comp_y1;
+
+		l_img_comp->factor = p_j2k->m_private_image->comps[compno].factor;
+
+		l_img_comp->x0 = int_ceildiv(p_image->x0, l_img_comp->dx);
+		l_img_comp->y0 = int_ceildiv(p_image->y0, l_img_comp->dy);
+		l_comp_x1 = int_ceildiv(p_image->x1, l_img_comp->dx);
+		l_comp_y1 = int_ceildiv(p_image->y1, l_img_comp->dy);
+
+		l_img_comp->w = int_ceildivpow2(l_comp_x1, l_img_comp->factor) - int_ceildivpow2(l_img_comp->x0, l_img_comp->factor);
+		l_img_comp->h = int_ceildivpow2(l_comp_y1, l_img_comp->factor) - int_ceildivpow2(l_img_comp->y0, l_img_comp->factor);
+
+		l_img_comp++;
+	}
+
+	/* Destroy the previous output image*/
+	if (p_j2k->m_output_image)
+		opj_image_destroy(p_j2k->m_output_image);
+
+	/* Create the ouput image from the information previously computed*/
+	p_j2k->m_output_image = opj_image_create0();
+	if (! (p_j2k->m_output_image)) {
+		return OPJ_FALSE;
+	}
+	opj_copy_image_header(p_image, p_j2k->m_output_image);
+
+	p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec = tile_index;
+
+	/* customization of the decoding */
+	j2k_setup_decoding_tile(p_j2k);
+
+	/* Decode the codestream */
+	if (! j2k_exec (p_j2k,p_j2k->m_procedure_list,p_stream,p_manager)) {
+		opj_image_destroy(p_j2k->m_private_image);
+		p_j2k->m_private_image = NULL;
 		return OPJ_FALSE;
 	}
 
-	/* Copy data from codec to output image*/
+	/* Move data and copy one information from codec to output image*/
 	for (compno = 0; compno < p_image->numcomps; compno++) {
-		p_image->comps[compno].data = p_j2k->m_image->comps[compno].data;
-		p_j2k->m_image->comps[compno].data = NULL;
+		p_image->comps[compno].resno_decoded = p_j2k->m_output_image->comps[compno].resno_decoded;
+
+		if (p_image->comps[compno].data)
+			opj_free(p_image->comps[compno].data);
+
+		p_image->comps[compno].data = p_j2k->m_output_image->comps[compno].data;
+
+		p_j2k->m_output_image->comps[compno].data = NULL;
 	}
 
 	return OPJ_TRUE;
 }
+
+opj_bool j2k_set_decoded_resolution_factor(opj_j2k_v2_t *p_j2k, OPJ_UINT32 res_factor, opj_event_mgr_t * p_manager)
+{
+	OPJ_UINT32 it_comp;
+
+	p_j2k->m_cp.m_specific_param.m_dec.m_reduce = res_factor;
+
+	if (p_j2k->m_private_image) {
+		if (p_j2k->m_private_image->comps) {
+			if (p_j2k->m_specific_param.m_decoder.m_default_tcp) {
+				if (p_j2k->m_specific_param.m_decoder.m_default_tcp->tccps) {
+					for (it_comp = 0 ; it_comp < p_j2k->m_private_image->numcomps; it_comp++) {
+						OPJ_UINT32 max_res = p_j2k->m_specific_param.m_decoder.m_default_tcp->tccps[it_comp].numresolutions;
+						if ( res_factor >= max_res){
+							opj_event_msg_v2(p_manager, EVT_ERROR, "Resolution factor is superior to the maximum resolution in the component.\n");
+							return OPJ_FALSE;
+						}
+						p_j2k->m_private_image->comps[it_comp].factor = res_factor;
+					}
+					return OPJ_TRUE;
+				}
+			}
+		}
+	}
+
+	return OPJ_FALSE;
+}