summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat (limited to 'media-libs')
-rw-r--r--media-libs/openjpeg/Manifest20
-rw-r--r--media-libs/openjpeg/files/OPJ_limit_tags_for_decode_UPDATED.patch3765
-rw-r--r--media-libs/openjpeg/files/digest-openjpeg-1.1.13
-rw-r--r--media-libs/openjpeg/files/openjpeg-1.1.1-gentoo.patch20
-rw-r--r--media-libs/openjpeg/openjpeg-1.1.1.ebuild38
5 files changed, 3846 insertions, 0 deletions
diff --git a/media-libs/openjpeg/Manifest b/media-libs/openjpeg/Manifest
new file mode 100644
index 0000000..af58122
--- /dev/null
+++ b/media-libs/openjpeg/Manifest
@@ -0,0 +1,20 @@
+AUX OPJ_limit_tags_for_decode_UPDATED.patch 121951 RMD160 876e9c90ee0a18b3f4f9077e9b7f1b7b6491b3a1 SHA1 d3ad1f7da7e318b1575123e7e7032ef22ea8e362 SHA256 a661e2a121e627522736416844dcba854e532beb7d72015217d0ea6b187c6786
+MD5 8233f9be998cb6ca326ec1aa1a5cf136 files/OPJ_limit_tags_for_decode_UPDATED.patch 121951
+RMD160 876e9c90ee0a18b3f4f9077e9b7f1b7b6491b3a1 files/OPJ_limit_tags_for_decode_UPDATED.patch 121951
+SHA256 a661e2a121e627522736416844dcba854e532beb7d72015217d0ea6b187c6786 files/OPJ_limit_tags_for_decode_UPDATED.patch 121951
+AUX openjpeg-1.1.1-gentoo.patch 595 RMD160 eea4058aae591a8a50a78c06788412ddda978195 SHA1 1139bd57dcea2ecadac6597691ccffa835f5e8de SHA256 1e2677bb0635d06fe8f3a37167bf0bd339fa59e20ee7364793e103631c2e989b
+MD5 8248d3ca7ba44598b52dcfe9626554a0 files/openjpeg-1.1.1-gentoo.patch 595
+RMD160 eea4058aae591a8a50a78c06788412ddda978195 files/openjpeg-1.1.1-gentoo.patch 595
+SHA256 1e2677bb0635d06fe8f3a37167bf0bd339fa59e20ee7364793e103631c2e989b files/openjpeg-1.1.1-gentoo.patch 595
+DIST openjpeg_v1_1_1.tar.gz 1406460 RMD160 08b2318441075a8704d6b9b0ac3d9d277c44d85e SHA1 1de6f9ccebe8844c96416daca521a20a84df23f5 SHA256 6076db131bfaa966a691d718044e5b5cdbec028436be3b7a3f146d1a0e3a7ec6
+EBUILD openjpeg-1.1.1.ebuild 876 RMD160 0839119e8c5b1be4817b283a3bee5b37fb629e4f SHA1 a2459ccbac53254b97878051a5745b2fa10b5b34 SHA256 faabd254957b6a7903c566e85e34daa9de861cd6668a5d01b05bab28abf2da40
+MD5 233ec2c814bae7bc17d2c08cce133ac3 openjpeg-1.1.1.ebuild 876
+RMD160 0839119e8c5b1be4817b283a3bee5b37fb629e4f openjpeg-1.1.1.ebuild 876
+SHA256 faabd254957b6a7903c566e85e34daa9de861cd6668a5d01b05bab28abf2da40 openjpeg-1.1.1.ebuild 876
+MISC .swp 4096 RMD160 654e0e4af7c51347966f4e45088874477c3d8a12 SHA1 30c6d8301b2a1b5c9f568ad859bbde7487ffad46 SHA256 fe70d97bd7e13f5c121b33a9e6fd682dbfaec845b07edb261c661ef8de411206
+MD5 327b5dbac44adeca74794fcf547e3122 .swp 4096
+RMD160 654e0e4af7c51347966f4e45088874477c3d8a12 .swp 4096
+SHA256 fe70d97bd7e13f5c121b33a9e6fd682dbfaec845b07edb261c661ef8de411206 .swp 4096
+MD5 fcdc3157bb74483f5e444836db0580b6 files/digest-openjpeg-1.1.1 250
+RMD160 f90411a7b6c5b72cc42ab7e7c217f554dad5d4f6 files/digest-openjpeg-1.1.1 250
+SHA256 d1a1fb2cc3299dae27b36b9ef21418fa213b29ee2709dcd67a2dd597498e4155 files/digest-openjpeg-1.1.1 250
diff --git a/media-libs/openjpeg/files/OPJ_limit_tags_for_decode_UPDATED.patch b/media-libs/openjpeg/files/OPJ_limit_tags_for_decode_UPDATED.patch
new file mode 100644
index 0000000..be5cd8b
--- /dev/null
+++ b/media-libs/openjpeg/files/OPJ_limit_tags_for_decode_UPDATED.patch
@@ -0,0 +1,3765 @@
+diff -Naur OpenJPEG/libopenjpeg/j2k.c OpenJPEG-patched/libopenjpeg/j2k.c
+--- OpenJPEG/libopenjpeg/j2k.c 2007-02-19 10:59:29.000000000 +0100
++++ OpenJPEG-patched/libopenjpeg/j2k.c 2007-03-17 14:18:44.000000000 +0100
+@@ -1342,37 +1342,39 @@
+ int states;
+ /** action linked to the marker */
+ void (*handler) (opj_j2k_t *j2k);
++ /** The enum value used to limit decode to specific tags. */
++ OPJ_LIMIT_TAGS limit_tag;
+ } opj_dec_mstabent_t;
+
+ opj_dec_mstabent_t j2k_dec_mstab[] = {
+- {J2K_MS_SOC, J2K_STATE_MHSOC, j2k_read_soc},
+- {J2K_MS_SOT, J2K_STATE_MH | J2K_STATE_TPHSOT, j2k_read_sot},
+- {J2K_MS_SOD, J2K_STATE_TPH, j2k_read_sod},
+- {J2K_MS_EOC, J2K_STATE_TPHSOT, j2k_read_eoc},
+- {J2K_MS_SIZ, J2K_STATE_MHSIZ, j2k_read_siz},
+- {J2K_MS_COD, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_cod},
+- {J2K_MS_COC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_coc},
+- {J2K_MS_RGN, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_rgn},
+- {J2K_MS_QCD, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_qcd},
+- {J2K_MS_QCC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_qcc},
+- {J2K_MS_POC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_poc},
+- {J2K_MS_TLM, J2K_STATE_MH, j2k_read_tlm},
+- {J2K_MS_PLM, J2K_STATE_MH, j2k_read_plm},
+- {J2K_MS_PLT, J2K_STATE_TPH, j2k_read_plt},
+- {J2K_MS_PPM, J2K_STATE_MH, j2k_read_ppm},
+- {J2K_MS_PPT, J2K_STATE_TPH, j2k_read_ppt},
+- {J2K_MS_SOP, 0, 0},
+- {J2K_MS_CRG, J2K_STATE_MH, j2k_read_crg},
+- {J2K_MS_COM, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_com},
++ {J2K_MS_SOC, J2K_STATE_MHSOC, j2k_read_soc, OPJ_TAG_SOC},
++ {J2K_MS_SOT, J2K_STATE_MH | J2K_STATE_TPHSOT, j2k_read_sot, OPJ_TAG_SOT},
++ {J2K_MS_SOD, J2K_STATE_TPH, j2k_read_sod, OPJ_TAG_SOD},
++ {J2K_MS_EOC, J2K_STATE_TPHSOT, j2k_read_eoc, OPJ_TAG_EOC},
++ {J2K_MS_SIZ, J2K_STATE_MHSIZ, j2k_read_siz, OPJ_TAG_SIZ},
++ {J2K_MS_COD, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_cod, OPJ_TAG_COD},
++ {J2K_MS_COC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_coc, OPJ_TAG_COC},
++ {J2K_MS_RGN, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_rgn, OPJ_TAG_RGN},
++ {J2K_MS_QCD, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_qcd, OPJ_TAG_QCD},
++ {J2K_MS_QCC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_qcc, OPJ_TAG_QCC},
++ {J2K_MS_POC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_poc, OPJ_TAG_POC},
++ {J2K_MS_TLM, J2K_STATE_MH, j2k_read_tlm, OPJ_TAG_TLM},
++ {J2K_MS_PLM, J2K_STATE_MH, j2k_read_plm, OPJ_TAG_PLM},
++ {J2K_MS_PLT, J2K_STATE_TPH, j2k_read_plt, OPJ_TAG_PLT},
++ {J2K_MS_PPM, J2K_STATE_MH, j2k_read_ppm, OPJ_TAG_PPM},
++ {J2K_MS_PPT, J2K_STATE_TPH, j2k_read_ppt, OPJ_TAG_PPT},
++ {J2K_MS_SOP, 0, 0, OPJ_TAG_SOP},
++ {J2K_MS_CRG, J2K_STATE_MH, j2k_read_crg, OPJ_TAG_CRG},
++ {J2K_MS_COM, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_com, OPJ_TAG_COM},
+ /* UniPG>> */
+ #ifdef USE_JPWL
+- {J2K_MS_EPC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_epc},
+- {J2K_MS_EPB, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_epb},
+- {J2K_MS_ESD, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_esd},
+- {J2K_MS_RED, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_red},
++ {J2K_MS_EPC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_epc, OPJ_TAG_EPC},
++ {J2K_MS_EPB, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_epb, OPJ_TAG_EPB},
++ {J2K_MS_ESD, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_esd, OPJ_TAG_ESD},
++ {J2K_MS_RED, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_red, OPJ_TAG_RED},
+ #endif /* USE_JPWL */
+ /* <<UniPG */
+- {0, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_unk}
++ {0, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_unk, -1}
+ };
+
+ static void j2k_read_unk(opj_j2k_t *j2k) {
+@@ -1689,6 +1691,12 @@
+ opj_event_msg(cinfo, EVT_ERROR, "%.8x: unexpected marker %x\n", cio_tell(cio) - 2, id);
+ return 0;
+ }
++ /* If a partial decode is requested, stop if the current tag
++ * isn't in the list.
++ */
++ if (j2k->cp->limit_tags && !(j2k->cp->limit_tags & e->limit_tag)) {
++ return image;
++ }
+ if (e->handler) {
+ (*e->handler)(j2k);
+ }
+diff -Naur OpenJPEG/libopenjpeg/j2k.c.orig OpenJPEG-patched/libopenjpeg/j2k.c.orig
+--- OpenJPEG/libopenjpeg/j2k.c.orig 1970-01-01 01:00:00.000000000 +0100
++++ OpenJPEG-patched/libopenjpeg/j2k.c.orig 2007-02-19 10:59:29.000000000 +0100
+@@ -0,0 +1,2392 @@
++/*
++ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
++ * Copyright (c) 2002-2007, Professor Benoit Macq
++ * Copyright (c) 2001-2003, David Janssens
++ * Copyright (c) 2002-2003, Yannick Verschueren
++ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
++ * Copyright (c) 2005, Herve Drolon, FreeImage Team
++ * All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions
++ * are met:
++ * 1. Redistributions of source code must retain the above copyright
++ * notice, this list of conditions and the following disclaimer.
++ * 2. Redistributions in binary form must reproduce the above copyright
++ * notice, this list of conditions and the following disclaimer in the
++ * documentation and/or other materials provided with the distribution.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
++ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
++ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
++ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
++ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
++ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
++ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
++ * POSSIBILITY OF SUCH DAMAGE.
++ */
++
++#include "opj_includes.h"
++
++/** @defgroup J2K J2K - JPEG-2000 codestream reader/writer */
++/*@{*/
++
++/** @name Local static functions */
++/*@{*/
++
++/**
++Write the SOC marker (Start Of Codestream)
++@param j2k J2K handle
++*/
++static void j2k_write_soc(opj_j2k_t *j2k);
++/**
++Read the SOC marker (Start of Codestream)
++@param j2k J2K handle
++*/
++static void j2k_read_soc(opj_j2k_t *j2k);
++/**
++Write the SIZ marker (image and tile size)
++@param j2k J2K handle
++*/
++static void j2k_write_siz(opj_j2k_t *j2k);
++/**
++Read the SIZ marker (image and tile size)
++@param j2k J2K handle
++*/
++static void j2k_read_siz(opj_j2k_t *j2k);
++/**
++Write the COM marker (comment)
++@param j2k J2K handle
++*/
++static void j2k_write_com(opj_j2k_t *j2k);
++/**
++Read the COM marker (comment)
++@param j2k J2K handle
++*/
++static void j2k_read_com(opj_j2k_t *j2k);
++/**
++Write the value concerning the specified component in the marker COD and COC
++@param j2k J2K handle
++@param compno Number of the component concerned by the information written
++*/
++static void j2k_write_cox(opj_j2k_t *j2k, int compno);
++/**
++Read the value concerning the specified component in the marker COD and COC
++@param j2k J2K handle
++@param compno Number of the component concerned by the information read
++*/
++static void j2k_read_cox(opj_j2k_t *j2k, int compno);
++/**
++Write the COD marker (coding style default)
++@param j2k J2K handle
++*/
++static void j2k_write_cod(opj_j2k_t *j2k);
++/**
++Read the COD marker (coding style default)
++@param j2k J2K handle
++*/
++static void j2k_read_cod(opj_j2k_t *j2k);
++/**
++Write the COC marker (coding style component)
++@param j2k J2K handle
++@param compno Number of the component concerned by the information written
++*/
++static void j2k_write_coc(opj_j2k_t *j2k, int compno);
++/**
++Read the COC marker (coding style component)
++@param j2k J2K handle
++*/
++static void j2k_read_coc(opj_j2k_t *j2k);
++/**
++Write the value concerning the specified component in the marker QCD and QCC
++@param j2k J2K handle
++@param compno Number of the component concerned by the information written
++*/
++static void j2k_write_qcx(opj_j2k_t *j2k, int compno);
++/**
++Read the value concerning the specified component in the marker QCD and QCC
++@param j2k J2K handle
++@param compno Number of the component concern by the information read
++@param len Length of the information in the QCX part of the marker QCD/QCC
++*/
++static void j2k_read_qcx(opj_j2k_t *j2k, int compno, int len);
++/**
++Write the QCD marker (quantization default)
++@param j2k J2K handle
++*/
++static void j2k_write_qcd(opj_j2k_t *j2k);
++/**
++Read the QCD marker (quantization default)
++@param j2k J2K handle
++*/
++static void j2k_read_qcd(opj_j2k_t *j2k);
++/**
++Write the QCC marker (quantization component)
++@param j2k J2K handle
++@param compno Number of the component concerned by the information written
++*/
++static void j2k_write_qcc(opj_j2k_t *j2k, int compno);
++/**
++Read the QCC marker (quantization component)
++@param j2k J2K handle
++*/
++static void j2k_read_qcc(opj_j2k_t *j2k);
++/**
++Write the POC marker (progression order change)
++@param j2k J2K handle
++*/
++static void j2k_write_poc(opj_j2k_t *j2k);
++/**
++Read the POC marker (progression order change)
++@param j2k J2K handle
++*/
++static void j2k_read_poc(opj_j2k_t *j2k);
++/**
++Read the CRG marker (component registration)
++@param j2k J2K handle
++*/
++static void j2k_read_crg(opj_j2k_t *j2k);
++/**
++Read the TLM marker (tile-part lengths)
++@param j2k J2K handle
++*/
++static void j2k_read_tlm(opj_j2k_t *j2k);
++/**
++Read the PLM marker (packet length, main header)
++@param j2k J2K handle
++*/
++static void j2k_read_plm(opj_j2k_t *j2k);
++/**
++Read the PLT marker (packet length, tile-part header)
++@param j2k J2K handle
++*/
++static void j2k_read_plt(opj_j2k_t *j2k);
++/**
++Read the PPM marker (packet packet headers, main header)
++@param j2k J2K handle
++*/
++static void j2k_read_ppm(opj_j2k_t *j2k);
++/**
++Read the PPT marker (packet packet headers, tile-part header)
++@param j2k J2K handle
++*/
++static void j2k_read_ppt(opj_j2k_t *j2k);
++/**
++Write the SOT marker (start of tile-part)
++@param j2k J2K handle
++*/
++static void j2k_write_sot(opj_j2k_t *j2k);
++/**
++Read the SOT marker (start of tile-part)
++@param j2k J2K handle
++*/
++static void j2k_read_sot(opj_j2k_t *j2k);
++/**
++Write the SOD marker (start of data)
++@param j2k J2K handle
++@param tile_coder Pointer to a TCD handle
++*/
++static void j2k_write_sod(opj_j2k_t *j2k, void *tile_coder);
++/**
++Read the SOD marker (start of data)
++@param j2k J2K handle
++*/
++static void j2k_read_sod(opj_j2k_t *j2k);
++/**
++Write the RGN marker (region-of-interest)
++@param j2k J2K handle
++@param compno Number of the component concerned by the information written
++@param tileno Number of the tile concerned by the information written
++*/
++static void j2k_write_rgn(opj_j2k_t *j2k, int compno, int tileno);
++/**
++Read the RGN marker (region-of-interest)
++@param j2k J2K handle
++*/
++static void j2k_read_rgn(opj_j2k_t *j2k);
++/**
++Write the EOC marker (end of codestream)
++@param j2k J2K handle
++*/
++static void j2k_write_eoc(opj_j2k_t *j2k);
++/**
++Read the EOC marker (end of codestream)
++@param j2k J2K handle
++*/
++static void j2k_read_eoc(opj_j2k_t *j2k);
++/**
++Read an unknown marker
++@param j2k J2K handle
++*/
++static void j2k_read_unk(opj_j2k_t *j2k);
++
++/*@}*/
++
++/*@}*/
++
++/* ----------------------------------------------------------------------- */
++
++void j2k_dump_image(FILE *fd, opj_image_t * img) {
++ int compno;
++ fprintf(fd, "image {\n");
++ fprintf(fd, " x0=%d, y0=%d, x1=%d, y1=%d\n", img->x0, img->y0, img->x1, img->y1);
++ fprintf(fd, " numcomps=%d\n", img->numcomps);
++ for (compno = 0; compno < img->numcomps; compno++) {
++ opj_image_comp_t *comp = &img->comps[compno];
++ fprintf(fd, " comp %d {\n", compno);
++ fprintf(fd, " dx=%d, dy=%d\n", comp->dx, comp->dy);
++ fprintf(fd, " prec=%d\n", comp->prec);
++ fprintf(fd, " sgnd=%d\n", comp->sgnd);
++ fprintf(fd, " }\n");
++ }
++ fprintf(fd, "}\n");
++}
++
++void j2k_dump_cp(FILE *fd, opj_image_t * img, opj_cp_t * cp) {
++ int tileno, compno, layno, bandno, resno, numbands;
++ fprintf(fd, "coding parameters {\n");
++ fprintf(fd, " tx0=%d, ty0=%d\n", cp->tx0, cp->ty0);
++ fprintf(fd, " tdx=%d, tdy=%d\n", cp->tdx, cp->tdy);
++ fprintf(fd, " tw=%d, th=%d\n", cp->tw, cp->th);
++ for (tileno = 0; tileno < cp->tw * cp->th; tileno++) {
++ opj_tcp_t *tcp = &cp->tcps[tileno];
++ fprintf(fd, " tile %d {\n", tileno);
++ fprintf(fd, " csty=%x\n", tcp->csty);
++ fprintf(fd, " prg=%d\n", tcp->prg);
++ fprintf(fd, " numlayers=%d\n", tcp->numlayers);
++ fprintf(fd, " mct=%d\n", tcp->mct);
++ fprintf(fd, " rates=");
++ for (layno = 0; layno < tcp->numlayers; layno++) {
++ fprintf(fd, "%.1f ", tcp->rates[layno]);
++ }
++ fprintf(fd, "\n");
++ for (compno = 0; compno < img->numcomps; compno++) {
++ opj_tccp_t *tccp = &tcp->tccps[compno];
++ fprintf(fd, " comp %d {\n", compno);
++ fprintf(fd, " csty=%x\n", tccp->csty);
++ fprintf(fd, " numresolutions=%d\n", tccp->numresolutions);
++ fprintf(fd, " cblkw=%d\n", tccp->cblkw);
++ fprintf(fd, " cblkh=%d\n", tccp->cblkh);
++ fprintf(fd, " cblksty=%x\n", tccp->cblksty);
++ fprintf(fd, " qmfbid=%d\n", tccp->qmfbid);
++ fprintf(fd, " qntsty=%d\n", tccp->qntsty);
++ fprintf(fd, " numgbits=%d\n", tccp->numgbits);
++ fprintf(fd, " roishift=%d\n", tccp->roishift);
++ fprintf(fd, " stepsizes=");
++ numbands = tccp->qntsty == J2K_CCP_QNTSTY_SIQNT ? 1 : tccp->numresolutions * 3 - 2;
++ for (bandno = 0; bandno < numbands; bandno++) {
++ fprintf(fd, "(%d,%d) ", tccp->stepsizes[bandno].mant,
++ tccp->stepsizes[bandno].expn);
++ }
++ fprintf(fd, "\n");
++
++ if (tccp->csty & J2K_CCP_CSTY_PRT) {
++ fprintf(fd, " prcw=");
++ for (resno = 0; resno < tccp->numresolutions; resno++) {
++ fprintf(fd, "%d ", tccp->prcw[resno]);
++ }
++ fprintf(fd, "\n");
++ fprintf(fd, " prch=");
++ for (resno = 0; resno < tccp->numresolutions; resno++) {
++ fprintf(fd, "%d ", tccp->prch[resno]);
++ }
++ fprintf(fd, "\n");
++ }
++ fprintf(fd, " }\n");
++ }
++ fprintf(fd, " }\n");
++ }
++ fprintf(fd, "}\n");
++}
++
++/* ----------------------------------------------------------------------- */
++
++static void j2k_write_soc(opj_j2k_t *j2k) {
++ opj_cio_t *cio = j2k->cio;
++ cio_write(cio, J2K_MS_SOC, 2);
++}
++
++static void j2k_read_soc(opj_j2k_t *j2k) {
++ j2k->state = J2K_STATE_MHSIZ;
++}
++
++static void j2k_write_siz(opj_j2k_t *j2k) {
++ int i;
++ int lenp, len;
++
++ opj_cio_t *cio = j2k->cio;
++ opj_image_t *image = j2k->image;
++ opj_cp_t *cp = j2k->cp;
++
++ cio_write(cio, J2K_MS_SIZ, 2); /* SIZ */
++ lenp = cio_tell(cio);
++ cio_skip(cio, 2);
++ cio_write(cio, 0, 2); /* Rsiz (capabilities) */
++ cio_write(cio, image->x1, 4); /* Xsiz */
++ cio_write(cio, image->y1, 4); /* Ysiz */
++ cio_write(cio, image->x0, 4); /* X0siz */
++ cio_write(cio, image->y0, 4); /* Y0siz */
++ cio_write(cio, cp->tdx, 4); /* XTsiz */
++ cio_write(cio, cp->tdy, 4); /* YTsiz */
++ cio_write(cio, cp->tx0, 4); /* XT0siz */
++ cio_write(cio, cp->ty0, 4); /* YT0siz */
++ cio_write(cio, image->numcomps, 2); /* Csiz */
++ for (i = 0; i < image->numcomps; i++) {
++ cio_write(cio, image->comps[i].prec - 1 + (image->comps[i].sgnd << 7), 1); /* Ssiz_i */
++ cio_write(cio, image->comps[i].dx, 1); /* XRsiz_i */
++ cio_write(cio, image->comps[i].dy, 1); /* YRsiz_i */
++ }
++ len = cio_tell(cio) - lenp;
++ cio_seek(cio, lenp);
++ cio_write(cio, len, 2); /* Lsiz */
++ cio_seek(cio, lenp + len);
++}
++
++static void j2k_read_siz(opj_j2k_t *j2k) {
++ int len, i;
++
++ opj_cio_t *cio = j2k->cio;
++ opj_image_t *image = j2k->image;
++ opj_cp_t *cp = j2k->cp;
++
++ len = cio_read(cio, 2); /* Lsiz */
++ cio_read(cio, 2); /* Rsiz (capabilities) */
++ image->x1 = cio_read(cio, 4); /* Xsiz */
++ image->y1 = cio_read(cio, 4); /* Ysiz */
++ image->x0 = cio_read(cio, 4); /* X0siz */
++ image->y0 = cio_read(cio, 4); /* Y0siz */
++ cp->tdx = cio_read(cio, 4); /* XTsiz */
++ cp->tdy = cio_read(cio, 4); /* YTsiz */
++ cp->tx0 = cio_read(cio, 4); /* XT0siz */
++ cp->ty0 = cio_read(cio, 4); /* YT0siz */
++
++ image->numcomps = cio_read(cio, 2); /* Csiz */
++/* UniPG>> */
++#ifdef USE_JPWL
++ if (j2k->cp->correct) {
++ /* if JPWL is on, we check whether TX errors have damaged
++ too much the SIZ parameters */
++ if (!(image->x1 * image->y1)) {
++ opj_event_msg(j2k->cinfo, EVT_ERROR,
++ "JPWL: bad image size (%d x %d)\n",
++ image->x1, image->y1);
++ if (!JPWL_ASSUME || JPWL_ASSUME)
++ exit(1);
++ }
++ if (image->numcomps != ((len - 38) / 3)) {
++ opj_event_msg(j2k->cinfo, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
++ "JPWL: Csiz is %d => space in SIZ only for %d comps.!!!\n",
++ image->numcomps, ((len - 38) / 3));
++ if (!JPWL_ASSUME)
++ exit(1);
++ /* we try to correct */
++ opj_event_msg(j2k->cinfo, EVT_WARNING, "- trying to adjust this\n");
++ if (image->numcomps < ((len - 38) / 3)) {
++ len = 38 + 3 * image->numcomps;
++ opj_event_msg(j2k->cinfo, EVT_WARNING, "- setting Lsiz to %d => HYPOTHESIS!!!\n",
++ len);
++ } else {
++ image->numcomps = ((len - 38) / 3);
++ opj_event_msg(j2k->cinfo, EVT_WARNING, "- setting Csiz to %d => HYPOTHESIS!!!\n",
++ image->numcomps);
++ }
++ }
++
++ /* update components number in the jpwl_exp_comps filed */
++ cp->exp_comps = image->numcomps;
++ }
++#endif /* USE_JPWL */
++/* <<UniPG */
++ image->comps = (opj_image_comp_t *) opj_malloc(image->numcomps * sizeof(opj_image_comp_t));
++ for (i = 0; i < image->numcomps; i++) {
++ int tmp, w, h;
++ tmp = cio_read(cio, 1); /* Ssiz_i */
++ image->comps[i].prec = (tmp & 0x7f) + 1;
++ image->comps[i].sgnd = tmp >> 7;
++ image->comps[i].dx = cio_read(cio, 1); /* XRsiz_i */
++ image->comps[i].dy = cio_read(cio, 1); /* YRsiz_i */
++
++/* UniPG>> */
++#ifdef USE_JPWL
++ if (j2k->cp->correct) {
++ /* if JPWL is on, we check whether TX errors have damaged
++ too much the SIZ parameters, again */
++ if (!(image->comps[i].dx * image->comps[i].dy)) {
++ opj_event_msg(j2k->cinfo, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
++ "JPWL: bad XRsiz_%d/YRsiz_%d (%d x %d)\n",
++ i, i, image->comps[i].dx, image->comps[i].dy);
++ if (!JPWL_ASSUME)
++ exit(1);
++ /* we try to correct */
++ opj_event_msg(j2k->cinfo, EVT_WARNING, "- trying to adjust them\n");
++ if (!image->comps[i].dx) {
++ image->comps[i].dx = 1;
++ opj_event_msg(j2k->cinfo, EVT_WARNING, "- setting XRsiz_%d to %d => HYPOTHESIS!!!\n",
++ i, image->comps[i].dx);
++ }
++ if (!image->comps[i].dy) {
++ image->comps[i].dy = 1;
++ opj_event_msg(j2k->cinfo, EVT_WARNING, "- setting YRsiz_%d to %d => HYPOTHESIS!!!\n",
++ i, image->comps[i].dy);
++ }
++ }
++
++ }
++#endif /* USE_JPWL */
++/* <<UniPG */
++
++
++ /* TODO: unused ? */
++ w = int_ceildiv(image->x1 - image->x0, image->comps[i].dx);
++ h = int_ceildiv(image->y1 - image->y0, image->comps[i].dy);
++
++ image->comps[i].resno_decoded = 0; /* number of resolution decoded */
++ image->comps[i].factor = 0; /* reducing factor per component */
++ }
++
++ cp->tw = int_ceildiv(image->x1 - cp->tx0, cp->tdx);
++ cp->th = int_ceildiv(image->y1 - cp->ty0, cp->tdy);
++/* UniPG>> */
++#ifdef USE_JPWL
++ if (j2k->cp->correct) {
++ /* if JPWL is on, we check whether TX errors have damaged
++ too much the SIZ parameters */
++ if ((cp->tw < 1) || (cp->th < 1) || (cp->tw > cp->max_tiles) || (cp->th > cp->max_tiles)) {
++ opj_event_msg(j2k->cinfo, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
++ "JPWL: bad number of tiles (%d x %d)\n",
++ cp->tw, cp->th);
++ if (!JPWL_ASSUME)
++ exit(1);
++ /* we try to correct */
++ opj_event_msg(j2k->cinfo, EVT_WARNING, "- trying to adjust them\n");
++ if (cp->tw < 1) {
++ cp->tw= 1;
++ opj_event_msg(j2k->cinfo, EVT_WARNING, "- setting %d tiles in x => HYPOTHESIS!!!\n",
++ cp->tw);
++ }
++ if (cp->tw > cp->max_tiles) {
++ opj_event_msg(j2k->cinfo, EVT_WARNING, "- too large x, increase expectance of %d\n",
++ cp->max_tiles);
++ cp->tw= 1;
++ opj_event_msg(j2k->cinfo, EVT_WARNING, "- setting %d tiles in x => HYPOTHESIS!!!\n",
++ cp->tw);
++ }
++ if (cp->th < 1) {
++ cp->th= 1;
++ opj_event_msg(j2k->cinfo, EVT_WARNING, "- setting %d tiles in y => HYPOTHESIS!!!\n",
++ cp->th);
++ }
++ if (cp->th > cp->max_tiles) {
++ opj_event_msg(j2k->cinfo, EVT_WARNING, "- too large y, increase expectance of %d to continue\n",
++ cp->max_tiles);
++ cp->th= 1;
++ opj_event_msg(j2k->cinfo, EVT_WARNING, "- setting %d tiles in y => HYPOTHESIS!!!\n",
++ cp->th);
++ }
++ }
++ }
++#endif /* USE_JPWL */
++/* <<UniPG */
++ cp->tcps = (opj_tcp_t *) opj_malloc(cp->tw * cp->th * sizeof(opj_tcp_t));
++ cp->tileno = (int *) opj_malloc(cp->tw * cp->th * sizeof(int));
++ cp->tileno_size = 0;
++
++/* UniPG>> */
++#ifdef USE_JPWL
++ if (j2k->cp->correct) {
++ if (!cp->tcps) {
++ opj_event_msg(j2k->cinfo, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
++ "JPWL: could not alloc tcps field of cp\n");
++ if (!JPWL_ASSUME || JPWL_ASSUME)
++ exit(1);
++ }
++ }
++#endif /* USE_JPWL */
++/* <<UniPG */
++ for (i = 0; i < cp->tw * cp->th; i++) {
++ cp->tcps[i].POC = 0;
++ cp->tcps[i].numpocs = 0;
++ cp->tcps[i].first = 1;
++ }
++
++ /* Initialization for PPM marker */
++ cp->ppm = 0;
++ cp->ppm_data = NULL;
++ cp->ppm_data_first = NULL;
++ cp->ppm_previous = 0;
++ cp->ppm_store = 0;
++
++ j2k->default_tcp->tccps = (opj_tccp_t *) opj_malloc(sizeof(opj_tccp_t) * image->numcomps);
++ for (i = 0; i < cp->tw * cp->th; i++) {
++ cp->tcps[i].tccps = (opj_tccp_t *) opj_malloc(sizeof(opj_tccp_t) * image->numcomps);
++ }
++ j2k->tile_data = (unsigned char **) opj_malloc(cp->tw * cp->th * sizeof(unsigned char *));
++ j2k->tile_len = (int *) opj_malloc(cp->tw * cp->th * sizeof(int));
++ j2k->state = J2K_STATE_MH;
++}
++
++static void j2k_write_com(opj_j2k_t *j2k) {
++ unsigned int i;
++ int lenp, len;
++
++ if(j2k->cp->comment) {
++ opj_cio_t *cio = j2k->cio;
++ char *comment = j2k->cp->comment;
++
++ cio_write(cio, J2K_MS_COM, 2);
++ lenp = cio_tell(cio);
++ cio_skip(cio, 2);
++ cio_write(cio, 0, 2);
++ for (i = 0; i < strlen(comment); i++) {
++ cio_write(cio, comment[i], 1);
++ }
++ len = cio_tell(cio) - lenp;
++ cio_seek(cio, lenp);
++ cio_write(cio, len, 2);
++ cio_seek(cio, lenp + len);
++ }
++}
++
++static void j2k_read_com(opj_j2k_t *j2k) {
++ int len;
++
++ opj_cio_t *cio = j2k->cio;
++
++ len = cio_read(cio, 2);
++ cio_skip(cio, len - 2);
++}
++
++static void j2k_write_cox(opj_j2k_t *j2k, int compno) {
++ int i;
++
++ opj_cp_t *cp = j2k->cp;
++ opj_tcp_t *tcp = &cp->tcps[j2k->curtileno];
++ opj_tccp_t *tccp = &tcp->tccps[compno];
++ opj_cio_t *cio = j2k->cio;
++
++ cio_write(cio, tccp->numresolutions - 1, 1); /* SPcox (D) */
++ cio_write(cio, tccp->cblkw - 2, 1); /* SPcox (E) */
++ cio_write(cio, tccp->cblkh - 2, 1); /* SPcox (F) */
++ cio_write(cio, tccp->cblksty, 1); /* SPcox (G) */
++ cio_write(cio, tccp->qmfbid, 1); /* SPcox (H) */
++
++ if (tccp->csty & J2K_CCP_CSTY_PRT) {
++ for (i = 0; i < tccp->numresolutions; i++) {
++ cio_write(cio, tccp->prcw[i] + (tccp->prch[i] << 4), 1); /* SPcox (I_i) */
++ }
++ }
++}
++
++static void j2k_read_cox(opj_j2k_t *j2k, int compno) {
++ int i;
++
++ opj_cp_t *cp = j2k->cp;
++ opj_tcp_t *tcp = j2k->state == J2K_STATE_TPH ? &cp->tcps[j2k->curtileno] : j2k->default_tcp;
++ opj_tccp_t *tccp = &tcp->tccps[compno];
++ opj_cio_t *cio = j2k->cio;
++
++ tccp->numresolutions = cio_read(cio, 1) + 1; /* SPcox (D) */
++
++ /* check the reduce value */
++ cp->reduce = int_min((tccp->numresolutions)-1, cp->reduce);
++ tccp->cblkw = cio_read(cio, 1) + 2; /* SPcox (E) */
++ tccp->cblkh = cio_read(cio, 1) + 2; /* SPcox (F) */
++ tccp->cblksty = cio_read(cio, 1); /* SPcox (G) */
++ tccp->qmfbid = cio_read(cio, 1); /* SPcox (H) */
++ if (tccp->csty & J2K_CP_CSTY_PRT) {
++ for (i = 0; i < tccp->numresolutions; i++) {
++ int tmp = cio_read(cio, 1); /* SPcox (I_i) */
++ tccp->prcw[i] = tmp & 0xf;
++ tccp->prch[i] = tmp >> 4;
++ }
++ }
++}
++
++static void j2k_write_cod(opj_j2k_t *j2k) {
++ opj_cp_t *cp = NULL;
++ opj_tcp_t *tcp = NULL;
++ int lenp, len;
++
++ opj_cio_t *cio = j2k->cio;
++
++ cio_write(cio, J2K_MS_COD, 2); /* COD */
++
++ lenp = cio_tell(cio);
++ cio_skip(cio, 2);
++
++ cp = j2k->cp;
++ tcp = &cp->tcps[j2k->curtileno];
++
++ cio_write(cio, tcp->csty, 1); /* Scod */
++ cio_write(cio, tcp->prg, 1); /* SGcod (A) */
++ cio_write(cio, tcp->numlayers, 2); /* SGcod (B) */
++ cio_write(cio, tcp->mct, 1); /* SGcod (C) */
++
++ j2k_write_cox(j2k, 0);
++ len = cio_tell(cio) - lenp;
++ cio_seek(cio, lenp);
++ cio_write(cio, len, 2); /* Lcod */
++ cio_seek(cio, lenp + len);
++}
++
++static void j2k_read_cod(opj_j2k_t *j2k) {
++ int len, i, pos;
++
++ opj_cio_t *cio = j2k->cio;
++ opj_cp_t *cp = j2k->cp;
++ opj_tcp_t *tcp = j2k->state == J2K_STATE_TPH ? &cp->tcps[j2k->curtileno] : j2k->default_tcp;
++ opj_image_t *image = j2k->image;
++
++ len = cio_read(cio, 2); /* Lcod */
++ tcp->csty = cio_read(cio, 1); /* Scod */
++ tcp->prg = (OPJ_PROG_ORDER)cio_read(cio, 1); /* SGcod (A) */
++ tcp->numlayers = cio_read(cio, 2); /* SGcod (B) */
++ tcp->mct = cio_read(cio, 1); /* SGcod (C) */
++
++ pos = cio_tell(cio);
++ for (i = 0; i < image->numcomps; i++) {
++ tcp->tccps[i].csty = tcp->csty & J2K_CP_CSTY_PRT;
++ cio_seek(cio, pos);
++ j2k_read_cox(j2k, i);
++ }
++}
++
++static void j2k_write_coc(opj_j2k_t *j2k, int compno) {
++ int lenp, len;
++
++ opj_cp_t *cp = j2k->cp;
++ opj_tcp_t *tcp = &cp->tcps[j2k->curtileno];
++ opj_image_t *image = j2k->image;
++ opj_cio_t *cio = j2k->cio;
++
++ cio_write(cio, J2K_MS_COC, 2); /* COC */
++ lenp = cio_tell(cio);
++ cio_skip(cio, 2);
++ cio_write(cio, compno, image->numcomps <= 256 ? 1 : 2); /* Ccoc */
++ cio_write(cio, tcp->tccps[compno].csty, 1); /* Scoc */
++ j2k_write_cox(j2k, compno);
++ len = cio_tell(cio) - lenp;
++ cio_seek(cio, lenp);
++ cio_write(cio, len, 2); /* Lcoc */
++ cio_seek(cio, lenp + len);
++}
++
++static void j2k_read_coc(opj_j2k_t *j2k) {
++ int len, compno;
++
++ opj_cp_t *cp = j2k->cp;
++ opj_tcp_t *tcp = j2k->state == J2K_STATE_TPH ? &cp->tcps[j2k->curtileno] : j2k->default_tcp;
++ opj_image_t *image = j2k->image;
++ opj_cio_t *cio = j2k->cio;
++
++ len = cio_read(cio, 2); /* Lcoc */
++ compno = cio_read(cio, image->numcomps <= 256 ? 1 : 2); /* Ccoc */
++ tcp->tccps[compno].csty = cio_read(cio, 1); /* Scoc */
++ j2k_read_cox(j2k, compno);
++}
++
++static void j2k_write_qcx(opj_j2k_t *j2k, int compno) {
++ int bandno, numbands;
++ int expn, mant;
++
++ opj_cp_t *cp = j2k->cp;
++ opj_tcp_t *tcp = &cp->tcps[j2k->curtileno];
++ opj_tccp_t *tccp = &tcp->tccps[compno];
++ opj_cio_t *cio = j2k->cio;
++
++ cio_write(cio, tccp->qntsty + (tccp->numgbits << 5), 1); /* Sqcx */
++ numbands = tccp->qntsty == J2K_CCP_QNTSTY_SIQNT ? 1 : tccp->numresolutions * 3 - 2;
++
++ for (bandno = 0; bandno < numbands; bandno++) {
++ expn = tccp->stepsizes[bandno].expn;
++ mant = tccp->stepsizes[bandno].mant;
++
++ if (tccp->qntsty == J2K_CCP_QNTSTY_NOQNT) {
++ cio_write(cio, expn << 3, 1); /* SPqcx_i */
++ } else {
++ cio_write(cio, (expn << 11) + mant, 2); /* SPqcx_i */
++ }
++ }
++}
++
++static void j2k_read_qcx(opj_j2k_t *j2k, int compno, int len) {
++ int tmp;
++ int bandno, numbands;
++
++ opj_cp_t *cp = j2k->cp;
++ opj_tcp_t *tcp = j2k->state == J2K_STATE_TPH ? &cp->tcps[j2k->curtileno] : j2k->default_tcp;
++ opj_tccp_t *tccp = &tcp->tccps[compno];
++ opj_cio_t *cio = j2k->cio;
++
++ tmp = cio_read(cio, 1); /* Sqcx */
++ tccp->qntsty = tmp & 0x1f;
++ tccp->numgbits = tmp >> 5;
++ numbands = (tccp->qntsty == J2K_CCP_QNTSTY_SIQNT) ?
++ 1 : ((tccp->qntsty == J2K_CCP_QNTSTY_NOQNT) ? len - 1 : (len - 1) / 2);
++/* UniPG>> */
++#ifdef USE_JPWL
++ if (j2k->cp->correct) {
++
++ /* if JPWL is on, we check whether there are too many subbands */
++ if ((numbands < 0) || (numbands >= J2K_MAXBANDS)) {
++ opj_event_msg(j2k->cinfo, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
++ "JPWL: bad number of subbands in Sqcx (%d)\n",
++ numbands);
++ if (!JPWL_ASSUME)
++ exit(1);
++ /* we try to correct */
++ opj_event_msg(j2k->cinfo, EVT_WARNING, "- trying to adjust them\n");
++ numbands = 1;
++ opj_event_msg(j2k->cinfo, EVT_WARNING, "- setting number of bands to %d => HYPOTHESIS!!!\n",
++ numbands);
++ };
++
++ };
++#endif /* USE_JPWL */
++/* <<UniPG */
++ for (bandno = 0; bandno < numbands; bandno++) {
++ int expn, mant;
++ if (tccp->qntsty == J2K_CCP_QNTSTY_NOQNT) {
++ expn = cio_read(cio, 1) >> 3; /* SPqcx_i */
++ mant = 0;
++ } else {
++ tmp = cio_read(cio, 2); /* SPqcx_i */
++ expn = tmp >> 11;
++ mant = tmp & 0x7ff;
++ }
++ tccp->stepsizes[bandno].expn = expn;
++ tccp->stepsizes[bandno].mant = mant;
++ }
++
++ /* Add Antonin : if scalar_derived -> compute other stepsizes */
++ if (tccp->qntsty == J2K_CCP_QNTSTY_SIQNT) {
++ for (bandno = 1; bandno < J2K_MAXBANDS; bandno++) {
++ tccp->stepsizes[bandno].expn =
++ ((tccp->stepsizes[0].expn) - ((bandno - 1) / 3) > 0) ?
++ (tccp->stepsizes[0].expn) - ((bandno - 1) / 3) : 0;
++ tccp->stepsizes[bandno].mant = tccp->stepsizes[0].mant;
++ }
++ }
++ /* ddA */
++}
++
++static void j2k_write_qcd(opj_j2k_t *j2k) {
++ int lenp, len;
++
++ opj_cio_t *cio = j2k->cio;
++
++ cio_write(cio, J2K_MS_QCD, 2); /* QCD */
++ lenp = cio_tell(cio);
++ cio_skip(cio, 2);
++ j2k_write_qcx(j2k, 0);
++ len = cio_tell(cio) - lenp;
++ cio_seek(cio, lenp);
++ cio_write(cio, len, 2); /* Lqcd */
++ cio_seek(cio, lenp + len);
++}
++
++static void j2k_read_qcd(opj_j2k_t *j2k) {
++ int len, i, pos;
++
++ opj_cio_t *cio = j2k->cio;
++ opj_image_t *image = j2k->image;
++
++ len = cio_read(cio, 2); /* Lqcd */
++ pos = cio_tell(cio);
++ for (i = 0; i < image->numcomps; i++) {
++ cio_seek(cio, pos);
++ j2k_read_qcx(j2k, i, len - 2);
++ }
++}
++
++static void j2k_write_qcc(opj_j2k_t *j2k, int compno) {
++ int lenp, len;
++
++ opj_cio_t *cio = j2k->cio;
++
++ cio_write(cio, J2K_MS_QCC, 2); /* QCC */
++ lenp = cio_tell(cio);
++ cio_skip(cio, 2);
++ cio_write(cio, compno, j2k->image->numcomps <= 256 ? 1 : 2); /* Cqcc */
++ j2k_write_qcx(j2k, compno);
++ len = cio_tell(cio) - lenp;
++ cio_seek(cio, lenp);
++ cio_write(cio, len, 2); /* Lqcc */
++ cio_seek(cio, lenp + len);
++}
++
++static void j2k_read_qcc(opj_j2k_t *j2k) {
++ int len, compno;
++ int numcomp = j2k->image->numcomps;
++ opj_cio_t *cio = j2k->cio;
++
++ len = cio_read(cio, 2); /* Lqcc */
++ compno = cio_read(cio, numcomp <= 256 ? 1 : 2); /* Cqcc */
++/* UniPG>> */
++#ifdef USE_JPWL
++ if (j2k->cp->correct) {
++
++ static int backup_compno = 0;
++
++ /* compno is negative or larger than the number of components!!! */
++ if ((compno < 0) || (compno >= numcomp)) {
++ opj_event_msg(j2k->cinfo, EVT_ERROR,
++ "JPWL: bad component number in QCC (%d out of a maximum of %d)\n",
++ compno, numcomp);
++ if (!JPWL_ASSUME)
++ exit(1);
++ /* we try to correct */
++ opj_event_msg(j2k->cinfo, EVT_WARNING, "- trying to adjust this\n");
++ compno = backup_compno % numcomp;
++ opj_event_msg(j2k->cinfo, EVT_WARNING, "- setting component number to %d\n",
++ compno);
++ }
++
++ /* keep your private count of tiles */
++ backup_compno++;
++ };
++#endif /* USE_JPWL */
++/* <<UniPG */
++ j2k_read_qcx(j2k, compno, len - 2 - (numcomp <= 256 ? 1 : 2));
++}
++
++static void j2k_write_poc(opj_j2k_t *j2k) {
++ int len, numpchgs, i;
++
++ int numcomps = j2k->image->numcomps;
++
++ opj_cp_t *cp = j2k->cp;
++ opj_tcp_t *tcp = &cp->tcps[j2k->curtileno];
++ opj_tccp_t *tccp = &tcp->tccps[0];
++ opj_cio_t *cio = j2k->cio;
++
++ numpchgs = tcp->numpocs;
++ cio_write(cio, J2K_MS_POC, 2); /* POC */
++ len = 2 + (5 + 2 * (numcomps <= 256 ? 1 : 2)) * numpchgs;
++ cio_write(cio, len, 2); /* Lpoc */
++ for (i = 0; i < numpchgs; i++) {
++ opj_poc_t *poc = &tcp->pocs[i];
++ cio_write(cio, poc->resno0, 1); /* RSpoc_i */
++ cio_write(cio, poc->compno0, (numcomps <= 256 ? 1 : 2)); /* CSpoc_i */
++ cio_write(cio, poc->layno1, 2); /* LYEpoc_i */
++ poc->layno1 = int_min(poc->layno1, tcp->numlayers);
++ cio_write(cio, poc->resno1, 1); /* REpoc_i */
++ poc->resno1 = int_min(poc->resno1, tccp->numresolutions);
++ cio_write(cio, poc->compno1, (numcomps <= 256 ? 1 : 2)); /* CEpoc_i */
++ poc->compno1 = int_min(poc->compno1, numcomps);
++ cio_write(cio, poc->prg, 1); /* Ppoc_i */
++ }
++}
++
++static void j2k_read_poc(opj_j2k_t *j2k) {
++ int len, numpchgs, i, old_poc;
++
++ int numcomps = j2k->image->numcomps;
++
++ opj_cp_t *cp = j2k->cp;
++ opj_tcp_t *tcp = j2k->state == J2K_STATE_TPH ? &cp->tcps[j2k->curtileno] : j2k->default_tcp;
++ opj_tccp_t *tccp = &tcp->tccps[0];
++ opj_cio_t *cio = j2k->cio;
++
++ old_poc = tcp->POC ? tcp->numpocs + 1 : 0;
++ tcp->POC = 1;
++ len = cio_read(cio, 2); /* Lpoc */
++ numpchgs = (len - 2) / (5 + 2 * (numcomps <= 256 ? 1 : 2));
++
++ for (i = old_poc; i < numpchgs + old_poc; i++) {
++ opj_poc_t *poc;
++ poc = &tcp->pocs[i];
++ poc->resno0 = cio_read(cio, 1); /* RSpoc_i */
++ poc->compno0 = cio_read(cio, numcomps <= 256 ? 1 : 2); /* CSpoc_i */
++ poc->layno1 = int_min(cio_read(cio, 2), (unsigned int) tcp->numlayers); /* LYEpoc_i */
++ poc->resno1 = int_min(cio_read(cio, 1), (unsigned int) tccp->numresolutions); /* REpoc_i */
++ poc->compno1 = int_min(
++ cio_read(cio, numcomps <= 256 ? 1 : 2), (unsigned int) numcomps); /* CEpoc_i */
++ poc->prg = (OPJ_PROG_ORDER)cio_read(cio, 1); /* Ppoc_i */
++ }
++
++ tcp->numpocs = numpchgs + old_poc - 1;
++}
++
++static void j2k_read_crg(opj_j2k_t *j2k) {
++ int len, i, Xcrg_i, Ycrg_i;
++
++ opj_cio_t *cio = j2k->cio;
++ int numcomps = j2k->image->numcomps;
++
++ len = cio_read(cio, 2); /* Lcrg */
++ for (i = 0; i < numcomps; i++) {
++ Xcrg_i = cio_read(cio, 2); /* Xcrg_i */
++ Ycrg_i = cio_read(cio, 2); /* Ycrg_i */
++ }
++}
++
++static void j2k_read_tlm(opj_j2k_t *j2k) {
++ int len, Ztlm, Stlm, ST, SP, tile_tlm, i;
++ long int Ttlm_i, Ptlm_i;
++
++ opj_cio_t *cio = j2k->cio;
++
++ len = cio_read(cio, 2); /* Ltlm */
++ Ztlm = cio_read(cio, 1); /* Ztlm */
++ Stlm = cio_read(cio, 1); /* Stlm */
++ ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02);
++ SP = (Stlm >> 6) & 0x01;
++ tile_tlm = (len - 4) / ((SP + 1) * 2 + ST);
++ for (i = 0; i < tile_tlm; i++) {
++ Ttlm_i = cio_read(cio, ST); /* Ttlm_i */
++ Ptlm_i = cio_read(cio, SP ? 4 : 2); /* Ptlm_i */
++ }
++}
++
++static void j2k_read_plm(opj_j2k_t *j2k) {
++ int len, i, Zplm, Nplm, add, packet_len = 0;
++
++ opj_cio_t *cio = j2k->cio;
++
++ len = cio_read(cio, 2); /* Lplm */
++ Zplm = cio_read(cio, 1); /* Zplm */
++ len -= 3;
++ while (len > 0) {
++ Nplm = cio_read(cio, 4); /* Nplm */
++ len -= 4;
++ for (i = Nplm; i > 0; i--) {
++ add = cio_read(cio, 1);
++ len--;
++ packet_len = (packet_len << 7) + add; /* Iplm_ij */
++ if ((add & 0x80) == 0) {
++ /* New packet */
++ packet_len = 0;
++ }
++ if (len <= 0)
++ break;
++ }
++ }
++}
++
++static void j2k_read_plt(opj_j2k_t *j2k) {
++ int len, i, Zplt, packet_len = 0, add;
++
++ opj_cio_t *cio = j2k->cio;
++
++ len = cio_read(cio, 2); /* Lplt */
++ Zplt = cio_read(cio, 1); /* Zplt */
++ for (i = len - 3; i > 0; i--) {
++ add = cio_read(cio, 1);
++ packet_len = (packet_len << 7) + add; /* Iplt_i */
++ if ((add & 0x80) == 0) {
++ /* New packet */
++ packet_len = 0;
++ }
++ }
++}
++
++static void j2k_read_ppm(opj_j2k_t *j2k) {
++ int len, Z_ppm, i, j;
++ int N_ppm;
++
++ opj_cp_t *cp = j2k->cp;
++ opj_cio_t *cio = j2k->cio;
++
++ len = cio_read(cio, 2);
++ cp->ppm = 1;
++
++ Z_ppm = cio_read(cio, 1); /* Z_ppm */
++ len -= 3;
++ while (len > 0) {
++ if (cp->ppm_previous == 0) {
++ N_ppm = cio_read(cio, 4); /* N_ppm */
++ len -= 4;
++ } else {
++ N_ppm = cp->ppm_previous;
++ }
++ j = cp->ppm_store;
++ if (Z_ppm == 0) { /* First PPM marker */
++ cp->ppm_data = (unsigned char *) opj_malloc(N_ppm * sizeof(unsigned char));
++ cp->ppm_data_first = cp->ppm_data;
++ cp->ppm_len = N_ppm;
++ } else { /* NON-first PPM marker */
++ cp->ppm_data = (unsigned char *) opj_realloc(cp->ppm_data, (N_ppm + cp->ppm_store) * sizeof(unsigned char));
++/* UniPG>> */
++#ifdef USE_JPWL
++ /* this memory allocation check could be done even in non-JPWL cases */
++ if (cp->correct) {
++ if (!cp->ppm_data) {
++ opj_event_msg(j2k->cinfo, EVT_ERROR,
++ "JPWL: failed memory allocation during PPM marker parsing (pos. %x)\n",
++ cio_tell(cio));
++ if (!JPWL_ASSUME || JPWL_ASSUME)
++ exit(1);
++ }
++ }
++#endif
++/* <<UniPG */
++ cp->ppm_data_first = cp->ppm_data;
++ cp->ppm_len = N_ppm + cp->ppm_store;
++ }
++ for (i = N_ppm; i > 0; i--) { /* Read packet header */
++ cp->ppm_data[j] = cio_read(cio, 1);
++ j++;
++ len--;
++ if (len == 0)
++ break; /* Case of non-finished packet header in present marker but finished in next one */
++ }
++ cp->ppm_previous = i - 1;
++ cp->ppm_store = j;
++ }
++}
++
++static void j2k_read_ppt(opj_j2k_t *j2k) {
++ int len, Z_ppt, i, j = 0;
++
++ opj_cp_t *cp = j2k->cp;
++ opj_tcp_t *tcp = cp->tcps + j2k->curtileno;
++ opj_cio_t *cio = j2k->cio;
++
++ len = cio_read(cio, 2);
++ Z_ppt = cio_read(cio, 1);
++ tcp->ppt = 1;
++ if (Z_ppt == 0) { /* First PPT marker */
++ tcp->ppt_data = (unsigned char *) opj_malloc((len - 3) * sizeof(unsigned char));
++ tcp->ppt_data_first = tcp->ppt_data;
++ tcp->ppt_store = 0;
++ tcp->ppt_len = len - 3;
++ } else { /* NON-first PPT marker */
++ tcp->ppt_data = (unsigned char *) opj_realloc(tcp->ppt_data, (len - 3 + tcp->ppt_store) * sizeof(unsigned char));
++ tcp->ppt_data_first = tcp->ppt_data;
++ tcp->ppt_len = len - 3 + tcp->ppt_store;
++ }
++ j = tcp->ppt_store;
++ for (i = len - 3; i > 0; i--) {
++ tcp->ppt_data[j] = cio_read(cio, 1);
++ j++;
++ }
++ tcp->ppt_store = j;
++}
++
++static void j2k_write_sot(opj_j2k_t *j2k) {
++ int lenp, len;
++
++ opj_cio_t *cio = j2k->cio;
++
++ j2k->sot_start = cio_tell(cio);
++ cio_write(cio, J2K_MS_SOT, 2); /* SOT */
++ lenp = cio_tell(cio);
++ cio_skip(cio, 2); /* Lsot (further) */
++ cio_write(cio, j2k->curtileno, 2); /* Isot */
++ cio_skip(cio, 4); /* Psot (further in j2k_write_sod) */
++ cio_write(cio, 0, 1); /* TPsot */
++ cio_write(cio, 1, 1); /* TNsot */
++ len = cio_tell(cio) - lenp;
++ cio_seek(cio, lenp);
++ cio_write(cio, len, 2); /* Lsot */
++ cio_seek(cio, lenp + len);
++}
++
++static void j2k_read_sot(opj_j2k_t *j2k) {
++ int len, tileno, totlen, partno, numparts, i;
++ opj_tcp_t *tcp = NULL;
++ char status = 0;
++
++ opj_cp_t *cp = j2k->cp;
++ opj_cio_t *cio = j2k->cio;
++
++ len = cio_read(cio, 2);
++ tileno = cio_read(cio, 2);
++/* UniPG>> */
++#ifdef USE_JPWL
++ if (j2k->cp->correct) {
++
++ static int backup_tileno = 0;
++
++ /* tileno is negative or larger than the number of tiles!!! */
++ if ((tileno < 0) || (tileno > (cp->tw * cp->th))) {
++ opj_event_msg(j2k->cinfo, EVT_ERROR,
++ "JPWL: bad tile number (%d out of a maximum of %d)\n",
++ tileno, (cp->tw * cp->th));
++ if (!JPWL_ASSUME)
++ exit(1);
++ /* we try to correct */
++ opj_event_msg(j2k->cinfo, EVT_WARNING, "- trying to adjust this\n");
++ tileno = backup_tileno;
++ opj_event_msg(j2k->cinfo, EVT_WARNING, "- setting tile number to %d\n",
++ tileno);
++ }
++
++ /* keep your private count of tiles */
++ backup_tileno++;
++ };
++#endif /* USE_JPWL */
++/* <<UniPG */
++
++ if (cp->tileno_size == 0) {
++ cp->tileno[cp->tileno_size] = tileno;
++ cp->tileno_size++;
++ } else {
++ i = 0;
++ while (i < cp->tileno_size && status == 0) {
++ status = cp->tileno[i] == tileno ? 1 : 0;
++ i++;
++ }
++ if (status == 0) {
++ cp->tileno[cp->tileno_size] = tileno;
++ cp->tileno_size++;
++ }
++ }
++
++ totlen = cio_read(cio, 4);
++/* UniPG>> */
++#ifdef USE_JPWL
++ if (j2k->cp->correct) {
++
++ /* totlen is negative or larger than the bytes left!!! */
++ if ((totlen < 0) || (totlen > (cio_numbytesleft(cio) + 8))) {
++ opj_event_msg(j2k->cinfo, EVT_ERROR,
++ "JPWL: bad tile byte size (%d bytes against %d bytes left)\n",
++ totlen, cio_numbytesleft(cio) + 8);
++ if (!JPWL_ASSUME)
++ exit(1);
++ /* we try to correct */
++ opj_event_msg(j2k->cinfo, EVT_WARNING, "- trying to adjust this\n");
++ totlen = 0;
++ opj_event_msg(j2k->cinfo, EVT_WARNING, "- setting Psot to %d => "
++ "assuming it is the last tile\n",
++ totlen);
++ }
++
++ };
++#endif /* USE_JPWL */
++/* <<UniPG */
++ if (!totlen)
++ totlen = cio_numbytesleft(cio) + 8;
++
++ partno = cio_read(cio, 1);
++ numparts = cio_read(cio, 1);
++
++ j2k->curtileno = tileno;
++ j2k->eot = cio_getbp(cio) - 12 + totlen;
++ j2k->state = J2K_STATE_TPH;
++ tcp = &cp->tcps[j2k->curtileno];
++
++ if (tcp->first == 1) {
++
++ /* Initialization PPT */
++ opj_tccp_t *tmp = tcp->tccps;
++ memcpy(tcp, j2k->default_tcp, sizeof(opj_tcp_t));
++ tcp->ppt = 0;
++ tcp->ppt_data = NULL;
++ tcp->ppt_data_first = NULL;
++ tcp->tccps = tmp;
++
++ for (i = 0; i < j2k->image->numcomps; i++) {
++ tcp->tccps[i] = j2k->default_tcp->tccps[i];
++ }
++ cp->tcps[j2k->curtileno].first = 0;
++ }
++}
++
++static void j2k_write_sod(opj_j2k_t *j2k, void *tile_coder) {
++ int l, layno;
++ int totlen;
++ opj_tcp_t *tcp = NULL;
++ opj_image_info_t *image_info = NULL;
++
++ opj_tcd_t *tcd = (opj_tcd_t*)tile_coder; /* cast is needed because of conflicts in header inclusions */
++ opj_cp_t *cp = j2k->cp;
++ opj_cio_t *cio = j2k->cio;
++
++ cio_write(cio, J2K_MS_SOD, 2);
++ if (j2k->curtileno == 0) {
++ j2k->sod_start = cio_tell(cio) + j2k->pos_correction;
++ }
++
++ /* INDEX >> */
++ image_info = j2k->image_info;
++ if (image_info && image_info->index_on) {
++ image_info->tile[j2k->curtileno].end_header = cio_tell(cio) + j2k->pos_correction - 1;
++ }
++ /* << INDEX */
++
++ tcp = &cp->tcps[j2k->curtileno];
++ for (layno = 0; layno < tcp->numlayers; layno++) {
++ tcp->rates[layno] -= tcp->rates[layno] ? (j2k->sod_start / (cp->th * cp->tw)) : 0;
++ }
++ if(image_info) {
++ image_info->num = 0;
++ }
++
++ l = tcd_encode_tile(tcd, j2k->curtileno, cio_getbp(cio), cio_numbytesleft(cio) - 2, image_info);
++
++ /* Writing Psot in SOT marker */
++ totlen = cio_tell(cio) + l - j2k->sot_start;
++ cio_seek(cio, j2k->sot_start + 6);
++ cio_write(cio, totlen, 4);
++ cio_seek(cio, j2k->sot_start + totlen);
++}
++
++static void j2k_read_sod(opj_j2k_t *j2k) {
++ int len, truncate = 0, i;
++ unsigned char *data = NULL, *data_ptr = NULL;
++
++ opj_cio_t *cio = j2k->cio;
++ int curtileno = j2k->curtileno;
++
++ len = int_min(j2k->eot - cio_getbp(cio), cio_numbytesleft(cio) + 1);
++
++ if (len == cio_numbytesleft(cio) + 1) {
++ truncate = 1; /* Case of a truncate codestream */
++ }
++
++ data = (unsigned char *) opj_malloc((j2k->tile_len[curtileno] + len) * sizeof(unsigned char));
++
++ for (i = 0; i < j2k->tile_len[curtileno]; i++) {
++ data[i] = j2k->tile_data[curtileno][i];
++ }
++
++ data_ptr = data + j2k->tile_len[curtileno];
++ for (i = 0; i < len; i++) {
++ data_ptr[i] = cio_read(cio, 1);
++ }
++
++ j2k->tile_len[curtileno] += len;
++ opj_free(j2k->tile_data[curtileno]);
++ j2k->tile_data[curtileno] = data;
++
++ if (!truncate) {
++ j2k->state = J2K_STATE_TPHSOT;
++ } else {
++ j2k->state = J2K_STATE_NEOC; /* RAJOUTE !! */
++ }
++}
++
++static void j2k_write_rgn(opj_j2k_t *j2k, int compno, int tileno) {
++
++ opj_cp_t *cp = j2k->cp;
++ opj_tcp_t *tcp = &cp->tcps[tileno];
++ opj_cio_t *cio = j2k->cio;
++ int numcomps = j2k->image->numcomps;
++
++ cio_write(cio, J2K_MS_RGN, 2); /* RGN */
++ cio_write(cio, numcomps <= 256 ? 5 : 6, 2); /* Lrgn */
++ cio_write(cio, compno, numcomps <= 256 ? 1 : 2); /* Crgn */
++ cio_write(cio, 0, 1); /* Srgn */
++ cio_write(cio, tcp->tccps[compno].roishift, 1); /* SPrgn */
++}
++
++static void j2k_read_rgn(opj_j2k_t *j2k) {
++ int len, compno, roisty;
++
++ opj_cp_t *cp = j2k->cp;
++ opj_tcp_t *tcp = j2k->state == J2K_STATE_TPH ? &cp->tcps[j2k->curtileno] : j2k->default_tcp;
++ opj_cio_t *cio = j2k->cio;
++ int numcomps = j2k->image->numcomps;
++
++ len = cio_read(cio, 2); /* Lrgn */
++ compno = cio_read(cio, numcomps <= 256 ? 1 : 2); /* Crgn */
++ roisty = cio_read(cio, 1); /* Srgn */
++/* UniPG>> */
++#ifdef USE_JPWL
++ if (j2k->cp->correct) {
++ /* totlen is negative or larger than the bytes left!!! */
++ if (compno >= numcomps) {
++ opj_event_msg(j2k->cinfo, EVT_ERROR,
++ "JPWL: bad component number in RGN (%d when there are only %d)\n",
++ compno, numcomps);
++ if (!JPWL_ASSUME || JPWL_ASSUME)
++ exit(1);
++ }
++ };
++#endif /* USE_JPWL */
++/* <<UniPG */
++ tcp->tccps[compno].roishift = cio_read(cio, 1); /* SPrgn */
++}
++
++static void j2k_write_eoc(opj_j2k_t *j2k) {
++ opj_cio_t *cio = j2k->cio;
++ /* opj_event_msg(j2k->cinfo, "%.8x: EOC\n", cio_tell(cio) + j2k->pos_correction); */
++ cio_write(cio, J2K_MS_EOC, 2);
++}
++
++static void j2k_read_eoc(opj_j2k_t *j2k) {
++ int i, tileno;
++
++#ifndef NO_PACKETS_DECODING
++ opj_tcd_t *tcd = tcd_create(j2k->cinfo);
++ tcd_malloc_decode(tcd, j2k->image, j2k->cp);
++ for (i = 0; i < j2k->cp->tileno_size; i++) {
++ tileno = j2k->cp->tileno[i];
++ tcd_decode_tile(tcd, j2k->tile_data[tileno], j2k->tile_len[tileno], tileno);
++ opj_free(j2k->tile_data[tileno]);
++ j2k->tile_data[tileno] = NULL;
++ }
++ tcd_free_decode(tcd);
++ tcd_destroy(tcd);
++#else
++ for (i = 0; i < j2k->cp->tileno_size; i++) {
++ tileno = j2k->cp->tileno[i];
++ opj_free(j2k->tile_data[tileno]);
++ j2k->tile_data[tileno] = NULL;
++ }
++#endif
++
++ j2k->state = J2K_STATE_MT;
++}
++
++typedef struct opj_dec_mstabent {
++ /** marker value */
++ int id;
++ /** value of the state when the marker can appear */
++ int states;
++ /** action linked to the marker */
++ void (*handler) (opj_j2k_t *j2k);
++} opj_dec_mstabent_t;
++
++opj_dec_mstabent_t j2k_dec_mstab[] = {
++ {J2K_MS_SOC, J2K_STATE_MHSOC, j2k_read_soc},
++ {J2K_MS_SOT, J2K_STATE_MH | J2K_STATE_TPHSOT, j2k_read_sot},
++ {J2K_MS_SOD, J2K_STATE_TPH, j2k_read_sod},
++ {J2K_MS_EOC, J2K_STATE_TPHSOT, j2k_read_eoc},
++ {J2K_MS_SIZ, J2K_STATE_MHSIZ, j2k_read_siz},
++ {J2K_MS_COD, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_cod},
++ {J2K_MS_COC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_coc},
++ {J2K_MS_RGN, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_rgn},
++ {J2K_MS_QCD, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_qcd},
++ {J2K_MS_QCC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_qcc},
++ {J2K_MS_POC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_poc},
++ {J2K_MS_TLM, J2K_STATE_MH, j2k_read_tlm},
++ {J2K_MS_PLM, J2K_STATE_MH, j2k_read_plm},
++ {J2K_MS_PLT, J2K_STATE_TPH, j2k_read_plt},
++ {J2K_MS_PPM, J2K_STATE_MH, j2k_read_ppm},
++ {J2K_MS_PPT, J2K_STATE_TPH, j2k_read_ppt},
++ {J2K_MS_SOP, 0, 0},
++ {J2K_MS_CRG, J2K_STATE_MH, j2k_read_crg},
++ {J2K_MS_COM, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_com},
++/* UniPG>> */
++#ifdef USE_JPWL
++ {J2K_MS_EPC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_epc},
++ {J2K_MS_EPB, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_epb},
++ {J2K_MS_ESD, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_esd},
++ {J2K_MS_RED, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_red},
++#endif /* USE_JPWL */
++/* <<UniPG */
++ {0, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_unk}
++};
++
++static void j2k_read_unk(opj_j2k_t *j2k) {
++ opj_event_msg(j2k->cinfo, EVT_WARNING, "Unknown marker\n");
++/* UniPG>> */
++#ifdef USE_JPWL
++ if (j2k->cp->correct) {
++ int m = 0, id, i;
++ int min_id = 0, min_dist = 17, cur_dist = 0, tmp_id;
++ cio_seek(j2k->cio, cio_tell(j2k->cio) - 2);
++ id = cio_read(j2k->cio, 2);
++ opj_event_msg(j2k->cinfo, EVT_ERROR,
++ "JPWL: really don't know this marker %x\n",
++ id);
++ if (!JPWL_ASSUME) {
++ opj_event_msg(j2k->cinfo, EVT_ERROR,
++ "- possible synch loss due to uncorrectable channel errors => Exiting\n");
++ exit(1);
++ }
++ /* OK, activate this at your own risk!!! */
++ /* we look for the marker at the minimum hamming distance from this */
++ while (j2k_dec_mstab[m].id) {
++
++ /* 1's where they differ */
++ tmp_id = j2k_dec_mstab[m].id ^ id;
++
++ /* compute the hamming distance between our id and the current */
++ cur_dist = 0;
++ for (i = 0; i < 16; i++) {
++ if ((tmp_id >> i) & 0x0001) {
++ cur_dist++;
++ }
++ }
++
++ /* if current distance is smaller, set the minimum */
++ if (cur_dist < min_dist) {
++ min_dist = cur_dist;
++ min_id = j2k_dec_mstab[m].id;
++ }
++
++ /* jump to the next marker */
++ m++;
++ }
++
++ /* do we substitute the marker? */
++ if (min_dist < JPWL_MAXIMUM_HAMMING) {
++ opj_event_msg(j2k->cinfo, EVT_ERROR,
++ "- marker %x is at distance %d from the read %x\n",
++ min_id, min_dist, id);
++ opj_event_msg(j2k->cinfo, EVT_ERROR,
++ "- trying to substitute in place and crossing fingers!\n");
++ cio_seek(j2k->cio, cio_tell(j2k->cio) - 2);
++ cio_write(j2k->cio, min_id, 2);
++
++ /* rewind */
++ cio_seek(j2k->cio, cio_tell(j2k->cio) - 2);
++
++ }
++
++ };
++#endif /* USE_JPWL */
++/* <<UniPG */
++}
++
++/**
++Read the lookup table containing all the marker, status and action
++@param id Marker value
++*/
++static opj_dec_mstabent_t *j2k_dec_mstab_lookup(int id) {
++ opj_dec_mstabent_t *e;
++ for (e = j2k_dec_mstab; e->id != 0; e++) {
++ if (e->id == id) {
++ break;
++ }
++ }
++ return e;
++}
++
++/* ----------------------------------------------------------------------- */
++/* J2K / JPT decoder interface */
++/* ----------------------------------------------------------------------- */
++
++opj_j2k_t* j2k_create_decompress(opj_common_ptr cinfo) {
++ opj_j2k_t *j2k = (opj_j2k_t*)opj_malloc(sizeof(opj_j2k_t));
++ if(j2k) {
++ j2k->cinfo = cinfo;
++ j2k->default_tcp = (opj_tcp_t*)opj_malloc(sizeof(opj_tcp_t));
++ if(!j2k->default_tcp) {
++ opj_free(j2k);
++ return NULL;
++ }
++ }
++ return j2k;
++}
++
++void j2k_destroy_decompress(opj_j2k_t *j2k) {
++ int i = 0;
++
++ if(j2k->tile_len != NULL) {
++ opj_free(j2k->tile_len);
++ }
++ if(j2k->tile_data != NULL) {
++ opj_free(j2k->tile_data);
++ }
++ if(j2k->default_tcp != NULL) {
++ opj_tcp_t *default_tcp = j2k->default_tcp;
++ if(default_tcp->ppt_data_first != NULL) {
++ opj_free(default_tcp->ppt_data_first);
++ }
++ if(j2k->default_tcp->tccps != NULL) {
++ opj_free(j2k->default_tcp->tccps);
++ }
++ opj_free(j2k->default_tcp);
++ }
++ if(j2k->cp != NULL) {
++ opj_cp_t *cp = j2k->cp;
++ if(cp->tcps != NULL) {
++ for(i = 0; i < cp->tw * cp->th; i++) {
++ if(cp->tcps[i].ppt_data_first != NULL) {
++ opj_free(cp->tcps[i].ppt_data_first);
++ }
++ if(cp->tcps[i].tccps != NULL) {
++ opj_free(cp->tcps[i].tccps);
++ }
++ }
++ opj_free(cp->tcps);
++ }
++ if(cp->ppm_data_first != NULL) {
++ opj_free(cp->ppm_data_first);
++ }
++ if(cp->tileno != NULL) {
++ opj_free(cp->tileno);
++ }
++ if(cp->comment != NULL) {
++ opj_free(cp->comment);
++ }
++
++ opj_free(cp);
++ }
++
++ opj_free(j2k);
++}
++
++void j2k_setup_decoder(opj_j2k_t *j2k, opj_dparameters_t *parameters) {
++ if(j2k && parameters) {
++ /* create and initialize the coding parameters structure */
++ opj_cp_t *cp = (opj_cp_t*)opj_malloc(sizeof(opj_cp_t));
++ cp->reduce = parameters->cp_reduce;
++ cp->layer = parameters->cp_layer;
++ cp->limit_decoding = parameters->cp_limit_decoding;
++/* UniPG>> */
++#ifdef USE_JPWL
++ cp->correct = parameters->jpwl_correct;
++ cp->exp_comps = parameters->jpwl_exp_comps;
++ cp->max_tiles = parameters->jpwl_max_tiles;
++#endif /* USE_JPWL */
++/* <<UniPG */
++
++ /* keep a link to cp so that we can destroy it later in j2k_destroy_decompress */
++ j2k->cp = cp;
++ }
++}
++
++opj_image_t* j2k_decode(opj_j2k_t *j2k, opj_cio_t *cio) {
++ opj_image_t *image = NULL;
++
++ opj_common_ptr cinfo = j2k->cinfo;
++
++ j2k->cio = cio;
++
++ /* create an empty image */
++ image = opj_image_create0();
++ j2k->image = image;
++
++ j2k->state = J2K_STATE_MHSOC;
++
++ for (;;) {
++ opj_dec_mstabent_t *e;
++ int id = cio_read(cio, 2);
++
++/* UniPG>> */
++#ifdef USE_JPWL
++ /* we try to honor JPWL correction power */
++ if (j2k->cp->correct) {
++
++ int orig_pos = cio_tell(cio);
++ bool status;
++
++ /* call the corrector */
++ status = jpwl_correct(j2k);
++
++ /* go back to where you were */
++ cio_seek(cio, orig_pos - 2);
++
++ /* re-read the marker */
++ id = cio_read(cio, 2);
++
++ /* check whether it begins with ff */
++ if (id >> 8 != 0xff) {
++ opj_event_msg(j2k->cinfo, EVT_ERROR,
++ "JPWL: possible bad marker %x at %d\n",
++ id, cio_tell(cio) - 2);
++ if (!JPWL_ASSUME)
++ exit(1);
++ /* we try to correct */
++ opj_event_msg(j2k->cinfo, EVT_WARNING, "- trying to adjust this\n");
++ id = id | 0xff00;
++ cio_seek(cio, cio_tell(cio) - 2);
++ cio_write(cio, id, 2);
++ opj_event_msg(j2k->cinfo, EVT_WARNING, "- setting marker to %x\n",
++ id);
++ }
++
++ }
++#endif /* USE_JPWL */
++/* <<UniPG */
++ if (id >> 8 != 0xff) {
++ opj_image_destroy(image);
++ opj_event_msg(cinfo, EVT_ERROR, "%.8x: expected a marker instead of %x\n", cio_tell(cio) - 2, id);
++ return 0;
++ }
++ e = j2k_dec_mstab_lookup(id);
++ // Check if the marker is known
++ if (!(j2k->state & e->states)) {
++ opj_image_destroy(image);
++ opj_event_msg(cinfo, EVT_ERROR, "%.8x: unexpected marker %x\n", cio_tell(cio) - 2, id);
++ return 0;
++ }
++ // Check if the decoding is limited to the main header
++ if (e->id == J2K_MS_SOT && j2k->cp->limit_decoding == LIMIT_TO_MAIN_HEADER) {
++ opj_event_msg(cinfo, EVT_INFO, "Main Header decoded.\n");
++ return image;
++ }
++
++ if (e->handler) {
++ (*e->handler)(j2k);
++ }
++ if (j2k->state == J2K_STATE_MT) {
++ break;
++ }
++ if (j2k->state == J2K_STATE_NEOC) {
++ break;
++ }
++ }
++ if (j2k->state == J2K_STATE_NEOC) {
++ j2k_read_eoc(j2k);
++ }
++
++ if (j2k->state != J2K_STATE_MT) {
++ opj_event_msg(cinfo, EVT_WARNING, "Incomplete bitstream\n");
++ }
++
++ return image;
++}
++
++/*
++* Read a JPT-stream and decode file
++*
++*/
++opj_image_t* j2k_decode_jpt_stream(opj_j2k_t *j2k, opj_cio_t *cio) {
++ opj_image_t *image = NULL;
++ opj_jpt_msg_header_t header;
++ int position;
++
++ opj_common_ptr cinfo = j2k->cinfo;
++
++ j2k->cio = cio;
++
++ /* create an empty image */
++ image = opj_image_create0();
++
++ j2k->state = J2K_STATE_MHSOC;
++
++ /* Initialize the header */
++ jpt_init_msg_header(&header);
++ /* Read the first header of the message */
++ jpt_read_msg_header(cinfo, cio, &header);
++
++ position = cio_tell(cio);
++ if (header.Class_Id != 6) { /* 6 : Main header data-bin message */
++ opj_image_destroy(image);
++ opj_event_msg(cinfo, EVT_ERROR, "[JPT-stream] : Expecting Main header first [class_Id %d] !\n", header.Class_Id);
++ return 0;
++ }
++
++ for (;;) {
++ opj_dec_mstabent_t *e = NULL;
++ int id;
++
++ if (!cio_numbytesleft(cio)) {
++ j2k_read_eoc(j2k);
++ return image;
++ }
++ /* data-bin read -> need to read a new header */
++ if ((unsigned int) (cio_tell(cio) - position) == header.Msg_length) {
++ jpt_read_msg_header(cinfo, cio, &header);
++ position = cio_tell(cio);
++ if (header.Class_Id != 4) { /* 4 : Tile data-bin message */
++ opj_image_destroy(image);
++ opj_event_msg(cinfo, EVT_ERROR, "[JPT-stream] : Expecting Tile info !\n");
++ return 0;
++ }
++ }
++
++ id = cio_read(cio, 2);
++ if (id >> 8 != 0xff) {
++ opj_image_destroy(image);
++ opj_event_msg(cinfo, EVT_ERROR, "%.8x: expected a marker instead of %x\n", cio_tell(cio) - 2, id);
++ return 0;
++ }
++ e = j2k_dec_mstab_lookup(id);
++ if (!(j2k->state & e->states)) {
++ opj_image_destroy(image);
++ opj_event_msg(cinfo, EVT_ERROR, "%.8x: unexpected marker %x\n", cio_tell(cio) - 2, id);
++ return 0;
++ }
++ if (e->handler) {
++ (*e->handler)(j2k);
++ }
++ if (j2k->state == J2K_STATE_MT) {
++ break;
++ }
++ if (j2k->state == J2K_STATE_NEOC) {
++ break;
++ }
++ }
++ if (j2k->state == J2K_STATE_NEOC) {
++ j2k_read_eoc(j2k);
++ }
++
++ if (j2k->state != J2K_STATE_MT) {
++ opj_event_msg(cinfo, EVT_WARNING, "Incomplete bitstream\n");
++ }
++
++ return image;
++}
++
++/* ----------------------------------------------------------------------- */
++/* J2K encoder interface */
++/* ----------------------------------------------------------------------- */
++
++opj_j2k_t* j2k_create_compress(opj_common_ptr cinfo) {
++ opj_j2k_t *j2k = (opj_j2k_t*)opj_malloc(sizeof(opj_j2k_t));
++ if(j2k) {
++ j2k->cinfo = cinfo;
++ }
++ return j2k;
++}
++
++void j2k_destroy_compress(opj_j2k_t *j2k) {
++ int tileno;
++
++ if(!j2k) return;
++
++ if(j2k->image_info != NULL) {
++ opj_image_info_t *image_info = j2k->image_info;
++ if (image_info->index_on && j2k->cp) {
++ opj_cp_t *cp = j2k->cp;
++ for (tileno = 0; tileno < cp->tw * cp->th; tileno++) {
++ opj_tile_info_t *tile_info = &image_info->tile[tileno];
++ opj_free(tile_info->thresh);
++ opj_free(tile_info->packet);
++ }
++ opj_free(image_info->tile);
++ }
++ opj_free(image_info);
++ }
++ if(j2k->cp != NULL) {
++ opj_cp_t *cp = j2k->cp;
++
++ if(cp->comment) {
++ opj_free(cp->comment);
++ }
++ if(cp->matrice) {
++ opj_free(cp->matrice);
++ }
++ for (tileno = 0; tileno < cp->tw * cp->th; tileno++) {
++ opj_free(cp->tcps[tileno].tccps);
++ }
++ opj_free(cp->tcps);
++ opj_free(cp);
++ }
++
++ opj_free(j2k);
++}
++
++void j2k_setup_encoder(opj_j2k_t *j2k, opj_cparameters_t *parameters, opj_image_t *image) {
++ int i, j, tileno, numpocs_tile;
++ opj_cp_t *cp = NULL;
++
++ if(!j2k || !parameters || ! image) {
++ return;
++ }
++
++ /* create and initialize the coding parameters structure */
++ cp = (opj_cp_t*)opj_malloc(sizeof(opj_cp_t));
++
++ /* keep a link to cp so that we can destroy it later in j2k_destroy_compress */
++ j2k->cp = cp;
++
++ /* set default values for cp */
++ cp->tw = 1;
++ cp->th = 1;
++
++ /*
++ copy user encoding parameters
++ */
++
++ cp->disto_alloc = parameters->cp_disto_alloc;
++ cp->fixed_alloc = parameters->cp_fixed_alloc;
++ cp->fixed_quality = parameters->cp_fixed_quality;
++
++ /* mod fixed_quality */
++ if(parameters->cp_matrice) {
++ size_t array_size = parameters->tcp_numlayers * parameters->numresolution * 3 * sizeof(int);
++ cp->matrice = (int *) opj_malloc(array_size);
++ memcpy(cp->matrice, parameters->cp_matrice, array_size);
++ }
++
++ /* creation of an index file ? */
++ cp->index_on = parameters->index_on;
++ if(cp->index_on) {
++ j2k->image_info = (opj_image_info_t*)opj_malloc(sizeof(opj_image_info_t));
++ }
++
++ /* tiles */
++ cp->tdx = parameters->cp_tdx;
++ cp->tdy = parameters->cp_tdy;
++
++ /* tile offset */
++ cp->tx0 = parameters->cp_tx0;
++ cp->ty0 = parameters->cp_ty0;
++
++ /* comment string */
++ if(parameters->cp_comment) {
++ cp->comment = (char*)opj_malloc(strlen(parameters->cp_comment) + 1);
++ if(cp->comment) {
++ strcpy(cp->comment, parameters->cp_comment);
++ }
++ }
++
++ /*
++ calculate other encoding parameters
++ */
++
++ if (parameters->tile_size_on) {
++ cp->tw = int_ceildiv(image->x1 - cp->tx0, cp->tdx);
++ cp->th = int_ceildiv(image->y1 - cp->ty0, cp->tdy);
++ } else {
++ cp->tdx = image->x1 - cp->tx0;
++ cp->tdy = image->y1 - cp->ty0;
++ }
++
++/* UniPG>> */
++#ifdef USE_JPWL
++ /*
++ calculate JPWL encoding parameters
++ */
++
++ if (parameters->jpwl_epc_on) {
++ int i;
++
++ /* set JPWL on */
++ cp->epc_on = true;
++ cp->info_on = false; /* no informative technique */
++
++ /* set EPB on */
++ if ((parameters->jpwl_hprot_MH > 0) || (parameters->jpwl_hprot_TPH[0] > 0)) {
++ cp->epb_on = true;
++
++ cp->hprot_MH = parameters->jpwl_hprot_MH;
++ for (i = 0; i < JPWL_MAX_NO_TILESPECS; i++) {
++ cp->hprot_TPH_tileno[i] = parameters->jpwl_hprot_TPH_tileno[i];
++ cp->hprot_TPH[i] = parameters->jpwl_hprot_TPH[i];
++ }
++ /* if tile specs are not specified, copy MH specs */
++ if (cp->hprot_TPH[0] == -1) {
++ cp->hprot_TPH_tileno[0] = 0;
++ cp->hprot_TPH[0] = parameters->jpwl_hprot_MH;
++ }
++ for (i = 0; i < JPWL_MAX_NO_PACKSPECS; i++) {
++ cp->pprot_tileno[i] = parameters->jpwl_pprot_tileno[i];
++ cp->pprot_packno[i] = parameters->jpwl_pprot_packno[i];
++ cp->pprot[i] = parameters->jpwl_pprot[i];
++ }
++ }
++
++ /* set ESD writing */
++ if ((parameters->jpwl_sens_size == 1) || (parameters->jpwl_sens_size == 2)) {
++ cp->esd_on = true;
++
++ cp->sens_size = parameters->jpwl_sens_size;
++ cp->sens_addr = parameters->jpwl_sens_addr;
++ cp->sens_range = parameters->jpwl_sens_range;
++
++ cp->sens_MH = parameters->jpwl_sens_MH;
++ for (i = 0; i < JPWL_MAX_NO_TILESPECS; i++) {
++ cp->sens_TPH_tileno[i] = parameters->jpwl_sens_TPH_tileno[i];
++ cp->sens_TPH[i] = parameters->jpwl_sens_TPH[i];
++ }
++ }
++
++ /* always set RED writing to false: we are at the encoder */
++ cp->red_on = false;
++
++ } else {
++ cp->epc_on = false;
++ }
++#endif /* USE_JPWL */
++/* <<UniPG */
++
++ /* initialize the mutiple tiles */
++ /* ---------------------------- */
++ cp->tcps = (opj_tcp_t *) opj_malloc(cp->tw * cp->th * sizeof(opj_tcp_t));
++
++ for (tileno = 0; tileno < cp->tw * cp->th; tileno++) {
++ opj_tcp_t *tcp = &cp->tcps[tileno];
++ tcp->numlayers = parameters->tcp_numlayers;
++ for (j = 0; j < tcp->numlayers; j++) {
++ if (cp->fixed_quality) { /* add fixed_quality */
++ tcp->distoratio[j] = parameters->tcp_distoratio[j];
++ } else {
++ tcp->rates[j] = parameters->tcp_rates[j];
++ }
++ }
++ tcp->csty = parameters->csty;
++ tcp->prg = parameters->prog_order;
++ tcp->mct = image->numcomps == 3 ? 1 : 0;
++
++ numpocs_tile = 0;
++ tcp->POC = 0;
++ if (parameters->numpocs) {
++ /* initialisation of POC */
++ tcp->POC = 1;
++ for (i = 0; i < parameters->numpocs; i++) {
++ if((tileno == parameters->POC[i].tile - 1) || (parameters->POC[i].tile == -1)) {
++ opj_poc_t *tcp_poc = &tcp->pocs[numpocs_tile];
++ tcp_poc->resno0 = parameters->POC[numpocs_tile].resno0;
++ tcp_poc->compno0 = parameters->POC[numpocs_tile].compno0;
++ tcp_poc->layno1 = parameters->POC[numpocs_tile].layno1;
++ tcp_poc->resno1 = parameters->POC[numpocs_tile].resno1;
++ tcp_poc->compno1 = parameters->POC[numpocs_tile].compno1;
++ tcp_poc->prg = parameters->POC[numpocs_tile].prg;
++ tcp_poc->tile = parameters->POC[numpocs_tile].tile;
++ numpocs_tile++;
++ }
++ }
++ }
++ tcp->numpocs = numpocs_tile;
++
++ tcp->tccps = (opj_tccp_t *) opj_malloc(image->numcomps * sizeof(opj_tccp_t));
++
++ for (i = 0; i < image->numcomps; i++) {
++ opj_tccp_t *tccp = &tcp->tccps[i];
++ tccp->csty = parameters->csty & 0x01; /* 0 => one precinct || 1 => custom precinct */
++ tccp->numresolutions = parameters->numresolution;
++ tccp->cblkw = int_floorlog2(parameters->cblockw_init);
++ tccp->cblkh = int_floorlog2(parameters->cblockh_init);
++ tccp->cblksty = parameters->mode;
++ tccp->qmfbid = parameters->irreversible ? 0 : 1;
++ tccp->qntsty = parameters->irreversible ? J2K_CCP_QNTSTY_SEQNT : J2K_CCP_QNTSTY_NOQNT;
++ tccp->numgbits = 2;
++ if (i == parameters->roi_compno) {
++ tccp->roishift = parameters->roi_shift;
++ } else {
++ tccp->roishift = 0;
++ }
++ if (parameters->csty & J2K_CCP_CSTY_PRT) {
++ int p = 0;
++ for (j = tccp->numresolutions - 1; j >= 0; j--) {
++ if (p < parameters->res_spec) {
++ if (parameters->prcw_init[p] < 1) {
++ tccp->prcw[j] = 1;
++ } else {
++ tccp->prcw[j] = int_floorlog2(parameters->prcw_init[p]);
++ }
++ if (parameters->prch_init[p] < 1) {
++ tccp->prch[j] = 1;
++ } else {
++ tccp->prch[j] = int_floorlog2(parameters->prch_init[p]);
++ }
++ } else {
++ int res_spec = parameters->res_spec;
++ int size_prcw = parameters->prcw_init[res_spec - 1] >> (p - (res_spec - 1));
++ int size_prch = parameters->prch_init[res_spec - 1] >> (p - (res_spec - 1));
++ if (size_prcw < 1) {
++ tccp->prcw[j] = 1;
++ } else {
++ tccp->prcw[j] = int_floorlog2(size_prcw);
++ }
++ if (size_prch < 1) {
++ tccp->prch[j] = 1;
++ } else {
++ tccp->prch[j] = int_floorlog2(size_prch);
++ }
++ }
++ p++;
++ /*printf("\nsize precinct for level %d : %d,%d\n", j,tccp->prcw[j], tccp->prch[j]); */
++ }
++ } else {
++ for (j = 0; j < tccp->numresolutions; j++) {
++ tccp->prcw[j] = 15;
++ tccp->prch[j] = 15;
++ }
++ }
++
++ dwt_calc_explicit_stepsizes(tccp, image->comps[i].prec);
++ }
++ }
++}
++
++/**
++Create an index file
++@param j2k
++@param cio
++@param image_info
++@param index Index filename
++@return Returns 1 if successful, returns 0 otherwise
++*/
++static int j2k_create_index(opj_j2k_t *j2k, opj_cio_t *cio, opj_image_info_t *image_info, char *index) {
++ int tileno, compno, layno, resno, precno, pack_nb, x, y;
++ FILE *stream = NULL;
++ double total_disto = 0;
++
++ image_info->codestream_size = cio_tell(cio) + j2k->pos_correction; /* Correction 14/4/03 suite rmq de Patrick */
++
++/* UniPG>> */
++#ifdef USE_JPWL
++ /* if JPWL is enabled and the name coincides with our own set
++ then discard the creation of the file: this was just done to
++ enable indexing, we do not want an index file
++ */
++ if (j2k->cp->epc_on && !strcmp(index, JPWL_PRIVATEINDEX_NAME))
++ return 1;
++#endif /* USE_JPWL */
++/* <<UniPG */
++
++ stream = fopen(index, "w");
++ if (!stream) {
++ opj_event_msg(j2k->cinfo, EVT_ERROR, "failed to open %s for writing\n", index);
++ return 0;
++ }
++
++ fprintf(stream, "%d %d\n", image_info->image_w, image_info->image_h);
++ fprintf(stream, "%d\n", image_info->prog);
++ fprintf(stream, "%d %d\n", image_info->tile_x, image_info->tile_y);
++ fprintf(stream, "%d %d\n", image_info->tw, image_info->th);
++ fprintf(stream, "%d\n", image_info->comp);
++ fprintf(stream, "%d\n", image_info->layer);
++ fprintf(stream, "%d\n", image_info->decomposition);
++
++ for (resno = image_info->decomposition; resno >= 0; resno--) {
++ fprintf(stream, "[%d,%d] ",
++ (1 << image_info->tile[0].pdx[resno]), (1 << image_info->tile[0].pdx[resno])); /* based on tile 0 */
++ }
++ fprintf(stream, "\n");
++ fprintf(stream, "%d\n", image_info->main_head_end);
++ fprintf(stream, "%d\n", image_info->codestream_size);
++
++ for (tileno = 0; tileno < image_info->tw * image_info->th; tileno++) {
++ fprintf(stream, "%4d %9d %9d %9d %9e %9d %9e\n",
++ image_info->tile[tileno].num_tile,
++ image_info->tile[tileno].start_pos,
++ image_info->tile[tileno].end_header,
++ image_info->tile[tileno].end_pos,
++ image_info->tile[tileno].distotile, image_info->tile[tileno].nbpix,
++ image_info->tile[tileno].distotile / image_info->tile[tileno].nbpix);
++ }
++
++ for (tileno = 0; tileno < image_info->tw * image_info->th; tileno++) {
++ int start_pos, end_pos;
++ double disto = 0;
++ pack_nb = 0;
++
++ /*
++ fprintf(stream, "pkno tileno layerno resno compno precno start_pos end_pos deltaSE \n");
++ */
++
++ if (image_info->prog == LRCP) { /* LRCP */
++ /*
++ fprintf(stream, "pack_nb tileno layno resno compno precno start_pos end_pos disto");
++ */
++ for (layno = 0; layno < image_info->layer; layno++) {
++ for (resno = 0; resno < image_info->decomposition + 1; resno++) {
++ for (compno = 0; compno < image_info->comp; compno++) {
++ int prec_max = image_info->tile[tileno].pw[resno] * image_info->tile[tileno].ph[resno];
++ for (precno = 0; precno < prec_max; precno++) {
++ start_pos = image_info->tile[tileno].packet[pack_nb].start_pos;
++ end_pos = image_info->tile[tileno].packet[pack_nb].end_pos;
++ disto = image_info->tile[tileno].packet[pack_nb].disto;
++ fprintf(stream, "%4d %6d %7d %5d %6d %6d %9d %9d %8e\n",
++ pack_nb, tileno, layno, resno, compno, precno, start_pos, end_pos, disto);
++ total_disto += disto;
++ pack_nb++;
++ }
++ }
++ }
++ }
++ } /* LRCP */
++ else if (image_info->prog == RLCP) { /* RLCP */
++ /*
++ fprintf(stream, "pack_nb tileno resno layno compno precno start_pos end_pos disto");
++ */
++ for (resno = 0; resno < image_info->decomposition + 1; resno++) {
++ for (layno = 0; layno < image_info->layer; layno++) {
++ for (compno = 0; compno < image_info->comp; compno++) {
++ int prec_max = image_info->tile[tileno].pw[resno] * image_info->tile[tileno].ph[resno];
++ for (precno = 0; precno < prec_max; precno++) {
++ start_pos = image_info->tile[tileno].packet[pack_nb].start_pos;
++ end_pos = image_info->tile[tileno].packet[pack_nb].end_pos;
++ disto = image_info->tile[tileno].packet[pack_nb].disto;
++ fprintf(stream, "%4d %6d %5d %7d %6d %6d %9d %9d %8e\n",
++ pack_nb, tileno, resno, layno, compno, precno, start_pos, end_pos, disto);
++ total_disto += disto;
++ pack_nb++;
++ }
++ }
++ }
++ }
++ } /* RLCP */
++ else if (image_info->prog == RPCL) { /* RPCL */
++ /*
++ fprintf(stream, "\npack_nb tileno resno precno compno layno start_pos end_pos disto\n");
++ */
++ for (resno = 0; resno < image_info->decomposition + 1; resno++) {
++ /* I suppose components have same XRsiz, YRsiz */
++ int x0 = image_info->tile_Ox + tileno - (int)floor( (float)tileno/(float)image_info->tw ) * image_info->tw * image_info->tile_x;
++ int y0 = image_info->tile_Ox + (int)floor( (float)tileno/(float)image_info->tw ) * image_info->tile_y;
++ int x1 = x0 + image_info->tile_x;
++ int y1 = y0 + image_info->tile_y;
++ for(y = y0; y < y1; y++) {
++ for(x = x0; x < x1; x++) {
++ for (compno = 0; compno < image_info->comp; compno++) {
++ int prec_max = image_info->tile[tileno].pw[resno] * image_info->tile[tileno].ph[resno];
++ for (precno = 0; precno < prec_max; precno++) {
++ int pcnx = image_info->tile[tileno].pw[resno];
++ int pcx = (int) pow( 2, image_info->tile[tileno].pdx[resno] + image_info->decomposition - resno );
++ int pcy = (int) pow( 2, image_info->tile[tileno].pdy[resno] + image_info->decomposition - resno );
++ int precno_x = precno - (int) floor( (float)precno/(float)pcnx ) * pcnx;
++ int precno_y = (int) floor( (float)precno/(float)pcnx );
++ if (precno_y*pcy == y ) {
++ if (precno_x*pcx == x ) {
++ for (layno = 0; layno < image_info->layer; layno++) {
++ start_pos = image_info->tile[tileno].packet[pack_nb].start_pos;
++ end_pos = image_info->tile[tileno].packet[pack_nb].end_pos;
++ disto = image_info->tile[tileno].packet[pack_nb].disto;
++ fprintf(stream, "%4d %6d %5d %6d %6d %7d %9d %9d %8e\n",
++ pack_nb, tileno, resno, precno, compno, layno, start_pos, end_pos, disto);
++ total_disto += disto;
++ pack_nb++;
++ }
++ }
++ }
++ } /* precno */
++ } /* compno */
++ } /* x = x0..x1 */
++ } /* y = y0..y1 */
++ } /* resno */
++ } /* RPCL */
++ else if (image_info->prog == PCRL) { /* PCRL */
++ /* I suppose components have same XRsiz, YRsiz */
++ int x0 = image_info->tile_Ox + tileno - (int)floor( (float)tileno/(float)image_info->tw ) * image_info->tw * image_info->tile_x;
++ int y0 = image_info->tile_Ox + (int)floor( (float)tileno/(float)image_info->tw ) * image_info->tile_y;
++ int x1 = x0 + image_info->tile_x;
++ int y1 = y0 + image_info->tile_y;
++ /*
++ fprintf(stream, "\npack_nb tileno precno compno resno layno start_pos end_pos disto\n");
++ */
++ for(y = y0; y < y1; y++) {
++ for(x = x0; x < x1; x++) {
++ for (compno = 0; compno < image_info->comp; compno++) {
++ for (resno = 0; resno < image_info->decomposition + 1; resno++) {
++ int prec_max = image_info->tile[tileno].pw[resno] * image_info->tile[tileno].ph[resno];
++ for (precno = 0; precno < prec_max; precno++) {
++ int pcnx = image_info->tile[tileno].pw[resno];
++ int pcx = (int) pow( 2, image_info->tile[tileno].pdx[resno] + image_info->decomposition - resno );
++ int pcy = (int) pow( 2, image_info->tile[tileno].pdy[resno] + image_info->decomposition - resno );
++ int precno_x = precno - (int) floor( (float)precno/(float)pcnx ) * pcnx;
++ int precno_y = (int) floor( (float)precno/(float)pcnx );
++ if (precno_y*pcy == y ) {
++ if (precno_x*pcx == x ) {
++ for (layno = 0; layno < image_info->layer; layno++) {
++ start_pos = image_info->tile[tileno].packet[pack_nb].start_pos;
++ end_pos = image_info->tile[tileno].packet[pack_nb].end_pos;
++ disto = image_info->tile[tileno].packet[pack_nb].disto;
++ fprintf(stream, "%4d %6d %6d %6d %5d %7d %9d %9d %8e\n",
++ pack_nb, tileno, precno, compno, resno, layno, start_pos, end_pos, disto);
++ total_disto += disto;
++ pack_nb++;
++ }
++ }
++ }
++ } /* precno */
++ } /* resno */
++ } /* compno */
++ } /* x = x0..x1 */
++ } /* y = y0..y1 */
++ } /* PCRL */
++ else { /* CPRL */
++ /*
++ fprintf(stream, "\npack_nb tileno compno precno resno layno start_pos end_pos disto\n");
++ */
++ for (compno = 0; compno < image_info->comp; compno++) {
++ /* I suppose components have same XRsiz, YRsiz */
++ int x0 = image_info->tile_Ox + tileno - (int)floor( (float)tileno/(float)image_info->tw ) * image_info->tw * image_info->tile_x;
++ int y0 = image_info->tile_Ox + (int)floor( (float)tileno/(float)image_info->tw ) * image_info->tile_y;
++ int x1 = x0 + image_info->tile_x;
++ int y1 = y0 + image_info->tile_y;
++ for(y = y0; y < y1; y++) {
++ for(x = x0; x < x1; x++) {
++ for (resno = 0; resno < image_info->decomposition + 1; resno++) {
++ int prec_max = image_info->tile[tileno].pw[resno] * image_info->tile[tileno].ph[resno];
++ for (precno = 0; precno < prec_max; precno++) {
++ int pcnx = image_info->tile[tileno].pw[resno];
++ int pcx = (int) pow( 2, image_info->tile[tileno].pdx[resno] + image_info->decomposition - resno );
++ int pcy = (int) pow( 2, image_info->tile[tileno].pdy[resno] + image_info->decomposition - resno );
++ int precno_x = precno - (int) floor( (float)precno/(float)pcnx ) * pcnx;
++ int precno_y = (int) floor( (float)precno/(float)pcnx );
++ if (precno_y*pcy == y ) {
++ if (precno_x*pcx == x ) {
++ for (layno = 0; layno < image_info->layer; layno++) {
++ start_pos = image_info->tile[tileno].packet[pack_nb].start_pos;
++ end_pos = image_info->tile[tileno].packet[pack_nb].end_pos;
++ disto = image_info->tile[tileno].packet[pack_nb].disto;
++ fprintf(stream, "%4d %6d %6d %6d %5d %7d %9d %9d %8e\n",
++ pack_nb, tileno, compno, precno, resno, layno, start_pos, end_pos, disto);
++ total_disto += disto;
++ pack_nb++;
++ }
++ }
++ }
++ } /* precno */
++ } /* resno */
++ } /* x = x0..x1 */
++ } /* y = y0..y1 */
++ } /* comno */
++ } /* CPRL */
++ } /* tileno */
++
++ fprintf(stream, "%8e\n", image_info->D_max); /* SE max */
++ fprintf(stream, "%.8e\n", total_disto); /* SE totale */
++ fclose(stream);
++
++ return 1;
++}
++
++bool j2k_encode(opj_j2k_t *j2k, opj_cio_t *cio, opj_image_t *image, char *index) {
++ int tileno, compno;
++ opj_image_info_t *image_info = NULL;
++ opj_cp_t *cp = NULL;
++
++ opj_tcd_t *tcd = NULL; /* TCD component */
++
++ j2k->cio = cio;
++ j2k->image = image;
++
++ cp = j2k->cp;
++
++ /* j2k_dump_cp(stdout, image, cp); */
++
++ /* INDEX >> */
++ image_info = j2k->image_info;
++ if (image_info && cp->index_on) {
++ image_info->index_on = cp->index_on;
++ image_info->tile = (opj_tile_info_t *) opj_malloc(cp->tw * cp->th * sizeof(opj_tile_info_t));
++ image_info->image_w = image->x1 - image->x0;
++ image_info->image_h = image->y1 - image->y0;
++ image_info->prog = (&cp->tcps[0])->prg;
++ image_info->tw = cp->tw;
++ image_info->th = cp->th;
++ image_info->tile_x = cp->tdx; /* new version parser */
++ image_info->tile_y = cp->tdy; /* new version parser */
++ image_info->tile_Ox = cp->tx0; /* new version parser */
++ image_info->tile_Oy = cp->ty0; /* new version parser */
++ image_info->comp = image->numcomps;
++ image_info->layer = (&cp->tcps[0])->numlayers;
++ image_info->decomposition = (&cp->tcps[0])->tccps->numresolutions - 1;
++ image_info->D_max = 0; /* ADD Marcela */
++ }
++ /* << INDEX */
++
++ j2k_write_soc(j2k);
++ j2k_write_siz(j2k);
++/* UniPG>> */
++#ifdef USE_JPWL
++ /** THIS CODE IS NOT USED */
++ //if(image_info && image_info->index_on && cp->epc_on)
++ // j2k_write_epc(j2k);
++#endif /* USE_JPWL */
++/* <<UniPG */
++ j2k_write_cod(j2k);
++ j2k_write_qcd(j2k);
++ for (compno = 0; compno < image->numcomps; compno++) {
++ opj_tcp_t *tcp = &cp->tcps[0];
++ if (tcp->tccps[compno].roishift)
++ j2k_write_rgn(j2k, compno, 0);
++ }
++ if (cp->comment != NULL) {
++ j2k_write_com(j2k);
++ }
++ /* INDEX >> */
++ if(image_info && image_info->index_on) {
++ image_info->main_head_end = cio_tell(cio) - 1;
++ }
++ /* << INDEX */
++
++ /* create the tile encoder */
++ tcd = tcd_create(j2k->cinfo);
++
++ /* encode each tile */
++
++ for (tileno = 0; tileno < cp->tw * cp->th; tileno++) {
++ opj_event_msg(j2k->cinfo, EVT_INFO, "tile number %d / %d\n", tileno + 1, cp->tw * cp->th);
++
++ j2k->curtileno = tileno;
++
++ /* initialisation before tile encoding */
++ if (tileno == 0) {
++ tcd_malloc_encode(tcd, image, cp, j2k->curtileno);
++ } else {
++ tcd_init_encode(tcd, image, cp, j2k->curtileno);
++ }
++
++ /* INDEX >> */
++ if(image_info && image_info->index_on) {
++ image_info->tile[j2k->curtileno].num_tile = j2k->curtileno;
++ image_info->tile[j2k->curtileno].start_pos = cio_tell(cio) + j2k->pos_correction;
++ }
++ /* << INDEX */
++
++ j2k_write_sot(j2k);
++
++ for (compno = 1; compno < image->numcomps; compno++) {
++ j2k_write_coc(j2k, compno);
++ j2k_write_qcc(j2k, compno);
++ }
++ if (cp->tcps[tileno].numpocs) {
++ j2k_write_poc(j2k);
++ }
++
++ j2k_write_sod(j2k, tcd);
++
++ /* INDEX >> */
++ if(image_info && image_info->index_on) {
++ image_info->tile[j2k->curtileno].end_pos = cio_tell(cio) + j2k->pos_correction - 1;
++ }
++ /* << INDEX */
++
++
++ /*
++ if (tile->PPT) { // BAD PPT !!!
++ FILE *PPT_file;
++ int i;
++ PPT_file=fopen("PPT","rb");
++ fprintf(stderr,"%c%c%c%c",255,97,tile->len_ppt/256,tile->len_ppt%256);
++ for (i=0;i<tile->len_ppt;i++) {
++ unsigned char elmt;
++ fread(&elmt, 1, 1, PPT_file);
++ fwrite(&elmt,1,1,f);
++ }
++ fclose(PPT_file);
++ unlink("PPT");
++ }
++ */
++
++ }
++
++ /* destroy the tile encoder */
++ tcd_free_encode(tcd);
++ tcd_destroy(tcd);
++
++ j2k_write_eoc(j2k);
++
++ /* Creation of the index file */
++ if(image_info && image_info->index_on) {
++ if(!j2k_create_index(j2k, cio, image_info, index)) {
++ opj_event_msg(j2k->cinfo, EVT_ERROR, "failed to create index file %s\n", index);
++ return false;
++ }
++ }
++
++/* UniPG>> */
++#ifdef USE_JPWL
++ /*
++ preparation of JPWL marker segments: can be finalized only when the whole
++ codestream is known
++ */
++ if(image_info && image_info->index_on && cp->epc_on) {
++
++ /* let's begin creating a marker list, according to user wishes */
++ jpwl_prepare_marks(j2k, cio, image);
++
++ /* now we dump the JPWL markers on the codestream */
++ jpwl_dump_marks(j2k, cio, image);
++
++ /* do not know exactly what is this for,
++ but it gets called during index creation */
++ j2k->pos_correction = 0;
++
++ /* Re-creation of the index file, with updated info */
++ if(image_info && image_info->index_on) {
++ if(!j2k_create_index(j2k, cio, image_info, index)) {
++ opj_event_msg(j2k->cinfo, EVT_ERROR, "failed to re-create index file %s\n", index);
++ return false;
++ }
++ }
++
++ /* now we finalize the marker contents */
++ /*jpwl_finalize_marks(j2k, cio, image);*/
++
++ }
++#endif /* USE_JPWL */
++/* <<UniPG */
++
++ return true;
++}
++
+diff -Naur OpenJPEG/libopenjpeg/j2k.c.rej OpenJPEG-patched/libopenjpeg/j2k.c.rej
+--- OpenJPEG/libopenjpeg/j2k.c.rej 1970-01-01 01:00:00.000000000 +0100
++++ OpenJPEG-patched/libopenjpeg/j2k.c.rej 2007-03-17 14:18:44.000000000 +0100
+@@ -0,0 +1,16 @@
++***************
++*** 1522,1527 ****
++ opj_cp_t *cp = (opj_cp_t*)opj_malloc(sizeof(opj_cp_t));
++ cp->reduce = parameters->cp_reduce;
++ cp->layer = parameters->cp_layer;
++ /* UniPG>> */
++ #ifdef USE_JPWL
++ cp->correct = parameters->jpwl_correct;
++--- 1524,1530 ----
++ opj_cp_t *cp = (opj_cp_t*)opj_malloc(sizeof(opj_cp_t));
++ cp->reduce = parameters->cp_reduce;
++ cp->layer = parameters->cp_layer;
+++ cp->limit_tags = parameters->cp_limit_tags;
++ /* UniPG>> */
++ #ifdef USE_JPWL
++ cp->correct = parameters->jpwl_correct;
+diff -Naur OpenJPEG/libopenjpeg/j2k.h OpenJPEG-patched/libopenjpeg/j2k.h
+--- OpenJPEG/libopenjpeg/j2k.h 2007-02-19 10:59:29.000000000 +0100
++++ OpenJPEG-patched/libopenjpeg/j2k.h 2007-03-17 14:20:28.000000000 +0100
+@@ -200,6 +200,8 @@
+ /** if == NO_LIMITATION, decode entire codestream; if == LIMIT_TO_MAIN_HEADER then only decode the main header */
+ OPJ_LIMIT_DECODING limit_decoding;
+ /** 0 = no index || 1 = index */
++ /** if != 0, then only decode specific tags, abort on any other; if == 0 decode all tags */
++ OPJ_LIMIT_TAGS limit_tags;
+ int index_on;
+ /** XTOsiz */
+ int tx0;
+diff -Naur OpenJPEG/libopenjpeg/j2k.h.orig OpenJPEG-patched/libopenjpeg/j2k.h.orig
+--- OpenJPEG/libopenjpeg/j2k.h.orig 1970-01-01 01:00:00.000000000 +0100
++++ OpenJPEG-patched/libopenjpeg/j2k.h.orig 2007-02-19 10:59:29.000000000 +0100
+@@ -0,0 +1,484 @@
++/*
++ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
++ * Copyright (c) 2002-2007, Professor Benoit Macq
++ * Copyright (c) 2001-2003, David Janssens
++ * Copyright (c) 2002-2003, Yannick Verschueren
++ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
++ * Copyright (c) 2005, Herve Drolon, FreeImage Team
++ * All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions
++ * are met:
++ * 1. Redistributions of source code must retain the above copyright
++ * notice, this list of conditions and the following disclaimer.
++ * 2. Redistributions in binary form must reproduce the above copyright
++ * notice, this list of conditions and the following disclaimer in the
++ * documentation and/or other materials provided with the distribution.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
++ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
++ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
++ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
++ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
++ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
++ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
++ * POSSIBILITY OF SUCH DAMAGE.
++ */
++#ifndef __J2K_H
++#define __J2K_H
++/**
++@file j2k.h
++@brief The JPEG-2000 Codestream Reader/Writer (J2K)
++
++The functions in J2K.C have for goal to read/write the several parts of the codestream: markers and data.
++*/
++
++/** @defgroup J2K J2K - JPEG-2000 codestream reader/writer */
++/*@{*/
++
++#define J2K_CP_CSTY_PRT 0x01
++#define J2K_CP_CSTY_SOP 0x02
++#define J2K_CP_CSTY_EPH 0x04
++#define J2K_CCP_CSTY_PRT 0x01
++#define J2K_CCP_CBLKSTY_LAZY 0x01
++#define J2K_CCP_CBLKSTY_RESET 0x02
++#define J2K_CCP_CBLKSTY_TERMALL 0x04
++#define J2K_CCP_CBLKSTY_VSC 0x08
++#define J2K_CCP_CBLKSTY_PTERM 0x10
++#define J2K_CCP_CBLKSTY_SEGSYM 0x20
++#define J2K_CCP_QNTSTY_NOQNT 0
++#define J2K_CCP_QNTSTY_SIQNT 1
++#define J2K_CCP_QNTSTY_SEQNT 2
++
++/* ----------------------------------------------------------------------- */
++
++#define J2K_MS_SOC 0xff4f /**< SOC marker value */
++#define J2K_MS_SOT 0xff90 /**< SOT marker value */
++#define J2K_MS_SOD 0xff93 /**< SOD marker value */
++#define J2K_MS_EOC 0xffd9 /**< EOC marker value */
++#define J2K_MS_SIZ 0xff51 /**< SIZ marker value */
++#define J2K_MS_COD 0xff52 /**< COD marker value */
++#define J2K_MS_COC 0xff53 /**< COC marker value */
++#define J2K_MS_RGN 0xff5e /**< RGN marker value */
++#define J2K_MS_QCD 0xff5c /**< QCD marker value */
++#define J2K_MS_QCC 0xff5d /**< QCC marker value */
++#define J2K_MS_POC 0xff5f /**< POC marker value */
++#define J2K_MS_TLM 0xff55 /**< TLM marker value */
++#define J2K_MS_PLM 0xff57 /**< PLM marker value */
++#define J2K_MS_PLT 0xff58 /**< PLT marker value */
++#define J2K_MS_PPM 0xff60 /**< PPM marker value */
++#define J2K_MS_PPT 0xff61 /**< PPT marker value */
++#define J2K_MS_SOP 0xff91 /**< SOP marker value */
++#define J2K_MS_EPH 0xff92 /**< EPH marker value */
++#define J2K_MS_CRG 0xff63 /**< CRG marker value */
++#define J2K_MS_COM 0xff64 /**< COM marker value */
++/* UniPG>> */
++#ifdef USE_JPWL
++#define J2K_MS_EPC 0xff68 /**< EPC marker value (Part11) */
++#define J2K_MS_EPB 0xff66 /**< EPB marker value (Part11) */
++#define J2K_MS_ESD 0xff67 /**< ESD marker value (Part11) */
++#define J2K_MS_RED 0xff69 /**< RED marker value (Part11) */
++#endif /* USE_JPWL */
++/* <<UniPG */
++
++/* ----------------------------------------------------------------------- */
++
++/**
++Values that specify the status of the decoding process when decoding the main header.
++These values may be combined with a | operator.
++*/
++typedef enum J2K_STATUS {
++ J2K_STATE_MHSOC = 0x0001, /**< a SOC marker is expected */
++ J2K_STATE_MHSIZ = 0x0002, /**< a SIZ marker is expected */
++ J2K_STATE_MH = 0x0004, /**< the decoding process is in the main header */
++ J2K_STATE_TPHSOT = 0x0008, /**< the decoding process is in a tile part header and expects a SOT marker */
++ J2K_STATE_TPH = 0x0010, /**< the decoding process is in a tile part header */
++ J2K_STATE_MT = 0x0020, /**< the EOC marker has just been read */
++ J2K_STATE_NEOC = 0x0040 /**< the decoding process must not expect a EOC marker because the codestream is truncated */
++} J2K_STATUS;
++
++/* ----------------------------------------------------------------------- */
++
++/**
++Quantization stepsize
++*/
++typedef struct opj_stepsize {
++ /** exponent */
++ int expn;
++ /** mantissa */
++ int mant;
++} opj_stepsize_t;
++
++/**
++Tile-component coding parameters
++*/
++typedef struct opj_tccp {
++ /** coding style */
++ int csty;
++ /** number of resolutions */
++ int numresolutions;
++ /** code-blocks width */
++ int cblkw;
++ /** code-blocks height */
++ int cblkh;
++ /** code-block coding style */
++ int cblksty;
++ /** discrete wavelet transform identifier */
++ int qmfbid;
++ /** quantisation style */
++ int qntsty;
++ /** stepsizes used for quantization */
++ opj_stepsize_t stepsizes[J2K_MAXBANDS];
++ /** number of guard bits */
++ int numgbits;
++ /** Region Of Interest shift */
++ int roishift;
++ /** precinct width */
++ int prcw[J2K_MAXRLVLS];
++ /** precinct height */
++ int prch[J2K_MAXRLVLS];
++} opj_tccp_t;
++
++/**
++Tile coding parameters :
++this structure is used to store coding/decoding parameters common to all
++tiles (information like COD, COC in main header)
++*/
++typedef struct opj_tcp {
++ /** 1 : first part-tile of a tile */
++ int first;
++ /** coding style */
++ int csty;
++ /** progression order */
++ OPJ_PROG_ORDER prg;
++ /** number of layers */
++ int numlayers;
++ /** multi-component transform identifier */
++ int mct;
++ /** rates of layers */
++ float rates[100];
++ /** number of progression order changes */
++ int numpocs;
++ /** indicates if a POC marker has been used O:NO, 1:YES */
++ int POC;
++ /** progression order changes */
++ opj_poc_t pocs[32];
++ /** packet header store there for futur use in t2_decode_packet */
++ unsigned char *ppt_data;
++ /** pointer remaining on the first byte of the first header if ppt is used */
++ unsigned char *ppt_data_first;
++ /** If ppt == 1 --> there was a PPT marker for the present tile */
++ int ppt;
++ /** used in case of multiple marker PPT (number of info already stored) */
++ int ppt_store;
++ /** ppmbug1 */
++ int ppt_len;
++ /** add fixed_quality */
++ float distoratio[100];
++ /** tile-component coding parameters */
++ opj_tccp_t *tccps;
++} opj_tcp_t;
++
++/**
++Coding parameters
++*/
++typedef struct opj_cp {
++ /** allocation by rate/distortion */
++ int disto_alloc;
++ /** allocation by fixed layer */
++ int fixed_alloc;
++ /** add fixed_quality */
++ int fixed_quality;
++ /** if != 0, then original dimension divided by 2^(reduce); if == 0 or not used, image is decoded to the full resolution */
++ int reduce;
++ /** if != 0, then only the first "layer" layers are decoded; if == 0 or not used, all the quality layers are decoded */
++ int layer;
++ /** if == NO_LIMITATION, decode entire codestream; if == LIMIT_TO_MAIN_HEADER then only decode the main header */
++ OPJ_LIMIT_DECODING limit_decoding;
++ /** 0 = no index || 1 = index */
++ int index_on;
++ /** XTOsiz */
++ int tx0;
++ /** YTOsiz */
++ int ty0;
++ /** XTsiz */
++ int tdx;
++ /** YTsiz */
++ int tdy;
++ /** comment for coding */
++ char *comment;
++ /** number of tiles in width */
++ int tw;
++ /** number of tiles in heigth */
++ int th;
++ /** ID number of the tiles present in the codestream */
++ int *tileno;
++ /** size of the vector tileno */
++ int tileno_size;
++ /** packet header store there for futur use in t2_decode_packet */
++ unsigned char *ppm_data;
++ /** pointer remaining on the first byte of the first header if ppm is used */
++ unsigned char *ppm_data_first;
++ /** if ppm == 1 --> there was a PPM marker for the present tile */
++ int ppm;
++ /** use in case of multiple marker PPM (number of info already store) */
++ int ppm_store;
++ /** use in case of multiple marker PPM (case on non-finished previous info) */
++ int ppm_previous;
++ /** ppmbug1 */
++ int ppm_len;
++ /** tile coding parameters */
++ opj_tcp_t *tcps;
++ /** fixed layer */
++ int *matrice;
++/* UniPG>> */
++#ifdef USE_JPWL
++ /** enables writing of EPC in MH, thus activating JPWL */
++ bool epc_on;
++ /** enables writing of EPB, in case of activated JPWL */
++ bool epb_on;
++ /** enables writing of ESD, in case of activated JPWL */
++ bool esd_on;
++ /** enables writing of informative techniques of ESD, in case of activated JPWL */
++ bool info_on;
++ /** enables writing of RED, in case of activated JPWL */
++ bool red_on;
++ /** error protection method for MH (0,1,16,32,37-128) */
++ int hprot_MH;
++ /** tile number of header protection specification (>=0) */
++ int hprot_TPH_tileno[JPWL_MAX_NO_TILESPECS];
++ /** error protection methods for TPHs (0,1,16,32,37-128) */
++ int hprot_TPH[JPWL_MAX_NO_TILESPECS];
++ /** tile number of packet protection specification (>=0) */
++ int pprot_tileno[JPWL_MAX_NO_PACKSPECS];
++ /** packet number of packet protection specification (>=0) */
++ int pprot_packno[JPWL_MAX_NO_PACKSPECS];
++ /** error protection methods for packets (0,1,16,32,37-128) */
++ int pprot[JPWL_MAX_NO_PACKSPECS];
++ /** enables writing of ESD, (0/2/4 bytes) */
++ int sens_size;
++ /** sensitivity addressing size (0=auto/2/4 bytes) */
++ int sens_addr;
++ /** sensitivity range (0-3) */
++ int sens_range;
++ /** sensitivity method for MH (-1,0-7) */
++ int sens_MH;
++ /** tile number of sensitivity specification (>=0) */
++ int sens_TPH_tileno[JPWL_MAX_NO_TILESPECS];
++ /** sensitivity methods for TPHs (-1,0-7) */
++ int sens_TPH[JPWL_MAX_NO_TILESPECS];
++ /** enables JPWL correction at the decoder */
++ bool correct;
++ /** expected number of components at the decoder */
++ int exp_comps;
++ /** maximum number of tiles at the decoder */
++ int max_tiles;
++#endif /* USE_JPWL */
++/* <<UniPG */
++} opj_cp_t;
++
++/**
++Information concerning a packet inside tile
++*/
++typedef struct opj_packet_info {
++ /** start position */
++ int start_pos;
++ /** end position */
++ int end_pos;
++ /** ADD for Marcela */
++ double disto;
++} opj_packet_info_t;
++
++/**
++Index structure : information regarding tiles inside image
++*/
++typedef struct opj_tile_info {
++ /** value of thresh for each layer by tile cfr. Marcela */
++ double *thresh;
++ /** number of tile */
++ int num_tile;
++ /** start position */
++ int start_pos;
++ /** end position of the header */
++ int end_header;
++ /** end position */
++ int end_pos;
++ /** precinct number for each resolution level (width) */
++ int pw[33];
++ /** precinct number for each resolution level (height) */
++ int ph[33];
++ /** precinct size (in power of 2), in X for each resolution level */
++ int pdx[33];
++ /** precinct size (in power of 2), in Y for each resolution level */
++ int pdy[33];
++ /** information concerning packets inside tile */
++ opj_packet_info_t *packet;
++ /** add fixed_quality */
++ int nbpix;
++ /** add fixed_quality */
++ double distotile;
++} opj_tile_info_t;
++
++/**
++Index structure
++*/
++typedef struct opj_image_info {
++ /** 0 = no index || 1 = index */
++ int index_on;
++ /** maximum distortion reduction on the whole image (add for Marcela) */
++ double D_max;
++ /** packet number */
++ int num;
++ /** writing the packet in the index with t2_encode_packets */
++ int index_write;
++ /** image width */
++ int image_w;
++ /** image height */
++ int image_h;
++ /** progression order */
++ OPJ_PROG_ORDER prog;
++ /** tile size in x */
++ int tile_x;
++ /** tile size in y */
++ int tile_y;
++ /** */
++ int tile_Ox;
++ /** */
++ int tile_Oy;
++ /** number of tiles in X */
++ int tw;
++ /** number of tiles in Y */
++ int th;
++ /** component numbers */
++ int comp;
++ /** number of layer */
++ int layer;
++ /** number of decomposition */
++ int decomposition;
++ /** main header position */
++ int main_head_end;
++ /** codestream's size */
++ int codestream_size;
++ /** information regarding tiles inside image */
++ opj_tile_info_t *tile;
++} opj_image_info_t;
++
++/**
++JPEG-2000 codestream reader/writer
++*/
++typedef struct opj_j2k {
++ /** codec context */
++ opj_common_ptr cinfo;
++
++ /** locate in which part of the codestream the decoder is (main header, tile header, end) */
++ int state;
++ /** number of the tile curently concern by coding/decoding */
++ int curtileno;
++ /**
++ locate the position of the end of the tile in the codestream,
++ used to detect a truncated codestream (in j2k_read_sod)
++ */
++ unsigned char *eot;
++ /**
++ locate the start position of the SOT marker of the current coded tile:
++ after encoding the tile, a jump (in j2k_write_sod) is done to the SOT marker to store the value of its length.
++ */
++ int sot_start;
++ int sod_start;
++ /**
++ as the J2K-file is written in several parts during encoding,
++ it enables to make the right correction in position return by cio_tell
++ */
++ int pos_correction;
++ /** array used to store the data of each tile */
++ unsigned char **tile_data;
++ /** array used to store the length of each tile */
++ int *tile_len;
++ /**
++ decompression only :
++ store decoding parameters common to all tiles (information like COD, COC in main header)
++ */
++ opj_tcp_t *default_tcp;
++ /** pointer to the encoded / decoded image */
++ opj_image_t *image;
++ /** pointer to the coding parameters */
++ opj_cp_t *cp;
++ /** helper used to write the index file */
++ opj_image_info_t *image_info;
++ /** pointer to the byte i/o stream */
++ opj_cio_t *cio;
++} opj_j2k_t;
++
++/** @name Exported functions */
++/*@{*/
++/* ----------------------------------------------------------------------- */
++/**
++Creates a J2K decompression structure
++@param cinfo Codec context info
++@return Returns a handle to a J2K decompressor if successful, returns NULL otherwise
++*/
++opj_j2k_t* j2k_create_decompress(opj_common_ptr cinfo);
++/**
++Destroy a J2K decompressor handle
++@param j2k J2K decompressor handle to destroy
++*/
++void j2k_destroy_decompress(opj_j2k_t *j2k);
++/**
++Setup the decoder decoding parameters using user parameters.
++Decoding parameters are returned in j2k->cp.
++@param j2k J2K decompressor handle
++@param parameters decompression parameters
++*/
++void j2k_setup_decoder(opj_j2k_t *j2k, opj_dparameters_t *parameters);
++/**
++Decode an image from a JPEG-2000 codestream
++@param j2k J2K decompressor handle
++@param cio Input buffer stream
++@return Returns a decoded image if successful, returns NULL otherwise
++*/
++opj_image_t* j2k_decode(opj_j2k_t *j2k, opj_cio_t *cio);
++/**
++Decode an image form a JPT-stream (JPEG 2000, JPIP)
++@param j2k J2K decompressor handle
++@param cio Input buffer stream
++@return Returns a decoded image if successful, returns NULL otherwise
++*/
++opj_image_t* j2k_decode_jpt_stream(opj_j2k_t *j2k, opj_cio_t *cio);
++/**
++Creates a J2K compression structure
++@param cinfo Codec context info
++@return Returns a handle to a J2K compressor if successful, returns NULL otherwise
++*/
++opj_j2k_t* j2k_create_compress(opj_common_ptr cinfo);
++/**
++Destroy a J2K compressor handle
++@param j2k J2K compressor handle to destroy
++*/
++void j2k_destroy_compress(opj_j2k_t *j2k);
++/**
++Setup the encoder parameters using the current image and using user parameters.
++Coding parameters are returned in j2k->cp.
++@param j2k J2K compressor handle
++@param parameters compression parameters
++@param image input filled image
++*/
++void j2k_setup_encoder(opj_j2k_t *j2k, opj_cparameters_t *parameters, opj_image_t *image);
++/**
++Encode an image into a JPEG-2000 codestream
++@param j2k J2K compressor handle
++@param cio Output buffer stream
++@param image Image to encode
++@param index Name of the index file if required, NULL otherwise
++@return Returns true if successful, returns false otherwise
++*/
++bool j2k_encode(opj_j2k_t *j2k, opj_cio_t *cio, opj_image_t *image, char *index);
++/* ----------------------------------------------------------------------- */
++/*@}*/
++
++/*@}*/
++
++#endif /* __J2K_H */
+diff -Naur OpenJPEG/libopenjpeg/openjpeg.h OpenJPEG-patched/libopenjpeg/openjpeg.h
+--- OpenJPEG/libopenjpeg/openjpeg.h 2007-02-23 11:48:11.000000000 +0100
++++ OpenJPEG-patched/libopenjpeg/openjpeg.h 2007-03-17 14:18:28.000000000 +0100
+@@ -319,6 +319,41 @@
+
+ } opj_cparameters_t;
+
++/** Stop after tags. */
++typedef enum LIMIT_TAGS {
++ OPJ_TAG_SOC = 0x000001, /**< start of codestream */
++ OPJ_TAG_SOT = 0x000002, /**< start of tile-part*/
++ OPJ_TAG_SOD = 0x000004, /**< start of data */
++ OPJ_TAG_EOC = 0x000008, /**< end of codestream */
++ OPJ_TAG_SIZ = 0x000010, /**< image and tile size */
++ OPJ_TAG_COD = 0x000020, /**< coding style default */
++ OPJ_TAG_COC = 0x000040, /**< coding style component */
++ OPJ_TAG_RGN = 0x000080, /**< region-of-interest */
++ OPJ_TAG_QCD = 0x000100, /**< quantization default */
++ OPJ_TAG_QCC = 0x000200, /**< quantization component */
++ OPJ_TAG_POC = 0x000400, /**< progression order change */
++ OPJ_TAG_TLM = 0x000800, /**< tile-part lengths */
++ OPJ_TAG_PLM = 0x001000, /**< packet length, main header */
++ OPJ_TAG_PLT = 0x002000, /**< packet length, tile-part header */
++ OPJ_TAG_PPM = 0x004000, /**< packet packet headers, main header */
++ OPJ_TAG_PPT = 0x008000, /**< packet packet headers, tile-part header */
++ OPJ_TAG_SOP = 0x010000, /**< SOP marker value */
++ OPJ_TAG_EPH = 0x020000, /**< EPH marker value */
++ OPJ_TAG_CRG = 0x040000, /**< component registration */
++ OPJ_TAG_COM = 0x080000, /**< comment */
++#ifdef USE_JPWL
++/* UniPG>> */
++ OPJ_TAG_EPC = 0x100000, /**< EPC marker value (Part11) */
++ OPJ_TAG_EPB = 0x200000, /**< EPB marker value (Part11) */
++ OPJ_TAG_ESD = 0x400000, /**< ESD marker value (Part11) */
++ OPJ_TAG_RED = 0x800000, /**< RED marker value (Part11) */
++#endif /* USE_JPWL */
++/* <<UniPG */
++} OPJ_LIMIT_TAGS;
++
++/** The needed tags to decode just the size of the image. */
++#define OPJ_LIMIT_FOR_SIZE (OPJ_LIMIT_TAGS)(OPJ_TAG_SOC | OPJ_TAG_SIZ )
++
+ /**
+ Decompression parameters
+ */
+@@ -338,6 +373,15 @@
+ if == 0 or not used, all the quality layers are decoded
+ */
+ int cp_layer;
++ /**
++ Limits the tags that are decoded.
++ This is a bitwise OR of the tags to be decoded. If a tag is
++ encountered that isn't in the list decoding ceases and the function
++ returns.
++ if != 0 only the given tags are decoded.
++ if == 0 all tags are decoded.
++ */
++ OPJ_LIMIT_TAGS cp_limit_tags;
+
+ /**
+ Specify whether the decoding should be done on the entire codestream, or be limited to the main header
+diff -Naur OpenJPEG/libopenjpeg/openjpeg.h.orig OpenJPEG-patched/libopenjpeg/openjpeg.h.orig
+--- OpenJPEG/libopenjpeg/openjpeg.h.orig 1970-01-01 01:00:00.000000000 +0100
++++ OpenJPEG-patched/libopenjpeg/openjpeg.h.orig 2007-02-23 11:48:11.000000000 +0100
+@@ -0,0 +1,704 @@
++ /*
++ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
++ * Copyright (c) 2002-2007, Professor Benoit Macq
++ * Copyright (c) 2001-2003, David Janssens
++ * Copyright (c) 2002-2003, Yannick Verschueren
++ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
++ * Copyright (c) 2005, Herve Drolon, FreeImage Team
++ * All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions
++ * are met:
++ * 1. Redistributions of source code must retain the above copyright
++ * notice, this list of conditions and the following disclaimer.
++ * 2. Redistributions in binary form must reproduce the above copyright
++ * notice, this list of conditions and the following disclaimer in the
++ * documentation and/or other materials provided with the distribution.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
++ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
++ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
++ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
++ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
++ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
++ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
++ * POSSIBILITY OF SUCH DAMAGE.
++ */
++#ifndef OPENJPEG_H
++#define OPENJPEG_H
++
++#define OPENJPEG_VERSION "1.1.1"
++
++/*
++==========================================================
++ Compiler directives
++==========================================================
++*/
++
++#if defined(OPJ_STATIC) || !(defined(WIN32) || defined(__WIN32__))
++#define OPJ_API
++#define OPJ_CALLCONV
++#else
++#define OPJ_CALLCONV __stdcall
++/*
++The following ifdef block is the standard way of creating macros which make exporting
++from a DLL simpler. All files within this DLL are compiled with the OPJ_EXPORTS
++symbol defined on the command line. this symbol should not be defined on any project
++that uses this DLL. This way any other project whose source files include this file see
++OPJ_API functions as being imported from a DLL, wheras this DLL sees symbols
++defined with this macro as being exported.
++*/
++#ifdef OPJ_EXPORTS
++#define OPJ_API __declspec(dllexport)
++#else
++#define OPJ_API __declspec(dllimport)
++#endif /* OPJ_EXPORTS */
++#endif /* !OPJ_STATIC || !WIN32 */
++
++#ifndef __cplusplus
++#if defined(HAVE_STDBOOL_H)
++/*
++The C language implementation does correctly provide the standard header
++file "stdbool.h".
++ */
++#include <stdbool.h>
++#else
++/*
++The C language implementation does not provide the standard header file
++"stdbool.h" as required by ISO/IEC 9899:1999. Try to compensate for this
++braindamage below.
++*/
++#if !defined(bool)
++#define bool int
++#endif
++#if !defined(true)
++#define true 1
++#endif
++#if !defined(false)
++#define false 0
++#endif
++#endif
++#endif /* __cplusplus */
++
++/*
++==========================================================
++ Useful constant definitions
++==========================================================
++*/
++
++#define OPJ_PATH_LEN 4096 /**< Maximum allowed size for filenames */
++
++#define J2K_MAXRLVLS 33 /**< Number of maximum resolution level authorized */
++#define J2K_MAXBANDS (3*J2K_MAXRLVLS-2) /**< Number of maximum sub-band linked to number of resolution level */
++
++/* UniPG>> */
++#ifdef USE_JPWL
++#define JPWL_MAX_NO_TILESPECS 16 /**< Maximum number of tile parts expected by JPWL: increase at your will */
++#define JPWL_MAX_NO_PACKSPECS 16 /**< Maximum number of packet parts expected by JPWL: increase at your will */
++#define JPWL_MAX_NO_MARKERS 512 /**< Maximum number of JPWL markers: increase at your will */
++#define JPWL_PRIVATEINDEX_NAME "jpwl_index_privatefilename" /**< index file name used when JPWL is on */
++#define JPWL_EXPECTED_COMPONENTS 3 /**< Expect this number of components, so you'll find better the first EPB */
++#define JPWL_MAXIMUM_TILES 8192 /**< Expect this maximum number of tiles, to avoid some crashes */
++#define JPWL_MAXIMUM_HAMMING 2 /**< Expect this maximum number of bit errors in marker id's */
++#endif /* USE_JPWL */
++/* <<UniPG */
++
++/*
++==========================================================
++ enum definitions
++==========================================================
++*/
++
++/** Progression order */
++typedef enum PROG_ORDER {
++ PROG_UNKNOWN = -1, /**< place-holder */
++ LRCP = 0, /**< layer-resolution-component-precinct order */
++ RLCP = 1, /**< resolution-layer-component-precinct order */
++ RPCL = 2, /**< resolution-precinct-component-layer order */
++ PCRL = 3, /**< precinct-component-resolution-layer order */
++ CPRL = 4 /**< component-precinct-resolution-layer order */
++} OPJ_PROG_ORDER;
++
++/**
++Supported image color spaces
++*/
++typedef enum COLOR_SPACE {
++ CLRSPC_UNKNOWN = -1, /**< place-holder */
++ CLRSPC_SRGB = 1, /**< sRGB */
++ CLRSPC_GRAY = 2, /**< grayscale */
++ CLRSPC_SYCC = 3 /**< YUV */
++} OPJ_COLOR_SPACE;
++
++/**
++Supported codec
++*/
++typedef enum CODEC_FORMAT {
++ CODEC_UNKNOWN = -1, /**< place-holder */
++ CODEC_J2K = 0, /**< JPEG-2000 codestream : read/write */
++ CODEC_JPT = 1, /**< JPT-stream (JPEG 2000, JPIP) : read only */
++ CODEC_JP2 = 2 /**< JPEG-2000 file format : read/write */
++} OPJ_CODEC_FORMAT;
++
++/**
++Limit decoding to certain portions of the codestream.
++*/
++typedef enum LIMIT_DECODING {
++ NO_LIMITATION = 0, /**< No limitation for the decoding. The entire codestream will de decoded */
++ LIMIT_TO_MAIN_HEADER = 1 /**< The decoding is limited to the Main Header */
++} OPJ_LIMIT_DECODING;
++
++/*
++==========================================================
++ event manager typedef definitions
++==========================================================
++*/
++
++/**
++Callback function prototype for events
++@param msg Event message
++@param client_data
++*/
++typedef void (*opj_msg_callback) (const char *msg, void *client_data);
++
++/**
++Message handler object
++used for
++<ul>
++<li>Error messages
++<li>Warning messages
++<li>Debugging messages
++</ul>
++*/
++typedef struct opj_event_mgr {
++ /** Error message callback if available, NULL otherwise */
++ opj_msg_callback error_handler;
++ /** Warning message callback if available, NULL otherwise */
++ opj_msg_callback warning_handler;
++ /** Debug message callback if available, NULL otherwise */
++ opj_msg_callback info_handler;
++} opj_event_mgr_t;
++
++
++/*
++==========================================================
++ codec typedef definitions
++==========================================================
++*/
++
++/**
++Progression order changes
++*/
++typedef struct opj_poc {
++ int resno0, compno0;
++ int layno1, resno1, compno1;
++ OPJ_PROG_ORDER prg;
++ int tile;
++ char progorder[4];
++} opj_poc_t;
++
++/**
++Compression parameters
++*/
++typedef struct opj_cparameters {
++ /** size of tile: tile_size_on = false (not in argument) or = true (in argument) */
++ bool tile_size_on;
++ /** XTOsiz */
++ int cp_tx0;
++ /** YTOsiz */
++ int cp_ty0;
++ /** XTsiz */
++ int cp_tdx;
++ /** YTsiz */
++ int cp_tdy;
++ /** allocation by rate/distortion */
++ int cp_disto_alloc;
++ /** allocation by fixed layer */
++ int cp_fixed_alloc;
++ /** add fixed_quality */
++ int cp_fixed_quality;
++ /** fixed layer */
++ int *cp_matrice;
++ /** comment for coding */
++ char *cp_comment;
++ /** csty : coding style */
++ int csty;
++ /** progression order (default LRCP) */
++ OPJ_PROG_ORDER prog_order;
++ /** progression order changes */
++ opj_poc_t POC[32];
++ /** number of progression order changes (POC), default to 0 */
++ int numpocs;
++ /** number of layers */
++ int tcp_numlayers;
++ /** rates of layers */
++ float tcp_rates[100];
++ /** different psnr for successive layers */
++ float tcp_distoratio[100];
++ /** number of resolutions */
++ int numresolution;
++ /** initial code block width, default to 64 */
++ int cblockw_init;
++ /** initial code block height, default to 64 */
++ int cblockh_init;
++ /** mode switch (cblk_style) */
++ int mode;
++ /** 1 : use the irreversible DWT 9-7, 0 : use lossless compression (default) */
++ int irreversible;
++ /** region of interest: affected component in [0..3], -1 means no ROI */
++ int roi_compno;
++ /** region of interest: upshift value */
++ int roi_shift;
++ /* number of precinct size specifications */
++ int res_spec;
++ /** initial precinct width */
++ int prcw_init[J2K_MAXRLVLS];
++ /** initial precinct height */
++ int prch_init[J2K_MAXRLVLS];
++
++ /**@name command line encoder parameters (not used inside the library) */
++ /*@{*/
++ /** input file name */
++ char infile[OPJ_PATH_LEN];
++ /** output file name */
++ char outfile[OPJ_PATH_LEN];
++ /** creation of an index file, default to 0 (false) */
++ int index_on;
++ /** index file name */
++ char index[OPJ_PATH_LEN];
++ /** subimage encoding: origin image offset in x direction */
++ int image_offset_x0;
++ /** subimage encoding: origin image offset in y direction */
++ int image_offset_y0;
++ /** subsampling value for dx */
++ int subsampling_dx;
++ /** subsampling value for dy */
++ int subsampling_dy;
++ /** input file format 0: PGX, 1: PxM, 2: BMP */
++ int decod_format;
++ /** output file format 0: J2K, 1: JP2, 2: JPT */
++ int cod_format;
++ /*@}*/
++
++/* UniPG>> */
++#ifdef USE_JPWL
++ /**@name JPWL encoding parameters */
++ /*@{*/
++ /** enables writing of EPC in MH, thus activating JPWL */
++ bool jpwl_epc_on;
++ /** error protection method for MH (0,1,16,32,37-128) */
++ int jpwl_hprot_MH;
++ /** tile number of header protection specification (>=0) */
++ int jpwl_hprot_TPH_tileno[JPWL_MAX_NO_TILESPECS];
++ /** error protection methods for TPHs (0,1,16,32,37-128) */
++ int jpwl_hprot_TPH[JPWL_MAX_NO_TILESPECS];
++ /** tile number of packet protection specification (>=0) */
++ int jpwl_pprot_tileno[JPWL_MAX_NO_PACKSPECS];
++ /** packet number of packet protection specification (>=0) */
++ int jpwl_pprot_packno[JPWL_MAX_NO_PACKSPECS];
++ /** error protection methods for packets (0,1,16,32,37-128) */
++ int jpwl_pprot[JPWL_MAX_NO_PACKSPECS];
++ /** enables writing of ESD, (0=no/1/2 bytes) */
++ int jpwl_sens_size;
++ /** sensitivity addressing size (0=auto/2/4 bytes) */
++ int jpwl_sens_addr;
++ /** sensitivity range (0-3) */
++ int jpwl_sens_range;
++ /** sensitivity method for MH (-1=no,0-7) */
++ int jpwl_sens_MH;
++ /** tile number of sensitivity specification (>=0) */
++ int jpwl_sens_TPH_tileno[JPWL_MAX_NO_TILESPECS];
++ /** sensitivity methods for TPHs (-1=no,0-7) */
++ int jpwl_sens_TPH[JPWL_MAX_NO_TILESPECS];
++ /*@}*/
++#endif /* USE_JPWL */
++/* <<UniPG */
++
++} opj_cparameters_t;
++
++/**
++Decompression parameters
++*/
++typedef struct opj_dparameters {
++ /**
++ Set the number of highest resolution levels to be discarded.
++ The image resolution is effectively divided by 2 to the power of the number of discarded levels.
++ The reduce factor is limited by the smallest total number of decomposition levels among tiles.
++ if != 0, then original dimension divided by 2^(reduce);
++ if == 0 or not used, image is decoded to the full resolution
++ */
++ int cp_reduce;
++ /**
++ Set the maximum number of quality layers to decode.
++ If there are less quality layers than the specified number, all the quality layers are decoded.
++ if != 0, then only the first "layer" layers are decoded;
++ if == 0 or not used, all the quality layers are decoded
++ */
++ int cp_layer;
++
++ /**
++ Specify whether the decoding should be done on the entire codestream, or be limited to the main header
++ Limiting the decoding to the main header makes it possible to extract the characteristics of the codestream
++ if == NO_LIMITATION, the entire codestream is decoded;
++ if == LIMIT_TO_MAIN_HEADER, only the main header is decoded;
++ */
++ OPJ_LIMIT_DECODING cp_limit_decoding;
++
++ /**@name command line encoder parameters (not used inside the library) */
++ /*@{*/
++ /** input file name */
++ char infile[OPJ_PATH_LEN];
++ /** output file name */
++ char outfile[OPJ_PATH_LEN];
++ /** input file format 0: J2K, 1: JP2, 2: JPT */
++ int decod_format;
++ /** output file format 0: PGX, 1: PxM, 2: BMP */
++ int cod_format;
++ /*@}*/
++
++/* UniPG>> */
++#ifdef USE_JPWL
++ /**@name JPWL decoding parameters */
++ /*@{*/
++ /** activates the JPWL correction capabilities */
++ bool jpwl_correct;
++ /** expected number of components */
++ int jpwl_exp_comps;
++ /** maximum number of tiles */
++ int jpwl_max_tiles;
++ /*@}*/
++#endif /* USE_JPWL */
++/* <<UniPG */
++} opj_dparameters_t;
++
++/** Common fields between JPEG-2000 compression and decompression master structs. */
++
++#define opj_common_fields \
++ opj_event_mgr_t *event_mgr; /**< pointer to the event manager */\
++ void * client_data; /**< Available for use by application */\
++ bool is_decompressor; /**< So common code can tell which is which */\
++ OPJ_CODEC_FORMAT codec_format; /**< selected codec */\
++ void *j2k_handle; /**< pointer to the J2K codec */\
++ void *jp2_handle /**< pointer to the JP2 codec */
++
++/* Routines that are to be used by both halves of the library are declared
++ * to receive a pointer to this structure. There are no actual instances of
++ * opj_common_struct_t, only of opj_cinfo_t and opj_dinfo_t.
++ */
++typedef struct opj_common_struct {
++ opj_common_fields; /* Fields common to both master struct types */
++ /* Additional fields follow in an actual opj_cinfo_t or
++ * opj_dinfo_t. All three structs must agree on these
++ * initial fields! (This would be a lot cleaner in C++.)
++ */
++} opj_common_struct_t;
++
++typedef opj_common_struct_t * opj_common_ptr;
++
++/**
++Compression context info
++*/
++typedef struct opj_cinfo {
++ /** Fields shared with opj_dinfo_t */
++ opj_common_fields;
++ /* other specific fields go here */
++} opj_cinfo_t;
++
++/**
++Decompression context info
++*/
++typedef struct opj_dinfo {
++ /** Fields shared with opj_cinfo_t */
++ opj_common_fields;
++ /* other specific fields go here */
++} opj_dinfo_t;
++
++/*
++==========================================================
++ I/O stream typedef definitions
++==========================================================
++*/
++
++/*
++ * Stream open flags.
++ */
++/** The stream was opened for reading. */
++#define OPJ_STREAM_READ 0x0001
++/** The stream was opened for writing. */
++#define OPJ_STREAM_WRITE 0x0002
++
++/**
++Byte input-output stream (CIO)
++*/
++typedef struct opj_cio {
++ /** codec context */
++ opj_common_ptr cinfo;
++
++ /** open mode (read/write) either OPJ_STREAM_READ or OPJ_STREAM_WRITE */
++ int openmode;
++ /** pointer to the start of the buffer */
++ unsigned char *buffer;
++ /** buffer size in bytes */
++ int length;
++
++ /** pointer to the start of the stream */
++ unsigned char *start;
++ /** pointer to the end of the stream */
++ unsigned char *end;
++ /** pointer to the current position */
++ unsigned char *bp;
++} opj_cio_t;
++
++/*
++==========================================================
++ image typedef definitions
++==========================================================
++*/
++
++/**
++Defines a single image component
++*/
++typedef struct opj_image_comp {
++ /** XRsiz: horizontal separation of a sample of ith component with respect to the reference grid */
++ int dx;
++ /** YRsiz: vertical separation of a sample of ith component with respect to the reference grid */
++ int dy;
++ /** data width */
++ int w;
++ /** data height */
++ int h;
++ /** x component offset compared to the whole image */
++ int x0;
++ /** y component offset compared to the whole image */
++ int y0;
++ /** precision */
++ int prec;
++ /** image depth in bits */
++ int bpp;
++ /** signed (1) / unsigned (0) */
++ int sgnd;
++ /** number of decoded resolution */
++ int resno_decoded;
++ /** number of division by 2 of the out image compared to the original size of image */
++ int factor;
++ /** image component data */
++ int *data;
++} opj_image_comp_t;
++
++/**
++Defines image data and characteristics
++*/
++typedef struct opj_image {
++ /** XOsiz: horizontal offset from the origin of the reference grid to the left side of the image area */
++ int x0;
++ /** YOsiz: vertical offset from the origin of the reference grid to the top side of the image area */
++ int y0;
++ /** Xsiz: width of the reference grid */
++ int x1;
++ /** Ysiz: height of the reference grid */
++ int y1;
++ /** number of components in the image */
++ int numcomps;
++ /** color space: sRGB, Greyscale or YUV */
++ OPJ_COLOR_SPACE color_space;
++ /** image components */
++ opj_image_comp_t *comps;
++} opj_image_t;
++
++/**
++Component parameters structure used by the opj_image_create function
++*/
++typedef struct opj_image_comptparm {
++ /** XRsiz: horizontal separation of a sample of ith component with respect to the reference grid */
++ int dx;
++ /** YRsiz: vertical separation of a sample of ith component with respect to the reference grid */
++ int dy;
++ /** data width */
++ int w;
++ /** data height */
++ int h;
++ /** x component offset compared to the whole image */
++ int x0;
++ /** y component offset compared to the whole image */
++ int y0;
++ /** precision */
++ int prec;
++ /** image depth in bits */
++ int bpp;
++ /** signed (1) / unsigned (0) */
++ int sgnd;
++} opj_image_cmptparm_t;
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++
++/*
++==========================================================
++ openjpeg version
++==========================================================
++*/
++
++OPJ_API const char * OPJ_CALLCONV opj_version();
++
++/*
++==========================================================
++ image functions definitions
++==========================================================
++*/
++
++/**
++Create an image
++@param numcmpts number of components
++@param cmptparms components parameters
++@param clrspc image color space
++@return returns a new image structure if successful, returns NULL otherwise
++*/
++OPJ_API opj_image_t* OPJ_CALLCONV opj_image_create(int numcmpts, opj_image_cmptparm_t *cmptparms, OPJ_COLOR_SPACE clrspc);
++
++/**
++Deallocate any resources associated with an image
++@param image image to be destroyed
++*/
++OPJ_API void OPJ_CALLCONV opj_image_destroy(opj_image_t *image);
++
++/*
++==========================================================
++ stream functions definitions
++==========================================================
++*/
++
++/**
++Open and allocate a memory stream for read / write.
++On reading, the user must provide a buffer containing encoded data. The buffer will be
++wrapped by the returned CIO handle.
++On writing, buffer parameters must be set to 0: a buffer will be allocated by the library
++to contain encoded data.
++@param cinfo Codec context info
++@param buffer Reading: buffer address. Writing: NULL
++@param length Reading: buffer length. Writing: 0
++@return Returns a CIO handle if successful, returns NULL otherwise
++*/
++OPJ_API opj_cio_t* OPJ_CALLCONV opj_cio_open(opj_common_ptr cinfo, unsigned char *buffer, int length);
++
++/**
++Close and free a CIO handle
++@param cio CIO handle to free
++*/
++OPJ_API void OPJ_CALLCONV opj_cio_close(opj_cio_t *cio);
++
++/**
++Get position in byte stream
++@param cio CIO handle
++@return Returns the position in bytes
++*/
++OPJ_API int OPJ_CALLCONV cio_tell(opj_cio_t *cio);
++/**
++Set position in byte stream
++@param cio CIO handle
++@param pos Position, in number of bytes, from the beginning of the stream
++*/
++OPJ_API void OPJ_CALLCONV cio_seek(opj_cio_t *cio, int pos);
++
++/*
++==========================================================
++ event manager functions definitions
++==========================================================
++*/
++
++OPJ_API opj_event_mgr_t* OPJ_CALLCONV opj_set_event_mgr(opj_common_ptr cinfo, opj_event_mgr_t *event_mgr, void *context);
++
++/*
++==========================================================
++ codec functions definitions
++==========================================================
++*/
++/**
++Creates a J2K/JPT/JP2 decompression structure
++@param format Decoder to select
++@return Returns a handle to a decompressor if successful, returns NULL otherwise
++*/
++OPJ_API opj_dinfo_t* OPJ_CALLCONV opj_create_decompress(OPJ_CODEC_FORMAT format);
++/**
++Destroy a decompressor handle
++@param dinfo decompressor handle to destroy
++*/
++OPJ_API void OPJ_CALLCONV opj_destroy_decompress(opj_dinfo_t *dinfo);
++/**
++Set decoding parameters to default values
++@param parameters Decompression parameters
++*/
++OPJ_API void OPJ_CALLCONV opj_set_default_decoder_parameters(opj_dparameters_t *parameters);
++/**
++Setup the decoder decoding parameters using user parameters.
++Decoding parameters are returned in j2k->cp.
++@param dinfo decompressor handle
++@param parameters decompression parameters
++*/
++OPJ_API void OPJ_CALLCONV opj_setup_decoder(opj_dinfo_t *dinfo, opj_dparameters_t *parameters);
++/**
++Decode an image from a JPEG-2000 codestream
++@param dinfo decompressor handle
++@param cio Input buffer stream
++@return Returns a decoded image if successful, returns NULL otherwise
++*/
++OPJ_API opj_image_t* OPJ_CALLCONV opj_decode(opj_dinfo_t *dinfo, opj_cio_t *cio);
++/**
++Creates a J2K/JP2 compression structure
++@param format Coder to select
++@return Returns a handle to a compressor if successful, returns NULL otherwise
++*/
++OPJ_API opj_cinfo_t* OPJ_CALLCONV opj_create_compress(OPJ_CODEC_FORMAT format);
++/**
++Destroy a compressor handle
++@param cinfo compressor handle to destroy
++*/
++OPJ_API void OPJ_CALLCONV opj_destroy_compress(opj_cinfo_t *cinfo);
++/**
++Set encoding parameters to default values, that means :
++<ul>
++<li>Lossless
++<li>1 tile
++<li>Size of precinct : 2^15 x 2^15 (means 1 precinct)
++<li>Size of code-block : 64 x 64
++<li>Number of resolutions: 6
++<li>No SOP marker in the codestream
++<li>No EPH marker in the codestream
++<li>No sub-sampling in x or y direction
++<li>No mode switch activated
++<li>Progression order: LRCP
++<li>No index file
++<li>No ROI upshifted
++<li>No offset of the origin of the image
++<li>No offset of the origin of the tiles
++<li>Reversible DWT 5-3
++</ul>
++@param parameters Compression parameters
++*/
++OPJ_API void OPJ_CALLCONV opj_set_default_encoder_parameters(opj_cparameters_t *parameters);
++/**
++Setup the encoder parameters using the current image and using user parameters.
++@param cinfo compressor handle
++@param parameters compression parameters
++@param image input filled image
++*/
++OPJ_API void OPJ_CALLCONV opj_setup_encoder(opj_cinfo_t *cinfo, opj_cparameters_t *parameters, opj_image_t *image);
++/**
++Encode an image into a JPEG-2000 codestream
++@param cinfo compressor handle
++@param cio Output buffer stream
++@param image Image to encode
++@param index Name of the index file if required, NULL otherwise
++@return Returns true if successful, returns false otherwise
++*/
++OPJ_API bool OPJ_CALLCONV opj_encode(opj_cinfo_t *cinfo, opj_cio_t *cio, opj_image_t *image, char *index);
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* OPENJPEG_H */
diff --git a/media-libs/openjpeg/files/digest-openjpeg-1.1.1 b/media-libs/openjpeg/files/digest-openjpeg-1.1.1
new file mode 100644
index 0000000..c726c97
--- /dev/null
+++ b/media-libs/openjpeg/files/digest-openjpeg-1.1.1
@@ -0,0 +1,3 @@
+MD5 55ce1119efd3efb3d689ca2105afd10e openjpeg_v1_1_1.tar.gz 1406460
+RMD160 08b2318441075a8704d6b9b0ac3d9d277c44d85e openjpeg_v1_1_1.tar.gz 1406460
+SHA256 6076db131bfaa966a691d718044e5b5cdbec028436be3b7a3f146d1a0e3a7ec6 openjpeg_v1_1_1.tar.gz 1406460
diff --git a/media-libs/openjpeg/files/openjpeg-1.1.1-gentoo.patch b/media-libs/openjpeg/files/openjpeg-1.1.1-gentoo.patch
new file mode 100644
index 0000000..fdb0b9c
--- /dev/null
+++ b/media-libs/openjpeg/files/openjpeg-1.1.1-gentoo.patch
@@ -0,0 +1,20 @@
+diff -Naur OpenJPEG.orig/Makefile OpenJPEG/Makefile
+--- OpenJPEG.orig/Makefile 2007-02-13 17:49:00.000000000 +0900
++++ OpenJPEG/Makefile 2007-02-24 11:47:31.000000000 +0900
+@@ -36,7 +36,7 @@
+ dist: OpenJPEG
+ mkdir -p dist
+ cp *.a dist
+- mv *.so dist
++ cp *.so dist
+ cp libopenjpeg/openjpeg.h dist
+
+ dos2unix:
+@@ -57,7 +57,6 @@
+ install -m 644 -o root -g root $(STATICLIB) $(INSTALLDIR)
+ install -m 755 -o root -g root $(SHAREDLIB) $(INSTALLDIR)
+ ln -sf $(SHAREDLIB) $(INSTALLDIR)/$(LIBNAME)
+- ldconfig
+
+ clean:
+ rm -rf core dist/ u2dtmp* $(MODULES) $(STATICLIB) $(SHAREDLIB) $(LIBNAME)
diff --git a/media-libs/openjpeg/openjpeg-1.1.1.ebuild b/media-libs/openjpeg/openjpeg-1.1.1.ebuild
new file mode 100644
index 0000000..008ef72
--- /dev/null
+++ b/media-libs/openjpeg/openjpeg-1.1.1.ebuild
@@ -0,0 +1,38 @@
+# Copyright 1999-2007 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+# $Header: $
+
+inherit eutils flag-o-matic toolchain-funcs multilib
+
+DESCRIPTION="An open-source JPEG 2000 codec written in C"
+HOMEPAGE="http://www.openjpeg.org/"
+SRC_URI="http://www.openjpeg.org/openjpeg_v${PV//./_}.tar.gz"
+
+LICENSE="BSD"
+SLOT="0"
+KEYWORDS="~amd64 ~ppc64 ~x86"
+IUSE=""
+
+S="${WORKDIR}/OpenJPEG"
+
+src_unpack() {
+ unpack ${A}
+ cd "${S}"
+ epatch "${FILESDIR}"/${P}-gentoo.patch
+ epatch "${FILESDIR}"/OPJ_limit_tags_for_decode_UPDATED.patch
+}
+
+src_compile() {
+ append-flags -fPIC
+ emake CC="$(tc-getCC)" COMPILERFLAGS="${CFLAGS}" || die "emake failed"
+}
+
+src_install() {
+ dodir /usr/$(get_libdir)
+ emake INSTALLDIR="${D}usr/$(get_libdir)" install || die "install failed"
+
+ insinto /usr/include
+ doins libopenjpeg/openjpeg.h
+
+ dodoc ChangeLog README.linux
+}