libopenjpeg/j2k.c

   1 /*
   2  * Copyright (c) 2001-2002, David Janssens
   3  * Copyright (c) 2002-2004, Yannick Verschueren
   4  * Copyright (c) 2002-2004, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
  17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  26  * POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <setjmp.h>
  33 #include <math.h>
  34
  35 #include "j2k.h"
  36 #include "cio.h"
  37 #include "tcd.h"
  38 #include "dwt.h"
  39 #include "int.h"
  40 #include "jpt.h"
  41
  42 #define J2K_MS_SOC 0xff4f
  43 #define J2K_MS_SOT 0xff90
  44 #define J2K_MS_SOD 0xff93
  45 #define J2K_MS_EOC 0xffd9
  46 #define J2K_MS_SIZ 0xff51
  47 #define J2K_MS_COD 0xff52
  48 #define J2K_MS_COC 0xff53
  49 #define J2K_MS_RGN 0xff5e
  50 #define J2K_MS_QCD 0xff5c
  51 #define J2K_MS_QCC 0xff5d
  52 #define J2K_MS_POC 0xff5f
  53 #define J2K_MS_TLM 0xff55
  54 #define J2K_MS_PLM 0xff57
  55 #define J2K_MS_PLT 0xff58
  56 #define J2K_MS_PPM 0xff60
  57 #define J2K_MS_PPT 0xff61
  58 #define J2K_MS_SOP 0xff91
  59 #define J2K_MS_EPH 0xff92
  60 #define J2K_MS_CRG 0xff63
  61 #define J2K_MS_COM 0xff64
  62
  63 #define J2K_STATE_MHSOC 0x0001
  64 #define J2K_STATE_MHSIZ 0x0002
  65 #define J2K_STATE_MH 0x0004
  66 #define J2K_STATE_TPHSOT 0x0008
  67 #define J2K_STATE_TPH 0x0010
  68 #define J2K_STATE_MT 0x0020
  69 #define J2K_STATE_NEOC 0x0040
  70
  71
  72 jmp_buf j2k_error;
  73
  74 static int j2k_state;
  75 static int j2k_curtileno;
  76 static j2k_tcp_t j2k_default_tcp;
  77 static unsigned char *j2k_eot;
  78 static int j2k_sot_start;
  79 static int pos_correction;
  80
  81 static j2k_image_t *j2k_img;
  82 static j2k_cp_t *j2k_cp;
  83
  84 static unsigned char **j2k_tile_data;
  85 static int *j2k_tile_len;
  86
  87 static info_image info_IM;
  88
  89 /* Add Patrick */
  90 void j2k_clean()
  91 {
  92   int tileno = 0;
  93   tcd_free_encode(j2k_img, j2k_cp, j2k_curtileno);
  94
  95   if (info_IM.index_on) {
  96     for (tileno = 0; tileno < j2k_cp->tw * j2k_cp->th; tileno++) {
  97       free(info_IM.tile[tileno].packet);
  98     }
  99     free(info_IM.tile);
 100   }
 101 }
 102
 103 /* \Add Patrick */
 104
 105 void j2k_dump_image(j2k_image_t * img)
 106 {
 107   int compno;
 108   fprintf(stderr, "image {\n");
 109   fprintf(stderr, "  x0=%d, y0=%d, x1=%d, y1=%d\n", img->x0, img->y0,
 110           img->x1, img->y1);
 111   fprintf(stderr, "  numcomps=%d\n", img->numcomps);
 112   for (compno = 0; compno < img->numcomps; compno++) {
 113     j2k_comp_t *comp = &img->comps[compno];
 114     fprintf(stderr, "  comp %d {\n", compno);
 115     fprintf(stderr, "    dx=%d, dy=%d\n", comp->dx, comp->dy);
 116     fprintf(stderr, "    prec=%d\n", comp->prec);
 117     fprintf(stderr, "    sgnd=%d\n", comp->sgnd);
 118     fprintf(stderr, "  }\n");
 119   }
 120   fprintf(stderr, "}\n");
 121 }
 122
 123 void j2k_dump_cp(j2k_image_t * img, j2k_cp_t * cp)
 124 {
 125   int tileno, compno, layno, bandno, resno, numbands;
 126   fprintf(stderr, "coding parameters {\n");
 127   fprintf(stderr, "  tx0=%d, ty0=%d\n", cp->tx0, cp->ty0);
 128   fprintf(stderr, "  tdx=%d, tdy=%d\n", cp->tdx, cp->tdy);
 129   fprintf(stderr, "  tw=%d, th=%d\n", cp->tw, cp->th);
 130   for (tileno = 0; tileno < cp->tw * cp->th; tileno++) {
 131     j2k_tcp_t *tcp = &cp->tcps[tileno];
 132     fprintf(stderr, "  tile %d {\n", tileno);
 133     fprintf(stderr, "    csty=%x\n", tcp->csty);
 134     fprintf(stderr, "    prg=%d\n", tcp->prg);
 135     fprintf(stderr, "    numlayers=%d\n", tcp->numlayers);
 136     fprintf(stderr, "    mct=%d\n", tcp->mct);
 137     fprintf(stderr, "    rates=");
 138     for (layno = 0; layno < tcp->numlayers; layno++) {
 139       fprintf(stderr, "%d ", tcp->rates[layno]);
 140     }
 141     fprintf(stderr, "\n");
 142     for (compno = 0; compno < img->numcomps; compno++) {
 143       j2k_tccp_t *tccp = &tcp->tccps[compno];
 144       fprintf(stderr, "    comp %d {\n", compno);
 145       fprintf(stderr, "      csty=%x\n", tccp->csty);
 146       fprintf(stderr, "      numresolutions=%d\n", tccp->numresolutions);
 147       fprintf(stderr, "      cblkw=%d\n", tccp->cblkw);
 148       fprintf(stderr, "      cblkh=%d\n", tccp->cblkh);
 149       fprintf(stderr, "      cblksty=%x\n", tccp->cblksty);
 150       fprintf(stderr, "      qmfbid=%d\n", tccp->qmfbid);
 151       fprintf(stderr, "      qntsty=%d\n", tccp->qntsty);
 152       fprintf(stderr, "      numgbits=%d\n", tccp->numgbits);
 153       fprintf(stderr, "      roishift=%d\n", tccp->roishift);
 154       fprintf(stderr, "      stepsizes=");
 155       numbands =
 156         tccp->qntsty ==
 157         J2K_CCP_QNTSTY_SIQNT ? 1 : tccp->numresolutions * 3 - 2;
 158       for (bandno = 0; bandno < numbands; bandno++) {
 159         fprintf(stderr, "(%d,%d) ", tccp->stepsizes[bandno].mant,
 160                 tccp->stepsizes[bandno].expn);
 161       }
 162       fprintf(stderr, "\n");
 163
 164       if (tccp->csty & J2K_CCP_CSTY_PRT) {
 165         fprintf(stderr, "      prcw=");
 166         for (resno = 0; resno < tccp->numresolutions; resno++) {
 167           fprintf(stderr, "%d ", tccp->prcw[resno]);
 168         }
 169         fprintf(stderr, "\n");
 170         fprintf(stderr, "      prch=");
 171         for (resno = 0; resno < tccp->numresolutions; resno++) {
 172           fprintf(stderr, "%d ", tccp->prch[resno]);
 173         }
 174         fprintf(stderr, "\n");
 175       }
 176       fprintf(stderr, "    }\n");
 177     }
 178     fprintf(stderr, "  }\n");
 179   }
 180   fprintf(stderr, "}\n");
 181 }
 182
 183 void j2k_write_soc()
 184 {
 185   cio_write(J2K_MS_SOC, 2);
 186 }
 187
 188 void j2k_read_soc()
 189 {
 190   j2k_state = J2K_STATE_MHSIZ;
 191 }
 192
 193 void j2k_write_siz()
 194 {
 195   int i;
 196   int lenp, len;
 197
 198   cio_write(J2K_MS_SIZ, 2);     /* SIZ                 */
 199   lenp = cio_tell();
 200   cio_skip(2);
 201   cio_write(0, 2);              /* Rsiz (capabilities) */
 202   cio_write(j2k_img->x1, 4);    /* Xsiz                */
 203   cio_write(j2k_img->y1, 4);    /* Ysiz                */
 204   cio_write(j2k_img->x0, 4);    /* X0siz               */
 205   cio_write(j2k_img->y0, 4);    /* Y0siz               */
 206   cio_write(j2k_cp->tdx, 4);    /* XTsiz               */
 207   cio_write(j2k_cp->tdy, 4);    /* YTsiz               */
 208   cio_write(j2k_cp->tx0, 4);    /* XT0siz              */
 209   cio_write(j2k_cp->ty0, 4);    /* YT0siz              */
 210   cio_write(j2k_img->numcomps, 2);      /* Csiz                */
 211   for (i = 0; i < j2k_img->numcomps; i++) {
 212     cio_write(j2k_img->comps[i].prec - 1 + (j2k_img->comps[i].sgnd << 7), 1);   /* Ssiz_i */
 213     cio_write(j2k_img->comps[i].dx, 1); /* XRsiz_i             */
 214     cio_write(j2k_img->comps[i].dy, 1); /* YRsiz_i             */
 215   }
 216   len = cio_tell() - lenp;
 217   cio_seek(lenp);
 218   cio_write(len, 2);            /* Lsiz                */
 219   cio_seek(lenp + len);
 220
 221 }
 222
 223 void j2k_read_siz()
 224 {
 225   int len, i;
 226
 227   len = cio_read(2);            /* Lsiz                */
 228   cio_read(2);                  /* Rsiz (capabilities) */
 229   j2k_img->x1 = cio_read(4);    /* Xsiz                */
 230   j2k_img->y1 = cio_read(4);    /* Ysiz                */
 231   j2k_img->x0 = cio_read(4);    /* X0siz               */
 232   j2k_img->y0 = cio_read(4);    /* Y0siz               */
 233   j2k_cp->tdx = cio_read(4);    /* XTsiz               */
 234   j2k_cp->tdy = cio_read(4);    /* YTsiz               */
 235   j2k_cp->tx0 = cio_read(4);    /* XT0siz              */
 236   j2k_cp->ty0 = cio_read(4);    /* YT0siz              */
 237
 238   j2k_img->numcomps = cio_read(2);      /* Csiz                */
 239   j2k_img->comps =
 240     (j2k_comp_t *) malloc(j2k_img->numcomps * sizeof(j2k_comp_t));
 241   for (i = 0; i < j2k_img->numcomps; i++) {
 242     int tmp, w, h;
 243     tmp = cio_read(1);          /* Ssiz_i          */
 244     j2k_img->comps[i].prec = (tmp & 0x7f) + 1;
 245     j2k_img->comps[i].sgnd = tmp >> 7;
 246     j2k_img->comps[i].dx = cio_read(1); /* XRsiz_i         */
 247     j2k_img->comps[i].dy = cio_read(1); /* YRsiz_i         */
 248     w = int_ceildiv(j2k_img->x1 - j2k_img->x0, j2k_img->comps[i].dx);
 249     h = int_ceildiv(j2k_img->y1 - j2k_img->y0, j2k_img->comps[i].dy);
 250     j2k_img->comps[i].resno_decoded = 0;        /* number of resolution decoded */
 251     j2k_img->comps[i].factor = 0;       /* reducing factor by component */
 252   }
 253
 254   j2k_cp->tw = int_ceildiv(j2k_img->x1 - j2k_cp->tx0, j2k_cp->tdx);
 255   j2k_cp->th = int_ceildiv(j2k_img->y1 - j2k_cp->ty0, j2k_cp->tdy);
 256   j2k_cp->tcps =
 257     (j2k_tcp_t *) calloc(j2k_cp->tw * j2k_cp->th, sizeof(j2k_tcp_t));
 258   j2k_cp->tileno = (int *) calloc(j2k_cp->tw * j2k_cp->th, sizeof(int));
 259   j2k_cp->tileno_size = 0;
 260
 261   for (i = 0; i < j2k_cp->tw * j2k_cp->th; i++) {
 262     j2k_cp->tcps[i].POC = 0;
 263     j2k_cp->tcps[i].numpocs = 0;
 264     j2k_cp->tcps[i].first = 1;
 265   }
 266
 267   /* Initialization for PPM marker */
 268   j2k_cp->ppm = 0;
 269   j2k_cp->ppm_data = NULL;
 270   j2k_cp->ppm_previous = 0;
 271   j2k_cp->ppm_store = 0;
 272
 273   j2k_default_tcp.tccps =
 274     (j2k_tccp_t *) calloc(sizeof(j2k_tccp_t), j2k_img->numcomps);
 275   for (i = 0; i < j2k_cp->tw * j2k_cp->th; i++) {
 276     j2k_cp->tcps[i].tccps =
 277       (j2k_tccp_t *) calloc(sizeof(j2k_tccp_t), j2k_img->numcomps);
 278   }
 279   j2k_tile_data =
 280     (unsigned char **) calloc(j2k_cp->tw * j2k_cp->th, sizeof(char *));
 281   j2k_tile_len = (int *) calloc(j2k_cp->tw * j2k_cp->th, sizeof(int));
 282   j2k_state = J2K_STATE_MH;
 283
 284
 285 }
 286
 287 void j2k_write_com()
 288 {
 289   unsigned int i;
 290   int lenp, len;
 291   char str[256];
 292   sprintf(str, "%s", j2k_cp->comment);
 293
 294   cio_write(J2K_MS_COM, 2);
 295   lenp = cio_tell();
 296   cio_skip(2);
 297   cio_write(0, 2);
 298   for (i = 0; i < strlen(str); i++) {
 299     cio_write(str[i], 1);
 300   }
 301   len = cio_tell() - lenp;
 302   cio_seek(lenp);
 303   cio_write(len, 2);
 304   cio_seek(lenp + len);
 305
 306 }
 307
 308 void j2k_read_com()
 309 {
 310   int len;
 311
 312   len = cio_read(2);
 313   cio_skip(len - 2);
 314
 315 }
 316
 317 void j2k_write_cox(int compno)
 318 {
 319   int i;
 320   j2k_tcp_t *tcp;
 321   j2k_tccp_t *tccp;
 322   tcp = &j2k_cp->tcps[j2k_curtileno];
 323   tccp = &tcp->tccps[compno];
 324
 325   cio_write(tccp->numresolutions - 1, 1);       /* SPcox (D) */
 326   cio_write(tccp->cblkw - 2, 1);        /* SPcox (E) */
 327   cio_write(tccp->cblkh - 2, 1);        /* SPcox (F) */
 328   cio_write(tccp->cblksty, 1);  /* SPcox (G) */
 329   cio_write(tccp->qmfbid, 1);   /* SPcox (H) */
 330
 331   if (tccp->csty & J2K_CCP_CSTY_PRT) {
 332     for (i = 0; i < tccp->numresolutions; i++) {
 333       cio_write(tccp->prcw[i] + (tccp->prch[i] << 4), 1);       /* SPcox (I_i) */
 334     }
 335   }
 336 }
 337
 338 void j2k_read_cox(int compno)
 339 {
 340   int i;
 341   j2k_tcp_t *tcp;
 342   j2k_tccp_t *tccp;
 343   tcp =
 344     j2k_state ==
 345     J2K_STATE_TPH ? &j2k_cp->tcps[j2k_curtileno] : &j2k_default_tcp;
 346   tccp = &tcp->tccps[compno];
 347   tccp->numresolutions = cio_read(1) + 1;       /* SPcox (D) */
 348   tccp->cblkw = cio_read(1) + 2;        /* SPcox (E) */
 349   tccp->cblkh = cio_read(1) + 2;        /* SPcox (F) */
 350   tccp->cblksty = cio_read(1);  /* SPcox (G) */
 351   tccp->qmfbid = cio_read(1);   /* SPcox (H) */
 352   if (tccp->csty & J2K_CP_CSTY_PRT) {
 353     for (i = 0; i < tccp->numresolutions; i++) {
 354       int tmp = cio_read(1);    /* SPcox (I_i) */
 355       tccp->prcw[i] = tmp & 0xf;
 356       tccp->prch[i] = tmp >> 4;
 357     }
 358   }
 359 }
 360
 361 void j2k_write_cod()
 362 {
 363   j2k_tcp_t *tcp;
 364   int lenp, len;
 365
 366   cio_write(J2K_MS_COD, 2);     /* COD */
 367
 368   lenp = cio_tell();
 369   cio_skip(2);
 370
 371   tcp = &j2k_cp->tcps[j2k_curtileno];
 372   cio_write(tcp->csty, 1);      /* Scod */
 373   cio_write(tcp->prg, 1);       /* SGcod (A) */
 374   cio_write(tcp->numlayers, 2); /* SGcod (B) */
 375   cio_write(tcp->mct, 1);       /* SGcod (C) */
 376
 377   j2k_write_cox(0);
 378   len = cio_tell() - lenp;
 379   cio_seek(lenp);
 380   cio_write(len, 2);            /* Lcod */
 381   cio_seek(lenp + len);
 382 }
 383
 384 void j2k_read_cod()
 385 {
 386   int len, i, pos;
 387   j2k_tcp_t *tcp;
 388
 389   tcp =
 390     j2k_state ==
 391     J2K_STATE_TPH ? &j2k_cp->tcps[j2k_curtileno] : &j2k_default_tcp;
 392   len = cio_read(2);            /* Lcod */
 393   tcp->csty = cio_read(1);      /* Scod */
 394   tcp->prg = cio_read(1);       /* SGcod (A) */
 395   tcp->numlayers = cio_read(2); /* SGcod (B) */
 396   tcp->mct = cio_read(1);       /* SGcod (C) */
 397
 398   pos = cio_tell();
 399   for (i = 0; i < j2k_img->numcomps; i++) {
 400     tcp->tccps[i].csty = tcp->csty & J2K_CP_CSTY_PRT;
 401     cio_seek(pos);
 402     j2k_read_cox(i);
 403   }
 404 }
 405
 406 void j2k_write_coc(int compno)
 407 {
 408   j2k_tcp_t *tcp;
 409   int lenp, len;
 410
 411   cio_write(J2K_MS_COC, 2);     /* COC */
 412   lenp = cio_tell();
 413   cio_skip(2);
 414   tcp = &j2k_cp->tcps[j2k_curtileno];
 415   cio_write(compno, j2k_img->numcomps <= 256 ? 1 : 2);  /* Ccoc */
 416   cio_write(tcp->tccps[compno].csty, 1);        /* Scoc */
 417   j2k_write_cox(compno);
 418   len = cio_tell() - lenp;
 419   cio_seek(lenp);
 420   cio_write(len, 2);            /* Lcoc */
 421   cio_seek(lenp + len);
 422 }
 423
 424 void j2k_read_coc()
 425 {
 426   int len, compno;
 427   j2k_tcp_t *tcp;
 428
 429   tcp =
 430     j2k_state ==
 431     J2K_STATE_TPH ? &j2k_cp->tcps[j2k_curtileno] : &j2k_default_tcp;
 432   len = cio_read(2);            /* Lcoc */
 433   compno = cio_read(j2k_img->numcomps <= 256 ? 1 : 2);  /* Ccoc */
 434   tcp->tccps[compno].csty = cio_read(1);        /* Scoc */
 435   j2k_read_cox(compno);
 436 }
 437
 438 void j2k_write_qcx(int compno)
 439 {
 440   j2k_tcp_t *tcp;
 441   j2k_tccp_t *tccp;
 442   int bandno, numbands;
 443   int expn, mant;
 444
 445   tcp = &j2k_cp->tcps[j2k_curtileno];
 446   tccp = &tcp->tccps[compno];
 447
 448   cio_write(tccp->qntsty + (tccp->numgbits << 5), 1);   /* Sqcx */
 449   numbands =
 450     tccp->qntsty ==
 451     J2K_CCP_QNTSTY_SIQNT ? 1 : tccp->numresolutions * 3 - 2;
 452
 453   for (bandno = 0; bandno < numbands; bandno++) {
 454     expn = tccp->stepsizes[bandno].expn;
 455     mant = tccp->stepsizes[bandno].mant;
 456
 457     if (tccp->qntsty == J2K_CCP_QNTSTY_NOQNT) {
 458       cio_write(expn << 3, 1);  /* SPqcx_i */
 459     } else {
 460       cio_write((expn << 11) + mant, 2);        /* SPqcx_i */
 461     }
 462   }
 463
 464 }
 465
 466 void j2k_read_qcx(int compno, int len)
 467 {
 468   int tmp;
 469   j2k_tcp_t *tcp;
 470   j2k_tccp_t *tccp;
 471   int bandno, numbands;
 472
 473   tcp =
 474     j2k_state ==
 475     J2K_STATE_TPH ? &j2k_cp->tcps[j2k_curtileno] : &j2k_default_tcp;
 476   tccp = &tcp->tccps[compno];
 477   tmp = cio_read(1);            /* Sqcx */
 478   tccp->qntsty = tmp & 0x1f;
 479   tccp->numgbits = tmp >> 5;
 480   numbands =
 481     tccp->qntsty == J2K_CCP_QNTSTY_SIQNT ? 1 : (tccp->qntsty ==
 482                                                 J2K_CCP_QNTSTY_NOQNT ?
 483                                                 len - 1 : (len - 1) / 2);
 484   for (bandno = 0; bandno < numbands; bandno++) {
 485     int expn, mant;
 486     if (tccp->qntsty == J2K_CCP_QNTSTY_NOQNT) {
 487       expn = cio_read(1) >> 3;  /* SPqcx_i */
 488       mant = 0;
 489     } else {
 490       tmp = cio_read(2);        /* SPqcx_i */
 491       expn = tmp >> 11;
 492       mant = tmp & 0x7ff;
 493     }
 494     tccp->stepsizes[bandno].expn = expn;
 495     tccp->stepsizes[bandno].mant = mant;
 496   }
 497
 498   /* Add Antonin : if scalar_derived -> compute other stepsizes */
 499
 500   if (tccp->qntsty==J2K_CCP_QNTSTY_SIQNT) {
 501     for (bandno=1 ; bandno<J2K_MAXBANDS ; bandno++) {
 502       tccp->stepsizes[bandno].expn = ((tccp->stepsizes[0].expn)-((bandno-1)/3)>0)?(tccp->stepsizes[0].expn)-((bandno-1)/3):0;
 503       tccp->stepsizes[bandno].mant = tccp->stepsizes[0].mant;
 504     }
 505   }
 506
 507   /* ddA */
 508 }
 509
 510 void j2k_write_qcd()
 511 {
 512   int lenp, len;
 513
 514   cio_write(J2K_MS_QCD, 2);     /* QCD */
 515   lenp = cio_tell();
 516   cio_skip(2);
 517   j2k_write_qcx(0);
 518   len = cio_tell() - lenp;
 519   cio_seek(lenp);
 520   cio_write(len, 2);            /* Lqcd */
 521   cio_seek(lenp + len);
 522 }
 523
 524 void j2k_read_qcd()
 525 {
 526   int len, i, pos;
 527
 528   len = cio_read(2);            /* Lqcd */
 529   pos = cio_tell();
 530   for (i = 0; i < j2k_img->numcomps; i++) {
 531     cio_seek(pos);
 532     j2k_read_qcx(i, len - 2);
 533   }
 534 }
 535
 536 void j2k_write_qcc(int compno)
 537 {
 538   int lenp, len;
 539
 540   cio_write(J2K_MS_QCC, 2);     /* QCC */
 541   lenp = cio_tell();
 542   cio_skip(2);
 543   cio_write(compno, j2k_img->numcomps <= 256 ? 1 : 2);  /* Cqcc */
 544   j2k_write_qcx(compno);
 545   len = cio_tell() - lenp;
 546   cio_seek(lenp);
 547   cio_write(len, 2);            /* Lqcc */
 548   cio_seek(lenp + len);
 549 }
 550
 551 void j2k_read_qcc()
 552 {
 553   int len, compno;
 554
 555   len = cio_read(2);            /* Lqcc */
 556   compno = cio_read(j2k_img->numcomps <= 256 ? 1 : 2);  /* Cqcc */
 557   j2k_read_qcx(compno, len - 2 - (j2k_img->numcomps <= 256 ? 1 : 2));
 558 }
 559
 560 void j2k_write_poc()
 561 {
 562   int len, numpchgs, i;
 563   j2k_tcp_t *tcp;
 564   j2k_tccp_t *tccp;
 565
 566   tcp = &j2k_cp->tcps[j2k_curtileno];
 567   tccp = &tcp->tccps[0];
 568   numpchgs = tcp->numpocs;
 569   cio_write(J2K_MS_POC, 2);     /* POC  */
 570   len = 2 + (5 + 2 * (j2k_img->numcomps <= 256 ? 1 : 2)) * numpchgs;
 571   cio_write(len, 2);            /* Lpoc */
 572   for (i = 0; i < numpchgs; i++) {
 573     // MODIF
 574     j2k_poc_t *poc;
 575     poc = &tcp->pocs[i];
 576     cio_write(poc->resno0, 1);  /* RSpoc_i */
 577     cio_write(poc->compno0, (j2k_img->numcomps <= 256 ? 1 : 2));        /* CSpoc_i */
 578     cio_write(poc->layno1, 2);  /* LYEpoc_i */
 579     poc->layno1 = int_min(poc->layno1, tcp->numlayers);
 580     cio_write(poc->resno1, 1);  /* REpoc_i */
 581     poc->resno1 = int_min(poc->resno1, tccp->numresolutions);
 582     cio_write(poc->compno1, (j2k_img->numcomps <= 256 ? 1 : 2));        /* CEpoc_i */
 583     poc->compno1 = int_min(poc->compno1, j2k_img->numcomps);
 584     cio_write(poc->prg, 1);     /* Ppoc_i */
 585   }
 586 }
 587
 588 void j2k_read_poc()
 589 {
 590   int len, numpchgs, i, old_poc;
 591   j2k_tcp_t *tcp;
 592   j2k_tccp_t *tccp;
 593
 594   tcp =
 595     j2k_state ==
 596     J2K_STATE_TPH ? &j2k_cp->tcps[j2k_curtileno] : &j2k_default_tcp;
 597
 598   old_poc = tcp->POC ? tcp->numpocs + 1 : 0;
 599   tcp->POC = 1;
 600   tccp = &tcp->tccps[0];
 601   len = cio_read(2);            /* Lpoc */
 602   numpchgs = (len - 2) / (5 + 2 * (j2k_img->numcomps <= 256 ? 1 : 2));
 603
 604   for (i = old_poc; i < numpchgs + old_poc; i++) {
 605     j2k_poc_t *poc;
 606     poc = &tcp->pocs[i];
 607     poc->resno0 = cio_read(1);  /* RSpoc_i */
 608     poc->compno0 = cio_read(j2k_img->numcomps <= 256 ? 1 : 2);  /* CSpoc_i */
 609     poc->layno1 = int_min(cio_read(2), tcp->numlayers); /* LYEpoc_i */
 610     poc->resno1 = int_min(cio_read(1), tccp->numresolutions);   /* REpoc_i */
 611     poc->compno1 = int_min(cio_read(j2k_img->numcomps <= 256 ? 1 : 2), j2k_img->numcomps);      /* CEpoc_i */
 612     poc->prg = cio_read(1);     /* Ppoc_i */
 613   }
 614
 615   tcp->numpocs = numpchgs + old_poc - 1;
 616 }
 617
 618 void j2k_read_crg()
 619 {
 620   int len, i, Xcrg_i, Ycrg_i;
 621
 622   len = cio_read(2);            /* Lcrg */
 623   for (i = 0; i < j2k_img->numcomps; i++) {
 624     Xcrg_i = cio_read(2);       /* Xcrg_i */
 625     Ycrg_i = cio_read(2);       /* Ycrg_i */
 626   }
 627 }
 628
 629 void j2k_read_tlm()
 630 {
 631   int len, Ztlm, Stlm, ST, SP, tile_tlm, i;
 632   long int Ttlm_i, Ptlm_i;
 633
 634   len = cio_read(2);            /* Ltlm */
 635   Ztlm = cio_read(1);           /* Ztlm */
 636   Stlm = cio_read(1);           /* Stlm */
 637   ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02);
 638   SP = (Stlm >> 6) & 0x01;
 639   tile_tlm = (len - 4) / ((SP + 1) * 2 + ST);
 640   for (i = 0; i < tile_tlm; i++) {
 641     Ttlm_i = cio_read(ST);      /* Ttlm_i */
 642     Ptlm_i = cio_read(SP ? 4 : 2);      /* Ptlm_i */
 643   }
 644 }
 645
 646 void j2k_read_plm()
 647 {
 648   int len, i, Zplm, Nplm, add, packet_len = 0;
 649
 650   len = cio_read(2);            /* Lplm */
 651   Zplm = cio_read(1);           /* Zplm */
 652   len -= 3;
 653   while (len > 0) {
 654     Nplm = cio_read(4);         /* Nplm */
 655     len -= 4;
 656     for (i = Nplm; i > 0; i--) {
 657       add = cio_read(1);
 658       len--;
 659       packet_len = (packet_len << 7) + add;     /* Iplm_ij */
 660       if ((add & 0x80) == 0) {
 661         /* New packet */
 662         packet_len = 0;
 663       }
 664       if (len <= 0)
 665         break;
 666     }
 667   }
 668 }
 669
 670 void j2k_read_plt()
 671 {
 672   int len, i, Zplt, packet_len = 0, add;
 673
 674   len = cio_read(2);            /* Lplt */
 675   Zplt = cio_read(1);           /* Zplt */
 676   for (i = len - 3; i > 0; i--) {
 677     add = cio_read(1);
 678     packet_len = (packet_len << 7) + add;       /* Iplt_i */
 679     if ((add & 0x80) == 0) {
 680       /* New packet */
 681       packet_len = 0;
 682     }
 683   }
 684 }
 685
 686 void j2k_read_ppm()
 687 {
 688   int len, Z_ppm, i, j;
 689   int N_ppm;
 690
 691   len = cio_read(2);
 692   j2k_cp->ppm = 1;
 693
 694   Z_ppm = cio_read(1);          /* Z_ppm */
 695   len -= 3;
 696   while (len > 0) {
 697     if (j2k_cp->ppm_previous == 0) {
 698       N_ppm = cio_read(4);      /* N_ppm */
 699       len -= 4;
 700     } else {
 701       N_ppm = j2k_cp->ppm_previous;
 702     }
 703
 704     j = j2k_cp->ppm_store;
 705     if (Z_ppm == 0)             /* First PPM marker */
 706       j2k_cp->ppm_data =
 707         (unsigned char *) calloc(N_ppm, sizeof(unsigned char));
 708     else                        /* NON-first PPM marker */
 709       j2k_cp->ppm_data =
 710         (unsigned char *) realloc(j2k_cp->ppm_data,
 711                                   (N_ppm +
 712                                    j2k_cp->ppm_store) *
 713                                   sizeof(unsigned char));
 714
 715     for (i = N_ppm; i > 0; i--) {       /* Read packet header */
 716       j2k_cp->ppm_data[j] = cio_read(1);
 717       j++;
 718       len--;
 719       if (len == 0)
 720         break;                  /* Case of non-finished packet header in present marker but finished in next one */
 721     }
 722
 723     j2k_cp->ppm_previous = i - 1;
 724     j2k_cp->ppm_store = j;
 725   }
 726 }
 727
 728 void j2k_read_ppt()
 729 {
 730   int len, Z_ppt, i, j = 0;
 731   j2k_tcp_t *tcp;
 732
 733   len = cio_read(2);
 734   Z_ppt = cio_read(1);
 735   tcp = &j2k_cp->tcps[j2k_curtileno];
 736   tcp->ppt = 1;
 737   if (Z_ppt == 0) {             /* First PPT marker */
 738     tcp->ppt_data =
 739       (unsigned char *) calloc(len - 3, sizeof(unsigned char));
 740     tcp->ppt_store = 0;
 741   } else                        /* NON-first PPT marker */
 742     tcp->ppt_data =
 743       (unsigned char *) realloc(tcp->ppt_data,
 744                                 (len - 3 +
 745                                  tcp->ppt_store) * sizeof(unsigned char));
 746
 747   j = tcp->ppt_store;
 748   for (i = len - 3; i > 0; i--) {
 749     tcp->ppt_data[j] = cio_read(1);
 750     j++;
 751   }
 752   tcp->ppt_store = j;
 753 }
 754
 755 void j2k_write_sot()
 756 {
 757   int lenp, len;
 758
 759   j2k_sot_start = cio_tell();
 760   cio_write(J2K_MS_SOT, 2);     /* SOT */
 761   lenp = cio_tell();
 762   cio_skip(2);                  /* Lsot (further) */
 763   cio_write(j2k_curtileno, 2);  /* Isot */
 764   cio_skip(4);                  /* Psot (further in j2k_write_sod) */
 765   cio_write(0, 1);              /* TPsot */
 766   cio_write(1, 1);              /* TNsot */
 767   len = cio_tell() - lenp;
 768   cio_seek(lenp);
 769   cio_write(len, 2);            /* Lsot */
 770   cio_seek(lenp + len);
 771 }
 772
 773 void j2k_read_sot()
 774 {
 775   int len, tileno, totlen, partno, numparts, i;
 776   j2k_tcp_t *tcp;
 777   j2k_tccp_t *tmp;
 778   char status = 0;
 779
 780   len = cio_read(2);
 781   tileno = cio_read(2);
 782
 783   if (j2k_cp->tileno_size == 0) {
 784     j2k_cp->tileno[j2k_cp->tileno_size] = tileno;
 785     j2k_cp->tileno_size++;
 786   } else {
 787     i = 0;
 788     while (i < j2k_cp->tileno_size && status == 0) {
 789       status = j2k_cp->tileno[i] == tileno ? 1 : 0;
 790       i++;
 791     }
 792     if (status == 0) {
 793       j2k_cp->tileno[j2k_cp->tileno_size] = tileno;
 794       j2k_cp->tileno_size++;
 795     }
 796   }
 797
 798   totlen = cio_read(4);
 799   if (!totlen)
 800     totlen = cio_numbytesleft() + 8;
 801
 802   partno = cio_read(1);
 803   numparts = cio_read(1);
 804
 805   j2k_curtileno = tileno;
 806   j2k_eot = cio_getbp() - 12 + totlen;
 807   j2k_state = J2K_STATE_TPH;
 808   tcp = &j2k_cp->tcps[j2k_curtileno];
 809
 810   if (tcp->first == 1) {
 811     tmp = tcp->tccps;
 812     *tcp = j2k_default_tcp;
 813
 814     /* Initialization PPT */
 815     tcp->ppt = 0;
 816     tcp->ppt_data = NULL;
 817
 818     tcp->tccps = tmp;
 819     for (i = 0; i < j2k_img->numcomps; i++) {
 820       tcp->tccps[i] = j2k_default_tcp.tccps[i];
 821     }
 822     j2k_cp->tcps[j2k_curtileno].first = 0;
 823   }
 824 }
 825
 826 void j2k_write_sod()
 827 {
 828   int l, layno;
 829   int totlen;
 830   j2k_tcp_t *tcp;
 831   static int j2k_sod_start;
 832
 833   cio_write(J2K_MS_SOD, 2);
 834   if (j2k_curtileno == 0) {
 835     j2k_sod_start = cio_tell() + pos_correction;
 836   }
 837
 838   /* INDEX >> */
 839   if (info_IM.index_on) {
 840     info_IM.tile[j2k_curtileno].end_header =
 841       cio_tell() + pos_correction - 1;
 842     info_IM.tile[j2k_curtileno].packet =
 843       (info_packet *) calloc(info_IM.Comp * info_IM.Layer *
 844                              (info_IM.Decomposition + 1) * 100,
 845                              sizeof(info_packet));
 846   }
 847   /* << INDEX */
 848
 849   tcp = &j2k_cp->tcps[j2k_curtileno];
 850   for (layno = 0; layno < tcp->numlayers; layno++) {
 851     tcp->rates[layno] -= (j2k_sod_start / (j2k_cp->th * j2k_cp->tw));
 852   }
 853
 854   info_IM.num = 0;
 855   if (j2k_cp->image_type)
 856     l = tcd_encode_tile_pxm(j2k_curtileno, cio_getbp(),
 857                             cio_numbytesleft() - 2, &info_IM);
 858   else
 859     l = tcd_encode_tile_pgx(j2k_curtileno, cio_getbp(),
 860                             cio_numbytesleft() - 2, &info_IM);
 861
 862   /* Writing Psot in SOT marker */
 863   totlen = cio_tell() + l - j2k_sot_start;
 864   cio_seek(j2k_sot_start + 6);
 865   cio_write(totlen, 4);
 866   cio_seek(j2k_sot_start + totlen);
 867 }
 868
 869 void j2k_read_sod()
 870 {
 871   int len, truncate = 0, i;
 872   unsigned char *data;
 873
 874   len = int_min(j2k_eot - cio_getbp(), cio_numbytesleft() + 1);
 875   if (len == cio_numbytesleft() + 1)
 876     truncate = 1;               /* Case of a truncate codestream */
 877
 878   data =
 879     (unsigned char *) malloc((j2k_tile_len[j2k_curtileno] + len) *
 880                              sizeof(unsigned char));
 881   for (i = 0; i < j2k_tile_len[j2k_curtileno]; i++)
 882     data[i] = j2k_tile_data[j2k_curtileno][i];
 883   for (i = 0; i < len; i++)
 884     data[i + j2k_tile_len[j2k_curtileno]] = cio_read(1);
 885
 886   j2k_tile_len[j2k_curtileno] += len;
 887   free(j2k_tile_data[j2k_curtileno]);
 888   j2k_tile_data[j2k_curtileno] = data;
 889   data = NULL;
 890
 891   if (!truncate)
 892     j2k_state = J2K_STATE_TPHSOT;
 893   else
 894     j2k_state = J2K_STATE_NEOC; /* RAJOUTE !! */
 895 }
 896
 897 void j2k_write_rgn(int compno, int tileno)
 898 {
 899   j2k_tcp_t *tcp = &j2k_cp->tcps[tileno];
 900
 901   cio_write(J2K_MS_RGN, 2);     /* RGN  */
 902   cio_write(j2k_img->numcomps <= 256 ? 5 : 6, 2);       /* Lrgn */
 903   cio_write(compno, j2k_img->numcomps <= 256 ? 1 : 2);  /* Crgn */
 904   cio_write(0, 1);              /* Srgn */
 905   cio_write(tcp->tccps[compno].roishift, 1);    /* SPrgn */
 906 }
 907
 908 void j2k_read_rgn()
 909 {
 910   int len, compno, roisty;
 911   j2k_tcp_t *tcp;
 912
 913   tcp =
 914     j2k_state ==
 915     J2K_STATE_TPH ? &j2k_cp->tcps[j2k_curtileno] : &j2k_default_tcp;
 916   len = cio_read(2);            /* Lrgn */
 917   compno = cio_read(j2k_img->numcomps <= 256 ? 1 : 2);  /* Crgn */
 918   roisty = cio_read(1);         /* Srgn */
 919   tcp->tccps[compno].roishift = cio_read(1);    /* SPrgn */
 920 }
 921
 922 void j2k_write_eoc()
 923 {
 924   /* fprintf(stderr, "%.8x: EOC\n", cio_tell() + pos_correction); */
 925   cio_write(J2K_MS_EOC, 2);
 926 }
 927
 928 void j2k_read_eoc()
 929 {
 930   int i, tileno;
 931
 932   tcd_init(j2k_img, j2k_cp);
 933
 934   for (i = 0; i < j2k_cp->tileno_size; i++) {
 935     tileno = j2k_cp->tileno[i];
 936     tcd_decode_tile(j2k_tile_data[tileno], j2k_tile_len[tileno], tileno);
 937   }
 938
 939   j2k_state = J2K_STATE_MT;
 940   longjmp(j2k_error, 1);
 941 }
 942
 943 void j2k_read_unk()
 944 {
 945   fprintf(stderr, "warning: unknown marker\n");
 946 }
 947
 948 LIBJ2K_API int j2k_encode(j2k_image_t * img, j2k_cp_t * cp, char *output,
 949                           int len, char *index)
 950 {
 951   int tileno, compno, layno, resno, precno, pack_nb;
 952   char *dest;
 953   FILE *INDEX;
 954   FILE *f;
 955
 956   if (setjmp(j2k_error)) {
 957     return 0;
 958   }
 959
 960   if (cp->intermed_file==1) {
 961     f = fopen(output, "wb");
 962     if (!f) {
 963       fprintf(stderr, "failed to open %s for writing\n", output);
 964       return 1;
 965     }
 966     dest = (char *) malloc(len);
 967     cio_init(dest, len);
 968   }
 969
 970   j2k_img = img;
 971   j2k_cp = cp;
 972   /* j2k_dump_cp(j2k_img, j2k_cp); */
 973
 974   /* INDEX >> */
 975   info_IM.index_on = j2k_img->index_on;
 976   if (info_IM.index_on) {
 977     info_IM.tile =
 978       (info_tile *) malloc(j2k_cp->tw * j2k_cp->th * sizeof(info_tile));
 979     info_IM.Im_w = j2k_img->x1 - j2k_img->x0;
 980     info_IM.Im_h = j2k_img->y1 - j2k_img->y0;
 981     info_IM.Prog = (&j2k_cp->tcps[0])->prg;
 982     info_IM.tw=j2k_cp->tw;
 983     info_IM.th=j2k_cp->th;
 984     info_IM.Tile_x = j2k_cp->tdx;       /* new version parser */
 985     info_IM.Tile_y = j2k_cp->tdy;       /* new version parser */
 986     info_IM.Comp = j2k_img->numcomps;
 987     info_IM.Layer = (&j2k_cp->tcps[0])->numlayers;
 988     info_IM.Decomposition = (&j2k_cp->tcps[0])->tccps->numresolutions - 1;
 989     info_IM.D_max = 0;          /* ADD Marcela */
 990   }
 991   /* << INDEX */
 992
 993   j2k_write_soc();
 994   j2k_write_siz();
 995   j2k_write_cod();
 996   j2k_write_qcd();
 997   for (compno = 0; compno < j2k_img->numcomps; compno++) {
 998     j2k_tcp_t *tcp = &j2k_cp->tcps[0];
 999     if (tcp->tccps[compno].roishift)
1000       j2k_write_rgn(compno, 0);
1001   }
1002   if (j2k_cp->comment != NULL)
1003     j2k_write_com();
1004
1005   if (cp->intermed_file==1) {
1006     /* Writing the main header */
1007     pos_correction = cio_tell();
1008     fwrite(dest, 1, cio_tell(), f);
1009   }
1010
1011   /* INDEX >> */
1012   if (info_IM.index_on) {
1013     info_IM.Main_head_end = cio_tell() - 1;
1014   }
1015   /* << INDEX */
1016
1017
1018   for (tileno = 0; tileno < cp->tw * cp->th; tileno++) {
1019     fprintf(stderr, "\nTile number %d / %d \n", tileno + 1,
1020       cp->tw * cp->th);
1021
1022     if (cp->intermed_file==1) {
1023       /* new dest for each tile  */
1024       free(dest);
1025       dest = (char *) malloc(len);
1026       cio_init(dest, len);
1027     }
1028     j2k_curtileno = tileno;
1029     /* initialisation before tile encoding  */
1030
1031     if (tileno == 0) {
1032       tcd_malloc_encode(j2k_img, j2k_cp, j2k_curtileno);
1033     } else {
1034       tcd_init_encode(j2k_img, j2k_cp, j2k_curtileno);
1035     }
1036
1037     /* INDEX >> */
1038     if (info_IM.index_on) {
1039       info_IM.tile[j2k_curtileno].num_tile = j2k_curtileno;
1040       info_IM.tile[j2k_curtileno].start_pos = cio_tell() + pos_correction;
1041     }
1042     /* << INDEX */
1043     j2k_write_sot();
1044
1045     for (compno = 1; compno < img->numcomps; compno++) {
1046       j2k_write_coc(compno);
1047       j2k_write_qcc(compno);
1048     }
1049
1050     if (cp->tcps[tileno].numpocs)
1051       j2k_write_poc();
1052     j2k_write_sod();
1053
1054     /* INDEX >> */
1055     if (info_IM.index_on) {
1056       info_IM.tile[j2k_curtileno].end_pos =
1057         cio_tell() + pos_correction - 1;
1058     }
1059     /* << INDEX */
1060
1061     /*
1062        if (tile->PPT)  BAD PPT !!!
1063        {
1064        FILE *PPT_file;
1065
1066        int i;
1067        PPT_file=fopen("PPT","rb");
1068        fprintf(stderr,"%c%c%c%c",255,97,tile->len_ppt/256,tile->len_ppt%256);
1069        for (i=0;i<tile->len_ppt;i++)
1070        {
1071        unsigned char elmt;
1072        fread(&elmt, 1, 1, PPT_file);
1073        fwrite(&elmt,1,1,f);
1074        }
1075        fclose(PPT_file);
1076        unlink("PPT");
1077        }
1078      */
1079     if (cp->intermed_file==1) {
1080       fwrite(dest, 1, cio_tell(), f);
1081       pos_correction = cio_tell() + pos_correction;
1082     }
1083   }
1084
1085   if (cp->intermed_file==1) {
1086     free(dest);
1087     dest = (char *) malloc(len);
1088     cio_init(dest, len);
1089   }
1090
1091   j2k_write_eoc();
1092
1093   if (cp->intermed_file==1) {
1094     fwrite(dest, 1, 2, f);
1095     free(dest);
1096     /* closing file *.j2k */
1097     fclose(f);
1098   }
1099
1100   /* Creation of the index file     */
1101
1102   if (info_IM.index_on) {
1103
1104     double DistoTotal = 0;
1105
1106     info_IM.codestream_size = cio_tell() + pos_correction;      /* Correction 14/4/03 suite rmq de Patrick */
1107
1108     INDEX = fopen(index, "w");
1109
1110
1111
1112     if (!INDEX) {
1113
1114       fprintf(stderr, "failed to open %s for writing\n", index);
1115
1116       return 1;
1117
1118     }
1119
1120
1121
1122     fprintf(INDEX, "%d %d\n", info_IM.Im_w, info_IM.Im_h);
1123
1124     fprintf(INDEX, "%d\n", info_IM.Prog);
1125
1126     fprintf(INDEX, "%d %d\n", info_IM.Tile_x, info_IM.Tile_y);
1127
1128     fprintf(INDEX, "%d %d\n", info_IM.tw, info_IM.th);
1129
1130     fprintf(INDEX, "%d\n", info_IM.Comp);
1131
1132     fprintf(INDEX, "%d\n", info_IM.Layer);
1133
1134     fprintf(INDEX, "%d\n", info_IM.Decomposition);
1135
1136     for (resno=info_IM.Decomposition;resno>=0;resno--) {
1137
1138       fprintf(INDEX, "[%d,%d] ", (1<<info_IM.tile[0].pdx[resno]), (1<<info_IM.tile[0].pdx[resno])); //based on tile 0
1139
1140     }
1141
1142     fprintf(INDEX,"\n");
1143
1144     fprintf(INDEX, "%d\n", info_IM.Main_head_end);
1145
1146     fprintf(INDEX, "%d\n", info_IM.codestream_size);
1147
1148     for (tileno = 0; tileno < info_IM.tw * info_IM.th; tileno++) {
1149
1150       fprintf(INDEX, "%4d %9d %9d %9d %9e %9d %9e\n",
1151
1152               info_IM.tile[tileno].num_tile,
1153
1154               info_IM.tile[tileno].start_pos,
1155
1156               info_IM.tile[tileno].end_header,
1157
1158               info_IM.tile[tileno].end_pos, info_IM.tile[tileno].distotile, info_IM.tile[tileno].nbpix,
1159
1160               info_IM.tile[tileno].distotile / info_IM.tile[tileno].nbpix);
1161
1162     }
1163
1164     for (tileno = 0; tileno < info_IM.tw * info_IM.th; tileno++) {
1165
1166       int start_pos, end_pos;
1167
1168       double disto = 0;
1169
1170       pack_nb = 0;
1171
1172       /* fprintf(INDEX,
1173
1174               "pkno tileno layerno resno compno precno start_pos   end_pos       deltaSE        \n");*/
1175
1176       if (info_IM.Prog == 0) {  /* LRCP */
1177
1178         for (layno = 0; layno < info_IM.Layer; layno++) {
1179
1180           for (resno = 0; resno < info_IM.Decomposition + 1; resno++) {
1181
1182             for (compno = 0; compno < info_IM.Comp; compno++) {
1183
1184               for (precno = 0;
1185
1186                    precno <
1187
1188                    info_IM.tile[tileno].pw[resno] * info_IM.tile[tileno].ph[resno];
1189
1190                    precno++) {
1191
1192                 start_pos = info_IM.tile[tileno].packet[pack_nb].start_pos;
1193
1194                 end_pos = info_IM.tile[tileno].packet[pack_nb].end_pos;
1195
1196                 disto = info_IM.tile[tileno].packet[pack_nb].disto;
1197
1198                 fprintf(INDEX, "%4d %6d %7d %5d %6d %6d %9d %9d %8e\n",
1199
1200                         pack_nb, tileno, layno, resno, compno, precno,
1201
1202                         start_pos, end_pos, disto);
1203
1204                 DistoTotal += disto;
1205
1206                 pack_nb++;
1207
1208               }
1209
1210             }
1211
1212           }
1213
1214         }
1215
1216       } else if (info_IM.Prog == 1) {   /* RLCP */
1217
1218         for (resno = 0; resno < info_IM.Decomposition + 1; resno++) {
1219
1220           for (layno = 0; layno < info_IM.Layer; layno++) {
1221
1222             for (compno = 0; compno < info_IM.Comp; compno++) {
1223
1224               for (precno = 0; precno < info_IM.tile[tileno].pw[resno] * info_IM.tile[tileno].ph[resno]; precno++) {
1225
1226                 start_pos = info_IM.tile[tileno].packet[pack_nb].start_pos;
1227
1228                 end_pos = info_IM.tile[tileno].packet[pack_nb].end_pos;
1229
1230                 disto = info_IM.tile[tileno].packet[pack_nb].disto;
1231
1232                 fprintf(INDEX, "%4d %6d %7d %5d %6d %6d %9d %9d %8e\n",
1233
1234                         pack_nb, tileno, layno, resno, compno, precno,
1235
1236                         start_pos, end_pos, disto);
1237
1238                 DistoTotal += disto;
1239
1240                 pack_nb++;
1241
1242               }
1243
1244             }
1245
1246           }
1247
1248         }
1249
1250       } else if (info_IM.Prog == 2) {   /* RPCL */
1251
1252         for (resno = 0; resno < info_IM.Decomposition + 1; resno++) {
1253
1254           for (precno = 0; precno < info_IM.tile[tileno].pw[resno] * info_IM.tile[tileno].ph[resno]; precno++) {
1255
1256             for (compno = 0; compno < info_IM.Comp; compno++) {
1257
1258               for (layno = 0; layno < info_IM.Layer; layno++) {
1259
1260                 start_pos = info_IM.tile[tileno].packet[pack_nb].start_pos;
1261
1262                 end_pos = info_IM.tile[tileno].packet[pack_nb].end_pos;
1263
1264                 disto = info_IM.tile[tileno].packet[pack_nb].disto;
1265
1266                 fprintf(INDEX, "%4d %6d %7d %5d %6d %6d %9d %9d %8e\n",
1267
1268                         pack_nb, tileno, layno, resno, compno, precno,
1269
1270                         start_pos, end_pos, disto);
1271
1272                 DistoTotal += disto;
1273
1274                 pack_nb++;
1275
1276               }
1277
1278             }
1279
1280           }
1281
1282         }
1283
1284       } else if (info_IM.Prog == 3) {   /* PCRL */
1285
1286         for (precno = 0; precno < info_IM.tile[tileno].pw[resno] * info_IM.tile[tileno].ph[resno]; precno++) {
1287
1288           for (compno = 0; compno < info_IM.Comp; compno++) {
1289
1290             for (resno = 0; resno < info_IM.Decomposition + 1; resno++) {
1291
1292               for (layno = 0; layno < info_IM.Layer; layno++) {
1293
1294                 start_pos = info_IM.tile[tileno].packet[pack_nb].start_pos;
1295
1296                 end_pos = info_IM.tile[tileno].packet[pack_nb].end_pos;
1297
1298                 disto = info_IM.tile[tileno].packet[pack_nb].disto;
1299
1300                 fprintf(INDEX, "%4d %6d %7d %5d %6d %6d %9d %9d %8e\n",
1301
1302                         pack_nb, tileno, layno, resno, compno, precno,
1303
1304                         start_pos, end_pos, disto);
1305
1306                 DistoTotal += disto;
1307
1308                 pack_nb++;
1309
1310               }
1311
1312             }
1313
1314           }
1315
1316         }
1317
1318       } else {                  /* CPRL */
1319
1320
1321
1322         for (compno = 0; compno < info_IM.Comp; compno++) {
1323
1324           for (precno = 0; precno < info_IM.tile[tileno].pw[resno] * info_IM.tile[tileno].ph[resno]; precno++) {
1325
1326             for (resno = 0; resno < info_IM.Decomposition + 1; resno++) {
1327
1328               for (layno = 0; layno < info_IM.Layer; layno++) {
1329
1330                 start_pos = info_IM.tile[tileno].packet[pack_nb].start_pos;
1331
1332                 end_pos = info_IM.tile[tileno].packet[pack_nb].end_pos;
1333
1334                 disto = info_IM.tile[tileno].packet[pack_nb].disto;
1335
1336                 fprintf(INDEX, "%4d %6d %7d %5d %6d %6d %9d %9d %8e\n",
1337
1338                         pack_nb, tileno, layno, resno, compno, precno,
1339
1340                         start_pos, end_pos, disto);
1341
1342                 DistoTotal += disto;
1343
1344                 pack_nb++;
1345
1346               }
1347
1348             }
1349
1350           }
1351
1352         }
1353
1354       }
1355
1356     }
1357
1358     fprintf(INDEX, "SE max : %8e\n", info_IM.D_max);
1359
1360     fprintf(INDEX, "SE total : %.8e\n", DistoTotal);
1361
1362     fclose(INDEX);
1363
1364   }
1365
1366   j2k_clean();
1367
1368   return cio_tell();
1369 }
1370
1371 typedef struct {
1372   int id;
1373   int states;
1374   void (*handler) ();
1375 } j2k_dec_mstabent_t;
1376
1377 j2k_dec_mstabent_t j2k_dec_mstab[] = {
1378   {J2K_MS_SOC, J2K_STATE_MHSOC, j2k_read_soc},
1379   {J2K_MS_SOT, J2K_STATE_MH | J2K_STATE_TPHSOT, j2k_read_sot},
1380   {J2K_MS_SOD, J2K_STATE_TPH, j2k_read_sod},
1381   {J2K_MS_EOC, J2K_STATE_TPHSOT, j2k_read_eoc},
1382   {J2K_MS_SIZ, J2K_STATE_MHSIZ, j2k_read_siz},
1383   {J2K_MS_COD, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_cod},
1384   {J2K_MS_COC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_coc},
1385   {J2K_MS_RGN, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_rgn},
1386   {J2K_MS_QCD, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_qcd},
1387   {J2K_MS_QCC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_qcc},
1388   {J2K_MS_POC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_poc},
1389   {J2K_MS_TLM, J2K_STATE_MH, j2k_read_tlm},
1390   {J2K_MS_PLM, J2K_STATE_MH, j2k_read_plm},
1391   {J2K_MS_PLT, J2K_STATE_TPH, j2k_read_plt},
1392   {J2K_MS_PPM, J2K_STATE_MH, j2k_read_ppm},
1393   {J2K_MS_PPT, J2K_STATE_TPH, j2k_read_ppt},
1394   {J2K_MS_SOP, 0, 0},
1395   {J2K_MS_CRG, J2K_STATE_MH, j2k_read_crg},
1396   {J2K_MS_COM, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_com},
1397   {0, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_unk}
1398 };
1399
1400 j2k_dec_mstabent_t *j2k_dec_mstab_lookup(int id)
1401 {
1402   j2k_dec_mstabent_t *e;
1403   for (e = j2k_dec_mstab; e->id != 0; e++) {
1404     if (e->id == id) {
1405       break;
1406     }
1407   }
1408   return e;
1409 }
1410
1411 LIBJ2K_API int j2k_decode(unsigned char *src, int len, j2k_image_t ** img,
1412                           j2k_cp_t ** cp, j2k_option_t option)
1413 {
1414
1415   if (setjmp(j2k_error)) {
1416     if (j2k_state != J2K_STATE_MT) {
1417       fprintf(stderr, "WARNING: incomplete bitstream\n");
1418       return 0;
1419     }
1420     return cio_numbytes();
1421   }
1422
1423   j2k_img = (j2k_image_t *) malloc(sizeof(j2k_image_t));
1424   j2k_cp = (j2k_cp_t *) malloc(sizeof(j2k_cp_t));
1425   *img = j2k_img;
1426   *cp = j2k_cp;
1427   /* Option */
1428   j2k_cp->reduce_on = option.reduce_on;
1429   j2k_cp->reduce_value = option.reduce_value;
1430
1431   j2k_state = J2K_STATE_MHSOC;
1432   cio_init(src, len);
1433
1434   for (;;) {
1435     j2k_dec_mstabent_t *e;
1436     int id = cio_read(2);
1437     if (id >> 8 != 0xff) {
1438       fprintf(stderr, "%.8x: expected a marker instead of %x\n",
1439               cio_tell() - 2, id);
1440       return 0;
1441     }
1442     e = j2k_dec_mstab_lookup(id);
1443     if (!(j2k_state & e->states)) {
1444       fprintf(stderr, "%.8x: unexpected marker %x\n", cio_tell() - 2, id);
1445       return 0;
1446     }
1447     if (e->handler) {
1448       (*e->handler) ();
1449     }
1450     if (j2k_state == J2K_STATE_NEOC)
1451       break;                    /* RAJOUTE */
1452   }
1453   if (j2k_state == J2K_STATE_NEOC)
1454     j2k_read_eoc();             /* RAJOUTE */
1455
1456   return 0;
1457 }
1458
1459 /*
1460  * Read a JPT-stream and decode file
1461  *
1462  */
1463 int j2k_decode_jpt_stream(unsigned char *src, int len, j2k_image_t ** img,
1464                           j2k_cp_t ** cp)
1465 {
1466   jpt_msg_header_struct_t header;
1467   int position;
1468
1469   if (setjmp(j2k_error)) {
1470     if (j2k_state != J2K_STATE_MT) {
1471       fprintf(stderr, "WARNING: incomplete bitstream\n");
1472       return 0;
1473     }
1474     return cio_numbytes();
1475   }
1476
1477   j2k_img = (j2k_image_t *) malloc(sizeof(j2k_image_t));
1478   j2k_cp = (j2k_cp_t *) malloc(sizeof(j2k_cp_t));
1479   *img = j2k_img;
1480   *cp = j2k_cp;
1481
1482   j2k_state = J2K_STATE_MHSOC;
1483   cio_init(src, len);
1484
1485   /* Initialize the header */
1486   jpt_init_Msg_Header(&header);
1487   /* Read the first header of the message */
1488   jpt_read_Msg_Header(&header);
1489
1490   position = cio_tell();
1491   if (header.Class_Id != 6) {   /* 6 : Main header data-bin message */
1492     fprintf(stderr,
1493             "[JPT-stream] : Expecting Main header first [class_Id %d] !\n",
1494             header.Class_Id);
1495     return 0;
1496   }
1497
1498   for (;;) {
1499     j2k_dec_mstabent_t *e;
1500     int id;
1501
1502     if (!cio_numbytesleft()) {
1503       j2k_read_eoc();
1504       return 0;
1505     }
1506     /* data-bin read -> need to read a new header */
1507     if ((unsigned int) (cio_tell() - position) == header.Msg_length) {
1508       jpt_read_Msg_Header(&header);
1509       position = cio_tell();
1510       if (header.Class_Id != 4) {       /* 4 : Tile data-bin message */
1511         fprintf(stderr, "[JPT-stream] : Expecting Tile info !\n");
1512         return 0;
1513       }
1514     }
1515
1516     id = cio_read(2);
1517     if (id >> 8 != 0xff) {
1518       fprintf(stderr, "%.8x: expected a marker instead of %x\n",
1519               cio_tell() - 2, id);
1520       return 0;
1521     }
1522     e = j2k_dec_mstab_lookup(id);
1523     if (!(j2k_state & e->states)) {
1524       fprintf(stderr, "%.8x: unexpected marker %x\n", cio_tell() - 2, id);
1525       return 0;
1526     }
1527     if (e->handler) {
1528       (*e->handler) ();
1529     }
1530     if (j2k_state == J2K_STATE_NEOC)
1531       break;                    /* RAJOUTE */
1532   }
1533   if (j2k_state == J2K_STATE_NEOC)
1534     j2k_read_eoc();             /* RAJOUTE */
1535
1536   return 0;
1537 }
1538
1539 #ifdef WIN32
1540 #include <windows.h>
1541
1542 BOOL APIENTRY DllMain(HANDLE hModule, DWORD ul_reason_for_call,
1543                       LPVOID lpReserved)
1544 {
1545   switch (ul_reason_for_call) {
1546   case DLL_PROCESS_ATTACH:
1547   case DLL_THREAD_ATTACH:
1548   case DLL_THREAD_DETACH:
1549   case DLL_PROCESS_DETACH:
1550     break;
1551   }
1552   return TRUE;
1553 }
1554 #endif