PageRenderTime 109ms CodeModel.GetById 2ms app.highlight 93ms RepoModel.GetById 1ms app.codeStats 1ms

/src/FreeImage/Source/LibOpenJPEG/j2k.c

https://bitbucket.org/cabalistic/ogredeps/
C | 2534 lines | 1799 code | 348 blank | 387 comment | 376 complexity | 7c3951d52c2de93f0d3640ef51d5ada6 MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   1/*
   2 * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
   3 * Copyright (c) 2002-2007, Professor Benoit Macq
   4 * Copyright (c) 2001-2003, David Janssens
   5 * Copyright (c) 2002-2003, Yannick Verschueren
   6 * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
   7 * Copyright (c) 2005, Herve Drolon, FreeImage Team
   8 * Copyright (c) 2006-2007, Parvatha Elangovan
   9 * Copyright (c) 2010-2011, Kaori Hagihara
  10 * All rights reserved.
  11 *
  12 * Redistribution and use in source and binary forms, with or without
  13 * modification, are permitted provided that the following conditions
  14 * are met:
  15 * 1. Redistributions of source code must retain the above copyright
  16 *    notice, this list of conditions and the following disclaimer.
  17 * 2. Redistributions in binary form must reproduce the above copyright
  18 *    notice, this list of conditions and the following disclaimer in the
  19 *    documentation and/or other materials provided with the distribution.
  20 *
  21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
  22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  25 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  31 * POSSIBILITY OF SUCH DAMAGE.
  32 */
  33
  34#include "opj_includes.h"
  35
  36/** @defgroup J2K J2K - JPEG-2000 codestream reader/writer */
  37/*@{*/
  38
  39/** @name Local static functions */
  40/*@{*/
  41
  42/**
  43Write the SOC marker (Start Of Codestream)
  44@param j2k J2K handle
  45*/
  46static void j2k_write_soc(opj_j2k_t *j2k);
  47/**
  48Read the SOC marker (Start of Codestream)
  49@param j2k J2K handle
  50*/
  51static void j2k_read_soc(opj_j2k_t *j2k);
  52/**
  53Write the SIZ marker (image and tile size)
  54@param j2k J2K handle
  55*/
  56static void j2k_write_siz(opj_j2k_t *j2k);
  57/**
  58Read the SIZ marker (image and tile size)
  59@param j2k J2K handle
  60*/
  61static void j2k_read_siz(opj_j2k_t *j2k);
  62/**
  63Write the COM marker (comment)
  64@param j2k J2K handle
  65*/
  66static void j2k_write_com(opj_j2k_t *j2k);
  67/**
  68Read the COM marker (comment)
  69@param j2k J2K handle
  70*/
  71static void j2k_read_com(opj_j2k_t *j2k);
  72/**
  73Write the value concerning the specified component in the marker COD and COC
  74@param j2k J2K handle
  75@param compno Number of the component concerned by the information written
  76*/
  77static void j2k_write_cox(opj_j2k_t *j2k, int compno);
  78/**
  79Read the value concerning the specified component in the marker COD and COC
  80@param j2k J2K handle
  81@param compno Number of the component concerned by the information read
  82*/
  83static void j2k_read_cox(opj_j2k_t *j2k, int compno);
  84/**
  85Write the COD marker (coding style default)
  86@param j2k J2K handle
  87*/
  88static void j2k_write_cod(opj_j2k_t *j2k);
  89/**
  90Read the COD marker (coding style default)
  91@param j2k J2K handle
  92*/
  93static void j2k_read_cod(opj_j2k_t *j2k);
  94/**
  95Write the COC marker (coding style component)
  96@param j2k J2K handle
  97@param compno Number of the component concerned by the information written
  98*/
  99static void j2k_write_coc(opj_j2k_t *j2k, int compno);
 100/**
 101Read the COC marker (coding style component)
 102@param j2k J2K handle
 103*/
 104static void j2k_read_coc(opj_j2k_t *j2k);
 105/**
 106Write the value concerning the specified component in the marker QCD and QCC
 107@param j2k J2K handle
 108@param compno Number of the component concerned by the information written
 109*/
 110static void j2k_write_qcx(opj_j2k_t *j2k, int compno);
 111/**
 112Read the value concerning the specified component in the marker QCD and QCC
 113@param j2k J2K handle
 114@param compno Number of the component concern by the information read
 115@param len Length of the information in the QCX part of the marker QCD/QCC
 116*/
 117static void j2k_read_qcx(opj_j2k_t *j2k, int compno, int len);
 118/**
 119Write the QCD marker (quantization default)
 120@param j2k J2K handle
 121*/
 122static void j2k_write_qcd(opj_j2k_t *j2k);
 123/**
 124Read the QCD marker (quantization default)
 125@param j2k J2K handle
 126*/
 127static void j2k_read_qcd(opj_j2k_t *j2k);
 128/**
 129Write the QCC marker (quantization component)
 130@param j2k J2K handle
 131@param compno Number of the component concerned by the information written
 132*/
 133static void j2k_write_qcc(opj_j2k_t *j2k, int compno);
 134/**
 135Read the QCC marker (quantization component)
 136@param j2k J2K handle
 137*/
 138static void j2k_read_qcc(opj_j2k_t *j2k);
 139/**
 140Write the POC marker (progression order change)
 141@param j2k J2K handle
 142*/
 143static void j2k_write_poc(opj_j2k_t *j2k);
 144/**
 145Read the POC marker (progression order change)
 146@param j2k J2K handle
 147*/
 148static void j2k_read_poc(opj_j2k_t *j2k);
 149/**
 150Read the CRG marker (component registration)
 151@param j2k J2K handle
 152*/
 153static void j2k_read_crg(opj_j2k_t *j2k);
 154/**
 155Read the TLM marker (tile-part lengths)
 156@param j2k J2K handle
 157*/
 158static void j2k_read_tlm(opj_j2k_t *j2k);
 159/**
 160Read the PLM marker (packet length, main header)
 161@param j2k J2K handle
 162*/
 163static void j2k_read_plm(opj_j2k_t *j2k);
 164/**
 165Read the PLT marker (packet length, tile-part header)
 166@param j2k J2K handle
 167*/
 168static void j2k_read_plt(opj_j2k_t *j2k);
 169/**
 170Read the PPM marker (packet packet headers, main header)
 171@param j2k J2K handle
 172*/
 173static void j2k_read_ppm(opj_j2k_t *j2k);
 174/**
 175Read the PPT marker (packet packet headers, tile-part header)
 176@param j2k J2K handle
 177*/
 178static void j2k_read_ppt(opj_j2k_t *j2k);
 179/**
 180Write the TLM marker (Mainheader)
 181@param j2k J2K handle
 182*/
 183static void j2k_write_tlm(opj_j2k_t *j2k);
 184/**
 185Write the SOT marker (start of tile-part)
 186@param j2k J2K handle
 187*/
 188static void j2k_write_sot(opj_j2k_t *j2k);
 189/**
 190Read the SOT marker (start of tile-part)
 191@param j2k J2K handle
 192*/
 193static void j2k_read_sot(opj_j2k_t *j2k);
 194/**
 195Write the SOD marker (start of data)
 196@param j2k J2K handle
 197@param tile_coder Pointer to a TCD handle
 198*/
 199static void j2k_write_sod(opj_j2k_t *j2k, void *tile_coder);
 200/**
 201Read the SOD marker (start of data)
 202@param j2k J2K handle
 203*/
 204static void j2k_read_sod(opj_j2k_t *j2k);
 205/**
 206Write the RGN marker (region-of-interest)
 207@param j2k J2K handle
 208@param compno Number of the component concerned by the information written
 209@param tileno Number of the tile concerned by the information written
 210*/
 211static void j2k_write_rgn(opj_j2k_t *j2k, int compno, int tileno);
 212/**
 213Read the RGN marker (region-of-interest)
 214@param j2k J2K handle
 215*/
 216static void j2k_read_rgn(opj_j2k_t *j2k);
 217/**
 218Write the EOC marker (end of codestream)
 219@param j2k J2K handle
 220*/
 221static void j2k_write_eoc(opj_j2k_t *j2k);
 222/**
 223Read the EOC marker (end of codestream)
 224@param j2k J2K handle
 225*/
 226static void j2k_read_eoc(opj_j2k_t *j2k);
 227/**
 228Read an unknown marker
 229@param j2k J2K handle
 230*/
 231static void j2k_read_unk(opj_j2k_t *j2k);
 232/**
 233Add main header marker information
 234@param cstr_info Codestream information structure
 235@param type marker type
 236@param pos byte offset of marker segment
 237@param len length of marker segment
 238 */
 239static void j2k_add_mhmarker(opj_codestream_info_t *cstr_info, unsigned short int type, int pos, int len);
 240/**
 241Add tile header marker information
 242@param tileno tile index number
 243@param cstr_info Codestream information structure
 244@param type marker type
 245@param pos byte offset of marker segment
 246@param len length of marker segment
 247 */
 248static void j2k_add_tlmarker( int tileno, opj_codestream_info_t *cstr_info, unsigned short int type, int pos, int len);
 249
 250/*@}*/
 251
 252/*@}*/
 253
 254/* ----------------------------------------------------------------------- */
 255typedef struct j2k_prog_order{
 256	OPJ_PROG_ORDER enum_prog;
 257	char str_prog[5];
 258}j2k_prog_order_t;
 259
 260j2k_prog_order_t j2k_prog_order_list[] = {
 261	{CPRL, "CPRL"},
 262	{LRCP, "LRCP"},
 263	{PCRL, "PCRL"},
 264	{RLCP, "RLCP"},
 265	{RPCL, "RPCL"},
 266	{(OPJ_PROG_ORDER)-1, ""}
 267};
 268
 269char *j2k_convert_progression_order(OPJ_PROG_ORDER prg_order){
 270	j2k_prog_order_t *po;
 271	for(po = j2k_prog_order_list; po->enum_prog != -1; po++ ){
 272		if(po->enum_prog == prg_order){
 273			break;
 274		}
 275	}
 276	return po->str_prog;
 277}
 278
 279/* ----------------------------------------------------------------------- */
 280static int j2k_get_num_tp(opj_cp_t *cp,int pino,int tileno){
 281	char *prog;
 282	int i;
 283	int tpnum=1,tpend=0;
 284	opj_tcp_t *tcp = &cp->tcps[tileno];
 285	prog = j2k_convert_progression_order(tcp->prg);
 286	
 287	if(cp->tp_on == 1){
 288		for(i=0;i<4;i++){
 289			if(tpend!=1){
 290				if( cp->tp_flag == prog[i] ){
 291					tpend=1;cp->tp_pos=i;
 292				}
 293				switch(prog[i]){
 294				case 'C':
 295					tpnum= tpnum * tcp->pocs[pino].compE;
 296					break;
 297				case 'R':
 298					tpnum= tpnum * tcp->pocs[pino].resE;
 299					break;
 300				case 'P':
 301					tpnum= tpnum * tcp->pocs[pino].prcE;
 302					break;
 303				case 'L':
 304					tpnum= tpnum * tcp->pocs[pino].layE;
 305					break;
 306				}
 307			}
 308		}
 309	}else{
 310		tpnum=1;
 311	}
 312	return tpnum;
 313}
 314
 315/**	mem allocation for TLM marker*/
 316int j2k_calculate_tp(opj_cp_t *cp,int img_numcomp,opj_image_t *image,opj_j2k_t *j2k ){
 317	int pino,tileno,totnum_tp=0;
 318
 319	OPJ_ARG_NOT_USED(img_numcomp);
 320
 321	j2k->cur_totnum_tp = (int *) opj_malloc(cp->tw * cp->th * sizeof(int));
 322	for (tileno = 0; tileno < cp->tw * cp->th; tileno++) {
 323		int cur_totnum_tp = 0;
 324		opj_tcp_t *tcp = &cp->tcps[tileno];
 325		for(pino = 0; pino <= tcp->numpocs; pino++) {
 326			int tp_num=0;
 327			opj_pi_iterator_t *pi = pi_initialise_encode(image, cp, tileno,FINAL_PASS);
 328			if(!pi) { return -1;}
 329			tp_num = j2k_get_num_tp(cp,pino,tileno);
 330			totnum_tp = totnum_tp + tp_num;
 331			cur_totnum_tp = cur_totnum_tp + tp_num;
 332			pi_destroy(pi, cp, tileno);
 333		}
 334		j2k->cur_totnum_tp[tileno] = cur_totnum_tp;
 335		/* INDEX >> */
 336		if (j2k->cstr_info) {
 337			j2k->cstr_info->tile[tileno].num_tps = cur_totnum_tp;
 338			j2k->cstr_info->tile[tileno].tp = (opj_tp_info_t *) opj_malloc(cur_totnum_tp * sizeof(opj_tp_info_t));
 339		}
 340		/* << INDEX */
 341	}
 342	return totnum_tp;
 343}
 344
 345static void j2k_write_soc(opj_j2k_t *j2k) {
 346	opj_cio_t *cio = j2k->cio;
 347	cio_write(cio, J2K_MS_SOC, 2);
 348
 349	if(j2k->cstr_info)
 350	  j2k_add_mhmarker(j2k->cstr_info, J2K_MS_SOC, cio_tell(cio), 0);
 351
 352/* UniPG>> */
 353#ifdef USE_JPWL
 354
 355	/* update markers struct */
 356	j2k_add_marker(j2k->cstr_info, J2K_MS_SOC, cio_tell(cio) - 2, 2);
 357#endif /* USE_JPWL */
 358/* <<UniPG */
 359}
 360
 361static void j2k_read_soc(opj_j2k_t *j2k) {	
 362	j2k->state = J2K_STATE_MHSIZ;
 363	/* Index */
 364	if (j2k->cstr_info) {
 365		j2k->cstr_info->main_head_start = cio_tell(j2k->cio) - 2;
 366		j2k->cstr_info->codestream_size = cio_numbytesleft(j2k->cio) + 2 - j2k->cstr_info->main_head_start;
 367	}
 368}
 369
 370static void j2k_write_siz(opj_j2k_t *j2k) {
 371	int i;
 372	int lenp, len;
 373
 374	opj_cio_t *cio = j2k->cio;
 375	opj_image_t *image = j2k->image;
 376	opj_cp_t *cp = j2k->cp;
 377
 378	cio_write(cio, J2K_MS_SIZ, 2);	/* SIZ */
 379	lenp = cio_tell(cio);
 380	cio_skip(cio, 2);
 381	cio_write(cio, cp->rsiz, 2);			/* Rsiz (capabilities) */
 382	cio_write(cio, image->x1, 4);	/* Xsiz */
 383	cio_write(cio, image->y1, 4);	/* Ysiz */
 384	cio_write(cio, image->x0, 4);	/* X0siz */
 385	cio_write(cio, image->y0, 4);	/* Y0siz */
 386	cio_write(cio, cp->tdx, 4);		/* XTsiz */
 387	cio_write(cio, cp->tdy, 4);		/* YTsiz */
 388	cio_write(cio, cp->tx0, 4);		/* XT0siz */
 389	cio_write(cio, cp->ty0, 4);		/* YT0siz */
 390	cio_write(cio, image->numcomps, 2);	/* Csiz */
 391	for (i = 0; i < image->numcomps; i++) {
 392		cio_write(cio, image->comps[i].prec - 1 + (image->comps[i].sgnd << 7), 1);	/* Ssiz_i */
 393		cio_write(cio, image->comps[i].dx, 1);	/* XRsiz_i */
 394		cio_write(cio, image->comps[i].dy, 1);	/* YRsiz_i */
 395	}
 396	len = cio_tell(cio) - lenp;
 397	cio_seek(cio, lenp);
 398	cio_write(cio, len, 2);		/* Lsiz */
 399	cio_seek(cio, lenp + len);
 400	
 401	if(j2k->cstr_info)
 402	  j2k_add_mhmarker(j2k->cstr_info, J2K_MS_SIZ, lenp, len);
 403}
 404
 405static void j2k_read_siz(opj_j2k_t *j2k) {
 406	int len, i;
 407	
 408	opj_cio_t *cio = j2k->cio;
 409	opj_image_t *image = j2k->image;
 410	opj_cp_t *cp = j2k->cp;
 411	
 412	len = cio_read(cio, 2);			/* Lsiz */
 413	cio_read(cio, 2);				/* Rsiz (capabilities) */
 414	image->x1 = cio_read(cio, 4);	/* Xsiz */
 415	image->y1 = cio_read(cio, 4);	/* Ysiz */
 416	image->x0 = cio_read(cio, 4);	/* X0siz */
 417	image->y0 = cio_read(cio, 4);	/* Y0siz */
 418	cp->tdx = cio_read(cio, 4);		/* XTsiz */
 419	cp->tdy = cio_read(cio, 4);		/* YTsiz */
 420	cp->tx0 = cio_read(cio, 4);		/* XT0siz */
 421	cp->ty0 = cio_read(cio, 4);		/* YT0siz */
 422	
 423	if ((image->x0<0)||(image->x1<0)||(image->y0<0)||(image->y1<0)) {
 424		opj_event_msg(j2k->cinfo, EVT_ERROR,
 425									"%s: invalid image size (x0:%d, x1:%d, y0:%d, y1:%d)\n",
 426									image->x0,image->x1,image->y0,image->y1);
 427		return;
 428	}
 429	
 430	image->numcomps = cio_read(cio, 2);	/* Csiz */
 431
 432#ifdef USE_JPWL
 433	if (j2k->cp->correct) {
 434		/* if JPWL is on, we check whether TX errors have damaged
 435		  too much the SIZ parameters */
 436		if (!(image->x1 * image->y1)) {
 437			opj_event_msg(j2k->cinfo, EVT_ERROR,
 438				"JPWL: bad image size (%d x %d)\n",
 439				image->x1, image->y1);
 440			if (!JPWL_ASSUME || JPWL_ASSUME) {
 441				opj_event_msg(j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
 442				return;
 443			}
 444		}
 445		if (image->numcomps != ((len - 38) / 3)) {
 446			opj_event_msg(j2k->cinfo, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
 447				"JPWL: Csiz is %d => space in SIZ only for %d comps.!!!\n",
 448				image->numcomps, ((len - 38) / 3));
 449			if (!JPWL_ASSUME) {
 450				opj_event_msg(j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
 451				return;
 452			}
 453			/* we try to correct */
 454			opj_event_msg(j2k->cinfo, EVT_WARNING, "- trying to adjust this\n");
 455			if (image->numcomps < ((len - 38) / 3)) {
 456				len = 38 + 3 * image->numcomps;
 457				opj_event_msg(j2k->cinfo, EVT_WARNING, "- setting Lsiz to %d => HYPOTHESIS!!!\n",
 458					len);				
 459			} else {
 460				image->numcomps = ((len - 38) / 3);
 461				opj_event_msg(j2k->cinfo, EVT_WARNING, "- setting Csiz to %d => HYPOTHESIS!!!\n",
 462					image->numcomps);				
 463			}
 464		}
 465
 466		/* update components number in the jpwl_exp_comps filed */
 467		cp->exp_comps = image->numcomps;
 468	}
 469#endif /* USE_JPWL */
 470
 471	image->comps = (opj_image_comp_t*) opj_calloc(image->numcomps, sizeof(opj_image_comp_t));
 472	for (i = 0; i < image->numcomps; i++) {
 473		int tmp, w, h;
 474		tmp = cio_read(cio, 1);		/* Ssiz_i */
 475		image->comps[i].prec = (tmp & 0x7f) + 1;
 476		image->comps[i].sgnd = tmp >> 7;
 477		image->comps[i].dx = cio_read(cio, 1);	/* XRsiz_i */
 478		image->comps[i].dy = cio_read(cio, 1);	/* YRsiz_i */
 479		
 480#ifdef USE_JPWL
 481		if (j2k->cp->correct) {
 482		/* if JPWL is on, we check whether TX errors have damaged
 483			too much the SIZ parameters, again */
 484			if (!(image->comps[i].dx * image->comps[i].dy)) {
 485				opj_event_msg(j2k->cinfo, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
 486					"JPWL: bad XRsiz_%d/YRsiz_%d (%d x %d)\n",
 487					i, i, image->comps[i].dx, image->comps[i].dy);
 488				if (!JPWL_ASSUME) {
 489					opj_event_msg(j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
 490					return;
 491				}
 492				/* we try to correct */
 493				opj_event_msg(j2k->cinfo, EVT_WARNING, "- trying to adjust them\n");
 494				if (!image->comps[i].dx) {
 495					image->comps[i].dx = 1;
 496					opj_event_msg(j2k->cinfo, EVT_WARNING, "- setting XRsiz_%d to %d => HYPOTHESIS!!!\n",
 497						i, image->comps[i].dx);
 498				}
 499				if (!image->comps[i].dy) {
 500					image->comps[i].dy = 1;
 501					opj_event_msg(j2k->cinfo, EVT_WARNING, "- setting YRsiz_%d to %d => HYPOTHESIS!!!\n",
 502						i, image->comps[i].dy);
 503				}
 504			}
 505			
 506		}
 507#endif /* USE_JPWL */
 508
 509		/* TODO: unused ? */
 510		w = int_ceildiv(image->x1 - image->x0, image->comps[i].dx);
 511		h = int_ceildiv(image->y1 - image->y0, image->comps[i].dy);
 512
 513		image->comps[i].resno_decoded = 0;	/* number of resolution decoded */
 514		image->comps[i].factor = cp->reduce; /* reducing factor per component */
 515	}
 516	
 517	cp->tw = int_ceildiv(image->x1 - cp->tx0, cp->tdx);
 518	cp->th = int_ceildiv(image->y1 - cp->ty0, cp->tdy);
 519
 520#ifdef USE_JPWL
 521	if (j2k->cp->correct) {
 522		/* if JPWL is on, we check whether TX errors have damaged
 523		  too much the SIZ parameters */
 524		if ((cp->tw < 1) || (cp->th < 1) || (cp->tw > cp->max_tiles) || (cp->th > cp->max_tiles)) {
 525			opj_event_msg(j2k->cinfo, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
 526				"JPWL: bad number of tiles (%d x %d)\n",
 527				cp->tw, cp->th);
 528			if (!JPWL_ASSUME) {
 529				opj_event_msg(j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
 530				return;
 531			}
 532			/* we try to correct */
 533			opj_event_msg(j2k->cinfo, EVT_WARNING, "- trying to adjust them\n");
 534			if (cp->tw < 1) {
 535				cp->tw= 1;
 536				opj_event_msg(j2k->cinfo, EVT_WARNING, "- setting %d tiles in x => HYPOTHESIS!!!\n",
 537					cp->tw);
 538			}
 539			if (cp->tw > cp->max_tiles) {
 540				cp->tw= 1;
 541				opj_event_msg(j2k->cinfo, EVT_WARNING, "- too large x, increase expectance of %d\n"
 542					"- setting %d tiles in x => HYPOTHESIS!!!\n",
 543					cp->max_tiles, cp->tw);
 544			}
 545			if (cp->th < 1) {
 546				cp->th= 1;
 547				opj_event_msg(j2k->cinfo, EVT_WARNING, "- setting %d tiles in y => HYPOTHESIS!!!\n",
 548					cp->th);
 549			}
 550			if (cp->th > cp->max_tiles) {
 551				cp->th= 1;
 552				opj_event_msg(j2k->cinfo, EVT_WARNING, "- too large y, increase expectance of %d to continue\n",
 553					"- setting %d tiles in y => HYPOTHESIS!!!\n",
 554					cp->max_tiles, cp->th);
 555			}
 556		}
 557	}
 558#endif /* USE_JPWL */
 559
 560	cp->tcps = (opj_tcp_t*) opj_calloc(cp->tw * cp->th, sizeof(opj_tcp_t));
 561	cp->tileno = (int*) opj_malloc(cp->tw * cp->th * sizeof(int));
 562	cp->tileno_size = 0;
 563	
 564#ifdef USE_JPWL
 565	if (j2k->cp->correct) {
 566		if (!cp->tcps) {
 567			opj_event_msg(j2k->cinfo, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
 568				"JPWL: could not alloc tcps field of cp\n");
 569			if (!JPWL_ASSUME || JPWL_ASSUME) {
 570				opj_event_msg(j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
 571				return;
 572			}
 573		}
 574	}
 575#endif /* USE_JPWL */
 576
 577	for (i = 0; i < cp->tw * cp->th; i++) {
 578		cp->tcps[i].POC = 0;
 579		cp->tcps[i].numpocs = 0;
 580		cp->tcps[i].first = 1;
 581	}
 582	
 583	/* Initialization for PPM marker */
 584	cp->ppm = 0;
 585	cp->ppm_data = NULL;
 586	cp->ppm_data_first = NULL;
 587	cp->ppm_previous = 0;
 588	cp->ppm_store = 0;
 589
 590	j2k->default_tcp->tccps = (opj_tccp_t*) opj_calloc(image->numcomps, sizeof(opj_tccp_t));
 591	for (i = 0; i < cp->tw * cp->th; i++) {
 592		cp->tcps[i].tccps = (opj_tccp_t*) opj_malloc(image->numcomps * sizeof(opj_tccp_t));
 593	}	
 594	j2k->tile_data = (unsigned char**) opj_calloc(cp->tw * cp->th, sizeof(unsigned char*));
 595	j2k->tile_len = (int*) opj_calloc(cp->tw * cp->th, sizeof(int));
 596	j2k->state = J2K_STATE_MH;
 597
 598	/* Index */
 599	if (j2k->cstr_info) {
 600		opj_codestream_info_t *cstr_info = j2k->cstr_info;
 601		cstr_info->image_w = image->x1 - image->x0;
 602		cstr_info->image_h = image->y1 - image->y0;
 603		cstr_info->numcomps = image->numcomps;
 604		cstr_info->tw = cp->tw;
 605		cstr_info->th = cp->th;
 606		cstr_info->tile_x = cp->tdx;	
 607		cstr_info->tile_y = cp->tdy;	
 608		cstr_info->tile_Ox = cp->tx0;	
 609		cstr_info->tile_Oy = cp->ty0;			
 610		cstr_info->tile = (opj_tile_info_t*) opj_calloc(cp->tw * cp->th, sizeof(opj_tile_info_t));		
 611	}
 612}
 613
 614static void j2k_write_com(opj_j2k_t *j2k) {
 615	unsigned int i;
 616	int lenp, len;
 617
 618	if(j2k->cp->comment) {
 619		opj_cio_t *cio = j2k->cio;
 620		char *comment = j2k->cp->comment;
 621
 622		cio_write(cio, J2K_MS_COM, 2);
 623		lenp = cio_tell(cio);
 624		cio_skip(cio, 2);
 625		cio_write(cio, 1, 2);		/* General use (IS 8859-15:1999 (Latin) values) */
 626		for (i = 0; i < strlen(comment); i++) {
 627			cio_write(cio, comment[i], 1);
 628		}
 629		len = cio_tell(cio) - lenp;
 630		cio_seek(cio, lenp);
 631		cio_write(cio, len, 2);
 632		cio_seek(cio, lenp + len);
 633
 634		
 635		if(j2k->cstr_info)
 636		  j2k_add_mhmarker(j2k->cstr_info, J2K_MS_COM, lenp, len);
 637
 638	}
 639}
 640
 641static void j2k_read_com(opj_j2k_t *j2k) {
 642	int len;
 643	
 644	opj_cio_t *cio = j2k->cio;
 645
 646	len = cio_read(cio, 2);
 647	cio_skip(cio, len - 2);  
 648}
 649
 650static void j2k_write_cox(opj_j2k_t *j2k, int compno) {
 651	int i;
 652
 653	opj_cp_t *cp = j2k->cp;
 654	opj_tcp_t *tcp = &cp->tcps[j2k->curtileno];
 655	opj_tccp_t *tccp = &tcp->tccps[compno];
 656	opj_cio_t *cio = j2k->cio;
 657	
 658	cio_write(cio, tccp->numresolutions - 1, 1);	/* SPcox (D) */
 659	cio_write(cio, tccp->cblkw - 2, 1);				/* SPcox (E) */
 660	cio_write(cio, tccp->cblkh - 2, 1);				/* SPcox (F) */
 661	cio_write(cio, tccp->cblksty, 1);				/* SPcox (G) */
 662	cio_write(cio, tccp->qmfbid, 1);				/* SPcox (H) */
 663	
 664	if (tccp->csty & J2K_CCP_CSTY_PRT) {
 665		for (i = 0; i < tccp->numresolutions; i++) {
 666			cio_write(cio, tccp->prcw[i] + (tccp->prch[i] << 4), 1);	/* SPcox (I_i) */
 667		}
 668	}
 669}
 670
 671static void j2k_read_cox(opj_j2k_t *j2k, int compno) {
 672	int i;
 673
 674	opj_cp_t *cp = j2k->cp;
 675	opj_tcp_t *tcp = j2k->state == J2K_STATE_TPH ? &cp->tcps[j2k->curtileno] : j2k->default_tcp;
 676	opj_tccp_t *tccp = &tcp->tccps[compno];
 677	opj_cio_t *cio = j2k->cio;
 678
 679	tccp->numresolutions = cio_read(cio, 1) + 1;	/* SPcox (D) */
 680
 681	/* If user wants to remove more resolutions than the codestream contains, return error*/
 682	if (cp->reduce >= tccp->numresolutions) {
 683		opj_event_msg(j2k->cinfo, EVT_ERROR, "Error decoding component %d.\nThe number of resolutions to remove is higher than the number "
 684					"of resolutions of this component\nModify the cp_reduce parameter.\n\n", compno);
 685		j2k->state |= J2K_STATE_ERR;
 686	}
 687
 688	tccp->cblkw = cio_read(cio, 1) + 2;	/* SPcox (E) */
 689	tccp->cblkh = cio_read(cio, 1) + 2;	/* SPcox (F) */
 690	tccp->cblksty = cio_read(cio, 1);	/* SPcox (G) */
 691	tccp->qmfbid = cio_read(cio, 1);	/* SPcox (H) */
 692	if (tccp->csty & J2K_CP_CSTY_PRT) {
 693		for (i = 0; i < tccp->numresolutions; i++) {
 694			int tmp = cio_read(cio, 1);	/* SPcox (I_i) */
 695			tccp->prcw[i] = tmp & 0xf;
 696			tccp->prch[i] = tmp >> 4;
 697		}
 698	}
 699
 700	/* INDEX >> */
 701	if(j2k->cstr_info && compno == 0) {
 702		for (i = 0; i < tccp->numresolutions; i++) {
 703			if (tccp->csty & J2K_CP_CSTY_PRT) {
 704				j2k->cstr_info->tile[j2k->curtileno].pdx[i] = tccp->prcw[i];
 705				j2k->cstr_info->tile[j2k->curtileno].pdy[i] = tccp->prch[i];
 706			}
 707			else {
 708				j2k->cstr_info->tile[j2k->curtileno].pdx[i] = 15;
 709				j2k->cstr_info->tile[j2k->curtileno].pdx[i] = 15;
 710			}
 711		}
 712	}
 713	/* << INDEX */
 714}
 715
 716static void j2k_write_cod(opj_j2k_t *j2k) {
 717	opj_cp_t *cp = NULL;
 718	opj_tcp_t *tcp = NULL;
 719	int lenp, len;
 720
 721	opj_cio_t *cio = j2k->cio;
 722	
 723	cio_write(cio, J2K_MS_COD, 2);	/* COD */
 724	
 725	lenp = cio_tell(cio);
 726	cio_skip(cio, 2);
 727	
 728	cp = j2k->cp;
 729	tcp = &cp->tcps[j2k->curtileno];
 730
 731	cio_write(cio, tcp->csty, 1);		/* Scod */
 732	cio_write(cio, tcp->prg, 1);		/* SGcod (A) */
 733	cio_write(cio, tcp->numlayers, 2);	/* SGcod (B) */
 734	cio_write(cio, tcp->mct, 1);		/* SGcod (C) */
 735	
 736	j2k_write_cox(j2k, 0);
 737	len = cio_tell(cio) - lenp;
 738	cio_seek(cio, lenp);
 739	cio_write(cio, len, 2);		/* Lcod */
 740	cio_seek(cio, lenp + len);
 741
 742	if(j2k->cstr_info)
 743	  j2k_add_mhmarker(j2k->cstr_info, J2K_MS_COD, lenp, len);
 744
 745}
 746
 747static void j2k_read_cod(opj_j2k_t *j2k) {
 748	int len, i, pos;
 749	
 750	opj_cio_t *cio = j2k->cio;
 751	opj_cp_t *cp = j2k->cp;
 752	opj_tcp_t *tcp = j2k->state == J2K_STATE_TPH ? &cp->tcps[j2k->curtileno] : j2k->default_tcp;
 753	opj_image_t *image = j2k->image;
 754	
 755	len = cio_read(cio, 2);				/* Lcod */
 756	tcp->csty = cio_read(cio, 1);		/* Scod */
 757	tcp->prg = (OPJ_PROG_ORDER)cio_read(cio, 1);		/* SGcod (A) */
 758	tcp->numlayers = cio_read(cio, 2);	/* SGcod (B) */
 759	tcp->mct = cio_read(cio, 1);		/* SGcod (C) */
 760	
 761	pos = cio_tell(cio);
 762	for (i = 0; i < image->numcomps; i++) {
 763		tcp->tccps[i].csty = tcp->csty & J2K_CP_CSTY_PRT;
 764		cio_seek(cio, pos);
 765		j2k_read_cox(j2k, i);
 766	}
 767
 768	/* Index */
 769	if (j2k->cstr_info) {
 770		opj_codestream_info_t *cstr_info = j2k->cstr_info;
 771		cstr_info->prog = tcp->prg;
 772		cstr_info->numlayers = tcp->numlayers;
 773		cstr_info->numdecompos = (int*) opj_malloc(image->numcomps * sizeof(int));
 774		for (i = 0; i < image->numcomps; i++) {
 775			cstr_info->numdecompos[i] = tcp->tccps[i].numresolutions - 1;
 776		}
 777	}
 778}
 779
 780static void j2k_write_coc(opj_j2k_t *j2k, int compno) {
 781	int lenp, len;
 782
 783	opj_cp_t *cp = j2k->cp;
 784	opj_tcp_t *tcp = &cp->tcps[j2k->curtileno];
 785	opj_image_t *image = j2k->image;
 786	opj_cio_t *cio = j2k->cio;
 787	
 788	cio_write(cio, J2K_MS_COC, 2);	/* COC */
 789	lenp = cio_tell(cio);
 790	cio_skip(cio, 2);
 791	cio_write(cio, compno, image->numcomps <= 256 ? 1 : 2);	/* Ccoc */
 792	cio_write(cio, tcp->tccps[compno].csty, 1);	/* Scoc */
 793	j2k_write_cox(j2k, compno);
 794	len = cio_tell(cio) - lenp;
 795	cio_seek(cio, lenp);
 796	cio_write(cio, len, 2);			/* Lcoc */
 797	cio_seek(cio, lenp + len);
 798}
 799
 800static void j2k_read_coc(opj_j2k_t *j2k) {
 801	int len, compno;
 802
 803	opj_cp_t *cp = j2k->cp;
 804	opj_tcp_t *tcp = j2k->state == J2K_STATE_TPH ? &cp->tcps[j2k->curtileno] : j2k->default_tcp;
 805	opj_image_t *image = j2k->image;
 806	opj_cio_t *cio = j2k->cio;
 807	
 808	len = cio_read(cio, 2);		/* Lcoc */
 809	compno = cio_read(cio, image->numcomps <= 256 ? 1 : 2);	/* Ccoc */
 810	tcp->tccps[compno].csty = cio_read(cio, 1);	/* Scoc */
 811	j2k_read_cox(j2k, compno);
 812}
 813
 814static void j2k_write_qcx(opj_j2k_t *j2k, int compno) {
 815	int bandno, numbands;
 816	int expn, mant;
 817	
 818	opj_cp_t *cp = j2k->cp;
 819	opj_tcp_t *tcp = &cp->tcps[j2k->curtileno];
 820	opj_tccp_t *tccp = &tcp->tccps[compno];
 821	opj_cio_t *cio = j2k->cio;
 822	
 823	cio_write(cio, tccp->qntsty + (tccp->numgbits << 5), 1);	/* Sqcx */
 824	numbands = tccp->qntsty == J2K_CCP_QNTSTY_SIQNT ? 1 : tccp->numresolutions * 3 - 2;
 825	
 826	for (bandno = 0; bandno < numbands; bandno++) {
 827		expn = tccp->stepsizes[bandno].expn;
 828		mant = tccp->stepsizes[bandno].mant;
 829		
 830		if (tccp->qntsty == J2K_CCP_QNTSTY_NOQNT) {
 831			cio_write(cio, expn << 3, 1);	/* SPqcx_i */
 832		} else {
 833			cio_write(cio, (expn << 11) + mant, 2);	/* SPqcx_i */
 834		}
 835	}
 836}
 837
 838static void j2k_read_qcx(opj_j2k_t *j2k, int compno, int len) {
 839	int tmp;
 840	int bandno, numbands;
 841
 842	opj_cp_t *cp = j2k->cp;
 843	opj_tcp_t *tcp = j2k->state == J2K_STATE_TPH ? &cp->tcps[j2k->curtileno] : j2k->default_tcp;
 844	opj_tccp_t *tccp = &tcp->tccps[compno];
 845	opj_cio_t *cio = j2k->cio;
 846
 847	tmp = cio_read(cio, 1);		/* Sqcx */
 848	tccp->qntsty = tmp & 0x1f;
 849	tccp->numgbits = tmp >> 5;
 850	numbands = (tccp->qntsty == J2K_CCP_QNTSTY_SIQNT) ? 
 851		1 : ((tccp->qntsty == J2K_CCP_QNTSTY_NOQNT) ? len - 1 : (len - 1) / 2);
 852
 853#ifdef USE_JPWL
 854	if (j2k->cp->correct) {
 855
 856		/* if JPWL is on, we check whether there are too many subbands */
 857		if ((numbands < 0) || (numbands >= J2K_MAXBANDS)) {
 858			opj_event_msg(j2k->cinfo, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
 859				"JPWL: bad number of subbands in Sqcx (%d)\n",
 860				numbands);
 861			if (!JPWL_ASSUME) {
 862				opj_event_msg(j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
 863				return;
 864			}
 865			/* we try to correct */
 866			numbands = 1;
 867			opj_event_msg(j2k->cinfo, EVT_WARNING, "- trying to adjust them\n"
 868				"- setting number of bands to %d => HYPOTHESIS!!!\n",
 869				numbands);
 870		};
 871
 872	};
 873
 874#else
 875	/* We check whether there are too many subbands */
 876	if ((numbands < 0) || (numbands >= J2K_MAXBANDS)) {
 877		opj_event_msg(j2k->cinfo, EVT_WARNING ,
 878					"bad number of subbands in Sqcx (%d) regarding to J2K_MAXBANDS (%d) \n"
 879				    "- limiting number of bands to J2K_MAXBANDS and try to move to the next markers\n", numbands, J2K_MAXBANDS);
 880	}
 881
 882#endif /* USE_JPWL */
 883
 884	for (bandno = 0; bandno < numbands; bandno++) {
 885		int expn, mant;
 886		if (tccp->qntsty == J2K_CCP_QNTSTY_NOQNT) {
 887			expn = cio_read(cio, 1) >> 3;	/* SPqcx_i */
 888			mant = 0;
 889		} else {
 890			tmp = cio_read(cio, 2);	/* SPqcx_i */
 891			expn = tmp >> 11;
 892			mant = tmp & 0x7ff;
 893		}
 894		if (bandno < J2K_MAXBANDS){
 895			tccp->stepsizes[bandno].expn = expn;
 896			tccp->stepsizes[bandno].mant = mant;
 897		}
 898	}
 899	
 900	/* Add Antonin : if scalar_derived -> compute other stepsizes */
 901	if (tccp->qntsty == J2K_CCP_QNTSTY_SIQNT) {
 902		for (bandno = 1; bandno < J2K_MAXBANDS; bandno++) {
 903			tccp->stepsizes[bandno].expn = 
 904				((tccp->stepsizes[0].expn) - ((bandno - 1) / 3) > 0) ? 
 905					(tccp->stepsizes[0].expn) - ((bandno - 1) / 3) : 0;
 906			tccp->stepsizes[bandno].mant = tccp->stepsizes[0].mant;
 907		}
 908	}
 909	/* ddA */
 910}
 911
 912static void j2k_write_qcd(opj_j2k_t *j2k) {
 913	int lenp, len;
 914
 915	opj_cio_t *cio = j2k->cio;
 916	
 917	cio_write(cio, J2K_MS_QCD, 2);	/* QCD */
 918	lenp = cio_tell(cio);
 919	cio_skip(cio, 2);
 920	j2k_write_qcx(j2k, 0);
 921	len = cio_tell(cio) - lenp;
 922	cio_seek(cio, lenp);
 923	cio_write(cio, len, 2);			/* Lqcd */
 924	cio_seek(cio, lenp + len);
 925
 926	if(j2k->cstr_info)
 927	  j2k_add_mhmarker(j2k->cstr_info, J2K_MS_QCD, lenp, len);
 928}
 929
 930static void j2k_read_qcd(opj_j2k_t *j2k) {
 931	int len, i, pos;
 932
 933	opj_cio_t *cio = j2k->cio;
 934	opj_image_t *image = j2k->image;
 935	
 936	len = cio_read(cio, 2);		/* Lqcd */
 937	pos = cio_tell(cio);
 938	for (i = 0; i < image->numcomps; i++) {
 939		cio_seek(cio, pos);
 940		j2k_read_qcx(j2k, i, len - 2);
 941	}
 942}
 943
 944static void j2k_write_qcc(opj_j2k_t *j2k, int compno) {
 945	int lenp, len;
 946
 947	opj_cio_t *cio = j2k->cio;
 948	
 949	cio_write(cio, J2K_MS_QCC, 2);	/* QCC */
 950	lenp = cio_tell(cio);
 951	cio_skip(cio, 2);
 952	cio_write(cio, compno, j2k->image->numcomps <= 256 ? 1 : 2);	/* Cqcc */
 953	j2k_write_qcx(j2k, compno);
 954	len = cio_tell(cio) - lenp;
 955	cio_seek(cio, lenp);
 956	cio_write(cio, len, 2);			/* Lqcc */
 957	cio_seek(cio, lenp + len);
 958}
 959
 960static void j2k_read_qcc(opj_j2k_t *j2k) {
 961	int len, compno;
 962	int numcomp = j2k->image->numcomps;
 963	opj_cio_t *cio = j2k->cio;
 964
 965	len = cio_read(cio, 2);	/* Lqcc */
 966	compno = cio_read(cio, numcomp <= 256 ? 1 : 2);	/* Cqcc */
 967
 968#ifdef USE_JPWL
 969	if (j2k->cp->correct) {
 970
 971		static int backup_compno = 0;
 972
 973		/* compno is negative or larger than the number of components!!! */
 974		if ((compno < 0) || (compno >= numcomp)) {
 975			opj_event_msg(j2k->cinfo, EVT_ERROR,
 976				"JPWL: bad component number in QCC (%d out of a maximum of %d)\n",
 977				compno, numcomp);
 978			if (!JPWL_ASSUME) {
 979				opj_event_msg(j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
 980				return;
 981			}
 982			/* we try to correct */
 983			compno = backup_compno % numcomp;
 984			opj_event_msg(j2k->cinfo, EVT_WARNING, "- trying to adjust this\n"
 985				"- setting component number to %d\n",
 986				compno);
 987		}
 988
 989		/* keep your private count of tiles */
 990		backup_compno++;
 991	};
 992#endif /* USE_JPWL */
 993
 994	j2k_read_qcx(j2k, compno, len - 2 - (numcomp <= 256 ? 1 : 2));
 995}
 996
 997static void j2k_write_poc(opj_j2k_t *j2k) {
 998	int len, numpchgs, i;
 999
1000	int numcomps = j2k->image->numcomps;
1001	
1002	opj_cp_t *cp = j2k->cp;
1003	opj_tcp_t *tcp = &cp->tcps[j2k->curtileno];
1004	opj_tccp_t *tccp = &tcp->tccps[0];
1005	opj_cio_t *cio = j2k->cio;
1006
1007	numpchgs = 1 + tcp->numpocs;
1008	cio_write(cio, J2K_MS_POC, 2);	/* POC  */
1009	len = 2 + (5 + 2 * (numcomps <= 256 ? 1 : 2)) * numpchgs;
1010	cio_write(cio, len, 2);		/* Lpoc */
1011	for (i = 0; i < numpchgs; i++) {
1012		opj_poc_t *poc = &tcp->pocs[i];
1013		cio_write(cio, poc->resno0, 1);	/* RSpoc_i */
1014		cio_write(cio, poc->compno0, (numcomps <= 256 ? 1 : 2));	/* CSpoc_i */
1015		cio_write(cio, poc->layno1, 2);	/* LYEpoc_i */
1016		poc->layno1 = int_min(poc->layno1, tcp->numlayers);
1017		cio_write(cio, poc->resno1, 1);	/* REpoc_i */
1018		poc->resno1 = int_min(poc->resno1, tccp->numresolutions);
1019		cio_write(cio, poc->compno1, (numcomps <= 256 ? 1 : 2));	/* CEpoc_i */
1020		poc->compno1 = int_min(poc->compno1, numcomps);
1021		cio_write(cio, poc->prg, 1);	/* Ppoc_i */
1022	}
1023}
1024
1025static void j2k_read_poc(opj_j2k_t *j2k) {
1026	int len, numpchgs, i, old_poc;
1027
1028	int numcomps = j2k->image->numcomps;
1029	
1030	opj_cp_t *cp = j2k->cp;
1031	opj_tcp_t *tcp = j2k->state == J2K_STATE_TPH ? &cp->tcps[j2k->curtileno] : j2k->default_tcp;
1032	opj_cio_t *cio = j2k->cio;
1033	
1034	old_poc = tcp->POC ? tcp->numpocs + 1 : 0;
1035	tcp->POC = 1;
1036	len = cio_read(cio, 2);		/* Lpoc */
1037	numpchgs = (len - 2) / (5 + 2 * (numcomps <= 256 ? 1 : 2));
1038	
1039	for (i = old_poc; i < numpchgs + old_poc; i++) {
1040		opj_poc_t *poc;
1041		poc = &tcp->pocs[i];
1042		poc->resno0 = cio_read(cio, 1);	/* RSpoc_i */
1043		poc->compno0 = cio_read(cio, numcomps <= 256 ? 1 : 2);	/* CSpoc_i */
1044		poc->layno1 = cio_read(cio, 2);    /* LYEpoc_i */
1045		poc->resno1 = cio_read(cio, 1);    /* REpoc_i */
1046		poc->compno1 = int_min(
1047			cio_read(cio, numcomps <= 256 ? 1 : 2), (unsigned int) numcomps);	/* CEpoc_i */
1048		poc->prg = (OPJ_PROG_ORDER)cio_read(cio, 1);	/* Ppoc_i */
1049	}
1050	
1051	tcp->numpocs = numpchgs + old_poc - 1;
1052}
1053
1054static void j2k_read_crg(opj_j2k_t *j2k) {
1055	int len, i, Xcrg_i, Ycrg_i;
1056	
1057	opj_cio_t *cio = j2k->cio;
1058	int numcomps = j2k->image->numcomps;
1059	
1060	len = cio_read(cio, 2);			/* Lcrg */
1061	for (i = 0; i < numcomps; i++) {
1062		Xcrg_i = cio_read(cio, 2);	/* Xcrg_i */
1063		Ycrg_i = cio_read(cio, 2);	/* Ycrg_i */
1064	}
1065}
1066
1067static void j2k_read_tlm(opj_j2k_t *j2k) {
1068	int len, Ztlm, Stlm, ST, SP, tile_tlm, i;
1069	long int Ttlm_i, Ptlm_i;
1070
1071	opj_cio_t *cio = j2k->cio;
1072	
1073	len = cio_read(cio, 2);		/* Ltlm */
1074	Ztlm = cio_read(cio, 1);	/* Ztlm */
1075	Stlm = cio_read(cio, 1);	/* Stlm */
1076	ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02);
1077	SP = (Stlm >> 6) & 0x01;
1078	tile_tlm = (len - 4) / ((SP + 1) * 2 + ST);
1079	for (i = 0; i < tile_tlm; i++) {
1080		Ttlm_i = cio_read(cio, ST);	/* Ttlm_i */
1081		Ptlm_i = cio_read(cio, SP ? 4 : 2);	/* Ptlm_i */
1082	}
1083}
1084
1085static void j2k_read_plm(opj_j2k_t *j2k) {
1086	int len, i, Zplm, Nplm, add, packet_len = 0;
1087	
1088	opj_cio_t *cio = j2k->cio;
1089
1090	len = cio_read(cio, 2);		/* Lplm */
1091	Zplm = cio_read(cio, 1);	/* Zplm */
1092	len -= 3;
1093	while (len > 0) {
1094		Nplm = cio_read(cio, 4);		/* Nplm */
1095		len -= 4;
1096		for (i = Nplm; i > 0; i--) {
1097			add = cio_read(cio, 1);
1098			len--;
1099			packet_len = (packet_len << 7) + add;	/* Iplm_ij */
1100			if ((add & 0x80) == 0) {
1101				/* New packet */
1102				packet_len = 0;
1103			}
1104			if (len <= 0)
1105				break;
1106		}
1107	}
1108}
1109
1110static void j2k_read_plt(opj_j2k_t *j2k) {
1111	int len, i, Zplt, packet_len = 0, add;
1112	
1113	opj_cio_t *cio = j2k->cio;
1114	
1115	len = cio_read(cio, 2);		/* Lplt */
1116	Zplt = cio_read(cio, 1);	/* Zplt */
1117	for (i = len - 3; i > 0; i--) {
1118		add = cio_read(cio, 1);
1119		packet_len = (packet_len << 7) + add;	/* Iplt_i */
1120		if ((add & 0x80) == 0) {
1121			/* New packet */
1122			packet_len = 0;
1123		}
1124	}
1125}
1126
1127static void j2k_read_ppm(opj_j2k_t *j2k) {
1128	int len, Z_ppm, i, j;
1129	int N_ppm;
1130
1131	opj_cp_t *cp = j2k->cp;
1132	opj_cio_t *cio = j2k->cio;
1133	
1134	len = cio_read(cio, 2);
1135	cp->ppm = 1;
1136	
1137	Z_ppm = cio_read(cio, 1);	/* Z_ppm */
1138	len -= 3;
1139	while (len > 0) {
1140		if (cp->ppm_previous == 0) {
1141			N_ppm = cio_read(cio, 4);	/* N_ppm */
1142			len -= 4;
1143		} else {
1144			N_ppm = cp->ppm_previous;
1145		}
1146		j = cp->ppm_store;
1147		if (Z_ppm == 0) {	/* First PPM marker */
1148			cp->ppm_data = (unsigned char *) opj_malloc(N_ppm * sizeof(unsigned char));
1149			cp->ppm_data_first = cp->ppm_data;
1150			cp->ppm_len = N_ppm;
1151		} else {			/* NON-first PPM marker */
1152			cp->ppm_data = (unsigned char *) opj_realloc(cp->ppm_data, (N_ppm +	cp->ppm_store) * sizeof(unsigned char));
1153
1154#ifdef USE_JPWL
1155			/* this memory allocation check could be done even in non-JPWL cases */
1156			if (cp->correct) {
1157				if (!cp->ppm_data) {
1158					opj_event_msg(j2k->cinfo, EVT_ERROR,
1159						"JPWL: failed memory allocation during PPM marker parsing (pos. %x)\n",
1160						cio_tell(cio));
1161					if (!JPWL_ASSUME || JPWL_ASSUME) {
1162						opj_free(cp->ppm_data);
1163						opj_event_msg(j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
1164						return;
1165					}
1166				}
1167			}
1168#endif
1169
1170			cp->ppm_data_first = cp->ppm_data;
1171			cp->ppm_len = N_ppm + cp->ppm_store;
1172		}
1173		for (i = N_ppm; i > 0; i--) {	/* Read packet header */
1174			cp->ppm_data[j] = cio_read(cio, 1);
1175			j++;
1176			len--;
1177			if (len == 0)
1178				break;			/* Case of non-finished packet header in present marker but finished in next one */
1179		}
1180		cp->ppm_previous = i - 1;
1181		cp->ppm_store = j;
1182	}
1183}
1184
1185static void j2k_read_ppt(opj_j2k_t *j2k) {
1186	int len, Z_ppt, i, j = 0;
1187
1188	opj_cp_t *cp = j2k->cp;
1189	opj_tcp_t *tcp = cp->tcps + j2k->curtileno;
1190	opj_cio_t *cio = j2k->cio;
1191
1192	len = cio_read(cio, 2);
1193	Z_ppt = cio_read(cio, 1);
1194	tcp->ppt = 1;
1195	if (Z_ppt == 0) {		/* First PPT marker */
1196		tcp->ppt_data = (unsigned char *) opj_malloc((len - 3) * sizeof(unsigned char));
1197		tcp->ppt_data_first = tcp->ppt_data;
1198		tcp->ppt_store = 0;
1199		tcp->ppt_len = len - 3;
1200	} else {			/* NON-first PPT marker */
1201		tcp->ppt_data =	(unsigned char *) opj_realloc(tcp->ppt_data, (len - 3 + tcp->ppt_store) * sizeof(unsigned char));
1202		tcp->ppt_data_first = tcp->ppt_data;
1203		tcp->ppt_len = len - 3 + tcp->ppt_store;
1204	}
1205	j = tcp->ppt_store;
1206	for (i = len - 3; i > 0; i--) {
1207		tcp->ppt_data[j] = cio_read(cio, 1);
1208		j++;
1209	}
1210	tcp->ppt_store = j;
1211}
1212
1213static void j2k_write_tlm(opj_j2k_t *j2k){
1214	int lenp;
1215	opj_cio_t *cio = j2k->cio;
1216	j2k->tlm_start = cio_tell(cio);
1217	cio_write(cio, J2K_MS_TLM, 2);/* TLM */
1218	lenp = 4 + (5*j2k->totnum_tp);
1219	cio_write(cio,lenp,2);				/* Ltlm */
1220	cio_write(cio, 0,1);					/* Ztlm=0*/
1221	cio_write(cio,80,1);					/* Stlm ST=1(8bits-255 tiles max),SP=1(Ptlm=32bits) */
1222	cio_skip(cio,5*j2k->totnum_tp);
1223}
1224
1225static void j2k_write_sot(opj_j2k_t *j2k) {
1226	int lenp, len;
1227
1228	opj_cio_t *cio = j2k->cio;
1229
1230	j2k->sot_start = cio_tell(cio);
1231	cio_write(cio, J2K_MS_SOT, 2);		/* SOT */
1232	lenp = cio_tell(cio);
1233	cio_skip(cio, 2);					/* Lsot (further) */
1234	cio_write(cio, j2k->curtileno, 2);	/* Isot */
1235	cio_skip(cio, 4);					/* Psot (further in j2k_write_sod) */
1236	cio_write(cio, j2k->cur_tp_num , 1);	/* TPsot */
1237	cio_write(cio, j2k->cur_totnum_tp[j2k->curtileno], 1);		/* TNsot */
1238	len = cio_tell(cio) - lenp;
1239	cio_seek(cio, lenp);
1240	cio_write(cio, len, 2);				/* Lsot */
1241	cio_seek(cio, lenp + len);
1242
1243	/* UniPG>> */
1244#ifdef USE_JPWL
1245	/* update markers struct */
1246	j2k_add_marker(j2k->cstr_info, J2K_MS_SOT, j2k->sot_start, len + 2);
1247#endif /* USE_JPWL */
1248	/* <<UniPG */
1249
1250	if( j2k->cstr_info && j2k->cur_tp_num==0){
1251	  j2k_add_tlmarker( j2k->curtileno, j2k->cstr_info, J2K_MS_SOT, lenp, len);
1252	}
1253}
1254
1255static void j2k_read_sot(opj_j2k_t *j2k) {
1256	int len, tileno, totlen, partno, numparts, i;
1257	opj_tcp_t *tcp = NULL;
1258	char status = 0;
1259
1260	opj_cp_t *cp = j2k->cp;
1261	opj_cio_t *cio = j2k->cio;
1262
1263	len = cio_read(cio, 2);
1264	tileno = cio_read(cio, 2);
1265
1266#ifdef USE_JPWL
1267	if (j2k->cp->correct) {
1268
1269		static int backup_tileno = 0;
1270
1271		/* tileno is negative or larger than the number of tiles!!! */
1272		if ((tileno < 0) || (tileno > (cp->tw * cp->th))) {
1273			opj_event_msg(j2k->cinfo, EVT_ERROR,
1274				"JPWL: bad tile number (%d out of a maximum of %d)\n",
1275				tileno, (cp->tw * cp->th));
1276			if (!JPWL_ASSUME) {
1277				opj_event_msg(j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
1278				return;
1279			}
1280			/* we try to correct */
1281			tileno = backup_tileno;
1282			opj_event_msg(j2k->cinfo, EVT_WARNING, "- trying to adjust this\n"
1283				"- setting tile number to %d\n",
1284				tileno);
1285		}
1286
1287		/* keep your private count of tiles */
1288		backup_tileno++;
1289	};
1290#endif /* USE_JPWL */
1291	
1292	if (cp->tileno_size == 0) {
1293		cp->tileno[cp->tileno_size] = tileno;
1294		cp->tileno_size++;
1295	} else {
1296		i = 0;
1297		while (i < cp->tileno_size && status == 0) {
1298			status = cp->tileno[i] == tileno ? 1 : 0;
1299			i++;
1300		}
1301		if (status == 0) {
1302			cp->tileno[cp->tileno_size] = tileno;
1303			cp->tileno_size++;
1304		}
1305	}
1306	
1307	totlen = cio_read(cio, 4);
1308
1309#ifdef USE_JPWL
1310	if (j2k->cp->correct) {
1311
1312		/* totlen is negative or larger than the bytes left!!! */
1313		if ((totlen < 0) || (totlen > (cio_numbytesleft(cio) + 8))) {
1314			opj_event_msg(j2k->cinfo, EVT_ERROR,
1315				"JPWL: bad tile byte size (%d bytes against %d bytes left)\n",
1316				totlen, cio_numbytesleft(cio) + 8);
1317			if (!JPWL_ASSUME) {
1318				opj_event_msg(j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
1319				return;
1320			}
1321			/* we try to correct */
1322			totlen = 0;
1323			opj_event_msg(j2k->cinfo, EVT_WARNING, "- trying to adjust this\n"
1324				"- setting Psot to %d => assuming it is the last tile\n",
1325				totlen);
1326		}
1327
1328	};
1329#endif /* USE_JPWL */
1330
1331	if (!totlen)
1332		totlen = cio_numbytesleft(cio) + 8;
1333	
1334	partno = cio_read(cio, 1);
1335	numparts = cio_read(cio, 1);
1336  
1337  if (partno >= numparts) {
1338    opj_event_msg(j2k->cinfo, EVT_WARNING, "SOT marker inconsistency in tile %d: tile-part index greater (%d) than number of tile-parts (%d)\n", tileno, partno, numparts);
1339    numparts = partno+1;
1340  }
1341	
1342	j2k->curtileno = tileno;
1343	j2k->cur_tp_num = partno;
1344	j2k->eot = cio_getbp(cio) - 12 + totlen;
1345	j2k->state = J2K_STATE_TPH;
1346	tcp = &cp->tcps[j2k->curtileno];
1347
1348	/* Index */
1349	if (j2k->cstr_info) {
1350		if (tcp->first) {
1351			if (tileno == 0) 
1352				j2k->cstr_info->main_head_end = cio_tell(cio) - 13;
1353			j2k->cstr_info->tile[tileno].tileno = tileno;
1354			j2k->cstr_info->tile[tileno].start_pos = cio_tell(cio) - 12;
1355			j2k->cstr_info->tile[tileno].end_pos = j2k->cstr_info->tile[tileno].start_pos + totlen - 1;				
1356    } else {
1357			j2k->cstr_info->tile[tileno].end_pos += totlen;
1358		}
1359    j2k->cstr_info->tile[tileno].num_tps = numparts;
1360    if (numparts)
1361      j2k->cstr_info->tile[tileno].tp = (opj_tp_info_t *) opj_realloc(j2k->cstr_info->tile[tileno].tp, numparts * sizeof(opj_tp_info_t));
1362    else
1363      j2k->cstr_info->tile[tileno].tp = (opj_tp_info_t *) opj_realloc(j2k->cstr_info->tile[tileno].tp, 10 * sizeof(opj_tp_info_t)); /* Fixme (10)*/
1364		j2k->cstr_info->tile[tileno].tp[partno].tp_start_pos = cio_tell(cio) - 12;
1365		j2k->cstr_info->tile[tileno].tp[partno].tp_end_pos = 
1366			j2k->cstr_info->tile[tileno].tp[partno].tp_start_pos + totlen - 1;
1367	}
1368	
1369	if (tcp->first == 1) {		
1370		/* Initialization PPT */
1371		opj_tccp_t *tmp = tcp->tccps;
1372		memcpy(tcp, j2k->default_tcp, sizeof(opj_tcp_t));
1373		tcp->ppt = 0;
1374		tcp->ppt_data = NULL;
1375		tcp->ppt_data_first = NULL;
1376		tcp->tccps = tmp;
1377
1378		for (i = 0; i < j2k->image->numcomps; i++) {
1379			tcp->tccps[i] = j2k->default_tcp->tccps[i];
1380		}
1381		cp->tcps[j2k->curtileno].first = 0;
1382	}
1383}
1384
1385static void j2k_write_sod(opj_j2k_t *j2k, void *tile_coder) {
1386	int l, layno;
1387	int totlen;
1388	opj_tcp_t *tcp = NULL;
1389	opj_codestream_info_t *cstr_info = NULL;
1390	
1391	opj_tcd_t *tcd = (opj_tcd_t*)tile_coder;	/* cast is needed because of conflicts in header inclusions */
1392	opj_cp_t *cp = j2k->cp;
1393	opj_cio_t *cio = j2k->cio;
1394
1395	tcd->tp_num = j2k->tp_num ;
1396	tcd->cur_tp_num = j2k->cur_tp_num;
1397	
1398	cio_write(cio, J2K_MS_SOD, 2);
1399
1400	if( j2k->cstr_info && j2k->cur_tp_num==0){
1401	  j2k_add_tlmarker( j2k->curtileno, j2k->cstr_info, J2K_MS_SOD, cio_tell(cio), 0);
1402	}
1403
1404	if (j2k->curtileno == 0) {
1405		j2k->sod_start = cio_tell(cio) + j2k->pos_correction;
1406	}
1407
1408	/* INDEX >> */
1409	cstr_info = j2k->cstr_info;
1410	if (cstr_info) {
1411		if (!j2k->cur_tp_num ) {
1412			cstr_info->tile[j2k->curtileno].end_header = cio_tell(cio) + j2k->pos_correction - 1;
1413			j2k->cstr_info->tile[j2k->curtileno].tileno = j2k->curtileno;
1414		}
1415		else{
1416			if(cstr_info->tile[j2k->curtileno].packet[cstr_info->packno - 1].end_pos < cio_tell(cio))
1417				cstr_info->tile[j2k->curtileno].packet[cstr_info->packno].start_pos = cio_tell(cio);
1418		}
1419		/* UniPG>> */
1420#ifdef USE_JPWL
1421		/* update markers struct */
1422		j2k_add_marker(j2k->cstr_info, J2K_MS_SOD, j2k->sod_start, 2);
1423#endif /* USE_JPWL */
1424		/* <<UniPG */
1425	}
1426	/* << INDEX */
1427	
1428	tcp = &cp->tcps[j2k->curtileno];
1429	for (layno = 0; layno < tcp->numlayers; layno++) {
1430		if (tcp->rates[layno]>(j2k->sod_start / (cp->th * cp->tw))) {
1431			tcp->rates[layno]-=(j2k->sod_start / (cp->th * cp->tw));
1432		} else if (tcp->rates[layno]) {
1433			tcp->rates[layno]=1;
1434		}
1435	}
1436	if(j2k->cur_tp_num == 0){
1437		tcd->tcd_image->tiles->packno = 0;
1438		if(cstr_info)
1439			cstr_info->packno = 0;
1440	}
1441	
1442	l = tcd_encode_tile(tcd, j2k->curtileno, cio_getbp(cio), cio_numbytesleft(cio) - 2, cstr_info);
1443	
1444	/* Writing Psot in SOT marker */
1445	totlen = cio_tell(cio) + l - j2k->sot_start;
1446	cio_seek(cio, j2k->sot_start + 6);
1447	cio_write(cio, totlen, 4);
1448	cio_seek(cio, j2k->sot_start + totlen);
1449	/* Writing Ttlm and Ptlm in TLM marker */
1450	if(cp->cinema){
1451		cio_seek(cio, j2k->tlm_start + 6 + (5*j2k->cur_tp_num));
1452		cio_write(cio, j2k->curtileno, 1);
1453		cio_write(cio, totlen, 4);
1454	}
1455	cio_seek(cio, j2k->sot_start + totlen);
1456}
1457
1458static void j2k_read_sod(opj_j2k_t *j2k) {
1459	int len, truncate = 0, i;
1460	unsigned char *data = NULL, *data_ptr = NULL;
1461
1462	opj_cio_t *cio = j2k->cio;
1463	int curtileno = j2k->curtileno;
1464
1465	/* Index */
1466	if (j2k->cstr_info) {
1467		j2k->cstr_info->tile[j2k->curtileno].tp[j2k->cur_tp_num].tp_end_header =
1468			cio_tell(cio) + j2k->pos_correction - 1;
1469		if (j2k->cur_tp_num == 0)
1470			j2k->cstr_info->tile[j2k->curtileno].end_header = cio_tell(cio) + j2k->pos_correction - 1;
1471		j2k->cstr_info->packno = 0;
1472	}
1473	
1474	len = int_min(j2k->eot - cio_getbp(cio), cio_numbytesleft(cio) + 1);
1475
1476	if (len == cio_numbytesleft(cio) + 1) {
1477		truncate = 1;		/* Case of a truncate codestream */
1478	}	
1479
1480	data = j2k->tile_data[curtileno];
1481	data = (unsigned char*) opj_realloc(data, (j2k->tile_len[curtileno] + len) * sizeof(unsigned char));
1482
1483	data_ptr = data + j2k->tile_len[curtileno];
1484	for (i = 0; i < len; i++) {
1485		data_ptr[i] = cio_read(cio, 1);
1486	}
1487
1488	j2k->tile_len[curtileno] += len;
1489	j2k->tile_data[curtileno] = data;
1490	
1491	if (!truncate) {
1492		j2k->state = J2K_STATE_TPHSOT;
1493	} else {
1494		j2k->state = J2K_STATE_NEOC;	/* RAJOUTE !! */
1495	}
1496	j2k->cur_tp_num++;
1497}
1498
1499static void j2k_write_rgn(opj_j2k_t *j2k, int compno, int tileno) {
1500	opj_cp_t *cp = j2k->cp;
1501	opj_tcp_t *tcp = &cp->tcps[tileno];
1502	opj_cio_t *cio = j2k->cio;
1503	int numcomps = j2k->image->numcomps;
1504	
1505	cio_write(cio, J2K_MS_RGN, 2);						/* RGN  */
1506	cio_write(cio, numcomps <= 256 ? 5 : 6, 2);			/* Lrgn */
1507	cio_write(cio, compno, numcomps <= 256 ? 1 : 2);	/* Crgn */
1508	cio_write(cio, 0, 1);								/* Srgn */
1509	cio_write(cio, tcp->tccps[compno].roishift, 1);		/* SPrgn */
1510}
1511
1512static void j2k_read_rgn(opj_j2k_t *j2k) {
1513	int len, compno, roisty;
1514
1515	opj_cp_t *cp = j2k->cp;
1516	opj_tcp_t *tcp = j2k->state == J2K_STATE_TPH ? &cp->tcps[j2k->curtileno] : j2k->default_tcp;
1517	opj_cio_t *cio = j2k->cio;
1518	int numcomps = j2k->image->numcomps;
1519
1520	len = cio_read(cio, 2);										/* Lrgn */
1521	compno = cio_read(cio, numcomps <= 256 ? 1 : 2);			/* Crgn */
1522	roisty = cio_read(cio, 1);									/* Srgn */
1523
1524#ifdef USE_JPWL
1525	if (j2k->cp->correct) {
1526		/* totlen is negative or larger than the bytes left!!! */
1527		if (compno >= numcomps) {
1528			opj_event_msg(j2k->cinfo, EVT_ERROR,
1529				"JPWL: bad component number in RGN (%d when there are only %d)\n",
1530				compno, numcomps);
1531			if (!JPWL_ASSUME || JPWL_ASSUME) {
1532				opj_event_msg(j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
1533				return;
1534			}
1535		}
1536	};
1537#endif /* USE_JPWL */
1538
1539	tcp->tccps[compno].roishift = cio_read(cio, 1);				/* SPrgn */
1540}
1541
1542static void j2k_write_eoc(opj_j2k_t *j2k) {
1543	opj_cio_t *cio = j2k->cio;
1544	/* opj_event_msg(j2k->cinfo, "%.8x: EOC\n", cio_tell(cio) + j2k->pos_correction); */
1545	cio_write(cio, J2K_MS_EOC, 2);
1546
1547/* UniPG>> */
1548#ifdef USE_JPWL
1549	/* update markers struct */
1550	j2k_add_marker(j2k->cstr_info, J2K_MS_EOC, cio_tell(cio) - 2, 2);
1551#endif /* USE_JPWL */
1552/* <<UniPG */
1553}
1554
1555static void j2k_read_eoc(opj_j2k_t *j2k) {
1556	int i, tileno;
1557	opj_bool success;
1558
1559	/* if packets should be decoded */
1560	if (j2k->cp->limit_decoding != DECODE_ALL_BUT_PACKETS) {
1561		opj_tcd_t *tcd = tcd_create(j2k->cinfo);
1562		tcd_malloc_decode(tcd, j2k->image, j2k->cp);
1563		for (i = 0; i < j2k->cp->tileno_size; i++) {
1564			tcd_malloc_decode_tile(tcd, j2k->image, j2k->cp, i, j2k->cstr_info);
1565			tileno = j2k->cp->tileno[i];
1566			success = tcd_decode_tile(tcd, j2k->tile_data[tileno], j2k->tile_len[tileno], tileno, j2k->cstr_info);
1567			opj_free(j2k->tile_data[tileno]);
1568			j2k->tile_data[tileno] = NULL;
1569			tcd_free_decode_tile(tcd, i);
1570			if (success == OPJ_FALSE) {
1571				j2k->state |= J2K_STATE_ERR;
1572				break;
1573			}
1574		}
1575		tcd_free_decode(tcd);
1576		tcd_destroy(tcd);
1577	}
1578	/* if packets should not be decoded  */
1579	else {
1580		for (i = 0; i < j2k->cp->tileno_size; i++) {
1581			tileno = j2k->cp->tileno[i];
1582			opj_free(j2k->tile_data[tileno]);
1583			j2k->tile_data[tileno] = NULL;
1584		}
1585	}	
1586	if (j2k->state & J2K_STATE_ERR)
1587		j2k->state = J2K_STATE_MT + J2K_STATE_ERR;
1588	else
1589		j2k->state = J2K_STATE_MT; 
1590}
1591
1592typedef struct opj_dec_mstabent {
1593	/** marker value */
1594	int id;
1595	/** value of the state when the marker can appear */
1596	int states;
1597	/** action linked to the marker */
1598	void (*handler) (opj_j2k_t *j2k);
1599} opj_dec_mstabent_t;
1600
1601opj_dec_mstabent_t j2k_dec_mstab[] = {
1602  {J2K_MS_SOC, J2K_STATE_MHSOC, j2k_read_soc},
1603  {J2K_MS_SOT, J2K_STATE_MH | J2K_STATE_TPHSOT, j2k_read_sot},
1604  {J2K_MS_SOD, J2K_STATE_TPH, j2k_read_sod},
1605  {J2K_MS_EOC, J2K_STATE_TPHSOT, j2k_read_eoc},
1606  {J2K_MS_SIZ, J2K_STATE_MHSIZ, j2k_read_siz},
1607  {J2K_MS_COD, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_cod},
1608  {J2K_MS_COC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_coc},
1609  {J2K_MS_RGN, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_rgn},
1610  {J2K_MS_QCD, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_qcd},
1611  {J2K_MS_QCC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_qcc},
1612  {J2K_MS_POC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_poc},
1613  {J2K_MS_TLM, J2K_STATE_MH, j2k_read_tlm},
1614  {J2K_MS_PLM, J2K_STATE_MH, j2k_read_plm},
1615  {J2K_MS_PLT, J2K_STATE_TPH, j2k_read_plt},
1616  {J2K_MS_PPM, J2K_STATE_MH, j2k_read_ppm},
1617  {J2K_MS_PPT, J2K_STATE_TPH, j2k_read_ppt},
1618  {J2K_MS_SOP, 0, 0},
1619  {J2K_MS_CRG, J2K_STATE_MH, j2k_read_crg},
1620  {J2K_MS_COM, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_com},
1621
1622#ifdef USE_JPWL
1623  {J2K_MS_EPC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_epc},
1624  {J2K_MS_EPB, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_epb},
1625  {J2K_MS_ESD, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_esd},
1626  {J2K_MS_RED, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_red},
1627#endif /* USE_JPWL */
1628#ifdef USE_JPSEC
1629  {J2K_MS_SEC, J2K_STATE_MH, j2k_read_sec},
1630  {J2K_MS_INSEC, 0, j2k_read_insec},
1631#endif /* USE_JPSEC */
1632
1633  {0, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_unk}
1634};
1635
1636static void j2k_read_unk(opj_j2k_t *j2k) {
1637	opj_event_msg(j2k->cinfo, EVT_WARNING, "Unknown marker\n");
1638
1639#ifdef USE_JPWL
1640	if (j2k->cp->correct) {
1641		int m = 0, id, i;
1642		int min_id = 0, min_dist = 17, cur_dist = 0, tmp_id;
1643		cio_seek(j2k->cio, cio_tell(j2k->cio) - 2);
1644		id = cio_read(j2k->cio, 2);
1645		opj_event_msg(j2k->cinfo, EVT_ERROR,
1646			"JPWL: really don't know this marker %x\n",
1647			id);
1648		if (!JPWL_ASSUME) {
1649			opj_event_msg(j2k->cinfo, EVT_ERROR,
1650				"- possible synch loss due to uncorrectable codestream errors => giving up\n");
1651			return;
1652		}
1653		/* OK, activate this at your own risk!!! */
1654		/* we look for the marker at the minimum hamming distance from this */
1655		while (j2k_dec_mstab[m].id) {
1656			
1657			/* 1's where they differ */
1658			tmp_id = j2k_dec_mstab[m].id ^ id;
1659
1660			/* compute the hamming distance between our id and the current */
1661			cur_dist = 0;
1662			for (i = 0; i < 16; i++) {
1663				if ((tmp_id >> i) & 0x0001) {
1664					cur_dist++;
1665				}
1666			}
1667
1668			/* if current distance is smaller, set the minimum */
1669			if (cur_dist < min_dist) {
1670				min_dist = cur_dist;
1671				min_id = j2k_dec_mstab[m].id;
1672			}
1673			
1674			/* jump to the next marker */
1675			m++;
1676		}
1677
1678		/* do we substitute the marker? */
1679		if (min_dist < JPWL_MAXIMUM_HAMMING) {
1680			opj_event_msg(j2k->cinfo, EVT_ERROR,
1681				"- marker %x is at distance %d from the read %x\n",
1682				min_id, min_dist, id);
1683			opj_event_msg(j2k->cinfo, EVT_ERROR,
1684				"- trying to substitute in place and crossing fingers!\n");
1685			cio_seek(j2k->cio, cio_tell(j2k->cio) - 2);
1686			cio_write(j2k->cio, min_id, 2);
1687
1688			/* rewind */
1689			cio_seek(j2k->cio, cio_tell(j2k->cio) - 2);
1690
1691		}
1692
1693	};
1694#endif /* USE_JPWL */
1695
1696}
1697
1698/**
1699Read the lookup table containing all the marker, status and action
1700@param id Marker value
1701*/
1702static opj_dec_mstabent_t *j2k_dec_mstab_lookup(int id) {
1703	opj_dec_msta

Large files files are truncated, but you can click here to view the full file