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       j2k_cp->ppm_len = N_ppm;        //Add antonin : ppmbug1
 709     } else {                    /* NON-first PPM marker */
 710       j2k_cp->ppm_data =
 711         (unsigned char *) realloc(j2k_cp->ppm_data,
 712                                   (N_ppm +
 713                                    j2k_cp->ppm_store) *
 714                                   sizeof(unsigned char));
 715       j2k_cp->ppm_len = N_ppm + j2k_cp->ppm_store; //Add antonin : ppmbug1
 716     }
 717
 718     for (i = N_ppm; i > 0; i--) {       /* Read packet header */
 719       j2k_cp->ppm_data[j] = cio_read(1);
 720       j++;
 721       len--;
 722       if (len == 0)
 723         break;                  /* Case of non-finished packet header in present marker but finished in next one */
 724     }
 725
 726     j2k_cp->ppm_previous = i - 1;
 727     j2k_cp->ppm_store = j;
 728   }
 729 }
 730
 731 void j2k_read_ppt()
 732 {
 733   int len, Z_ppt, i, j = 0;
 734   j2k_tcp_t *tcp;
 735
 736   len = cio_read(2);
 737   Z_ppt = cio_read(1);
 738   tcp = &j2k_cp->tcps[j2k_curtileno];
 739   tcp->ppt = 1;
 740   if (Z_ppt == 0) {             /* First PPT marker */
 741     tcp->ppt_data =
 742       (unsigned char *) calloc(len - 3, sizeof(unsigned char));
 743     tcp->ppt_store = 0;
 744     tcp->ppt_len = len-3;       //Add antonin : ppmbug1
 745   } else {                      /* NON-first PPT marker */
 746     tcp->ppt_data =
 747       (unsigned char *) realloc(tcp->ppt_data,
 748                                 (len - 3 +
 749                                  tcp->ppt_store) * sizeof(unsigned char));
 750     tcp->ppt_len=len - 3 + tcp->ppt_store;    //Add antonin : ppmbug1
 751   }
 752
 753   j = tcp->ppt_store;
 754   for (i = len - 3; i > 0; i--) {
 755     tcp->ppt_data[j] = cio_read(1);
 756     j++;
 757   }
 758   tcp->ppt_store = j;
 759 }
 760
 761 void j2k_write_sot()
 762 {
 763   int lenp, len;
 764
 765   j2k_sot_start = cio_tell();
 766   cio_write(J2K_MS_SOT, 2);     /* SOT */
 767   lenp = cio_tell();
 768   cio_skip(2);                  /* Lsot (further) */
 769   cio_write(j2k_curtileno, 2);  /* Isot */
 770   cio_skip(4);                  /* Psot (further in j2k_write_sod) */
 771   cio_write(0, 1);              /* TPsot */
 772   cio_write(1, 1);              /* TNsot */
 773   len = cio_tell() - lenp;
 774   cio_seek(lenp);
 775   cio_write(len, 2);            /* Lsot */
 776   cio_seek(lenp + len);
 777 }
 778
 779 void j2k_read_sot()
 780 {
 781   int len, tileno, totlen, partno, numparts, i;
 782   j2k_tcp_t *tcp;
 783   j2k_tccp_t *tmp;
 784   char status = 0;
 785
 786   len = cio_read(2);
 787   tileno = cio_read(2);
 788
 789   if (j2k_cp->tileno_size == 0) {
 790     j2k_cp->tileno[j2k_cp->tileno_size] = tileno;
 791     j2k_cp->tileno_size++;
 792   } else {
 793     i = 0;
 794     while (i < j2k_cp->tileno_size && status == 0) {
 795       status = j2k_cp->tileno[i] == tileno ? 1 : 0;
 796       i++;
 797     }
 798     if (status == 0) {
 799       j2k_cp->tileno[j2k_cp->tileno_size] = tileno;
 800       j2k_cp->tileno_size++;
 801     }
 802   }
 803
 804   totlen = cio_read(4);
 805   if (!totlen)
 806     totlen = cio_numbytesleft() + 8;
 807
 808   partno = cio_read(1);
 809   numparts = cio_read(1);
 810
 811   j2k_curtileno = tileno;
 812   j2k_eot = cio_getbp() - 12 + totlen;
 813   j2k_state = J2K_STATE_TPH;
 814   tcp = &j2k_cp->tcps[j2k_curtileno];
 815
 816   if (tcp->first == 1) {
 817     tmp = tcp->tccps;
 818     *tcp = j2k_default_tcp;
 819
 820     /* Initialization PPT */
 821     tcp->ppt = 0;
 822     tcp->ppt_data = NULL;
 823
 824     tcp->tccps = tmp;
 825     for (i = 0; i < j2k_img->numcomps; i++) {
 826       tcp->tccps[i] = j2k_default_tcp.tccps[i];
 827     }
 828     j2k_cp->tcps[j2k_curtileno].first = 0;
 829   }
 830 }
 831
 832 void j2k_write_sod()
 833 {
 834   int l, layno;
 835   int totlen;
 836   j2k_tcp_t *tcp;
 837   static int j2k_sod_start;
 838
 839   cio_write(J2K_MS_SOD, 2);
 840   if (j2k_curtileno == 0) {
 841     j2k_sod_start = cio_tell() + pos_correction;
 842   }
 843
 844   /* INDEX >> */
 845   if (info_IM.index_on) {
 846     info_IM.tile[j2k_curtileno].end_header =
 847       cio_tell() + pos_correction - 1;
 848     info_IM.tile[j2k_curtileno].packet =
 849       (info_packet *) calloc(info_IM.Comp * info_IM.Layer *
 850                              (info_IM.Decomposition + 1) * 100,
 851                              sizeof(info_packet));
 852   }
 853   /* << INDEX */
 854
 855   tcp = &j2k_cp->tcps[j2k_curtileno];
 856   for (layno = 0; layno < tcp->numlayers; layno++) {
 857     tcp->rates[layno] -= (j2k_sod_start / (j2k_cp->th * j2k_cp->tw));
 858   }
 859
 860   info_IM.num = 0;
 861   if (j2k_cp->image_type)
 862     l = tcd_encode_tile_pxm(j2k_curtileno, cio_getbp(),
 863                             cio_numbytesleft() - 2, &info_IM);
 864   else
 865     l = tcd_encode_tile_pgx(j2k_curtileno, cio_getbp(),
 866                             cio_numbytesleft() - 2, &info_IM);
 867
 868   /* Writing Psot in SOT marker */
 869   totlen = cio_tell() + l - j2k_sot_start;
 870   cio_seek(j2k_sot_start + 6);
 871   cio_write(totlen, 4);
 872   cio_seek(j2k_sot_start + totlen);
 873 }
 874
 875 void j2k_read_sod()
 876 {
 877   int len, truncate = 0, i;
 878   unsigned char *data;
 879
 880   len = int_min(j2k_eot - cio_getbp(), cio_numbytesleft() + 1);
 881   if (len == cio_numbytesleft() + 1)
 882     truncate = 1;               /* Case of a truncate codestream */
 883
 884   data =
 885     (unsigned char *) malloc((j2k_tile_len[j2k_curtileno] + len) *
 886                              sizeof(unsigned char));
 887   for (i = 0; i < j2k_tile_len[j2k_curtileno]; i++)
 888     data[i] = j2k_tile_data[j2k_curtileno][i];
 889   for (i = 0; i < len; i++)
 890     data[i + j2k_tile_len[j2k_curtileno]] = cio_read(1);
 891
 892   j2k_tile_len[j2k_curtileno] += len;
 893   free(j2k_tile_data[j2k_curtileno]);
 894   j2k_tile_data[j2k_curtileno] = data;
 895   data = NULL;
 896
 897   if (!truncate)
 898     j2k_state = J2K_STATE_TPHSOT;
 899   else
 900     j2k_state = J2K_STATE_NEOC; /* RAJOUTE !! */
 901 }
 902
 903 void j2k_write_rgn(int compno, int tileno)
 904 {
 905   j2k_tcp_t *tcp = &j2k_cp->tcps[tileno];
 906
 907   cio_write(J2K_MS_RGN, 2);     /* RGN  */
 908   cio_write(j2k_img->numcomps <= 256 ? 5 : 6, 2);       /* Lrgn */
 909   cio_write(compno, j2k_img->numcomps <= 256 ? 1 : 2);  /* Crgn */
 910   cio_write(0, 1);              /* Srgn */
 911   cio_write(tcp->tccps[compno].roishift, 1);    /* SPrgn */
 912 }
 913
 914 void j2k_read_rgn()
 915 {
 916   int len, compno, roisty;
 917   j2k_tcp_t *tcp;
 918
 919   tcp =
 920     j2k_state ==
 921     J2K_STATE_TPH ? &j2k_cp->tcps[j2k_curtileno] : &j2k_default_tcp;
 922   len = cio_read(2);            /* Lrgn */
 923   compno = cio_read(j2k_img->numcomps <= 256 ? 1 : 2);  /* Crgn */
 924   roisty = cio_read(1);         /* Srgn */
 925   tcp->tccps[compno].roishift = cio_read(1);    /* SPrgn */
 926 }
 927
 928 void j2k_write_eoc()
 929 {
 930   /* fprintf(stderr, "%.8x: EOC\n", cio_tell() + pos_correction); */
 931   cio_write(J2K_MS_EOC, 2);
 932 }
 933
 934 void j2k_read_eoc()
 935 {
 936   int i, tileno;
 937
 938   tcd_init(j2k_img, j2k_cp);
 939
 940   for (i = 0; i < j2k_cp->tileno_size; i++) {
 941     tileno = j2k_cp->tileno[i];
 942     tcd_decode_tile(j2k_tile_data[tileno], j2k_tile_len[tileno], tileno);
 943   }
 944
 945   j2k_state = J2K_STATE_MT;
 946   longjmp(j2k_error, 1);
 947 }
 948
 949 void j2k_read_unk()
 950 {
 951   fprintf(stderr, "warning: unknown marker\n");
 952 }
 953
 954 LIBJ2K_API int j2k_encode(j2k_image_t * img, j2k_cp_t * cp, char *output,
 955                           int len, char *index)
 956 {
 957   int tileno, compno, layno, resno, precno, pack_nb;
 958   char *dest;
 959   FILE *INDEX;
 960   FILE *f;
 961
 962   if (setjmp(j2k_error)) {
 963     return 0;
 964   }
 965
 966   if (cp->intermed_file==1) {
 967     f = fopen(output, "wb");
 968     if (!f) {
 969       fprintf(stderr, "failed to open %s for writing\n", output);
 970       return 1;
 971     }
 972     dest = (char *) malloc(len);
 973     cio_init(dest, len);
 974   }
 975
 976   j2k_img = img;
 977   j2k_cp = cp;
 978   /* j2k_dump_cp(j2k_img, j2k_cp); */
 979
 980   /* INDEX >> */
 981   info_IM.index_on = j2k_cp->index_on;
 982   if (info_IM.index_on) {
 983     info_IM.tile =
 984       (info_tile *) malloc(j2k_cp->tw * j2k_cp->th * sizeof(info_tile));
 985     info_IM.Im_w = j2k_img->x1 - j2k_img->x0;
 986     info_IM.Im_h = j2k_img->y1 - j2k_img->y0;
 987     info_IM.Prog = (&j2k_cp->tcps[0])->prg;
 988     info_IM.tw=j2k_cp->tw;
 989     info_IM.th=j2k_cp->th;
 990     info_IM.Tile_x = j2k_cp->tdx;       /* new version parser */
 991     info_IM.Tile_y = j2k_cp->tdy;       /* new version parser */
 992     info_IM.Comp = j2k_img->numcomps;
 993     info_IM.Layer = (&j2k_cp->tcps[0])->numlayers;
 994     info_IM.Decomposition = (&j2k_cp->tcps[0])->tccps->numresolutions - 1;
 995     info_IM.D_max = 0;          /* ADD Marcela */
 996   }
 997   /* << INDEX */
 998
 999   j2k_write_soc();
1000   j2k_write_siz();
1001   j2k_write_cod();
1002   j2k_write_qcd();
1003   for (compno = 0; compno < j2k_img->numcomps; compno++) {
1004     j2k_tcp_t *tcp = &j2k_cp->tcps[0];
1005     if (tcp->tccps[compno].roishift)
1006       j2k_write_rgn(compno, 0);
1007   }
1008   if (j2k_cp->comment != NULL)
1009     j2k_write_com();
1010
1011   if (cp->intermed_file==1) {
1012     /* Writing the main header */
1013     pos_correction = cio_tell();
1014     fwrite(dest, 1, cio_tell(), f);
1015   }
1016
1017   /* INDEX >> */
1018   if (info_IM.index_on) {
1019     info_IM.Main_head_end = cio_tell() - 1;
1020   }
1021   /* << INDEX */
1022
1023
1024   for (tileno = 0; tileno < cp->tw * cp->th; tileno++) {
1025     fprintf(stderr, "\nTile number %d / %d \n", tileno + 1,
1026       cp->tw * cp->th);
1027
1028     if (cp->intermed_file==1) {
1029       /* new dest for each tile  */
1030       free(dest);
1031       dest = (char *) malloc(len);
1032       cio_init(dest, len);
1033     }
1034     j2k_curtileno = tileno;
1035     /* initialisation before tile encoding  */
1036
1037     if (tileno == 0) {
1038       tcd_malloc_encode(j2k_img, j2k_cp, j2k_curtileno);
1039     } else {
1040       tcd_init_encode(j2k_img, j2k_cp, j2k_curtileno);
1041     }
1042
1043     /* INDEX >> */
1044     if (info_IM.index_on) {
1045       info_IM.tile[j2k_curtileno].num_tile = j2k_curtileno;
1046       info_IM.tile[j2k_curtileno].start_pos = cio_tell() + pos_correction;
1047     }
1048     /* << INDEX */
1049     j2k_write_sot();
1050
1051     for (compno = 1; compno < img->numcomps; compno++) {
1052       j2k_write_coc(compno);
1053       j2k_write_qcc(compno);
1054     }
1055
1056     if (cp->tcps[tileno].numpocs)
1057       j2k_write_poc();
1058     j2k_write_sod();
1059
1060     /* INDEX >> */
1061     if (info_IM.index_on) {
1062       info_IM.tile[j2k_curtileno].end_pos =
1063         cio_tell() + pos_correction - 1;
1064     }
1065     /* << INDEX */
1066
1067     /*
1068        if (tile->PPT)  BAD PPT !!!
1069        {
1070        FILE *PPT_file;
1071
1072        int i;
1073        PPT_file=fopen("PPT","rb");
1074        fprintf(stderr,"%c%c%c%c",255,97,tile->len_ppt/256,tile->len_ppt%256);
1075        for (i=0;i<tile->len_ppt;i++)
1076        {
1077        unsigned char elmt;
1078        fread(&elmt, 1, 1, PPT_file);
1079        fwrite(&elmt,1,1,f);
1080        }
1081        fclose(PPT_file);
1082        unlink("PPT");
1083        }
1084      */
1085     if (cp->intermed_file==1) {
1086       fwrite(dest, 1, cio_tell(), f);
1087       pos_correction = cio_tell() + pos_correction;
1088     }
1089   }
1090
1091   if (cp->intermed_file==1) {
1092     free(dest);
1093     dest = (char *) malloc(len);
1094     cio_init(dest, len);
1095   }
1096
1097   j2k_write_eoc();
1098
1099   if (cp->intermed_file==1) {
1100     fwrite(dest, 1, 2, f);
1101     free(dest);
1102     /* closing file *.j2k */
1103     fclose(f);
1104   }
1105
1106   /* Creation of the index file     */
1107
1108   if (info_IM.index_on) {
1109
1110     double DistoTotal = 0;
1111
1112     info_IM.codestream_size = cio_tell() + pos_correction;      /* Correction 14/4/03 suite rmq de Patrick */
1113
1114     INDEX = fopen(index, "w");
1115
1116
1117
1118     if (!INDEX) {
1119
1120       fprintf(stderr, "failed to open %s for writing\n", index);
1121
1122       return 1;
1123
1124     }
1125
1126
1127
1128     fprintf(INDEX, "%d %d\n", info_IM.Im_w, info_IM.Im_h);
1129
1130     fprintf(INDEX, "%d\n", info_IM.Prog);
1131
1132     fprintf(INDEX, "%d %d\n", info_IM.Tile_x, info_IM.Tile_y);
1133
1134     fprintf(INDEX, "%d %d\n", info_IM.tw, info_IM.th);
1135
1136     fprintf(INDEX, "%d\n", info_IM.Comp);
1137
1138     fprintf(INDEX, "%d\n", info_IM.Layer);
1139
1140     fprintf(INDEX, "%d\n", info_IM.Decomposition);
1141
1142     for (resno=info_IM.Decomposition;resno>=0;resno--) {
1143
1144       fprintf(INDEX, "[%d,%d] ", (1<<info_IM.tile[0].pdx[resno]), (1<<info_IM.tile[0].pdx[resno])); //based on tile 0
1145
1146     }
1147
1148     fprintf(INDEX,"\n");
1149
1150     fprintf(INDEX, "%d\n", info_IM.Main_head_end);
1151
1152     fprintf(INDEX, "%d\n", info_IM.codestream_size);
1153
1154     for (tileno = 0; tileno < info_IM.tw * info_IM.th; tileno++) {
1155
1156       fprintf(INDEX, "%4d %9d %9d %9d %9e %9d %9e\n",
1157
1158               info_IM.tile[tileno].num_tile,
1159
1160               info_IM.tile[tileno].start_pos,
1161
1162               info_IM.tile[tileno].end_header,
1163
1164               info_IM.tile[tileno].end_pos, info_IM.tile[tileno].distotile, info_IM.tile[tileno].nbpix,
1165
1166               info_IM.tile[tileno].distotile / info_IM.tile[tileno].nbpix);
1167
1168     }
1169
1170     for (tileno = 0; tileno < info_IM.tw * info_IM.th; tileno++) {
1171
1172       int start_pos, end_pos;
1173
1174       double disto = 0;
1175
1176       pack_nb = 0;
1177
1178       /* fprintf(INDEX,
1179
1180               "pkno tileno layerno resno compno precno start_pos   end_pos       deltaSE        \n");*/
1181
1182       if (info_IM.Prog == 0) {  /* LRCP */
1183
1184         for (layno = 0; layno < info_IM.Layer; layno++) {
1185
1186           for (resno = 0; resno < info_IM.Decomposition + 1; resno++) {
1187
1188             for (compno = 0; compno < info_IM.Comp; compno++) {
1189
1190               for (precno = 0;
1191
1192                    precno <
1193
1194                    info_IM.tile[tileno].pw[resno] * info_IM.tile[tileno].ph[resno];
1195
1196                    precno++) {
1197
1198                 start_pos = info_IM.tile[tileno].packet[pack_nb].start_pos;
1199
1200                 end_pos = info_IM.tile[tileno].packet[pack_nb].end_pos;
1201
1202                 disto = info_IM.tile[tileno].packet[pack_nb].disto;
1203
1204                 fprintf(INDEX, "%4d %6d %7d %5d %6d %6d %9d %9d %8e\n",
1205
1206                         pack_nb, tileno, layno, resno, compno, precno,
1207
1208                         start_pos, end_pos, disto);
1209
1210                 DistoTotal += disto;
1211
1212                 pack_nb++;
1213
1214               }
1215
1216             }
1217
1218           }
1219
1220         }
1221
1222       } else if (info_IM.Prog == 1) {   /* RLCP */
1223
1224         for (resno = 0; resno < info_IM.Decomposition + 1; resno++) {
1225
1226           for (layno = 0; layno < info_IM.Layer; layno++) {
1227
1228             for (compno = 0; compno < info_IM.Comp; compno++) {
1229
1230               for (precno = 0; precno < info_IM.tile[tileno].pw[resno] * info_IM.tile[tileno].ph[resno]; precno++) {
1231
1232                 start_pos = info_IM.tile[tileno].packet[pack_nb].start_pos;
1233
1234                 end_pos = info_IM.tile[tileno].packet[pack_nb].end_pos;
1235
1236                 disto = info_IM.tile[tileno].packet[pack_nb].disto;
1237
1238                 fprintf(INDEX, "%4d %6d %7d %5d %6d %6d %9d %9d %8e\n",
1239
1240                         pack_nb, tileno, layno, resno, compno, precno,
1241
1242                         start_pos, end_pos, disto);
1243
1244                 DistoTotal += disto;
1245
1246                 pack_nb++;
1247
1248               }
1249
1250             }
1251
1252           }
1253
1254         }
1255
1256       } else if (info_IM.Prog == 2) {   /* RPCL */
1257
1258         for (resno = 0; resno < info_IM.Decomposition + 1; resno++) {
1259
1260           for (precno = 0; precno < info_IM.tile[tileno].pw[resno] * info_IM.tile[tileno].ph[resno]; precno++) {
1261
1262             for (compno = 0; compno < info_IM.Comp; compno++) {
1263
1264               for (layno = 0; layno < info_IM.Layer; layno++) {
1265
1266                 start_pos = info_IM.tile[tileno].packet[pack_nb].start_pos;
1267
1268                 end_pos = info_IM.tile[tileno].packet[pack_nb].end_pos;
1269
1270                 disto = info_IM.tile[tileno].packet[pack_nb].disto;
1271
1272                 fprintf(INDEX, "%4d %6d %7d %5d %6d %6d %9d %9d %8e\n",
1273
1274                         pack_nb, tileno, layno, resno, compno, precno,
1275
1276                         start_pos, end_pos, disto);
1277
1278                 DistoTotal += disto;
1279
1280                 pack_nb++;
1281
1282               }
1283
1284             }
1285
1286           }
1287
1288         }
1289
1290       } else if (info_IM.Prog == 3) {   /* PCRL */
1291
1292         for (precno = 0; precno < info_IM.tile[tileno].pw[resno] * info_IM.tile[tileno].ph[resno]; precno++) {
1293
1294           for (compno = 0; compno < info_IM.Comp; compno++) {
1295
1296             for (resno = 0; resno < info_IM.Decomposition + 1; resno++) {
1297
1298               for (layno = 0; layno < info_IM.Layer; layno++) {
1299
1300                 start_pos = info_IM.tile[tileno].packet[pack_nb].start_pos;
1301
1302                 end_pos = info_IM.tile[tileno].packet[pack_nb].end_pos;
1303
1304                 disto = info_IM.tile[tileno].packet[pack_nb].disto;
1305
1306                 fprintf(INDEX, "%4d %6d %7d %5d %6d %6d %9d %9d %8e\n",
1307
1308                         pack_nb, tileno, layno, resno, compno, precno,
1309
1310                         start_pos, end_pos, disto);
1311
1312                 DistoTotal += disto;
1313
1314                 pack_nb++;
1315
1316               }
1317
1318             }
1319
1320           }
1321
1322         }
1323
1324       } else {                  /* CPRL */
1325
1326
1327
1328         for (compno = 0; compno < info_IM.Comp; compno++) {
1329
1330           for (precno = 0; precno < info_IM.tile[tileno].pw[resno] * info_IM.tile[tileno].ph[resno]; precno++) {
1331
1332             for (resno = 0; resno < info_IM.Decomposition + 1; resno++) {
1333
1334               for (layno = 0; layno < info_IM.Layer; layno++) {
1335
1336                 start_pos = info_IM.tile[tileno].packet[pack_nb].start_pos;
1337
1338                 end_pos = info_IM.tile[tileno].packet[pack_nb].end_pos;
1339
1340                 disto = info_IM.tile[tileno].packet[pack_nb].disto;
1341
1342                 fprintf(INDEX, "%4d %6d %7d %5d %6d %6d %9d %9d %8e\n",
1343
1344                         pack_nb, tileno, layno, resno, compno, precno,
1345
1346                         start_pos, end_pos, disto);
1347
1348                 DistoTotal += disto;
1349
1350                 pack_nb++;
1351
1352               }
1353
1354             }
1355
1356           }
1357
1358         }
1359
1360       }
1361
1362     }
1363
1364     fprintf(INDEX, "SE max : %8e\n", info_IM.D_max);
1365
1366     fprintf(INDEX, "SE total : %.8e\n", DistoTotal);
1367
1368     fclose(INDEX);
1369
1370   }
1371
1372   j2k_clean();
1373
1374   return cio_tell();
1375 }
1376
1377 typedef struct {
1378   int id;
1379   int states;
1380   void (*handler) ();
1381 } j2k_dec_mstabent_t;
1382
1383 j2k_dec_mstabent_t j2k_dec_mstab[] = {
1384   {J2K_MS_SOC, J2K_STATE_MHSOC, j2k_read_soc},
1385   {J2K_MS_SOT, J2K_STATE_MH | J2K_STATE_TPHSOT, j2k_read_sot},
1386   {J2K_MS_SOD, J2K_STATE_TPH, j2k_read_sod},
1387   {J2K_MS_EOC, J2K_STATE_TPHSOT, j2k_read_eoc},
1388   {J2K_MS_SIZ, J2K_STATE_MHSIZ, j2k_read_siz},
1389   {J2K_MS_COD, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_cod},
1390   {J2K_MS_COC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_coc},
1391   {J2K_MS_RGN, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_rgn},
1392   {J2K_MS_QCD, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_qcd},
1393   {J2K_MS_QCC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_qcc},
1394   {J2K_MS_POC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_poc},
1395   {J2K_MS_TLM, J2K_STATE_MH, j2k_read_tlm},
1396   {J2K_MS_PLM, J2K_STATE_MH, j2k_read_plm},
1397   {J2K_MS_PLT, J2K_STATE_TPH, j2k_read_plt},
1398   {J2K_MS_PPM, J2K_STATE_MH, j2k_read_ppm},
1399   {J2K_MS_PPT, J2K_STATE_TPH, j2k_read_ppt},
1400   {J2K_MS_SOP, 0, 0},
1401   {J2K_MS_CRG, J2K_STATE_MH, j2k_read_crg},
1402   {J2K_MS_COM, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_com},
1403   {0, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_unk}
1404 };
1405
1406 j2k_dec_mstabent_t *j2k_dec_mstab_lookup(int id)
1407 {
1408   j2k_dec_mstabent_t *e;
1409   for (e = j2k_dec_mstab; e->id != 0; e++) {
1410     if (e->id == id) {
1411       break;
1412     }
1413   }
1414   return e;
1415 }
1416
1417
1418 LIBJ2K_API int j2k_decode(unsigned char *src, int len, j2k_image_t * img,
1419                           j2k_cp_t * cp)
1420 {
1421
1422   if (setjmp(j2k_error)) {
1423     if (j2k_state != J2K_STATE_MT) {
1424       fprintf(stderr, "WARNING: incomplete bitstream\n");
1425       return 0;
1426     }
1427     return cio_numbytes();
1428   }
1429
1430   j2k_img = img;
1431   j2k_cp = cp;
1432
1433   j2k_state = J2K_STATE_MHSOC;
1434   cio_init(src, len);
1435
1436   for (;;) {
1437     j2k_dec_mstabent_t *e;
1438     int id = cio_read(2);
1439     if (id >> 8 != 0xff) {
1440       fprintf(stderr, "%.8x: expected a marker instead of %x\n",
1441               cio_tell() - 2, id);
1442       return 0;
1443     }
1444     e = j2k_dec_mstab_lookup(id);
1445     if (!(j2k_state & e->states)) {
1446       fprintf(stderr, "%.8x: unexpected marker %x\n", cio_tell() - 2, id);
1447       return 0;
1448     }
1449     if (e->handler) {
1450       (*e->handler) ();
1451     }
1452     if (j2k_state == J2K_STATE_NEOC)
1453       break;                    /* RAJOUTE */
1454   }
1455   if (j2k_state == J2K_STATE_NEOC)
1456     j2k_read_eoc();             /* RAJOUTE */
1457
1458   return 0;
1459 }
1460
1461 /*
1462  * Read a JPT-stream and decode file
1463  *
1464  */
1465 int j2k_decode_jpt_stream(unsigned char *src, int len, j2k_image_t * img,
1466                           j2k_cp_t * cp)
1467 {
1468   jpt_msg_header_struct_t header;
1469   int position;
1470
1471   if (setjmp(j2k_error)) {
1472     if (j2k_state != J2K_STATE_MT) {
1473       fprintf(stderr, "WARNING: incomplete bitstream\n");
1474       return 0;
1475     }
1476     return cio_numbytes();
1477   }
1478
1479   j2k_img = img;
1480   j2k_cp = 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